crypto/heimdal/lib/roken/getaddrinfo.c

   1 /*
   2  * Copyright (c) 1999 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: getaddrinfo.c,v 1.6 1999/12/20 00:56:44 assar Exp $");
  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 static int
 219 add_hostent (int port, int protocol, int socktype,
 220              struct addrinfo ***current,
 221              int (*func)(struct addrinfo *, void *data, int port),
 222              struct hostent *he, int *flags)
 223 {
 224     char **h;
 225     int ret;
 226     char *canonname = NULL;
 227
 228     if (*flags & AI_CANONNAME) {
 229         canonname = he->h_name;
 230
 231         if (strchr (he->h_name, '.') == NULL)
 232             for (h = he->h_aliases; *h; ++h) {
 233                 if (strchr (*h, '.') != NULL) {
 234                     canonname = *h;
 235                     break;
 236                 }
 237             }
 238         canonname = strdup (canonname);
 239         if (canonname == NULL)
 240             return EAI_MEMORY;
 241     }
 242
 243     for (h = he->h_addr_list; *h != NULL; ++h) {
 244         ret = add_one (port, protocol, socktype,
 245                        current, func, *h, canonname);
 246         if (ret)
 247             return ret;
 248         if (*flags & AI_CANONNAME) {
 249             *flags &= ~AI_CANONNAME;
 250             canonname = NULL;
 251         }
 252     }
 253     return 0;
 254 }
 255
 256 static int
 257 get_number (const char *nodename,
 258             const struct addrinfo *hints,
 259             int port, int protocol, int socktype,
 260             struct addrinfo **res)
 261 {
 262     struct addrinfo *first = NULL;
 263     struct addrinfo **current = &first;
 264     int family = PF_UNSPEC;
 265     int ret;
 266
 267     if (hints != NULL) {
 268         family = hints->ai_family;
 269     }
 270
 271 #ifdef HAVE_IPV6
 272     if (family == PF_INET6 || family == PF_UNSPEC) {
 273         struct in6_addr v6_addr;
 274
 275         if (inet_pton (PF_INET6, nodename, &v6_addr) == 1) {
 276             ret = add_one (port, protocol, socktype,
 277                            &current, const_v6, &v6_addr, NULL);
 278             *res = first;
 279             return ret;
 280         }
 281     }
 282 #endif
 283     if (family == PF_INET || family == PF_UNSPEC) {
 284         struct in_addr v4_addr;
 285
 286         if (inet_pton (PF_INET, nodename, &v4_addr) == 1) {
 287             ret = add_one (port, protocol, socktype,
 288                            &current, const_v4, &v4_addr, NULL);
 289             *res = first;
 290             return ret;
 291         }
 292     }
 293     return EAI_NONAME;
 294 }
 295
 296 static int
 297 get_nodes (const char *nodename,
 298            const struct addrinfo *hints,
 299            int port, int protocol, int socktype,
 300            struct addrinfo **res)
 301 {
 302     struct addrinfo *first = NULL;
 303     struct addrinfo **current = &first;
 304     int family = PF_UNSPEC;
 305     int flags  = 0;
 306     int ret = EAI_NONAME;
 307     int error;
 308
 309     if (hints != NULL) {
 310         family = hints->ai_family;
 311         flags  = hints->ai_flags;
 312     }
 313
 314 #ifdef HAVE_IPV6
 315     if (family == PF_INET6 || family == PF_UNSPEC) {
 316         struct hostent *he;
 317
 318         he = getipnodebyname (nodename, PF_INET6, 0, &error);
 319
 320         if (he != NULL) {
 321             ret = add_hostent (port, protocol, socktype,
 322                                &current, const_v6, he, &flags);
 323             freehostent (he);
 324         }
 325     }
 326 #endif
 327     if (family == PF_INET || family == PF_UNSPEC) {
 328         struct hostent *he;
 329
 330         he = getipnodebyname (nodename, PF_INET, 0, &error);
 331
 332         if (he != NULL) {
 333             ret = add_hostent (port, protocol, socktype,
 334                                &current, const_v4, he, &flags);
 335             freehostent (he);
 336         }
 337     }
 338     *res = first;
 339     return ret;
 340 }
 341
 342 /*
 343  * hints:
 344  *
 345  * struct addrinfo {
 346  *     int    ai_flags;
 347  *     int    ai_family;
 348  *     int    ai_socktype;
 349  *     int    ai_protocol;
 350  * ...
 351  * };
 352  */
 353
 354 int
 355 getaddrinfo(const char *nodename,
 356             const char *servname,
 357             const struct addrinfo *hints,
 358             struct addrinfo **res)
 359 {
 360     int ret;
 361     int port     = 0;
 362     int protocol = 0;
 363     int socktype = 0;
 364
 365     *res = NULL;
 366
 367     if (servname == NULL && nodename == NULL)
 368         return EAI_NONAME;
 369
 370     if (hints != NULL
 371         && hints->ai_family != PF_UNSPEC
 372         && hints->ai_family != PF_INET
 373 #ifdef HAVE_IPV6
 374         && hints->ai_family != PF_INET6
 375 #endif
 376         )
 377         return EAI_FAMILY;
 378
 379     if (servname != NULL) {
 380         ret = get_port_protocol_socktype (servname, hints,
 381                                           &port, &protocol, &socktype);
 382         if (ret)
 383             return ret;
 384     }
 385     if (nodename != NULL) {
 386         ret = get_number (nodename, hints, port, protocol, socktype, res);
 387         if (ret) {
 388             if(hints && hints->ai_flags & AI_NUMERICHOST)
 389                 ret = EAI_NONAME;
 390             else
 391                 ret = get_nodes (nodename, hints, port, protocol, socktype,
 392                                  res);
 393         }
 394     } else {
 395         ret = get_null (hints, port, protocol, socktype, res);
 396     }
 397     if (ret)
 398         freeaddrinfo (*res);
 399     return ret;
 400 }