Back to index

python3.2  3.2.2
Classes | Defines | Functions | Variables
getaddrinfo.c File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  sockinet
struct  gai_afd

Defines

#define SUCCESS   0
#define GAI_ANY   0
#define YES   1
#define NO   0
#define N_INET   0
#define PTON_MAX   4
#define IN_MULTICAST(i)   (((i) & 0xf0000000U) == 0xe0000000U)
#define IN_EXPERIMENTAL(i)   (((i) & 0xe0000000U) == 0xe0000000U)
#define IN_LOOPBACKNET   127
#define GET_CANONNAME(ai, str)
#define GET_AI(ai, gai_afd, addr, port)
#define ERR(err)   { error = (err); goto bad; }

Functions

static int get_name (const char *, struct gai_afd *, struct addrinfo **, char *, struct addrinfo *, int)
static int get_addr (const char *, int, struct addrinfo **, struct addrinfo *, int)
static int str_isnumber (const char *)
char * gai_strerror (int ecode)
void freeaddrinfo (struct addrinfo *ai)
int getaddrinfo (const char *hostname, const char *servname, const struct addrinfo *hints, struct addrinfo **res)
static int get_name (char *addr, struct gai_afd *gai_afd, struct addrinfo **res, char *numaddr, struct addrinfo *pai, int port0) const
static int get_addr (char *hostname, int af, struct addrinfo **res, struct addrinfo *pai, int port0) const

Variables

static const char in_addrany [] = { 0, 0, 0, 0 }
static const char in6_addrany []
static const char in_loopback [] = { 127, 0, 0, 1 }
static const char in6_loopback []
static struct gai_afd gai_afdl []
static char * ai_errlist []

Class Documentation

struct sockinet

Definition at line 83 of file getaddrinfo.c.

Class Members
u_char si_family
u_char si_len
u_short si_port
struct gai_afd

Definition at line 89 of file getaddrinfo.c.

Class Members
const char * a_addrany
int a_addrlen
int a_af
const char * a_loopback
int a_off
int a_socklen

Define Documentation

#define ERR (   err)    { error = (err); goto bad; }

Definition at line 199 of file getaddrinfo.c.

#define GAI_ANY   0

Definition at line 65 of file getaddrinfo.c.

#define GET_AI (   ai,
  gai_afd,
  addr,
  port 
)
Value:
{\
    char *p;\
    if (((ai) = (struct addrinfo *)malloc(sizeof(struct addrinfo) +\
                                          ((gai_afd)->a_socklen)))\
        == NULL) goto free;\
    memcpy(ai, pai, sizeof(struct addrinfo));\
    (ai)->ai_addr = (struct sockaddr *)((ai) + 1);\
    memset((ai)->ai_addr, 0, (gai_afd)->a_socklen);\
    (ai)->ai_addrlen = (gai_afd)->a_socklen;\
    (ai)->ai_addr->sa_family = (ai)->ai_family = (gai_afd)->a_af;\
    ((struct sockinet *)(ai)->ai_addr)->si_port = port;\
    p = (char *)((ai)->ai_addr);\
    memcpy(p + (gai_afd)->a_off, (addr), (gai_afd)->a_addrlen);\
}

Definition at line 183 of file getaddrinfo.c.

#define GET_CANONNAME (   ai,
  str 
)
Value:
if (pai->ai_flags & AI_CANONNAME) {\
    if (((ai)->ai_canonname = (char *)malloc(strlen(str) + 1)) != NULL) {\
        strcpy((ai)->ai_canonname, (str));\
    } else {\
        error = EAI_MEMORY;\
        goto free;\
    }\
}

Definition at line 157 of file getaddrinfo.c.

#define IN_EXPERIMENTAL (   i)    (((i) & 0xe0000000U) == 0xe0000000U)

Definition at line 125 of file getaddrinfo.c.

#define IN_LOOPBACKNET   127

Definition at line 129 of file getaddrinfo.c.

