Call GetAdaptersAddresses in the way recommended by MSDN.

net/base/network_interfaces_win.cc

 // Copyright (c) 2012 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/network_interfaces_win.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/win/scoped_handle.h"
 #include "net/base/escape.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
+// Max number of times to retry GetAdaptersAddresses due to
+// ERROR_BUFFER_OVERFLOW. If GetAdaptersAddresses returns this indefinitely
+// due to some Windows bug, we don't want to be stuck in an endless loop.
+const int MAX_GETADAPTERSADDRESSES_TRIES = 100;

[pauljensen, 2016/06/20 11:32:49]

100 seems like a lot.  I imagine 10 should be plenty?

[pauljensen, 2016/06/20 11:32:49]

how about moving this constant into the function?

[Taylor_Brandstetter, 2016/06/21 17:06:04]

Done.

[Taylor_Brandstetter, 2016/06/21 17:06:05]

Done. I thought to make it a large number so that this issue doesn't resurface
later, but you're likely right.

+
 // Converts Windows defined types to NetworkInterfaceType.
 NetworkChangeNotifier::ConnectionType GetNetworkInterfaceType(DWORD ifType) {
   NetworkChangeNotifier::ConnectionType type =
       NetworkChangeNotifier::CONNECTION_UNKNOWN;
   if (ifType == IF_TYPE_ETHERNET_CSMACD) {
     type = NetworkChangeNotifier::CONNECTION_ETHERNET;
   } else if (ifType == IF_TYPE_IEEE80211) {
     type = NetworkChangeNotifier::CONNECTION_WIFI;
   }
   // TODO(mallinath) - Cellular?
@@ skipping 153 matching lines @@
         }
       }
     }
   }
   return true;
 }
 
 }  // namespace internal
 
 bool GetNetworkList(NetworkInterfaceList* networks, int policy) {
-  ULONG len = 0;
+  // Use an initial buffer size of 15KB, as recommended by MSDN.

[pauljensen, 2016/06/20 11:32:49]

can you provide a link to this recommendation?

[Taylor_Brandstetter, 2016/06/21 17:06:04]

Done.

+  ULONG len = 15360;

[pauljensen, 2016/06/21 20:32:05]

Actually I think Windows may want you to use 15000 like their example shows:
https://msdn.microsoft.com/en-us/library/windows/desktop/aa365915(v=vs.85).aspx

[Taylor_Brandstetter, 2016/06/21 20:45:18]

Done, good catch.

   ULONG flags = 0;
   // GetAdaptersAddresses() may require IO operations.
   base::ThreadRestrictions::AssertIOAllowed();
-  ULONG result = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, NULL, &len);
-  if (result != ERROR_BUFFER_OVERFLOW) {
+  // Call GetAdaptersAddresses in a loop, because the required size may
+  // increase between successive calls, resulting in ERROR_BUFFER_OVERFLOW
+  // multiple times.
+  std::unique_ptr<char[]> buf;

[pauljensen, 2016/06/20 11:32:49]

can we type this as IP_ADAPTER_ADDRESSES*?

[Taylor_Brandstetter, 2016/06/21 17:06:05]

I think that may be confusing, because the buffer's size will not be a multiple
of `sizeof(IP_ADAPTER_ADDRESSES)`. We would need to type it as
`IP_ADAPTER_ADDRESSES[]` so that the array delete operator is used, and call
`buf.reset(reinterpret_cast<IP_ADAPTER_ADDRESSES*>(new char[len]))`. If you do
prefer that, I'll go ahead.

[pauljensen, 2016/06/21 17:20:10]

I assume IP_ADAPTER_ADDRESSES is POD so it's silly that it has to be an array,
but I guess this is what unique_ptr wants.

To be on the safe side and to avoid the ugly cast, I'd allocate it with:
buf.reset(new IP_ADAPTER_ADDRESSES[(len + sizeof(IP_ADAPTER_ADDRESSES) -
1)/sizeof(IP_ADAPTER_ADDRESSES)]);

or maybe define a ROUND_UP macro and use that to make it a little easier to
read.

[Taylor_Brandstetter, 2016/06/21 19:50:51]

Well... It depends on your definition of POD. It contains pointers to several
linked lists and variable size strings, and is itself the head node of a linked
list. So it would seem odd to me to declare an array when the underlying data is
a linked list. Someone may try to access an element other than [0] and get
undefined behavior.

[pauljensen, 2016/06/21 20:32:04]

I think the POD definition is pretty clear; isn't it part of the C++ spec?  I
think all this Windows stuff is from the days of C so it has to be POD.

Anyhow, I guess the current char[] and cast is fine as this isn't really an
array of anything sane.

+  IP_ADAPTER_ADDRESSES* adapters;
+  ULONG result;
+  int tries = 0;
+  do {
+    buf.reset(new char[len]);

[pauljensen, 2016/06/20 11:32:49]

it would be nice if the first 15k buffer could be on the stack so we don't
always have to allocate and free 15k, but it's not a big deal.

[Taylor_Brandstetter, 2016/06/21 17:06:04]

Done.

+    adapters = reinterpret_cast<IP_ADAPTER_ADDRESSES*>(buf.get());
+    result = GetAdaptersAddresses(AF_UNSPEC, flags, nullptr, adapters, &len);
+  } while (result == ERROR_BUFFER_OVERFLOW &&
+           ++tries < MAX_GETADAPTERSADDRESSES_TRIES);
+  if (result == ERROR_NO_DATA) {
     // There are 0 networks.
     return true;
-  }
-  std::unique_ptr<char[]> buf(new char[len]);
-  IP_ADAPTER_ADDRESSES* adapters =
-      reinterpret_cast<IP_ADAPTER_ADDRESSES*>(buf.get());
-  result = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, adapters, &len);
-  if (result != NO_ERROR) {
+  } else if (result != NO_ERROR) {
     LOG(ERROR) << "GetAdaptersAddresses failed: " << result;
     return false;
   }
 
   return internal::GetNetworkListImpl(networks, policy, adapters);
 }
 
 WifiPHYLayerProtocol GetWifiPHYLayerProtocol() {
   auto conn_info = GetConnectionAttributes();
 
@@ skipping 81 matching lines @@
 
   if (!conn_info.get())
     return "";
 
   const DOT11_SSID dot11_ssid = conn_info->wlanAssociationAttributes.dot11Ssid;
   return std::string(reinterpret_cast<const char*>(dot11_ssid.ucSSID),
                      dot11_ssid.uSSIDLength);
 }
 
 }  // namespace net