hostlookup.c

Go to the documentation of this file.

#include "iothread.h"
#include "hostlookup.h"
#include "text.h"
#include <string.h>
#ifndef NDEBUG
#include <stdio.h>
#endif
#include <assert.h>
#ifndef WIN32
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#endif
#include <SDL.h>

static struct addrinfo *addrLookup = NULL;

static char *lookupName = NULL;

static int conditionCode = 0;

static INetAddr hostaddr;

char localhostName[MAX_HOST_LEN] = { 0 };

char localhostAddrStr[INET6_ADDRSTRLEN] = { 0 };

static void DoAddrLookup(void *name) {
    struct addrinfo hint;
    hint.ai_flags = AI_CANONNAME;
    hint.ai_family = 0; // AF_INET or AF_INET6
    hint.ai_socktype = SOCK_DGRAM;
    hint.ai_protocol = 0;
    hint.ai_addrlen = 0;
    hint.ai_addr = NULL;
    hint.ai_canonname = NULL;
    hint.ai_next = NULL;
    
    if (addrLookup) freeaddrinfo(addrLookup);
    conditionCode = getaddrinfo(name, NULL, &hint, &addrLookup);
}

static void DoNameLookup(void *address) {
    SocketAddr addr;
    assert(lookupName != NULL);
    if (address == NULL) {
        if (hostaddr.family == AF_INET6) {
            addr.ipv6.sin6_family = AF_INET6;
            addr.ipv6.sin6_addr = hostaddr.ipv6;
            addr.length = sizeof(struct sockaddr_in6);
        }
        else {
            addr.ipv4.sin_family = AF_INET;
            addr.ipv4.sin_addr = hostaddr.ipv4;
            addr.length = sizeof(struct sockaddr_in);
        }
        address = &addr;
    }
    if ((conditionCode = getnameinfo(&(((SocketAddr*)address)->addr),
    ((SocketAddr*)address)->length, lookupName, MAX_HOST_LEN, 0, 0, 0)) == 0) {
        // success; assure a null terminated string
        lookupName[MAX_HOST_LEN - 1] = 0;
    }
}

void StartAddrLookup(char *name) {
    // wait for another lookup to finish
    #ifndef NDEBUG
    /*
    if (conditionCode > 0) {
        printf("Waiting for previous lookup before working on %s\n", name);
    }
    */
    #endif
    while (conditionCode > 0) {
        SDL_Delay(1);
    }
    conditionCode = 1;
    QueueOperation(DoAddrLookup, name);
}

#ifdef WIN32
int inet_pton(int fam, char *straddr, void *addr) {
    // check for valid family
    if (fam == AF_INET) {
        // convert the address
        if ((((struct in_addr*)addr)->s_addr = inet_addr(straddr)) != -1) {
            // success!
            return 1;
        }
        // bad address
        return 0;
    }
    // bad family -- no IPv6 support
    return -1;
}
#endif

Bool StartStrNameLookup(char *addrstr, char *name) {
    // wait for another lookup to finish
    #ifndef NDEBUG
    /*
    if (conditionCode > 0) {
        printf("Waiting for previous lookup before working on %s\n", addrstr);
    }
    */
    #endif
    while (conditionCode > 0) {
        SDL_Delay(1);
    }
    // flag that the operation has not yet finished
    conditionCode = 1;
    // attempt to parse the string as a numeric address
    if ((inet_pton(hostaddr.family = AF_INET, addrstr, &hostaddr) > 0) ||
    (inet_pton(hostaddr.family = AF_INET6, addrstr, &hostaddr) > 0)) {
        // store the string where the hostname will be written
        lookupName = name;
        // start looking for the name
        QueueOperation(DoNameLookup, NULL);
        // success to this point
        return TRUE;
    }
    // bad address
    conditionCode = 0;
    return FALSE;
}

void StartNameLookup(SocketAddr *addr, char *name) {
    // wait for another lookup to finish
    #ifndef NDEBUG
    /*
    if (conditionCode > 0) {
        printf("Waiting for previous lookup before working on another\n");
    }
    */
    #endif
    while (conditionCode > 0) {
        SDL_Delay(1);
    }
    // flag that the operation has not yet finished
    conditionCode = 1;
    // store the string where the hostname will be written
    lookupName = name;
    // start looking for the name
    QueueOperation(DoNameLookup, addr);
}

