crypto/heimdal/lib/roken/getaddrinfo.c

   1 /*
   2  * Copyright (c) 1999 - 2001 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 #include <config.h>
  35
  36 #include "roken.h"
  37
  38 /*
  39  * uses hints->ai_socktype and hints->ai_protocol
  40  */
  41
  42 static int
  43 get_port_protocol_socktype (const char *servname,
  44                             const struct addrinfo *hints,
  45                             int *port,
  46                             int *protocol,
  47                             int *socktype)
  48 {
  49     struct servent *se;
  50     const char *proto_str = NULL;
  51
  52     *socktype = 0;
  53
  54     if (hints != NULL && hints->ai_protocol != 0) {
  55         struct protoent *protoent = getprotobynumber (hints->ai_protocol);
  56
  57         if (protoent == NULL)
  58             return EAI_SOCKTYPE; /* XXX */
  59
  60         proto_str = protoent->p_name;
  61         *protocol = protoent->p_proto;
  62     }
  63
  64     if (hints != NULL)
  65         *socktype = hints->ai_socktype;
  66
  67     if (*socktype == SOCK_STREAM) {
  68         se = getservbyname (servname, proto_str ? proto_str : "tcp");
  69         if (proto_str == NULL)
  70             *protocol = IPPROTO_TCP;
  71     } else if (*socktype == SOCK_DGRAM) {
  72         se = getservbyname (servname, proto_str ? proto_str : "udp");
  73         if (proto_str == NULL)
  74             *protocol = IPPROTO_UDP;
  75     } else if (*socktype == 0) {
  76         if (proto_str != NULL) {
  77             se = getservbyname (servname, proto_str);
  78         } else {
  79             se = getservbyname (servname, "tcp");
  80             *protocol = IPPROTO_TCP;
  81             *socktype = SOCK_STREAM;
  82             if (se == NULL) {
  83                 se = getservbyname (servname, "udp");
  84                 *protocol = IPPROTO_UDP;
  85                 *socktype = SOCK_DGRAM;
  86             }
  87         }
  88     } else
  89         return EAI_SOCKTYPE;
  90
  91     if (se == NULL) {
  92         char *endstr;
  93
  94         *port = htons(strtol (servname, &endstr, 10));
  95         if (servname == endstr)
  96             return EAI_NONAME;
  97     } else {
  98         *port = se->s_port;
  99     }
 100     return 0;
 101 }
 102
 103 static int
 104 add_one (int port, int protocol, int socktype,
 105          struct addrinfo ***ptr,
 106          int (*func)(struct addrinfo *, void *data, int port),
 107          void *data,
 108          char *canonname)
 109 {
 110     struct addrinfo *a;
 111     int ret;
 112
 113     a = malloc (sizeof (*a));
 114     if (a == NULL)
 115         return EAI_MEMORY;
 116     memset (a, 0, sizeof(*a));
 117     a->ai_flags     = 0;
 118     a->ai_next      = NULL;
 119     a->ai_protocol  = protocol;
 120     a->ai_socktype  = socktype;
 121     a->ai_canonname = canonname;
 122     ret = (*func)(a, data, port);
 123     if (ret) {
 124         free (a);
 125         return ret;
 126     }
 127     **ptr = a;
 128     *ptr = &a->ai_next;
 129     return 0;
 130 }
 131
 132 static int
 133 const_v4 (struct addrinfo *a, void *data, int port)
 134 {
 135     struct sockaddr_in *sin4;
 136     struct in_addr *addr = (struct in_addr *)data;
 137
 138     a->ai_family  = PF_INET;
 139     a->ai_addrlen = sizeof(*sin4);
 140     a->ai_addr    = malloc (sizeof(*sin4));
 141     if (a->ai_addr == NULL)
 142         return EAI_MEMORY;
 143     sin4 = (struct sockaddr_in *)a->ai_addr;
 144     memset (sin4, 0, sizeof(*sin4));
 145     sin4->sin_family = AF_INET;
 146     sin4->sin_port   = port;
 147     sin4->sin_addr   = *addr;
 148     return 0;
 149 }
 150
 151 #ifdef HAVE_IPV6
 152 static int
 153 const_v6 (struct addrinfo *a, void *data, int port)
 154 {
 155     struct sockaddr_in6 *sin6;
 156     struct in6_addr *addr = (struct in6_addr *)data;
 157
 158     a->ai_family  = PF_INET6;
 159     a->ai_addrlen = sizeof(*sin6);
 160     a->ai_addr    = malloc (sizeof(*sin6));
 161     if (a->ai_addr == NULL)
 162         return EAI_MEMORY;
 163     sin6 = (struct sockaddr_in6 *)a->ai_addr;
 164     memset (sin6, 0, sizeof(*sin6));
 165     sin6->sin6_family = AF_INET6;
 166     sin6->sin6_port   = port;
 167     sin6->sin6_addr   = *addr;
 168     return 0;
 169 }
 170 #endif
 171
 172 /* this is mostly a hack for some versions of AIX that has a prototype
 173    for in6addr_loopback but no actual symbol in libc */
 174 #if defined(HAVE_IPV6) && !defined(HAVE_IN6ADDR_LOOPBACK) && defined(IN6ADDR_LOOPBACK_INIT)
 175 #define in6addr_loopback _roken_in6addr_loopback
 176 struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT;
 177 #endif
 178
 179 static int
 180 get_null (const struct addrinfo *hints,
 181           int port, int protocol, int socktype,
 182           struct addrinfo **res)
 183 {
 184     struct in_addr v4_addr;
 185 #ifdef HAVE_IPV6
 186     struct in6_addr v6_addr;
 187 #endif
 188     struct addrinfo *first = NULL;
 189     struct addrinfo **current = &first;
 190     int family = PF_UNSPEC;
 191     int ret = 0;
 192
 193     if (hints != NULL)
 194         family = hints->ai_family;
 195
 196     if (hints && hints->ai_flags & AI_PASSIVE) {
 197         v4_addr.s_addr = INADDR_ANY;
 198 #ifdef HAVE_IPV6
 199         v6_addr        = in6addr_any;
 200 #endif
 201     } else {
 202         v4_addr.s_addr = htonl(INADDR_LOOPBACK);
 203 #ifdef HAVE_IPV6
 204         v6_addr        = in6addr_loopback;
 205 #endif
 206     }
 207
 208 #ifdef HAVE_IPV6
 209     if (family == PF_INET6 || family == PF_UNSPEC) {
 210         ret = add_one (port, protocol, socktype,
 211                        &current, const_v6, &v6_addr, NULL);
 212         if (ret)
 213             return ret;
 214     }
 215 #endif
 216     if (family == PF_INET || family == PF_UNSPEC) {
 217         ret = add_one (port, protocol, socktype,
 218                        &current, const_v4, &v4_addr, NULL);
 219     }
 220     *res = first;
 221     return ret;
 222 }
 223
 224 static int
 225 add_hostent (int port, int protocol, int socktype,
 226              struct addrinfo ***current,
 227              int (*func)(struct addrinfo *, void *data, int port),
 228              struct hostent *he, int *flags)
 229 {
 230     int ret;
 231     char *canonname = NULL;
 232     char **h;
 233
 234     if (*flags & AI_CANONNAME) {
 235         struct hostent *he2 = NULL;
 236         const char *tmp_canon;
 237
 238         tmp_canon = hostent_find_fqdn (he);
 239         if (strchr (tmp_canon, '.') == NULL) {
 240             int error;
 241
 242             he2 = getipnodebyaddr (he->h_addr_list[0], he->h_length,
 243                                    he->h_addrtype, &error);
 244             if (he2 != NULL) {
 245                 const char *tmp = hostent_find_fqdn (he2);
 246
 247                 if (strchr (tmp, '.') != NULL)
 248                     tmp_canon = tmp;
 249             }
 250         }
 251
 252         canonname = strdup (tmp_canon);
 253         if (he2 != NULL)
 254             freehostent (he2);
 255         if (canonname == NULL)
 256             return EAI_MEMORY;
 257     }
 258
 259     for (h = he->h_addr_list; *h != NULL; ++h) {
 260         ret = add_one (port, protocol, socktype,
 261                        current, func, *h, canonname);
 262         if (ret)
 263             return ret;
 264         if (*flags & AI_CANONNAME) {
 265             *flags &= ~AI_CANONNAME;
 266             canonname = NULL;
 267         }
 268     }
 269     return 0;
 270 }
 271
 272 static int
 273 get_number (const char *nodename,
 274             const struct addrinfo *hints,
 275             int port, int protocol, int socktype,
 276             struct addrinfo **res)
 277 {
 278     struct addrinfo *first = NULL;
 279     struct addrinfo **current = &first;
 280     int family = PF_UNSPEC;
 281     int ret;
 282
 283     if (hints != NULL) {
 284         family = hints->ai_family;
 285     }
 286
 287 #ifdef HAVE_IPV6
 288     if (family == PF_INET6 || family == PF_UNSPEC) {
 289         struct in6_addr v6_addr;
 290
 291         if (inet_pton (PF_INET6, nodename, &v6_addr) == 1) {
 292             ret = add_one (port, protocol, socktype,
 293                            &current, const_v6, &v6_addr, NULL);
 294             *res = first;
 295             return ret;
 296         }
 297     }
 298 #endif
 299     if (family == PF_INET || family == PF_UNSPEC) {
 300         struct in_addr v4_addr;
 301
 302         if (inet_pton (PF_INET, nodename, &v4_addr) == 1) {
 303             ret = add_one (port, protocol, socktype,
 304                            &current, const_v4, &v4_addr, NULL);
 305             *res = first;
 306             return ret;
 307         }
 308     }
 309     return EAI_NONAME;
 310 }
 311
 312 static int
 313 get_nodes (const char *nodename,
 314            const struct addrinfo *hints,
 315            int port, int protocol, int socktype,
 316            struct addrinfo **res)
 317 {
 318     struct addrinfo *first = NULL;
 319     struct addrinfo **current = &first;
 320     int family = PF_UNSPEC;
 321     int flags  = 0;
 322     int ret = EAI_NONAME;
 323     int error;
 324
 325     if (hints != NULL) {
 326         family = hints->ai_family;
 327         flags  = hints->ai_flags;
 328     }
 329
 330 #ifdef HAVE_IPV6
 331     if (family == PF_INET6 || family == PF_UNSPEC) {
 332         struct hostent *he;
 333
 334         he = getipnodebyname (nodename, PF_INET6, 0, &error);
 335
 336         if (he != NULL) {
 337             ret = add_hostent (port, protocol, socktype,
 338                                &current, const_v6, he, &flags);
 339             freehostent (he);
 340         }
 341     }
 342 #endif
 343     if (family == PF_INET || family == PF_UNSPEC) {
 344         struct hostent *he;
 345
 346         he = getipnodebyname (nodename, PF_INET, 0, &error);
 347
 348         if (he != NULL) {
 349             ret = add_hostent (port, protocol, socktype,
 350                                &current, const_v4, he, &flags);
 351             freehostent (he);
 352         }
 353     }
 354     *res = first;
 355     return ret;
 356 }
 357
 358 /*
 359  * hints:
 360  *
 361  * struct addrinfo {
 362  *     int    ai_flags;
 363  *     int    ai_family;
 364  *     int    ai_socktype;
 365  *     int    ai_protocol;
 366  * ...
 367  * };
 368  */
 369
 370 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
 371 getaddrinfo(const char *nodename,
 372             const char *servname,
 373             const struct addrinfo *hints,
 374             struct addrinfo **res)
 375 {
 376     int ret;
 377     int port     = 0;
 378     int protocol = 0;
 379     int socktype = 0;
 380
 381     *res = NULL;
 382
 383     if (servname == NULL && nodename == NULL)
 384         return EAI_NONAME;
 385
 386     if (hints != NULL
 387         && hints->ai_family != PF_UNSPEC
 388         && hints->ai_family != PF_INET
 389 #ifdef HAVE_IPV6
 390         && hints->ai_family != PF_INET6
 391 #endif
 392         )
 393         return EAI_FAMILY;
 394
 395     if (servname != NULL) {
 396         ret = get_port_protocol_socktype (servname, hints,
 397                                           &port, &protocol, &socktype);
 398         if (ret)
 399             return ret;
 400     }
 401     if (nodename != NULL) {
 402         ret = get_number (nodename, hints, port, protocol, socktype, res);
 403         if (ret) {
 404             if(hints && hints->ai_flags & AI_NUMERICHOST)
 405                 ret = EAI_NONAME;
 406             else
 407                 ret = get_nodes (nodename, hints, port, protocol, socktype,
 408                                  res);
 409         }
 410     } else {
 411         ret = get_null (hints, port, protocol, socktype, res);
 412     }
 413     if (ret)
 414         freeaddrinfo (*res);
 415     return ret;
 416 }