lib/roken/getaddrinfo.c

   1 /*
   2  * Copyright (c) 1999 - 2000 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include <config.h>
  36 RCSID("$Id$");
  37 #endif
  38
  39 #include "roken.h"
  40
  41 /*
  42  * uses hints->ai_socktype and hints->ai_protocol
  43  */
  44
  45 static int
  46 get_port_protocol_socktype (const char *servname,
  47                             const struct addrinfo *hints,
  48                             int *port,
  49                             int *protocol,
  50                             int *socktype)
  51 {
  52     struct servent *se;
  53     const char *proto_str = NULL;
  54
  55     *socktype = 0;
  56
  57     if (hints != NULL && hints->ai_protocol != 0) {
  58         struct protoent *protoent = getprotobynumber (hints->ai_protocol);
  59
  60         if (protoent == NULL)
  61             return EAI_SOCKTYPE; /* XXX */
  62
  63         proto_str = protoent->p_name;
  64         *protocol = protoent->p_proto;
  65     }
  66
  67     if (hints != NULL)
  68         *socktype = hints->ai_socktype;
  69
  70     if (*socktype == SOCK_STREAM) {
  71         se = getservbyname (servname, proto_str ? proto_str : "tcp");
  72         if (proto_str == NULL)
  73             *protocol = IPPROTO_TCP;
  74     } else if (*socktype == SOCK_DGRAM) {
  75         se = getservbyname (servname, proto_str ? proto_str : "udp");
  76         if (proto_str == NULL)
  77             *protocol = IPPROTO_UDP;
  78     } else if (*socktype == 0) {
  79         if (proto_str != NULL) {
  80             se = getservbyname (servname, proto_str);
  81         } else {
  82             se = getservbyname (servname, "tcp");
  83             *protocol = IPPROTO_TCP;
  84             *socktype = SOCK_STREAM;
  85             if (se == NULL) {
  86                 se = getservbyname (servname, "udp");
  87                 *protocol = IPPROTO_UDP;
  88                 *socktype = SOCK_DGRAM;
  89             }
  90         }
  91     } else
  92         return EAI_SOCKTYPE;
  93
  94     if (se == NULL) {
  95         char *endstr;
  96
  97         *port = htons(strtol (servname, &endstr, 10));
  98         if (servname == endstr)
  99             return EAI_NONAME;
 100     } else {
 101         *port = se->s_port;
 102     }
 103     return 0;
 104 }
 105
 106 static int
 107 add_one (int port, int protocol, int socktype,
 108          struct addrinfo ***ptr,
 109          int (*func)(struct addrinfo *, void *data, int port),
 110          void *data,
 111          char *canonname)
 112 {
 113     struct addrinfo *a;
 114     int ret;
 115
 116     a = malloc (sizeof (*a));
 117     if (a == NULL)
 118         return EAI_MEMORY;
 119     memset (a, 0, sizeof(*a));
 120     a->ai_flags     = 0;
 121     a->ai_next      = NULL;
 122     a->ai_protocol  = protocol;
 123     a->ai_socktype  = socktype;
 124     a->ai_canonname = canonname;
 125     ret = (*func)(a, data, port);
 126     if (ret) {
 127         free (a);
 128         return ret;
 129     }
 130     **ptr = a;
 131     *ptr = &a->ai_next;
 132     return 0;
 133 }
 134
 135 static int
 136 const_v4 (struct addrinfo *a, void *data, int port)
 137 {
 138     struct sockaddr_in *sin;
 139     struct in_addr *addr = (struct in_addr *)data;
 140
 141     a->ai_family  = PF_INET;
 142     a->ai_addrlen = sizeof(*sin);
 143     a->ai_addr    = malloc (sizeof(*sin));
 144     if (a->ai_addr == NULL)
 145         return EAI_MEMORY;
 146     sin = (struct sockaddr_in *)a->ai_addr;
 147     memset (sin, 0, sizeof(*sin));
 148     sin->sin_family = AF_INET;
 149     sin->sin_port   = port;
 150     sin->sin_addr   = *addr;
 151     return 0;
 152 }
 153
 154 #ifdef HAVE_IPV6
 155 static int
 156 const_v6 (struct addrinfo *a, void *data, int port)
 157 {
 158     struct sockaddr_in6 *sin6;
 159     struct in6_addr *addr = (struct in6_addr *)data;
 160
 161     a->ai_family  = PF_INET6;
 162     a->ai_addrlen = sizeof(*sin6);
 163     a->ai_addr    = malloc (sizeof(*sin6));
 164     if (a->ai_addr == NULL)
 165         return EAI_MEMORY;
 166     sin6 = (struct sockaddr_in6 *)a->ai_addr;
 167     memset (sin6, 0, sizeof(*sin6));
 168     sin6->sin6_family = AF_INET6;
 169     sin6->sin6_port   = port;
 170     sin6->sin6_addr   = *addr;
 171     return 0;
 172 }
 173 #endif
 174
 175 static int
 176 get_null (const struct addrinfo *hints,
 177           int port, int protocol, int socktype,
 178           struct addrinfo **res)
 179 {
 180     struct in_addr v4_addr;
 181 #ifdef HAVE_IPV6
 182     struct in6_addr v6_addr;
 183 #endif
 184     struct addrinfo *first = NULL;
 185     struct addrinfo **current = &first;
 186     int family = PF_UNSPEC;
 187     int ret;
 188
 189     if (hints != NULL)
 190         family = hints->ai_family;
 191
 192     if (hints && hints->ai_flags & AI_PASSIVE) {
 193         v4_addr.s_addr = INADDR_ANY;
 194 #ifdef HAVE_IPV6
 195         v6_addr        = in6addr_any;
 196 #endif
 197     } else {
 198         v4_addr.s_addr = htonl(INADDR_LOOPBACK);
 199 #ifdef HAVE_IPV6
 200         v6_addr        = in6addr_loopback;
 201 #endif
 202     }
 203
 204 #ifdef HAVE_IPV6
 205     if (family == PF_INET6 || family == PF_UNSPEC) {
 206         ret = add_one (port, protocol, socktype,
 207                        &current, const_v6, &v6_addr, NULL);
 208     }
 209 #endif
 210     if (family == PF_INET || family == PF_UNSPEC) {
 211         ret = add_one (port, protocol, socktype,
 212                        &current, const_v4, &v4_addr, NULL);
 213     }
 214     *res = first;
 215     return 0;
 216 }
 217
 218 /*
 219  * Try to find a fqdn (with `.') in he if possible, else return h_name
 220  */
 221
 222 static char *
 223 find_fqdn (const struct hostent *he)
 224 {
 225     char *ret = he->h_name;
 226     char **h;
 227
 228     if (strchr (ret, '.') == NULL)
 229         for (h = he->h_aliases; *h; ++h) {
 230             if (strchr (*h, '.') != NULL) {
 231                 ret = *h;
 232                 break;
 233             }
 234         }
 235     return ret;
 236 }
 237
 238 static int
 239 add_hostent (int port, int protocol, int socktype,
 240              struct addrinfo ***current,
 241              int (*func)(struct addrinfo *, void *data, int port),
 242              struct hostent *he, int *flags)
 243 {
 244     int ret;
 245     char *canonname = NULL;
 246     char **h;
 247
 248     if (*flags & AI_CANONNAME) {
 249         struct hostent *he2 = NULL;
 250
 251         canonname = find_fqdn (he);
 252         if (strchr (canonname, '.') == NULL) {
 253             int error;
 254
 255             he2 = getipnodebyaddr (he->h_addr_list[0], he->h_length,
 256                                    he->h_addrtype, &error);
 257             if (he2 != NULL) {
 258                 char *tmp = find_fqdn (he2);
 259
 260                 if (strchr (tmp, '.') != NULL)
 261                     canonname = tmp;
 262             }
 263         }
 264
 265         canonname = strdup (canonname);
 266         if (he2 != NULL)
 267             freehostent (he2);
 268         if (canonname == NULL)
 269             return EAI_MEMORY;
 270     }
 271
 272     for (h = he->h_addr_list; *h != NULL; ++h) {
 273         ret = add_one (port, protocol, socktype,
 274                        current, func, *h, canonname);
 275         if (ret)
 276             return ret;
 277         if (*flags & AI_CANONNAME) {
 278             *flags &= ~AI_CANONNAME;
 279             canonname = NULL;
 280         }
 281     }
 282     return 0;
 283 }
 284
 285 static int
 286 get_number (const char *nodename,
 287             const struct addrinfo *hints,
 288             int port, int protocol, int socktype,
 289             struct addrinfo **res)
 290 {
 291     struct addrinfo *first = NULL;
 292     struct addrinfo **current = &first;
 293     int family = PF_UNSPEC;
 294     int ret;
 295
 296     if (hints != NULL) {
 297         family = hints->ai_family;
 298     }
 299
 300 #ifdef HAVE_IPV6
 301     if (family == PF_INET6 || family == PF_UNSPEC) {
 302         struct in6_addr v6_addr;
 303
 304         if (inet_pton (PF_INET6, nodename, &v6_addr) == 1) {
 305             ret = add_one (port, protocol, socktype,
 306                            &current, const_v6, &v6_addr, NULL);
 307             *res = first;
 308             return ret;
 309         }
 310     }
 311 #endif
 312     if (family == PF_INET || family == PF_UNSPEC) {
 313         struct in_addr v4_addr;
 314
 315         if (inet_pton (PF_INET, nodename, &v4_addr) == 1) {
 316             ret = add_one (port, protocol, socktype,
 317                            &current, const_v4, &v4_addr, NULL);
 318             *res = first;
 319             return ret;
 320         }
 321     }
 322     return EAI_NONAME;
 323 }
 324
 325 static int
 326 get_nodes (const char *nodename,
 327            const struct addrinfo *hints,
 328            int port, int protocol, int socktype,
 329            struct addrinfo **res)
 330 {
 331     struct addrinfo *first = NULL;
 332     struct addrinfo **current = &first;
 333     int family = PF_UNSPEC;
 334     int flags  = 0;
 335     int ret = EAI_NONAME;
 336     int error;
 337
 338     if (hints != NULL) {
 339         family = hints->ai_family;
 340         flags  = hints->ai_flags;
 341     }
 342
 343 #ifdef HAVE_IPV6
 344     if (family == PF_INET6 || family == PF_UNSPEC) {
 345         struct hostent *he;
 346
 347         he = getipnodebyname (nodename, PF_INET6, 0, &error);
 348
 349         if (he != NULL) {
 350             ret = add_hostent (port, protocol, socktype,
 351                                &current, const_v6, he, &flags);
 352             freehostent (he);
 353         }
 354     }
 355 #endif
 356     if (family == PF_INET || family == PF_UNSPEC) {
 357         struct hostent *he;
 358
 359         he = getipnodebyname (nodename, PF_INET, 0, &error);
 360
 361         if (he != NULL) {
 362             ret = add_hostent (port, protocol, socktype,
 363                                &current, const_v4, he, &flags);
 364             freehostent (he);
 365         }
 366     }
 367     *res = first;
 368     return ret;
 369 }
 370
 371 /*
 372  * hints:
 373  *
 374  * struct addrinfo {
 375  *     int    ai_flags;
 376  *     int    ai_family;
 377  *     int    ai_socktype;
 378  *     int    ai_protocol;
 379  * ...
 380  * };
 381  */
 382
 383 int
 384 getaddrinfo(const char *nodename,
 385             const char *servname,
 386             const struct addrinfo *hints,
 387             struct addrinfo **res)
 388 {
 389     int ret;
 390     int port     = 0;
 391     int protocol = 0;
 392     int socktype = 0;
 393
 394     *res = NULL;
 395
 396     if (servname == NULL && nodename == NULL)
 397         return EAI_NONAME;
 398
 399     if (hints != NULL
 400         && hints->ai_family != PF_UNSPEC
 401         && hints->ai_family != PF_INET
 402 #ifdef HAVE_IPV6
 403         && hints->ai_family != PF_INET6
 404 #endif
 405         )
 406         return EAI_FAMILY;
 407
 408     if (servname != NULL) {
 409         ret = get_port_protocol_socktype (servname, hints,
 410                                           &port, &protocol, &socktype);
 411         if (ret)
 412             return ret;
 413     }
 414     if (nodename != NULL) {
 415         ret = get_number (nodename, hints, port, protocol, socktype, res);
 416         if (ret) {
 417             if(hints && hints->ai_flags & AI_NUMERICHOST)
 418                 ret = EAI_NONAME;
 419             else
 420                 ret = get_nodes (nodename, hints, port, protocol, socktype,
 421                                  res);
 422         }
 423     } else {
 424         ret = get_null (hints, port, protocol, socktype, res);
 425     }
 426     if (ret)
 427         freeaddrinfo (*res);
 428     return ret;
 429 }