int LookupResult(char *name, INetAddr *addr) {
    // see if a lookup is in progress
    if (conditionCode == 1) return 0;
    // check for an error
    if (conditionCode != 0) {
        // The gai_strerror() function is not availble for gcc linked programs
        // on Windows, although the function is implemented in Winsock.
        #ifndef NDEBUG
        if (addrLookup == NULL) {
            prnfile(stderr, strings[STRING_ERR_HOSTLOOK],
            gai_strerror(conditionCode));
        }
        #endif
        return -1;
    }
    // looking for a hostname
    if (addrLookup == NULL) {
        if (addr != NULL) {
            if ((addr->family = hostaddr.family) == AF_INET6) {
                addr->ipv6 = hostaddr.ipv6;
            }
            else {
                addr->ipv4 = hostaddr.ipv4;
            }
        }
    }
    // looking for an IP
    else {
        // request for a host name
        if (name != NULL) {
            // a name is present
            if (addrLookup->ai_canonname) {
                // copy it over
                strncpy(name, addrLookup->ai_canonname, MAX_HOST_LEN);
                // assure null termination
                name[MAX_HOST_LEN - 1] = 0;
            }
            else {
                // no name is present; make it an empty string
                name[0] = 0;
            }
        }
        // request for an address
        if (addr != NULL) {
            // check for the family of the result (IPv6?)
            if ((addr->family = addrLookup->ai_family) == AF_INET6) {
                addr->ipv6 =
                ((struct sockaddr_in6*)(addrLookup->ai_addr))->sin6_addr;
            }
            else {
                addr->ipv4 =
                ((struct sockaddr_in*)(addrLookup->ai_addr))->sin_addr;
            }
        }
        // remove the dynamically allocated data from getaddrinfo()
        freeaddrinfo(addrLookup);
        addrLookup = NULL;
    }
    conditionCode = 0;
    return 1;
}

void DoHostnameLookup(void *ignore) {
    conditionCode = 1;
    // find what the local system thinks it's called
    gethostname(localhostName, MAX_HOST_LEN);
    // assure null termination
    localhostName[MAX_HOST_LEN - 1] = 0;
    // start the process of finding a better name, if available
    DoAddrLookup(localhostName);
    // check for success and a name other than localhost
    if ((conditionCode++ == 0) && addrLookup->ai_canonname &&
    (strncmp("localhost", addrLookup->ai_canonname, MAX_HOST_LEN) != 0)) {
        // copy it over
        strncpy(localhostName, addrLookup->ai_canonname, MAX_HOST_LEN);
        // assure null termination
        localhostName[MAX_HOST_LEN - 1] = 0;
        // check for an address other than the loopback address
        if (((addrLookup->ai_family == AF_INET) &&
        (((struct sockaddr_in*)(addrLookup->ai_addr))->sin_addr.s_addr !=
        htonl(INADDR_LOOPBACK))) || ((addrLookup->ai_family == AF_INET6) &&
        !IN6_IS_ADDR_LOOPBACK(
        &(((struct sockaddr_in6*)(addrLookup->ai_addr))->sin6_addr)))) {
            // get a string containing the address for presentation to the user
            #ifdef WIN32
            // windows lacks the standard inet_ntop() function, so work
            char *addrstr;                                 // around it
            if ((addrstr = 
            inet_ntoa(((struct sockaddr_in*)(addrLookup->ai_addr))->sin_addr))
            != NULL) {
                strcpy(localhostAddrStr, addrstr);
            }
            #else
            // convert the address to a string and test for success
            if (inet_ntop(addrLookup->ai_family,
            (addrLookup->ai_family == AF_INET) ?
            (void*)&((struct sockaddr_in*)(addrLookup->ai_addr))->sin_addr :
            (void*)&((struct sockaddr_in6*)(addrLookup->ai_addr))->sin6_addr,
            localhostAddrStr, sizeof(localhostAddrStr)) == NULL) {
                // failed for some reason, so make sure the string is NULL
                // terminated with zero length
                localhostAddrStr[0] = 0;
            }
            #endif
        }
    }
    // get rid of the result from getaddrinfo()
    freeaddrinfo(addrLookup);
    addrLookup = NULL;
    // allow another lookup operation
    conditionCode = 0;
}

---