xref: /reactos/dll/win32/iphlpapi/address.c (revision 048ea61a) 
1 /*
2  * COPYRIGHT:       See COPYING in the top level directory
3  * PROJECT:         ReactOS system libraries
4  * FILE:            dll/win32/iphlpapi/address.c
5  * PURPOSE:         iphlpapi implementation - Adapter Address APIs
6  * PROGRAMMERS:     Jérôme Gardou (jerome.gardou@reactos.org)
7  */
8 
9 #include "iphlpapi_private.h"
10 
11 WINE_DEFAULT_DEBUG_CHANNEL(iphlpapi);
12 #ifdef GetAdaptersAddressesV2
13 /* Helper for GetAdaptersAddresses:
14  * Retrieves the list of network adapters from tcpip.sys */
15 static
16 NTSTATUS
17 GetInterfacesList(
18     _In_ HANDLE TcpFile,
19     _Out_ TDIEntityID **EntityList,
20     _Out_ ULONG* InterfaceCount)
21 {
22 
23     TCP_REQUEST_QUERY_INFORMATION_EX TcpQueryInfo;
24     IO_STATUS_BLOCK StatusBlock;
25     NTSTATUS Status;
26     ULONG_PTR BufferSize;
27 
28     ZeroMemory(&TcpQueryInfo, sizeof(TcpQueryInfo));
29     TcpQueryInfo.ID.toi_class = INFO_CLASS_GENERIC;
30     TcpQueryInfo.ID.toi_type = INFO_TYPE_PROVIDER;
31     TcpQueryInfo.ID.toi_id = ENTITY_LIST_ID;
32     TcpQueryInfo.ID.toi_entity.tei_entity = GENERIC_ENTITY;
33     TcpQueryInfo.ID.toi_entity.tei_instance = 0;
34 
35     Status = NtDeviceIoControlFile(
36         TcpFile,
37         NULL,
38         NULL,
39         NULL,
40         &StatusBlock,
41         IOCTL_TCP_QUERY_INFORMATION_EX,
42         &TcpQueryInfo,
43         sizeof(TcpQueryInfo),
44         NULL,
45         0);
46     if (Status == STATUS_PENDING)
47     {
48         /* So we have to wait a bit */
49         Status = NtWaitForSingleObject(TcpFile, FALSE, NULL);
50         if (NT_SUCCESS(Status))
51             Status = StatusBlock.Status;
52     }
53 
54     if (!NT_SUCCESS(Status))
55         return Status;
56 
57     BufferSize = StatusBlock.Information;
58     *EntityList = HeapAlloc(GetProcessHeap(), 0, BufferSize);
59     if (!*EntityList)
60         return STATUS_NO_MEMORY;
61 
62     /* Do the real call */
63     Status = NtDeviceIoControlFile(
64         TcpFile,
65         NULL,
66         NULL,
67         NULL,
68         &StatusBlock,
69         IOCTL_TCP_QUERY_INFORMATION_EX,
70         &TcpQueryInfo,
71         sizeof(TcpQueryInfo),
72         *EntityList,
73         BufferSize);
74     if (Status == STATUS_PENDING)
75     {
76         /* So we have to wait a bit */
77         Status = NtWaitForSingleObject(TcpFile, FALSE, NULL);
78         if (NT_SUCCESS(Status))
79             Status = StatusBlock.Status;
80     }
81 
82     if (!NT_SUCCESS(Status))
83     {
84         HeapFree(GetProcessHeap(), 0, *EntityList);
85         return Status;
86     }
87 
88     *InterfaceCount = BufferSize / sizeof(TDIEntityID);
89     return Status;
90 }
91 
92 static
93 NTSTATUS
94 GetSnmpInfo(
95     _In_ HANDLE TcpFile,
96     _In_ TDIEntityID InterfaceID,
97     _Out_ IPSNMPInfo* Info)
98 {
99     TCP_REQUEST_QUERY_INFORMATION_EX TcpQueryInfo;
100     IO_STATUS_BLOCK StatusBlock;
101     NTSTATUS Status;
102 
103     ZeroMemory(&TcpQueryInfo, sizeof(TcpQueryInfo));
104     TcpQueryInfo.ID.toi_class = INFO_CLASS_PROTOCOL;
105     TcpQueryInfo.ID.toi_type = INFO_TYPE_PROVIDER;
106     TcpQueryInfo.ID.toi_id = IP_MIB_STATS_ID;
107     TcpQueryInfo.ID.toi_entity = InterfaceID;
108 
109     Status = NtDeviceIoControlFile(
110         TcpFile,
111         NULL,
112         NULL,
113         NULL,
114         &StatusBlock,
115         IOCTL_TCP_QUERY_INFORMATION_EX,
116         &TcpQueryInfo,
117         sizeof(TcpQueryInfo),
118         Info,
119         sizeof(*Info));
120     if (Status == STATUS_PENDING)
121     {
122         /* So we have to wait a bit */
123         Status = NtWaitForSingleObject(TcpFile, FALSE, NULL);
124         if (NT_SUCCESS(Status))
125             Status = StatusBlock.Status;
126     }
127 
128     return Status;
129 }
130 
131 static
132 NTSTATUS
133 GetAddrEntries(
134     _In_ HANDLE TcpFile,
135     _In_ TDIEntityID InterfaceID,
136     _Out_ IPAddrEntry* Entries,
137     _In_ ULONG NumEntries)
138 {
139     TCP_REQUEST_QUERY_INFORMATION_EX TcpQueryInfo;
140     IO_STATUS_BLOCK StatusBlock;
141     NTSTATUS Status;
142 
143     ZeroMemory(&TcpQueryInfo, sizeof(TcpQueryInfo));
144     TcpQueryInfo.ID.toi_class = INFO_CLASS_PROTOCOL;
145     TcpQueryInfo.ID.toi_type = INFO_TYPE_PROVIDER;
146     TcpQueryInfo.ID.toi_id = IP_MIB_ADDRTABLE_ENTRY_ID;
147     TcpQueryInfo.ID.toi_entity = InterfaceID;
148 
149     Status = NtDeviceIoControlFile(
150         TcpFile,
151         NULL,
152         NULL,
153         NULL,
154         &StatusBlock,
155         IOCTL_TCP_QUERY_INFORMATION_EX,
156         &TcpQueryInfo,
157         sizeof(TcpQueryInfo),
158         Entries,
159         NumEntries * sizeof(Entries[0]));
160     if (Status == STATUS_PENDING)
161     {
162         /* So we have to wait a bit */
163         Status = NtWaitForSingleObject(TcpFile, FALSE, NULL);
164         if (NT_SUCCESS(Status))
165             Status = StatusBlock.Status;
166     }
167 
168     return Status;
169 }
170 
171 /*
172  * Fills the IFEntry buffer from tcpip.sys.
173  * The buffer size MUST be FIELD_OFFSET(IFEntry, if_descr[MAX_ADAPTER_DESCRIPTION_LENGTH + 1]).
174  * See MSDN IFEntry struct definition if you don't believe me. ;-)
175  */
176 static
177 NTSTATUS
178 GetInterfaceEntry(
179     _In_ HANDLE TcpFile,
180     _In_ TDIEntityID InterfaceID,
181     _Out_ IFEntry* Entry)
182 {
183     TCP_REQUEST_QUERY_INFORMATION_EX TcpQueryInfo;
184     IO_STATUS_BLOCK StatusBlock;
185     NTSTATUS Status;
186 
187     ZeroMemory(&TcpQueryInfo, sizeof(TcpQueryInfo));
188     TcpQueryInfo.ID.toi_class = INFO_CLASS_PROTOCOL;
189     TcpQueryInfo.ID.toi_type = INFO_TYPE_PROVIDER;
190     TcpQueryInfo.ID.toi_id = IP_MIB_STATS_ID;
191     TcpQueryInfo.ID.toi_entity = InterfaceID;
192 
193     Status = NtDeviceIoControlFile(
194         TcpFile,
195         NULL,
196         NULL,
197         NULL,
198         &StatusBlock,
199         IOCTL_TCP_QUERY_INFORMATION_EX,
200         &TcpQueryInfo,
201         sizeof(TcpQueryInfo),
202         Entry,
203         FIELD_OFFSET(IFEntry, if_descr[MAX_ADAPTER_DESCRIPTION_LENGTH + 1]));
204     if (Status == STATUS_PENDING)
205     {
206         /* So we have to wait a bit */
207         Status = NtWaitForSingleObject(TcpFile, FALSE, NULL);
208         if (NT_SUCCESS(Status))
209             Status = StatusBlock.Status;
210     }
211 
212     return Status;
213 }
214 
215 /* Helpers to get the list of DNS for an interface */
216 static
217 VOID
218 EnumerateServerNameSize(
219     _In_ PWCHAR Interface,
220     _In_ PWCHAR NameServer,
221     _Inout_ PVOID Data)
222 {
223     ULONG* BufferSize = Data;
224 
225     /* This is just sizing here */
226     UNREFERENCED_PARAMETER(Interface);
227     UNREFERENCED_PARAMETER(NameServer);
228 
229     *BufferSize += sizeof(IP_ADAPTER_DNS_SERVER_ADDRESS) + sizeof(SOCKADDR);
230 }
231 
232 static
233 VOID
234 EnumerateServerName(
235     _In_ PWCHAR Interface,
236     _In_ PWCHAR NameServer,
237     _Inout_ PVOID Data)
238 {
239     PIP_ADAPTER_DNS_SERVER_ADDRESS** Ptr = Data;
240     PIP_ADAPTER_DNS_SERVER_ADDRESS ServerAddress = **Ptr;
241 
242     UNREFERENCED_PARAMETER(Interface);
243 
244     ServerAddress->Length = sizeof(IP_ADAPTER_DNS_SERVER_ADDRESS);
245     ServerAddress->Address.lpSockaddr = (PVOID)(ServerAddress + 1);
246     ServerAddress->Address.iSockaddrLength = sizeof(SOCKADDR);
247 
248 
249     /* Get the address from the server name string */
250     //FIXME: Only ipv4 for now...
251     if (WSAStringToAddressW(
252         NameServer,
253         AF_INET,
254         NULL,
255         ServerAddress->Address.lpSockaddr,
256         &ServerAddress->Address.iSockaddrLength))
257     {
258         /* Pass along, name conversion failed */
259         ERR("%S is not a valid IP address\n", NameServer);
260         return;
261     }
262 
263     /* Go to next item */
264     ServerAddress->Next = (PVOID)(ServerAddress->Address.lpSockaddr + 1);
265     *Ptr = &ServerAddress->Next;
266 }
267 
268 static
269 VOID
270 QueryFlags(
271     _In_ PUCHAR Interface,
272     _In_ DWORD InterfaceLength,
273     _Out_ LPDWORD Flags)
274 {
275     HKEY InterfaceKey;
276     CHAR KeyName[256];
277     DWORD Type, Size, Data;
278 
279     *Flags = 0;
280 
281     snprintf(KeyName, 256,
282              "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\%*s",
283              InterfaceLength, Interface);
284 
285     if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, KeyName, 0, KEY_READ, &InterfaceKey) == ERROR_SUCCESS)
286     {
287         Size = sizeof(DWORD);
288         if (RegQueryValueExA(InterfaceKey, "EnableDHCP", NULL, &Type, (LPBYTE)&Data, &Size) == ERROR_SUCCESS &&
289             Type == REG_DWORD && Data == 1)
290         {
291             *Flags |= IP_ADAPTER_DHCP_ENABLED;
292         }
293 
294         Size = sizeof(DWORD);
295         if (RegQueryValueExA(InterfaceKey, "RegisterAdapterName", NULL, &Type, (LPBYTE)&Data, &Size) == ERROR_SUCCESS &&
296             Type == REG_DWORD && Data == 1)
297         {
298             *Flags |= IP_ADAPTER_REGISTER_ADAPTER_SUFFIX;
299         }
300 
301         Size = 0;
302         if (RegQueryValueExA(InterfaceKey, "NameServer", NULL, &Type, (LPBYTE)&Data, &Size) != ERROR_SUCCESS)
303         {
304             *Flags |= IP_ADAPTER_DDNS_ENABLED;
305         }
306 
307         RegCloseKey(InterfaceKey);
308     }
309 
310     // FIXME: handle 0x8 -> 0x20
311 }
312 
313 DWORD
314 WINAPI
315 DECLSPEC_HOTPATCH
316 GetAdaptersAddresses(
317     _In_ ULONG Family,
318     _In_ ULONG Flags,
319     _In_ PVOID Reserved,
320     _Inout_ PIP_ADAPTER_ADDRESSES pAdapterAddresses,
321     _Inout_ PULONG pOutBufLen)
322 {
323     NTSTATUS Status;
324     HANDLE TcpFile;
325     TDIEntityID* InterfacesList;
326     ULONG InterfacesCount;
327     ULONG AdaptersCount = 0;
328     ULONG i;
329     ULONG TotalSize = 0, RemainingSize;
330     BYTE* Ptr = (BYTE*)pAdapterAddresses;
331     DWORD MIN_SIZE = 15 * 1024;
332     PIP_ADAPTER_ADDRESSES PreviousAA = NULL;
333 
334     TRACE("Family %u, Flags 0x%08x, Reserved %p, pAdapterAddress %p, pOutBufLen %p\n",
335           Family, Flags, Reserved, pAdapterAddresses, pOutBufLen);
336 
337     if (!pOutBufLen)
338         return ERROR_INVALID_PARAMETER;
339 
340     // FIXME: the exact needed size should be computed first, BEFORE doing any write to the output buffer.
341     // As suggested by MSDN, require a 15 KB buffer, which allows to React properly to length checks.
342     if(!Ptr || *pOutBufLen < MIN_SIZE)
343     {
344         *pOutBufLen = MIN_SIZE;
345         return ERROR_BUFFER_OVERFLOW;
346     }
347 
348     switch(Family)
349     {
350         case AF_INET:
351             break;
352         case AF_INET6:
353             /* One day maybe... */
354             FIXME("IPv6 is not supported in ReactOS!\n");
355             /* We got nothing to say in this case */
356             return ERROR_NO_DATA;
357             break;
358         case AF_UNSPEC:
359             WARN("IPv6 addresses ignored, IPv4 only\n");
360             Family = AF_INET;
361             break;
362         default:
363             ERR("Invalid family 0x%x\n", Family);
364             return ERROR_INVALID_PARAMETER;
365             break;
366     }
367 
368     RemainingSize = *pOutBufLen;
369     if (Ptr)
370         ZeroMemory(Ptr, RemainingSize);
371 
372     /* open the tcpip driver */
373     Status = openTcpFile(&TcpFile, FILE_READ_DATA);
374     if (!NT_SUCCESS(Status))
375     {
376         ERR("Could not open handle to tcpip.sys. Status %08x\n", Status);
377         return RtlNtStatusToDosError(Status);
378     }
379 
380     /* Get the interfaces list */
381     Status = GetInterfacesList(TcpFile, &InterfacesList, &InterfacesCount);
382     if (!NT_SUCCESS(Status))
383     {
384         ERR("Could not get adapters list. Status %08x\n", Status);
385         NtClose(TcpFile);
386         return RtlNtStatusToDosError(Status);
387     }
388 
389     /* Let's see if we got any adapter. */
390     for (i = 0; i < InterfacesCount; i++)
391     {
392         PIP_ADAPTER_ADDRESSES CurrentAA = (PIP_ADAPTER_ADDRESSES)Ptr;
393         ULONG CurrentAASize = 0;
394         ULONG FriendlySize = 0;
395 
396         if (InterfacesList[i].tei_entity == IF_ENTITY)
397         {
398             BYTE EntryBuffer[FIELD_OFFSET(IFEntry, if_descr) +
399                              RTL_FIELD_SIZE(IFEntry, if_descr[0]) * (MAX_ADAPTER_DESCRIPTION_LENGTH + 1)];
400             IFEntry* Entry = (IFEntry*)EntryBuffer;
401 
402             /* Remember we got one */
403             AdaptersCount++;
404 
405             /* Set the pointer to this instance in the previous one*/
406             if(PreviousAA)
407                 PreviousAA->Next = CurrentAA;
408 
409             /* Of course we need some space for the base structure. */
410             CurrentAASize = sizeof(IP_ADAPTER_ADDRESSES);
411 
412             /* Get the entry */
413             Status = GetInterfaceEntry(TcpFile, InterfacesList[i], Entry);
414             if (!NT_SUCCESS(Status))
415                 goto Error;
416 
417             TRACE("Got entity %*s, index %u.\n",
418                 Entry->if_descrlen, &Entry->if_descr[0], Entry->if_index);
419 
420             /* Add the adapter name */
421             CurrentAASize += Entry->if_descrlen + sizeof(CHAR);
422 
423             /* Add the DNS suffix */
424             CurrentAASize += sizeof(WCHAR);
425 
426             /* Add the description. */
427             CurrentAASize += sizeof(WCHAR);
428 
429             if (!(Flags & GAA_FLAG_SKIP_FRIENDLY_NAME))
430             {
431                 /* Get the friendly name */
432                 HKEY ConnectionKey;
433                 CHAR KeyName[256];
434 
435                 snprintf(KeyName, 256,
436                     "SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%*s\\Connection",
437                     Entry->if_descrlen, &Entry->if_descr[0]);
438 
439                 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, KeyName, 0, KEY_READ, &ConnectionKey) == ERROR_SUCCESS)
440                 {
441                     DWORD ValueType;
442                     DWORD ValueSize = 0;
443 
444                     if (RegQueryValueExW(ConnectionKey, L"Name", NULL, &ValueType, NULL, &ValueSize) == ERROR_SUCCESS &&
445                         ValueType == REG_SZ)
446                     {
447                         /* We remove the null char, it will be re-added after */
448                         FriendlySize = ValueSize - sizeof(WCHAR);
449                         CurrentAASize += FriendlySize;
450                     }
451 
452                     RegCloseKey(ConnectionKey);
453                 }
454 
455                 /* We always make sure to have enough room for empty string */
456                 CurrentAASize += sizeof(WCHAR);
457             }
458 
459             if (!(Flags & GAA_FLAG_SKIP_DNS_SERVER))
460             {
461                 /* Enumerate the name servers */
462                 HKEY InterfaceKey;
463                 CHAR KeyName[256];
464 
465                 snprintf(KeyName, 256,
466                     "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\%*s",
467                     Entry->if_descrlen, &Entry->if_descr[0]);
468 
469                 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, KeyName, 0, KEY_READ, &InterfaceKey) == ERROR_SUCCESS)
470                 {
471                     EnumNameServers(InterfaceKey, NULL, &CurrentAASize, EnumerateServerNameSize);
472                     RegCloseKey(InterfaceKey);
473                 }
474             }
475 
476             /* This is part of what we will need */
477             TotalSize += CurrentAASize;
478 
479             /* Fill in the data */
480             if ((CurrentAA) && (RemainingSize >= CurrentAASize))
481             {
482                 CurrentAA->Length = sizeof(IP_ADAPTER_ADDRESSES);
483                 CurrentAA->IfIndex = Entry->if_index;
484                 CopyMemory(CurrentAA->PhysicalAddress, Entry->if_physaddr, Entry->if_physaddrlen);
485                 CurrentAA->PhysicalAddressLength = Entry->if_physaddrlen;
486                 QueryFlags(&Entry->if_descr[0], Entry->if_descrlen, &CurrentAA->Flags);
487                 CurrentAA->Mtu = Entry->if_mtu;
488                 CurrentAA->IfType = Entry->if_type;
489                 if(Entry->if_operstatus >= IF_OPER_STATUS_CONNECTING)
490                     CurrentAA->OperStatus = IfOperStatusUp;
491                 else
492                     CurrentAA->OperStatus = IfOperStatusDown;
493 
494                 /* Next items */
495                 Ptr = (BYTE*)(CurrentAA + 1);
496 
497                 /* Now fill in the name */
498                 CopyMemory(Ptr, &Entry->if_descr[0], Entry->if_descrlen);
499                 CurrentAA->AdapterName = (PCHAR)Ptr;
500                 CurrentAA->AdapterName[Entry->if_descrlen] = '\0';
501                 /* Next items */
502                 Ptr = (BYTE*)(CurrentAA->AdapterName + Entry->if_descrlen + 1);
503 
504                 /* The DNS suffix */
505                 CurrentAA->DnsSuffix = (PWCHAR)Ptr;
506                 CurrentAA->DnsSuffix[0] = L'\0';
507                 /* Next items */
508                 Ptr = (BYTE*)(CurrentAA->DnsSuffix + 1);
509 
510                 /* The description */
511                 CurrentAA->Description = (PWCHAR)Ptr;
512                 CurrentAA->Description[0] = L'\0';
513                 /* Next items */
514                 Ptr = (BYTE*)(CurrentAA->Description + 1);
515 
516                 /* The friendly name */
517                 if (!(Flags & GAA_FLAG_SKIP_FRIENDLY_NAME))
518                 {
519                     CurrentAA->FriendlyName = (PWCHAR)Ptr;
520 
521                     if (FriendlySize != 0)
522                     {
523                         /* Get the friendly name */
524                         HKEY ConnectionKey;
525                         CHAR KeyName[256];
526 
527                         snprintf(KeyName, 256,
528                             "SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\%*s\\Connection",
529                             Entry->if_descrlen, &Entry->if_descr[0]);
530 
531                         if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, KeyName, 0, KEY_READ, &ConnectionKey) == ERROR_SUCCESS)
532                         {
533                             DWORD ValueType;
534                             DWORD ValueSize = FriendlySize + sizeof(WCHAR);
535 
536                             if (RegQueryValueExW(ConnectionKey, L"Name", NULL, &ValueType, (LPBYTE)CurrentAA->FriendlyName, &ValueSize) == ERROR_SUCCESS &&
537                                 ValueType == REG_SZ && ValueSize == FriendlySize + sizeof(WCHAR))
538                             {
539                                 /* We're done, next items */
540                                 Ptr = (BYTE*)(CurrentAA->FriendlyName + (ValueSize / sizeof(WCHAR)));
541                             }
542                             else
543                             {
544                                 /* Fail */
545                                 ERR("Friendly name changed after probe!\n");
546                                 FriendlySize = 0;
547                             }
548 
549                             RegCloseKey(ConnectionKey);
550                         }
551                         else
552                         {
553                             /* Fail */
554                             FriendlySize = 0;
555                         }
556                     }
557 
558                     /* In case of failure (or no name) */
559                     if (FriendlySize == 0)
560                     {
561                         CurrentAA->FriendlyName[0] = L'\0';
562                         /* Next items */
563                         Ptr = (BYTE*)(CurrentAA->FriendlyName + 1);
564                     }
565                 }
566 
567                 /* The DNS Servers */
568                 if (!(Flags & GAA_FLAG_SKIP_DNS_SERVER))
569                 {
570                     /* Enumerate the name servers */
571                     HKEY InterfaceKey;
572                     CHAR KeyName[256];
573 
574                     snprintf(KeyName, 256,
575                         "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\%*s",
576                         Entry->if_descrlen, &Entry->if_descr[0]);
577 
578                     if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, KeyName, 0, KEY_READ, &InterfaceKey) != ERROR_SUCCESS)
579                     {
580                         TRACE("Failed opening interface key for interface %*s\n", Entry->if_descrlen, &Entry->if_descr[0]);
581                     }
582                     else
583                     {
584                         PIP_ADAPTER_DNS_SERVER_ADDRESS* ServerAddressPtr;
585 
586                         CurrentAA->FirstDnsServerAddress = (PIP_ADAPTER_DNS_SERVER_ADDRESS)Ptr;
587                         ServerAddressPtr = &CurrentAA->FirstDnsServerAddress;
588 
589                         EnumNameServers(InterfaceKey, NULL, &ServerAddressPtr, EnumerateServerName);
590                         RegCloseKey(InterfaceKey);
591 
592                         /* Set the last entry in the list as having NULL next member */
593                         Ptr = (BYTE*)*ServerAddressPtr;
594                         *ServerAddressPtr = NULL;
595                     }
596                 }
597 
598                 /* We're done for this interface */
599                 PreviousAA = CurrentAA;
600                 RemainingSize -= CurrentAASize;
601             }
602         }
603     }
604 
605     if (AdaptersCount == 0)
606     {
607         /* Uh? Not even localhost ?! */
608         ERR("No Adapters found!\n");
609         *pOutBufLen = 0;
610         return ERROR_NO_DATA;
611     }
612 
613     /* See if we have anything to add */
614     // FIXME: Anycast and multicast
615     if ((Flags & (GAA_FLAG_SKIP_UNICAST | GAA_FLAG_INCLUDE_PREFIX)) == GAA_FLAG_SKIP_UNICAST)
616         goto Success;
617 
618     /* Now fill in the addresses */
619     for (i = 0; i < InterfacesCount; i++)
620     {
621         /* Look for network layers */
622         if ((InterfacesList[i].tei_entity == CL_NL_ENTITY)
623                 || (InterfacesList[i].tei_entity == CO_NL_ENTITY))
624         {
625             IPSNMPInfo SnmpInfo;
626             PIP_ADAPTER_ADDRESSES CurrentAA = NULL;
627             IPAddrEntry* AddrEntries;
628             ULONG j;
629 
630             /* Get its SNMP info */
631             Status = GetSnmpInfo(TcpFile, InterfacesList[i], &SnmpInfo);
632             if (!NT_SUCCESS(Status))
633                 goto Error;
634 
635             if (SnmpInfo.ipsi_numaddr == 0)
636                 continue;
637 
638             /* Allocate the address entry array and get them */
639             AddrEntries = HeapAlloc(GetProcessHeap(),
640                 HEAP_ZERO_MEMORY,
641                 SnmpInfo.ipsi_numaddr * sizeof(AddrEntries[0]));
642             if (!AddrEntries)
643             {
644                 Status = STATUS_NO_MEMORY;
645                 goto Error;
646             }
647             Status = GetAddrEntries(TcpFile, InterfacesList[i], AddrEntries, SnmpInfo.ipsi_numaddr);
648             if (!NT_SUCCESS(Status))
649             {
650                 HeapFree(GetProcessHeap(), 0, AddrEntries);
651                 goto Error;
652             }
653 
654             for (j = 0; j < SnmpInfo.ipsi_numaddr; j++)
655             {
656                 /* Find the adapters struct for this address. */
657                 if (pAdapterAddresses)
658                 {
659                     CurrentAA = pAdapterAddresses;
660                     while (CurrentAA)
661                     {
662                         if (CurrentAA->IfIndex == AddrEntries[j].iae_index)
663                             break;
664 
665                         CurrentAA = CurrentAA->Next;
666                     }
667 
668                     if (!CurrentAA)
669                     {
670                         ERR("Got address for interface %u but no adapter was found for it.\n", AddrEntries[j].iae_index);
671                         /* Go to the next address */
672                         continue;
673                     }
674                 }
675 
676                 TRACE("address is 0x%08x, mask is 0x%08x\n", AddrEntries[j].iae_addr, AddrEntries[j].iae_mask);
677 
678                 //FIXME: For now reactos only supports unicast addresses
679                 if (!(Flags & GAA_FLAG_SKIP_UNICAST))
680                 {
681                     ULONG Size = sizeof(IP_ADAPTER_UNICAST_ADDRESS) + sizeof(SOCKADDR);
682 
683                     if (Ptr && (RemainingSize >= Size))
684                     {
685                         PIP_ADAPTER_UNICAST_ADDRESS UnicastAddress = (PIP_ADAPTER_UNICAST_ADDRESS)Ptr;
686 
687                         /* Fill in the structure */
688                         UnicastAddress->Length = sizeof(IP_ADAPTER_UNICAST_ADDRESS);
689                         UnicastAddress->Next = CurrentAA->FirstUnicastAddress;
690 
691                         // FIXME: Put meaningful value here
692                         UnicastAddress->Flags = 0;
693                         UnicastAddress->PrefixOrigin = IpPrefixOriginOther;
694                         UnicastAddress->SuffixOrigin = IpSuffixOriginOther;
695                         UnicastAddress->DadState = IpDadStatePreferred;
696                         UnicastAddress->ValidLifetime = 0xFFFFFFFF;
697                         UnicastAddress->PreferredLifetime = 0xFFFFFFFF;
698 
699                         /* Set the address */
700                         //FIXME: ipv4 only (again...)
701                         UnicastAddress->Address.lpSockaddr = (LPSOCKADDR)(UnicastAddress + 1);
702                         UnicastAddress->Address.iSockaddrLength = sizeof(SOCKADDR);
703                         UnicastAddress->Address.lpSockaddr->sa_family = AF_INET;
704                         ((LPSOCKADDR_IN)UnicastAddress->Address.lpSockaddr)->sin_port = 0;
705                         memcpy(&((LPSOCKADDR_IN)UnicastAddress->Address.lpSockaddr)->sin_addr, &AddrEntries[j].iae_addr, sizeof(AddrEntries[j].iae_addr));
706 
707                         CurrentAA->FirstUnicastAddress = UnicastAddress;
708                         Ptr += Size;
709                         RemainingSize -= Size;
710                     }
711 
712                     TotalSize += Size;
713                 }
714 
715                 if (Flags & GAA_FLAG_INCLUDE_PREFIX)
716                 {
717                     ULONG Size = sizeof(IP_ADAPTER_PREFIX) + sizeof(SOCKADDR);
718 
719                     if (Ptr && (RemainingSize >= Size))
720                     {
721                         PIP_ADAPTER_PREFIX Prefix = (PIP_ADAPTER_PREFIX)Ptr;
722 
723                         /* Fill in the structure */
724                         Prefix->Length = sizeof(IP_ADAPTER_PREFIX);
725                         Prefix->Next = CurrentAA->FirstPrefix;
726 
727                         /* Set the address */
728                         //FIXME: ipv4 only (again...)
729                         Prefix->Address.lpSockaddr = (LPSOCKADDR)(Prefix + 1);
730                         Prefix->Address.iSockaddrLength = sizeof(AddrEntries[j].iae_mask);
731                         Prefix->Address.lpSockaddr->sa_family = AF_INET;
732                         memcpy(Prefix->Address.lpSockaddr->sa_data, &AddrEntries[j].iae_mask, sizeof(AddrEntries[j].iae_mask));
733 
734                         /* Compute the prefix size */
735                         _BitScanReverse(&Prefix->PrefixLength, AddrEntries[j].iae_mask);
736 
737                         CurrentAA->FirstPrefix = Prefix;
738                         Ptr += Size;
739                         RemainingSize -= Size;
740                     }
741 
742                     TotalSize += Size;
743                 }
744             }
745 
746             HeapFree(GetProcessHeap(), 0, AddrEntries);
747         }
748     }
749 
750 Success:
751     /* We're done */
752     HeapFree(GetProcessHeap(), 0, InterfacesList);
753     NtClose(TcpFile);
754     *pOutBufLen = TotalSize;
755     TRACE("TotalSize: %x\n", *pOutBufLen);
756     return ERROR_SUCCESS;
757 
758 Error:
759     ERR("Failed! Status 0x%08x\n", Status);
760     *pOutBufLen = 0;
761     HeapFree(GetProcessHeap(), 0, InterfacesList);
762     NtClose(TcpFile);
763     return RtlNtStatusToDosError(Status);
764 }
765 #endif
766