Annotation of embedaddon/sudo/compat/getaddrinfo.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Replacement for a missing getaddrinfo.
! 3: *
! 4: * This is an implementation of getaddrinfo for systems that don't have one so
! 5: * that networking code can use a consistant interface without #ifdef. It is
! 6: * a fairly minimal implementation, with the following limitations:
! 7: *
! 8: * - IPv4 support only. IPv6 is not supported.
! 9: * - AI_ADDRCONFIG is ignored.
! 10: * - Not thread-safe due to gethostbyname and getservbyname.
! 11: * - SOCK_DGRAM and SOCK_STREAM only.
! 12: * - Multiple possible socket types only generate one addrinfo struct.
! 13: * - Protocol hints aren't used correctly.
! 14: *
! 15: * The last four issues could probably be easily remedied, but haven't been
! 16: * needed to date. Adding IPv6 support isn't worth it; systems with IPv6
! 17: * support should already support getaddrinfo natively.
! 18: *
! 19: * The canonical version of this file is maintained in the rra-c-util package,
! 20: * which can be found at <http://www.eyrie.org/~eagle/software/rra-c-util/>.
! 21: *
! 22: * Written by Russ Allbery <rra@stanford.edu>
! 23: *
! 24: * The authors hereby relinquish any claim to any copyright that they may have
! 25: * in this work, whether granted under contract or by operation of law or
! 26: * international treaty, and hereby commit to the public, at large, that they
! 27: * shall not, at any time in the future, seek to enforce any copyright in this
! 28: * work against any person or entity, or prevent any person or entity from
! 29: * copying, publishing, distributing or creating derivative works of this
! 30: * work.
! 31: */
! 32:
! 33: #include <config.h>
! 34:
! 35: #include <sys/types.h>
! 36: #include <sys/socket.h>
! 37:
! 38: #include <stdio.h>
! 39: #ifdef STDC_HEADERS
! 40: # include <stdlib.h>
! 41: # include <stddef.h>
! 42: #else
! 43: # ifdef HAVE_STDLIB_H
! 44: # include <stdlib.h>
! 45: # endif
! 46: #endif /* STDC_HEADERS */
! 47: #ifdef HAVE_STRING_H
! 48: # include <string.h>
! 49: #endif /* HAVE_STRING_H */
! 50: #ifdef HAVE_STRINGS_H
! 51: # include <strings.h>
! 52: #endif /* HAVE_STRINGS_H */
! 53: #include <netdb.h>
! 54: #include <errno.h>
! 55:
! 56: #include <netinet/in.h>
! 57:
! 58: #include "compat/getaddrinfo.h"
! 59: #include "missing.h"
! 60:
! 61: /* We need access to h_errno to map errors from gethostbyname. */
! 62: #if !HAVE_DECL_H_ERRNO
! 63: extern int h_errno;
! 64: #endif
! 65:
! 66: /*
! 67: * The netdb constants, which aren't always defined (particularly if h_errno
! 68: * isn't declared). We also make sure that a few of the less-used ones are
! 69: * defined so that we can deal with them in case statements.
! 70: */
! 71: #ifndef HOST_NOT_FOUND
! 72: # define HOST_NOT_FOUND 1
! 73: # define TRY_AGAIN 2
! 74: # define NO_RECOVERY 3
! 75: # define NO_DATA 4
! 76: #endif
! 77: #ifndef NETDB_INTERNAL
! 78: # define NETDB_INTERNAL -1
! 79: #endif
! 80:
! 81: /*
! 82: * If we're running the test suite, rename the functions to avoid conflicts
! 83: * with the system version. Note that we don't rename the structures and
! 84: * constants, but that should be okay (except possibly for gai_strerror).
! 85: */
! 86: #if TESTING
! 87: # define gai_strerror test_gai_strerror
! 88: # define freeaddrinfo test_freeaddrinfo
! 89: # define getaddrinfo test_getaddrinfo
! 90: const char *test_gai_strerror(int);
! 91: void test_freeaddrinfo(struct addrinfo *);
! 92: int test_getaddrinfo(const char *, const char *, const struct addrinfo *,
! 93: struct addrinfo **);
! 94: #endif
! 95:
! 96: /*
! 97: * If the native platform doesn't support AI_NUMERICSERV or AI_NUMERICHOST,
! 98: * pick some other values for them.
! 99: */
! 100: #if TESTING
! 101: # if AI_NUMERICSERV == 0
! 102: # undef AI_NUMERICSERV
! 103: # define AI_NUMERICSERV 0x0080
! 104: # endif
! 105: # if AI_NUMERICHOST == 0
! 106: # undef AI_NUMERICHOST
! 107: # define AI_NUMERICHOST 0x0100
! 108: # endif
! 109: #endif
! 110:
! 111: /*
! 112: * Value representing all of the hint flags set. Linux uses flags up to
! 113: * 0x0400, so be sure not to break when testing on that platform.
! 114: */
! 115: #if TESTING
! 116: # ifdef HAVE_GETADDRINFO
! 117: # define AI_INTERNAL_ALL 0x04ff
! 118: # else
! 119: # define AI_INTERNAL_ALL 0x01ff
! 120: # endif
! 121: #else
! 122: # define AI_INTERNAL_ALL 0x007f
! 123: #endif
! 124:
! 125: /* Table of strings corresponding to the EAI_* error codes. */
! 126: static const char * const gai_errors[] = {
! 127: "Host name lookup failure", /* 1 EAI_AGAIN */
! 128: "Invalid flag value", /* 2 EAI_BADFLAGS */
! 129: "Unknown server error", /* 3 EAI_FAIL */
! 130: "Unsupported address family", /* 4 EAI_FAMILY */
! 131: "Memory allocation failure", /* 5 EAI_MEMORY */
! 132: "Host unknown or not given", /* 6 EAI_NONAME */
! 133: "Service not supported for socket", /* 7 EAI_SERVICE */
! 134: "Unsupported socket type", /* 8 EAI_SOCKTYPE */
! 135: "System error", /* 9 EAI_SYSTEM */
! 136: "Supplied buffer too small", /* 10 EAI_OVERFLOW */
! 137: };
! 138:
! 139: /* Macro to set the len attribute of sockaddr_in. */
! 140: #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
! 141: # define sin_set_length(s) ((s)->sin_len = sizeof(struct sockaddr_in))
! 142: #else
! 143: # define sin_set_length(s) /* empty */
! 144: #endif
! 145:
! 146: /*
! 147: * Used for iterating through arrays. ARRAY_SIZE returns the number of
! 148: * elements in the array (useful for a < upper bound in a for loop).
! 149: */
! 150: #define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
! 151:
! 152:
! 153: /*
! 154: * Return a constant string for a given EAI_* error code or a string
! 155: * indicating an unknown error.
! 156: */
! 157: const char *
! 158: gai_strerror(int ecode)
! 159: {
! 160: if (ecode < 1 || (size_t) ecode > ARRAY_SIZE(gai_errors))
! 161: return "Unknown error";
! 162: else
! 163: return gai_errors[ecode - 1];
! 164: }
! 165:
! 166:
! 167: /*
! 168: * Free a linked list of addrinfo structs.
! 169: */
! 170: void
! 171: freeaddrinfo(struct addrinfo *ai)
! 172: {
! 173: struct addrinfo *next;
! 174:
! 175: while (ai != NULL) {
! 176: next = ai->ai_next;
! 177: if (ai->ai_addr != NULL)
! 178: free(ai->ai_addr);
! 179: if (ai->ai_canonname != NULL)
! 180: free(ai->ai_canonname);
! 181: free(ai);
! 182: ai = next;
! 183: }
! 184: }
! 185:
! 186:
! 187: /*
! 188: * Convert a numeric service string to a number with error checking, returning
! 189: * true if the number was parsed correctly and false otherwise. Stores the
! 190: * converted number in the second argument. Equivalent to calling strtol, but
! 191: * with the base always fixed at 10, with checking of errno, ensuring that all
! 192: * of the string is consumed, and checking that the resulting number is
! 193: * positive.
! 194: */
! 195: static int
! 196: convert_service(const char *string, long *result)
! 197: {
! 198: char *end;
! 199:
! 200: if (*string == '\0')
! 201: return 0;
! 202: errno = 0;
! 203: *result = strtol(string, &end, 10);
! 204: if (errno != 0 || *end != '\0' || *result < 0)
! 205: return 0;
! 206: return 1;
! 207: }
! 208:
! 209:
! 210: /*
! 211: * Allocate a new addrinfo struct, setting some defaults given that this
! 212: * implementation is IPv4 only. Also allocates an attached sockaddr_in and
! 213: * zeroes it, per the requirement for getaddrinfo. Takes the socktype,
! 214: * canonical name (which is copied if not NULL), address, and port. Returns
! 215: * NULL on a memory allocation failure.
! 216: */
! 217: static struct addrinfo *
! 218: gai_addrinfo_new(int socktype, const char *canonical, struct in_addr addr,
! 219: unsigned short port)
! 220: {
! 221: struct addrinfo *ai;
! 222:
! 223: ai = malloc(sizeof(*ai));
! 224: if (ai == NULL)
! 225: return NULL;
! 226: ai->ai_addr = malloc(sizeof(struct sockaddr_in));
! 227: if (ai->ai_addr == NULL) {
! 228: free(ai);
! 229: return NULL;
! 230: }
! 231: ai->ai_next = NULL;
! 232: if (canonical == NULL)
! 233: ai->ai_canonname = NULL;
! 234: else {
! 235: ai->ai_canonname = strdup(canonical);
! 236: if (ai->ai_canonname == NULL) {
! 237: freeaddrinfo(ai);
! 238: return NULL;
! 239: }
! 240: }
! 241: memset(ai->ai_addr, 0, sizeof(struct sockaddr_in));
! 242: ai->ai_flags = 0;
! 243: ai->ai_family = AF_INET;
! 244: ai->ai_socktype = socktype;
! 245: ai->ai_protocol = (socktype == SOCK_DGRAM) ? IPPROTO_UDP : IPPROTO_TCP;
! 246: ai->ai_addrlen = sizeof(struct sockaddr_in);
! 247: ((struct sockaddr_in *) ai->ai_addr)->sin_family = AF_INET;
! 248: ((struct sockaddr_in *) ai->ai_addr)->sin_addr = addr;
! 249: ((struct sockaddr_in *) ai->ai_addr)->sin_port = htons(port);
! 250: sin_set_length((struct sockaddr_in *) ai->ai_addr);
! 251: return ai;
! 252: }
! 253:
! 254:
! 255: /*
! 256: * Look up a service. Takes the service name (which may be numeric), the hint
! 257: * flags, a pointer to the socket type (used to determine whether TCP or UDP
! 258: * services are of interest and, if 0, is filled in with the result of
! 259: * getservbyname if the service was not numeric), and a pointer to the
! 260: * addrinfo struct to fill in. Returns 0 on success or an EAI_* error on
! 261: * failure.
! 262: */
! 263: static int
! 264: gai_service(const char *servname, int flags, int *type, unsigned short *port)
! 265: {
! 266: struct servent *servent;
! 267: const char *protocol;
! 268: long value;
! 269:
! 270: if (convert_service(servname, &value)) {
! 271: if (value > (1L << 16) - 1)
! 272: return EAI_SERVICE;
! 273: *port = value;
! 274: } else {
! 275: if (flags & AI_NUMERICSERV)
! 276: return EAI_NONAME;
! 277: if (*type != 0)
! 278: protocol = (*type == SOCK_DGRAM) ? "udp" : "tcp";
! 279: else
! 280: protocol = NULL;
! 281:
! 282: /*
! 283: * We really technically should be generating an addrinfo struct for
! 284: * each possible protocol unless type is set, but this works well
! 285: * enough for what I need this for.
! 286: */
! 287: servent = getservbyname(servname, protocol);
! 288: if (servent == NULL)
! 289: return EAI_NONAME;
! 290: if (strcmp(servent->s_proto, "udp") == 0)
! 291: *type = SOCK_DGRAM;
! 292: else if (strcmp(servent->s_proto, "tcp") == 0)
! 293: *type = SOCK_STREAM;
! 294: else
! 295: return EAI_SERVICE;
! 296: *port = htons(servent->s_port);
! 297: }
! 298: return 0;
! 299: }
! 300:
! 301:
! 302: /*
! 303: * Look up a host and fill in a linked list of addrinfo structs with the
! 304: * results, one per IP address of the returned host. Takes the name or IP
! 305: * address of the host as a string, the lookup flags, the type of socket (to
! 306: * fill into the addrinfo structs), the port (likewise), and a pointer to
! 307: * where the head of the linked list should be put. Returns 0 on success or
! 308: * the appropriate EAI_* error.
! 309: */
! 310: static int
! 311: gai_lookup(const char *nodename, int flags, int socktype, unsigned short port,
! 312: struct addrinfo **res)
! 313: {
! 314: struct addrinfo *ai, *first, *prev;
! 315: struct in_addr addr;
! 316: struct hostent *host;
! 317: const char *canonical;
! 318: int i;
! 319:
! 320: if (inet_aton(nodename, &addr)) {
! 321: canonical = (flags & AI_CANONNAME) ? nodename : NULL;
! 322: ai = gai_addrinfo_new(socktype, canonical, addr, port);
! 323: if (ai == NULL)
! 324: return EAI_MEMORY;
! 325: *res = ai;
! 326: return 0;
! 327: } else {
! 328: if (flags & AI_NUMERICHOST)
! 329: return EAI_NONAME;
! 330: host = gethostbyname(nodename);
! 331: if (host == NULL)
! 332: switch (h_errno) {
! 333: case HOST_NOT_FOUND:
! 334: return EAI_NONAME;
! 335: case TRY_AGAIN:
! 336: case NO_DATA:
! 337: return EAI_AGAIN;
! 338: case NO_RECOVERY:
! 339: return EAI_FAIL;
! 340: case NETDB_INTERNAL:
! 341: default:
! 342: return EAI_SYSTEM;
! 343: }
! 344: if (host->h_addr_list[0] == NULL)
! 345: return EAI_FAIL;
! 346: canonical = (flags & AI_CANONNAME)
! 347: ? ((host->h_name != NULL) ? host->h_name : nodename)
! 348: : NULL;
! 349: first = NULL;
! 350: prev = NULL;
! 351: for (i = 0; host->h_addr_list[i] != NULL; i++) {
! 352: if (host->h_length != sizeof(addr)) {
! 353: freeaddrinfo(first);
! 354: return EAI_FAIL;
! 355: }
! 356: memcpy(&addr, host->h_addr_list[i], sizeof(addr));
! 357: ai = gai_addrinfo_new(socktype, canonical, addr, port);
! 358: if (ai == NULL) {
! 359: freeaddrinfo(first);
! 360: return EAI_MEMORY;
! 361: }
! 362: if (first == NULL) {
! 363: first = ai;
! 364: prev = ai;
! 365: } else {
! 366: prev->ai_next = ai;
! 367: prev = ai;
! 368: }
! 369: }
! 370: *res = first;
! 371: return 0;
! 372: }
! 373: }
! 374:
! 375:
! 376: /*
! 377: * The actual getaddrinfo implementation.
! 378: */
! 379: int
! 380: getaddrinfo(const char *nodename, const char *servname,
! 381: const struct addrinfo *hints, struct addrinfo **res)
! 382: {
! 383: struct addrinfo *ai;
! 384: struct in_addr addr;
! 385: int flags, socktype, status;
! 386: unsigned short port;
! 387:
! 388: /* Take the hints into account and check them for validity. */
! 389: if (hints != NULL) {
! 390: flags = hints->ai_flags;
! 391: socktype = hints->ai_socktype;
! 392: if ((flags & AI_INTERNAL_ALL) != flags)
! 393: return EAI_BADFLAGS;
! 394: if (hints->ai_family != AF_UNSPEC && hints->ai_family != AF_INET)
! 395: return EAI_FAMILY;
! 396: if (socktype != 0 && socktype != SOCK_STREAM && socktype != SOCK_DGRAM)
! 397: return EAI_SOCKTYPE;
! 398:
! 399: /* EAI_SOCKTYPE isn't quite right, but there isn't anything better. */
! 400: if (hints->ai_protocol != 0) {
! 401: int protocol = hints->ai_protocol;
! 402: if (protocol != IPPROTO_TCP && protocol != IPPROTO_UDP)
! 403: return EAI_SOCKTYPE;
! 404: }
! 405: } else {
! 406: flags = 0;
! 407: socktype = 0;
! 408: }
! 409:
! 410: /*
! 411: * See what we're doing. If nodename is null, either AI_PASSIVE is set or
! 412: * we're getting information for connecting to a service on the loopback
! 413: * address. Otherwise, we're getting information for connecting to a
! 414: * remote system.
! 415: */
! 416: if (servname == NULL)
! 417: port = 0;
! 418: else {
! 419: status = gai_service(servname, flags, &socktype, &port);
! 420: if (status != 0)
! 421: return status;
! 422: }
! 423: if (nodename != NULL)
! 424: return gai_lookup(nodename, flags, socktype, port, res);
! 425: else {
! 426: if (servname == NULL)
! 427: return EAI_NONAME;
! 428: if ((flags & AI_PASSIVE) == AI_PASSIVE)
! 429: addr.s_addr = INADDR_ANY;
! 430: else
! 431: addr.s_addr = htonl(0x7f000001UL);
! 432: ai = gai_addrinfo_new(socktype, NULL, addr, port);
! 433: if (ai == NULL)
! 434: return EAI_MEMORY;
! 435: *res = ai;
! 436: return 0;
! 437: }
! 438: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to getaddrinfo.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / compat