Git conversion: Make reactos the root directory, move rosapps, rostests, wallpapers...
[reactos.git] / modules / rostests / drivers / tcpip / tcp_info.c
1 /*
2 * PROJECT: ReactOS kernel-mode tests
3 * LICENSE: GPLv2+ - See COPYING in the top level directory
4 * PURPOSE: Tests for IOCTL_TCP_QUERY_INFORMATION_EX
5 * PROGRAMMER: Jérôme Gardou <jerome.gardou@reactos.org>
6 */
7
8 #include <apitest.h>
9
10 #include <stdio.h>
11
12 #include <winioctl.h>
13 #include <tcpioctl.h>
14 #include <tdiinfo.h>
15 #include <iptypes.h>
16 #include <winsock.h>
17
18 /* FIXME */
19 #define AT_MIB_ADDRXLAT_INFO_ID 1
20 #define AT_MIB_ADDRXLAT_ENTRY_ID 0x101
21
22 /* Route info */
23 typedef struct IPRouteEntry {
24 unsigned long ire_dest;
25 unsigned long ire_index;
26 unsigned long ire_metric1;
27 unsigned long ire_metric2;
28 unsigned long ire_metric3;
29 unsigned long ire_metric4;
30 unsigned long ire_nexthop;
31 unsigned long ire_type;
32 unsigned long ire_proto;
33 unsigned long ire_age;
34 unsigned long ire_mask;
35 unsigned long ire_metric5;
36 unsigned long ire_context;
37 } IPRouteEntry;
38
39 /* Present in headers for Vista+, but there in WinXP/2k3 ntdll */
40 NTSYSAPI
41 PSTR
42 NTAPI
43 RtlIpv4AddressToStringA(
44 _In_ const struct in_addr *Addr,
45 _Out_writes_(16) PSTR S);
46
47
48 static HANDLE TcpFileHandle;
49
50 static ULONG IndentationLevel = 0;
51
52 static
53 char*
54 dbg_print_physaddr(const unsigned char* addr, unsigned long addr_len)
55 {
56 static char buffer[24];
57
58 char* dest = buffer;
59 *dest = '\0';
60
61 while (addr_len--)
62 {
63 dest += sprintf(dest, "%02x", *addr);
64 addr++;
65 if (addr_len)
66 *dest++ = ':';
67 }
68
69 return buffer;
70 }
71
72 static
73 int
74 __cdecl
75 indent_printf(const char* format, ...)
76 {
77 ULONG Indent = IndentationLevel;
78 int ret;
79 va_list args;
80
81 while(Indent--)
82 printf("\t");
83
84 va_start(args, format);
85 ret = vprintf(format, args);
86 va_end(args);
87
88 ret += IndentationLevel;
89
90 return ret;
91 }
92
93 static
94 void
95 test_IF_MIB_STATS(
96 TDIEntityID Id,
97 ULONG EntityType)
98 {
99 IFEntry* IfEntry;
100 TCP_REQUEST_QUERY_INFORMATION_EX Request;
101 ULONG BufferSize = sizeof(IFEntry) + MAX_ADAPTER_DESCRIPTION_LENGTH + 1;
102 BOOL Result;
103
104 /* Not valid for other entity types */
105 if (EntityType != IF_MIB)
106 return;
107
108 IfEntry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, BufferSize);
109 ok(IfEntry != NULL, "\n");
110
111 ZeroMemory(&Request, sizeof(Request));
112 Request.ID.toi_entity = Id;
113 Request.ID.toi_class = INFO_CLASS_PROTOCOL;
114 Request.ID.toi_type = INFO_TYPE_PROVIDER;
115 Request.ID.toi_id = IF_MIB_STATS_ID;
116
117 Result = DeviceIoControl(
118 TcpFileHandle,
119 IOCTL_TCP_QUERY_INFORMATION_EX,
120 &Request,
121 sizeof(Request),
122 IfEntry,
123 BufferSize,
124 &BufferSize,
125 NULL);
126 ok(Result, "DeviceIoControl failed.\n");
127
128 /* Dump it */
129 indent_printf("IF_MIB Statistics:\n");
130 IndentationLevel++;
131 indent_printf("if_index: %lu\n", IfEntry->if_index);
132 indent_printf("if_type: %lu\n", IfEntry->if_type);
133 indent_printf("if_mtu: %lu\n", IfEntry->if_mtu);
134 indent_printf("if_speed: %lu\n", IfEntry->if_speed);
135 indent_printf("if_physaddr: %s\n", dbg_print_physaddr(IfEntry->if_physaddr, IfEntry->if_physaddrlen));
136 indent_printf("if_adminstatus: %lu\n", IfEntry->if_adminstatus);
137 indent_printf("if_operstatus: %lu\n", IfEntry->if_operstatus);
138 indent_printf("if_lastchange: %lu\n", IfEntry->if_lastchange);
139 indent_printf("if_inoctets: %lu\n", IfEntry->if_inoctets);
140 indent_printf("if_inucastpkts: %lu\n", IfEntry->if_inucastpkts);
141 indent_printf("if_innucastpkts: %lu\n", IfEntry->if_innucastpkts);
142 indent_printf("if_indiscards: %lu\n", IfEntry->if_indiscards);
143 indent_printf("if_inerrors: %lu\n", IfEntry->if_inerrors);
144 indent_printf("if_inunknownprotos: %lu\n", IfEntry->if_inunknownprotos);
145 indent_printf("if_outoctets: %lu\n", IfEntry->if_outoctets);
146 indent_printf("if_outucastpkts: %lu\n", IfEntry->if_outucastpkts);
147 indent_printf("if_outnucastpkts: %lu\n", IfEntry->if_outnucastpkts);
148 indent_printf("if_outdiscards: %lu\n", IfEntry->if_outdiscards);
149 indent_printf("if_outerrors: %lu\n", IfEntry->if_outerrors);
150 indent_printf("if_outqlen: %lu\n", IfEntry->if_outqlen);
151 indent_printf("if_descr: %*s\n", IfEntry->if_descrlen, IfEntry->if_descr);
152 IndentationLevel--;
153
154 HeapFree(GetProcessHeap(), 0, IfEntry);
155 }
156
157 static
158 void
159 test_IP_MIB_STATS(
160 TDIEntityID Id,
161 ULONG EntityType)
162 {
163 IPSNMPInfo IpSnmpInfo;
164 TCP_REQUEST_QUERY_INFORMATION_EX Request;
165 ULONG BufferSize = 0;
166 BOOL Result;
167
168 /* Not valid for other entity types */
169 if (EntityType != CL_NL_IP)
170 return;
171
172 ZeroMemory(&IpSnmpInfo, sizeof(IpSnmpInfo));
173
174 ZeroMemory(&Request, sizeof(Request));
175 Request.ID.toi_entity = Id;
176 Request.ID.toi_class = INFO_CLASS_PROTOCOL;
177 Request.ID.toi_type = INFO_TYPE_PROVIDER;
178 Request.ID.toi_id = IP_MIB_STATS_ID;
179
180 Result = DeviceIoControl(
181 TcpFileHandle,
182 IOCTL_TCP_QUERY_INFORMATION_EX,
183 &Request,
184 sizeof(Request),
185 &IpSnmpInfo,
186 sizeof(IpSnmpInfo),
187 &BufferSize,
188 NULL);
189 ok(Result, "DeviceIoControl failed.\n");
190
191 /* Dump it */
192 indent_printf("IP_MIB Statistics:\n");
193 IndentationLevel++;
194 indent_printf("ipsi_forwarding: %lu\n", IpSnmpInfo.ipsi_forwarding);
195 indent_printf("ipsi_defaultttl: %lu\n", IpSnmpInfo.ipsi_defaultttl);
196 indent_printf("ipsi_inreceives: %lu\n", IpSnmpInfo.ipsi_inreceives);
197 indent_printf("ipsi_inhdrerrors: %lu\n", IpSnmpInfo.ipsi_inhdrerrors);
198 indent_printf("ipsi_inaddrerrors: %lu\n", IpSnmpInfo.ipsi_inaddrerrors);
199 indent_printf("ipsi_forwdatagrams: %lu\n", IpSnmpInfo.ipsi_forwdatagrams);
200 indent_printf("ipsi_inunknownprotos: %lu\n", IpSnmpInfo.ipsi_inunknownprotos);
201 indent_printf("ipsi_indiscards: %lu\n", IpSnmpInfo.ipsi_indiscards);
202 indent_printf("ipsi_indelivers: %lu\n", IpSnmpInfo.ipsi_indelivers);
203 indent_printf("ipsi_outrequests: %lu\n", IpSnmpInfo.ipsi_outrequests);
204 indent_printf("ipsi_routingdiscards: %lu\n", IpSnmpInfo.ipsi_routingdiscards);
205 indent_printf("ipsi_outdiscards: %lu\n", IpSnmpInfo.ipsi_outdiscards);
206 indent_printf("ipsi_outnoroutes: %lu\n", IpSnmpInfo.ipsi_outnoroutes);
207 indent_printf("ipsi_reasmtimeout: %lu\n", IpSnmpInfo.ipsi_reasmtimeout);
208 indent_printf("ipsi_reasmreqds: %lu\n", IpSnmpInfo.ipsi_reasmreqds);
209 indent_printf("ipsi_reasmoks: %lu\n", IpSnmpInfo.ipsi_reasmoks);
210 indent_printf("ipsi_reasmfails: %lu\n", IpSnmpInfo.ipsi_reasmfails);
211 indent_printf("ipsi_fragoks: %lu\n", IpSnmpInfo.ipsi_fragoks);
212 indent_printf("ipsi_fragfails: %lu\n", IpSnmpInfo.ipsi_fragfails);
213 indent_printf("ipsi_fragcreates: %lu\n", IpSnmpInfo.ipsi_fragcreates);
214 indent_printf("ipsi_numif: %lu\n", IpSnmpInfo.ipsi_numif);
215 indent_printf("ipsi_numaddr: %lu\n", IpSnmpInfo.ipsi_numaddr);
216 indent_printf("ipsi_numroutes: %lu\n", IpSnmpInfo.ipsi_numroutes);
217
218 if (IpSnmpInfo.ipsi_numaddr != 0)
219 {
220 IPAddrEntry* AddrEntries;
221 ULONG i;
222
223 AddrEntries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, IpSnmpInfo.ipsi_numaddr * sizeof(AddrEntries[0]));
224 ok(AddrEntries != NULL, "\n");
225
226 ZeroMemory(&Request, sizeof(Request));
227 Request.ID.toi_entity = Id;
228 Request.ID.toi_class = INFO_CLASS_PROTOCOL;
229 Request.ID.toi_type = INFO_TYPE_PROVIDER;
230 Request.ID.toi_id = IP_MIB_ADDRTABLE_ENTRY_ID;
231
232 Result = DeviceIoControl(
233 TcpFileHandle,
234 IOCTL_TCP_QUERY_INFORMATION_EX,
235 &Request,
236 sizeof(Request),
237 AddrEntries,
238 IpSnmpInfo.ipsi_numaddr * sizeof(AddrEntries[0]),
239 &BufferSize,
240 NULL);
241 ok(Result, "DeviceIoControl failed.\n");
242 ok_long(BufferSize, IpSnmpInfo.ipsi_numaddr * sizeof(AddrEntries[0]));
243
244 for(i = 0; i < IpSnmpInfo.ipsi_numaddr; i++)
245 {
246 CHAR AddressString[16];
247 struct in_addr Addr;
248
249 Addr.S_un.S_addr = AddrEntries[i].iae_addr;
250 RtlIpv4AddressToStringA(&Addr, AddressString);
251
252 indent_printf("Address %lu: %s\n", i, AddressString);
253
254 IndentationLevel++;
255
256 indent_printf("iae_addr: %lx\n", AddrEntries[i].iae_addr);
257 indent_printf("iae_index: %lu\n", AddrEntries[i].iae_index);
258 Addr.S_un.S_addr = AddrEntries[i].iae_mask;
259 RtlIpv4AddressToStringA(&Addr, AddressString);
260 indent_printf("iae_mask: %lx (%s)\n", AddrEntries[i].iae_mask, AddressString);
261 indent_printf("iae_bcastaddr: %lu\n", AddrEntries[i].iae_bcastaddr);
262 indent_printf("iae_reasmsize: %lu\n", AddrEntries[i].iae_reasmsize);
263 indent_printf("iae_context: %u\n", AddrEntries[i].iae_context);
264
265 {
266 IPInterfaceInfo* InterfaceInfo;
267
268 /* Get the interface info */
269 BufferSize = sizeof(IPInterfaceInfo) + MAX_PHYSADDR_SIZE;
270 InterfaceInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, BufferSize);
271 ok(InterfaceInfo != NULL, "\n");
272
273 Request.ID.toi_id = IP_INTFC_INFO_ID;
274 Request.Context[0] = AddrEntries[i].iae_addr;
275 Result = DeviceIoControl(
276 TcpFileHandle,
277 IOCTL_TCP_QUERY_INFORMATION_EX,
278 &Request,
279 sizeof(Request),
280 InterfaceInfo,
281 BufferSize,
282 &BufferSize,
283 NULL);
284 ok(Result, "DeviceIoControl failed.\n");
285
286 indent_printf("Interface info:\n");
287 IndentationLevel++;
288
289 indent_printf("iii_flags: %lu\n", InterfaceInfo->iii_flags);
290 indent_printf("iii_mtu : %lu\n", InterfaceInfo->iii_mtu);
291 indent_printf("iii_speed: %lu\n", InterfaceInfo->iii_speed);
292 indent_printf("iii_physaddr: %s\n", dbg_print_physaddr(InterfaceInfo->iii_addr, InterfaceInfo->iii_addrlength));
293
294 IndentationLevel--;
295 }
296
297 IndentationLevel--;
298 }
299
300 HeapFree(GetProcessHeap(), 0, AddrEntries);
301 }
302
303 /* See for the routes */
304 if (IpSnmpInfo.ipsi_numroutes)
305 {
306 IPRouteEntry* RouteEntries;
307 ULONG i;
308
309 RouteEntries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, IpSnmpInfo.ipsi_numroutes * sizeof(RouteEntries[0]));
310 ok(RouteEntries != NULL, "\n");
311
312 ZeroMemory(&Request, sizeof(Request));
313 Request.ID.toi_entity = Id;
314 Request.ID.toi_class = INFO_CLASS_PROTOCOL;
315 Request.ID.toi_type = INFO_TYPE_PROVIDER;
316 Request.ID.toi_id = IP_MIB_ARPTABLE_ENTRY_ID;
317
318 Result = DeviceIoControl(
319 TcpFileHandle,
320 IOCTL_TCP_QUERY_INFORMATION_EX,
321 &Request,
322 sizeof(Request),
323 RouteEntries,
324 IpSnmpInfo.ipsi_numroutes * sizeof(RouteEntries[0]),
325 &BufferSize,
326 NULL);
327 ok(Result, "DeviceIoControl failed.\n");
328 ok_long(BufferSize, IpSnmpInfo.ipsi_numroutes * sizeof(RouteEntries[0]));
329
330 for (i = 0; i < IpSnmpInfo.ipsi_numroutes; i++)
331 {
332 CHAR AddressString[16];
333 struct in_addr Addr;
334
335 Addr.S_un.S_addr = RouteEntries[i].ire_dest;
336 RtlIpv4AddressToStringA(&Addr, AddressString);
337
338 indent_printf("Route %lu:\n", i);
339
340 IndentationLevel++;
341
342 indent_printf("ire_dest: %s (%lx)\n", AddressString, RouteEntries[i].ire_dest);
343 indent_printf("ire_index: %lu\n", RouteEntries[i].ire_index);
344 indent_printf("ire_metric1: %#lx\n", RouteEntries[i].ire_metric1);
345 indent_printf("ire_metric2: %#lx\n", RouteEntries[i].ire_metric2);
346 indent_printf("ire_metric3: %#lx\n", RouteEntries[i].ire_metric3);
347 indent_printf("ire_metric4: %#lx\n", RouteEntries[i].ire_metric4);
348 Addr.S_un.S_addr = RouteEntries[i].ire_nexthop;
349 RtlIpv4AddressToStringA(&Addr, AddressString);
350 indent_printf("ire_nexthop: %s (%lx)\n", AddressString, RouteEntries[i].ire_nexthop);
351 indent_printf("ire_type: %lu\n", RouteEntries[i].ire_type);
352 indent_printf("ire_proto: %lu\n", RouteEntries[i].ire_proto);
353 indent_printf("ire_age: %lu\n", RouteEntries[i].ire_age);
354 Addr.S_un.S_addr = RouteEntries[i].ire_mask;
355 RtlIpv4AddressToStringA(&Addr, AddressString);
356 indent_printf("ire_mask: %s (%lx)\n", AddressString, RouteEntries[i].ire_mask);
357 indent_printf("ire_metric5: %lx\n", RouteEntries[i].ire_metric5);
358 indent_printf("ire_context: %lx\n", RouteEntries[i].ire_context);
359
360 IndentationLevel--;
361 }
362 }
363
364 IndentationLevel--;
365 }
366
367 typedef struct ARPInfo
368 {
369 unsigned long ai_numroutes;
370 unsigned long ai_unknown;
371 } ARPInfo;
372
373 typedef struct ARPEntry
374 {
375 unsigned long ae_index;
376 unsigned long ae_physaddrlen;
377 unsigned char ae_physaddr[MAX_PHYSADDR_SIZE];
378 unsigned long ae_address;
379 unsigned long ae_unknown;
380 } ARPEntry;
381
382 static
383 void
384 test_AT_ARP_STATS(
385 TDIEntityID Id,
386 ULONG EntityType)
387 {
388 ARPInfo ArpInfo;
389 TCP_REQUEST_QUERY_INFORMATION_EX Request;
390 ULONG BufferSize = 0;
391 BOOL Result;
392
393 /* Not valid for other entity types */
394 if (EntityType != AT_ARP)
395 return;
396
397 ZeroMemory(&Request, sizeof(Request));
398 Request.ID.toi_entity = Id;
399 Request.ID.toi_class = INFO_CLASS_PROTOCOL;
400 Request.ID.toi_type = INFO_TYPE_PROVIDER;
401 Request.ID.toi_id = AT_MIB_ADDRXLAT_INFO_ID;
402
403 Result = DeviceIoControl(
404 TcpFileHandle,
405 IOCTL_TCP_QUERY_INFORMATION_EX,
406 &Request,
407 sizeof(Request),
408 &ArpInfo,
409 sizeof(ArpInfo),
410 &BufferSize,
411 NULL);
412 ok(Result, "DeviceIoControl failed.\n");
413 ok_long(BufferSize, sizeof(ArpInfo));
414
415 indent_printf("ARP Info:\n");
416 IndentationLevel++;
417
418 indent_printf("ai_numroutes: %lu\n", ArpInfo.ai_numroutes);
419 indent_printf("ai_unknown: %lx\n", ArpInfo.ai_unknown);
420
421 if (ArpInfo.ai_numroutes)
422 {
423 ARPEntry* ArpEntries;
424 ULONG i;
425
426 Request.ID.toi_id = AT_MIB_ADDRXLAT_ENTRY_ID;
427
428 ArpEntries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ArpInfo.ai_numroutes * sizeof(ArpEntries[0]));
429 ok(ArpEntries != NULL, "\n");
430
431 Result = DeviceIoControl(
432 TcpFileHandle,
433 IOCTL_TCP_QUERY_INFORMATION_EX,
434 &Request,
435 sizeof(Request),
436 ArpEntries,
437 ArpInfo.ai_numroutes * sizeof(ArpEntries[0]),
438 &BufferSize,
439 NULL);
440 ok(Result, "DeviceIoControl failed.\n");
441 ok_long(BufferSize, ArpInfo.ai_numroutes * sizeof(ArpEntries[0]));
442
443 for (i = 0; i < ArpInfo.ai_numroutes; i++)
444 {
445 CHAR AddressString[16];
446 struct in_addr Addr;
447
448 Addr.S_un.S_addr = ArpEntries[i].ae_address;
449 RtlIpv4AddressToStringA(&Addr, AddressString);
450
451 indent_printf("ARP Entry %lu:\n", i);
452
453 IndentationLevel++;
454
455 indent_printf("ae_index: %lu\n", ArpEntries[i].ae_index);
456 indent_printf("ae_physaddr: %s\n", dbg_print_physaddr(ArpEntries[i].ae_physaddr, ArpEntries[i].ae_physaddrlen));
457 indent_printf("ae_address: %lx (%s)\n", ArpEntries[i].ae_address, AddressString);
458 indent_printf("ae_unknown: %lu.\n", ArpEntries[i].ae_unknown);
459
460 IndentationLevel--;
461 }
462
463 HeapFree(GetProcessHeap(), 0, ArpEntries);
464 }
465
466 IndentationLevel--;
467 }
468
469 START_TEST(tcp_info)
470 {
471 TDIEntityID* Entities;
472 DWORD BufferSize;
473 BOOL Result;
474 ULONG i, EntityCount;
475 TCP_REQUEST_QUERY_INFORMATION_EX Request;
476
477 /* Open a control channel file for TCP */
478 TcpFileHandle = CreateFileW(
479 L"\\\\.\\Tcp",
480 FILE_READ_DATA | FILE_WRITE_DATA,
481 FILE_SHARE_READ | FILE_SHARE_WRITE,
482 NULL,
483 OPEN_EXISTING,
484 0,
485 NULL);
486 ok(TcpFileHandle != INVALID_HANDLE_VALUE, "CreateFile failed, GLE %lu\n", GetLastError());
487
488 /* Try the IOCTL */
489 BufferSize = 0;
490 Result = DeviceIoControl(
491 TcpFileHandle,
492 IOCTL_TCP_QUERY_INFORMATION_EX,
493 NULL,
494 0,
495 NULL,
496 0,
497 &BufferSize,
498 NULL);
499 ok(!Result, "DeviceIoControl succeeded.\n");
500 ok_long(GetLastError(), ERROR_INVALID_PARAMETER);
501 ok_long(BufferSize, 0);
502
503 ZeroMemory(&Request, sizeof(Request));
504 Request.ID.toi_entity.tei_entity = GENERIC_ENTITY;
505 Request.ID.toi_entity.tei_instance = 0;
506 Request.ID.toi_class = INFO_CLASS_GENERIC;
507 Request.ID.toi_type = INFO_TYPE_PROVIDER;
508 Request.ID.toi_id = ENTITY_LIST_ID;
509
510 BufferSize = 0;
511 Result = DeviceIoControl(
512 TcpFileHandle,
513 IOCTL_TCP_QUERY_INFORMATION_EX,
514 &Request,
515 sizeof(Request),
516 NULL,
517 0,
518 &BufferSize,
519 NULL);
520 ok(!Result, "DeviceIoControl succeeded.\n");
521 ok_long(GetLastError(), ERROR_INVALID_PARAMETER);
522 ok_long(BufferSize, 0);
523
524 BufferSize = 4 * sizeof(Entities[0]);
525 Entities = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, BufferSize);
526 ok(Entities != NULL, "\n");
527
528 while (TRUE)
529 {
530 Result = DeviceIoControl(
531 TcpFileHandle,
532 IOCTL_TCP_QUERY_INFORMATION_EX,
533 &Request,
534 sizeof(Request),
535 Entities,
536 BufferSize,
537 &BufferSize,
538 NULL);
539
540 if (Result)
541 break;
542
543 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
544 break;
545
546 BufferSize *= 2;
547 Entities = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Entities, BufferSize);
548 ok(Entities != NULL, "\n");
549 }
550
551 ok(Result, "DeviceIoControl failed!\n");
552 EntityCount = BufferSize / sizeof(Entities[0]);
553 trace("Got %lu entities.\n", EntityCount);
554
555 for (i = 0; i < EntityCount; i++)
556 {
557 ULONG EntityType;
558
559 /* Get the type */
560 Request.ID.toi_entity = Entities[i];
561 Request.ID.toi_class = INFO_CLASS_GENERIC;
562 Request.ID.toi_type = INFO_TYPE_PROVIDER;
563 Request.ID.toi_id = ENTITY_TYPE_ID;
564
565 Result = DeviceIoControl(
566 TcpFileHandle,
567 IOCTL_TCP_QUERY_INFORMATION_EX,
568 &Request,
569 sizeof(Request),
570 &EntityType,
571 sizeof(EntityType),
572 &BufferSize,
573 NULL);
574 ok(Result, "DeviceIoControl failed.\n");
575
576 printf("Entity %lu: %#lx, %#lx, type %#lx\n", i, Entities[i].tei_entity, Entities[i].tei_instance, EntityType);
577 test_IF_MIB_STATS(Entities[i], EntityType);
578 test_IP_MIB_STATS(Entities[i], EntityType);
579 test_AT_ARP_STATS(Entities[i], EntityType);
580 }
581
582 HeapFree(GetProcessHeap(), 0, Entities);
583 CloseHandle(TcpFileHandle);
584 }