#define IN_MULTICAST (   i)    (((i) & 0xf0000000U) == 0xe0000000U)

Definition at line 121 of file getaddrinfo.c.

#define N_INET   0
#define NO   0

Definition at line 67 of file getaddrinfo.c.

#define PTON_MAX   4

Definition at line 117 of file getaddrinfo.c.

#define SUCCESS   0

Definition at line 64 of file getaddrinfo.c.

#define YES   1

Definition at line 66 of file getaddrinfo.c.


Function Documentation

void freeaddrinfo ( struct addrinfo ai)

Definition at line 210 of file getaddrinfo.c.

{
    struct addrinfo *next;

    do {
        next = ai->ai_next;
        if (ai->ai_canonname)
            free(ai->ai_canonname);
        /* no need to free(ai->ai_addr) */
        free(ai);
    } while ((ai = next) != NULL);
}

Here is the caller graph for this function:

char* gai_strerror ( int  ecode)

Definition at line 202 of file getaddrinfo.c.

{
    if (ecode < 0 || ecode > EAI_MAX)
        ecode = EAI_MAX;
    return ai_errlist[ecode];
}
static int get_addr ( const char *  ,
int  ,
struct addrinfo **  ,
struct addrinfo ,
int   
) [static]

Here is the caller graph for this function:

static int get_addr ( char *  hostname,
int  af,
struct addrinfo **  res,
struct addrinfo pai,
int  port0 
) const [static]

Definition at line 530 of file getaddrinfo.c.

{
    u_short port = port0 & 0xffff;
    struct addrinfo sentinel;
    struct hostent *hp;
    struct addrinfo *top, *cur;
    struct gai_afd *gai_afd;
    int i, error = 0, h_error;
    char *ap;

    top = NULL;
    sentinel.ai_next = NULL;
    cur = &sentinel;
#ifdef ENABLE_IPV6
    if (af == AF_UNSPEC) {
        hp = getipnodebyname(hostname, AF_INET6,
                        AI_ADDRCONFIG|AI_ALL|AI_V4MAPPED, &h_error);
    } else
        hp = getipnodebyname(hostname, af, AI_ADDRCONFIG, &h_error);
#else
    hp = gethostbyname(hostname);
    h_error = h_errno;
#endif
    if (hp == NULL) {
        switch (h_error) {
        case HOST_NOT_FOUND:
        case NO_DATA:
            error = EAI_NODATA;
            break;
        case TRY_AGAIN:
            error = EAI_AGAIN;
            break;
        case NO_RECOVERY:
        default:
            error = EAI_FAIL;
            break;
        }
        goto free;
    }

    if ((hp->h_name == NULL) || (hp->h_name[0] == 0) ||
        (hp->h_addr_list[0] == NULL)) {
        error = EAI_FAIL;
        goto free;
    }

    for (i = 0; (ap = hp->h_addr_list[i]) != NULL; i++) {
        switch (af) {
#ifdef ENABLE_IPV6
        case AF_INET6:
            gai_afd = &gai_afdl[N_INET6];
            break;
#endif
#ifndef ENABLE_IPV6
        default:                /* AF_UNSPEC */
#endif
        case AF_INET:
            gai_afd = &gai_afdl[N_INET];
            break;
#ifdef ENABLE_IPV6
        default:                /* AF_UNSPEC */
            if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)ap)) {
                ap += sizeof(struct in6_addr) -
                    sizeof(struct in_addr);
                gai_afd = &gai_afdl[N_INET];
            } else
                gai_afd = &gai_afdl[N_INET6];
            break;
#endif
        }
#ifdef FAITH
        if (translate && gai_afd->a_af == AF_INET) {
            struct in6_addr *in6;

            GET_AI(cur->ai_next, &gai_afdl[N_INET6], ap, port);
            in6 = &((struct sockaddr_in6 *)cur->ai_next->ai_addr)->sin6_addr;
            memcpy(&in6->s6_addr32[0], &faith_prefix,
                sizeof(struct in6_addr) - sizeof(struct in_addr));
            memcpy(&in6->s6_addr32[3], ap, sizeof(struct in_addr));
        } else
