Call GetAdaptersAddresses in the way recommended by MSDN.

net/base/network_interfaces_win.cc

Index: net/base/network_interfaces_win.cc
diff --git a/net/base/network_interfaces_win.cc b/net/base/network_interfaces_win.cc
index e2f53caab9f060cd55fb56190a4fad1b8ccdfa76..0554dcc61eb7a2c4335754b92e03057615651fc3 100644
--- a/net/base/network_interfaces_win.cc
+++ b/net/base/network_interfaces_win.cc
@@ -24,6 +24,11 @@ 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 =
@@ -197,20 +202,28 @@ bool GetNetworkListImpl(NetworkInterfaceList* networks,
 }  // 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;
   }