| /* Copyright (c) 2015 Google, Inc. |
| * Barret Rhoden <brho@cs.berkeley.edu> |
| * See LICENSE for details. |
| * |
| * getaddrinfo/freeaddrinfo. |
| * |
| * Supports IPv4, TCP, UDP, and maybe a couple protocols/socktypes. |
| * |
| * Doesn't handle service resolution yet, and only returns one addrinfo. |
| */ |
| |
| #include <netdb.h> |
| #include <malloc.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <arpa/inet.h> |
| #include <netinet/in.h> |
| #include <unistd.h> |
| |
| /* Helper, given the serv string, figures out the port and protocol. Returns 0 |
| * on success or an EAI_ error. */ |
| static int serv_get_portprotocol(const char *serv, unsigned long *port_ret, |
| int *protocol_ret, struct addrinfo *hints) |
| { |
| char *strtoul_end = 0; |
| unsigned long port = 0; /* uninitialized, up to the main caller */ |
| int protocol = 0; /* any protocol, will assume TCP/UDP later */ |
| |
| if (serv) { |
| if (serv[0] == '\0') |
| return EAI_NONAME; |
| port = strtoul(serv, &strtoul_end, 0); |
| /* Already checked that serv != \0 */ |
| if (*strtoul_end != '\0') { |
| if (hints->ai_flags & AI_NUMERICSERV) |
| return EAI_NONAME; |
| /* CS lookup */ |
| /* TODO: get a port, maybe a protocol. If we have a |
| * restriction on the protocol from hints, check that |
| * here. Probably need to rework this a bit if we have |
| * multiple protocols. */ |
| return EAI_NONAME; |
| } |
| } |
| *port_ret = port; |
| *protocol_ret = protocol; |
| return 0; |
| } |
| |
| /* Helper: fills in all of the addr related info in ai for an ipv4 addr/port. |
| * addr is in network order. port is in host order. */ |
| static void addrinfo_filladdr_ipv4(struct addrinfo *ai, in_addr_t addr, |
| uint16_t port) |
| { |
| struct sockaddr_in *sa_in4 = (struct sockaddr_in*)ai->ai_addr; |
| ai->ai_family = AF_INET; |
| ai->ai_addrlen = sizeof(struct sockaddr_in); |
| sa_in4->sin_family = AF_INET; |
| sa_in4->sin_addr.s_addr = addr; |
| sa_in4->sin_port = htons(port); |
| } |
| |
| static int resolve_name_to_ipv4(const char *name, struct in_addr *hostaddr) |
| { |
| struct hostent host, *result; |
| char buf[1024]; |
| int _herrno; |
| int ret; |
| ret = gethostbyname2_r(name, AF_INET, &host, buf, sizeof(buf), |
| &result, &_herrno); |
| /* TODO: deal with the herrno errors and errno errors. */ |
| if (ret) |
| return -1; |
| assert(result == &host); |
| memcpy(hostaddr, host.h_addr_list[0], host.h_length); |
| return 0; |
| } |
| |
| /* Given the node string, fills in the addr related info in ai: the ai_family, |
| * ai_addr, and ai_addrlen. The ai_addr needs the port too, though that's a big |
| * ugly. We only support ipv4, so there's just one of these. Returns 0 on |
| * success, EAI_ error o/w. */ |
| static int node_fill_addrinfo(const char *node, struct addrinfo *ai, |
| uint16_t port, struct addrinfo *hints) |
| { |
| struct in_addr local_addr; |
| if (!node) { |
| /* AI_PASSIVE only matters with no node name */ |
| if (hints->ai_flags & AI_PASSIVE) { |
| /* Caller wants to bind */ |
| addrinfo_filladdr_ipv4(ai, INADDR_ANY, port); |
| } else { |
| /* Caller wants to send from localhost */ |
| addrinfo_filladdr_ipv4(ai, INADDR_LOOPBACK, port); |
| } |
| } else { |
| if (inet_pton(AF_INET, node, &local_addr) == 1) { |
| addrinfo_filladdr_ipv4(ai, local_addr.s_addr, port); |
| } else { |
| if (hints->ai_flags & AI_NUMERICHOST) |
| return EAI_NONAME; |
| if (resolve_name_to_ipv4(node, &local_addr)) |
| return EAI_FAIL; |
| addrinfo_filladdr_ipv4(ai, local_addr.s_addr, port); |
| } |
| } |
| return 0; |
| } |
| |
| static int proto_to_socktype(int protocol) |
| { |
| switch (protocol) { |
| case IPPROTO_IP: |
| case IPPROTO_TCP: |
| return SOCK_STREAM; |
| case IPPROTO_ICMP: |
| case IPPROTO_UDP: |
| return SOCK_DGRAM; |
| case IPPROTO_RAW: |
| return SOCK_RAW; |
| } |
| return -1; |
| } |
| |
| static int socktype_to_proto(int socktype) |
| { |
| switch (socktype) { |
| case SOCK_STREAM: |
| return IPPROTO_TCP; |
| case SOCK_DGRAM: |
| return IPPROTO_UDP; |
| case SOCK_RAW: |
| return IPPROTO_RAW; |
| } |
| return -1; |
| } |
| |
| int getaddrinfo(const char *node, const char *serv, |
| const struct addrinfo *hints, struct addrinfo **res) |
| { |
| struct addrinfo *ai; |
| struct addrinfo local_hints; |
| |
| local_hints.ai_socktype = 0; |
| local_hints.ai_protocol = 0; |
| local_hints.ai_family = AF_UNSPEC; |
| local_hints.ai_flags = AI_V4MAPPED | AI_ADDRCONFIG; |
| |
| unsigned long port = 0; /* AF agnostic, hope a long is enough */ |
| int protocol = 0; |
| int ret; |
| |
| if (hints) |
| local_hints = *hints; |
| |
| if (!node && !serv) |
| return EAI_NONAME; |
| |
| /* Only support IPv4 for now */ |
| if ((local_hints.ai_family != AF_UNSPEC) && |
| (local_hints.ai_family != AF_INET)) |
| return EAI_FAMILY; |
| |
| ai = malloc(sizeof(struct addrinfo)); |
| memset(ai, 0, sizeof(struct addrinfo)); |
| ai->ai_addr = malloc(sizeof(struct sockaddr_storage)); |
| memset(ai->ai_addr, 0, sizeof(struct sockaddr_storage)); |
| |
| /* Only supporting TCP and UDP for now. If protocol is 0, later we'll |
| * make addrinfos for both (TODO). Likewise, we only support DGRAM or |
| * STREAM for socktype. */ |
| if ((ret = serv_get_portprotocol(serv, &port, &protocol, &local_hints))) |
| { |
| freeaddrinfo(ai); |
| return ret; |
| } |
| if ((ret = node_fill_addrinfo(node, ai, port, &local_hints))) { |
| freeaddrinfo(ai); |
| return ret; |
| } |
| /* We have a mostly full addrinfo. Still missing ai_protocol, socktype, |
| * flags (already 0) and canonname (already 0). |
| * |
| * We might have restrictions on our protocol from the hints or from |
| * what serv specifies. If we don't have a protocol yet (== 0), that |
| * means we have no restrictions from serv. */ |
| if (local_hints.ai_protocol) { |
| if (protocol && protocol != local_hints.ai_protocol) { |
| /* requested protocol wasn't available */ |
| freeaddrinfo(ai); |
| return EAI_SERVICE; |
| } |
| ai->ai_protocol = local_hints.ai_protocol; |
| } else if (protocol) { |
| ai->ai_protocol = protocol; |
| } else if (local_hints.ai_socktype) { |
| ai->ai_protocol = socktype_to_proto(local_hints.ai_socktype); |
| } else { |
| /* no serv restrictions, no preferences */ |
| ai->ai_protocol = IPPROTO_TCP; |
| /* TODO: consider building a second addrinfo for UDP. while |
| * you're at it, support IPv6 and a bunch of other options! */ |
| } |
| if (ai->ai_protocol == -1) { |
| freeaddrinfo(ai); |
| return EAI_SERVICE; |
| } |
| ai->ai_socktype = proto_to_socktype(ai->ai_protocol); |
| if (local_hints.ai_socktype && |
| (local_hints.ai_socktype != ai->ai_socktype)) { |
| /* they requested a socktype, but we can't handle it */ |
| freeaddrinfo(ai); |
| return EAI_SOCKTYPE; |
| } |
| /* TODO: support AI_CANONNAME, only in the first ai */ |
| *res = ai; |
| return 0; |
| } |
| libc_hidden_def(getaddrinfo) |
| |
| void freeaddrinfo(struct addrinfo *ai) |
| { |
| struct addrinfo *next; |
| |
| if (!ai) |
| return; |
| free(ai->ai_addr); |
| free(ai->ai_canonname); |
| next = ai->ai_next; |
| free(ai); |
| freeaddrinfo(next); |
| } |
| libc_hidden_def(freeaddrinfo) |
