net/base/net_util_posix.cc

   1 // Copyright (c) 2011 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 #include "net/base/net_util.h"
   6
   7 #include <sys/types.h>
   8
   9 #include "base/files/file_path.h"
  10 #include "base/logging.h"
  11 #include "base/posix/eintr_wrapper.h"
  12 #include "base/strings/string_tokenizer.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/threading/thread_restrictions.h"
  15 #include "net/base/escape.h"
  16 #include "net/base/ip_endpoint.h"
  17 #include "net/base/net_errors.h"
  18 #include "url/gurl.h"
  19
  20 #if !defined(OS_ANDROID)
  21 #include <ifaddrs.h>
  22 #endif
  23 #include <net/if.h>
  24 #include <netinet/in.h>
  25
  26 #if defined(OS_ANDROID)
  27 #include "net/android/network_library.h"
  28 #endif
  29
  30 namespace net {
  31
  32 bool FileURLToFilePath(const GURL& url, base::FilePath* path) {
  33   *path = base::FilePath();
  34   std::string& file_path_str = const_cast<std::string&>(path->value());
  35   file_path_str.clear();
  36
  37   if (!url.is_valid())
  38     return false;
  39
  40   // Firefox seems to ignore the "host" of a file url if there is one. That is,
  41   // file://foo/bar.txt maps to /bar.txt.
  42   // TODO(dhg): This should probably take into account UNCs which could
  43   // include a hostname other than localhost or blank
  44   std::string old_path = url.path();
  45
  46   if (old_path.empty())
  47     return false;
  48
  49   // GURL stores strings as percent-encoded 8-bit, this will undo if possible.
  50   old_path = UnescapeURLComponent(old_path,
  51       UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS);
  52
  53   // Collapse multiple path slashes into a single path slash.
  54   std::string new_path;
  55   do {
  56     new_path = old_path;
  57     ReplaceSubstringsAfterOffset(&new_path, 0, "//", "/");
  58     old_path.swap(new_path);
  59   } while (new_path != old_path);
  60
  61   file_path_str.assign(old_path);
  62
  63   return !file_path_str.empty();
  64 }
  65
  66 bool GetNetworkList(NetworkInterfaceList* networks) {
  67 #if defined(OS_ANDROID)
  68   std::string network_list = android::GetNetworkList();
  69   base::StringTokenizer network_interfaces(network_list, ";");
  70   while (network_interfaces.GetNext()) {
  71     std::string network_item = network_interfaces.token();
  72     base::StringTokenizer network_tokenizer(network_item, ",");
  73     std::string name;
  74     if (!network_tokenizer.GetNext())
  75       continue;
  76     name = network_tokenizer.token();
  77
  78     std::string literal_address;
  79     if (!network_tokenizer.GetNext())
  80       continue;
  81     literal_address = network_tokenizer.token();
  82
  83     IPAddressNumber address;
  84     if (!ParseIPLiteralToNumber(literal_address, &address))
  85       continue;
  86     networks->push_back(NetworkInterface(name, address));
  87   }
  88   return true;
  89 #else
  90   // getifaddrs() may require IO operations.
  91   base::ThreadRestrictions::AssertIOAllowed();
  92
  93   ifaddrs *interfaces;
  94   if (getifaddrs(&interfaces) < 0) {
  95     PLOG(ERROR) << "getifaddrs";
  96     return false;
  97   }
  98
  99   // Enumerate the addresses assigned to network interfaces which are up.
 100   for (ifaddrs *interface = interfaces;
 101        interface != NULL;
 102        interface = interface->ifa_next) {
 103     // Skip loopback interfaces, and ones which are down.
 104     if (!(IFF_UP & interface->ifa_flags))
 105       continue;
 106     if (IFF_LOOPBACK & interface->ifa_flags)
 107       continue;
 108     // Skip interfaces with no address configured.
 109     struct sockaddr* addr = interface->ifa_addr;
 110     if (!addr)
 111       continue;
 112     // Skip unspecified addresses (i.e. made of zeroes) and loopback addresses
 113     // configured on non-loopback interfaces.
 114     int addr_size = 0;
 115     if (addr->sa_family == AF_INET6) {
 116       struct sockaddr_in6* addr_in6 =
 117           reinterpret_cast<struct sockaddr_in6*>(addr);
 118       struct in6_addr* sin6_addr = &addr_in6->sin6_addr;
 119       addr_size = sizeof(*addr_in6);
 120       if (IN6_IS_ADDR_LOOPBACK(sin6_addr) ||
 121           IN6_IS_ADDR_UNSPECIFIED(sin6_addr)) {
 122         continue;
 123       }
 124     } else if (addr->sa_family == AF_INET) {
 125       struct sockaddr_in* addr_in =
 126           reinterpret_cast<struct sockaddr_in*>(addr);
 127       addr_size = sizeof(*addr_in);
 128       if (addr_in->sin_addr.s_addr == INADDR_LOOPBACK ||
 129           addr_in->sin_addr.s_addr == 0) {
 130         continue;
 131       }
 132     } else {
 133       // Skip non-IP addresses.
 134       continue;
 135     }
 136     IPEndPoint address;
 137     std::string name = interface->ifa_name;
 138     if (address.FromSockAddr(addr, addr_size)) {
 139       networks->push_back(NetworkInterface(name, address.address()));
 140     }
 141   }
 142
 143   freeifaddrs(interfaces);
 144
 145   return true;
 146 #endif
 147 }
 148
 149 WifiPHYLayerProtocol GetWifiPHYLayerProtocol() {
 150   return WIFI_PHY_LAYER_PROTOCOL_UNKNOWN;
 151 }
 152
 153 }  // namespace net