Home | History | Annotate | Download | only in nacl_io 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef __STDC_LIMIT_MACROS
      6 #define __STDC_LIMIT_MACROS
      7 #endif
      8 
      9 #include "nacl_io/host_resolver.h"
     10 
     11 #include <assert.h>
     12 #include <stdint.h>
     13 #include <stdlib.h>
     14 #include <string.h>
     15 
     16 #include "nacl_io/kernel_proxy.h"
     17 #include "nacl_io/log.h"
     18 #include "nacl_io/ossocket.h"
     19 #include "nacl_io/pepper_interface.h"
     20 
     21 #ifdef PROVIDES_SOCKET_API
     22 
     23 namespace {
     24 
     25 void HintsToPPHints(const addrinfo* hints, PP_HostResolver_Hint* pp_hints) {
     26   memset(pp_hints, 0, sizeof(*pp_hints));
     27 
     28   if (hints->ai_family == AF_INET)
     29     pp_hints->family = PP_NETADDRESS_FAMILY_IPV4;
     30   else if (hints->ai_family == AF_INET6)
     31     pp_hints->family = PP_NETADDRESS_FAMILY_IPV6;
     32 
     33   if (hints->ai_flags & AI_CANONNAME)
     34     pp_hints->flags = PP_HOSTRESOLVER_FLAG_CANONNAME;
     35 }
     36 
     37 void CreateAddrInfo(const addrinfo* hints,
     38                     struct sockaddr* addr,
     39                     const char* name,
     40                     addrinfo** list_start,
     41                     addrinfo** list_end) {
     42   addrinfo* ai = static_cast<addrinfo*>(malloc(sizeof(addrinfo)));
     43   memset(ai, 0, sizeof(*ai));
     44 
     45   if (hints && hints->ai_socktype)
     46     ai->ai_socktype = hints->ai_socktype;
     47   else
     48     ai->ai_socktype = SOCK_STREAM;
     49 
     50   if (hints && hints->ai_protocol)
     51     ai->ai_protocol = hints->ai_protocol;
     52 
     53   if (name)
     54     ai->ai_canonname = strdup(name);
     55 
     56   switch (addr->sa_family) {
     57     case AF_INET6: {
     58       sockaddr_in6* in =
     59           static_cast<sockaddr_in6*>(malloc(sizeof(sockaddr_in6)));
     60       *in = *(sockaddr_in6*)addr;
     61       ai->ai_family = AF_INET6;
     62       ai->ai_addr = reinterpret_cast<sockaddr*>(in);
     63       ai->ai_addrlen = sizeof(*in);
     64       break;
     65     }
     66     case AF_INET: {
     67       sockaddr_in* in = static_cast<sockaddr_in*>(malloc(sizeof(sockaddr_in)));
     68       *in = *(sockaddr_in*)addr;
     69       ai->ai_family = AF_INET;
     70       ai->ai_addr = reinterpret_cast<sockaddr*>(in);
     71       ai->ai_addrlen = sizeof(*in);
     72       break;
     73     }
     74     default:
     75       assert(0);
     76       return;
     77   }
     78 
     79   if (*list_start == NULL) {
     80     *list_start = ai;
     81     *list_end = ai;
     82     return;
     83   }
     84 
     85   (*list_end)->ai_next = ai;
     86   *list_end = ai;
     87 }
     88 
     89 }  // namespace
     90 
     91 namespace nacl_io {
     92 
     93 HostResolver::HostResolver() : hostent_(), ppapi_(NULL) {
     94 }
     95 
     96 HostResolver::~HostResolver() {
     97   hostent_cleanup();
     98 }
     99 
    100 void HostResolver::Init(PepperInterface* ppapi) {
    101   ppapi_ = ppapi;
    102 }
    103 
    104 struct hostent* HostResolver::gethostbyname(const char* name) {
    105   h_errno = NETDB_INTERNAL;
    106 
    107   struct addrinfo* ai;
    108   struct addrinfo hints;
    109   memset(&hints, 0, sizeof(hints));
    110   hints.ai_flags = AI_CANONNAME;
    111   hints.ai_family = AF_INET;
    112   int err = getaddrinfo(name, NULL, &hints, &ai);
    113   if (err) {
    114     switch (err) {
    115       case EAI_SYSTEM:
    116         h_errno = NO_RECOVERY;
    117         break;
    118       case EAI_NONAME:
    119         h_errno = HOST_NOT_FOUND;
    120         break;
    121       default:
    122         h_errno = NETDB_INTERNAL;
    123         break;
    124     }
    125     return NULL;
    126   }
    127 
    128   // We use a single hostent struct for all calls to to gethostbyname
    129   // (as explicitly permitted by the spec - gethostbyname is NOT supposed to
    130   // be threadsafe!).  However by using a lock around all the global data
    131   // manipulation we can at least ensure that the call doesn't crash.
    132   AUTO_LOCK(gethostbyname_lock_);
    133 
    134   // The first thing we do is free any malloced data left over from
    135   // the last call.
    136   hostent_cleanup();
    137 
    138   switch (ai->ai_family) {
    139     case AF_INET:
    140       hostent_.h_addrtype = AF_INET;
    141       hostent_.h_length = sizeof(in_addr);
    142       break;
    143     case AF_INET6:
    144       hostent_.h_addrtype = AF_INET6;
    145       hostent_.h_length = sizeof(in6_addr);
    146       break;
    147     default:
    148       return NULL;
    149   }
    150 
    151   if (ai->ai_canonname != NULL)
    152     hostent_.h_name = strdup(ai->ai_canonname);
    153   else
    154     hostent_.h_name = strdup(name);
    155 
    156   // Aliases aren't supported at the moment, so we just make an empty list.
    157   hostent_.h_aliases = static_cast<char**>(malloc(sizeof(char*)));
    158   if (NULL == hostent_.h_aliases)
    159     return NULL;
    160   hostent_.h_aliases[0] = NULL;
    161 
    162   // Count number of address in list
    163   int num_addresses = 0;
    164   struct addrinfo* current = ai;
    165   while (current != NULL) {
    166     // Only count address that have the same type as first address
    167     if (current->ai_family == hostent_.h_addrtype)
    168       num_addresses++;
    169     current = current->ai_next;
    170   }
    171 
    172   // Allocate address list
    173   hostent_.h_addr_list = static_cast<char**>(calloc(num_addresses + 1,
    174                                                     sizeof(char*)));
    175   if (NULL == hostent_.h_addr_list)
    176     return NULL;
    177 
    178   // Copy all addresses of the relevant family.
    179   current = ai;
    180   char** hostent_addr = hostent_.h_addr_list;
    181   while (current != NULL) {
    182     if (current->ai_family != hostent_.h_addrtype) {
    183       current = current->ai_next;
    184       continue;
    185     }
    186     *hostent_addr = static_cast<char*>(malloc(hostent_.h_length));
    187     switch (current->ai_family) {
    188       case AF_INET: {
    189         sockaddr_in* in = reinterpret_cast<sockaddr_in*>(current->ai_addr);
    190         memcpy(*hostent_addr, &in->sin_addr.s_addr, hostent_.h_length);
    191         break;
    192       }
    193       case AF_INET6: {
    194         sockaddr_in6* in6 = reinterpret_cast<sockaddr_in6*>(current->ai_addr);
    195         memcpy(*hostent_addr, &in6->sin6_addr.s6_addr, hostent_.h_length);
    196         break;
    197       }
    198     }
    199     current = current->ai_next;
    200     hostent_addr++;
    201   }
    202 
    203   freeaddrinfo(ai);
    204 
    205 #if !defined(h_addr)
    206   // Copy element zero of h_addr_list to h_addr when h_addr is not defined
    207   // as in some libc's h_addr may be a separate member instead of a macro.
    208   hostent_.h_addr = hostent_.h_addr_list[0];
    209 #endif
    210 
    211   return &hostent_;
    212 }
    213 
    214 void HostResolver::freeaddrinfo(struct addrinfo* res) {
    215   while (res) {
    216     struct addrinfo* cur = res;
    217     res = res->ai_next;
    218     free(cur->ai_addr);
    219     free(cur->ai_canonname);
    220     free(cur);
    221   }
    222 }
    223 
    224 int HostResolver::getnameinfo(const struct sockaddr *sa,
    225                               socklen_t salen,
    226                               char *host,
    227                               size_t hostlen,
    228                               char *serv,
    229                               size_t servlen,
    230                               int flags) {
    231   return ENOSYS;
    232 }
    233 
    234 int HostResolver::getaddrinfo(const char* node,
    235                               const char* service,
    236                               const struct addrinfo* hints_in,
    237                               struct addrinfo** result) {
    238   *result = NULL;
    239   struct addrinfo* end = NULL;
    240 
    241   if (node == NULL && service == NULL) {
    242     LOG_TRACE("node and service are NULL.");
    243     return EAI_NONAME;
    244   }
    245 
    246   // Check the service name (port).  Currently we only handle numeric
    247   // services.
    248   long port = 0;
    249   if (service != NULL) {
    250     char* cp;
    251     port = strtol(service, &cp, 10);
    252     if (port >= 0 && port <= UINT16_MAX && *cp == '\0') {
    253       port = htons(port);
    254     } else {
    255       LOG_TRACE("Service \"%s\" not supported.", service);
    256       return EAI_SERVICE;
    257     }
    258   }
    259 
    260   struct addrinfo default_hints;
    261   memset(&default_hints, 0, sizeof(default_hints));
    262   const struct addrinfo* hints = hints_in ? hints_in : &default_hints;
    263 
    264   // Verify values passed in hints structure
    265   switch (hints->ai_family) {
    266     case AF_INET6:
    267     case AF_INET:
    268     case AF_UNSPEC:
    269       break;
    270     default:
    271       LOG_TRACE("Unknown family: %d.", hints->ai_family);
    272       return EAI_FAMILY;
    273   }
    274 
    275   struct sockaddr_in addr_in;
    276   memset(&addr_in, 0, sizeof(addr_in));
    277   addr_in.sin_family = AF_INET;
    278   addr_in.sin_port = port;
    279 
    280   struct sockaddr_in6 addr_in6;
    281   memset(&addr_in6, 0, sizeof(addr_in6));
    282   addr_in6.sin6_family = AF_INET6;
    283   addr_in6.sin6_port = port;
    284 
    285   if (node) {
    286     // Handle numeric node name.
    287     if (hints->ai_family == AF_INET || hints->ai_family == AF_UNSPEC) {
    288       in_addr in;
    289       if (inet_pton(AF_INET, node, &in)) {
    290         addr_in.sin_addr = in;
    291         CreateAddrInfo(hints, (sockaddr*)&addr_in, node, result, &end);
    292         return 0;
    293       }
    294     }
    295 
    296     if (hints->ai_family == AF_INET6 || hints->ai_family == AF_UNSPEC) {
    297       in6_addr in6;
    298       if (inet_pton(AF_INET6, node, &in6)) {
    299         addr_in6.sin6_addr = in6;
    300         CreateAddrInfo(hints, (sockaddr*)&addr_in6, node, result, &end);
    301         return 0;
    302       }
    303     }
    304   }
    305 
    306   // Handle AI_PASSIVE (used for listening sockets, e.g. INADDR_ANY)
    307   if (node == NULL && (hints->ai_flags & AI_PASSIVE)) {
    308     if (hints->ai_family == AF_INET6 || hints->ai_family == AF_UNSPEC) {
    309       const in6_addr in6addr_any = IN6ADDR_ANY_INIT;
    310       memcpy(&addr_in6.sin6_addr.s6_addr, &in6addr_any, sizeof(in6addr_any));
    311       CreateAddrInfo(hints, (sockaddr*)&addr_in6, NULL, result, &end);
    312     }
    313 
    314     if (hints->ai_family == AF_INET || hints->ai_family == AF_UNSPEC) {
    315       addr_in.sin_addr.s_addr = INADDR_ANY;
    316       CreateAddrInfo(hints, (sockaddr*)&addr_in, NULL, result, &end);
    317     }
    318     return 0;
    319   }
    320 
    321   if (NULL == ppapi_) {
    322     LOG_ERROR("ppapi_ is NULL.");
    323     return EAI_SYSTEM;
    324   }
    325 
    326   // Use PPAPI interface to resolve nodename
    327   HostResolverInterface* resolver_iface = ppapi_->GetHostResolverInterface();
    328   VarInterface* var_iface = ppapi_->GetVarInterface();
    329   NetAddressInterface* netaddr_iface = ppapi_->GetNetAddressInterface();
    330 
    331   if (!(resolver_iface && var_iface && netaddr_iface)) {
    332     LOG_ERROR("Got NULL interface(s): %s%s%s",
    333               resolver_iface ? "" : "HostResolver ",
    334               var_iface ? "" : "Var ",
    335               netaddr_iface ? "" : "NetAddress");
    336     return EAI_SYSTEM;
    337   }
    338 
    339   ScopedResource scoped_resolver(ppapi_,
    340                                  resolver_iface->Create(ppapi_->GetInstance()));
    341   PP_Resource resolver = scoped_resolver.pp_resource();
    342 
    343   struct PP_HostResolver_Hint pp_hints;
    344   HintsToPPHints(hints, &pp_hints);
    345 
    346   int err = resolver_iface->Resolve(resolver,
    347                                     node,
    348                                     0,
    349                                     &pp_hints,
    350                                     PP_BlockUntilComplete());
    351   if (err) {
    352     switch (err) {
    353       case PP_ERROR_NOACCESS:
    354         return EAI_SYSTEM;
    355       case PP_ERROR_NAME_NOT_RESOLVED:
    356         return EAI_NONAME;
    357       default:
    358         return EAI_SYSTEM;
    359     }
    360   }
    361 
    362   char* canon_name = NULL;
    363   if (hints->ai_flags & AI_CANONNAME) {
    364     PP_Var name_var = resolver_iface->GetCanonicalName(resolver);
    365     if (PP_VARTYPE_STRING == name_var.type) {
    366       uint32_t len = 0;
    367       const char* tmp = var_iface->VarToUtf8(name_var, &len);
    368       // For some reason GetCanonicalName alway returns an empty
    369       // string so this condition is never true.
    370       // TODO(sbc): investigate this issue with PPAPI team.
    371       if (len > 0) {
    372         // Copy and NULL-terminate the UTF8 string var.
    373         canon_name = static_cast<char*>(malloc(len + 1));
    374         strncpy(canon_name, tmp, len);
    375         canon_name[len] = '\0';
    376       }
    377     }
    378     if (!canon_name)
    379       canon_name = strdup(node);
    380     var_iface->Release(name_var);
    381   }
    382 
    383   int num_addresses = resolver_iface->GetNetAddressCount(resolver);
    384   if (0 == num_addresses)
    385     return EAI_NODATA;
    386 
    387   // Convert address to sockaddr struct.
    388   for (int i = 0; i < num_addresses; i++) {
    389     ScopedResource addr(ppapi_, resolver_iface->GetNetAddress(resolver, i));
    390     PP_Resource resource = addr.pp_resource();
    391     assert(resource != 0);
    392     assert(PP_ToBool(netaddr_iface->IsNetAddress(resource)));
    393     struct sockaddr* sockaddr = NULL;
    394     switch (netaddr_iface->GetFamily(resource)) {
    395       case PP_NETADDRESS_FAMILY_IPV4: {
    396         struct PP_NetAddress_IPv4 pp_addr;
    397         if (!netaddr_iface->DescribeAsIPv4Address(resource, &pp_addr)) {
    398           assert(false);
    399           break;
    400         }
    401         memcpy(&addr_in.sin_addr.s_addr, pp_addr.addr, sizeof(in_addr_t));
    402         sockaddr = (struct sockaddr*)&addr_in;
    403         break;
    404       }
    405       case PP_NETADDRESS_FAMILY_IPV6: {
    406         struct PP_NetAddress_IPv6 pp_addr;
    407         if (!netaddr_iface->DescribeAsIPv6Address(resource, &pp_addr)) {
    408           assert(false);
    409           break;
    410         }
    411         memcpy(&addr_in6.sin6_addr.s6_addr, pp_addr.addr, sizeof(in6_addr));
    412         sockaddr = (struct sockaddr*)&addr_in6;
    413         break;
    414       }
    415       default:
    416         return EAI_SYSTEM;
    417     }
    418 
    419     if (sockaddr != NULL)
    420       CreateAddrInfo(hints, sockaddr, canon_name, result, &end);
    421 
    422     if (canon_name) {
    423       free(canon_name);
    424       canon_name = NULL;
    425     }
    426   }
    427 
    428   return 0;
    429 }
    430 
    431 // Frees all of the deep pointers in a hostent struct. Called between uses of
    432 // gethostbyname, and when the kernel_proxy object is destroyed.
    433 void HostResolver::hostent_cleanup() {
    434   if (NULL != hostent_.h_name) {
    435     free(hostent_.h_name);
    436   }
    437   if (NULL != hostent_.h_aliases) {
    438     for (int i = 0; NULL != hostent_.h_aliases[i]; i++) {
    439       free(hostent_.h_aliases[i]);
    440     }
    441     free(hostent_.h_aliases);
    442   }
    443   if (NULL != hostent_.h_addr_list) {
    444     for (int i = 0; NULL != hostent_.h_addr_list[i]; i++) {
    445       free(hostent_.h_addr_list[i]);
    446     }
    447     free(hostent_.h_addr_list);
    448   }
    449   hostent_.h_name = NULL;
    450   hostent_.h_aliases = NULL;
    451   hostent_.h_addr_list = NULL;
    452 #if !defined(h_addr)
    453   // Initialize h_addr separately in the case where it is not a macro.
    454   hostent_.h_addr = NULL;
    455 #endif
    456 }
    457 
    458 }  // namespace nacl_io
    459 
    460 #endif  // PROVIDES_SOCKET_API
    461