@samitouri / QOSAMI-WSL
Code Commits Issues Pulls Sessions CI/CD
master
master
c 5,394 lines 185 KB
Raw
1 /*++
2
3 Copyright (c) Microsoft. All rights reserved.
4
5 Module Name:
6
7 netlink.c
8
9 Abstract:
10
11 Linux socket test for the AF_NETLINK family.
12
13 --*/
14
15 #include "lxtcommon.h"
16 #include "unittests.h"
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include <string.h>
20 #include <unistd.h>
21 #include <sys/types.h>
22 #include <sys/socket.h>
23 #include <sys/un.h>
24 #include <sys/ioctl.h>
25 #include <net/if.h>
26 #include <net/if_arp.h>
27 #include <arpa/inet.h>
28 #include <netinet/in.h>
29 #include <netinet/ip.h>
30 #include <netinet/udp.h>
31 #include <netinet/tcp.h>
32 #include <linux/icmp.h>
33 #include <netinet/icmp6.h>
34 #include <net/if.h>
35 #include <netdb.h>
36 #include <fcntl.h>
37 #include <time.h>
38 #include <pthread.h>
39 #include <poll.h>
40 #include <sys/epoll.h>
41 #include <sys/time.h>
42 #include <sys/prctl.h>
43 #include <asm/types.h>
44 #include <linux/netlink.h>
45 #include <linux/rtnetlink.h>
46 #include "common.h"
47
48 #define LXT_NAME "Netlink"
49
50 #define ATTRIBUTE_DUMP_BUFFER_SIZE 60
51
52 #define min(a, b) (((a) < (b)) ? (a) : (b))
53
54 #define SOCKET_LOOPBACK_IF_NAME "lo"
55
56 #define NLMSG_TAIL(nmsg) ((struct rtattr*)(((void*)(nmsg)) + NLMSG_ALIGN((nmsg)->nlmsg_len)))
57
58 const int MessageTypes[] = {
59 RTM_DELADDR, RTM_DELLINK, RTM_DELROUTE, RTM_GETADDR, RTM_GETLINK, RTM_GETNSID, RTM_GETROUTE, RTM_NEWADDR, RTM_NEWLINK, RTM_NEWROUTE, RTM_SETLINK};
60
61 const int SupportedFamily[] = {NETLINK_ROUTE};
62 const int SupportedType[] = {SOCK_DGRAM, SOCK_RAW};
63
64 typedef struct _NetlinkRecvmmsgBlockedReaderParams
65 {
66 int Socket;
67 int Option;
68 } NetlinkRecvmmsgBlockedReaderParams;
69
70 typedef struct _BindChildThreadReturn
71 {
72 pid_t nl_pid;
73 } BindChildThreadReturn;
74
75 LXT_VARIATION_HANDLER SocketNetlinkOpenClose;
76 LXT_VARIATION_HANDLER SocketNetlinkBasic;
77 LXT_VARIATION_HANDLER SocketNetlinkBind;
78 LXT_VARIATION_HANDLER SocketNetlinkBindThread;
79 LXT_VARIATION_HANDLER SocketNetlinkSendReceive;
80 LXT_VARIATION_HANDLER SocketNetlinkSendReceiveOverflow;
81 LXT_VARIATION_HANDLER SocketNetlinkBlockedReader;
82 LXT_VARIATION_HANDLER SocketNetlinkEpoll;
83 LXT_VARIATION_HANDLER SocketNetlinkRecvmmsg;
84 LXT_VARIATION_HANDLER SocketNetlinkSendBadMessage;
85 LXT_VARIATION_HANDLER SocketNetlinkRouteGetAddr;
86 LXT_VARIATION_HANDLER SocketNetlinkRouteGetLink;
87 LXT_VARIATION_HANDLER SocketNetlinkRouteGetRouteBestRoute;
88 LXT_VARIATION_HANDLER SocketNetlinkRouteGetRouteDump;
89 LXT_VARIATION_HANDLER SocketNetlinkRouteNewDelAddress;
90 LXT_VARIATION_HANDLER SocketNetlinkRouteNewDelRoute;
91 LXT_VARIATION_HANDLER SocketNetlinkSoPasscred;
92
93 void* SocketNetlinkBindThreadChild(void* Arg);
94
95 bool SocketNetlinkIsIpv6Configured();
96
97 void* SocketNetlinkRecvmmsgBlockedReaderThread(void* Arg);
98
99 void SocketNetlinkRouteDumpAttributeData(char* Buffer, int BufferSize, struct rtattr* Attribute);
100
101 int SocketNetlinkRouteGetLinkCheckResponse(int Socket, int OnlyOneLoopback);
102
103 int SocketNetlinkRouteGetRouteBestRouteCheckResponse(int Socket, int CheckGateway);
104
105 int SocketNetlinkGetLoopbackIndex();
106
107 int SocketNetlinkCheckResponseError(void* ReceiveBuffer, int ReceiveResult, int Error);
108
109 int SocketNetlinkRouteAddAttribute(struct nlmsghdr* Msghdr, int MessageSize, int AttributeType, void* AttributeData, int AttributeSize);
110
111 void SocketNetlinkRouteAddAddressAttributes(struct nlmsghdr* Msghdr, int MessageSize, struct in_addr* AddressIpv4);
112
113 void SocketNetlinkRouteAddRouteAttributes(
114 struct nlmsghdr* Msghdr, int MessageSize, struct in_addr* DestinationIpv4, struct in_addr* GatewayIpv4, int InterfaceIndex);
115
116 int SocketNetlinkSendAndWaitForExpectedError(int Socket, void* Request, int RequestSize, int ExpectedError);
117
118 int SocketNetlinkSetAndVerifySocketOptionTimeout(int Socket, int SocketOption, int Usec);
119
120 static const LXT_VARIATION g_LxtVariations[] = {
121 {"Open, close", SocketNetlinkOpenClose},
122 {"Basic netlink operations", SocketNetlinkBasic},
123 {"bind, getsockname (with fork)", SocketNetlinkBind},
124 {"bind, getsockname (with pthread_create)", SocketNetlinkBindThread},
125 {"Send and receive basic (sending to kernel)", SocketNetlinkSendReceive},
126 {"Send and receive where the receive buffer overflows (sending to kernel)", SocketNetlinkSendReceiveOverflow},
127 {"Blocked reader thread", SocketNetlinkBlockedReader},
128 {"epoll", SocketNetlinkEpoll},
129 {"Recvmmsg syscall", SocketNetlinkRecvmmsg},
130 {"Sending bad Netlink messages", SocketNetlinkSendBadMessage},
131 {"NETLINK_ROUTE RTM_GETADDR message", SocketNetlinkRouteGetAddr},
132 {"NETLINK_ROUTE RTM_GETLINK message", SocketNetlinkRouteGetLink},
133 {"NETLINK_ROUTE RTM_GETROUTE message - get best route", SocketNetlinkRouteGetRouteBestRoute},
134 {"NETLINK_ROUTE RTM_GETROUTE message - dump all routing entries", SocketNetlinkRouteGetRouteDump},
135 {"NETLINK_ROUTE RTM_NEWADDR and RTM_DELADDR message", SocketNetlinkRouteNewDelAddress},
136 {"NETLINK_ROUTE RTM_NEWROUTE and RTM_DELROUTE message", SocketNetlinkRouteNewDelRoute},
137 {"SO_PASSCRED", SocketNetlinkSoPasscred},
138 };
139
140 //
141 // Function definitions.
142 //
143
144 int NetlinkTestEntry(int Argc, char* Argv[])
145
146 /*++
147
148 Routine Description:
149
150 This routine main entry point for the test for get*id,set*id system call.
151
152 Arguments:
153
154 Argc - Supplies the number of command line arguments.
155
156 Argv - Supplies the command line arguments.
157
158 Return Value:
159
160 Returns 0 on success, -1 on failure.
161
162 --*/
163
164 {
165
166 LXT_ARGS Args;
167 int Result;
168
169 LxtCheckResult(LxtInitialize(Argc, Argv, &Args, LXT_NAME));
170
171 //
172 // Run test cases.
173 //
174
175 LxtCheckResult(LxtRunVariations(&Args, g_LxtVariations, LXT_COUNT_OF(g_LxtVariations)));
176
177 ErrorExit:
178 LxtUninitialize();
179 return !LXT_SUCCESS(Result);
180 }
181
182 bool SocketNetlinkIsIpv6Configured()
183
184 /*++
185
186 Routine Description:
187
188 This routine checks if an IPv6 address has been configured.
189
190 Arguments:
191
192 None.
193
194 Return Value:
195
196 Returns true if an IPv6 address is available.
197
198 --*/
199
200 {
201
202 socklen_t AddressLength;
203 struct rtattr* Attribute;
204 char AttributeDump[ATTRIBUTE_DUMP_BUFFER_SIZE];
205 struct sockaddr_nl BindAddress;
206 int FoundDone;
207 struct nlmsghdr* Header;
208 struct ifaddrmsg* IfAddrMsg;
209 bool IpV6AddressValid;
210 int LoopbackIndex;
211 char ReceiveBuffer[5000];
212 int ReceiveResult;
213 int RemainingLength;
214 int Result;
215 int Socket;
216
217 struct
218 {
219 struct nlmsghdr nlh;
220 struct ifinfomsg ifm;
221 struct rtattr ext_req __attribute__((aligned(NLMSG_ALIGNTO)));
222 __u32 ext_filter_mask;
223 } Request;
224
225 IpV6AddressValid = false;
226
227 LxtCheckErrnoZeroSuccess(SocketNetlinkGetLoopbackIndex(&LoopbackIndex));
228
229 //
230 // Create and bind socket. Create a RTM_GETADDR request.
231 //
232
233 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
234 memset(&BindAddress, 0, sizeof(BindAddress));
235 BindAddress.nl_family = AF_NETLINK;
236 AddressLength = sizeof(BindAddress);
237 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
238
239 memset(&Request, 0, sizeof(Request));
240 Request.nlh.nlmsg_len = sizeof(Request);
241 Request.nlh.nlmsg_type = RTM_GETADDR;
242 Request.nlh.nlmsg_seq = 0x4563;
243 Request.ifm.ifi_family = AF_NETLINK;
244 Request.ext_req.rta_type = IFLA_EXT_MASK;
245 Request.ext_req.rta_len = RTA_LENGTH(sizeof(__u32));
246 Request.ext_filter_mask = RTEXT_FILTER_VF;
247 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;
248 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
249 FoundDone = 0;
250 for (;;)
251 {
252 LxtCheckErrno(ReceiveResult = recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0, NULL, 0));
253
254 Header = (struct nlmsghdr*)ReceiveBuffer;
255 while (!IpV6AddressValid && NLMSG_OK(Header, ReceiveResult))
256 {
257 if (Header->nlmsg_type == NLMSG_DONE)
258 {
259 FoundDone = 1;
260 break;
261 }
262
263 IfAddrMsg = (struct ifaddrmsg*)NLMSG_DATA(Header);
264 if ((IfAddrMsg->ifa_index != LoopbackIndex) && (IfAddrMsg->ifa_family == AF_INET6))
265 {
266
267 Attribute = (struct rtattr*)((char*)IfAddrMsg + sizeof(struct ifaddrmsg));
268
269 RemainingLength = Header->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifaddrmsg));
270
271 while (RTA_OK(Attribute, RemainingLength))
272 {
273 SocketNetlinkRouteDumpAttributeData(AttributeDump, ATTRIBUTE_DUMP_BUFFER_SIZE, Attribute);
274
275 //
276 // If the address is IPv6 and does not start with the link
277 // local prefix, assume it is a valid address.
278 //
279
280 if ((Attribute->rta_type == IFA_ADDRESS) && strncmp(AttributeDump, "fe 80", 5) != 0)
281 {
282
283 LxtLogInfo("IpV6 address found: %s", AttributeDump);
284 IpV6AddressValid = true;
285 break;
286 }
287
288 Attribute = RTA_NEXT(Attribute, RemainingLength);
289 }
290 }
291
292 Header = NLMSG_NEXT(Header, ReceiveResult);
293 }
294
295 if (IpV6AddressValid || (FoundDone == 1))
296 {
297 break;
298 }
299 }
300
301 ErrorExit:
302 if (Socket > 0)
303 {
304 close(Socket);
305 }
306
307 return IpV6AddressValid;
308 }
309
310 int SocketNetlinkOpenClose(PLXT_ARGS Args)
311
312 /*++
313
314 Routine Description:
315
316 This routine tests the socket() API.
317
318 Arguments:
319
320 Args - Supplies the command line arguments.
321
322 Return Value:
323
324 Returns 0 on success, -1 on failure.
325
326 --*/
327
328 {
329
330 int FamilyIterator;
331 int Result;
332 int Socket;
333 int TypeIterator;
334
335 Result = LXT_RESULT_FAILURE;
336 Socket = -1;
337
338 for (TypeIterator = 0; TypeIterator < sizeof(SupportedType) / sizeof(int); TypeIterator++)
339 {
340
341 for (FamilyIterator = 0; FamilyIterator < sizeof(SupportedFamily) / sizeof(int); FamilyIterator++)
342 {
343
344 LxtLogInfo("testing type: %d, netlink family: %d", SupportedType[TypeIterator], SupportedFamily[FamilyIterator]);
345
346 //
347 // Success cases.
348 //
349
350 LxtCheckErrno((Socket = socket(AF_NETLINK, SupportedType[TypeIterator], SupportedFamily[FamilyIterator])));
351
352 LxtClose(Socket);
353
354 //
355 // Test case: Overloading 'type' field for netlink sockets.
356 //
357
358 LxtCheckErrno((Socket = socket(AF_NETLINK, SupportedType[TypeIterator] | O_NONBLOCK, SupportedFamily[FamilyIterator])));
359
360 LxtClose(Socket);
361 LxtCheckErrno((Socket = socket(AF_NETLINK, SupportedType[TypeIterator] | O_CLOEXEC, SupportedFamily[FamilyIterator])));
362
363 LxtClose(Socket);
364 LxtCheckErrno((Socket = socket(AF_NETLINK, SupportedType[TypeIterator] | O_NONBLOCK | O_CLOEXEC, SupportedFamily[FamilyIterator])));
365
366 LxtClose(Socket);
367 }
368 }
369
370 //
371 // Test case: Failure cases for socket(), unsupported type, family.
372 //
373
374 LxtCheckErrnoFailure(socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE + 100), EPROTONOSUPPORT);
375
376 LxtCheckErrnoFailure(socket(AF_NETLINK, SOCK_STREAM, NETLINK_ROUTE), ESOCKTNOSUPPORT);
377
378 ErrorExit:
379 if (Socket > 0)
380 {
381 close(Socket);
382 }
383
384 return Result;
385 }
386
387 int SocketNetlinkBasic(PLXT_ARGS Args)
388
389 /*++
390
391 Routine Description:
392
393 This routine tests basic operations on netlink sockets.
394
395 Arguments:
396
397 Args - Supplies the command line arguments.
398
399 Return Value:
400
401 Returns 0 on success, -1 on failure.
402
403 --*/
404
405 {
406
407 socklen_t AddressLength;
408 struct sockaddr_nl BindAddress;
409 int BufferSize;
410 int FamilyIterator;
411 socklen_t OptionLength;
412 int OptionInt;
413 char ReceiveBuffer[500];
414 int Result;
415 int Socket;
416 int SocketError;
417 struct timeval Timeout;
418 int TypeIterator;
419
420 Result = LXT_RESULT_FAILURE;
421 Socket = -1;
422
423 for (TypeIterator = 0; TypeIterator < sizeof(SupportedType) / sizeof(int); TypeIterator++)
424 {
425
426 for (FamilyIterator = 0; FamilyIterator < sizeof(SupportedFamily) / sizeof(int); FamilyIterator++)
427 {
428
429 LxtCheckErrno(Socket = socket(AF_NETLINK, SupportedType[TypeIterator], SupportedFamily[FamilyIterator]));
430
431 memset(&BindAddress, 0, sizeof(BindAddress));
432 BindAddress.nl_family = AF_NETLINK;
433 AddressLength = sizeof(BindAddress);
434 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
435 OptionLength = sizeof(BufferSize);
436 BufferSize = 2345;
437 LxtCheckErrno(setsockopt(Socket, SOL_SOCKET, SO_SNDBUF, &BufferSize, OptionLength));
438
439 LxtCheckErrno(getsockopt(Socket, SOL_SOCKET, SO_SNDBUF, &BufferSize, &OptionLength));
440
441 LxtCheckEqual(OptionLength, sizeof(BufferSize), "%d");
442 LxtCheckEqual(BufferSize, 2345 * 2, "%d");
443
444 OptionLength = sizeof(BufferSize);
445 BufferSize = 6345;
446 LxtCheckErrno(setsockopt(Socket, SOL_SOCKET, SO_RCVBUF, &BufferSize, OptionLength));
447
448 LxtCheckErrno(getsockopt(Socket, SOL_SOCKET, SO_RCVBUF, &BufferSize, &OptionLength));
449
450 LxtCheckEqual(OptionLength, sizeof(BufferSize), "%d");
451 LxtCheckEqual(BufferSize, 6345 * 2, "%d");
452
453 //
454 // Set a timeout value of 8 milliseconds for the send.
455 //
456
457 LxtCheckResult(SocketNetlinkSetAndVerifySocketOptionTimeout(Socket, SO_SNDTIMEO, 8000));
458
459 //
460 // Set a timeout value of 8 milliseconds for the receive.
461 //
462
463 LxtCheckResult(SocketNetlinkSetAndVerifySocketOptionTimeout(Socket, SO_RCVTIMEO, 8000));
464
465 //
466 // Check that the blocking read will timeout with EAGAIN
467 // after 8 milliseconds.
468 //
469
470 LxtCheckErrnoFailure(read(Socket, ReceiveBuffer, sizeof(ReceiveBuffer)), EAGAIN);
471
472 //
473 // Check that the value of SO_ERROR is 0 (no error).
474 //
475
476 SocketError = 1234;
477 OptionLength = sizeof(SocketError);
478 LxtCheckErrno(getsockopt(Socket, SOL_SOCKET, SO_ERROR, &SocketError, &OptionLength));
479
480 LxtCheckEqual(OptionLength, sizeof(SocketError), "%d");
481 LxtCheckEqual(SocketError, 0, "%d");
482
483 OptionLength = sizeof(OptionInt);
484 LxtCheckErrno(getsockopt(Socket, SOL_SOCKET, SO_TYPE, &OptionInt, &OptionLength));
485
486 LxtCheckEqual(OptionLength, sizeof(OptionInt), "%d");
487 LxtCheckEqual(OptionInt, SupportedType[TypeIterator], "%d");
488
489 OptionLength = sizeof(OptionInt);
490 LxtCheckErrno(getsockopt(Socket, SOL_SOCKET, SO_PROTOCOL, &OptionInt, &OptionLength));
491
492 LxtCheckEqual(OptionLength, sizeof(OptionInt), "%d");
493 LxtCheckEqual(OptionInt, SupportedFamily[FamilyIterator], "%d");
494
495 OptionLength = sizeof(OptionInt);
496 LxtCheckErrno(getsockopt(Socket, SOL_SOCKET, SO_DOMAIN, &OptionInt, &OptionLength));
497
498 LxtCheckEqual(OptionLength, sizeof(OptionInt), "%d");
499 LxtCheckEqual(OptionInt, AF_NETLINK, "%d");
500 LxtClose(Socket);
501 }
502 }
503
504 ErrorExit:
505 if (Socket > 0)
506 {
507 close(Socket);
508 }
509
510 return Result;
511 }
512
513 int SocketNetlinkBind(PLXT_ARGS Args)
514
515 /*++
516
517 Routine Description:
518
519 This routine tests the bind() API.
520
521 Arguments:
522
523 Args - Supplies the command line arguments.
524
525 Return Value:
526
527 Returns 0 on success, -1 on failure.
528
529 --*/
530
531 {
532
533 char AddressBuffer[150];
534 socklen_t AddressLength;
535 int ArrayIterator;
536 int ArrayIterator2;
537 const int ArraySize = 10;
538 struct sockaddr_nl BindAddress;
539 struct sockaddr_nl* BindAddressP;
540 int ChildPid;
541 char DataBuffer[10];
542 int Family;
543 int FamilyIterator;
544 int Result;
545 uint32_t SavedPid;
546 int Socket;
547 int Socket2;
548 int Socket3;
549 int Socket4;
550 int SocketA[ArraySize];
551 int SocketChildA[ArraySize];
552 int SocketChildPid[ArraySize];
553 int SocketPid[ArraySize];
554 int Type;
555 int TypeIterator;
556
557 Result = LXT_RESULT_FAILURE;
558 Socket = -1;
559 Socket2 = -1;
560 Socket3 = -1;
561 Socket4 = -1;
562 ChildPid = -1;
563 for (TypeIterator = 0; TypeIterator < sizeof(SupportedType) / sizeof(int); TypeIterator++)
564 {
565
566 Type = SupportedType[TypeIterator];
567 for (FamilyIterator = 0; FamilyIterator < sizeof(SupportedFamily) / sizeof(int); FamilyIterator++)
568 {
569
570 //
571 // First thing; initialize the various array.
572 //
573
574 for (ArrayIterator = 0; ArrayIterator < ArraySize; ArrayIterator++)
575 {
576 SocketA[ArrayIterator] = 0;
577 SocketPid[ArrayIterator] = 0;
578 SocketChildPid[ArrayIterator] = 0;
579 }
580
581 Family = SupportedFamily[FamilyIterator];
582 LxtLogInfo("testing type: %d, netlink family: %d", SupportedType[TypeIterator], SupportedFamily[FamilyIterator]);
583
584 //
585 // Test case: bind with invalid family value in the address.
586 //
587
588 LxtCheckErrno(Socket = socket(AF_NETLINK, Type, Family));
589 memset(&BindAddress, 0, sizeof(BindAddress));
590 BindAddress.nl_family = AF_INET;
591 AddressLength = sizeof(BindAddress);
592 LxtCheckErrnoFailure(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength), EINVAL);
593
594 LxtClose(Socket);
595
596 //
597 // Test case: bind with invalid address length.
598 //
599
600 LxtCheckErrno(Socket = socket(AF_NETLINK, Type, Family));
601 memset(&BindAddress, 0, sizeof(BindAddress));
602 BindAddress.nl_family = AF_NETLINK;
603 AddressLength = sizeof(BindAddress.nl_family);
604 LxtCheckErrnoFailure(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength), EINVAL);
605
606 LxtClose(Socket);
607
608 //
609 // Test case: address length > sizeof(sockaddr_nl) is also invalid.
610 //
611
612 LxtCheckErrno(Socket = socket(AF_NETLINK, Type, Family));
613 BindAddressP = (struct sockaddr_nl*)AddressBuffer;
614 memset(AddressBuffer, 0, sizeof(AddressBuffer));
615 BindAddressP->nl_family = AF_NETLINK;
616 AddressLength = sizeof(AddressBuffer);
617 LxtCheckErrnoFailure(bind(Socket, (struct sockaddr*)BindAddressP, AddressLength), EINVAL);
618
619 LxtClose(Socket);
620
621 //
622 // Test case: getsockname on unbound socket returns nl_pid = 0.
623 //
624
625 LxtCheckErrno(Socket = socket(AF_NETLINK, Type, Family));
626 memset(&BindAddress, 0, sizeof(BindAddress));
627 AddressLength = sizeof(BindAddress);
628 LxtCheckErrno(getsockname(Socket, (struct sockaddr*)&BindAddress, &AddressLength));
629
630 LxtCheckEqual(BindAddress.nl_pid, 0, "%d");
631 LxtCheckEqual(AddressLength, sizeof(BindAddress), "%d");
632 LxtClose(Socket);
633
634 //
635 // Test case: calling sendto() on unbound socket automatically
636 // binds the socket (even if the sendto() fails).
637 //
638
639 LxtCheckErrno(Socket = socket(AF_NETLINK, Type, Family));
640 memset(DataBuffer, 0, sizeof(DataBuffer));
641 memset(&BindAddress, 0, sizeof(BindAddress));
642 BindAddress.nl_family = AF_NETLINK;
643 AddressLength = sizeof(BindAddress);
644 sendto(Socket, DataBuffer, sizeof(DataBuffer), 0, (struct sockaddr*)&BindAddress, AddressLength);
645
646 memset(&BindAddress, 0, sizeof(BindAddress));
647 LxtCheckErrno(getsockname(Socket, (struct sockaddr*)&BindAddress, &AddressLength));
648
649 LxtCheckEqual(BindAddress.nl_pid, getpid(), "%d");
650 LxtCheckEqual(AddressLength, sizeof(BindAddress), "%d");
651 LxtClose(Socket);
652
653 //
654 // Test case: Bind with nl_pid = 0, kernel should assign a unique
655 // ID. The first netlink socket of the process is
656 // assigned the process ID as the nl_pid. It also confirms
657 // the pad value is ignored.
658 //
659
660 LxtCheckErrno(Socket = socket(AF_NETLINK, Type, Family));
661 memset(&BindAddress, 0, sizeof(BindAddress));
662 BindAddress.nl_family = AF_NETLINK;
663 BindAddress.nl_pad = 1;
664 AddressLength = sizeof(BindAddress);
665 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
666
667 memset(&BindAddress, 0, sizeof(BindAddress));
668 LxtCheckErrno(getsockname(Socket, (struct sockaddr*)&BindAddress, &AddressLength));
669
670 LxtCheckEqual(BindAddress.nl_pid, getpid(), "%d");
671 LxtCheckEqual(AddressLength, sizeof(BindAddress), "%d");
672
673 //
674 // Validate that a socket that is already bound, cannot be bound again.
675 //
676
677 memset(&BindAddress, 0, sizeof(BindAddress));
678 BindAddress.nl_family = AF_NETLINK;
679 AddressLength = sizeof(BindAddress);
680 LxtCheckErrnoFailure(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength), EINVAL);
681
682 //
683 // Test case: The user specifies a negative nl_pid (which is what the
684 // kernel assigns to the non-first sockets of the process).
685 // Test that the kernel will skip any negative nl_pid's that
686 // the user already specified. For example, Socket2 gets
687 // an auto-assigned nl_pid of -5. Socket3 is bound with
688 // the user specifying nl_pid of -4. Socket4 gets an
689 // auto-assigned nl_pid of -3, since -4 was already taken
690 // by the user.
691 //
692
693 LxtCheckErrno(Socket2 = socket(AF_NETLINK, Type, Family));
694 memset(&BindAddress, 0, sizeof(BindAddress));
695 BindAddress.nl_family = AF_NETLINK;
696 AddressLength = sizeof(BindAddress);
697 LxtCheckErrno(bind(Socket2, (struct sockaddr*)&BindAddress, AddressLength));
698
699 memset(&BindAddress, 0, sizeof(BindAddress));
700 LxtCheckErrno(getsockname(Socket2, (struct sockaddr*)&BindAddress, &AddressLength));
701
702 LxtCheckTrue((int)BindAddress.nl_pid < 0);
703 LxtCheckEqual(AddressLength, sizeof(BindAddress), "%d");
704
705 LxtCheckErrno(Socket3 = socket(AF_NETLINK, Type, Family));
706 BindAddress.nl_pid += 1;
707 AddressLength = sizeof(BindAddress);
708 LxtCheckErrno(bind(Socket3, (struct sockaddr*)&BindAddress, AddressLength));
709
710 memset(&BindAddress, 0, sizeof(BindAddress));
711 LxtCheckErrno(getsockname(Socket3, (struct sockaddr*)&BindAddress, &AddressLength));
712
713 LxtCheckTrue((int)BindAddress.nl_pid < 0);
714 LxtCheckEqual(AddressLength, sizeof(BindAddress), "%d");
715
716 LxtCheckErrno(Socket4 = socket(AF_NETLINK, Type, Family));
717 memset(&BindAddress, 0, sizeof(BindAddress));
718 BindAddress.nl_family = AF_NETLINK;
719 AddressLength = sizeof(BindAddress);
720 LxtCheckErrno(bind(Socket4, (struct sockaddr*)&BindAddress, AddressLength));
721
722 memset(&BindAddress, 0, sizeof(BindAddress));
723 LxtCheckErrno(getsockname(Socket4, (struct sockaddr*)&BindAddress, &AddressLength));
724
725 LxtCheckTrue((int)BindAddress.nl_pid < 0);
726 LxtCheckEqual(AddressLength, sizeof(BindAddress), "%d");
727 LxtClose(Socket3);
728 LxtClose(Socket4);
729
730 //
731 // Test case: The kernel assigned a negative custom PID for Socket2.
732 // Save Socket2's custom PID, close Socket2, then bind a
733 // new socket with the saved PID, and verify success.
734 //
735
736 AddressLength = sizeof(BindAddress);
737 memset(&BindAddress, 0, sizeof(BindAddress));
738 LxtCheckErrno(getsockname(Socket2, (struct sockaddr*)&BindAddress, &AddressLength));
739
740 LxtCheckTrue((int)BindAddress.nl_pid < 0);
741 LxtCheckEqual(AddressLength, sizeof(BindAddress), "%d");
742 SavedPid = BindAddress.nl_pid;
743 LxtClose(Socket2);
744 LxtCheckErrno(Socket2 = socket(AF_NETLINK, Type, Family));
745 AddressLength = sizeof(BindAddress);
746 LxtCheckErrno(bind(Socket2, (struct sockaddr*)&BindAddress, AddressLength));
747
748 memset(&BindAddress, 0, sizeof(BindAddress));
749 LxtCheckErrno(getsockname(Socket2, (struct sockaddr*)&BindAddress, &AddressLength));
750
751 LxtCheckEqual((int)BindAddress.nl_pid, SavedPid, "%d");
752 LxtCheckEqual(AddressLength, sizeof(BindAddress), "%d");
753 LxtClose(Socket2);
754
755 //
756 // Test case: close the first socket of the process and open a new
757 // one. Being the first netlink socket of the process,
758 // it should get the process ID as the 'nl_pid'.
759 //
760
761 LxtClose(Socket);
762 LxtCheckErrno(Socket = socket(AF_NETLINK, Type, Family));
763 memset(&BindAddress, 0, sizeof(BindAddress));
764 BindAddress.nl_family = AF_NETLINK;
765 AddressLength = sizeof(BindAddress);
766 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
767
768 memset(&BindAddress, 0, sizeof(BindAddress));
769 LxtCheckErrno(getsockname(Socket, (struct sockaddr*)&BindAddress, &AddressLength));
770
771 LxtCheckEqual(BindAddress.nl_pid, getpid(), "%d");
772 LxtCheckEqual(AddressLength, sizeof(BindAddress), "%d");
773
774 //
775 // Test case: Kernel should assign a negative unique ID to any subsequent
776 // (after the first one) netlink socket that the process
777 // subsequently creates.
778 //
779
780 for (ArrayIterator = 0; ArrayIterator < ArraySize; ArrayIterator++)
781 {
782 LxtCheckErrno(SocketA[ArrayIterator] = socket(AF_NETLINK, Type, Family));
783
784 memset(&BindAddress, 0, sizeof(BindAddress));
785 BindAddress.nl_family = AF_NETLINK;
786 AddressLength = sizeof(BindAddress);
787 LxtCheckErrno(bind(SocketA[ArrayIterator], (struct sockaddr*)&BindAddress, AddressLength));
788
789 memset(&BindAddress, 0, sizeof(BindAddress));
790 LxtCheckErrno(getsockname(SocketA[ArrayIterator], (struct sockaddr*)&BindAddress, &AddressLength));
791
792 SocketPid[ArrayIterator] = BindAddress.nl_pid;
793 LxtCheckTrue(SocketPid[ArrayIterator] < 0);
794 }
795
796 //
797 // Validate that every socket PID is unique.
798 //
799
800 for (ArrayIterator = 0; ArrayIterator < ArraySize; ArrayIterator++)
801 {
802 LxtLogInfo("parent, socket: %d, pid: %d", ArrayIterator + 1, SocketPid[ArrayIterator]);
803
804 for (ArrayIterator2 = ArrayIterator + 1; ArrayIterator2 < ArraySize; ArrayIterator2++)
805 {
806
807 LxtCheckNotEqual(SocketPid[ArrayIterator], SocketPid[ArrayIterator2], "%d");
808 }
809 }
810
811 //
812 // Test case: validate that the child process gets its own set of ID's.
813 //
814
815 ChildPid = fork();
816 if (ChildPid == 0)
817 {
818 LxtLogInfo("child, pid: %d", getpid());
819 LxtClose(Socket);
820 LxtCheckErrno(Socket = socket(AF_NETLINK, Type, Family));
821 memset(&BindAddress, 0, sizeof(BindAddress));
822 BindAddress.nl_family = AF_NETLINK;
823 AddressLength = sizeof(BindAddress);
824 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
825
826 memset(&BindAddress, 0, sizeof(BindAddress));
827 LxtCheckErrno(getsockname(Socket, (struct sockaddr*)&BindAddress, &AddressLength));
828
829 LxtCheckEqual(BindAddress.nl_pid, getpid(), "%d");
830 for (ArrayIterator = 0; ArrayIterator < ArraySize; ArrayIterator++)
831 {
832 LxtCheckErrno(SocketChildA[ArrayIterator] = socket(AF_NETLINK, Type, Family));
833
834 memset(&BindAddress, 0, sizeof(BindAddress));
835 BindAddress.nl_family = AF_NETLINK;
836 AddressLength = sizeof(BindAddress);
837 LxtCheckErrno(bind(SocketChildA[ArrayIterator], (struct sockaddr*)&BindAddress, AddressLength));
838
839 memset(&BindAddress, 0, sizeof(BindAddress));
840 LxtCheckErrno(getsockname(SocketChildA[ArrayIterator], (struct sockaddr*)&BindAddress, &AddressLength));
841
842 SocketChildPid[ArrayIterator] = BindAddress.nl_pid;
843 LxtCheckTrue(SocketChildPid[ArrayIterator] < 0);
844 }
845
846 //
847 // Validate that every socket PID is unique, locally as well
848 // as globally.
849 //
850
851 for (ArrayIterator = 0; ArrayIterator < ArraySize; ArrayIterator++)
852 {
853 LxtLogInfo("child, socket: %d, pid: %d", ArrayIterator + 1, SocketChildPid[ArrayIterator]);
854
855 for (ArrayIterator2 = ArrayIterator + 1; ArrayIterator2 < ArraySize; ArrayIterator2++)
856 {
857
858 LxtCheckNotEqual(SocketChildPid[ArrayIterator], SocketChildPid[ArrayIterator2], "%d");
859
860 LxtCheckNotEqual(SocketPid[ArrayIterator], SocketChildPid[ArrayIterator2], "%d");
861 }
862 }
863
864 for (ArrayIterator = 0; ArrayIterator < ArraySize; ArrayIterator++)
865 {
866 LxtClose(SocketChildA[ArrayIterator]);
867 }
868
869 LxtClose(Socket);
870 Result = LXT_RESULT_SUCCESS;
871 goto ErrorExit;
872 }
873
874 LxtCheckResult(LxtWaitPidPoll(ChildPid, LXT_RESULT_SUCCESS));
875 for (ArrayIterator = 0; ArrayIterator < ArraySize; ArrayIterator++)
876 {
877 LxtClose(SocketA[ArrayIterator]);
878 }
879
880 //
881 // Test case: validate that if the app provides a PID for the socket,
882 // then it should be unique.
883 //
884
885 LxtCheckErrno(SocketA[0] = socket(AF_NETLINK, Type, Family));
886 memset(&BindAddress, 0, sizeof(BindAddress));
887 BindAddress.nl_family = AF_NETLINK;
888
889 //
890 // Since the very first socket of this process is still open,
891 // getpid() as the socket PID is already in use.
892 //
893
894 BindAddress.nl_pid = getpid();
895 AddressLength = sizeof(BindAddress);
896 LxtCheckErrnoFailure(bind(SocketA[0], (struct sockaddr*)&BindAddress, AddressLength), EADDRINUSE);
897
898 LxtClose(SocketA[0]);
899 LxtClose(Socket);
900
901 //
902 // Test case: validate that when there are no netlink sockets opened
903 // by the process, the app should be able to provide the
904 // PID of the process as the unique ID for the socket.
905 //
906
907 LxtCheckErrno(Socket = socket(AF_NETLINK, Type, Family));
908 memset(&BindAddress, 0, sizeof(BindAddress));
909 BindAddress.nl_family = AF_NETLINK;
910 BindAddress.nl_pid = getpid();
911 AddressLength = sizeof(BindAddress);
912 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
913
914 LxtClose(Socket);
915 }
916 }
917
918 Result = LXT_RESULT_SUCCESS;
919
920 ErrorExit:
921 if (Socket > 0)
922 {
923 close(Socket);
924 }
925
926 if (Socket2 > 0)
927 {
928 close(Socket2);
929 }
930
931 if (Socket3 > 0)
932 {
933 close(Socket3);
934 }
935
936 if (Socket4 > 0)
937 {
938 close(Socket4);
939 }
940
941 for (ArrayIterator = 0; ArrayIterator < ArraySize; ArrayIterator++)
942 {
943 if (SocketA[ArrayIterator] != 0)
944 {
945 close(SocketA[ArrayIterator]);
946 }
947
948 if (SocketChildA[ArrayIterator] != 0)
949 {
950 close(SocketChildA[ArrayIterator]);
951 }
952 }
953
954 //
955 // If child, exit.
956 //
957
958 if (ChildPid == 0)
959 {
960 _exit(Result);
961 }
962
963 return Result;
964 }
965
966 int SocketNetlinkBindThread(PLXT_ARGS Args)
967
968 /*++
969
970 Routine Description:
971
972 This routine tests the bind() API with new threads
973 created by pthread_create.
974
975 Arguments:
976
977 Args - Supplies the command line arguments.
978
979 Return Value:
980
981 Returns 0 on success, -1 on failure.
982
983 --*/
984
985 {
986
987 socklen_t AddressLength;
988 int ArrayIterator;
989 struct sockaddr_nl BindAddress;
990 pthread_t ChildThread;
991 pid_t ChildThreadNetlinkPid;
992 BindChildThreadReturn* ChildThreadReturn;
993 int Result;
994 int Socket;
995
996 Result = LXT_RESULT_FAILURE;
997 Socket = -1;
998 for (ArrayIterator = 0; ArrayIterator < 5; ArrayIterator++)
999 {
1000
1001 //
1002 // Open a netlink socket. This is the first netlink socket of the
1003 // threadgroup, so it should have a nl_pid equal to getpid() (which
1004 // is the tgid).
1005 //
1006
1007 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
1008 memset(&BindAddress, 0, sizeof(BindAddress));
1009 BindAddress.nl_family = AF_NETLINK;
1010 AddressLength = sizeof(BindAddress);
1011 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
1012
1013 memset(&BindAddress, 0, sizeof(BindAddress));
1014 LxtCheckErrno(getsockname(Socket, (struct sockaddr*)&BindAddress, &AddressLength));
1015
1016 LxtLogInfo("nl_pid 1: %d pid: %d", BindAddress.nl_pid, getpid());
1017 LxtCheckTrue(BindAddress.nl_pid > 0);
1018 LxtCheckEqual(BindAddress.nl_pid, getpid(), "%d");
1019
1020 //
1021 // Create a new thread, which opens and closes a netlink socket in the
1022 // new thread. This is not the first netlink socket of the threadgroup,
1023 // so it should have a negative nl_pid.
1024 //
1025
1026 LxtCheckErrnoZeroSuccess(pthread_create(&ChildThread, NULL, SocketNetlinkBindThreadChild, NULL));
1027
1028 LxtCheckErrnoZeroSuccess(pthread_join(ChildThread, (void*)&ChildThreadReturn));
1029 LxtCheckTrue(ChildThreadReturn != NULL);
1030 ChildThreadNetlinkPid = ChildThreadReturn->nl_pid;
1031 free(ChildThreadReturn);
1032 LxtLogInfo("nl_pid 2: %d pid: %d", ChildThreadNetlinkPid, getpid());
1033 LxtCheckTrue(ChildThreadNetlinkPid < 0);
1034
1035 //
1036 // Close the first netlink socket (leaving no open netlink sockets).
1037 // Create a new thread, which opens and closes a netlink socket in the
1038 // new thread. This is the first netlink socket of the threadgroup.
1039 //
1040
1041 LxtClose(Socket);
1042 LxtCheckErrnoZeroSuccess(pthread_create(&ChildThread, NULL, SocketNetlinkBindThreadChild, NULL));
1043
1044 LxtCheckErrnoZeroSuccess(pthread_join(ChildThread, (void*)&ChildThreadReturn));
1045 LxtCheckTrue(ChildThreadReturn != NULL);
1046 ChildThreadNetlinkPid = ChildThreadReturn->nl_pid;
1047 free(ChildThreadReturn);
1048 LxtLogInfo("nl_pid 3: %d pid: %d", ChildThreadNetlinkPid, getpid());
1049 LxtCheckTrue(ChildThreadNetlinkPid > 0);
1050 LxtCheckEqual(ChildThreadNetlinkPid, getpid(), "%d");
1051 }
1052
1053 Result = LXT_RESULT_SUCCESS;
1054
1055 ErrorExit:
1056 if (Socket > 0)
1057 {
1058 close(Socket);
1059 }
1060
1061 return Result;
1062 }
1063
1064 void* SocketNetlinkBindThreadChild(void* Arg)
1065
1066 /*++
1067
1068 Routine Description:
1069
1070 This routine runs in a child thread and creates a netlink socket.
1071
1072 Arguments:
1073
1074 Args - Supplies the command line arguments.
1075
1076 Return Value:
1077
1078 On success, returns a struct containing the nl_pid of the netlink socket
1079 created by this thread. On failure, returns NULL.
1080
1081 --*/
1082
1083 {
1084
1085 socklen_t AddressLength;
1086 struct sockaddr_nl BindAddress;
1087 int Result;
1088 int Socket;
1089 BindChildThreadReturn* ThreadReturn;
1090
1091 Socket = -1;
1092 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
1093 memset(&BindAddress, 0, sizeof(BindAddress));
1094 BindAddress.nl_family = AF_NETLINK;
1095 AddressLength = sizeof(BindAddress);
1096 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
1097
1098 memset(&BindAddress, 0, sizeof(BindAddress));
1099 LxtCheckErrno(getsockname(Socket, (struct sockaddr*)&BindAddress, &AddressLength));
1100
1101 LxtLogInfo("Child thread: nl_pid: %d, getpid(): %d", BindAddress.nl_pid, getpid());
1102
1103 LxtClose(Socket);
1104 ThreadReturn = malloc(sizeof(*ThreadReturn));
1105 LxtCheckTrue(ThreadReturn != NULL);
1106 ThreadReturn->nl_pid = BindAddress.nl_pid;
1107
1108 ErrorExit:
1109 if (Socket > 0)
1110 {
1111 close(Socket);
1112 }
1113
1114 if (Result < 0)
1115 {
1116 return NULL;
1117 }
1118 else
1119 {
1120 return ThreadReturn;
1121 }
1122 }
1123
1124 int SocketNetlinkSendReceive(PLXT_ARGS Args)
1125
1126 /*++
1127
1128 Routine Description:
1129
1130 This routine tests the send and receive family of APIs.
1131
1132 Arguments:
1133
1134 Args - Supplies the command line arguments.
1135
1136 Return Value:
1137
1138 Returns 0 on success, -1 on failure.
1139
1140 --*/
1141
1142 {
1143
1144 socklen_t AddressLength;
1145 struct sockaddr_nl BindAddress;
1146 struct
1147 {
1148 struct nlmsghdr nlh1;
1149 char dummy[4];
1150 struct nlmsghdr nlh2;
1151 } DoubleRequest;
1152 struct nlmsgerr* Error;
1153 int ExpectedReceiveLength;
1154 struct iovec IoVec[10];
1155 struct msghdr MessageHeader;
1156 struct sockaddr_nl ReceiveAddress;
1157 char ReceiveBuffer[500];
1158 struct nlmsghdr* ReceiveHeader;
1159 struct nlmsghdr* ReceiveHeader2;
1160 int ReceiveResult;
1161 struct nlmsghdr Request;
1162 int Result;
1163 struct sockaddr_nl SendAddress;
1164 uint32_t Sequence;
1165 int Socket;
1166
1167 Result = LXT_RESULT_FAILURE;
1168 Socket = -1;
1169 Sequence = 0x7435;
1170
1171 //
1172 // Create and bind socket. Create a Netlink request with the ACK flag.
1173 // Netlink should echo the same request back to us.
1174 //
1175 // TODO_LX: Test whether invalid messages should be ACK'd back.
1176 //
1177
1178 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
1179 memset(&BindAddress, 0, sizeof(BindAddress));
1180 BindAddress.nl_family = AF_NETLINK;
1181 AddressLength = sizeof(BindAddress);
1182 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
1183
1184 memset(&Request, 0, sizeof(Request));
1185 Request.nlmsg_len = NLMSG_LENGTH(0);
1186 Request.nlmsg_type = NLMSG_NOOP;
1187 Request.nlmsg_flags = NLM_F_ACK;
1188 Request.nlmsg_seq = Sequence;
1189
1190 //
1191 // Test sendto() with invalid send addresses.
1192 //
1193
1194 AddressLength = sizeof(SendAddress);
1195 memset(&SendAddress, 0, sizeof(SendAddress));
1196 SendAddress.nl_family = AF_NETLINK;
1197 SendAddress.nl_pid = 0xFFFF1234;
1198 LxtCheckErrnoFailure(sendto(Socket, &Request, sizeof(Request), 0, (struct sockaddr*)&SendAddress, AddressLength), ECONNREFUSED);
1199
1200 memset(&SendAddress, 0, sizeof(SendAddress));
1201 SendAddress.nl_family = 0xFFFF;
1202 LxtCheckErrnoFailure(sendto(Socket, &Request, sizeof(Request), 0, (struct sockaddr*)&SendAddress, AddressLength), EINVAL);
1203
1204 //
1205 // Test sendto() with 0 nl_pid in send address. This should go to the kernel.
1206 // This is message 0.
1207 //
1208
1209 memset(&SendAddress, 0, sizeof(SendAddress));
1210 Request.nlmsg_seq = Sequence;
1211 SendAddress.nl_family = AF_NETLINK;
1212 SendAddress.nl_pid = 0;
1213 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, (struct sockaddr*)&SendAddress, AddressLength));
1214
1215 //
1216 // Test sendto() with 0 buffer length. The return value should be 0
1217 // and no response should be generated.
1218 //
1219
1220 LxtCheckErrnoZeroSuccess(sendto(Socket, &Request, 0, 0, (struct sockaddr*)&SendAddress, AddressLength));
1221
1222 //
1223 // Test sendto() with NULL send address. This should go to the kernel
1224 // by default. This is message 1.
1225 //
1226
1227 Request.nlmsg_seq = Sequence + 1;
1228 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
1229
1230 //
1231 // Test send(). This should go to the kernel by default. This is message 2.
1232 //
1233
1234 Request.nlmsg_seq = Sequence + 2;
1235 LxtCheckErrno(send(Socket, &Request, sizeof(Request), 0));
1236
1237 //
1238 // Test write(). This should go to the kernel by default. This is message 3.
1239 //
1240
1241 Request.nlmsg_seq = Sequence + 3;
1242 LxtCheckErrno(write(Socket, &Request, sizeof(Request)));
1243
1244 //
1245 // Test sendmsg() with NULL send address. This is message 4.
1246 // A NULL send address means the name size should be ignored, so also add
1247 // an invalid name size to verify this.
1248 //
1249
1250 memset(&IoVec, 0, sizeof(IoVec));
1251 memset(&MessageHeader, 0, sizeof(MessageHeader));
1252 IoVec[0].iov_base = &Request;
1253 IoVec[0].iov_len = sizeof(Request);
1254 MessageHeader.msg_iov = IoVec;
1255 MessageHeader.msg_iovlen = 1;
1256 MessageHeader.msg_namelen = -1;
1257 Request.nlmsg_seq = Sequence + 4;
1258 LxtCheckErrno(sendmsg(Socket, &MessageHeader, 0));
1259
1260 //
1261 // Test sendmsg() with buffer split across vectors. This is message 5.
1262 //
1263
1264 memset(&IoVec, 0, sizeof(IoVec));
1265 memset(&MessageHeader, 0, sizeof(MessageHeader));
1266 memset(&DoubleRequest, 0, sizeof(DoubleRequest));
1267 IoVec[0].iov_base = &DoubleRequest.nlh1;
1268 IoVec[0].iov_len = __builtin_offsetof(struct nlmsghdr, nlmsg_flags);
1269 IoVec[1].iov_base = &DoubleRequest.nlh2.nlmsg_flags;
1270 IoVec[1].iov_len = sizeof(struct nlmsghdr) - __builtin_offsetof(struct nlmsghdr, nlmsg_flags);
1271
1272 DoubleRequest.nlh1.nlmsg_len = NLMSG_LENGTH(0);
1273 DoubleRequest.nlh1.nlmsg_type = NLMSG_NOOP;
1274 DoubleRequest.nlh2.nlmsg_flags = NLM_F_ACK;
1275 DoubleRequest.nlh2.nlmsg_seq = Sequence + 5;
1276 MessageHeader.msg_iov = IoVec;
1277 MessageHeader.msg_iovlen = 2;
1278 LxtCheckErrno(sendmsg(Socket, &MessageHeader, 0));
1279
1280 //
1281 // Test sendmsg() with MSG_DONTWAIT flag.
1282 //
1283
1284 memset(&IoVec, 0, sizeof(IoVec));
1285 memset(&MessageHeader, 0, sizeof(MessageHeader));
1286 IoVec[0].iov_base = &Request;
1287 IoVec[0].iov_len = sizeof(Request);
1288 MessageHeader.msg_iov = IoVec;
1289 MessageHeader.msg_iovlen = 1;
1290 Request.nlmsg_seq = Sequence + 6;
1291 LxtCheckErrno(sendmsg(Socket, &MessageHeader, MSG_DONTWAIT));
1292
1293 //
1294 // Test sendmsg() with invalid send address.
1295 //
1296
1297 AddressLength = sizeof(SendAddress);
1298 memset(&SendAddress, 0, sizeof(SendAddress));
1299 SendAddress.nl_family = AF_NETLINK;
1300 SendAddress.nl_pid = 0xFFFF1234;
1301 MessageHeader.msg_name = &SendAddress;
1302 MessageHeader.msg_namelen = AddressLength;
1303 LxtCheckErrnoFailure(sendmsg(Socket, &MessageHeader, 0), ECONNREFUSED);
1304
1305 //
1306 // Test sendmsg() with negative send address length.
1307 //
1308
1309 AddressLength = sizeof(SendAddress);
1310 memset(&SendAddress, 0, sizeof(SendAddress));
1311 SendAddress.nl_family = AF_NETLINK;
1312 SendAddress.nl_pid = 0xFFFF1234;
1313 MessageHeader.msg_name = &SendAddress;
1314 MessageHeader.msg_namelen = -1;
1315 LxtCheckErrnoFailure(sendmsg(Socket, &MessageHeader, 0), EINVAL);
1316
1317 //
1318 // Test sendmsg() with 0 nl_pid in send address.
1319 //
1320
1321 AddressLength = sizeof(SendAddress);
1322 memset(&SendAddress, 0, sizeof(SendAddress));
1323 SendAddress.nl_family = AF_NETLINK;
1324 SendAddress.nl_pid = 0;
1325 MessageHeader.msg_name = &SendAddress;
1326 MessageHeader.msg_namelen = AddressLength;
1327 Request.nlmsg_seq = Sequence + 7;
1328 LxtCheckErrno(sendmsg(Socket, &MessageHeader, 0));
1329
1330 //
1331 // Test read(). Verify the received contents. The response should be message 0.
1332 //
1333
1334 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1335 LxtCheckErrno(ReceiveResult = read(Socket, ReceiveBuffer, sizeof(ReceiveBuffer)));
1336 ExpectedReceiveLength = NLMSG_LENGTH(sizeof(struct nlmsgerr));
1337 LxtCheckEqual(ReceiveResult, ExpectedReceiveLength, "%d");
1338 ReceiveHeader = (struct nlmsghdr*)ReceiveBuffer;
1339 LxtCheckEqual(ReceiveHeader->nlmsg_type, NLMSG_ERROR, "%d");
1340 LxtCheckEqual(ReceiveHeader->nlmsg_flags, 0, "%d");
1341 LxtCheckEqual(ReceiveHeader->nlmsg_seq, Sequence, "%d");
1342 LxtCheckEqual(ReceiveHeader->nlmsg_pid, getpid(), "%d");
1343 Error = (struct nlmsgerr*)NLMSG_DATA(ReceiveBuffer);
1344 LxtCheckEqual(Error->error, 0, "%d");
1345
1346 //
1347 // Test recv(). Verify the received contents. The response should be message 1.
1348 //
1349
1350 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1351 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
1352 ExpectedReceiveLength = NLMSG_LENGTH(sizeof(struct nlmsgerr));
1353 LxtCheckEqual(ReceiveResult, ExpectedReceiveLength, "%d");
1354 ReceiveHeader = (struct nlmsghdr*)ReceiveBuffer;
1355 LxtCheckEqual(ReceiveHeader->nlmsg_type, NLMSG_ERROR, "%d");
1356 LxtCheckEqual(ReceiveHeader->nlmsg_flags, 0, "%d");
1357 LxtCheckEqual(ReceiveHeader->nlmsg_seq, Sequence + 1, "%d");
1358 LxtCheckEqual(ReceiveHeader->nlmsg_pid, getpid(), "%d");
1359 Error = (struct nlmsgerr*)NLMSG_DATA(ReceiveBuffer);
1360 LxtCheckEqual(Error->error, 0, "%d");
1361
1362 //
1363 // Test recvfrom() with NULL receive address. Use MSG_PEEK flag, which
1364 // should not remove the data from the socket. Use MSG_TRUNC flag, which
1365 // should have no effect since the passed in buffer is larger than the
1366 // response. Use MSG_WAITALL flag, which has no effect on datagram sockets.
1367 // Verify the received contents. The response should be message 2.
1368 //
1369
1370 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1371 LxtCheckErrno(ReceiveResult = recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_PEEK | MSG_TRUNC | MSG_WAITALL, NULL, 0));
1372
1373 ExpectedReceiveLength = NLMSG_LENGTH(sizeof(struct nlmsgerr));
1374 LxtCheckEqual(ReceiveResult, ExpectedReceiveLength, "%d");
1375 ReceiveHeader = (struct nlmsghdr*)ReceiveBuffer;
1376 LxtCheckEqual(ReceiveHeader->nlmsg_type, NLMSG_ERROR, "%d");
1377 LxtCheckEqual(ReceiveHeader->nlmsg_flags, 0, "%d");
1378 LxtCheckEqual(ReceiveHeader->nlmsg_seq, Sequence + 2, "%d");
1379 LxtCheckEqual(ReceiveHeader->nlmsg_pid, getpid(), "%d");
1380 Error = (struct nlmsgerr*)NLMSG_DATA(ReceiveBuffer);
1381 LxtCheckEqual(Error->error, 0, "%d");
1382
1383 //
1384 // Test recvfrom(). Use MSG_TRUNC flag. Even though the passed in
1385 // receive buffer is too small, the return value should be the full length
1386 // of the response. The response should still be message 2, since the previous
1387 // call was a MSK_PEEK.
1388 //
1389
1390 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1391 LxtCheckErrno(ReceiveResult = recvfrom(Socket, ReceiveBuffer, 2 * sizeof(uint32_t), MSG_TRUNC, NULL, 0));
1392
1393 ExpectedReceiveLength = NLMSG_LENGTH(sizeof(struct nlmsgerr));
1394 LxtCheckEqual(ReceiveResult, ExpectedReceiveLength, "%d");
1395 ReceiveHeader = (struct nlmsghdr*)ReceiveBuffer;
1396 LxtCheckEqual(ReceiveHeader->nlmsg_type, NLMSG_ERROR, "%d");
1397 LxtCheckEqual(ReceiveHeader->nlmsg_flags, 0, "%d");
1398 LxtCheckEqual(ReceiveHeader->nlmsg_seq, 0, "%d");
1399 LxtCheckEqual(ReceiveHeader->nlmsg_pid, 0, "%d");
1400 Error = (struct nlmsgerr*)NLMSG_DATA(ReceiveBuffer);
1401 LxtCheckEqual(Error->error, 0, "%d");
1402
1403 //
1404 // Test recvfrom() with 0 buffer length. This should still advance the
1405 // socket's internal receive buffer (making the next response message 4).
1406 // This response should be message 3.
1407 //
1408
1409 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1410 LxtCheckErrno(ReceiveResult = recvfrom(Socket, ReceiveBuffer, 0, 0, NULL, 0));
1411
1412 ExpectedReceiveLength = 0;
1413 LxtCheckEqual(ReceiveResult, ExpectedReceiveLength, "%d");
1414 ReceiveHeader = (struct nlmsghdr*)ReceiveBuffer;
1415
1416 //
1417 // Test recvfrom() with valid receive address. Verify the received contents.
1418 // The response should be message 4.
1419 //
1420
1421 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1422 memset(&ReceiveAddress, 0, sizeof(ReceiveAddress));
1423 AddressLength = sizeof(struct sockaddr_nl);
1424 LxtCheckErrno(ReceiveResult = recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0, (struct sockaddr*)&ReceiveAddress, &AddressLength));
1425
1426 ExpectedReceiveLength = NLMSG_LENGTH(sizeof(struct nlmsgerr));
1427 LxtCheckEqual(ReceiveResult, ExpectedReceiveLength, "%d");
1428 LxtCheckEqual(AddressLength, sizeof(struct sockaddr_nl), "%d");
1429 ReceiveHeader = (struct nlmsghdr*)ReceiveBuffer;
1430 LxtCheckEqual(ReceiveHeader->nlmsg_type, NLMSG_ERROR, "%d");
1431 LxtCheckEqual(ReceiveHeader->nlmsg_flags, 0, "%d");
1432 LxtCheckEqual(ReceiveHeader->nlmsg_seq, Sequence + 4, "%d");
1433 LxtCheckEqual(ReceiveHeader->nlmsg_pid, getpid(), "%d");
1434 LxtCheckEqual(ReceiveAddress.nl_family, AF_NETLINK, "%d");
1435 LxtCheckEqual(ReceiveAddress.nl_pid, 0, "%d");
1436 Error = (struct nlmsgerr*)NLMSG_DATA(ReceiveBuffer);
1437 LxtCheckEqual(Error->error, 0, "%d");
1438 Request.nlmsg_seq = Sequence + 4;
1439 LxtCheckEqual(memcmp(&Error->msg, &Request, sizeof(Request)), 0, "%d");
1440
1441 //
1442 // Test recvmsg() with valid receive address. Verify the received contents.
1443 //
1444
1445 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1446 memset(&ReceiveAddress, 0, sizeof(ReceiveAddress));
1447 memset(&IoVec, 0, sizeof(IoVec));
1448 memset(&MessageHeader, 0, sizeof(MessageHeader));
1449 IoVec[0].iov_base = &ReceiveBuffer;
1450 IoVec[0].iov_len = sizeof(ReceiveBuffer);
1451 MessageHeader.msg_iov = IoVec;
1452 MessageHeader.msg_iovlen = 1;
1453 MessageHeader.msg_name = &ReceiveAddress;
1454 MessageHeader.msg_namelen = AddressLength;
1455
1456 //
1457 // Set some random value as the control length and check whether it gets
1458 // properly (re)set by the kernel.
1459 //
1460
1461 MessageHeader.msg_controllen = 100;
1462 LxtCheckErrno(ReceiveResult = recvmsg(Socket, &MessageHeader, 0));
1463 LxtCheckEqual(MessageHeader.msg_controllen, 0, "%d");
1464 LxtCheckEqual(MessageHeader.msg_flags, 0, "%d");
1465 ExpectedReceiveLength = NLMSG_LENGTH(sizeof(struct nlmsgerr));
1466 LxtCheckEqual(ReceiveResult, ExpectedReceiveLength, "%d");
1467 LxtCheckEqual(MessageHeader.msg_namelen, AddressLength, "%d");
1468 ReceiveHeader = (struct nlmsghdr*)ReceiveBuffer;
1469 LxtCheckEqual(ReceiveHeader->nlmsg_type, NLMSG_ERROR, "%d");
1470 LxtCheckEqual(ReceiveHeader->nlmsg_flags, 0, "%d");
1471 LxtCheckEqual(ReceiveHeader->nlmsg_seq, Sequence + 5, "%d");
1472 LxtCheckEqual(ReceiveHeader->nlmsg_pid, getpid(), "%d");
1473 LxtCheckEqual(ReceiveAddress.nl_family, AF_NETLINK, "%d");
1474 LxtCheckEqual(ReceiveAddress.nl_pid, 0, "%d");
1475 Error = (struct nlmsgerr*)NLMSG_DATA(ReceiveBuffer);
1476 LxtCheckEqual(Error->error, 0, "%d");
1477 Request.nlmsg_seq = Sequence + 5;
1478 LxtCheckEqual(memcmp(&Error->msg, &Request, sizeof(Request)), 0, "%d");
1479
1480 //
1481 // Test recvmsg() with passing in a small receive buffer.
1482 // The response should be truncated.
1483 //
1484
1485 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1486 memset(&IoVec, 0, sizeof(IoVec));
1487 memset(&MessageHeader, 0, sizeof(MessageHeader));
1488 IoVec[0].iov_base = &ReceiveBuffer;
1489 IoVec[0].iov_len = 2 * sizeof(uint32_t);
1490 MessageHeader.msg_iov = IoVec;
1491 MessageHeader.msg_iovlen = 1;
1492 LxtCheckErrno(ReceiveResult = recvmsg(Socket, &MessageHeader, 0));
1493 ExpectedReceiveLength = IoVec[0].iov_len;
1494 LxtCheckEqual(ReceiveResult, ExpectedReceiveLength, "%d");
1495 LxtCheckEqual(ReceiveHeader->nlmsg_type, NLMSG_ERROR, "%d");
1496 LxtCheckEqual(ReceiveHeader->nlmsg_flags, 0, "%d");
1497 LxtCheckEqual(ReceiveHeader->nlmsg_seq, 0, "%d");
1498 LxtCheckEqual(ReceiveHeader->nlmsg_pid, 0, "%d");
1499 Error = (struct nlmsgerr*)NLMSG_DATA(ReceiveBuffer);
1500 LxtCheckEqual(Error->error, 0, "%d");
1501 memset(&Request, 0, sizeof(Request));
1502 LxtCheckEqual(memcmp(&Error->msg, &Request, sizeof(Request)), 0, "%d");
1503
1504 //
1505 // Test recvmsg() split across vectors.
1506 //
1507
1508 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1509 memset(&IoVec, 0, sizeof(IoVec));
1510 memset(&MessageHeader, 0, sizeof(MessageHeader));
1511 ReceiveHeader2 =
1512 (struct nlmsghdr*)&ReceiveBuffer[NLMSG_LENGTH(sizeof(struct nlmsgerr)) + __builtin_offsetof(struct nlmsghdr, nlmsg_flags)];
1513
1514 IoVec[0].iov_len = __builtin_offsetof(struct nlmsghdr, nlmsg_flags);
1515 IoVec[0].iov_base = ReceiveHeader2;
1516 IoVec[1].iov_base = ReceiveBuffer + __builtin_offsetof(struct nlmsghdr, nlmsg_flags);
1517 IoVec[1].iov_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
1518 MessageHeader.msg_iov = IoVec;
1519 MessageHeader.msg_iovlen = 2;
1520 LxtCheckErrno(ReceiveResult = recvmsg(Socket, &MessageHeader, 0));
1521 LxtCheckEqual(MessageHeader.msg_controllen, 0, "%d");
1522 LxtCheckEqual(MessageHeader.msg_flags, 0, "%d");
1523 ExpectedReceiveLength = NLMSG_LENGTH(sizeof(struct nlmsgerr));
1524 LxtCheckEqual(ReceiveResult, ExpectedReceiveLength, "%d");
1525 ReceiveHeader = (struct nlmsghdr*)ReceiveBuffer;
1526 LxtCheckEqual(ReceiveHeader->nlmsg_len, 0, "%d");
1527 LxtCheckEqual(ReceiveHeader->nlmsg_type, 0, "%d");
1528 ReceiveHeader->nlmsg_len = ReceiveHeader2->nlmsg_len;
1529 ReceiveHeader->nlmsg_type = ReceiveHeader2->nlmsg_type;
1530 LxtCheckEqual(ReceiveHeader->nlmsg_len, ExpectedReceiveLength, "%d");
1531 LxtCheckEqual(ReceiveHeader->nlmsg_type, NLMSG_ERROR, "%d");
1532 LxtCheckEqual(ReceiveHeader->nlmsg_flags, 0, "%d");
1533 LxtCheckEqual(ReceiveHeader->nlmsg_seq, Sequence + 7, "%d");
1534 LxtCheckEqual(ReceiveHeader->nlmsg_pid, getpid(), "%d");
1535 LxtCheckEqual(ReceiveAddress.nl_family, AF_NETLINK, "%d");
1536 LxtCheckEqual(ReceiveAddress.nl_pid, 0, "%d");
1537 Error = (struct nlmsgerr*)NLMSG_DATA(ReceiveBuffer);
1538 LxtCheckEqual(Error->error, 0, "%d");
1539 Request.nlmsg_len = NLMSG_LENGTH(0);
1540 Request.nlmsg_type = NLMSG_NOOP;
1541 Request.nlmsg_flags = NLM_F_ACK;
1542 Request.nlmsg_seq = Sequence + 7;
1543 LxtCheckEqual(memcmp(&Error->msg, &Request, sizeof(Request)), 0, "%d");
1544
1545 //
1546 // Test recvfrom() when using the MSG_DONTWAIT flag. The socket has no data,
1547 // so it should return EAGAIN immediately instead of blocking forever.
1548 //
1549
1550 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1551 LxtCheckErrnoFailure(recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT, NULL, 0), EAGAIN);
1552
1553 //
1554 // Test specifying that the input buffer is much larger than it actually is.
1555 //
1556
1557 memset(&DoubleRequest, 0, sizeof(DoubleRequest));
1558 memset(&IoVec, 0, sizeof(IoVec));
1559 memset(&MessageHeader, 0, sizeof(MessageHeader));
1560 DoubleRequest.nlh1.nlmsg_len = 0x30000;
1561 DoubleRequest.nlh1.nlmsg_type = NLMSG_NOOP;
1562 DoubleRequest.nlh1.nlmsg_flags = NLM_F_ACK;
1563 DoubleRequest.nlh1.nlmsg_seq = Sequence;
1564 IoVec[0].iov_base = &DoubleRequest;
1565 IoVec[0].iov_len = 0x30000;
1566 MessageHeader.msg_iov = IoVec;
1567 MessageHeader.msg_iovlen = 1;
1568 Request.nlmsg_seq = Sequence + 4;
1569 LxtCheckErrnoFailure(sendmsg(Socket, &MessageHeader, 0), EFAULT);
1570
1571 //
1572 // Test passing in garbage length values in the message headers.
1573 //
1574
1575 DoubleRequest.nlh1.nlmsg_len = NLMSG_LENGTH(0) + 1;
1576 DoubleRequest.nlh2.nlmsg_len = 0x3000;
1577 IoVec[0].iov_len = sizeof(DoubleRequest.nlh1) + 1;
1578 LxtCheckErrno(sendmsg(Socket, &MessageHeader, 0));
1579
1580 //
1581 // Again.
1582 //
1583
1584 DoubleRequest.nlh1.nlmsg_len = 0x3000;
1585 DoubleRequest.nlh2.nlmsg_len = 0x3000;
1586 IoVec[0].iov_len = sizeof(DoubleRequest.nlh1) + 1;
1587 LxtCheckErrno(sendmsg(Socket, &MessageHeader, 0));
1588
1589 //
1590 // Again.
1591 //
1592
1593 DoubleRequest.nlh1.nlmsg_len = 0x3000;
1594 DoubleRequest.nlh2.nlmsg_len = NLMSG_LENGTH(0) + 1;
1595 IoVec[0].iov_len = sizeof(DoubleRequest.nlh1) + 1;
1596 LxtCheckErrno(sendmsg(Socket, &MessageHeader, 0));
1597
1598 //
1599 // TODO: Test multi-message send with different requests
1600 // bundled in the same send.
1601 //
1602
1603 ErrorExit:
1604 if (Socket > 0)
1605 {
1606 close(Socket);
1607 }
1608
1609 return Result;
1610 }
1611
1612 int SocketNetlinkSendReceiveOverflow(PLXT_ARGS Args)
1613
1614 /*++
1615
1616 Routine Description:
1617
1618 This routine tests the send and receive family of APIs
1619 in the context of the receive buffer overflowing.
1620
1621 Arguments:
1622
1623 Args - Supplies the command line arguments.
1624
1625 Return Value:
1626
1627 Returns 0 on success, -1 on failure.
1628
1629 --*/
1630
1631 {
1632
1633 socklen_t AddressLength;
1634 struct sockaddr_nl BindAddress;
1635 struct nlmsgerr* Error;
1636 int ExpectedReceiveLength;
1637 int Index;
1638 struct sockaddr_nl ReceiveAddress;
1639 char ReceiveBuffer[500];
1640 struct nlmsghdr* ReceiveHeader;
1641 int ReceiveResult;
1642 struct nlmsghdr Request;
1643 int Result;
1644 struct sockaddr_nl SendAddress;
1645 int SendResult;
1646 uint32_t Sequence;
1647 int Socket;
1648 int SocketError;
1649 socklen_t SocketErrorSize;
1650 struct timeval Timeout;
1651
1652 Result = LXT_RESULT_FAILURE;
1653 Socket = -1;
1654 Sequence = 0x3468;
1655
1656 //
1657 // Create and bind socket. Create a NOOP request with the ACK flag.
1658 // Netlink should echo the same request back to us.
1659 //
1660
1661 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
1662 memset(&BindAddress, 0, sizeof(BindAddress));
1663 BindAddress.nl_family = AF_NETLINK;
1664 AddressLength = sizeof(BindAddress);
1665 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
1666
1667 memset(&Request, 0, sizeof(Request));
1668 Request.nlmsg_len = NLMSG_LENGTH(0);
1669 Request.nlmsg_type = NLMSG_NOOP;
1670 Request.nlmsg_flags = NLM_F_ACK;
1671
1672 //
1673 // Overflow the receive buffer by sending 3000 events.
1674 // Each send should succeed with the return value being the full number of
1675 // bytes the user sent.
1676 //
1677
1678 AddressLength = sizeof(SendAddress);
1679 memset(&SendAddress, 0, sizeof(SendAddress));
1680 SendAddress.nl_family = AF_NETLINK;
1681 SendAddress.nl_pid = 0;
1682 for (Index = 0; Index < 3000; Index++)
1683 {
1684 Request.nlmsg_seq = Sequence + Index;
1685 LxtCheckErrno(SendResult = sendto(Socket, &Request, sizeof(Request), 0, (struct sockaddr*)&SendAddress, AddressLength));
1686
1687 LxtCheckEqual(SendResult, sizeof(Request), "%d");
1688 }
1689
1690 //
1691 // The first call to recvfrom() after the overflow should return ENOBUFS.
1692 // Also verify that the receive and address buffers were not changed.
1693 //
1694
1695 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1696 memset(&ReceiveAddress, 0, sizeof(ReceiveAddress));
1697 ReceiveBuffer[1] = 0x56;
1698 ReceiveAddress.nl_groups = 0x3456789a;
1699 AddressLength = sizeof(struct sockaddr_nl);
1700 LxtCheckErrnoFailure(recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0, (struct sockaddr*)&ReceiveAddress, &AddressLength), ENOBUFS);
1701
1702 LxtCheckEqual(ReceiveBuffer[1], 0x56, "%d");
1703 LxtCheckEqual(ReceiveAddress.nl_groups, 0x3456789a, "%d");
1704
1705 //
1706 // The subsequent calls to recvfrom() pull out the responses before the
1707 // overflow happened. Only call recvfrom() 3 times here, so that the receive
1708 // buffer is not yet fully drained.
1709 //
1710
1711 for (Index = 0; Index < 3; Index++)
1712 {
1713 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1714 memset(&ReceiveAddress, 0, sizeof(ReceiveAddress));
1715 LxtCheckErrno(ReceiveResult = recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0, (struct sockaddr*)&ReceiveAddress, &AddressLength));
1716
1717 ExpectedReceiveLength = NLMSG_LENGTH(sizeof(struct nlmsgerr));
1718 LxtCheckEqual(ReceiveResult, ExpectedReceiveLength, "%d");
1719 LxtCheckEqual(AddressLength, sizeof(struct sockaddr_nl), "%d");
1720 ReceiveHeader = (struct nlmsghdr*)ReceiveBuffer;
1721 LxtCheckEqual(ReceiveHeader->nlmsg_type, NLMSG_ERROR, "%d");
1722 LxtCheckEqual(ReceiveHeader->nlmsg_flags, 0, "%d");
1723 LxtCheckEqual(ReceiveHeader->nlmsg_seq, Sequence + Index, "%d");
1724 LxtCheckEqual(ReceiveHeader->nlmsg_pid, getpid(), "%d");
1725 LxtCheckEqual(ReceiveAddress.nl_family, AF_NETLINK, "%d");
1726 LxtCheckEqual(ReceiveAddress.nl_pid, 0, "%d");
1727 }
1728
1729 //
1730 // Check the socket option SO_ERROR. This should be 0 (no error),
1731 // since the error was cleared when the first recvfrom() returned ENOBUFS.
1732 //
1733
1734 SocketErrorSize = sizeof(SocketError);
1735 SocketError = 212;
1736 LxtCheckErrno(getsockopt(Socket, SOL_SOCKET, SO_ERROR, &SocketError, &SocketErrorSize));
1737
1738 LxtCheckEqual(SocketErrorSize, sizeof(SocketError), "%d");
1739 LxtCheckEqual(SocketError, 0, "%d");
1740
1741 //
1742 // Test that the receive buffer is still considered to be "overflown"
1743 // until the entire buffer is drained. This means that anything sent to
1744 // the socket now will be ignored and no response generated, even though
1745 // technically there is space in the receive buffer for the response.
1746 // The test sends a message with a unique sequence number. Later on, the
1747 // entire receive buffer will be drained and all responses checked to
1748 // verify that this unique sequence number is not in any of the responses.
1749 //
1750
1751 Request.nlmsg_seq = 0x98765432;
1752 LxtCheckErrno(SendResult = sendto(Socket, &Request, sizeof(Request), 0, (struct sockaddr*)&SendAddress, AddressLength));
1753
1754 LxtCheckEqual(SendResult, sizeof(Request), "%d");
1755
1756 //
1757 // Drain the entire response buffer. Set the recvfrom() timeout to 1 millisecond
1758 // so that it does not block infinitely.
1759 //
1760
1761 Timeout.tv_sec = 0;
1762 Timeout.tv_usec = 1000;
1763 LxtCheckErrno(setsockopt(Socket, SOL_SOCKET, SO_RCVTIMEO, &Timeout, sizeof(Timeout)));
1764
1765 for (;;)
1766 {
1767 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1768 memset(&ReceiveAddress, 0, sizeof(ReceiveAddress));
1769 ReceiveResult = recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0, (struct sockaddr*)&ReceiveAddress, &AddressLength);
1770
1771 if (ReceiveResult == -1)
1772 {
1773 LxtCheckErrnoFailure(ReceiveResult, EAGAIN);
1774 break;
1775 }
1776 else
1777 {
1778 ExpectedReceiveLength = NLMSG_LENGTH(sizeof(struct nlmsgerr));
1779 LxtCheckEqual(ReceiveResult, ExpectedReceiveLength, "%d");
1780 LxtCheckEqual(AddressLength, sizeof(struct sockaddr_nl), "%d");
1781 ReceiveHeader = (struct nlmsghdr*)ReceiveBuffer;
1782 LxtCheckEqual(ReceiveHeader->nlmsg_type, NLMSG_ERROR, "%d");
1783 LxtCheckEqual(ReceiveHeader->nlmsg_flags, 0, "%d");
1784 LxtCheckNotEqual(ReceiveHeader->nlmsg_seq, 0, "%d");
1785 LxtCheckNotEqual(ReceiveHeader->nlmsg_seq, 0x98765432, "%d");
1786 LxtCheckEqual(ReceiveHeader->nlmsg_pid, getpid(), "%d");
1787 LxtCheckEqual(ReceiveAddress.nl_family, AF_NETLINK, "%d");
1788 LxtCheckEqual(ReceiveAddress.nl_pid, 0, "%d");
1789 }
1790 }
1791
1792 //
1793 // Overflow the receive buffer again by sending 3000 events.
1794 // Each send should succeed with the return value being the full number of
1795 // bytes the user sent.
1796 //
1797
1798 AddressLength = sizeof(SendAddress);
1799 memset(&SendAddress, 0, sizeof(SendAddress));
1800 SendAddress.nl_family = AF_NETLINK;
1801 SendAddress.nl_pid = 0;
1802 for (Index = 0; Index < 3000; Index++)
1803 {
1804 Request.nlmsg_seq = Sequence + Index;
1805 LxtCheckErrno(SendResult = sendto(Socket, &Request, sizeof(Request), 0, (struct sockaddr*)&SendAddress, AddressLength));
1806
1807 LxtCheckEqual(SendResult, sizeof(Request), "%d");
1808 }
1809
1810 //
1811 // Check the socket option SO_ERROR. This should be ENOBUFS,
1812 // since recvfrom() has not been called yet.
1813 //
1814
1815 SocketErrorSize = sizeof(SocketError);
1816 SocketError = 212;
1817 LxtCheckErrno(getsockopt(Socket, SOL_SOCKET, SO_ERROR, &SocketError, &SocketErrorSize));
1818
1819 LxtCheckEqual(SocketErrorSize, sizeof(SocketError), "%d");
1820 LxtCheckEqual(SocketError, ENOBUFS, "%d");
1821
1822 //
1823 // The first recvfrom() should be successful, since the ENOBUFS error
1824 // was already cleared when socket option SO_ERROR was retrieved.
1825 //
1826
1827 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
1828 memset(&ReceiveAddress, 0, sizeof(ReceiveAddress));
1829 LxtCheckErrno(ReceiveResult = recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0, (struct sockaddr*)&ReceiveAddress, &AddressLength));
1830
1831 ExpectedReceiveLength = NLMSG_LENGTH(sizeof(struct nlmsgerr));
1832 LxtCheckEqual(ReceiveResult, ExpectedReceiveLength, "%d");
1833 LxtCheckEqual(AddressLength, sizeof(struct sockaddr_nl), "%d");
1834 ReceiveHeader = (struct nlmsghdr*)ReceiveBuffer;
1835 LxtCheckEqual(ReceiveHeader->nlmsg_type, NLMSG_ERROR, "%d");
1836 LxtCheckEqual(ReceiveHeader->nlmsg_flags, 0, "%d");
1837 LxtCheckEqual(ReceiveHeader->nlmsg_seq, Sequence, "%d");
1838 LxtCheckEqual(ReceiveHeader->nlmsg_pid, getpid(), "%d");
1839 LxtCheckEqual(ReceiveAddress.nl_family, AF_NETLINK, "%d");
1840 LxtCheckEqual(ReceiveAddress.nl_pid, 0, "%d");
1841
1842 ErrorExit:
1843 if (Socket > 0)
1844 {
1845 close(Socket);
1846 }
1847
1848 return Result;
1849 }
1850
1851 int SocketNetlinkBlockedReader(PLXT_ARGS Args)
1852
1853 /*++
1854
1855 Routine Description:
1856
1857 This routine tests that blocked readers do not get unblocked when the socket
1858 is closed. Also verify that shutdown() is invalid on NETLINK sockets.
1859
1860 Arguments:
1861
1862 Args - Supplies the command line arguments.
1863
1864 Return Value:
1865
1866 Returns 0 on success, -1 on failure.
1867
1868 --*/
1869
1870 {
1871
1872 socklen_t AddressLength;
1873 struct sockaddr_nl BindAddress;
1874 void* PthreadResult;
1875 int Result;
1876 int Socket;
1877 pthread_t Thread;
1878 struct timespec Timeout = {0};
1879
1880 Result = LXT_RESULT_FAILURE;
1881 Socket = -1;
1882
1883 //
1884 // Create and bind socket.
1885 //
1886
1887 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
1888 memset(&BindAddress, 0, sizeof(BindAddress));
1889 BindAddress.nl_family = AF_NETLINK;
1890 AddressLength = sizeof(BindAddress);
1891 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
1892
1893 //
1894 // Create a reader thread that will block on 'recv'.
1895 //
1896
1897 LxtCheckResultError(pthread_create(&Thread, NULL, SocketBlockedReaderThread, &Socket));
1898
1899 //
1900 // Wait for sometime to allow the reader thread to block on read. There
1901 // is no other elegant way of knowing whether the thread has blocked.
1902 //
1903
1904 usleep(5000);
1905
1906 //
1907 // Shutdown is NOT supported for NETLINK sockets.
1908 //
1909
1910 LxtCheckErrnoFailure(shutdown(Socket, SHUT_RD), EOPNOTSUPP);
1911 LxtCheckErrnoFailure(shutdown(Socket, SHUT_WR), EOPNOTSUPP);
1912 LxtCheckErrnoFailure(shutdown(Socket, SHUT_RDWR), EOPNOTSUPP);
1913
1914 //
1915 // Closing the socket does not unblock the reader. The pthread_timedjoin_np()
1916 // should timeout since the reader thread is still blocked.
1917 //
1918
1919 LxtCheckErrnoZeroSuccess(close(Socket));
1920 usleep(5000);
1921 Timeout.tv_nsec = 5000;
1922 Result = pthread_timedjoin_np(Thread, &PthreadResult, &Timeout);
1923 if (Result != ETIMEDOUT)
1924 {
1925 LxtLogError(
1926 "Expecting pthread_tryjoin_np to return ETIMEDOUT(%d), "
1927 "but it returned with result: %d",
1928 ETIMEDOUT,
1929 Result);
1930
1931 goto ErrorExit;
1932 }
1933
1934 //
1935 // No other choice but to kill the reader thread.
1936 //
1937
1938 LxtCheckErrnoZeroSuccess(pthread_cancel(Thread));
1939 LxtCheckErrnoZeroSuccess(pthread_join(Thread, &PthreadResult));
1940 LxtCheckEqual(PthreadResult, PTHREAD_CANCELED, "%p");
1941
1942 ErrorExit:
1943 if (Socket > 0)
1944 {
1945 close(Socket);
1946 }
1947
1948 return Result;
1949 }
1950
1951 int SocketNetlinkEpoll(PLXT_ARGS Args)
1952
1953 /*++
1954
1955 Routine Description:
1956
1957 This routine tests that the epoll state is correct.
1958
1959 Arguments:
1960
1961 Args - Supplies the command line arguments.
1962
1963 Return Value:
1964
1965 Returns 0 on success, -1 on failure.
1966
1967 --*/
1968
1969 {
1970
1971 socklen_t AddressLength;
1972 struct sockaddr_nl BindAddress;
1973 int EdRead;
1974 int EdWrite;
1975 struct epoll_event EpollControlEvent;
1976 struct epoll_event EpollWaitEvent[2];
1977 int Index;
1978 char ReceiveBuffer[500];
1979 int ReceiveResult;
1980 struct nlmsghdr Request;
1981 int Result;
1982 int SendResult;
1983 int Socket;
1984
1985 Result = LXT_RESULT_FAILURE;
1986 Socket = -1;
1987
1988 //
1989 // Create socket.
1990 //
1991
1992 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW | SOCK_NONBLOCK, 0));
1993
1994 //
1995 // Create epoll containers for read and write and
1996 // add the socket descriptor to them.
1997 //
1998
1999 LxtCheckErrno(EdRead = epoll_create(1));
2000 EpollControlEvent.events = EPOLLIN;
2001 EpollControlEvent.data.fd = Socket;
2002 Result = epoll_ctl(EdRead, EPOLL_CTL_ADD, Socket, &EpollControlEvent);
2003 LxtCheckErrnoZeroSuccess(Result);
2004
2005 LxtCheckErrno(EdWrite = epoll_create(1));
2006 EpollControlEvent.events = EPOLLOUT;
2007 EpollControlEvent.data.fd = Socket;
2008 Result = epoll_ctl(EdWrite, EPOLL_CTL_ADD, Socket, &EpollControlEvent);
2009 LxtCheckErrnoZeroSuccess(Result);
2010
2011 //
2012 // Wait for data to be available with a timeout. This should timeout since
2013 // there is no data. Verify that write is available.
2014 //
2015
2016 Result = epoll_wait(EdRead, EpollWaitEvent, 2, 50);
2017 LxtCheckEqual(Result, 0, "%d");
2018 Result = epoll_wait(EdWrite, EpollWaitEvent, 2, 50);
2019 LxtCheckEqual(Result, 1, "%d");
2020
2021 //
2022 // Bind the socket.
2023 //
2024
2025 memset(&BindAddress, 0, sizeof(BindAddress));
2026 BindAddress.nl_family = AF_NETLINK;
2027 AddressLength = sizeof(BindAddress);
2028 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
2029
2030 //
2031 // Wait for data to be available with a timeout. This should timeout since
2032 // there is no data. Verify that write is available.
2033 //
2034
2035 Result = epoll_wait(EdRead, EpollWaitEvent, 2, 50);
2036 LxtCheckEqual(Result, 0, "%d");
2037 Result = epoll_wait(EdWrite, EpollWaitEvent, 2, 50);
2038 LxtCheckEqual(Result, 1, "%d");
2039
2040 //
2041 // Send 3000 messages. The receive buffer will overflow, but write is still
2042 // available. Read is available now.
2043 //
2044
2045 memset(&Request, 0, sizeof(Request));
2046 Request.nlmsg_len = NLMSG_LENGTH(0);
2047 Request.nlmsg_type = NLMSG_NOOP;
2048 Request.nlmsg_flags = NLM_F_ACK;
2049 for (Index = 0; Index < 3000; Index++)
2050 {
2051 LxtCheckErrno(SendResult = sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2052
2053 LxtCheckEqual(SendResult, sizeof(Request), "%d");
2054 }
2055
2056 Result = epoll_wait(EdRead, EpollWaitEvent, 2, 50);
2057 LxtCheckEqual(Result, 1, "%d");
2058 Result = epoll_wait(EdWrite, EpollWaitEvent, 2, 50);
2059 LxtCheckEqual(Result, 1, "%d");
2060
2061 //
2062 // Drain all the events. Write is still available, but read is not.
2063 //
2064
2065 LxtCheckErrnoFailure(recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0, NULL, 0), ENOBUFS);
2066
2067 for (;;)
2068 {
2069 memset(&ReceiveBuffer, 0, sizeof(ReceiveBuffer));
2070 ReceiveResult = recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0, NULL, 0);
2071
2072 if (ReceiveResult == -1)
2073 {
2074 LxtCheckErrnoFailure(ReceiveResult, EAGAIN);
2075 break;
2076 }
2077 }
2078
2079 Result = epoll_wait(EdRead, EpollWaitEvent, 2, 50);
2080 LxtCheckEqual(Result, 0, "%d");
2081 Result = epoll_wait(EdWrite, EpollWaitEvent, 2, 50);
2082 LxtCheckEqual(Result, 1, "%d");
2083
2084 //
2085 // Close the socket. Both read and write are not available.
2086 //
2087
2088 LxtCheckErrnoZeroSuccess(close(Socket));
2089 Result = epoll_wait(EdRead, EpollWaitEvent, 2, 50);
2090 LxtCheckEqual(Result, 0, "%d");
2091 Result = epoll_wait(EdWrite, EpollWaitEvent, 2, 50);
2092 LxtCheckEqual(Result, 0, "%d");
2093
2094 ErrorExit:
2095 if (Socket > 0)
2096 {
2097 close(Socket);
2098 }
2099
2100 if (EdRead > 0)
2101 {
2102 close(EdRead);
2103 }
2104
2105 if (EdWrite > 0)
2106 {
2107 close(EdWrite);
2108 }
2109
2110 return Result;
2111 }
2112
2113 int SocketNetlinkRecvmmsg(PLXT_ARGS Args)
2114
2115 /*++
2116
2117 Routine Description:
2118
2119 This routine tests the recvmmsg() syscall.
2120
2121 Arguments:
2122
2123 Args - Supplies the command line arguments.
2124
2125 Return Value:
2126
2127 Returns 0 on success, -1 on failure.
2128
2129 --*/
2130
2131 {
2132
2133 socklen_t AddressLength;
2134 struct sockaddr_nl BindAddress;
2135 NetlinkRecvmmsgBlockedReaderParams BlockedReaderParams;
2136 struct nlmsgerr* Error;
2137 struct nlmsghdr* Header;
2138 int Index;
2139 socklen_t OptionLength;
2140 void* PthreadResult;
2141 char ReceiveBuffers[10][1000];
2142 struct iovec ReceiveIovecs[10];
2143 struct mmsghdr ReceiveMessages[10];
2144 int ReceiveResult;
2145 int Result;
2146 int SendResult;
2147 int Socket;
2148 pthread_t Thread;
2149 struct timespec Timeout;
2150 struct timespec TimeoutPthread;
2151
2152 struct
2153 {
2154 struct nlmsghdr nlh;
2155 struct ifinfomsg ifm;
2156 struct rtattr ext_req __attribute__((aligned(NLMSG_ALIGNTO)));
2157 __u32 ext_filter_mask;
2158 } Request;
2159
2160 //
2161 // Create and bind socket. Create a RTM_GETLINK request. Note that the
2162 // request is not sent yet at this point.
2163 //
2164
2165 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
2166 memset(&BindAddress, 0, sizeof(BindAddress));
2167 BindAddress.nl_family = AF_NETLINK;
2168 AddressLength = sizeof(BindAddress);
2169 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
2170
2171 memset(&Request, 0, sizeof(Request));
2172 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | NLM_F_DUMP;
2173 Request.nlh.nlmsg_len = sizeof(Request);
2174 Request.nlh.nlmsg_type = RTM_GETLINK;
2175 Request.nlh.nlmsg_seq = 0x4567;
2176 Request.ifm.ifi_family = AF_NETLINK;
2177 Request.ext_req.rta_type = IFLA_EXT_MASK;
2178 Request.ext_req.rta_len = RTA_LENGTH(sizeof(__u32));
2179 Request.ext_filter_mask = RTEXT_FILTER_VF;
2180
2181 //
2182 // The timeout value passed to recvmmsg() is ignored - there is a bug in the
2183 // Linux kernel where the timeout does not work at all. In lxcore we ignore
2184 // this parameter.
2185 //
2186
2187 Timeout.tv_sec = 800;
2188 Timeout.tv_nsec = 0;
2189
2190 //
2191 // Set up the receive buffers.
2192 //
2193
2194 memset(ReceiveMessages, 0, sizeof(ReceiveMessages));
2195 for (Index = 0; Index < 10; Index++)
2196 {
2197 ReceiveIovecs[Index].iov_base = ReceiveBuffers[Index];
2198 ReceiveIovecs[Index].iov_len = 1000;
2199 ReceiveMessages[Index].msg_hdr.msg_iov = &ReceiveIovecs[Index];
2200 ReceiveMessages[Index].msg_hdr.msg_iovlen = 1;
2201 }
2202
2203 //
2204 // There is nothing to receive at this point. Test that MSG_DONTWAIT trumps
2205 // MSG_WAITFORONE and MSG_WAITALL, therefore EAGAIN is returned due to not waiting.
2206 //
2207
2208 LxtCheckErrnoFailure(Result = recvmmsg(Socket, ReceiveMessages, 1000, MSG_DONTWAIT | MSG_WAITFORONE | MSG_WAITALL, &Timeout), EAGAIN);
2209
2210 LxtCheckErrnoFailure(Result = recvmmsg(Socket, ReceiveMessages, 1000, MSG_DONTWAIT | MSG_WAITFORONE, &Timeout), EAGAIN);
2211
2212 LxtCheckErrnoFailure(Result = recvmmsg(Socket, ReceiveMessages, 1000, MSG_DONTWAIT | MSG_WAITALL, &Timeout), EAGAIN);
2213
2214 LxtCheckErrnoFailure(Result = recvmmsg(Socket, ReceiveMessages, 1000, MSG_DONTWAIT, &Timeout), EAGAIN);
2215
2216 //
2217 // Set a SO_RCVTIMEO timeout value of 8 milliseconds for the receive. This timeout
2218 // applies to each individual recvmsg() call and actually works. Both calls to
2219 // recvmmsg below should time out from the SO_RCVTIMEO.
2220 //
2221
2222 LxtCheckResult(SocketNetlinkSetAndVerifySocketOptionTimeout(Socket, SO_RCVTIMEO, 8000));
2223
2224 LxtCheckErrnoFailure(Result = recvmmsg(Socket, ReceiveMessages, 1000, MSG_WAITFORONE, &Timeout), EAGAIN);
2225
2226 LxtCheckErrnoFailure(Result = recvmmsg(Socket, ReceiveMessages, 1000, 0, &Timeout), EAGAIN);
2227
2228 //
2229 // Restore the SO_RCVTIMEO timeout to 0 (never times out).
2230 //
2231
2232 LxtCheckResult(SocketNetlinkSetAndVerifySocketOptionTimeout(Socket, SO_RCVTIMEO, 0));
2233
2234 //
2235 // Test blocking behavior when zero flags (option 0) and when MSG_WAITFORONE
2236 // (option 1) is passed to recvmmsg. Create a new thread that blocks forever,
2237 // then cancel the thread after waiting for some time.
2238 //
2239
2240 for (Index = 0; Index < 2; Index++)
2241 {
2242
2243 //
2244 // Create a reader thread that will block on 'recvmmsg'.
2245 //
2246
2247 BlockedReaderParams.Socket = Socket;
2248 BlockedReaderParams.Option = Index;
2249 LxtCheckResultError(pthread_create(&Thread, NULL, SocketNetlinkRecvmmsgBlockedReaderThread, &BlockedReaderParams));
2250
2251 //
2252 // Wait for sometime to allow the reader thread to block on read. There
2253 // is no other elegant way of knowing whether the thread has blocked.
2254 //
2255
2256 usleep(5000);
2257
2258 //
2259 // The pthread_timedjoin_np() should timeout since the reader thread is
2260 // still blocked.
2261 //
2262
2263 TimeoutPthread.tv_sec = 0;
2264 TimeoutPthread.tv_nsec = 5000;
2265 Result = pthread_timedjoin_np(Thread, &PthreadResult, &TimeoutPthread);
2266 if (Result != ETIMEDOUT)
2267 {
2268 LxtLogError(
2269 "Expecting pthread_tryjoin_np to return ETIMEDOUT(%d), "
2270 "but it returned with result: %d for index: %d",
2271 ETIMEDOUT,
2272 Result,
2273 Index);
2274
2275 goto ErrorExit;
2276 }
2277
2278 //
2279 // No other choice but to kill the reader thread.
2280 //
2281
2282 LxtCheckErrnoZeroSuccess(pthread_cancel(Thread));
2283 LxtCheckErrnoZeroSuccess(pthread_join(Thread, &PthreadResult));
2284 LxtCheckEqual(PthreadResult, PTHREAD_CANCELED, "%p");
2285 }
2286
2287 //
2288 // Now generate a lot of Netlink responses waiting to be read.
2289 //
2290
2291 for (Index = 0; Index < 10; Index++)
2292 {
2293 LxtCheckErrno(SendResult = send(Socket, &Request, sizeof(Request), 0));
2294 LxtCheckEqual(SendResult, sizeof(Request), "%d");
2295 }
2296
2297 //
2298 // Test various combinations of input parameters and verify the output.
2299 //
2300
2301 LxtCheckErrno(Result = recvmmsg(Socket, ReceiveMessages, 3, MSG_DONTWAIT | MSG_WAITFORONE | MSG_WAITALL | MSG_PEEK | MSG_TRUNC, &Timeout));
2302
2303 LxtCheckEqual(Result, 3, "%d");
2304 LxtCheckNotEqual(ReceiveMessages[0].msg_len, 0, "%d");
2305 LxtCheckNotEqual(ReceiveMessages[1].msg_len, 0, "%d");
2306 LxtCheckNotEqual(ReceiveMessages[2].msg_len, 0, "%d");
2307 LxtCheckEqual(ReceiveMessages[3].msg_len, 0, "%d");
2308 LxtCheckErrno(Result = recvmmsg(Socket, ReceiveMessages, 2, MSG_DONTWAIT, &Timeout));
2309 LxtCheckEqual(Result, 2, "%d");
2310 LxtCheckNotEqual(ReceiveMessages[0].msg_len, 0, "%d");
2311 LxtCheckNotEqual(ReceiveMessages[1].msg_len, 0, "%d");
2312 LxtCheckNotEqual(ReceiveMessages[2].msg_len, 0, "%d");
2313 LxtCheckEqual(ReceiveMessages[3].msg_len, 0, "%d");
2314 ReceiveMessages[0].msg_len = 0;
2315 ReceiveMessages[1].msg_len = 0;
2316 ReceiveMessages[2].msg_len = 0;
2317 LxtCheckErrno(Result = recvmmsg(Socket, ReceiveMessages, 1, 0, &Timeout));
2318 LxtCheckEqual(Result, 1, "%d");
2319 LxtCheckNotEqual(ReceiveMessages[0].msg_len, 0, "%d");
2320 LxtCheckEqual(ReceiveMessages[1].msg_len, 0, "%d");
2321 LxtCheckEqual(ReceiveMessages[2].msg_len, 0, "%d");
2322 LxtCheckEqual(ReceiveMessages[3].msg_len, 0, "%d");
2323 LxtCheckErrno(Result = recvmmsg(Socket, ReceiveMessages, 1, MSG_WAITFORONE, &Timeout));
2324 LxtCheckEqual(Result, 1, "%d");
2325 LxtCheckNotEqual(ReceiveMessages[0].msg_len, 0, "%d");
2326 LxtCheckEqual(ReceiveMessages[1].msg_len, 0, "%d");
2327 LxtCheckEqual(ReceiveMessages[2].msg_len, 0, "%d");
2328 LxtCheckEqual(ReceiveMessages[3].msg_len, 0, "%d");
2329 Result = LXT_RESULT_SUCCESS;
2330
2331 ErrorExit:
2332 if (Socket > 0)
2333 {
2334 close(Socket);
2335 }
2336
2337 return Result;
2338 }
2339
2340 void* SocketNetlinkRecvmmsgBlockedReaderThread(void* Arg)
2341
2342 /*++
2343
2344 Routine Description:
2345
2346 This routine will call recvmmsg on the given socket fd and block.
2347
2348 Arguments:
2349
2350 Arg - Supplies the socket fd to read and the options.
2351
2352 Return Value:
2353
2354 Returns 0 on success, -1 on failure.
2355
2356 --*/
2357
2358 {
2359
2360 NetlinkRecvmmsgBlockedReaderParams* BlockedReaderParams;
2361 int Flags;
2362 int Index;
2363 int MessagesRead;
2364 char ReceiveBuffers[20][1000];
2365 struct iovec ReceiveIovecs[20];
2366 struct mmsghdr ReceiveMessages[20];
2367 int Result = LXT_RESULT_FAILURE;
2368 int Socket;
2369 struct timespec Timeout;
2370
2371 //
2372 // The timeout value passed to recvmmsg() is ignored. Set up the receive
2373 // buffers.
2374 //
2375
2376 BlockedReaderParams = (NetlinkRecvmmsgBlockedReaderParams*)Arg;
2377 Socket = BlockedReaderParams->Socket;
2378 Timeout.tv_sec = 800;
2379 Timeout.tv_nsec = 0;
2380 memset(ReceiveMessages, 0, sizeof(ReceiveMessages));
2381 for (Index = 0; Index < 20; Index++)
2382 {
2383 ReceiveIovecs[Index].iov_base = ReceiveBuffers[Index];
2384 ReceiveIovecs[Index].iov_len = 1000;
2385 ReceiveMessages[Index].msg_hdr.msg_iov = &ReceiveIovecs[Index];
2386 ReceiveMessages[Index].msg_hdr.msg_iovlen = 1;
2387 }
2388
2389 //
2390 // The flags passed to recvmmsg() depend on the option value passed into
2391 // this function.
2392 //
2393
2394 switch (BlockedReaderParams->Option)
2395 {
2396 case 0:
2397 Flags = 0;
2398 break;
2399
2400 case 1:
2401 Flags = MSG_WAITFORONE;
2402 break;
2403
2404 default:
2405 LxtLogError("Incorrect option: %d", BlockedReaderParams->Option);
2406 goto ErrorExit;
2407 }
2408
2409 LxtCheckErrno(MessagesRead = recvmmsg(Socket, ReceiveMessages, 20, Flags, NULL));
2410 if (MessagesRead != 0)
2411 {
2412 LxtLogError(
2413 "recvmmsg should return 0 messages read, "
2414 "but it returned %d messages for flags %x",
2415 MessagesRead,
2416 Flags);
2417
2418 goto ErrorExit;
2419 }
2420
2421 LxtLogInfo("recvmmsg unblocked, flags %x", Flags);
2422 Result = LXT_RESULT_SUCCESS;
2423
2424 ErrorExit:
2425 pthread_exit((void*)(ssize_t)Result);
2426 }
2427
2428 int SocketNetlinkSendBadMessage(PLXT_ARGS Args)
2429
2430 /*++
2431
2432 Routine Description:
2433
2434 This routine sends bad Netlink messages, to test that the system does not crash.
2435
2436 Arguments:
2437
2438 Args - Supplies the command line arguments.
2439
2440 Return Value:
2441
2442 Returns 0 on success, -1 on failure.
2443
2444 --*/
2445
2446 {
2447
2448 socklen_t AddressLength;
2449 struct sockaddr_nl BindAddress;
2450 char* Buffer;
2451 struct nlmsghdr* Header;
2452 char ReceiveBuffer;
2453 int Result;
2454 int Socket;
2455 int TypeIterator;
2456
2457 Buffer = malloc(PAGE_SIZE * 2);
2458 LxtCheckTrue(Buffer != NULL);
2459 Header = (struct nlmsghdr*)(((uint64_t)(Buffer + PAGE_SIZE) & ~(PAGE_SIZE - 1)) - sizeof(struct nlmsghdr));
2460 LxtLogInfo("Malloc end of page: %p", Header);
2461 for (TypeIterator = 0; TypeIterator < sizeof(MessageTypes) / sizeof(int); TypeIterator++)
2462 {
2463
2464 LxtLogInfo("Checking message type: %d", MessageTypes[TypeIterator]);
2465 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
2466 memset(&BindAddress, 0, sizeof(BindAddress));
2467 BindAddress.nl_family = AF_NETLINK;
2468 AddressLength = sizeof(BindAddress);
2469 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
2470
2471 Header->nlmsg_flags = NLM_F_REQUEST;
2472 Header->nlmsg_len = sizeof(struct nlmsghdr);
2473 Header->nlmsg_type = MessageTypes[TypeIterator];
2474 Header->nlmsg_seq = 0x4567;
2475 sendto(Socket, Header, sizeof(struct nlmsghdr), 0, NULL, 0);
2476 }
2477
2478 Result = LXT_RESULT_SUCCESS;
2479
2480 ErrorExit:
2481 if (Socket > 0)
2482 {
2483 close(Socket);
2484 }
2485
2486 if (Buffer != NULL)
2487 {
2488 free(Buffer);
2489 }
2490
2491 return Result;
2492 }
2493
2494 void SocketNetlinkRouteDumpAttributeData(char* Buffer, int BufferSize, struct rtattr* Attribute)
2495
2496 /*++
2497
2498 Routine Description:
2499
2500 This routine dumps the data in the NETLINK_ROUTE protocol's RT attribute.
2501
2502 Arguments:
2503
2504 Buffer - Supplies a pointer to the buffer to write the dumped data to.
2505
2506 Attribute - Supplies a pointer to the RT attribute to dump.
2507
2508 Return Value:
2509
2510 None.
2511
2512 --*/
2513
2514 {
2515
2516 unsigned char* AttributeCurrent;
2517 char* BufferCurrent;
2518 int Index;
2519
2520 AttributeCurrent = (unsigned char*)RTA_DATA(Attribute);
2521 BufferCurrent = Buffer;
2522 memset(Buffer, 0, BufferSize);
2523
2524 //
2525 // Each char takes 3 bytes in the dump buffer.
2526 //
2527
2528 for (Index = 0; Index < min((BufferSize - 1) / 3, RTA_PAYLOAD(Attribute)); Index++)
2529 {
2530 sprintf(BufferCurrent, "%02x ", *AttributeCurrent);
2531 AttributeCurrent += 1;
2532 BufferCurrent += 3;
2533 }
2534
2535 return;
2536 }
2537
2538 int SocketNetlinkRouteGetAddr(PLXT_ARGS Args)
2539
2540 /*++
2541
2542 Routine Description:
2543
2544 This routine tests the NETLINK_ROUTE protocol's RTM_GETADDR message.
2545
2546 Arguments:
2547
2548 Args - Supplies the command line arguments.
2549
2550 Return Value:
2551
2552 Returns 0 on success, -1 on failure.
2553
2554 --*/
2555
2556 {
2557
2558 socklen_t AddressLength;
2559 struct rtattr* Attribute;
2560 char AttributeDump[ATTRIBUTE_DUMP_BUFFER_SIZE];
2561 int AttributeSeenAddress;
2562 int AttributeSeenCacheInfo;
2563 struct sockaddr_nl BindAddress;
2564 struct nlmsgerr* Error;
2565 int FoundDone;
2566 struct nlmsghdr* Header;
2567 struct ifaddrmsg* IfAddrMsg;
2568 char ReceiveBuffer[5000];
2569 int ReceiveResult;
2570 int RemainingLength;
2571 int Result;
2572 int Socket;
2573
2574 struct
2575 {
2576 struct nlmsghdr nlh;
2577 struct ifinfomsg ifm;
2578 struct rtattr ext_req __attribute__((aligned(NLMSG_ALIGNTO)));
2579 __u32 ext_filter_mask;
2580 } Request;
2581
2582 AttributeSeenAddress = 0;
2583 AttributeSeenCacheInfo = 0;
2584
2585 //
2586 // Create and bind socket. Create a RTM_GETADDR request.
2587 //
2588
2589 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
2590 memset(&BindAddress, 0, sizeof(BindAddress));
2591 BindAddress.nl_family = AF_NETLINK;
2592 AddressLength = sizeof(BindAddress);
2593 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
2594
2595 memset(&Request, 0, sizeof(Request));
2596 Request.nlh.nlmsg_len = sizeof(Request);
2597 Request.nlh.nlmsg_type = RTM_GETADDR;
2598 Request.nlh.nlmsg_seq = 0x4563;
2599 Request.ifm.ifi_family = AF_NETLINK;
2600 Request.ext_req.rta_type = IFLA_EXT_MASK;
2601 Request.ext_req.rta_len = RTA_LENGTH(sizeof(__u32));
2602 Request.ext_filter_mask = RTEXT_FILTER_VF;
2603
2604 //
2605 // Test flags. Only passing the NLM_F_REQUEST flag returns an Error.
2606 //
2607
2608 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
2609 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2610 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
2611
2612 Header = (struct nlmsghdr*)ReceiveBuffer;
2613 LxtCheckTrue(NLMSG_OK(Header, ReceiveResult));
2614 LxtCheckEqual(Header->nlmsg_type, NLMSG_ERROR, "%d");
2615 Error = (struct nlmsgerr*)NLMSG_DATA(Header);
2616 LxtCheckEqual(Error->error, -EOPNOTSUPP, "%d");
2617 LxtCheckEqual(memcmp(&Error->msg, &Request, sizeof(Request)), 0, "%d");
2618
2619 //
2620 // Test flags. Only passing the NLM_F_REQUEST flag returns an Error.
2621 // Verify that adding a NLM_F_ACK flag still returns an Error.
2622 //
2623
2624 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
2625 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2626 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
2627
2628 Header = (struct nlmsghdr*)ReceiveBuffer;
2629 LxtCheckTrue(NLMSG_OK(Header, ReceiveResult));
2630 LxtCheckEqual(Header->nlmsg_type, NLMSG_ERROR, "%d");
2631 Error = (struct nlmsgerr*)NLMSG_DATA(Header);
2632 LxtCheckEqual(Error->error, -EOPNOTSUPP, "%d");
2633 LxtCheckEqual(memcmp(&Error->msg, &Request, sizeof(Request)), 0, "%d");
2634
2635 //
2636 // Test flags. Only passing the NLM_F_ROOT and/or NLM_F_MATCH flag(s)
2637 // result in no response.
2638 //
2639
2640 Request.nlh.nlmsg_flags = NLM_F_ROOT;
2641 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2642 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
2643
2644 Request.nlh.nlmsg_flags = NLM_F_MATCH;
2645 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2646 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
2647
2648 Request.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH;
2649 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2650 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
2651
2652 //
2653 // Test flags. Passing 0 flags or invalid flags result in no response.
2654 //
2655
2656 Request.nlh.nlmsg_flags = 0;
2657 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2658 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
2659
2660 Request.nlh.nlmsg_flags = 0x40;
2661 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2662 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
2663
2664 //
2665 // Test flags. NLM_F_REQUEST and at least one of NLM_F_ROOT/NLM_F_MATCH
2666 // results in the correct response.
2667 // For the response, verify the presence of several attributes.
2668 //
2669
2670 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;
2671 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2672 FoundDone = 0;
2673 for (;;)
2674 {
2675 LxtCheckErrno(ReceiveResult = recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0, NULL, 0));
2676
2677 Header = (struct nlmsghdr*)ReceiveBuffer;
2678 while (NLMSG_OK(Header, ReceiveResult))
2679 {
2680 if (Header->nlmsg_type == NLMSG_DONE)
2681 {
2682 FoundDone = 1;
2683 break;
2684 }
2685
2686 IfAddrMsg = (struct ifaddrmsg*)NLMSG_DATA(Header);
2687 LxtLogInfo(
2688 "ifaddrmsg: ifa_family %d ifa_prefixlen %d "
2689 "ifa_flags %d ifa_scope %d ifa_index %d",
2690 IfAddrMsg->ifa_family,
2691 IfAddrMsg->ifa_prefixlen,
2692 IfAddrMsg->ifa_flags,
2693 IfAddrMsg->ifa_scope,
2694 IfAddrMsg->ifa_index);
2695
2696 Attribute = (struct rtattr*)((char*)IfAddrMsg + sizeof(struct ifaddrmsg));
2697
2698 RemainingLength = Header->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifaddrmsg));
2699
2700 while (RTA_OK(Attribute, RemainingLength))
2701 {
2702 SocketNetlinkRouteDumpAttributeData(AttributeDump, ATTRIBUTE_DUMP_BUFFER_SIZE, Attribute);
2703
2704 LxtLogInfo("RTATTR type: %2d len: %3d data: %s", Attribute->rta_type, Attribute->rta_len, AttributeDump);
2705
2706 if (Attribute->rta_type == IFA_ADDRESS)
2707 {
2708 AttributeSeenAddress += 1;
2709 }
2710 else if (Attribute->rta_type == IFA_CACHEINFO)
2711 {
2712 LxtCheckEqual(Attribute->rta_len, RTA_LENGTH(sizeof(struct ifa_cacheinfo)), "%d");
2713
2714 AttributeSeenCacheInfo += 1;
2715 }
2716
2717 Attribute = RTA_NEXT(Attribute, RemainingLength);
2718 }
2719
2720 Header = NLMSG_NEXT(Header, ReceiveResult);
2721 }
2722
2723 if (FoundDone == 1)
2724 {
2725 break;
2726 }
2727 }
2728
2729 LxtCheckTrue(AttributeSeenAddress > 0);
2730 LxtCheckTrue(AttributeSeenCacheInfo > 0);
2731
2732 ErrorExit:
2733 if (Socket > 0)
2734 {
2735 close(Socket);
2736 }
2737
2738 return Result;
2739 }
2740
2741 int SocketNetlinkRouteGetLink(PLXT_ARGS Args)
2742
2743 /*++
2744
2745 Routine Description:
2746
2747 This routine tests the NETLINK_ROUTE protocol's RTM_GETLINK message.
2748
2749 Arguments:
2750
2751 Args - Supplies the command line arguments.
2752
2753 Return Value:
2754
2755 Returns 0 on success, -1 on failure.
2756
2757 --*/
2758
2759 {
2760
2761 socklen_t AddressLength;
2762 struct sockaddr_nl BindAddress;
2763 pid_t ChildPid;
2764 int ChildSocket;
2765 struct nlmsgerr* Error;
2766 struct nlmsghdr* Header;
2767 int Index;
2768 char InterfaceName[32];
2769 int LoopbackIndex;
2770 char ReceiveBuffer[5000];
2771 int ReceiveResult;
2772 int Result;
2773 int SendResult;
2774 int Socket;
2775
2776 struct
2777 {
2778 struct nlmsghdr nlh;
2779 struct ifinfomsg ifm;
2780 char Attributes[200];
2781 } Request;
2782
2783 //
2784 // Create and bind socket. Create a RTM_GETLINK request.
2785 //
2786
2787 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
2788 memset(&BindAddress, 0, sizeof(BindAddress));
2789 BindAddress.nl_family = AF_NETLINK;
2790 AddressLength = sizeof(BindAddress);
2791 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
2792
2793 memset(&Request, 0, sizeof(Request));
2794 Request.nlh.nlmsg_len = sizeof(Request);
2795 Request.nlh.nlmsg_type = RTM_GETLINK;
2796 Request.nlh.nlmsg_seq = 0x4567;
2797 Request.ifm.ifi_family = AF_NETLINK;
2798
2799 //
2800 // Test flags. Only passing the NLM_F_REQUEST flag with no network interface
2801 // specified returns an Error.
2802 //
2803
2804 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
2805 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2806 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
2807
2808 Header = (struct nlmsghdr*)ReceiveBuffer;
2809 LxtCheckTrue(NLMSG_OK(Header, ReceiveResult));
2810 LxtCheckEqual(Header->nlmsg_type, NLMSG_ERROR, "%d");
2811 Error = (struct nlmsgerr*)NLMSG_DATA(Header);
2812 LxtCheckEqual(Error->error, -EINVAL, "%d");
2813 LxtCheckEqual(memcmp(&Error->msg, &Request, sizeof(Request)), 0, "%d");
2814
2815 //
2816 // Test flags. Only passing the NLM_F_REQUEST flag with no network interface
2817 // returns an Error. Verify that adding a NLM_F_ACK flag still returns an Error.
2818 //
2819
2820 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
2821 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2822 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
2823
2824 Header = (struct nlmsghdr*)ReceiveBuffer;
2825 LxtCheckTrue(NLMSG_OK(Header, ReceiveResult));
2826 LxtCheckEqual(Header->nlmsg_type, NLMSG_ERROR, "%d");
2827 Error = (struct nlmsgerr*)NLMSG_DATA(Header);
2828 LxtCheckEqual(Error->error, -EINVAL, "%d");
2829 LxtCheckEqual(memcmp(&Error->msg, &Request, sizeof(Request)), 0, "%d");
2830
2831 //
2832 // Test flags. Only passing the NLM_F_ROOT and/or NLM_F_MATCH flag(s)
2833 // result in no response.
2834 //
2835
2836 Request.nlh.nlmsg_flags = NLM_F_ROOT;
2837 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2838 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
2839
2840 Request.nlh.nlmsg_flags = NLM_F_MATCH;
2841 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2842 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
2843
2844 Request.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH;
2845 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2846 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
2847
2848 //
2849 // Test flags. Passing 0 flags or invalid flags result in no response.
2850 //
2851
2852 Request.nlh.nlmsg_flags = 0;
2853 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2854 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
2855
2856 Request.nlh.nlmsg_flags = 0x40;
2857 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2858 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
2859
2860 //
2861 // Test filter mode.
2862 // When passing only the NLM_F_REQUEST flag, "filter" mode is used.
2863 // In this mode, either ifinfomsg.ifi_index must be valid, or IFLA_IFNAME
2864 // must be present to filter the response to one network interface.
2865 //
2866
2867 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
2868
2869 //
2870 // Passing a zero ifi_index returns an Error.
2871 //
2872
2873 Request.ifm.ifi_index = 0;
2874 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2875 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
2876
2877 Header = (struct nlmsghdr*)ReceiveBuffer;
2878 LxtCheckTrue(NLMSG_OK(Header, ReceiveResult));
2879 LxtCheckEqual(Header->nlmsg_type, NLMSG_ERROR, "%d");
2880 Error = (struct nlmsgerr*)NLMSG_DATA(Header);
2881 LxtCheckEqual(Error->error, -EINVAL, "%d");
2882
2883 //
2884 // Passing a negative ifi_index returns an Error.
2885 //
2886
2887 Request.ifm.ifi_index = -1;
2888 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2889 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
2890
2891 Header = (struct nlmsghdr*)ReceiveBuffer;
2892 LxtCheckTrue(NLMSG_OK(Header, ReceiveResult));
2893 LxtCheckEqual(Header->nlmsg_type, NLMSG_ERROR, "%d");
2894 Error = (struct nlmsgerr*)NLMSG_DATA(Header);
2895 LxtCheckEqual(Error->error, -EINVAL, "%d");
2896
2897 //
2898 // Passing a bad ifi_index and the correct interface name returns an Error.
2899 //
2900
2901 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
2902 Request.ifm.ifi_index = 100;
2903 strcpy(InterfaceName, "lo");
2904 LxtCheckErrnoZeroSuccess(
2905 SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), IFLA_IFNAME, InterfaceName, strlen(InterfaceName) + 1));
2906
2907 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2908 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
2909
2910 Header = (struct nlmsghdr*)ReceiveBuffer;
2911 LxtCheckTrue(NLMSG_OK(Header, ReceiveResult));
2912 LxtCheckEqual(Header->nlmsg_type, NLMSG_ERROR, "%d");
2913 Error = (struct nlmsgerr*)NLMSG_DATA(Header);
2914 LxtCheckEqual(Error->error, -ENODEV, "%d");
2915
2916 //
2917 // Passing a negative ifi_index and the correct interface name results in the
2918 // correct response.
2919 //
2920
2921 Request.ifm.ifi_index = -1;
2922 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2923 LxtCheckResult(SocketNetlinkRouteGetLinkCheckResponse(Socket, TRUE));
2924
2925 //
2926 // Passing a zero ifi_index and the correct interface name results in the
2927 // correct response.
2928 //
2929
2930 Request.ifm.ifi_index = 0;
2931 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2932 LxtCheckResult(SocketNetlinkRouteGetLinkCheckResponse(Socket, TRUE));
2933
2934 //
2935 // Passing a bad ifi_index and a bad interface name returns an Error.
2936 //
2937
2938 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
2939 Request.ifm.ifi_index = 100;
2940 strcpy(InterfaceName, "loooo");
2941 LxtCheckErrnoZeroSuccess(
2942 SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), IFLA_IFNAME, InterfaceName, strlen(InterfaceName) + 1));
2943
2944 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2945 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
2946
2947 Header = (struct nlmsghdr*)ReceiveBuffer;
2948 LxtCheckTrue(NLMSG_OK(Header, ReceiveResult));
2949 LxtCheckEqual(Header->nlmsg_type, NLMSG_ERROR, "%d");
2950 Error = (struct nlmsgerr*)NLMSG_DATA(Header);
2951 LxtCheckEqual(Error->error, -ENODEV, "%d");
2952
2953 //
2954 // Passing a zero ifi_index and a bad interface name returns an Error.
2955 //
2956
2957 Request.ifm.ifi_index = 0;
2958 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2959 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
2960
2961 Header = (struct nlmsghdr*)ReceiveBuffer;
2962 LxtCheckTrue(NLMSG_OK(Header, ReceiveResult));
2963 LxtCheckEqual(Header->nlmsg_type, NLMSG_ERROR, "%d");
2964 Error = (struct nlmsgerr*)NLMSG_DATA(Header);
2965 LxtCheckEqual(Error->error, -ENODEV, "%d");
2966
2967 //
2968 // Passing a negative ifi_index and a bad interface name returns an Error.
2969 //
2970
2971 Request.ifm.ifi_index = -1;
2972 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2973 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
2974
2975 Header = (struct nlmsghdr*)ReceiveBuffer;
2976 LxtCheckTrue(NLMSG_OK(Header, ReceiveResult));
2977 LxtCheckEqual(Header->nlmsg_type, NLMSG_ERROR, "%d");
2978 Error = (struct nlmsgerr*)NLMSG_DATA(Header);
2979 LxtCheckEqual(Error->error, -ENODEV, "%d");
2980
2981 //
2982 // Get the interface index of the loopback adapter.
2983 //
2984
2985 LxtCheckErrnoZeroSuccess(SocketNetlinkGetLoopbackIndex(&LoopbackIndex));
2986 LxtCheckTrue(LoopbackIndex > 0);
2987
2988 //
2989 // Passing a correct ifi_index and a bad interface name results in the
2990 // correct response.
2991 //
2992
2993 Request.ifm.ifi_index = LoopbackIndex;
2994 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
2995 LxtCheckResult(SocketNetlinkRouteGetLinkCheckResponse(Socket, TRUE));
2996
2997 //
2998 // Passing a correct ifi_index and no interface name results in the
2999 // correct response.
3000 //
3001
3002 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
3003 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3004 LxtCheckResult(SocketNetlinkRouteGetLinkCheckResponse(Socket, TRUE));
3005
3006 //
3007 // Test dump mode.
3008 // NLM_F_REQUEST and at least one of NLM_F_ROOT/NLM_F_MATCH
3009 // results in the correct response.
3010 // For the response, verify that at least one interface is present (loopback),
3011 // and also verify the presence of several attributes.
3012 //
3013
3014 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;
3015 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3016 LxtCheckResult(SocketNetlinkRouteGetLinkCheckResponse(Socket, FALSE));
3017
3018 //
3019 // Create a child process and switch it to a new network namespace.
3020 // RTM_GETLINK should only return one network interface - loopback.
3021 //
3022
3023 LxtCheckErrno(ChildPid = fork());
3024 if (ChildPid == 0)
3025 {
3026 LxtCheckErrnoZeroSuccess(unshare(CLONE_NEWNET));
3027
3028 //
3029 // N.B. The sleep is because it can take some time for the lxcore cache to get
3030 // the new network interface notification.
3031 //
3032
3033 usleep(1000 * 100);
3034 LxtLogInfo("Now testing child socket");
3035 LxtCheckErrno(ChildSocket = socket(AF_NETLINK, SOCK_RAW, 0));
3036 LxtCheckErrno(sendto(ChildSocket, &Request, sizeof(Request), 0, NULL, 0));
3037 LxtCheckResult(SocketNetlinkRouteGetLinkCheckResponse(ChildSocket, TRUE));
3038 LxtClose(ChildSocket);
3039 exit(0);
3040 }
3041
3042 LxtCheckResult(LxtWaitPidPoll(ChildPid, 0));
3043
3044 //
3045 // Check that sending is still successful even if the
3046 // receive buffer has overflown.
3047 //
3048
3049 for (Index = 0; Index < 1000; Index++)
3050 {
3051 LxtCheckErrno(SendResult = send(Socket, &Request, sizeof(Request), 0));
3052 LxtCheckEqual(SendResult, sizeof(Request), "%d");
3053 }
3054
3055 ErrorExit:
3056 if (Socket > 0)
3057 {
3058 close(Socket);
3059 }
3060
3061 return Result;
3062 }
3063
3064 int SocketNetlinkRouteGetLinkCheckResponse(int Socket, int OnlyOneInterface)
3065
3066 /*++
3067
3068 Routine Description:
3069
3070 This routine checks the response of the NETLINK_ROUTE protocol's
3071 RTM_GETLINK message.
3072
3073 Arguments:
3074
3075 Socket - Supplies the socket to read the response from.
3076
3077 OnlyOneInterface - Supplies a boolean indicating whether there should only
3078 be one network interface in the response.
3079
3080 Return Value:
3081
3082 Returns 0 on success, -1 on failure.
3083
3084 --*/
3085
3086 {
3087
3088 struct rtattr* Attribute;
3089 char AttributeDump[ATTRIBUTE_DUMP_BUFFER_SIZE];
3090 int AttributeSeenAddress;
3091 int AttributeSeenMtu;
3092 int AttributeSeenName;
3093 int FoundDone;
3094 struct nlmsghdr* Header;
3095 struct ifinfomsg* IfInfoMsg;
3096 int InterfaceCount;
3097 char ReceiveBuffer[5000];
3098 int ReceiveResult;
3099 int RemainingLength;
3100 int Result;
3101 int SeenLoopback;
3102
3103 AttributeSeenAddress = 0;
3104 AttributeSeenMtu = 0;
3105 AttributeSeenName = 0;
3106 SeenLoopback = 0;
3107 FoundDone = 0;
3108 InterfaceCount = 0;
3109 for (;;)
3110 {
3111 LxtCheckErrno(ReceiveResult = recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0, NULL, 0));
3112
3113 Header = (struct nlmsghdr*)ReceiveBuffer;
3114 while (NLMSG_OK(Header, ReceiveResult))
3115 {
3116 if (Header->nlmsg_type == NLMSG_DONE)
3117 {
3118 FoundDone = 1;
3119 break;
3120 }
3121
3122 IfInfoMsg = (struct ifinfomsg*)NLMSG_DATA(Header);
3123 LxtLogInfo(
3124 "ifinfomsg: ifi_family %d ifi_type %d "
3125 "ifi_index %d ifi_flags %d ifi_change %d",
3126 IfInfoMsg->ifi_family,
3127 IfInfoMsg->ifi_type,
3128 IfInfoMsg->ifi_index,
3129 IfInfoMsg->ifi_flags,
3130 IfInfoMsg->ifi_change);
3131
3132 InterfaceCount += 1;
3133 if ((IfInfoMsg->ifi_flags & IFF_LOOPBACK) != 0)
3134 {
3135 SeenLoopback += 1;
3136 }
3137
3138 Attribute = (struct rtattr*)((char*)IfInfoMsg + sizeof(struct ifinfomsg));
3139
3140 RemainingLength = Header->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifinfomsg));
3141
3142 while (RTA_OK(Attribute, RemainingLength))
3143 {
3144 SocketNetlinkRouteDumpAttributeData(AttributeDump, ATTRIBUTE_DUMP_BUFFER_SIZE, Attribute);
3145
3146 LxtLogInfo("RTATTR type: %2d len: %3d data: %s", Attribute->rta_type, Attribute->rta_len, AttributeDump);
3147
3148 if (Attribute->rta_type == IFLA_ADDRESS)
3149 {
3150 AttributeSeenAddress += 1;
3151 }
3152 else if (Attribute->rta_type == IFLA_MTU)
3153 {
3154 AttributeSeenMtu += 1;
3155 }
3156 else if (Attribute->rta_type == IFLA_IFNAME)
3157 {
3158 AttributeSeenName += 1;
3159 }
3160
3161 Attribute = RTA_NEXT(Attribute, RemainingLength);
3162 }
3163
3164 if ((Header->nlmsg_flags & NLM_F_MULTI) == 0)
3165 {
3166 goto LoopDone;
3167 }
3168
3169 Header = NLMSG_NEXT(Header, ReceiveResult);
3170 }
3171
3172 if (FoundDone == 1)
3173 {
3174 break;
3175 }
3176 }
3177
3178 LoopDone:
3179 LxtCheckTrue(AttributeSeenAddress > 0);
3180 LxtCheckTrue(AttributeSeenMtu > 0);
3181 LxtCheckTrue(AttributeSeenName > 0);
3182 LxtCheckEqual(SeenLoopback, 1, "%d");
3183 LxtLogInfo("Found %d interfaces total", InterfaceCount);
3184 if (OnlyOneInterface != FALSE)
3185 {
3186 LxtCheckEqual(InterfaceCount, 1, "%d");
3187 }
3188
3189 Result = LXT_RESULT_SUCCESS;
3190
3191 ErrorExit:
3192 return Result;
3193 }
3194
3195 int SocketNetlinkRouteGetRouteBestRoute(PLXT_ARGS Args)
3196
3197 /*++
3198
3199 Routine Description:
3200
3201 This routine tests the NETLINK_ROUTE protocol's RTM_GETROUTE message's
3202 get best route request.
3203
3204 Arguments:
3205
3206 Args - Supplies the command line arguments.
3207
3208 Return Value:
3209
3210 Returns 0 on success, -1 on failure.
3211
3212 --*/
3213
3214 {
3215
3216 socklen_t AddressLength;
3217 struct sockaddr_nl BindAddress;
3218 struct in_addr DestinationIpv4;
3219 struct in6_addr DestinationIpv6;
3220 struct in_addr GatewayIpv4;
3221 struct in6_addr GatewayIpv6;
3222 struct nlmsgerr* Error;
3223 struct nlmsghdr* Header;
3224 int Index;
3225 bool IsIpV6Configured;
3226 int LoopbackIndex;
3227 char ReceiveBuffer[5000];
3228 int ReceiveResult;
3229 int Result;
3230 int SendResult;
3231 int Socket;
3232
3233 struct
3234 {
3235 struct nlmsghdr nlh;
3236 struct rtmsg msg;
3237 char attr[200];
3238 } Request;
3239
3240 //
3241 // Get the interface index of the loopback adapter.
3242 //
3243
3244 LxtCheckErrnoZeroSuccess(SocketNetlinkGetLoopbackIndex(&LoopbackIndex));
3245 LxtCheckTrue(LoopbackIndex > 0);
3246
3247 //
3248 // Create and bind socket. Create a RTM_GETROUTE request.
3249 //
3250
3251 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
3252 memset(&BindAddress, 0, sizeof(BindAddress));
3253 BindAddress.nl_family = AF_NETLINK;
3254 AddressLength = sizeof(BindAddress);
3255 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
3256
3257 memset(&Request, 0, sizeof(Request));
3258 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
3259 Request.nlh.nlmsg_type = RTM_GETROUTE;
3260 Request.nlh.nlmsg_seq = 0x4567;
3261
3262 //
3263 // NLM_F_REQUEST with no NLM_F_DUMP means "get best route" request.
3264 //
3265
3266 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
3267
3268 //
3269 // Test specifying an invalid address family.
3270 //
3271
3272 Request.msg.rtm_family = AF_UNSPEC;
3273 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3274 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
3275 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EOPNOTSUPP));
3276
3277 //
3278 // Test specifying AF_INET6 while really giving an IPv4 destination address.
3279 //
3280
3281 Request.msg.rtm_family = AF_INET6;
3282 inet_aton("1.1.1.1", &DestinationIpv4);
3283 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, NULL, -1);
3284
3285 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3286 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
3287 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EINVAL));
3288
3289 IsIpV6Configured = SocketNetlinkIsIpv6Configured();
3290
3291 //
3292 // Test not specifying the destination (both Ipv4 and Ipv6).
3293 //
3294
3295 memset(&Request, 0, sizeof(Request));
3296 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
3297 Request.nlh.nlmsg_type = RTM_GETROUTE;
3298 Request.nlh.nlmsg_seq = 0x4567;
3299 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
3300 Request.msg.rtm_family = AF_INET;
3301 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3302 LxtCheckResult(SocketNetlinkRouteGetRouteBestRouteCheckResponse(Socket, FALSE));
3303 Request.msg.rtm_family = AF_INET6;
3304 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3305 if (IsIpV6Configured)
3306 {
3307 LxtCheckResult(SocketNetlinkRouteGetRouteBestRouteCheckResponse(Socket, FALSE));
3308 }
3309 else
3310 {
3311 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
3312
3313 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -ENETUNREACH));
3314 }
3315
3316 //
3317 // Test specifying the destination (Ipv4).
3318 //
3319
3320 inet_aton("1.1.1.1", &DestinationIpv4);
3321 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, NULL, -1);
3322
3323 Request.msg.rtm_family = AF_INET;
3324 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3325 LxtCheckResult(SocketNetlinkRouteGetRouteBestRouteCheckResponse(Socket, TRUE));
3326
3327 //
3328 // Test specifying the destination (Ipv6).
3329 //
3330 if (IsIpV6Configured)
3331 {
3332 memset(&Request, 0, sizeof(Request));
3333 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
3334 Request.nlh.nlmsg_type = RTM_GETROUTE;
3335 Request.nlh.nlmsg_seq = 0x4567;
3336 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
3337 Request.msg.rtm_family = AF_INET6;
3338 inet_pton(AF_INET6, "12::", &GatewayIpv6);
3339 LxtCheckErrnoZeroSuccess(
3340 SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), RTA_DST, &DestinationIpv6, sizeof(DestinationIpv6)));
3341
3342 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3343 LxtCheckResult(SocketNetlinkRouteGetRouteBestRouteCheckResponse(Socket, TRUE));
3344 }
3345
3346 //
3347 // Test specifying the destination and gateway (Ipv4).
3348 //
3349
3350 memset(&Request, 0, sizeof(Request));
3351 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
3352 Request.nlh.nlmsg_type = RTM_GETROUTE;
3353 Request.nlh.nlmsg_seq = 0x4567;
3354 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
3355 Request.msg.rtm_family = AF_INET;
3356 inet_aton("1.1.1.1", &DestinationIpv4);
3357 inet_aton("1.1.1.2", &GatewayIpv4);
3358 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, &GatewayIpv4, -1);
3359
3360 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3361 LxtCheckResult(SocketNetlinkRouteGetRouteBestRouteCheckResponse(Socket, TRUE));
3362
3363 //
3364 // Test specifying the destination and gateway (Ipv6).
3365 //
3366
3367 if (IsIpV6Configured)
3368 {
3369 memset(&Request, 0, sizeof(Request));
3370 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
3371 Request.nlh.nlmsg_type = RTM_GETROUTE;
3372 Request.nlh.nlmsg_seq = 0x4567;
3373 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
3374 Request.msg.rtm_family = AF_INET6;
3375 inet_pton(AF_INET6, "12::", &DestinationIpv6);
3376 inet_pton(AF_INET6, "13::", &GatewayIpv6);
3377 LxtCheckErrnoZeroSuccess(
3378 SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), RTA_DST, &DestinationIpv6, sizeof(DestinationIpv6)));
3379
3380 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), RTA_GATEWAY, &GatewayIpv6, sizeof(GatewayIpv6)));
3381
3382 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3383 LxtCheckResult(SocketNetlinkRouteGetRouteBestRouteCheckResponse(Socket, TRUE));
3384 }
3385
3386 //
3387 // Test specifying the destination, gateway and interface index (Ipv4).
3388 //
3389
3390 memset(&Request, 0, sizeof(Request));
3391 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
3392 Request.nlh.nlmsg_type = RTM_GETROUTE;
3393 Request.nlh.nlmsg_seq = 0x4567;
3394 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
3395 Request.msg.rtm_family = AF_INET;
3396 inet_aton("127.0.0.1", &DestinationIpv4);
3397 inet_aton("1.1.1.2", &GatewayIpv4);
3398 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, &GatewayIpv4, LoopbackIndex);
3399
3400 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3401 LxtCheckResult(SocketNetlinkRouteGetRouteBestRouteCheckResponse(Socket, FALSE));
3402
3403 //
3404 // Test specifying the destination, gateway and interface index (Ipv6).
3405 //
3406
3407 memset(&Request, 0, sizeof(Request));
3408 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
3409 Request.nlh.nlmsg_type = RTM_GETROUTE;
3410 Request.nlh.nlmsg_seq = 0x4567;
3411 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
3412 Request.msg.rtm_family = AF_INET6;
3413 inet_pton(AF_INET6, "::1", &DestinationIpv6);
3414 inet_pton(AF_INET6, "13::", &GatewayIpv6);
3415 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), RTA_DST, &DestinationIpv6, sizeof(DestinationIpv6)));
3416
3417 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), RTA_GATEWAY, &GatewayIpv6, sizeof(GatewayIpv6)));
3418
3419 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), RTA_OIF, &LoopbackIndex, sizeof(LoopbackIndex)));
3420
3421 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3422 LxtCheckResult(SocketNetlinkRouteGetRouteBestRouteCheckResponse(Socket, FALSE));
3423
3424 ErrorExit:
3425 if (Socket > 0)
3426 {
3427 close(Socket);
3428 }
3429
3430 return Result;
3431 }
3432
3433 int SocketNetlinkRouteGetRouteBestRouteCheckResponse(int Socket, int CheckGateway)
3434
3435 /*++
3436
3437 Routine Description:
3438
3439 This routine tests the response to the NETLINK_ROUTE protocol's
3440 RTM_GETROUTE message's get best route request.
3441
3442 Arguments:
3443
3444 Socket - Supplies the socket to read the response from.
3445
3446 CheckGateway - Supplies a boolean indicating whether to check for the
3447 presence of the RTA_GATEWAY attribute.
3448
3449 Return Value:
3450
3451 Returns 0 on success, -1 on failure.
3452
3453 --*/
3454
3455 {
3456
3457 struct rtattr* Attribute;
3458 char AttributeDump[ATTRIBUTE_DUMP_BUFFER_SIZE];
3459 int AttributeSeenDst;
3460 int AttributeSeenGateway;
3461 int AttributeSeenOif;
3462 int FoundDone;
3463 struct nlmsghdr* Header;
3464 char ReceiveBuffer[5000];
3465 int ReceiveResult;
3466 int RemainingLength;
3467 int Result;
3468 struct rtmsg* RtMsg;
3469
3470 AttributeSeenDst = 0;
3471 AttributeSeenGateway = 0;
3472 AttributeSeenOif = 0;
3473 FoundDone = 0;
3474 LxtCheckErrno(ReceiveResult = recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0, NULL, 0));
3475
3476 Header = (struct nlmsghdr*)ReceiveBuffer;
3477 RtMsg = (struct rtmsg*)NLMSG_DATA(Header);
3478 LxtLogInfo(
3479 "rtmsg: rtm_family %d rtm_dst_len %d rtm_src_len %d "
3480 "rtm_tos %d rtm_table %d rtm_protocol %d "
3481 "rtm_scope %d rtm_type %d rtm_flags %d",
3482 RtMsg->rtm_family,
3483 RtMsg->rtm_dst_len,
3484 RtMsg->rtm_src_len,
3485 RtMsg->rtm_tos,
3486 RtMsg->rtm_table,
3487 RtMsg->rtm_protocol,
3488 RtMsg->rtm_scope,
3489 RtMsg->rtm_type,
3490 RtMsg->rtm_flags);
3491
3492 Attribute = (struct rtattr*)((char*)RtMsg + sizeof(struct rtmsg));
3493 RemainingLength = Header->nlmsg_len - NLMSG_LENGTH(sizeof(struct rtmsg));
3494 while (RTA_OK(Attribute, RemainingLength))
3495 {
3496 SocketNetlinkRouteDumpAttributeData(AttributeDump, ATTRIBUTE_DUMP_BUFFER_SIZE, Attribute);
3497
3498 LxtLogInfo("RTATTR type: %2d len: %3d data: %s", Attribute->rta_type, Attribute->rta_len, AttributeDump);
3499
3500 if (Attribute->rta_type == RTA_DST)
3501 {
3502 AttributeSeenDst += 1;
3503 }
3504 else if (Attribute->rta_type == RTA_GATEWAY)
3505 {
3506 AttributeSeenGateway += 1;
3507 }
3508 else if (Attribute->rta_type == RTA_OIF)
3509 {
3510 AttributeSeenOif += 1;
3511 }
3512
3513 Attribute = RTA_NEXT(Attribute, RemainingLength);
3514 }
3515
3516 LxtCheckTrue(AttributeSeenDst > 0);
3517 if (CheckGateway != FALSE)
3518 {
3519 LxtCheckTrue(AttributeSeenGateway > 0);
3520 }
3521
3522 LxtCheckTrue(AttributeSeenOif > 0);
3523 Result = LXT_RESULT_SUCCESS;
3524
3525 ErrorExit:
3526 return Result;
3527 }
3528
3529 int SocketNetlinkRouteGetRouteDump(PLXT_ARGS Args)
3530
3531 /*++
3532
3533 Routine Description:
3534
3535 This routine tests the NETLINK_ROUTE protocol's RTM_GETROUTE message's
3536 dump request.
3537
3538 Arguments:
3539
3540 Args - Supplies the command line arguments.
3541
3542 Return Value:
3543
3544 Returns 0 on success, -1 on failure.
3545
3546 --*/
3547
3548 {
3549
3550 socklen_t AddressLength;
3551 struct rtattr* Attribute;
3552 char AttributeDump[ATTRIBUTE_DUMP_BUFFER_SIZE];
3553 int AttributeSeenDst;
3554 int AttributeSeenGateway;
3555 int AttributeSeenOif;
3556 int AttributeSeenPriority;
3557 struct sockaddr_nl BindAddress;
3558 struct nlmsgerr* Error;
3559 int FoundDone;
3560 struct nlmsghdr* Header;
3561 int Index;
3562 char ReceiveBuffer[5000];
3563 int ReceiveResult;
3564 int RemainingLength;
3565 int Result;
3566 struct rtmsg* RtMsg;
3567 int SendResult;
3568 int Socket;
3569
3570 struct
3571 {
3572 struct nlmsghdr nlh;
3573 struct rtmsg msg;
3574 } Request;
3575
3576 AttributeSeenDst = 0;
3577 AttributeSeenGateway = 0;
3578 AttributeSeenOif = 0;
3579 AttributeSeenPriority = 0;
3580
3581 //
3582 // Create and bind socket. Create a RTM_GETROUTE request.
3583 //
3584
3585 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
3586 memset(&BindAddress, 0, sizeof(BindAddress));
3587 BindAddress.nl_family = AF_NETLINK;
3588 AddressLength = sizeof(BindAddress);
3589 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
3590
3591 memset(&Request, 0, sizeof(Request));
3592 Request.nlh.nlmsg_len = sizeof(Request);
3593 Request.nlh.nlmsg_type = RTM_GETROUTE;
3594 Request.nlh.nlmsg_seq = 0x4567;
3595 Request.msg.rtm_family = AF_UNSPEC;
3596
3597 //
3598 // Test flags. Only passing the NLM_F_ROOT and/or NLM_F_MATCH flag(s)
3599 // result in no response.
3600 //
3601
3602 Request.nlh.nlmsg_flags = NLM_F_ROOT;
3603 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3604 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
3605
3606 Request.nlh.nlmsg_flags = NLM_F_MATCH;
3607 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3608 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
3609
3610 Request.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH;
3611 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3612 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
3613
3614 //
3615 // Test flags. Passing 0 flags or invalid flags result in no response.
3616 //
3617
3618 Request.nlh.nlmsg_flags = 0;
3619 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3620 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
3621
3622 Request.nlh.nlmsg_flags = 0x40;
3623 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3624 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
3625
3626 //
3627 // Test flags. NLM_F_REQUEST and at least one of NLM_F_ROOT/NLM_F_MATCH
3628 // results in the correct response.
3629 // For the response, verify that at least one interface is present (loopback),
3630 // and also verify the presence of several attributes.
3631 //
3632
3633 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;
3634 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
3635 FoundDone = 0;
3636 for (;;)
3637 {
3638 LxtCheckErrno(ReceiveResult = recvfrom(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0, NULL, 0));
3639
3640 Header = (struct nlmsghdr*)ReceiveBuffer;
3641 while (NLMSG_OK(Header, ReceiveResult))
3642 {
3643 if (Header->nlmsg_type == NLMSG_DONE)
3644 {
3645 FoundDone = 1;
3646 break;
3647 }
3648
3649 RtMsg = (struct rtmsg*)NLMSG_DATA(Header);
3650 LxtLogInfo(
3651 "rtmsg: rtm_family %d rtm_dst_len %d rtm_src_len %d "
3652 "rtm_tos %d rtm_table %d rtm_protocol %d "
3653 "rtm_scope %d rtm_type %d rtm_flags %d",
3654 RtMsg->rtm_family,
3655 RtMsg->rtm_dst_len,
3656 RtMsg->rtm_src_len,
3657 RtMsg->rtm_tos,
3658 RtMsg->rtm_table,
3659 RtMsg->rtm_protocol,
3660 RtMsg->rtm_scope,
3661 RtMsg->rtm_type,
3662 RtMsg->rtm_flags);
3663
3664 Attribute = (struct rtattr*)((char*)RtMsg + sizeof(struct rtmsg));
3665
3666 RemainingLength = Header->nlmsg_len - NLMSG_LENGTH(sizeof(struct rtmsg));
3667
3668 while (RTA_OK(Attribute, RemainingLength))
3669 {
3670 SocketNetlinkRouteDumpAttributeData(AttributeDump, ATTRIBUTE_DUMP_BUFFER_SIZE, Attribute);
3671
3672 LxtLogInfo("RTATTR type: %2d len: %3d data: %s", Attribute->rta_type, Attribute->rta_len, AttributeDump);
3673
3674 if (Attribute->rta_type == RTA_DST)
3675 {
3676 AttributeSeenDst += 1;
3677 }
3678 else if (Attribute->rta_type == RTA_GATEWAY)
3679 {
3680 AttributeSeenGateway += 1;
3681 }
3682 else if (Attribute->rta_type == RTA_OIF)
3683 {
3684 AttributeSeenOif += 1;
3685 }
3686 else if (Attribute->rta_type == RTA_PRIORITY)
3687 {
3688 AttributeSeenPriority += 1;
3689 }
3690
3691 Attribute = RTA_NEXT(Attribute, RemainingLength);
3692 }
3693
3694 Header = NLMSG_NEXT(Header, ReceiveResult);
3695 }
3696
3697 if (FoundDone == 1)
3698 {
3699 break;
3700 }
3701 }
3702
3703 LxtCheckTrue(AttributeSeenDst > 0);
3704 LxtCheckTrue(AttributeSeenGateway > 0);
3705 LxtCheckTrue(AttributeSeenOif > 0);
3706 LxtCheckTrue(AttributeSeenPriority > 0);
3707
3708 //
3709 // Check that sending is still successful even if the
3710 // receive buffer has overflown.
3711 //
3712
3713 for (Index = 0; Index < 1000; Index++)
3714 {
3715 LxtCheckErrno(SendResult = send(Socket, &Request, sizeof(Request), 0));
3716 LxtCheckEqual(SendResult, sizeof(Request), "%d");
3717 }
3718
3719 ErrorExit:
3720 if (Socket > 0)
3721 {
3722 close(Socket);
3723 }
3724
3725 return Result;
3726 }
3727
3728 int SocketNetlinkGetLoopbackIndex(int* LoopbackIndex)
3729
3730 /*++
3731
3732 Routine Description:
3733
3734 This routine obtains the interface index of the loopback adapter.
3735
3736 Arguments:
3737
3738 LoopbackIndex - Supplies a pointer to an integer that receives the
3739 interface index of the loopback adapter.
3740
3741 Return Value:
3742
3743 Returns 0 on success, -1 on failure.
3744
3745 --*/
3746
3747 {
3748
3749 struct ifreq InterfaceRequest;
3750 int Result;
3751 int Socket;
3752
3753 LxtCheckErrno(Socket = socket(AF_INET, SOCK_STREAM, 0));
3754 memset(&InterfaceRequest, 0, sizeof(InterfaceRequest));
3755 strncpy(InterfaceRequest.ifr_name, SOCKET_LOOPBACK_IF_NAME, sizeof(InterfaceRequest.ifr_name) - 1);
3756
3757 LxtCheckErrnoZeroSuccess(ioctl(Socket, SIOCGIFINDEX, &InterfaceRequest));
3758 *LoopbackIndex = InterfaceRequest.ifr_ifindex;
3759
3760 ErrorExit:
3761 if (Socket > 0)
3762 {
3763 close(Socket);
3764 }
3765
3766 return Result;
3767 }
3768
3769 int SocketNetlinkCheckResponseError(void* ReceiveBuffer, int ReceiveResult, int Error)
3770
3771 /*++
3772
3773 Routine Description:
3774
3775 This routine checks the Netlink error message response.
3776
3777 Arguments:
3778
3779 ReceiveBuffer - Supplies a pointer to the error message.
3780
3781 ReceiveResult - Supplies the total size of the error message.
3782
3783 Error - Supplies the error number to check for in the error message.
3784
3785 Return Value:
3786
3787 Returns 0 on success, -1 on failure.
3788
3789 --*/
3790
3791 {
3792
3793 struct nlmsgerr* ErrorMessage;
3794 struct nlmsghdr* ReceiveHeader;
3795 int Result;
3796
3797 ReceiveHeader = (struct nlmsghdr*)ReceiveBuffer;
3798 LxtCheckTrue(NLMSG_OK(ReceiveHeader, ReceiveResult));
3799 LxtCheckEqual(ReceiveHeader->nlmsg_type, NLMSG_ERROR, "%d");
3800 ErrorMessage = (struct nlmsgerr*)NLMSG_DATA(ReceiveHeader);
3801 LxtCheckEqual(ErrorMessage->error, Error, "%d");
3802 Result = 0;
3803
3804 ErrorExit:
3805 return Result;
3806 }
3807
3808 int SocketNetlinkRouteAddAttribute(struct nlmsghdr* Msghdr, int MessageSize, int AttributeType, void* AttributeData, int AttributeSize)
3809
3810 /*++
3811
3812 Routine Description:
3813
3814 This routine adds a RT attribute to the Netlink message.
3815
3816 Arguments:
3817
3818 Msghdr - Supplies the message header.
3819
3820 MessageSize - Supplies the total possible size of the message.
3821
3822 AttributeType - Supplies the RT attribute type.
3823
3824 AttributeData - Supplies the RT attribute data.
3825
3826 AttributeSize - Supplies the RT attribute size.
3827
3828 Return Value:
3829
3830 Returns 0 on success, -1 on failure.
3831
3832 --*/
3833
3834 {
3835
3836 int Length;
3837 struct rtattr* Attribute;
3838
3839 Length = RTA_LENGTH(AttributeSize);
3840 if (NLMSG_ALIGN(Msghdr->nlmsg_len) + RTA_ALIGN(Length) > MessageSize)
3841 {
3842 LxtLogError("Adding RT attribute, message size overflowed: %d %d %d", Msghdr->nlmsg_len, Length, MessageSize);
3843
3844 return -1;
3845 }
3846
3847 Attribute = NLMSG_TAIL(Msghdr);
3848 Attribute->rta_type = AttributeType;
3849 Attribute->rta_len = Length;
3850 memcpy(RTA_DATA(Attribute), AttributeData, AttributeSize);
3851 Msghdr->nlmsg_len = NLMSG_ALIGN(Msghdr->nlmsg_len) + RTA_ALIGN(Length);
3852 return 0;
3853 }
3854
3855 void SocketNetlinkRouteAddAddressAttributes(struct nlmsghdr* Msghdr, int MessageSize, struct in_addr* AddressIpv4)
3856
3857 /*++
3858
3859 Routine Description:
3860
3861 This routine appends the RTM_*ADDR message RT attributes to the message.
3862
3863 Arguments:
3864
3865 Msghdr - Supplies the message header.
3866
3867 MessageSize - Supplies the total possible size of the message.
3868
3869 AddressIpv4 - Supplies a pointer to the IPv4 address RT attribute.
3870
3871 Return Value:
3872
3873 None.
3874
3875 --*/
3876
3877 {
3878
3879 int Result;
3880
3881 if (AddressIpv4 != NULL)
3882 {
3883 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(Msghdr, MessageSize, IFA_ADDRESS, AddressIpv4, sizeof(*AddressIpv4)));
3884
3885 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(Msghdr, MessageSize, IFA_LOCAL, AddressIpv4, sizeof(*AddressIpv4)));
3886 }
3887
3888 ErrorExit:
3889 return;
3890 }
3891
3892 void SocketNetlinkRouteAddRouteAttributes(struct nlmsghdr* Msghdr, int MessageSize, struct in_addr* DestinationIpv4, struct in_addr* GatewayIpv4, int InterfaceIndex)
3893
3894 /*++
3895
3896 Routine Description:
3897
3898 This routine appends the RTM_*ROUTE message RT attributes to the message.
3899
3900 Arguments:
3901
3902 Msghdr - Supplies the message header.
3903
3904 MessageSize - Supplies the total possible size of the message.
3905
3906 DestinationIpv4 - Supplies a pointer to the destination IPv4 address RT attribute.
3907
3908 GatewayIpv4 - Supplies a pointer to the gateway IPv4 address RT attribute.
3909
3910 InterfaceIndex - Supplies the interface index RT attribute.
3911
3912 Return Value:
3913
3914 None.
3915
3916 --*/
3917
3918 {
3919
3920 int Result;
3921
3922 if (DestinationIpv4 != NULL)
3923 {
3924 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(Msghdr, MessageSize, RTA_DST, DestinationIpv4, sizeof(*DestinationIpv4)));
3925 }
3926
3927 if (GatewayIpv4 != NULL)
3928 {
3929 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(Msghdr, MessageSize, RTA_GATEWAY, GatewayIpv4, sizeof(*GatewayIpv4)));
3930 }
3931
3932 if (InterfaceIndex > 0)
3933 {
3934 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(Msghdr, MessageSize, RTA_OIF, &InterfaceIndex, sizeof(InterfaceIndex)));
3935 }
3936
3937 ErrorExit:
3938 return;
3939 }
3940
3941 int SocketNetlinkRouteNewDelAddress(PLXT_ARGS Args)
3942
3943 /*++
3944
3945 Routine Description:
3946
3947 This routine tests the NETLINK_ROUTE protocol's
3948 RTM_NEWADDR and RTM_DELADDR messages.
3949
3950 Arguments:
3951
3952 Args - Supplies the command line arguments.
3953
3954 Return Value:
3955
3956 Returns 0 on success, -1 on failure.
3957
3958 --*/
3959
3960 {
3961
3962 struct in_addr AddressIpv4;
3963 struct in6_addr AddressIpv6;
3964 socklen_t AddressLength;
3965 struct sockaddr_nl BindAddress;
3966 struct nlmsgerr* Error;
3967 struct in_addr GatewayIpv4;
3968 struct in6_addr GatewayIpv6;
3969 int LoopbackIndex;
3970 char ReceiveBuffer[5000];
3971 struct nlmsghdr* ReceiveHeader;
3972 int ReceiveResult;
3973 struct
3974 {
3975 struct nlmsghdr nlh;
3976 struct ifaddrmsg msg;
3977 char attr[200];
3978 } Request;
3979 int Result;
3980 int Retries;
3981 int Socket;
3982
3983 //
3984 // Create and bind socket. Create a RTM_GETROUTE request.
3985 //
3986
3987 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
3988 memset(&BindAddress, 0, sizeof(BindAddress));
3989 BindAddress.nl_family = AF_NETLINK;
3990 AddressLength = sizeof(BindAddress);
3991 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
3992
3993 memset(&Request, 0, sizeof(Request));
3994 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
3995 Request.nlh.nlmsg_type = RTM_NEWADDR;
3996 Request.nlh.nlmsg_seq = 0x4567;
3997 Request.msg.ifa_family = AF_UNSPEC;
3998
3999 //
4000 // Get the interface index of the loopback adapter. All the tests
4001 // below operate on the loopback adapter.
4002 //
4003
4004 LxtCheckErrnoZeroSuccess(SocketNetlinkGetLoopbackIndex(&LoopbackIndex));
4005 LxtCheckTrue(LoopbackIndex > 0);
4006
4007 //
4008 // Test flags. Passing in (invalid) flags for RTM_GET* results in no response.
4009 //
4010
4011 Request.nlh.nlmsg_flags = NLM_F_ROOT;
4012 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4013 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4014
4015 Request.nlh.nlmsg_flags = NLM_F_MATCH;
4016 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4017 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4018
4019 Request.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH;
4020 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4021 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4022
4023 //
4024 // Test invalid flags with NLM_F_ACK.
4025 //
4026
4027 Request.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_ACK;
4028 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4029 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4030 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4031
4032 //
4033 // Test flags. Passing 0 flags or invalid flags result in no response.
4034 //
4035
4036 Request.nlh.nlmsg_flags = 0;
4037 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4038 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4039
4040 Request.nlh.nlmsg_flags = 0x40;
4041 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4042 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4043
4044 //
4045 // Add an ip address 2.1.1.1/30.
4046 //
4047
4048 memset(&Request, 0, sizeof(Request));
4049 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
4050 Request.nlh.nlmsg_type = RTM_NEWADDR;
4051 Request.nlh.nlmsg_seq = 0x4567;
4052 Request.msg.ifa_prefixlen = 30;
4053 Request.msg.ifa_index = LoopbackIndex;
4054 inet_aton("2.1.1.1", &AddressIpv4);
4055
4056 //
4057 // Test specifying an invalid address family.
4058 //
4059
4060 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
4061 Request.msg.ifa_family = AF_UNSPEC;
4062 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4063 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4064 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EOPNOTSUPP));
4065
4066 //
4067 // Test not specifying the ip address, which should fail.
4068 //
4069
4070 Request.msg.ifa_family = AF_INET;
4071 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_EXCL | NLM_F_ACK;
4072 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4073 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4074 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EINVAL));
4075
4076 //
4077 // Basically any flag allows you to create.
4078 // Windows can take up to 10 seconds before sending the WNF notification that lxcore
4079 // uses to update its internal network interface and address cache. Before the cache
4080 // is updated, this create operation will fail, so wait for 20 seconds for the
4081 // operation to succeed.
4082 //
4083
4084 SocketNetlinkRouteAddAddressAttributes(&Request.nlh, sizeof(Request), &AddressIpv4);
4085
4086 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_EXCL | NLM_F_ACK;
4087 LxtCheckResult(SocketNetlinkSendAndWaitForExpectedError(Socket, &Request, sizeof(Request), 0));
4088
4089 //
4090 // Test NLM_F_REPLACE, which should succeed.
4091 // Windows can take up to 10 seconds before sending the WNF notification that lxcore
4092 // uses to update its internal network interface and address cache. Before the cache
4093 // is updated, this replace operation will fail, so wait for 20 seconds for the
4094 // operation to succeed.
4095 //
4096
4097 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_ACK;
4098 LxtCheckResult(SocketNetlinkSendAndWaitForExpectedError(Socket, &Request, sizeof(Request), 0));
4099
4100 //
4101 // Test NLM_F_EXCL, which should fail since it prevents existing addresses
4102 // from being changed.
4103 //
4104
4105 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_EXCL | NLM_F_ACK;
4106 LxtCheckResult(SocketNetlinkSendAndWaitForExpectedError(Socket, &Request, sizeof(Request), -EEXIST));
4107
4108 //
4109 // Even if NLM_F_REPLACE is added to NLM_F_EXCL, it still fails.
4110 //
4111
4112 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_EXCL | NLM_F_ACK;
4113 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4114 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4115 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EEXIST));
4116
4117 //
4118 // NLM_F_CREATE without NLM_F_REPLACE fails.
4119 //
4120
4121 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_ACK;
4122 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4123 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4124 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EEXIST));
4125
4126 //
4127 // NLM_F_CREATE with NLM_F_REPLACE succeeds.
4128 //
4129
4130 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_REPLACE | NLM_F_ACK;
4131 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4132 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4133 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4134
4135 //
4136 // Test giving an invalid interface index, which should fail.
4137 //
4138
4139 Request.msg.ifa_index = 90000;
4140 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_ACK;
4141 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4142 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4143 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -ENODEV));
4144
4145 //
4146 // Add an ip address 2.1.1.2/32.
4147 //
4148
4149 memset(&Request, 0, sizeof(Request));
4150 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
4151 Request.nlh.nlmsg_type = RTM_NEWADDR;
4152 Request.nlh.nlmsg_seq = 0x4567;
4153 Request.msg.ifa_family = AF_INET;
4154 Request.msg.ifa_prefixlen = 32;
4155 Request.msg.ifa_index = LoopbackIndex;
4156 inet_aton("2.1.1.2", &AddressIpv4);
4157 SocketNetlinkRouteAddAddressAttributes(&Request.nlh, sizeof(Request), &AddressIpv4);
4158
4159 //
4160 // Only setting the NLM_F_REQUEST flag allows creating a new ip address.
4161 //
4162
4163 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
4164 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4165 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4166 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4167
4168 //
4169 // Add an ip address 11::/31.
4170 //
4171
4172 memset(&Request, 0, sizeof(Request));
4173 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
4174 Request.nlh.nlmsg_type = RTM_NEWADDR;
4175 Request.nlh.nlmsg_seq = 0x4567;
4176 Request.msg.ifa_family = AF_INET6;
4177 Request.msg.ifa_prefixlen = 31;
4178 Request.msg.ifa_index = LoopbackIndex;
4179 inet_pton(AF_INET6, "11::", &AddressIpv6);
4180 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), IFA_ADDRESS, &AddressIpv6, sizeof(AddressIpv6)));
4181
4182 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), IFA_LOCAL, &AddressIpv6, sizeof(AddressIpv6)));
4183
4184 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
4185 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4186 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4187 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4188
4189 //
4190 // Delete 2.1.1.1/30.
4191 //
4192
4193 usleep(1000 * 40);
4194 memset(&Request, 0, sizeof(Request));
4195 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
4196 Request.nlh.nlmsg_type = RTM_DELADDR;
4197 Request.nlh.nlmsg_seq = 0x4567;
4198 Request.msg.ifa_family = AF_INET;
4199 Request.msg.ifa_prefixlen = 30;
4200 Request.msg.ifa_index = LoopbackIndex;
4201 inet_aton("2.1.1.1", &AddressIpv4);
4202 SocketNetlinkRouteAddAddressAttributes(&Request.nlh, sizeof(Request), &AddressIpv4);
4203
4204 //
4205 // Passing 0 flags results in no response.
4206 //
4207
4208 Request.nlh.nlmsg_flags = 0;
4209 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4210 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4211
4212 //
4213 // Need at least NLM_F_REQUEST.
4214 //
4215
4216 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
4217 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4218 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4219 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4220
4221 //
4222 // Try deleting again, which should fail.
4223 //
4224
4225 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4226 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4227 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EADDRNOTAVAIL));
4228
4229 //
4230 // Delete 2.1.1.2/32.
4231 //
4232
4233 memset(&Request, 0, sizeof(Request));
4234 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
4235 Request.nlh.nlmsg_type = RTM_DELADDR;
4236 Request.nlh.nlmsg_seq = 0x4567;
4237 Request.msg.ifa_family = AF_INET;
4238 Request.msg.ifa_prefixlen = 32;
4239 Request.msg.ifa_index = LoopbackIndex;
4240 inet_aton("2.1.1.2", &AddressIpv4);
4241 SocketNetlinkRouteAddAddressAttributes(&Request.nlh, sizeof(Request), &AddressIpv4);
4242
4243 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_EXCL | NLM_F_ACK;
4244 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4245 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4246 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4247
4248 //
4249 // Test giving an invalid interface index, which should fail.
4250 //
4251
4252 Request.msg.ifa_index = 90000;
4253 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4254 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4255 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -ENODEV));
4256
4257 //
4258 // Delete ip address 11::/31.
4259 //
4260
4261 memset(&Request, 0, sizeof(Request));
4262 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
4263 Request.nlh.nlmsg_type = RTM_DELADDR;
4264 Request.nlh.nlmsg_seq = 0x4567;
4265 Request.msg.ifa_family = AF_INET6;
4266 Request.msg.ifa_prefixlen = 31;
4267 Request.msg.ifa_index = LoopbackIndex;
4268 inet_pton(AF_INET6, "11::", &AddressIpv6);
4269
4270 //
4271 // Test not specifying the ip address, which should fail.
4272 //
4273
4274 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
4275 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4276 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4277 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EINVAL));
4278
4279 //
4280 // Now, this should succeed.
4281 //
4282
4283 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), IFA_ADDRESS, &AddressIpv6, sizeof(AddressIpv6)));
4284
4285 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), IFA_LOCAL, &AddressIpv6, sizeof(AddressIpv6)));
4286
4287 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
4288 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4289 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4290 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4291
4292 ErrorExit:
4293 if (Socket > 0)
4294 {
4295 close(Socket);
4296 }
4297
4298 return Result;
4299 }
4300
4301 int SocketNetlinkRouteNewDelRoute(PLXT_ARGS Args)
4302
4303 /*++
4304
4305 Routine Description:
4306
4307 This routine tests the NETLINK_ROUTE protocol's
4308 RTM_NEWROUTE and RTM_DELROUTE messages.
4309
4310 Arguments:
4311
4312 Args - Supplies the command line arguments.
4313
4314 Return Value:
4315
4316 Returns 0 on success, -1 on failure.
4317
4318 --*/
4319
4320 {
4321
4322 socklen_t AddressLength;
4323 struct sockaddr_nl BindAddress;
4324 struct in_addr DestinationIpv4;
4325 struct in6_addr DestinationIpv6;
4326 struct in_addr GatewayIpv4;
4327 struct in6_addr GatewayIpv6;
4328 int LoopbackIndex;
4329 char ReceiveBuffer[5000];
4330 int ReceiveResult;
4331 struct
4332 {
4333 struct nlmsghdr nlh;
4334 struct rtmsg msg;
4335 char attr[200];
4336 } Request;
4337 int Result;
4338 int Socket;
4339
4340 //
4341 // Create and bind socket. Create a RTM_GETROUTE request.
4342 //
4343
4344 LxtCheckErrno(Socket = socket(AF_NETLINK, SOCK_RAW, 0));
4345 memset(&BindAddress, 0, sizeof(BindAddress));
4346 BindAddress.nl_family = AF_NETLINK;
4347 AddressLength = sizeof(BindAddress);
4348 LxtCheckErrno(bind(Socket, (struct sockaddr*)&BindAddress, AddressLength));
4349
4350 memset(&Request, 0, sizeof(Request));
4351 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4352 Request.nlh.nlmsg_type = RTM_NEWROUTE;
4353 Request.nlh.nlmsg_seq = 0x4567;
4354 Request.msg.rtm_family = AF_UNSPEC;
4355
4356 //
4357 // Get the interface index of the loopback adapter. All the tests
4358 // below operate on the loopback adapter.
4359 //
4360
4361 LxtCheckErrnoZeroSuccess(SocketNetlinkGetLoopbackIndex(&LoopbackIndex));
4362 LxtCheckTrue(LoopbackIndex > 0);
4363
4364 //
4365 // Test flags. Passing in (invalid) flags for RTM_GET* results in no response.
4366 //
4367
4368 Request.nlh.nlmsg_flags = NLM_F_ROOT;
4369 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4370 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4371
4372 Request.nlh.nlmsg_flags = NLM_F_MATCH;
4373 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4374 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4375
4376 Request.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH;
4377 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4378 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4379
4380 //
4381 // Test invalid flags with NLM_F_ACK.
4382 //
4383
4384 Request.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_ACK;
4385 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4386 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4387 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4388
4389 //
4390 // Test flags. Passing 0 flags or invalid flags result in no response.
4391 //
4392
4393 Request.nlh.nlmsg_flags = 0;
4394 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4395 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4396
4397 Request.nlh.nlmsg_flags = 0x40;
4398 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4399 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4400
4401 //
4402 // Add a routing entry to lo with destination 1.1.1.1 and on-link gateway.
4403 //
4404
4405 memset(&Request, 0, sizeof(Request));
4406 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4407 Request.nlh.nlmsg_type = RTM_NEWROUTE;
4408 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
4409 Request.nlh.nlmsg_seq = 0x4567;
4410 Request.msg.rtm_dst_len = 32;
4411 Request.msg.rtm_table = RT_TABLE_MAIN;
4412 Request.msg.rtm_protocol = RTPROT_BOOT;
4413 Request.msg.rtm_scope = RT_SCOPE_LINK;
4414 Request.msg.rtm_type = RTN_UNICAST;
4415 inet_aton("1.1.1.1", &DestinationIpv4);
4416 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, NULL, -1);
4417
4418 //
4419 // Test specifying an invalid address family.
4420 //
4421
4422 Request.msg.rtm_family = AF_UNSPEC;
4423 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4424 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4425 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EOPNOTSUPP));
4426
4427 //
4428 // Only send the request with the destination and no interface index.
4429 // The request should fail with ENODEV, because no interface index was specified.
4430 //
4431
4432 Request.msg.rtm_family = AF_INET;
4433 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4434 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4435 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -ENODEV));
4436
4437 //
4438 // Send the request with only NLM_F_REQUEST. The request should fail with ENOENT,
4439 // because destination 1.1.1.1 does not exist and NLM_F_CREATE was not specified.
4440 //
4441
4442 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
4443 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), RTA_OIF, &LoopbackIndex, sizeof(LoopbackIndex)));
4444
4445 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4446 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4447 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -ENOENT));
4448
4449 //
4450 // Now add the NLM_F_REPLACE flag, and the request should still fail.
4451 //
4452
4453 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE;
4454 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4455 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4456 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -ENOENT));
4457
4458 //
4459 // Now add the NLM_F_CREATE flag, and the request should succeed.
4460 // Since the NLM_F_ACK flag was not specified, there should be no response,
4461 // even though the operation succeeded.
4462 //
4463
4464 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE;
4465 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4466 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4467
4468 //
4469 // Sending again gets an error message EEXIST.
4470 //
4471 // N.B. The sleep is to wait for the lxcore internal cache to be updated
4472 // with the latest routing info from NETIO.
4473 //
4474
4475 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE;
4476 LxtCheckResult(SocketNetlinkSendAndWaitForExpectedError(Socket, &Request, sizeof(Request), -EEXIST));
4477
4478 //
4479 // Sending again with only NLM_F_REQUEST still gets an error message EEXIST.
4480 //
4481
4482 Request.nlh.nlmsg_flags = NLM_F_REQUEST;
4483 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4484 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4485 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EEXIST));
4486
4487 //
4488 // Sending again with NLM_F_REQUEST and NLM_F_EXCL still gets an error message EEXIST.
4489 //
4490
4491 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_EXCL;
4492 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4493 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4494 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EEXIST));
4495
4496 //
4497 // Sending again after adding NLM_F_REPLACE still gets an error message EEXIST.
4498 //
4499
4500 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_EXCL | NLM_F_REPLACE;
4501 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4502 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4503 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EEXIST));
4504
4505 //
4506 // Sending again with NLM_F_REPLACE is successful.
4507 //
4508
4509 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_APPEND | NLM_F_ACK;
4510 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4511 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4512 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4513
4514 //
4515 // Add a routing entry to lo with destination 1.1.1.2 and on-link gateway.
4516 // Send the request with various flags. The request should succeed.
4517 //
4518
4519 usleep(1000 * 60);
4520 memset(&Request, 0, sizeof(Request));
4521 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4522 Request.nlh.nlmsg_type = RTM_NEWROUTE;
4523 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE | NLM_F_EXCL;
4524 Request.nlh.nlmsg_seq = 0x4567;
4525 Request.msg.rtm_family = AF_INET;
4526 Request.msg.rtm_dst_len = 32;
4527 Request.msg.rtm_table = RT_TABLE_MAIN;
4528 Request.msg.rtm_protocol = RTPROT_BOOT;
4529 Request.msg.rtm_scope = RT_SCOPE_LINK;
4530 Request.msg.rtm_type = RTN_UNICAST;
4531 inet_aton("1.1.1.2", &DestinationIpv4);
4532 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, NULL, LoopbackIndex);
4533
4534 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4535 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4536
4537 //
4538 // Sending again gets an error message EEXIST.
4539 //
4540
4541 usleep(1000 * 60);
4542 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE | NLM_F_EXCL | NLM_F_ACK;
4543 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4544 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4545 LxtCheckEqual(ReceiveResult, Request.nlh.nlmsg_len + NLMSG_LENGTH(sizeof(int)), "%d");
4546 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EEXIST));
4547
4548 //
4549 // Sending again with the following flags still gets an error message EEXIST.
4550 //
4551
4552 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_EXCL | NLM_F_ACK;
4553 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4554 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4555 LxtCheckEqual(ReceiveResult, Request.nlh.nlmsg_len + NLMSG_LENGTH(sizeof(int)), "%d");
4556 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EEXIST));
4557
4558 //
4559 // Use NLM_F_REPLACE to change the gateway from on-link to 1.1.1.1.
4560 // Note that including the NLM_F_EXCL flag fails the operation.
4561 //
4562
4563 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE | NLM_F_EXCL;
4564 inet_aton("1.1.1.1", &GatewayIpv4);
4565 Request.msg.rtm_scope = RT_SCOPE_UNIVERSE;
4566 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), RTA_GATEWAY, &GatewayIpv4, sizeof(GatewayIpv4)));
4567
4568 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4569 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4570 LxtCheckEqual(ReceiveResult, Request.nlh.nlmsg_len + NLMSG_LENGTH(sizeof(int)), "%d");
4571 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -EEXIST));
4572
4573 //
4574 // Now remove the NLM_F_EXCL flag, and the operation should succeed.
4575 //
4576
4577 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE | NLM_F_ACK;
4578 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4579 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4580 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4581
4582 //
4583 // Add a routing entry to lo with destination 1.1.1.3 and gateway 1.1.1.1.
4584 // Send the request with various flags. The request should succeed.
4585 //
4586
4587 usleep(1000 * 60);
4588 memset(&Request, 0, sizeof(Request));
4589 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4590 Request.nlh.nlmsg_type = RTM_NEWROUTE;
4591 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE;
4592 Request.nlh.nlmsg_seq = 0x4567;
4593 Request.msg.rtm_family = AF_INET;
4594 Request.msg.rtm_dst_len = 32;
4595 Request.msg.rtm_table = RT_TABLE_MAIN;
4596 Request.msg.rtm_protocol = RTPROT_BOOT;
4597 Request.msg.rtm_scope = RT_SCOPE_UNIVERSE;
4598 Request.msg.rtm_type = RTN_UNICAST;
4599 inet_aton("1.1.1.3", &DestinationIpv4);
4600 inet_aton("1.1.1.1", &GatewayIpv4);
4601 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, &GatewayIpv4, LoopbackIndex);
4602
4603 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4604 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4605
4606 //
4607 // Change the gateway from 1.1.1.1 to on-link.
4608 // Note that invalid flags are silently dropped.
4609 //
4610
4611 usleep(1000 * 60);
4612 memset(&Request, 0, sizeof(Request));
4613 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4614 Request.nlh.nlmsg_type = RTM_NEWROUTE;
4615 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | 0xF800;
4616 Request.nlh.nlmsg_seq = 0x4567;
4617 Request.msg.rtm_family = AF_INET;
4618 Request.msg.rtm_dst_len = 32;
4619 Request.msg.rtm_table = RT_TABLE_MAIN;
4620 Request.msg.rtm_protocol = RTPROT_BOOT;
4621 Request.msg.rtm_scope = RT_SCOPE_LINK;
4622 Request.msg.rtm_type = RTN_UNICAST;
4623 inet_aton("1.1.1.3", &DestinationIpv4);
4624 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, NULL, LoopbackIndex);
4625
4626 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4627 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4628
4629 //
4630 // Add two more routing entries: destination 1.1.2 and 1.3,
4631 // with 1.1.1.1 as their gateway.
4632 //
4633
4634 usleep(1000 * 60);
4635 memset(&Request, 0, sizeof(Request));
4636 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4637 Request.nlh.nlmsg_type = RTM_NEWROUTE;
4638 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE | NLM_F_ACK;
4639 Request.nlh.nlmsg_seq = 0x4567;
4640 Request.msg.rtm_family = AF_INET;
4641 Request.msg.rtm_dst_len = 32;
4642 Request.msg.rtm_table = RT_TABLE_MAIN;
4643 Request.msg.rtm_protocol = RTPROT_BOOT;
4644 Request.msg.rtm_scope = RT_SCOPE_UNIVERSE;
4645 Request.msg.rtm_type = RTN_UNICAST;
4646 inet_aton("1.1.2", &DestinationIpv4);
4647 inet_aton("1.1.1.1", &GatewayIpv4);
4648 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, &GatewayIpv4, LoopbackIndex);
4649
4650 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4651 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4652 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4653
4654 usleep(1000 * 60);
4655 memset(&Request, 0, sizeof(Request));
4656 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4657 Request.nlh.nlmsg_type = RTM_NEWROUTE;
4658 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE;
4659 Request.nlh.nlmsg_seq = 0x4567;
4660 Request.msg.rtm_family = AF_INET;
4661 Request.msg.rtm_dst_len = 32;
4662 Request.msg.rtm_table = RT_TABLE_MAIN;
4663 Request.msg.rtm_protocol = RTPROT_BOOT;
4664 Request.msg.rtm_scope = RT_SCOPE_UNIVERSE;
4665 Request.msg.rtm_type = RTN_UNICAST;
4666 inet_aton("1.3", &DestinationIpv4);
4667 inet_aton("1.1.1.1", &GatewayIpv4);
4668 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, &GatewayIpv4, LoopbackIndex);
4669
4670 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4671 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4672
4673 //
4674 // Add three more routing entries: destination 1.1.1.0,
4675 // with 1.1.1.1 as their gateway, and prefix lengths 30, 31 and 32.
4676 //
4677
4678 usleep(1000 * 60);
4679 memset(&Request, 0, sizeof(Request));
4680 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4681 Request.nlh.nlmsg_type = RTM_NEWROUTE;
4682 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE;
4683 Request.nlh.nlmsg_seq = 0x4567;
4684 Request.msg.rtm_family = AF_INET;
4685 Request.msg.rtm_dst_len = 30;
4686 Request.msg.rtm_table = RT_TABLE_MAIN;
4687 Request.msg.rtm_protocol = RTPROT_BOOT;
4688 Request.msg.rtm_scope = RT_SCOPE_UNIVERSE;
4689 Request.msg.rtm_type = RTN_UNICAST;
4690 inet_aton("1.1.1.0", &DestinationIpv4);
4691 inet_aton("1.1.1.1", &GatewayIpv4);
4692 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, &GatewayIpv4, LoopbackIndex);
4693
4694 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4695 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4696
4697 usleep(1000 * 60);
4698 memset(&Request, 0, sizeof(Request));
4699 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4700 Request.nlh.nlmsg_type = RTM_NEWROUTE;
4701 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE;
4702 Request.nlh.nlmsg_seq = 0x4567;
4703 Request.msg.rtm_family = AF_INET;
4704 Request.msg.rtm_dst_len = 31;
4705 Request.msg.rtm_table = RT_TABLE_MAIN;
4706 Request.msg.rtm_protocol = RTPROT_BOOT;
4707 Request.msg.rtm_scope = RT_SCOPE_UNIVERSE;
4708 Request.msg.rtm_type = RTN_UNICAST;
4709 inet_aton("1.1.1.0", &DestinationIpv4);
4710 inet_aton("1.1.1.1", &GatewayIpv4);
4711 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, &GatewayIpv4, LoopbackIndex);
4712
4713 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4714 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4715
4716 usleep(1000 * 60);
4717 memset(&Request, 0, sizeof(Request));
4718 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4719 Request.nlh.nlmsg_type = RTM_NEWROUTE;
4720 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_ACK;
4721 Request.nlh.nlmsg_seq = 0x4567;
4722 Request.msg.rtm_family = AF_INET;
4723 Request.msg.rtm_dst_len = 32;
4724 Request.msg.rtm_table = RT_TABLE_MAIN;
4725 Request.msg.rtm_protocol = RTPROT_BOOT;
4726 Request.msg.rtm_scope = RT_SCOPE_UNIVERSE;
4727 Request.msg.rtm_type = RTN_UNICAST;
4728 inet_aton("1.1.1.0", &DestinationIpv4);
4729 inet_aton("1.1.1.1", &GatewayIpv4);
4730 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, &GatewayIpv4, LoopbackIndex);
4731
4732 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4733 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4734 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4735
4736 //
4737 // Test giving an invalid interface index, which should fail.
4738 //
4739
4740 memset(&Request, 0, sizeof(Request));
4741 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4742 Request.nlh.nlmsg_type = RTM_NEWROUTE;
4743 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_ACK;
4744 Request.nlh.nlmsg_seq = 0x4567;
4745 Request.msg.rtm_family = AF_INET;
4746 Request.msg.rtm_dst_len = 32;
4747 Request.msg.rtm_table = RT_TABLE_MAIN;
4748 Request.msg.rtm_protocol = RTPROT_BOOT;
4749 Request.msg.rtm_scope = RT_SCOPE_UNIVERSE;
4750 Request.msg.rtm_type = RTN_UNICAST;
4751 inet_aton("1.1.1.10", &DestinationIpv4);
4752 inet_aton("1.1.1.1", &GatewayIpv4);
4753 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, &GatewayIpv4, 90000);
4754
4755 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4756 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4757 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -ENETUNREACH));
4758
4759 //
4760 // Add 2 Ipv6 entries.
4761 //
4762
4763 usleep(1000 * 60);
4764 memset(&Request, 0, sizeof(Request));
4765 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4766 Request.nlh.nlmsg_type = RTM_NEWROUTE;
4767 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE;
4768 Request.nlh.nlmsg_seq = 0x4567;
4769 Request.msg.rtm_family = AF_INET6;
4770 Request.msg.rtm_dst_len = 31;
4771 Request.msg.rtm_table = RT_TABLE_MAIN;
4772 Request.msg.rtm_protocol = RTPROT_BOOT;
4773 Request.msg.rtm_scope = RT_SCOPE_UNIVERSE;
4774 Request.msg.rtm_type = RTN_UNICAST;
4775 inet_pton(AF_INET6, "3ffa::", &DestinationIpv6);
4776 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), RTA_DST, &DestinationIpv6, sizeof(DestinationIpv6)));
4777
4778 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), RTA_OIF, &LoopbackIndex, sizeof(LoopbackIndex)));
4779
4780 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4781 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4782
4783 usleep(1000 * 60);
4784 memset(&Request, 0, sizeof(Request));
4785 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4786 Request.nlh.nlmsg_type = RTM_NEWROUTE;
4787 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_ACK;
4788 Request.nlh.nlmsg_seq = 0x4567;
4789 Request.msg.rtm_family = AF_INET6;
4790 Request.msg.rtm_dst_len = 32;
4791 Request.msg.rtm_table = RT_TABLE_MAIN;
4792 Request.msg.rtm_protocol = RTPROT_BOOT;
4793 Request.msg.rtm_scope = RT_SCOPE_UNIVERSE;
4794 Request.msg.rtm_type = RTN_UNICAST;
4795 inet_pton(AF_INET6, "3ffa::", &DestinationIpv6);
4796 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), RTA_DST, &DestinationIpv6, sizeof(DestinationIpv6)));
4797
4798 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), RTA_OIF, &LoopbackIndex, sizeof(LoopbackIndex)));
4799
4800 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4801 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4802 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4803
4804 //
4805 // Now test RTM_DELROUTE!
4806 // Now, we have the following routing entries for the loopback adapter:
4807 // Destination Gateway
4808 // 1.1.1.0/30 1.1.1.1
4809 // 1.1.1.0/31 1.1.1.1
4810 // 1.1.1.0/32 1.1.1.1
4811 // 1.1.1.1 on-link (zero)
4812 // 1.1.1.2 1.1.1.1
4813 // 1.1.1.3 on-link (zero)
4814 // 1.1.2 1.1.1.1
4815 // 1.3 1.1.1.1
4816 // === IPv6 ===
4817 // 3ffa::/31 on-link
4818 // 3ffa::/32 on-link
4819 //
4820
4821 //
4822 // Try to delete the routing entry with destination 1.1.1.1 and
4823 // gateway 1.2.3.4, which does not exist, returning ESRCH.
4824 //
4825
4826 memset(&Request, 0, sizeof(Request));
4827 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4828 Request.nlh.nlmsg_type = RTM_DELROUTE;
4829 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE | NLM_F_EXCL | 0x4321;
4830 Request.nlh.nlmsg_seq = 0x4567;
4831 Request.msg.rtm_family = AF_INET;
4832 Request.msg.rtm_dst_len = 32;
4833 Request.msg.rtm_table = RT_TABLE_MAIN;
4834 Request.msg.rtm_scope = RT_SCOPE_NOWHERE;
4835 inet_aton("1.1.1.1", &DestinationIpv4);
4836 inet_aton("1.2.3.4", &GatewayIpv4);
4837 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, &GatewayIpv4, LoopbackIndex);
4838
4839 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4840 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4841 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -ESRCH));
4842
4843 //
4844 // Passing 0 flags results in no response.
4845 //
4846
4847 Request.nlh.nlmsg_flags = 0;
4848 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4849 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4850
4851 //
4852 // Try to delete the routing entry with destination 1.1.1.1 and
4853 // gateway 0.0.0.0, which should succeed.
4854 // Note that as long as the NLM_F_REQUEST flag is present, it does
4855 // not matter what the rest of the flags are.
4856 //
4857
4858 memset(&Request, 0, sizeof(Request));
4859 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4860 Request.nlh.nlmsg_type = RTM_DELROUTE;
4861 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE | NLM_F_EXCL | 0x4321;
4862 Request.nlh.nlmsg_seq = 0x4567;
4863 Request.msg.rtm_family = AF_INET;
4864 Request.msg.rtm_dst_len = 32;
4865 Request.msg.rtm_table = RT_TABLE_MAIN;
4866 Request.msg.rtm_scope = RT_SCOPE_NOWHERE;
4867 inet_aton("1.1.1.1", &DestinationIpv4);
4868 inet_aton("0.0.0.0", &GatewayIpv4);
4869 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, &GatewayIpv4, LoopbackIndex);
4870
4871 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4872 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4873
4874 //
4875 // Try to delete the routing entry with destination 1.1.1.2 and
4876 // gateway 1.2.3.4, which does not exist, returning ESRCH.
4877 //
4878
4879 memset(&Request, 0, sizeof(Request));
4880 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4881 Request.nlh.nlmsg_type = RTM_DELROUTE;
4882 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE | NLM_F_EXCL | 0x4321;
4883 Request.nlh.nlmsg_seq = 0x4567;
4884 Request.msg.rtm_family = AF_INET;
4885 Request.msg.rtm_dst_len = 32;
4886 Request.msg.rtm_table = RT_TABLE_MAIN;
4887 Request.msg.rtm_scope = RT_SCOPE_NOWHERE;
4888 inet_aton("1.1.1.2", &DestinationIpv4);
4889 inet_aton("1.2.3.4", &GatewayIpv4);
4890 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, &GatewayIpv4, LoopbackIndex);
4891
4892 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4893 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4894 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -ESRCH));
4895
4896 //
4897 // Try to delete the routing entry with destination 1.1.1.2 and
4898 // gateway 0.0.0.0, which should succeed.
4899 // Note that even though the gateway is 1.1.1.1, specifying
4900 // 0.0.0.0 in the request specifies a wildcard gateway.
4901 //
4902
4903 memset(&Request, 0, sizeof(Request));
4904 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4905 Request.nlh.nlmsg_type = RTM_DELROUTE;
4906 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE | NLM_F_EXCL | 0x4321;
4907 Request.nlh.nlmsg_seq = 0x4567;
4908 Request.msg.rtm_family = AF_INET;
4909 Request.msg.rtm_dst_len = 32;
4910 Request.msg.rtm_table = RT_TABLE_MAIN;
4911 Request.msg.rtm_scope = RT_SCOPE_NOWHERE;
4912 inet_aton("1.1.1.2", &DestinationIpv4);
4913 inet_aton("0.0.0.0", &GatewayIpv4);
4914 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, &GatewayIpv4, LoopbackIndex);
4915
4916 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4917 LxtCheckErrnoFailure(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), MSG_DONTWAIT), EAGAIN);
4918
4919 //
4920 // Test giving an invalid interface index, which should fail.
4921 //
4922
4923 memset(&Request, 0, sizeof(Request));
4924 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4925 Request.nlh.nlmsg_type = RTM_DELROUTE;
4926 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE | NLM_F_EXCL | NLM_F_ACK | 0x4321;
4927 Request.nlh.nlmsg_seq = 0x4567;
4928 Request.msg.rtm_family = AF_INET;
4929 Request.msg.rtm_dst_len = 32;
4930 Request.msg.rtm_table = RT_TABLE_MAIN;
4931 Request.msg.rtm_scope = RT_SCOPE_NOWHERE;
4932 inet_aton("1.1.1.3", &DestinationIpv4);
4933 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, NULL, 90000);
4934
4935 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4936 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4937 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, -ESRCH));
4938
4939 //
4940 // Try to delete the routing entry with destination 1.1.1.3 and
4941 // no gateway specified, which should succeed.
4942 //
4943
4944 memset(&Request, 0, sizeof(Request));
4945 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4946 Request.nlh.nlmsg_type = RTM_DELROUTE;
4947 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE | NLM_F_EXCL | NLM_F_ACK | 0x4321;
4948 Request.nlh.nlmsg_seq = 0x4567;
4949 Request.msg.rtm_family = AF_INET;
4950 Request.msg.rtm_dst_len = 32;
4951 Request.msg.rtm_table = RT_TABLE_MAIN;
4952 Request.msg.rtm_scope = RT_SCOPE_NOWHERE;
4953 inet_aton("1.1.1.3", &DestinationIpv4);
4954 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, NULL, LoopbackIndex);
4955
4956 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4957 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4958 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4959
4960 //
4961 // Try to delete the routing entry with destination 1.1.2 and
4962 // no gateway specified, which should succeed.
4963 //
4964
4965 memset(&Request, 0, sizeof(Request));
4966 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4967 Request.nlh.nlmsg_type = RTM_DELROUTE;
4968 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE | NLM_F_EXCL | NLM_F_ACK | 0x4321;
4969 Request.nlh.nlmsg_seq = 0x4567;
4970 Request.msg.rtm_family = AF_INET;
4971 Request.msg.rtm_dst_len = 32;
4972 Request.msg.rtm_table = RT_TABLE_MAIN;
4973 Request.msg.rtm_scope = RT_SCOPE_NOWHERE;
4974 inet_aton("1.1.2", &DestinationIpv4);
4975 SocketNetlinkRouteAddRouteAttributes(&Request.nlh, sizeof(Request), &DestinationIpv4, NULL, LoopbackIndex);
4976
4977 LxtCheckErrno(sendto(Socket, &Request, sizeof(Request), 0, NULL, 0));
4978 LxtCheckErrno(ReceiveResult = recv(Socket, ReceiveBuffer, sizeof(ReceiveBuffer), 0));
4979 LxtCheckResult(SocketNetlinkCheckResponseError(ReceiveBuffer, ReceiveResult, 0));
4980
4981 //
4982 // Try to delete the routing entry with destination 1.3 and
4983 // gateway 1.1.1.1 specified, which should succeed.
4984 //
4985
4986 memset(&Request, 0, sizeof(Request));
4987 Request.nlh.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
4988 Request.nlh.nlmsg_type = RTM_DELROUTE;
4989 Request.nlh.nlmsg_flags = NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE | NLM_F_EXCL | 0x4321;
4990 Request.nlh.nlmsg_seq = 0x4567;
4991 Request.msg.rtm_family = AF_INET;
4992 Request.msg.rtm_dst_len = 32;
4993 Request.msg.rtm_table = RT_TABLE_MAIN;
4994 Request.msg.rtm_scope = RT_SCOPE_NOWHERE;
4995 inet_aton("1.3", &DestinationIpv4);
4996 inet_aton("1.1.1.1", &GatewayIpv4);
4997 LxtCheckErrnoZeroSuccess(SocketNetlinkRouteAddAttribute(&Request.nlh, sizeof(Request), RTA_GATEWAY, &GatewayIpv4, sizeof(GatewayIpv4)));
4998
4999 //
5000 // First try sending incomplete information (only sending the gateway
Showing first 5,000 of 5,394 lines. View raw