API C souci de convertion string et char ?

**panthere noire** · 22/06/2012, 02h47

Bonjours .
Je reprend l'aPI systeme ecrit en C sous linux. getaddrinfo(), comme je récupère une structure sa deviens un casse tête pour éviter le

warning: deprecated conversion from string constant to ‘char*’

sans compter l'erreur qui suis.
j'ai bien tenter un cast mai rien a faire sa ne veux rien savoir... comme je peux pas modifier le code de l'API je fait comment ??

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
#ifndef DEF_ME_NET
#define DEF_ME_NET
#include <iostream>
#include <string>
 
 
#include <stdio.h>
#include <string.h>
 
#include <netdb.h>
#include <arpa/inet.h>
 
 
#include <stdlib.h>
//#define _POSIX_C_SOURCE 2 /* Nécessaire sur certains Linux. */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
typedef const std::string csr;
class cNet  {
 
	public:
	cNet(){};
	csr GetIpFromHostname(csr & Hostname);
	private:
	csr flags(int f);    		// Affichage du champ ai_flags.
	csr family(int af);  		// Affichage du champ ai_family.
	csr socktype(int sock); 	// Affichage du champ ai_socktype.
	csr protocol(int p); 		// Affichage du champ ai_protocol.
	csr GetIp(struct addrinfo * ai);
 
 
};
 