#endif /* FAITH */
        GET_AI(cur->ai_next, gai_afd, ap, port);
        if (cur == &sentinel) {
            top = cur->ai_next;
            GET_CANONNAME(top, hp->h_name);
        }
        cur = cur->ai_next;
    }
#ifdef ENABLE_IPV6
    freehostent(hp);
#endif
    *res = top;
    return SUCCESS;
 free:
    if (top)
        freeaddrinfo(top);
#ifdef ENABLE_IPV6
    if (hp)
        freehostent(hp);
#endif
/* bad: */
    *res = NULL;
    return error;
}

Here is the call graph for this function:

static int get_name ( const char *  ,
struct gai_afd ,
struct addrinfo **  ,
char *  ,
struct addrinfo ,
int   
) [static]

Here is the caller graph for this function:

static int get_name ( char *  addr,
struct gai_afd gai_afd,
struct addrinfo **  res,
char *  numaddr,
struct addrinfo pai,
int  port0 
) const [static]

Definition at line 484 of file getaddrinfo.c.

{
    u_short port = port0 & 0xffff;
    struct hostent *hp;
    struct addrinfo *cur;
    int error = 0;
#ifdef ENABLE_IPV6
    int h_error;
#endif

#ifdef ENABLE_IPV6
    hp = getipnodebyaddr(addr, gai_afd->a_addrlen, gai_afd->a_af, &h_error);
#else
    hp = gethostbyaddr(addr, gai_afd->a_addrlen, AF_INET);
#endif
    if (hp && hp->h_name && hp->h_name[0] && hp->h_addr_list[0]) {
        GET_AI(cur, gai_afd, hp->h_addr_list[0], port);
        GET_CANONNAME(cur, hp->h_name);
    } else
        GET_AI(cur, gai_afd, numaddr, port);

#ifdef ENABLE_IPV6
    if (hp)
        freehostent(hp);
#endif
    *res = cur;
    return SUCCESS;
 free:
    if (cur)
        freeaddrinfo(cur);
#ifdef ENABLE_IPV6
    if (hp)
        freehostent(hp);
#endif
 /* bad: */
    *res = NULL;
    return error;
}

Here is the call graph for this function:

int getaddrinfo ( const char *  hostname,
const char *  servname,
const struct addrinfo hints,
struct addrinfo **  res 
)

Definition at line 236 of file getaddrinfo.c.

