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 48 matching lines @@
   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();
 
     std::string literal_address;
     if (!network_tokenizer.GetNext())
       continue;

[szym, 2013/09/23 17:26:55]

I don't quite understand why the code here silently ignores unexpected format.
android::GetNetworkList comes from across the JNI barrier, but there's no reason
why it would be inconsistent (there's no hot updating on Android).

I really think these should all be CHECKed instead.

     literal_address = network_tokenizer.token();
 
+    uint8 net_mask = 0;
+    if (network_tokenizer.GetNext()) {
+      unsigned int_token = 0;
+      if (base::StringToUint(network_tokenizer.token(), &int_token) &&
+          int_token <= 255) {
+        net_mask = int_token;
+      } else {
+        NOTREACHED();

[szym, 2013/09/23 17:26:55]

This should be consistent with the rest of the code. I.e., either CHECK all,
DCHECK all (NOTREACHED), or |if (unexpected) continue;|

+      }
+    }
+
     IPAddressNumber address;
     if (!ParseIPLiteralToNumber(literal_address, &address))
       continue;
-    networks->push_back(NetworkInterface(name, address));
+    networks->push_back(NetworkInterface(name, address, 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