Obtenir l'adresse IP de la machine

Question

Cette question est presque identique à celle posée précédemment. Obtenir l'adresse IP de l'ordinateur local -Question. Cependant, j'ai besoin de trouver l'adresse ou les adresses IP d'un site Web. Machine Linux .

Donc : Comment puis-je - de manière programmatique dans C++ - détecter les adresses IP du serveur linux sur lequel mon application est exécutée. Les serveurs auront au moins deux adresses IP et j'ai besoin d'une adresse spécifique (celle d'un réseau donné (le réseau public)).

Je suis sûr qu'il existe une fonction simple pour le faire - mais où ?

---

Pour rendre les choses un peu plus claires :

• Le serveur aura évidemment l'adresse "localhost" : 127.0.0.1
• Le serveur aura une adresse IP interne (de gestion) : 172.16.x.x
• Le serveur aura une adresse IP externe (publique) : 80.190.x.x

Je dois trouver l'adresse IP externe pour y lier mon application. Il est évident que je peux aussi me lier à INADDR_ANY (et c'est d'ailleurs ce que je fais pour l'instant). Mais je préférerais détecter l'adresse publique.

Answer 1

J'ai trouvé la solution ioctl problématique sur os x (qui est conforme à POSIX donc devrait être similaire à linux). Cependant getifaddress() vous permettra de faire la même chose facilement, il fonctionne bien pour moi sur os x 10.5 et devrait être le même sous linux.

J'ai fait un exemple rapide ci-dessous qui imprimera toutes les adresses IPv4 de la machine, (vous devriez également vérifier que getifaddrs a réussi, c'est-à-dire qu'il renvoie 0).

Je l'ai mis à jour pour montrer les adresses IPv6 aussi.

#include <stdio.h>      
#include <sys/types.h>
#include <ifaddrs.h>
#include <netinet/in.h> 
#include <string.h> 
#include <arpa/inet.h>

int main (int argc, const char * argv[]) {
    struct ifaddrs * ifAddrStruct=NULL;
    struct ifaddrs * ifa=NULL;
    void * tmpAddrPtr=NULL;

    getifaddrs(&ifAddrStruct);

    for (ifa = ifAddrStruct; ifa != NULL; ifa = ifa->ifa_next) {
        if (ifa ->ifa_addr->sa_family==AF_INET) { // check it is IP4
            // is a valid IP4 Address
            tmpAddrPtr=&((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
            char addressBuffer[INET_ADDRSTRLEN];
            inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, INET_ADDRSTRLEN);
            printf("%s IP Address %s\n", ifa->ifa_name, addressBuffer); 
        } else if (ifa->ifa_addr->sa_family==AF_INET6) { // check it is IP6
            // is a valid IP6 Address
            tmpAddrPtr=&((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
            char addressBuffer[INET6_ADDRSTRLEN];
            inet_ntop(AF_INET6, tmpAddrPtr, addressBuffer, INET6_ADDRSTRLEN);
            printf("%s IP Address %s\n", ifa->ifa_name, addressBuffer); 
        } 
    }
    if (ifAddrStruct!=NULL) freeifaddrs(ifAddrStruct);
    return 0;
}

Answer 2

1. Créer un socket.
2. Exécuter ioctl(<socketfd>, SIOCGIFCONF, (struct ifconf)&buffer);

Lisez /usr/include/linux/if.h pour des informations sur les structures ifconf et ifreq. Cela devrait vous donner l'adresse IP de chaque interface sur le système. Lisez également /usr/include/linux/sockios.h pour des ioctls supplémentaires.

Answer 3

J'aime La réponse de jjvainio . Comme le dit Zan Lnyx, il utilise la table de routage locale pour trouver l'adresse IP de l'interface Ethernet qui serait utilisée pour une connexion à un hôte externe spécifique. En utilisant un socket UDP connecté, vous pouvez obtenir l'information sans envoyer de paquets. Cette approche nécessite que vous choisissiez un hôte externe spécifique. La plupart du temps, toute adresse IP publique bien connue devrait faire l'affaire. J'aime bien l'adresse 8.8.8.8 du serveur DNS public de Google à cette fin, mais il peut arriver que vous souhaitiez choisir une autre adresse IP d'hôte externe. Voici un code qui illustre l'approche complète.

void GetPrimaryIp(char* buffer, size_t buflen) 
{
    assert(buflen >= 16);

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    assert(sock != -1);

    const char* kGoogleDnsIp = "8.8.8.8";
    uint16_t kDnsPort = 53;
    struct sockaddr_in serv;
    memset(&serv, 0, sizeof(serv));
    serv.sin_family = AF_INET;
    serv.sin_addr.s_addr = inet_addr(kGoogleDnsIp);
    serv.sin_port = htons(kDnsPort);

    int err = connect(sock, (const sockaddr*) &serv, sizeof(serv));
    assert(err != -1);

    sockaddr_in name;
    socklen_t namelen = sizeof(name);
    err = getsockname(sock, (sockaddr*) &name, &namelen);
    assert(err != -1);

    const char* p = inet_ntop(AF_INET, &name.sin_addr, buffer, buflen);
    assert(p);

    close(sock);
}

Answer 4

Comme vous l'avez constaté, il n'existe pas d'"adresse IP locale" unique. Voici comment trouver l'adresse locale qui peut être envoyée à un hôte spécifique.

1. Créer un socket UDP
2. Connectez le socket à une adresse extérieure (l'hôte qui recevra éventuellement l'adresse locale).
3. Utilisez getsockname pour obtenir l'adresse locale

Answer 5

Cette page montre une solution utilisant les deux fonctions gethostname() en même temps que gethostbyname() . Le premier vous indique le nom de la machine locale, le second recherche la ou les adresses IP correspondant à ce nom. L'utilisation de cette dernière avec "localhost" ne fonctionne pas, car elle ne donne généralement que 127.0.0.1.