[WINSPOOL] Implement DocumentPropertiesA including DEVMODE conversions (#2339)
[reactos.git] / dll / win32 / iphlpapi / address.c
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 FIXME("GetAdaptersAddresses - Semi Stub: 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