{
    struct addrinfo sentinel;
    struct addrinfo *top = NULL;
    struct addrinfo *cur;
    int i, error = 0;
    char pton[PTON_MAX];
    struct addrinfo ai;
    struct addrinfo *pai;
    u_short port;

#ifdef FAITH
    static int firsttime = 1;

    if (firsttime) {
        /* translator hack */
        {
            char *q = getenv("GAI");
            if (q && inet_pton(AF_INET6, q, &faith_prefix) == 1)
                translate = YES;
        }
        firsttime = 0;
    }
#endif

    /* initialize file static vars */
    sentinel.ai_next = NULL;
    cur = &sentinel;
    pai = &ai;
    pai->ai_flags = 0;
    pai->ai_family = PF_UNSPEC;
    pai->ai_socktype = GAI_ANY;
    pai->ai_protocol = GAI_ANY;
    pai->ai_addrlen = 0;
    pai->ai_canonname = NULL;
    pai->ai_addr = NULL;
    pai->ai_next = NULL;
    port = GAI_ANY;

    if (hostname == NULL && servname == NULL)
        return EAI_NONAME;
    if (hints) {
        /* error check for hints */
        if (hints->ai_addrlen || hints->ai_canonname ||
            hints->ai_addr || hints->ai_next)
            ERR(EAI_BADHINTS); /* xxx */
        if (hints->ai_flags & ~AI_MASK)
            ERR(EAI_BADFLAGS);
        switch (hints->ai_family) {
        case PF_UNSPEC:
        case PF_INET:
#ifdef ENABLE_IPV6
        case PF_INET6:
#endif
            break;
        default:
            ERR(EAI_FAMILY);
        }
        memcpy(pai, hints, sizeof(*pai));
        switch (pai->ai_socktype) {
        case GAI_ANY:
            switch (pai->ai_protocol) {
            case GAI_ANY:
                break;
            case IPPROTO_UDP:
                pai->ai_socktype = SOCK_DGRAM;
                break;
            case IPPROTO_TCP:
                pai->ai_socktype = SOCK_STREAM;
                break;
            default:
                pai->ai_socktype = SOCK_RAW;
                break;
            }
            break;
        case SOCK_RAW:
            break;
        case SOCK_DGRAM:
            if (pai->ai_protocol != IPPROTO_UDP &&
                pai->ai_protocol != GAI_ANY)
                ERR(EAI_BADHINTS);                      /*xxx*/
            pai->ai_protocol = IPPROTO_UDP;
            break;
        case SOCK_STREAM:
            if (pai->ai_protocol != IPPROTO_TCP &&
                pai->ai_protocol != GAI_ANY)
                ERR(EAI_BADHINTS);                      /*xxx*/
            pai->ai_protocol = IPPROTO_TCP;
            break;
        default:
            ERR(EAI_SOCKTYPE);
            /* unreachable */
        }
    }

    /*
     * service port
     */
    if (servname) {
        if (str_isnumber(servname)) {
            if (pai->ai_socktype == GAI_ANY) {
                /* caller accept *GAI_ANY* socktype */
                pai->ai_socktype = SOCK_DGRAM;
                pai->ai_protocol = IPPROTO_UDP;
            }
            port = htons((u_short)atoi(servname));
        } else {
            struct servent *sp;
            char *proto;

            proto = NULL;
            switch (pai->ai_socktype) {
            case GAI_ANY:
                proto = NULL;
                break;
            case SOCK_DGRAM:
                proto = "udp";
                break;
            case SOCK_STREAM:
                proto = "tcp";
                break;
            default:
                fprintf(stderr, "panic!\n");
                break;
            }
            if ((sp = getservbyname(servname, proto)) == NULL)
                ERR(EAI_SERVICE);
            port = sp->s_port;
            if (pai->ai_socktype == GAI_ANY) {
                if (strcmp(sp->s_proto, "udp") == 0) {
                    pai->ai_socktype = SOCK_DGRAM;
                    pai->ai_protocol = IPPROTO_UDP;
                } else if (strcmp(sp->s_proto, "tcp") == 0) {
                    pai->ai_socktype = SOCK_STREAM;
                    pai->ai_protocol = IPPROTO_TCP;
                } else
                    ERR(EAI_PROTOCOL);                          /*xxx*/
            }
        }
    }

    /*
     * hostname == NULL.
     * passive socket -> anyaddr (0.0.0.0 or ::)
     * non-passive socket -> localhost (127.0.0.1 or ::1)
     */
    if (hostname == NULL) {
        struct gai_afd *gai_afd;

        for (gai_afd = &gai_afdl[0]; gai_afd->a_af; gai_afd++) {
            if (!(pai->ai_family == PF_UNSPEC
               || pai->ai_family == gai_afd->a_af)) {
                continue;
            }

            if (pai->ai_flags & AI_PASSIVE) {
                GET_AI(cur->ai_next, gai_afd, gai_afd->a_addrany, port);
                /* xxx meaningless?
                 * GET_CANONNAME(cur->ai_next, "anyaddr");
                 */
            } else {
                GET_AI(cur->ai_next, gai_afd, gai_afd->a_loopback,
                    port);
                /* xxx meaningless?
                 * GET_CANONNAME(cur->ai_next, "localhost");
                 */
            }
            cur = cur->ai_next;
        }
        top = sentinel.ai_next;
        if (top)
            goto good;
        else
            ERR(EAI_FAMILY);
    }

    /* hostname as numeric name */
    for (i = 0; gai_afdl[i].a_af; i++) {
        if (inet_pton(gai_afdl[i].a_af, hostname, pton)) {
            u_long v4a;
#ifdef ENABLE_IPV6
            u_char pfx;
#endif

            switch (gai_afdl[i].a_af) {
            case AF_INET:
                v4a = ((struct in_addr *)pton)->s_addr;
                v4a = ntohl(v4a);
                if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a))
                    pai->ai_flags &= ~AI_CANONNAME;
                v4a >>= IN_CLASSA_NSHIFT;
                if (v4a == 0 || v4a == IN_LOOPBACKNET)
                    pai->ai_flags &= ~AI_CANONNAME;
                break;
#ifdef ENABLE_IPV6
            case AF_INET6:
                pfx = ((struct in6_addr *)pton)->s6_addr8[0];
                if (pfx == 0 || pfx == 0xfe || pfx == 0xff)
                    pai->ai_flags &= ~AI_CANONNAME;
                break;
#endif
            }

            if (pai->ai_family == gai_afdl[i].a_af ||
                pai->ai_family == PF_UNSPEC) {
                if (! (pai->ai_flags & AI_CANONNAME)) {
                    GET_AI(top, &gai_afdl[i], pton, port);
                    goto good;
                }
                /*
                 * if AI_CANONNAME and if reverse lookup
                 * fail, return ai anyway to pacify
                 * calling application.
                 *
                 * XXX getaddrinfo() is a name->address
                 * translation function, and it looks strange
                 * that we do addr->name translation here.
                 */
                get_name(pton, &gai_afdl[i], &top, pton, pai, port);
                goto good;
            } else
                ERR(EAI_FAMILY);                        /*xxx*/
        }
    }

    if (pai->ai_flags & AI_NUMERICHOST)
        ERR(EAI_NONAME);

    /* hostname as alphabetical name */
    error = get_addr(hostname, pai->ai_family, &top, pai, port);
    if (error == 0) {
        if (top) {
 good:
            *res = top;
            return SUCCESS;
        } else
            error = EAI_FAIL;
    }
 free:
    if (top)
        freeaddrinfo(top);
 bad:
    *res = NULL;
    return error;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int str_isnumber ( const char *  p) [static]