#endif

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
#include "cGetHostnameIP.hpp"
// csr =  typedef const std::string csr;
csr cNet::GetIpFromHostname(csr & Hostname){
        char *hostname = "www.google.com", *service = NULL;
        struct addrinfo indices, *res;
        int error;
        memset(&indices, 0, sizeof(indices));
        indices.ai_flags = AI_CANONNAME;
        indices.ai_family = AF_UNSPEC;      // Adresse IPv4 ou IPv6.
        indices.ai_socktype = SOCK_STREAM;  // Socket connectee.
        if ((error = getaddrinfo(hostname, service, &indices, &res))) {
                if (error == EAI_SYSTEM) perror("  [getaddrinfo]");
                fprintf(stderr, "  [getaddrinfo] %s : %s\n", hostname,
                        gai_strerror(error));
                return "Erreur";
        }
 
 
        return res;
//        freeaddrinfo(res);
 
 
 
}
csr cNet::GetIp(struct addrinfo * ai){
     //int i = 0;
        char *ptr = NULL;
        int port = 0;                // Numero de port.
        char addr[INET6_ADDRSTRLEN]; // Adresse reseau.
 
        while (ai != NULL) {  // Parcours de la liste chainée.
              //  printf("  [%d] ",i++);
              //  print_family(ai->ai_family);     printf("(%d) ", ai->ai_addrlen);
              //  print_socktype(ai->ai_socktype); printf(" ");
               // print_protocol(ai->ai_protocol); printf("\n");
                // Récupération du numéro de port et de l'adresse IP.
                switch (ai->ai_family) {
                case AF_INET:  {
                        struct sockaddr_in *sin =
                                (struct sockaddr_in *) ai->ai_addr;
                        ptr = (char *) inet_ntop(AF_INET, &sin->sin_addr,
                                                 addr, sizeof(addr));
                        port = sin->sin_port;
                        break;     }
                case AF_INET6: {
                        struct sockaddr_in6 *sin6 =
                                (struct sockaddr_in6 *) ai->ai_addr;
                        ptr = (char *) inet_ntop(AF_INET6, &sin6->sin6_addr,
                                                 addr, sizeof(addr));
                        port = sin6->sin6_port;
                        break;     }
                }
				std::cout << "IP : " << addr << "Port" << port << std::endl;
				return addr;
              //  if (ptr != NULL) printf("\t@IP -> %s\t port : %d\n",addr,port);
               /* if (ai->ai_canonname != NULL)
                        printf("\tNom -> %s\n", ai->ai_canonname);*/
              //  ai = ai->ai_next; // On passe à l'élément suivant.
        }
		return "Erreur inconnue ";
}
csr cNet::flags(int fl){
	switch (fl) {
	case AI_PASSIVE:     	return "Passive"		; break;
	case AI_CANONNAME:   	return "Name"			; break;
	case AI_NUMERICHOST: 	return "Numeric host"	; break;
	default: return"%d Inconnu " +fl				;
	}
}
csr cNet::family(int fam){
	switch (fam) {
	case AF_INET:  			return "Inet"			; break;
	case AF_INET6: 			return "Inet6"			; break;
	case AF_LOCAL: 			return "Local"			; break;
	default: return "Inconnu : " + fam 				;
	}
}
csr cNet::socktype(int sock){
	switch (sock) {
	case SOCK_STREAM: 		return "Sock stream"	; break;
	case SOCK_DGRAM:  		return "Sock dgram"		; break;
	default: return "Inconnu " + sock				;
	}
}
csr cNet::protocol(int proto){
	switch (proto) {
	case IPPROTO_IP:   		return "Protocole ip"	; break;
	case IPPROTO_TCP:  		return "Protocole tcp"	; break;
	case IPPROTO_UDP:  		return "Protocole udp"	; break;
	case IPPROTO_RAW:  		return "Protocole raw"	; break;
	case IPPROTO_ICMP: 		return "Protocole icmp"	; break;
	default: return "Inconnu " + proto				;
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
cGetHostnameIP.cpp: In member function ‘const csr cNet::GetIpFromHostname(const csr&)’:
cGetHostnameIP.cpp:4: warning: deprecated conversion from string constant to ‘char*’
cGetHostnameIP.cpp:19: error: conversion from ‘addrinfo*’ to non-scalar type ‘const csr’ requested

note: j'ai fait un typdef: // csr = typedef const std::string csr;

Merci d'avance

**Neckara** · 22/06/2012, 07h44

Il faut que tu définisse l'opérateur d'affectation entre un csr et un addrinfo*, sinon le compilateur ne sait pas ce qu'il va devoir faire lorsque tu veux mettre un addrinfo* dans un csr.

warning: deprecated conversion from string constant to ‘char*’

Tu as bien mis :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
csr from;
char * to;
to = from.c_str();

?

**ternel** · 22/06/2012, 14h34

En règle général, tout code contenant une instruction telle que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

char *hostname = "www.google.com";

est systématiquement faux.

Il arrivera forcément un moment où chaine sera transmise à strcat, sprintf ou que sais-je (ça a couté un mois de dev sur mon dernier projet...)

Il vaut mieux rajouter utiliser

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const char *hostname = "www.google.com";

Cela dit, ce warning précis vient de la traduction d'un std::string ou d'une chaine littérale ("truc") vers un char*.

**panthere noire** · 22/06/2012, 17h38

Envoyé par leternel

En règle général, tout code contenant une instruction telle que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

char *hostname = "www.google.com";

est systématiquement faux.

Il arrivera forcément un moment où chaine sera transmise à strcat, sprintf ou que sais-je (ça a couté un mois de dev sur mon dernier projet...)

Il vaut mieux rajouter utiliser

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const char *hostname = "www.google.com";

Cela dit, ce warning précis vient de la traduction d'un std::string ou d'une chaine littérale ("truc") vers un char*.

Cela a marcher pour le warning

Merci , je pense que cela devrai faire partie de la faq, ce genre de chose ?

Mai pour l'autre pas de changement ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

cGetHostnameIP.cpp:20: error: conversion from ‘addrinfo**’ to non-scalar type ‘std::string’ requested

c'est une structure d'après le man don voici l'extrait.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
int getaddrinfo(const char *node, const char *service,
                       const struct addrinfo *hints,
                       struct addrinfo **res);

j'essaye donc de comprendre ce que dit Neckara

Il faut que tu définisse l'opérateur d'affectation entre un csr et un addrinfo*, sinon le compilateur ne sait pas ce qu'il va devoir faire lorsque tu veux mettre un addrinfo* dans un csr.

concrètement je fait quoi quoi parce que je ne comprend pas ce que tu entend par : définisse l'opérateur d'affectation.
veux tu dire un cast ? si oui comment car j'en ai bien tenter quelque un mai je suppose tous sauf celui qui va bien

Merci de mavoir répondu et de m'avoir lu

**oodini** · 22/06/2012, 17h40

Apparemment, pour le dernier argument, il faut que tu crées une variable qui va recevoir la valeur de string.c_str(), puisque tu passes un pointeurs sur cette variable.

**Neckara** · 22/06/2012, 17h53

Envoyé par panthere noire

concrètement je fait quoi quoi parce que je ne comprend pas ce que tu entend par : définisse l'opérateur d'affectation.
veux tu dire un cast ? si oui comment car j'en ai bien tenter quelque un mai je suppose tous sauf celui qui va bien

Merci de mavoir répondu et de m'avoir lu

En fait il faut que tu fasse ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
const & std::string operator=(std::string &destination,  addrinfo** source)
{
         destination = (*source)->data1;
         destination += (*source)->data2;
         return destination;
}

Ainsi tu pourra convertir un addrinfo en std::string.

Mais il vaudrait mieux que tu fasse une classe csr qui hérite publiquement de std::string.
Ainsi tu pourras aussi définir un constructeur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
Csr::Csr( addrinfo** source)
{
 
}

**panthere noire** · 23/06/2012, 02h12

Hello
Neckara:
j'ai bien tenter une fonction libre et même membre pour :
*.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
         const & std::string operator=(std::string  &destination,  addrinfo** source);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
const & std::string operator=(std::string &destination,  addrinfo** source)
{
         destination = (*source)->data1;
         destination += (*source)->data2;
         return destination;
}

cGetHostnameIP.hpp:31: error: ISO C++ forbids declaration of ‘string’ with no type
cGetHostnameIP.hpp:31: error: invalid use of ‘::’
cGetHostnameIP.hpp:31: error: expected ‘;’ before ‘operator’

vus que c'est pour une fonction membre je ne sai pas ou placer mon cNet dans le *.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
const & std::string cNet::operator=(std::string &destination,  addrinfo** source)
{
         destination = (*source)->data1;
         destination += (*source)->data2;
         return destination;
}

j'ai regarder du coter de la faq
http://cpp.developpez.com/faq/cpp/?p...embre_ou_libre

il y est spécifier:

Il y a par contre des opérateurs que l'on n'a le droit de surcharger que comme fonction membre : operator=, operator(), operator[] et operator->.

Donc sa doit forcement être membre de la classe. j'ai aussi essayer d'adapter la syntaxe a la forme qui y est mentionnée. mai sa reste le même problème.

ou est ce que sa coince ?

Merci de m'avoir répondu et de votre patience

**Neckara** · 23/06/2012, 07h36

cGetHostnameIP.hpp:31: error: ISO C++ forbids declaration of ‘string’ with no type

Tu n'as pas oublier un #include <string> ?

Il y a par contre des opérateurs que l'on n'a le droit de surcharger que comme fonction membre : operator=, operator(), operator[] et operator->.

Je dois reconnaitre que je l'ignorais, je trouve très dommage que ce problème n'ai pas été abordés dans mon cours de surcharge d'opérateur ><.

Je ne comprend même pas l'intérêt de cette interdiction.

Le seule solution est donc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
class Csr : public std::string
{
       public :
                Csr(addrinfo** source); //on défini un constructeur
                const Csr & operator=(addrinfo** source);//on défini un opérateur d'affectation
 
}
 
Csr::Csr(addrinfo** source)
{
           //...
}
 
const Csr & Csr::operator=(addrinfo** source)
{
      //....
 
     return *this;
}

**panthere noire** · 23/06/2012, 10h52

Salut,

Je pense qu'il serai sage de remettre le code des 2 fichier.
sa devrai répondre a ta question et a ta réponse

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
#ifndef DEF_ME_NET
#define DEF_ME_NET
#include <iostream>
#include <string>
 
#include <stdio.h>
#include <string.h>
 
#include <netdb.h>
#include <arpa/inet.h>
 
 
#include <stdlib.h>
//#define _POSIX_C_SOURCE 2 /* Nécessaire sur certains Linux. */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
typedef const std::string csr;
class cNet  {
 
	public:
	cNet(){};
	std::string GetIpFromHostname(csr & Hostname);
	private:
	const std::string flags(int f);    		// Affichage du champ ai_flags.
	const std::string family(int af);  		// Affichage du champ ai_family.
	const std::string socktype(int sock); 	// Affichage du champ ai_socktype.
	const std::string protocol(int p); 		// Affichage du champ ai_protocol.
	const std::string GetIp(struct addrinfo * ai);
//	const & std::string operator=(std::string  &destination,  addrinfo** source);
 
};
 
 
class Csr : public std::string
{
       public :
                Csr(addrinfo** source); //on défini un constructeur
                const Csr & operator=(addrinfo** source);//on défini un opérateur d'affectation
 
}
 
#endif //fin des macro

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
#include "cGetHostnameIP.hpp"
std::string cNet::GetIpFromHostname(csr & Hostname){
        const char *hostname = "www.google.com", *service = NULL;
        struct addrinfo indices, *res;
        int error;
        memset(&indices, 0, sizeof(indices));
        indices.ai_flags = AI_CANONNAME;
        indices.ai_family = AF_UNSPEC;      // Adresse IPv4 ou IPv6.
        indices.ai_socktype = SOCK_STREAM;  // Socket connectee.
        if ((error = getaddrinfo(hostname, service, &indices, &res))) {
                if (error == EAI_SYSTEM) perror("  [getaddrinfo]");
                fprintf(stderr, "  [getaddrinfo] %s : %s\n", hostname,
                        gai_strerror(error));
                return "Erreur";
        }
 
return "";
	//       return res ;
	//       freeaddrinfo(res);
 
 
 
}
const std::string cNet::GetIp(struct addrinfo * ai){
     //int i = 0;
        char *ptr = NULL;
        int port = 0;                // Numero de port.
        char addr[INET6_ADDRSTRLEN]; // Adresse reseau.
 
        while (ai != NULL) {  // Parcours de la liste chainée.
              //  printf("  [%d] ",i++);
              //  print_family(ai->ai_family);     printf("(%d) ", ai->ai_addrlen);
              //  print_socktype(ai->ai_socktype); printf(" ");
               // print_protocol(ai->ai_protocol); printf("\n");
                // Récupération du numéro de port et de l'adresse IP.
                switch (ai->ai_family) {
                case AF_INET:  {
                        struct sockaddr_in *sin =
                                (struct sockaddr_in *) ai->ai_addr;
                        ptr = (char *) inet_ntop(AF_INET, &sin->sin_addr,
                                                 addr, sizeof(addr));
                        port = sin->sin_port;
                        break;     }
                case AF_INET6: {
                        struct sockaddr_in6 *sin6 =
                                (struct sockaddr_in6 *) ai->ai_addr;
                        ptr = (char *) inet_ntop(AF_INET6, &sin6->sin6_addr,
                                                 addr, sizeof(addr));
                        port = sin6->sin6_port;
                        break;     }
                }
				std::cout << "IP : " << addr << "Port" << port << std::endl;
				return addr;
              //  if (ptr != NULL) printf("\t@IP -> %s\t port : %d\n",addr,port);
               /* if (ai->ai_canonname != NULL)
                        printf("\tNom -> %s\n", ai->ai_canonname);*/
              //  ai = ai->ai_next; // On passe à l'élément suivant.
        }
		return "Erreur inconnue ";
}
const std::string cNet::flags(int fl){
	switch (fl) {
	case AI_PASSIVE:     	return "Passive"		; break;
	case AI_CANONNAME:   	return "Name"			; break;
	case AI_NUMERICHOST: 	return "Numeric host"	; break;
	default: return"%d Inconnu " +fl				;
	}
}
const std::string cNet::family(int fam){
	switch (fam) {
	case AF_INET:  			return "Inet"			; break;
	case AF_INET6: 			return "Inet6"			; break;
	case AF_LOCAL: 			return "Local"			; break;
	default: return "Inconnu : " + fam 				;
	}
}
const std::string cNet::socktype(int sock){
	switch (sock) {
	case SOCK_STREAM: 		return "Sock stream"	; break;
	case SOCK_DGRAM:  		return "Sock dgram"		; break;
	default: return "Inconnu " + sock				;
	}
}
const std::string cNet::protocol(int proto){
	switch (proto) {
	case IPPROTO_IP:   		return "Protocole ip"	; break;
	case IPPROTO_TCP:  		return "Protocole tcp"	; break;
	case IPPROTO_UDP:  		return "Protocole udp"	; break;
	case IPPROTO_RAW:  		return "Protocole raw"	; break;
	case IPPROTO_ICMP: 		return "Protocole icmp"	; break;
	default: return "Inconnu " + proto				;
	}
}
//*************************************************************
Csr::Csr(addrinfo** source)
{
           //...
}
 
const Csr & cCsr::operator=(addrinfo** source)
{
      //....
 
     return *this;
}

si je supprime le typedef const std::string csr; du *.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
cGetHostnameIP.cpp:2: error: expected initializer before ‘cNet’

sa ce déporte sur les autre fichier du projet ... j'ai donc tenter de supprimer les typedef const std::string csr des autre fichier

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
cAppli.hpp:58: error: multiple types in one declaration

je doit avouer que je comprend plus rien......

**Neckara** · 23/06/2012, 11h13

Peux-tu nous monter ton fichier cAppli.hpp et nous mettre en valeur la ligne 58 ?

**panthere noire** · 23/06/2012, 13h18

pas de souci
Pas de souci bien que cela n'apporte amha rien de mieux

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#ifndef DEF_ME_APPLI
#define DEF_ME_APPLI
#include <iostream>
#include "cMakeString.hpp"
#include "cFileReadWrite.hpp"
#include "cTableaux.hpp"
#include "cFiltreString.hpp"
#include "cGetHostnameIP.hpp"

class cAppliInput
{
	public:
	cAppliInput();

	void DropNoStandart			();//protocole
	void DropPkFrag			();// paquet fraguementer

	void Loopack				();
	void ListBlanche				(const std::string & PathListeBlanche);
	void ListNoire				(const std::string & PathListeNoire);
	void Dns					();
	void Dhcp					();
	void Irc					();
	void Browser				();
	void Mumble				();
	void CleanTableF			();
	void Ntp					();
	void LogFullLimit			();
	void Multicast				();
	void MailEntrant				();
	void MailSortant				();
	void SshOvh				();
	void Unreal				();
	void Whois					();
	void Ping					();
	void OilRush				();
	void DropAvahiDaemon		();
	void DropSynFlood			();

	void Drop_Icmp				();
	void Drop_Igmp				();
	void PoliceAccept			();
	void PoliceDrop				();
	void PrintAll				(const std::string & Interfaces);

	private:
	void IpBanInTcpUdp			(const std::string & Ip);
	cIncoming_MakeString		cMS;
	cMyFile					cMF;
	std::string MessageAutoLog;
	std::string MessageBanLog;



};// ======================<  cAppli.hpp:55: error: multiple types in one déclaration

class cAppliSytem
{
	public:
	cAppliSytem(){};
	void KernelProc				();
	void CleanKernelProc			();
	void PrintLog				();
	void ResetUlogd				();
	void Netstat				();

	private:
	cIncoming_MakeString		cMS;
	cMyFile					cMF;

};

class cAppliOutput
{
	public:
	cAppliOutput();
	void Loopack				();
	void ListBlanche				(const std::string & PathListeBlanche);
	void ListNoire				(const std::string & FileIpListNoire);
	void DropAvahiDaemon		();
	void Dns					(const std::string & Uid);
	void Browser				(const std::string & Uid);
	void Ntp					(const std::string & Uid);
	void Irc					(const std::string & Uid);
	void MailEntrant				(const std::string & Uid);
	void SshOvh				(const std::string & Uid);
	void Whois					(const std::string & Uid);
	void MailSortant				(const std::string & Uid);
	void Mumble				(const std::string & Uid);
	void Unreal				(const std::string & Uid);
	void DnsDrop				(const std::string & Uid);
	void AptForRoot				(const std::string & Uid);
	void PrintLog				();
	void LogUidSystem			();
	private:
	cIncoming_MakeString		cMS;
	cMyFile					cMF;
	std::string MessageAutoLog;
	std::string MessageBanLog;

};
#endif //fin des macro

désoler pour l'indentation sa deconne visiblement

**Neckara** · 23/06/2012, 13h28

j'ai trouvé l'erreur, juste un ';' d'oublié.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
class Csr : public std::string
{
       public :
                Csr(addrinfo** source); //on défini un constructeur
                const Csr & operator=(addrinfo** source);//on défini un opérateur d'affectation
 
} ;

**panthere noire** · 23/06/2012, 14h45

la bonne nouvelle : sa compile :

j'ai tout de même corriger aussi dans le cpp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
const Csr & cCsr::operator=(addrinfo** source)
{
      //....

     return *this;
}

Ensuite je cherche comment s'en servir,(et comment sa fonctionne etc) , car comme citer plus haut j'ai un peux perdu le fil

je declare la classe en priver, sous cette forme:

Csr ClasseCsr;

?
ou je fait autrement ?

**Neckara** · 23/06/2012, 15h20

Tu as juste à enlever ton typedef std::string csr et de remplacer chaque csr par Csr.

**panthere noire** · 23/06/2012, 15h59

retour a la case départ

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
#ifndef DEF_ME_NET
#define DEF_ME_NET
#include <iostream>
#include <string>
 
#include <stdio.h>
#include <string.h>
 
#include <netdb.h>
#include <arpa/inet.h>
 
 
#include <stdlib.h>
//#define _POSIX_C_SOURCE 2 /* Nécessaire sur certains Linux. */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
//typedef const std::string csr;
class Csr : public std::string
{
       public :
                Csr(addrinfo** source); //on défini un constructeur
                const Csr & operator=(addrinfo** source);//on défini un opérateur d'affectation
 
};
class cNet  {
 
	public:
	cNet(){};
	Csr GetIpFromHostname(Csr & Hostname);
	private:
	const std::string flags(int f);    		// Affichage du champ ai_flags.
	const std::string family(int af);  		// Affichage du champ ai_family.
	const std::string socktype(int sock); 	// Affichage du champ ai_socktype.
	const std::string protocol(int p); 		// Affichage du champ ai_protocol.
	const std::string GetIp(struct addrinfo * ai);
//	const & std::string operator=(std::string  &destination,  addrinfo** source);
 
};
 
#endif //fin des macro

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
#include "cGetHostnameIP.hpp"
Csr cNet::GetIpFromHostname(Csr & Hostname){
        const char *hostname = "www.google.com", *service = NULL;
        struct addrinfo indices, *res;
        int error;
        memset(&indices, 0, sizeof(indices));
        indices.ai_flags = AI_CANONNAME;
        indices.ai_family = AF_UNSPEC;      // Adresse IPv4 ou IPv6.
        indices.ai_socktype = SOCK_STREAM;  // Socket connectee.
        if ((error = getaddrinfo(hostname, service, &indices, &res))) {
                if (error == EAI_SYSTEM) perror("  [getaddrinfo]");
                fprintf(stderr, "  [getaddrinfo] %s : %s\n", hostname,
                        gai_strerror(error));
               // return "Erreur";
        }
 
//return "";
	       return res ;
	//       freeaddrinfo(res);
 
 
 
}
const std::string cNet::GetIp(struct addrinfo * ai){
     //int i = 0;
        char *ptr = NULL;
        int port = 0;                // Numero de port.
        char addr[INET6_ADDRSTRLEN]; // Adresse reseau.
 
        while (ai != NULL) {  // Parcours de la liste chainée.
              //  printf("  [%d] ",i++);
              //  print_family(ai->ai_family);     printf("(%d) ", ai->ai_addrlen);
              //  print_socktype(ai->ai_socktype); printf(" ");
               // print_protocol(ai->ai_protocol); printf("\n");
                // Récupération du numéro de port et de l'adresse IP.
                switch (ai->ai_family) {
                case AF_INET:  {
                        struct sockaddr_in *sin =
                                (struct sockaddr_in *) ai->ai_addr;
                        ptr = (char *) inet_ntop(AF_INET, &sin->sin_addr,
                                                 addr, sizeof(addr));
                        port = sin->sin_port;
                        break;     }
                case AF_INET6: {
                        struct sockaddr_in6 *sin6 =
                                (struct sockaddr_in6 *) ai->ai_addr;
                        ptr = (char *) inet_ntop(AF_INET6, &sin6->sin6_addr,
                                                 addr, sizeof(addr));
                        port = sin6->sin6_port;
                        break;     }
                }
				std::cout << "IP : " << addr << "Port" << port << std::endl;
				return addr;
              //  if (ptr != NULL) printf("\t@IP -> %s\t port : %d\n",addr,port);
               /* if (ai->ai_canonname != NULL)
                        printf("\tNom -> %s\n", ai->ai_canonname);*/
              //  ai = ai->ai_next; // On passe à l'élément suivant.
        }
		return "Erreur inconnue ";
}
const std::string cNet::flags(int fl){
	switch (fl) {
	case AI_PASSIVE:     	return "Passive"		; break;
	case AI_CANONNAME:   	return "Name"			; break;
	case AI_NUMERICHOST: 	return "Numeric host"	; break;
	default: return"%d Inconnu " +fl				;
	}
}
const std::string cNet::family(int fam){
	switch (fam) {
	case AF_INET:  			return "Inet"			; break;
	case AF_INET6: 			return "Inet6"			; break;
	case AF_LOCAL: 			return "Local"			; break;
	default: return "Inconnu : " + fam 				;
	}
}
const std::string cNet::socktype(int sock){
	switch (sock) {
	case SOCK_STREAM: 		return "Sock stream"	; break;
	case SOCK_DGRAM:  		return "Sock dgram"		; break;
	default: return "Inconnu " + sock				;
	}
}
const std::string cNet::protocol(int proto){
	switch (proto) {
	case IPPROTO_IP:   		return "Protocole ip"	; break;
	case IPPROTO_TCP:  		return "Protocole tcp"	; break;
	case IPPROTO_UDP:  		return "Protocole udp"	; break;
	case IPPROTO_RAW:  		return "Protocole raw"	; break;
	case IPPROTO_ICMP: 		return "Protocole icmp"	; break;
	default: return "Inconnu " + proto				;
	}
}
//*************************************************************
Csr::Csr(addrinfo** source)
{
           //...
}
 
const Csr & Csr::operator=(addrinfo** source)
{
      //....
 
     return *this;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
cGetHostnameIP.cpp: In member function ‘Csr cNet::GetIpFromHostname(Csr&)’:
cGetHostnameIP.cpp:18: error: conversion from ‘addrinfo*’ to non-scalar type ‘Csr’ requested

euh j'ai rater quelque chose ??

**Neckara** · 23/06/2012, 16h26

Soit tu fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return &res ;

Soit tu modifies ton constructeur et la surchage de l'opérateur = pour avoir en paramètre un addrinfo*.

**panthere noire** · 23/06/2012, 18h56

Merci pour ta réponse , c'est fois c est la bonne :p

j'ai quand meme du mettre la classe Csr avant l'autre sinon sa passait pas

voila le code qui tourne ou plutôt compile pour que cela puisse servir a d'autre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
#ifndef DEF_ME_NET
#define DEF_ME_NET
#include <iostream>
#include <string>
 
#include <stdio.h>
#include <string.h>
 
#include <netdb.h>
#include <arpa/inet.h>
 
 
#include <stdlib.h>
//#define _POSIX_C_SOURCE 2 /* Nécessaire sur certains Linux. */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
//typedef const std::string csr;
class Csr : public std::string
{
       public :
                Csr(addrinfo** source); //on défini un constructeur
                const Csr & operator=(addrinfo** source);//on défini un opérateur d'affectation
 
};
class cNet  {
 
	public:
	cNet(){};
	Csr GetIpFromHostname(Csr & Hostname);
	private:
	const std::string flags(int f);    		// Affichage du champ ai_flags.
	const std::string family(int af);  		// Affichage du champ ai_family.
	const std::string socktype(int sock); 	// Affichage du champ ai_socktype.
	const std::string protocol(int p); 		// Affichage du champ ai_protocol.
	const std::string GetIp(struct addrinfo * ai);
//	const & std::string operator=(std::string  &destination,  addrinfo** source);
 
};
 
 
#endif //fin des macro

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
#include "cGetHostnameIP.hpp"
Csr cNet::GetIpFromHostname(Csr & Hostname){
        const char *hostname = "www.google.com", *service = NULL;
        struct addrinfo indices, *res;
        int error;
        memset(&indices, 0, sizeof(indices));
        indices.ai_flags = AI_CANONNAME;
        indices.ai_family = AF_UNSPEC;      // Adresse IPv4 ou IPv6.
        indices.ai_socktype = SOCK_STREAM;  // Socket connectee.
        if ((error = getaddrinfo(hostname, service, &indices, &res))) {
                if (error == EAI_SYSTEM) perror("  [getaddrinfo]");
                fprintf(stderr, "  [getaddrinfo] %s : %s\n", hostname,
                        gai_strerror(error));
//                return "Erreur"; // évidement c'est a changer !
        }
 
//return "";
	       return &res ;
	//       freeaddrinfo(res);
 
 
 
}
const std::string cNet::GetIp(struct addrinfo * ai){
     //int i = 0;
        char *ptr = NULL;
        int port = 0;                // Numero de port.
        char addr[INET6_ADDRSTRLEN]; // Adresse reseau.
 
        while (ai != NULL) {  // Parcours de la liste chainée.
              //  printf("  [%d] ",i++);
              //  print_family(ai->ai_family);     printf("(%d) ", ai->ai_addrlen);
              //  print_socktype(ai->ai_socktype); printf(" ");
               // print_protocol(ai->ai_protocol); printf("\n");
                // Récupération du numéro de port et de l'adresse IP.
                switch (ai->ai_family) {
                case AF_INET:  {
                        struct sockaddr_in *sin =
                                (struct sockaddr_in *) ai->ai_addr;
                        ptr = (char *) inet_ntop(AF_INET, &sin->sin_addr,
                                                 addr, sizeof(addr));
                        port = sin->sin_port;
                        break;     }
                case AF_INET6: {
                        struct sockaddr_in6 *sin6 =
                                (struct sockaddr_in6 *) ai->ai_addr;
                        ptr = (char *) inet_ntop(AF_INET6, &sin6->sin6_addr,
                                                 addr, sizeof(addr));
                        port = sin6->sin6_port;
                        break;     }
                }
				std::cout << "IP : " << addr << "Port" << port << std::endl;
				return addr;
              //  if (ptr != NULL) printf("\t@IP -> %s\t port : %d\n",addr,port);
               /* if (ai->ai_canonname != NULL)
                        printf("\tNom -> %s\n", ai->ai_canonname);*/
              //  ai = ai->ai_next; // On passe à l'élément suivant.
        }
		return "Erreur inconnue ";
}
const std::string cNet::flags(int fl){
	switch (fl) {
	case AI_PASSIVE:     	return "Passive"		; break;
	case AI_CANONNAME:   	return "Name"			; break;
	case AI_NUMERICHOST: 	return "Numeric host"	; break;
	default: return"%d Inconnu " +fl				;
	}
}
const std::string cNet::family(int fam){
	switch (fam) {
	case AF_INET:  			return "Inet"			; break;
	case AF_INET6: 			return "Inet6"			; break;
	case AF_LOCAL: 			return "Local"			; break;
	default: return "Inconnu : " + fam 				;
	}
}
const std::string cNet::socktype(int sock){
	switch (sock) {
	case SOCK_STREAM: 		return "Sock stream"	; break;
	case SOCK_DGRAM:  		return "Sock dgram"		; break;
	default: return "Inconnu " + sock				;
	}
}
const std::string cNet::protocol(int proto){
	switch (proto) {
	case IPPROTO_IP:   		return "Protocole ip"	; break;
	case IPPROTO_TCP:  		return "Protocole tcp"	; break;
	case IPPROTO_UDP:  		return "Protocole udp"	; break;
	case IPPROTO_RAW:  		return "Protocole raw"	; break;
	case IPPROTO_ICMP: 		return "Protocole icmp"	; break;
	default: return "Inconnu " + proto				;
	}
}
//*************************************************************
Csr::Csr(addrinfo** source)
{
           //...
}
 
const Csr & Csr::operator=(addrinfo** source)
{
      //....
 
     return *this;
}

bon c'est loin d'etre fini , mai bon sa explique comment y faire face

Merci pour ta patience et ta rapidité dans tes réponses

API C souci de convertion string et char ?

C++

Discussions similaires

Partager

Partager