IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C++ Discussion :

API C souci de convertion string et char ?


Sujet :

C++

  1. #1
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2006
    Messages
    412
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Décembre 2006
    Messages : 412
    Par défaut API C souci de convertion string et char ?
    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

  2. #2
    Inactif  


    Homme Profil pro
    Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Inscrit en
    Décembre 2011
    Messages
    9 026
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 32
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Secteur : Enseignement

    Informations forums :
    Inscription : Décembre 2011
    Messages : 9 026
    Par défaut
    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();
    ?

  3. #3
    Expert éminent

    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2007
    Messages
    5 202
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2007
    Messages : 5 202
    Par défaut
    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*.

  4. #4
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2006
    Messages
    412
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Décembre 2006
    Messages : 412
    Par défaut
    Citation Envoyé par leternel Voir le message
    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

  5. #5
    Membre éprouvé
    Profil pro
    Inscrit en
    Novembre 2004
    Messages
    2 766
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2004
    Messages : 2 766
    Par défaut
    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.

  6. #6
    Inactif  


    Homme Profil pro
    Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Inscrit en
    Décembre 2011
    Messages
    9 026
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 32
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Secteur : Enseignement

    Informations forums :
    Inscription : Décembre 2011
    Messages : 9 026
    Par défaut
    Citation Envoyé par panthere noire Voir le message
    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)
    {
     
    }

  7. #7
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2006
    Messages
    412
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Décembre 2006
    Messages : 412
    Par défaut
    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

  8. #8
    Inactif  


    Homme Profil pro
    Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Inscrit en
    Décembre 2011
    Messages
    9 026
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 32
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Secteur : Enseignement

    Informations forums :
    Inscription : Décembre 2011
    Messages : 9 026
    Par défaut
    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;
    }

  9. #9
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2006
    Messages
    412
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Décembre 2006
    Messages : 412
    Par défaut
    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......

  10. #10
    Inactif  


    Homme Profil pro
    Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Inscrit en
    Décembre 2011
    Messages
    9 026
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 32
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Secteur : Enseignement

    Informations forums :
    Inscription : Décembre 2011
    Messages : 9 026
    Par défaut
    Peux-tu nous monter ton fichier cAppli.hpp et nous mettre en valeur la ligne 58 ?

  11. #11
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2006
    Messages
    412
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Décembre 2006
    Messages : 412
    Par défaut
    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

  12. #12
    Inactif  


    Homme Profil pro
    Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Inscrit en
    Décembre 2011
    Messages
    9 026
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 32
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Secteur : Enseignement

    Informations forums :
    Inscription : Décembre 2011
    Messages : 9 026
    Par défaut
    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
     
    } ;

  13. #13
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2006
    Messages
    412
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Décembre 2006
    Messages : 412
    Par défaut
    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 ?

  14. #14
    Inactif  


    Homme Profil pro
    Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Inscrit en
    Décembre 2011
    Messages
    9 026
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 32
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Secteur : Enseignement

    Informations forums :
    Inscription : Décembre 2011
    Messages : 9 026
    Par défaut
    Tu as juste à enlever ton typedef std::string csr et de remplacer chaque csr par Csr.

  15. #15
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2006
    Messages
    412
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Décembre 2006
    Messages : 412
    Par défaut
    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 ??

  16. #16
    Inactif  


    Homme Profil pro
    Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Inscrit en
    Décembre 2011
    Messages
    9 026
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 32
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Secteur : Enseignement

    Informations forums :
    Inscription : Décembre 2011
    Messages : 9 026
    Par défaut
    Soit tu fait :
    Soit tu modifies ton constructeur et la surchage de l'opérateur = pour avoir en paramètre un addrinfo*.

  17. #17
    Membre éclairé
    Profil pro
    Inscrit en
    Décembre 2006
    Messages
    412
    Détails du profil
    Informations personnelles :
    Localisation : Suisse

    Informations forums :
    Inscription : Décembre 2006
    Messages : 412
    Par défaut
    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

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. MD5, convertion hexa en char/string
    Par mindofbuild dans le forum C
    Réponses: 4
    Dernier message: 14/08/2010, 14h01
  2. Convertion d'un String en Char
    Par bnbnb dans le forum Débuter
    Réponses: 2
    Dernier message: 04/03/2008, 19h36
  3. Convertion string en char*
    Par krolineeee dans le forum C++
    Réponses: 9
    Dernier message: 24/07/2006, 14h35
  4. convertion string --> long
    Par JulienT dans le forum Langage
    Réponses: 3
    Dernier message: 23/03/2005, 23h05
  5. [Debutant(e)]limitation du String 65536 char
    Par srane dans le forum API standards et tierces
    Réponses: 8
    Dernier message: 28/05/2004, 23h42

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo