Added NetworkInterface::network_prefix

net/base/net_util_posix.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/net_util.h"
 
 #include <sys/types.h>
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/base/escape.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "url/gurl.h"
 
 #if !defined(OS_ANDROID)
 #include <ifaddrs.h>
@@ skipping 37 matching lines @@
   } while (new_path != old_path);
 
   file_path_str.assign(old_path);
 
   return !file_path_str.empty();
 }
 
 bool GetNetworkList(NetworkInterfaceList* networks) {
 #if defined(OS_ANDROID)
   std::string network_list = android::GetNetworkList();
-  base::StringTokenizer network_interfaces(network_list, ";");
+  base::StringTokenizer network_interfaces(network_list, "\n");
   while (network_interfaces.GetNext()) {
     std::string network_item = network_interfaces.token();
-    base::StringTokenizer network_tokenizer(network_item, ",");
-    std::string name;
-    if (!network_tokenizer.GetNext())
-      continue;
-    name = network_tokenizer.token();
+    base::StringTokenizer network_tokenizer(network_item, "\t");
+    CHECK(network_tokenizer.GetNext());
+    std::string name = network_tokenizer.token();
 
-    std::string literal_address;
-    if (!network_tokenizer.GetNext())
-      continue;
-    literal_address = network_tokenizer.token();
+    CHECK(network_tokenizer.GetNext());
+    std::string interface_address = network_tokenizer.token();
+
+    base::StringTokenizer address_tokenizer(interface_address, "/");
+
+    CHECK(address_tokenizer.GetNext());
+    std::string literal_address = address_tokenizer.token();
+
+    CHECK(address_tokenizer.GetNext());
+    std::string network_prefix = address_tokenizer.token();
 
     IPAddressNumber address;
-    if (!ParseIPLiteralToNumber(literal_address, &address))
-      continue;
-    networks->push_back(NetworkInterface(name, address));
+    CHECK(ParseIPLiteralToNumber(literal_address, &address));
+
+    unsigned net_mask = 0;
+    CHECK(base::StringToUint(network_prefix, &net_mask));
+    CHECK_LE(net_mask, address.size() * 8);
+
+    networks->push_back(
+        NetworkInterface(name, address, static_cast<uint8>(net_mask)));
   }
   return true;
 #else
   // getifaddrs() may require IO operations.
   base::ThreadRestrictions::AssertIOAllowed();
 
   ifaddrs *interfaces;
   if (getifaddrs(&interfaces) < 0) {
     PLOG(ERROR) << "getifaddrs";
     return false;
@@ skipping 29 matching lines @@
           reinterpret_cast<struct sockaddr_in*>(addr);
       addr_size = sizeof(*addr_in);
       if (addr_in->sin_addr.s_addr == INADDR_LOOPBACK ||
           addr_in->sin_addr.s_addr == 0) {
         continue;
       }
     } else {
       // Skip non-IP addresses.
       continue;
     }
+
     IPEndPoint address;
     std::string name = interface->ifa_name;
     if (address.FromSockAddr(addr, addr_size)) {
-      networks->push_back(NetworkInterface(name, address.address()));
+      uint8 net_mask = 0;
+      if (interface->ifa_netmask) {
+        IPEndPoint netmask;
+        if (netmask.FromSockAddr(interface->ifa_netmask, addr_size)) {
+          net_mask = MaskPrefixLength(netmask.address());
+        }
+      }
+
+      networks->push_back(NetworkInterface(name, address.address(), net_mask));
     }
   }
 
   freeifaddrs(interfaces);
 
   return true;
 #endif
 }
 
 WifiPHYLayerProtocol GetWifiPHYLayerProtocol() {
   return WIFI_PHY_LAYER_PROTOCOL_UNKNOWN;
 }
 
 }  // namespace net