Definition at line 224 of file getaddrinfo.c.

{
    unsigned char *q = (unsigned char *)p;
    while (*q) {
        if (! isdigit(*q))
            return NO;
        q++;
    }
    return YES;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

char* ai_errlist[] [static]
Initial value:
 {
    "success.",
    "address family for hostname not supported.",       
    "temporary failure in name resolution.",            
    "invalid value for ai_flags.",                      
    "non-recoverable failure in name resolution.",      
    "ai_family not supported.",                         
    "memory allocation failure.",                       
    "no address associated with hostname.",             
    "hostname nor servname provided, or not known.",
    "servname not supported for ai_socktype.",          
    "ai_socktype not supported.",                       
    "system error returned in errno.",                  
    "invalid value for hints.",                         
    "resolved protocol is unknown.",                    
    "unknown error.",                                   
}

Definition at line 139 of file getaddrinfo.c.

struct gai_afd gai_afdl[] [static]
const char in6_addrany[] [static]
Initial value:
 {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
}

Definition at line 75 of file getaddrinfo.c.

const char in6_loopback[] [static]
Initial value:
 {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
}

Definition at line 79 of file getaddrinfo.c.

const char in_addrany[] = { 0, 0, 0, 0 } [static]

Definition at line 74 of file getaddrinfo.c.

const char in_loopback[] = { 127, 0, 0, 1 } [static]

Definition at line 78 of file getaddrinfo.c.