1 /*
2 * Copyright (c) 2020 Intel Corporation
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include <zephyr/logging/log.h>
8 LOG_MODULE_REGISTER(net_test, CONFIG_NET_SOCKETS_LOG_LEVEL);
9
10 #include <stdio.h>
11 #include <zephyr/sys/mutex.h>
12 #include <zephyr/ztest_assert.h>
13
14 #include <zephyr/posix/fcntl.h>
15 #include <zephyr/net/socket.h>
16 #include <zephyr/net/ethernet.h>
17
18 #if defined(CONFIG_NET_SOCKETS_LOG_LEVEL_DBG)
19 #define DBG(fmt, ...) NET_DBG(fmt, ##__VA_ARGS__)
20 #else
21 #define DBG(fmt, ...)
22 #endif
23
24 #define IPV4_ADDR "127.0.0.1"
25
26 static uint8_t lladdr1[] = { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 };
27 static uint8_t lladdr2[] = { 0x02, 0x02, 0x02, 0x02, 0x02, 0x02 };
28
29 struct eth_fake_context {
30 struct net_if *iface;
31 uint8_t *mac_address;
32 char *ip_address;
33 };
34
35 static struct eth_fake_context eth_fake_data1 = {
36 .mac_address = lladdr1,
37 .ip_address = IPV4_ADDR,
38 };
39 static struct eth_fake_context eth_fake_data2 = {
40 .mac_address = lladdr2
41 };
42
eth_fake_send(const struct device * dev,struct net_pkt * pkt)43 static int eth_fake_send(const struct device *dev, struct net_pkt *pkt)
44 {
45 struct net_pkt *recv_pkt;
46 int ret;
47 struct net_if *target_iface;
48
49 ARG_UNUSED(dev);
50 ARG_UNUSED(pkt);
51
52 DBG("Sending data (%d bytes) to iface %d\n",
53 net_pkt_get_len(pkt), net_if_get_by_iface(net_pkt_iface(pkt)));
54
55 recv_pkt = net_pkt_rx_clone(pkt, K_NO_WAIT);
56
57 if (memcmp(pkt->frags->data, lladdr1, sizeof(lladdr1)) == 0) {
58 target_iface = eth_fake_data1.iface;
59 } else {
60 target_iface = eth_fake_data2.iface;
61 }
62
63 net_pkt_set_iface(recv_pkt, target_iface);
64
65 k_sleep(K_MSEC(10)); /* Let the receiver run */
66
67 ret = net_recv_data(net_pkt_iface(recv_pkt), recv_pkt);
68 zassert_equal(ret, 0, "Cannot receive data (%d)", ret);
69
70 return 0;
71 }
72
eth_fake_iface_init(struct net_if * iface)73 static void eth_fake_iface_init(struct net_if *iface)
74 {
75 const struct device *dev = net_if_get_device(iface);
76 struct eth_fake_context *ctx = dev->data;
77
78 ctx->iface = iface;
79
80 net_if_set_link_addr(iface, ctx->mac_address, 6, NET_LINK_ETHERNET);
81
82 if (ctx->ip_address != NULL) {
83 struct in_addr addr;
84
85 if (net_addr_pton(AF_INET, ctx->ip_address, &addr) == 0) {
86 net_if_ipv4_addr_add(iface, &addr, NET_ADDR_MANUAL, 0);
87 }
88 }
89
90 ethernet_init(iface);
91 }
92
93 static struct ethernet_api eth_fake_api_funcs = {
94 .iface_api.init = eth_fake_iface_init,
95 .send = eth_fake_send,
96 };
97
98 ETH_NET_DEVICE_INIT(eth_fake1, "eth_fake1", NULL, NULL, ð_fake_data1, NULL,
99 CONFIG_ETH_INIT_PRIORITY, ð_fake_api_funcs,
100 NET_ETH_MTU);
101
102 ETH_NET_DEVICE_INIT(eth_fake2, "eth_fake2", NULL, NULL, ð_fake_data2, NULL,
103 CONFIG_ETH_INIT_PRIORITY, ð_fake_api_funcs,
104 NET_ETH_MTU);
105
setup_socket(struct net_if * iface,int type,int proto)106 static int setup_socket(struct net_if *iface, int type, int proto)
107 {
108 int sock;
109
110 sock = zsock_socket(AF_PACKET, type, proto);
111 zassert_true(sock >= 0, "Cannot create packet socket (%d)", -errno);
112
113 return sock;
114 }
115
bind_socket(int sock,struct net_if * iface)116 static int bind_socket(int sock, struct net_if *iface)
117 {
118 struct sockaddr_ll addr;
119
120 memset(&addr, 0, sizeof(addr));
121
122 addr.sll_ifindex = net_if_get_by_iface(iface);
123 addr.sll_family = AF_PACKET;
124
125 return zsock_bind(sock, (struct sockaddr *)&addr, sizeof(addr));
126 }
127
128 struct user_data {
129 struct net_if *first;
130 struct net_if *second;
131 };
132
iface_cb(struct net_if * iface,void * user_data)133 static void iface_cb(struct net_if *iface, void *user_data)
134 {
135 struct user_data *ud = user_data;
136 struct net_linkaddr *link_addr;
137
138 if (net_if_l2(iface) != &NET_L2_GET_NAME(ETHERNET)) {
139 return;
140 }
141
142 link_addr = net_if_get_link_addr(iface);
143 if (memcmp(link_addr->addr, lladdr1, sizeof(lladdr1)) != 0 &&
144 memcmp(link_addr->addr, lladdr2, sizeof(lladdr2)) != 0) {
145 return;
146 }
147
148 if (ud->first == NULL) {
149 ud->first = iface;
150 return;
151 }
152
153 ud->second = iface;
154 }
155
setblocking(int fd,bool val)156 static void setblocking(int fd, bool val)
157 {
158 int fl, res;
159
160 fl = zsock_fcntl(fd, F_GETFL, 0);
161 zassert_not_equal(fl, -1, "Fail to set fcntl");
162
163 if (val) {
164 fl &= ~O_NONBLOCK;
165 } else {
166 fl |= O_NONBLOCK;
167 }
168
169 res = zsock_fcntl(fd, F_SETFL, fl);
170 zassert_not_equal(res, -1, "Fail to set fcntl");
171 }
172
173 #define SRC_PORT 4240
174 #define DST_PORT 4242
prepare_udp_socket(struct sockaddr_in * sockaddr,uint16_t local_port)175 static int prepare_udp_socket(struct sockaddr_in *sockaddr, uint16_t local_port)
176 {
177 int sock, ret;
178
179 sock = zsock_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
180 zassert_true(sock >= 0, "Cannot create DGRAM (UDP) socket (%d)", sock);
181
182 sockaddr->sin_family = AF_INET;
183 sockaddr->sin_port = htons(local_port);
184 ret = zsock_inet_pton(AF_INET, IPV4_ADDR, &sockaddr->sin_addr);
185 zassert_equal(ret, 1, "inet_pton failed");
186
187 /* Bind UDP socket to local port */
188 ret = zsock_bind(sock, (struct sockaddr *) sockaddr, sizeof(*sockaddr));
189 zassert_equal(ret, 0, "Cannot bind DGRAM (UDP) socket (%d)", -errno);
190
191 return sock;
192 }
193
__test_packet_sockets(int * sock1,int * sock2)194 static void __test_packet_sockets(int *sock1, int *sock2)
195 {
196 struct user_data ud = { 0 };
197 int ret;
198
199 net_if_foreach(iface_cb, &ud);
200
201 zassert_not_null(ud.first, "1st Ethernet interface not found");
202 zassert_not_null(ud.second, "2nd Ethernet interface not found");
203
204 *sock1 = setup_socket(ud.first, SOCK_RAW, htons(ETH_P_ALL));
205 zassert_true(*sock1 >= 0, "Cannot create 1st socket (%d)", *sock1);
206
207 *sock2 = setup_socket(ud.second, SOCK_RAW, htons(ETH_P_ALL));
208 zassert_true(*sock2 >= 0, "Cannot create 2nd socket (%d)", *sock2);
209
210 ret = bind_socket(*sock1, ud.first);
211 zassert_equal(ret, 0, "Cannot bind 1st socket (%d)", -errno);
212
213 ret = bind_socket(*sock2, ud.second);
214 zassert_equal(ret, 0, "Cannot bind 2nd socket (%d)", -errno);
215 }
216
217 #define IP_HDR_SIZE 20
218 #define UDP_HDR_SIZE 8
219 #define HDR_SIZE (IP_HDR_SIZE + UDP_HDR_SIZE)
ZTEST(socket_packet,test_raw_packet_sockets)220 ZTEST(socket_packet, test_raw_packet_sockets)
221 {
222 uint8_t data_to_send[] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
223 uint8_t data_to_receive[sizeof(data_to_send) + HDR_SIZE];
224 struct sockaddr_ll src;
225 struct sockaddr_in sockaddr;
226 int ret, sock1, sock2, sock3, sock4;
227 socklen_t addrlen;
228 ssize_t sent = 0;
229
230 __test_packet_sockets(&sock1, &sock2);
231
232 /* Prepare UDP socket which will read data */
233 sock3 = prepare_udp_socket(&sockaddr, DST_PORT);
234
235 /* Prepare UDP socket from which data are going to be sent */
236 sock4 = prepare_udp_socket(&sockaddr, SRC_PORT);
237 /* Properly set destination port for UDP packet */
238 sockaddr.sin_port = htons(DST_PORT);
239
240 /*
241 * Send UDP datagram to us - as check_ip_addr() in net_send_data()
242 * returns 1 - the packet is processed immediately in the net stack
243 */
244 sent = zsock_sendto(sock4, data_to_send, sizeof(data_to_send),
245 0, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
246 zassert_equal(sent, sizeof(data_to_send), "sendto failed");
247
248 k_msleep(10); /* Let the packet enter the system */
249
250 setblocking(sock3, false);
251 memset(&data_to_receive, 0, sizeof(data_to_receive));
252 errno = 0;
253
254 /* Check if UDP packets can be read after being sent */
255 addrlen = sizeof(sockaddr);
256 ret = zsock_recvfrom(sock3, data_to_receive, sizeof(data_to_receive),
257 0, (struct sockaddr *)&sockaddr, &addrlen);
258 zassert_equal(ret, sizeof(data_to_send), "Cannot receive all data (%d)",
259 -errno);
260 zassert_mem_equal(data_to_receive, data_to_send, sizeof(data_to_send),
261 "Sent and received buffers do not match");
262
263 /* And if the packet has been also passed to RAW socket */
264 setblocking(sock1, false);
265 memset(&data_to_receive, 0, sizeof(data_to_receive));
266 memset(&src, 0, sizeof(src));
267 addrlen = sizeof(src);
268 errno = 0;
269
270 /* The recvfrom reads the whole received packet - including its
271 * IP (20B) and UDP (8) headers. After those we can expect payload,
272 * which have been sent.
273 */
274 ret = zsock_recvfrom(sock1, data_to_receive, sizeof(data_to_receive), 0,
275 (struct sockaddr *)&src, &addrlen);
276 zassert_equal(ret, sizeof(data_to_send) + HDR_SIZE,
277 "Cannot receive all data (%d vs %zd) (%d)",
278 ret, sizeof(data_to_send), -errno);
279 zassert_mem_equal(&data_to_receive[HDR_SIZE], data_to_send,
280 sizeof(data_to_send),
281 "Sent and received buffers do not match");
282
283 zsock_close(sock1);
284 zsock_close(sock2);
285 zsock_close(sock3);
286 zsock_close(sock4);
287 }
288
ZTEST(socket_packet,test_packet_sockets)289 ZTEST(socket_packet, test_packet_sockets)
290 {
291 int sock1, sock2;
292
293 __test_packet_sockets(&sock1, &sock2);
294
295 zsock_close(sock1);
296 zsock_close(sock2);
297 }
298
ZTEST(socket_packet,test_packet_sockets_dgram)299 ZTEST(socket_packet, test_packet_sockets_dgram)
300 {
301 uint8_t data_to_send[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
302 uint8_t data_to_receive[32];
303 socklen_t addrlen = sizeof(struct sockaddr_ll);
304 struct user_data ud = { 0 };
305 struct sockaddr_ll dst, src;
306 int ret, sock1, sock2;
307 int iter, max_iter = 10;
308
309 net_if_foreach(iface_cb, &ud);
310
311 zassert_not_null(ud.first, "1st Ethernet interface not found");
312 zassert_not_null(ud.second, "2nd Ethernet interface not found");
313
314 sock1 = setup_socket(ud.first, SOCK_DGRAM, htons(ETH_P_TSN));
315 zassert_true(sock1 >= 0, "Cannot create 1st socket (%d)", sock1);
316
317 sock2 = setup_socket(ud.second, SOCK_DGRAM, htons(ETH_P_TSN));
318 zassert_true(sock2 >= 0, "Cannot create 2nd socket (%d)", sock2);
319
320 ret = bind_socket(sock1, ud.first);
321 zassert_equal(ret, 0, "Cannot bind 1st socket (%d)", -errno);
322
323 ret = bind_socket(sock2, ud.second);
324 zassert_equal(ret, 0, "Cannot bind 2nd socket (%d)", -errno);
325
326 setblocking(sock1, false);
327 setblocking(sock2, false);
328
329 memset(&dst, 0, sizeof(dst));
330 dst.sll_family = AF_PACKET;
331 dst.sll_protocol = htons(ETH_P_TSN);
332 memcpy(dst.sll_addr, lladdr1, sizeof(lladdr1));
333
334 ret = zsock_sendto(sock2, data_to_send, sizeof(data_to_send), 0,
335 (const struct sockaddr *)&dst, sizeof(struct sockaddr_ll));
336 zassert_equal(ret, sizeof(data_to_send), "Cannot send all data (%d)",
337 -errno);
338
339 k_msleep(10); /* Let the packet enter the system */
340
341 ret = zsock_recvfrom(sock2, data_to_receive, sizeof(data_to_receive), 0,
342 (struct sockaddr *)&src, &addrlen);
343 zassert_equal(ret, -1, "Received something (%d)", ret);
344 zassert_equal(errno, EAGAIN, "Wrong errno (%d)", errno);
345
346 memset(&src, 0, sizeof(src));
347 errno = 0;
348 iter = 0;
349 do {
350 ret = zsock_recvfrom(sock1, data_to_receive, sizeof(data_to_receive),
351 0, (struct sockaddr *)&src, &addrlen);
352 k_msleep(10);
353 iter++;
354 } while (ret < 0 && errno == EAGAIN && iter < max_iter);
355
356 zassert_equal(ret, sizeof(data_to_send),
357 "Cannot receive all data (%d vs %zd) (%d)",
358 ret, sizeof(data_to_send), -errno);
359
360 zassert_equal(addrlen, sizeof(struct sockaddr_ll),
361 "Invalid address length (%d)", addrlen);
362
363 struct sockaddr_ll src_expected = {
364 .sll_family = AF_PACKET,
365 .sll_protocol = dst.sll_protocol,
366 .sll_ifindex = net_if_get_by_iface(ud.first),
367 .sll_pkttype = PACKET_OTHERHOST,
368 .sll_hatype = ARPHRD_ETHER,
369 .sll_halen = sizeof(lladdr2),
370 .sll_addr = {0},
371 };
372 memcpy(&src_expected.sll_addr, lladdr2, ARRAY_SIZE(lladdr2));
373 zassert_mem_equal(&src, &src_expected, addrlen, "Invalid source address");
374
375 zassert_mem_equal(data_to_send, data_to_receive, sizeof(data_to_send),
376 "Data mismatch");
377
378 memcpy(dst.sll_addr, lladdr2, sizeof(lladdr2));
379
380 /* Send to socket 2 but read from socket 1. There should not be any
381 * data in socket 1
382 */
383 ret = zsock_sendto(sock2, data_to_send, sizeof(data_to_send), 0,
384 (const struct sockaddr *)&dst, sizeof(struct sockaddr_ll));
385 zassert_equal(ret, sizeof(data_to_send), "Cannot send all data (%d)",
386 -errno);
387
388 k_msleep(10);
389 memset(&src, 0, sizeof(src));
390
391 ret = zsock_recvfrom(sock1, data_to_receive, sizeof(data_to_receive), 0,
392 (struct sockaddr *)&src, &addrlen);
393 zassert_equal(ret, -1, "Received something (%d)", ret);
394 zassert_equal(errno, EAGAIN, "Wrong errno (%d)", errno);
395
396 memset(&src, 0, sizeof(src));
397
398 errno = 0;
399 iter = 0;
400 do {
401 ret = zsock_recvfrom(sock2, data_to_receive, sizeof(data_to_receive),
402 0, (struct sockaddr *)&src, &addrlen);
403 k_msleep(10);
404 iter++;
405 } while (ret < 0 && errno == EAGAIN && iter < max_iter);
406
407 zassert_equal(ret, sizeof(data_to_send), "Cannot receive all data (%d)",
408 -errno);
409 zassert_equal(addrlen, sizeof(struct sockaddr_ll),
410 "Invalid address length (%d)", addrlen);
411
412 src_expected = (struct sockaddr_ll){
413 .sll_family = AF_PACKET,
414 .sll_protocol = dst.sll_protocol,
415 .sll_ifindex = net_if_get_by_iface(ud.second),
416 .sll_pkttype = PACKET_OTHERHOST,
417 .sll_hatype = ARPHRD_ETHER,
418 .sll_halen = ARRAY_SIZE(lladdr2),
419 .sll_addr = {0},
420 };
421 memcpy(&src_expected.sll_addr, lladdr2, ARRAY_SIZE(lladdr2));
422 zassert_mem_equal(&src, &src_expected, addrlen, "Invalid source address");
423
424 zassert_mem_equal(data_to_send, data_to_receive, sizeof(data_to_send),
425 "Data mismatch");
426
427 /* Send specially crafted payload to mimic IPv4 and IPv6 length field,
428 * to ckeck correct length returned.
429 */
430 uint8_t payload_ip_length[64], receive_ip_length[64];
431
432 memset(payload_ip_length, 0, sizeof(payload_ip_length));
433 /* Set ipv4 and ipv6 length fields to represent IP payload with the
434 * length of 1 byte.
435 */
436 payload_ip_length[3] = 21;
437 payload_ip_length[5] = 1;
438
439 ret = zsock_sendto(sock2, payload_ip_length, sizeof(payload_ip_length), 0,
440 (const struct sockaddr *)&dst, sizeof(struct sockaddr_ll));
441 zassert_equal(ret, sizeof(payload_ip_length), "Cannot send all data (%d)", -errno);
442
443 k_msleep(10);
444
445 memset(&src, 0, sizeof(src));
446 errno = 0;
447 iter = 0;
448 do {
449 ret = zsock_recvfrom(sock2, receive_ip_length, sizeof(receive_ip_length), 0,
450 (struct sockaddr *)&src, &addrlen);
451 k_msleep(10);
452 iter++;
453 } while (ret < 0 && errno == EAGAIN && iter < max_iter);
454
455 zassert_equal(ret, ARRAY_SIZE(payload_ip_length), "Cannot receive all data (%d)", -errno);
456 zassert_mem_equal(payload_ip_length, receive_ip_length, sizeof(payload_ip_length),
457 "Data mismatch");
458
459 zsock_close(sock1);
460 zsock_close(sock2);
461 }
462
ZTEST(socket_packet,test_raw_and_dgram_socket_exchange)463 ZTEST(socket_packet, test_raw_and_dgram_socket_exchange)
464 {
465 uint8_t data_to_send[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
466 uint8_t data_to_receive[32];
467 socklen_t addrlen = sizeof(struct sockaddr_ll);
468 struct user_data ud = { 0 };
469 struct sockaddr_ll dst, src;
470 int ret, sock1, sock2;
471 int iter, max_iter = 10;
472 const uint8_t expected_payload_raw[] = {
473 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* Dst ll addr */
474 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, /* Src ll addr */
475 ETH_P_IP >> 8, ETH_P_IP & 0xFF, /* EtherType */
476 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 /* Payload */
477 };
478 const uint8_t send_payload_raw[] = {
479 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, /* Dst ll addr */
480 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* Src ll addr */
481 ETH_P_IP >> 8, ETH_P_IP & 0xFF, /* EtherType */
482 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 /* Payload */
483 };
484
485
486 net_if_foreach(iface_cb, &ud);
487
488 zassert_not_null(ud.first, "1st Ethernet interface not found");
489 zassert_not_null(ud.second, "2nd Ethernet interface not found");
490
491 sock1 = setup_socket(ud.first, SOCK_DGRAM, htons(ETH_P_ALL));
492 zassert_true(sock1 >= 0, "Cannot create 1st socket (%d)", sock1);
493
494 sock2 = setup_socket(ud.second, SOCK_RAW, htons(ETH_P_ALL));
495 zassert_true(sock2 >= 0, "Cannot create 2nd socket (%d)", sock2);
496
497 ret = bind_socket(sock1, ud.first);
498 zassert_equal(ret, 0, "Cannot bind 1st socket (%d)", -errno);
499
500 ret = bind_socket(sock2, ud.second);
501 zassert_equal(ret, 0, "Cannot bind 2nd socket (%d)", -errno);
502
503 setblocking(sock1, false);
504 setblocking(sock2, false);
505
506 memset(&dst, 0, sizeof(dst));
507 dst.sll_family = AF_PACKET;
508 dst.sll_protocol = htons(ETH_P_IP);
509 memcpy(dst.sll_addr, lladdr2, sizeof(lladdr1));
510
511 /* SOCK_DGRAM to SOCK_RAW */
512
513 ret = zsock_sendto(sock1, data_to_send, sizeof(data_to_send), 0,
514 (const struct sockaddr *)&dst, sizeof(struct sockaddr_ll));
515 zassert_equal(ret, sizeof(data_to_send), "Cannot send all data (%d)",
516 -errno);
517
518 k_msleep(10); /* Let the packet enter the system */
519 memset(&src, 0, sizeof(src));
520
521 errno = 0;
522 iter = 0;
523 do {
524 ret = zsock_recvfrom(sock2, data_to_receive, sizeof(data_to_receive),
525 0, (struct sockaddr *)&src, &addrlen);
526 k_msleep(10);
527 iter++;
528 } while (ret < 0 && errno == EAGAIN && iter < max_iter);
529
530 zassert_equal(ret, sizeof(expected_payload_raw),
531 "Cannot receive all data (%d vs %zd) (%d)",
532 ret, sizeof(expected_payload_raw), -errno);
533
534 zassert_mem_equal(expected_payload_raw, data_to_receive,
535 sizeof(expected_payload_raw), "Data mismatch");
536
537 memset(&dst, 0, sizeof(dst));
538 dst.sll_family = AF_PACKET;
539 dst.sll_protocol = htons(ETH_P_IP);
540
541 /* SOCK_RAW to SOCK_DGRAM */
542
543 ret = zsock_sendto(sock2, send_payload_raw, sizeof(send_payload_raw), 0,
544 (const struct sockaddr *)&dst, sizeof(struct sockaddr_ll));
545 zassert_equal(ret, sizeof(send_payload_raw), "Cannot send all data (%d)",
546 -errno);
547
548 k_msleep(10);
549 memset(&src, 0, sizeof(src));
550
551 errno = 0;
552 iter = 0;
553 do {
554 ret = zsock_recvfrom(sock1, data_to_receive, sizeof(data_to_receive),
555 0, (struct sockaddr *)&src, &addrlen);
556 k_msleep(10);
557 iter++;
558 } while (ret < 0 && errno == EAGAIN && iter < max_iter);
559
560 zassert_equal(ret, sizeof(data_to_send), "Cannot receive all data (%d)",
561 -errno);
562 zassert_mem_equal(data_to_send, data_to_receive, sizeof(data_to_send),
563 "Data mismatch");
564
565 zsock_close(sock1);
566 zsock_close(sock2);
567 }
568
ZTEST(socket_packet,test_raw_and_dgram_socket_recv)569 ZTEST(socket_packet, test_raw_and_dgram_socket_recv)
570 {
571 uint8_t data_to_send[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
572 uint8_t data_to_receive[32];
573 socklen_t addrlen = sizeof(struct sockaddr_ll);
574 struct user_data ud = { 0 };
575 struct sockaddr_ll dst, src;
576 int ret, sock1, sock2, sock3;
577 int iter, max_iter = 10;
578 const uint8_t expected_payload_raw[] = {
579 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* Dst ll addr */
580 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, /* Src ll addr */
581 ETH_P_IP >> 8, ETH_P_IP & 0xFF, /* EtherType */
582 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 /* Payload */
583 };
584
585 net_if_foreach(iface_cb, &ud);
586
587 zassert_not_null(ud.first, "1st Ethernet interface not found");
588 zassert_not_null(ud.second, "2nd Ethernet interface not found");
589
590 sock1 = setup_socket(ud.first, SOCK_DGRAM, htons(ETH_P_ALL));
591 zassert_true(sock1 >= 0, "Cannot create 1st socket (%d)", sock1);
592
593 sock2 = setup_socket(ud.second, SOCK_RAW, htons(ETH_P_ALL));
594 zassert_true(sock2 >= 0, "Cannot create 2nd socket (%d)", sock2);
595
596 sock3 = setup_socket(ud.second, SOCK_RAW, htons(ETH_P_ALL));
597 zassert_true(sock3 >= 0, "Cannot create 2nd socket (%d)", sock3);
598
599 ret = bind_socket(sock1, ud.first);
600 zassert_equal(ret, 0, "Cannot bind 1st socket (%d)", -errno);
601
602 ret = bind_socket(sock2, ud.second);
603 zassert_equal(ret, 0, "Cannot bind 2nd socket (%d)", -errno);
604
605 ret = bind_socket(sock3, ud.second);
606 zassert_equal(ret, 0, "Cannot bind 2nd socket (%d)", -errno);
607
608 setblocking(sock1, false);
609 setblocking(sock2, false);
610 setblocking(sock3, false);
611
612 memset(&dst, 0, sizeof(dst));
613 dst.sll_family = AF_PACKET;
614 dst.sll_protocol = htons(ETH_P_IP);
615 memcpy(dst.sll_addr, lladdr2, sizeof(lladdr1));
616
617 ret = zsock_sendto(sock1, data_to_send, sizeof(data_to_send), 0,
618 (const struct sockaddr *)&dst, sizeof(struct sockaddr_ll));
619 zassert_equal(ret, sizeof(data_to_send), "Cannot send all data (%d)",
620 -errno);
621
622 k_msleep(10); /* Let the packet enter the system */
623 memset(&src, 0, sizeof(src));
624
625 /* Both SOCK_DGRAM to SOCK_RAW sockets should receive packet. */
626
627 errno = 0;
628 iter = 0;
629 do {
630 ret = zsock_recvfrom(sock2, data_to_receive, sizeof(data_to_receive),
631 0, (struct sockaddr *)&src, &addrlen);
632 k_msleep(10);
633 iter++;
634 } while (ret < 0 && errno == EAGAIN && iter < max_iter);
635
636 zassert_equal(ret, sizeof(expected_payload_raw),
637 "Cannot receive all data (%d vs %zd) (%d)",
638 ret, sizeof(expected_payload_raw), -errno);
639
640 zassert_mem_equal(expected_payload_raw, data_to_receive,
641 sizeof(expected_payload_raw), "Data mismatch");
642
643 memset(&src, 0, sizeof(src));
644
645 errno = 0;
646 iter = 0;
647 do {
648 ret = zsock_recvfrom(sock3, data_to_receive, sizeof(data_to_receive),
649 0, (struct sockaddr *)&src, &addrlen);
650 k_msleep(10);
651 iter++;
652 } while (ret < 0 && errno == EAGAIN && iter < max_iter);
653
654 zassert_equal(ret, sizeof(expected_payload_raw),
655 "Cannot receive all data (%d)", -errno);
656 zassert_mem_equal(expected_payload_raw, data_to_receive,
657 sizeof(expected_payload_raw), "Data mismatch");
658
659 zsock_close(sock1);
660 zsock_close(sock2);
661 zsock_close(sock3);
662 }
663
664 ZTEST_SUITE(socket_packet, NULL, NULL, NULL, NULL, NULL);
665
