1 /*
2 * Copyright (c) 2019 Linaro Limited
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/ztest_assert.h>
12 #include <zephyr/sys/sem.h>
13
14 #include <zephyr/net/socket.h>
15 #include <zephyr/net/dummy.h>
16
17 #include "net_private.h"
18
19 #include "../../socket_helpers.h"
20
ZTEST_USER(socket_misc_test_suite,test_gethostname)21 ZTEST_USER(socket_misc_test_suite, test_gethostname)
22 {
23 static ZTEST_BMEM char buf[80];
24 int res;
25
26 res = zsock_gethostname(buf, sizeof(buf));
27 zassert_equal(res, 0, "");
28 printk("%s\n", buf);
29 zassert_equal(strcmp(buf, "ztest_hostname"), 0, "");
30 }
31
ZTEST_USER(socket_misc_test_suite,test_inet_pton)32 ZTEST_USER(socket_misc_test_suite, test_inet_pton)
33 {
34 int res;
35 uint8_t buf[32];
36
37 res = zsock_inet_pton(AF_INET, "127.0.0.1", buf);
38 zassert_equal(res, 1, "");
39
40 res = zsock_inet_pton(AF_INET, "127.0.0.1a", buf);
41 zassert_equal(res, 0, "");
42
43 res = zsock_inet_pton(AF_INET6, "a:b:c:d:0:1:2:3", buf);
44 zassert_equal(res, 1, "");
45
46 res = zsock_inet_pton(AF_INET6, "::1", buf);
47 zassert_equal(res, 1, "");
48
49 res = zsock_inet_pton(AF_INET6, "1::", buf);
50 zassert_equal(res, 1, "");
51
52 res = zsock_inet_pton(AF_INET6, "a:b:c:d:0:1:2:3z", buf);
53 zassert_equal(res, 0, "");
54
55 res = zsock_inet_pton(AF_INET, "192.0.2.400", buf);
56 zassert_equal(res, 0, "");
57
58 res = zsock_inet_pton(AF_INET, "0.0", buf);
59 zassert_equal(res, 0, "");
60
61 res = zsock_inet_pton(AF_INET, "0.1", buf);
62 zassert_equal(res, 0, "");
63
64 res = zsock_inet_pton(AF_INET, "0", buf);
65 zassert_equal(res, 0, "");
66
67 res = zsock_inet_pton(AF_INET, "1", buf);
68 zassert_equal(res, 0, "");
69
70 res = zsock_inet_pton(AF_INET, "256", buf);
71 zassert_equal(res, 0, "");
72
73 res = zsock_inet_pton(AF_INET, "00.0.0.0", buf);
74 zassert_equal(res, 0, "");
75
76 res = zsock_inet_pton(AF_INET, "0.0.0.0", buf);
77 zassert_equal(res, 1, "");
78
79 res = zsock_inet_pton(AF_INET, "0.0..0", buf);
80 zassert_equal(res, 0, "");
81
82 res = zsock_inet_pton(AF_INET, "1.2.3.0.", buf);
83 zassert_equal(res, 0, "");
84 }
85
86 #define TEST_MY_IPV4_ADDR "192.0.1.1"
87 #define TEST_PEER_IPV4_ADDR "192.0.2.2"
88 #define TEST_MY_IPV6_ADDR "2001:db8::1"
89 #define TEST_PEER_IPV6_ADDR "2001:db8::2"
90
91 static struct in6_addr my_ipv6_addr1 = { { { 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0,
92 0, 0, 0, 0, 0, 0, 0, 0x1 } } };
93 static struct in_addr my_ipv4_addr1 = { { { 192, 0, 1, 1 } } };
94
95 static struct in6_addr my_ipv6_addr2 = { { { 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0,
96 0, 0, 0, 0, 0, 0, 0, 0x2 } } };
97 static struct in_addr my_ipv4_addr2 = { { { 192, 0, 2, 2 } } };
98
99 static uint8_t lladdr1[] = { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 };
100 static uint8_t lladdr2[] = { 0x02, 0x02, 0x02, 0x02, 0x02, 0x02 };
101
102 struct dummy_context {
103 struct net_if *iface;
104 uint8_t *mac_address;
105 struct in6_addr *ipv6_addr;
106 struct in_addr *ipv4_addr;
107 };
108
109 static struct dummy_context dummy_data1 = {
110 .mac_address = lladdr1,
111 .ipv6_addr = &my_ipv6_addr1,
112 .ipv4_addr = &my_ipv4_addr1
113 };
114 static struct dummy_context dummy_data2 = {
115 .mac_address = lladdr2,
116 .ipv6_addr = &my_ipv6_addr2,
117 .ipv4_addr = &my_ipv4_addr2
118 };
119
120 static ZTEST_BMEM const struct device *current_dev;
121 static ZTEST_BMEM struct sys_sem send_sem;
122
dummy_send(const struct device * dev,struct net_pkt * pkt)123 static int dummy_send(const struct device *dev, struct net_pkt *pkt)
124 {
125 struct net_pkt *recv_pkt;
126 int ret;
127
128 ARG_UNUSED(dev);
129
130 NET_DBG("Sending data (%zd bytes) to iface %d",
131 net_pkt_get_len(pkt), net_if_get_by_iface(net_pkt_iface(pkt)));
132
133 current_dev = dev;
134
135 sys_sem_give(&send_sem);
136
137 /* Report it back to the interface. */
138 recv_pkt = net_pkt_clone(pkt, K_NO_WAIT);
139 if (recv_pkt == NULL) {
140 return -ENOMEM;
141 }
142
143 ret = net_recv_data(net_pkt_iface(recv_pkt), recv_pkt);
144 zassert_equal(ret, 0, "Cannot receive data (%d)", ret);
145
146 net_pkt_unref(pkt);
147
148 return 0;
149 }
150
dummy_iface_init(struct net_if * iface)151 static void dummy_iface_init(struct net_if *iface)
152 {
153 const struct device *dev = net_if_get_device(iface);
154 struct dummy_context *ctx = dev->data;
155 struct net_if_addr *ifaddr;
156
157 ctx->iface = iface;
158
159 net_if_set_link_addr(iface, ctx->mac_address, 6, NET_LINK_DUMMY);
160
161 ifaddr = net_if_ipv6_addr_add(net_if_lookup_by_dev(dev), ctx->ipv6_addr,
162 NET_ADDR_MANUAL, 0);
163 if (!ifaddr) {
164 zassert_not_null(ifaddr, "ipv6 addr");
165 }
166
167 ifaddr = net_if_ipv4_addr_add(net_if_lookup_by_dev(dev), ctx->ipv4_addr,
168 NET_ADDR_MANUAL, 0);
169 if (!ifaddr) {
170 zassert_not_null(ifaddr, "ipv4 addr");
171 }
172 }
173
174 static struct dummy_api dummy_api_funcs = {
175 .iface_api.init = dummy_iface_init,
176 .send = dummy_send,
177 };
178
179 #if defined(CONFIG_NET_INTERFACE_NAME)
180 #define DEV1_NAME "dummy0"
181 #define DEV2_NAME "dummy1"
182 #else
183 #define DEV1_NAME "dummy_1"
184 #define DEV2_NAME "dummy_2"
185 #endif
186
187 NET_DEVICE_INIT(dummy_1, DEV1_NAME, NULL, NULL, &dummy_data1, NULL,
188 CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &dummy_api_funcs,
189 DUMMY_L2, NET_L2_GET_CTX_TYPE(DUMMY_L2), 127);
190
191
192 NET_DEVICE_INIT(dummy_2, DEV2_NAME, NULL, NULL, &dummy_data2, NULL,
193 CONFIG_KERNEL_INIT_PRIORITY_DEFAULT, &dummy_api_funcs,
194 DUMMY_L2, NET_L2_GET_CTX_TYPE(DUMMY_L2), 127);
195
196 #define DST_PORT 4242
197 #define BIND_PORT 4240
198
test_so_bindtodevice(int sock_c,int sock_s,struct sockaddr * peer_addr_1,struct sockaddr * peer_addr_2,socklen_t peer_addrlen,struct sockaddr * bind_addr,socklen_t bind_addrlen)199 void test_so_bindtodevice(int sock_c, int sock_s, struct sockaddr *peer_addr_1,
200 struct sockaddr *peer_addr_2, socklen_t peer_addrlen,
201 struct sockaddr *bind_addr, socklen_t bind_addrlen)
202 {
203 int ret;
204 struct ifreq ifreq = { 0 };
205
206 #if !defined(CONFIG_NET_INTERFACE_NAME)
207 const struct device *dev1 = device_get_binding(DEV1_NAME);
208 const struct device *dev2 = device_get_binding(DEV2_NAME);
209 #endif
210
211 uint8_t send_buf[32];
212 uint8_t recv_buf[sizeof(send_buf)] = { 0 };
213
214 ret = zsock_bind(sock_s, bind_addr, bind_addrlen);
215 zassert_equal(ret, 0, "bind failed, %d", errno);
216
217 /* Bind server socket with interface 2. */
218
219 strcpy(ifreq.ifr_name, DEV2_NAME);
220 ret = zsock_setsockopt(sock_s, SOL_SOCKET, SO_BINDTODEVICE, &ifreq,
221 sizeof(ifreq));
222 zassert_equal(ret, 0, "SO_BINDTODEVICE failed, %d", errno);
223
224 /* Bind client socket with interface 1 and send a packet. */
225
226 current_dev = NULL;
227 sys_sem_init(&send_sem, 0, 1);
228 strcpy(ifreq.ifr_name, DEV1_NAME);
229 strcpy(send_buf, DEV1_NAME);
230
231 ret = zsock_setsockopt(sock_c, SOL_SOCKET, SO_BINDTODEVICE, &ifreq,
232 sizeof(ifreq));
233 zassert_equal(ret, 0, "SO_BINDTODEVICE failed, %d", errno);
234
235 ret = zsock_sendto(sock_c, send_buf, strlen(send_buf) + 1, 0,
236 peer_addr_1, peer_addrlen);
237 zassert_equal(ret, strlen(send_buf) + 1, "sendto failed, %d", errno);
238
239 ret = sys_sem_take(&send_sem, K_MSEC(100));
240 zassert_equal(ret, 0, "iface did not receive packet");
241
242 #if !defined(CONFIG_NET_INTERFACE_NAME)
243 zassert_equal_ptr(dev1, current_dev, "invalid interface used (%p vs %p)",
244 dev1, current_dev);
245 #endif
246
247 k_msleep(10);
248
249 /* Bind client socket with interface 2 and send a packet. */
250
251 current_dev = NULL;
252 sys_sem_init(&send_sem, 0, 1);
253 strcpy(ifreq.ifr_name, DEV2_NAME);
254 strcpy(send_buf, DEV2_NAME);
255
256 ret = zsock_setsockopt(sock_c, SOL_SOCKET, SO_BINDTODEVICE, &ifreq,
257 sizeof(ifreq));
258 zassert_equal(ret, 0, "SO_BINDTODEVICE failed, %d", errno);
259
260 ret = zsock_sendto(sock_c, send_buf, strlen(send_buf) + 1, 0,
261 peer_addr_2, peer_addrlen);
262 zassert_equal(ret, strlen(send_buf) + 1, "sendto failed, %d", errno);
263
264 ret = sys_sem_take(&send_sem, K_MSEC(100));
265 zassert_equal(ret, 0, "iface did not receive packet");
266
267 #if !defined(CONFIG_NET_INTERFACE_NAME)
268 zassert_equal_ptr(dev2, current_dev, "invalid interface used (%p vs %p)",
269 dev2, current_dev);
270 #endif
271
272 /* Server socket should only receive data from the bound interface. */
273
274 k_msleep(10);
275
276 ret = zsock_recv(sock_s, recv_buf, sizeof(recv_buf), ZSOCK_MSG_DONTWAIT);
277 zassert_true(ret > 0, "recv failed, %d", errno);
278 zassert_mem_equal(recv_buf, DEV2_NAME, strlen(DEV2_NAME),
279 "received datagram from invalid interface");
280
281 /* Remove the binding from the server socket. */
282
283 strcpy(ifreq.ifr_name, "");
284 ret = zsock_setsockopt(sock_s, SOL_SOCKET, SO_BINDTODEVICE, &ifreq,
285 sizeof(ifreq));
286 zassert_equal(ret, 0, "SO_BINDTODEVICE failed, %d", errno);
287
288 /* Bind client socket with interface 1 again. */
289
290 sys_sem_init(&send_sem, 0, 1);
291 strcpy(ifreq.ifr_name, DEV1_NAME);
292 strcpy(send_buf, DEV1_NAME);
293
294 ret = zsock_setsockopt(sock_c, SOL_SOCKET, SO_BINDTODEVICE, &ifreq,
295 sizeof(ifreq));
296 zassert_equal(ret, 0, "SO_BINDTODEVICE failed, %d", errno);
297
298 ret = zsock_sendto(sock_c, send_buf, strlen(send_buf) + 1, 0,
299 peer_addr_1, peer_addrlen);
300 zassert_equal(ret, strlen(send_buf) + 1, "sendto failed, %d", errno);
301
302 ret = sys_sem_take(&send_sem, K_MSEC(100));
303 zassert_equal(ret, 0, "iface did not receive packet");
304
305 #if !defined(CONFIG_NET_INTERFACE_NAME)
306 zassert_equal_ptr(dev1, current_dev, "invalid interface used");
307 #endif
308
309 /* Server socket should now receive data from interface 1 as well. */
310
311 k_msleep(10);
312
313 ret = zsock_recv(sock_s, recv_buf, sizeof(recv_buf), ZSOCK_MSG_DONTWAIT);
314 zassert_true(ret > 0, "recv failed, %d", errno);
315 zassert_mem_equal(recv_buf, DEV1_NAME, strlen(DEV1_NAME),
316 "received datagram from invalid interface");
317
318 ret = zsock_close(sock_c);
319 zassert_equal(ret, 0, "close failed, %d", errno);
320 ret = zsock_close(sock_s);
321 zassert_equal(ret, 0, "close failed, %d", errno);
322
323 k_sleep(K_MSEC(CONFIG_NET_TCP_TIME_WAIT_DELAY));
324 }
325
test_ipv4_so_bindtodevice(void)326 void test_ipv4_so_bindtodevice(void)
327 {
328 int sock_c;
329 int sock_s;
330 struct sockaddr_in peer_addr_1 = {
331 .sin_family = AF_INET,
332 .sin_port = htons(DST_PORT),
333 .sin_addr = { { { 192, 0, 1, 1 } } },
334 };
335 struct sockaddr_in peer_addr_2 = {
336 .sin_family = AF_INET,
337 .sin_port = htons(DST_PORT),
338 .sin_addr = { { { 192, 0, 2, 2 } } },
339 };
340 struct sockaddr_in bind_addr = {
341 .sin_family = AF_INET,
342 .sin_port = htons(DST_PORT),
343 .sin_addr = INADDR_ANY_INIT,
344 };
345
346 sock_c = zsock_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
347 zassert_true(sock_c >= 0, "socket open failed");
348 sock_s = zsock_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
349 zassert_true(sock_s >= 0, "socket open failed");
350
351 test_so_bindtodevice(sock_c, sock_s, (struct sockaddr *)&peer_addr_1,
352 (struct sockaddr *)&peer_addr_2, sizeof(peer_addr_1),
353 (struct sockaddr *)&bind_addr, sizeof(bind_addr));
354 }
355
test_ipv6_so_bindtodevice(void)356 void test_ipv6_so_bindtodevice(void)
357 {
358 int sock_c;
359 int sock_s;
360 struct sockaddr_in6 peer_addr_1 = {
361 .sin6_family = AF_INET6,
362 .sin6_port = htons(DST_PORT),
363 .sin6_addr = { { { 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0,
364 0, 0, 0, 0, 0, 0, 0, 0x1 } } },
365 };
366 struct sockaddr_in6 peer_addr_2 = {
367 .sin6_family = AF_INET6,
368 .sin6_port = htons(DST_PORT),
369 .sin6_addr = { { { 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0,
370 0, 0, 0, 0, 0, 0, 0, 0x2 } } },
371 };
372 struct sockaddr_in6 bind_addr = {
373 .sin6_family = AF_INET6,
374 .sin6_port = htons(DST_PORT),
375 .sin6_addr = IN6ADDR_ANY_INIT,
376 };
377
378 sock_c = zsock_socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
379 zassert_true(sock_c >= 0, "socket open failed");
380 sock_s = zsock_socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
381 zassert_true(sock_s >= 0, "socket open failed");
382
383 test_so_bindtodevice(sock_c, sock_s, (struct sockaddr *)&peer_addr_1,
384 (struct sockaddr *)&peer_addr_2, sizeof(peer_addr_1),
385 (struct sockaddr *)&bind_addr, sizeof(bind_addr));
386 }
387
388 #define ADDR_SIZE(family) ((family == AF_INET) ? \
389 sizeof(struct sockaddr_in) : \
390 sizeof(struct sockaddr_in6))
391
test_getpeername(int family)392 void test_getpeername(int family)
393 {
394 int ret;
395 int sock_c;
396 int sock_s;
397 struct sockaddr peer_addr;
398 socklen_t peer_addr_len;
399 struct sockaddr srv_addr = { 0 };
400
401 srv_addr.sa_family = family;
402 if (family == AF_INET) {
403 net_sin(&srv_addr)->sin_port = htons(DST_PORT);
404 ret = zsock_inet_pton(AF_INET, TEST_MY_IPV4_ADDR,
405 &net_sin(&srv_addr)->sin_addr);
406 } else {
407 net_sin6(&srv_addr)->sin6_port = htons(DST_PORT);
408 ret = zsock_inet_pton(AF_INET6, TEST_MY_IPV6_ADDR,
409 &net_sin6(&srv_addr)->sin6_addr);
410 }
411 zassert_equal(ret, 1, "inet_pton failed");
412
413 /* UDP socket */
414 sock_c = zsock_socket(family, SOCK_DGRAM, IPPROTO_UDP);
415 zassert_true(sock_c >= 0, "socket open failed");
416
417 peer_addr_len = ADDR_SIZE(family);
418 ret = zsock_getpeername(sock_c, &peer_addr, &peer_addr_len);
419 zassert_equal(ret, -1, "getpeername shouldn've failed");
420 zassert_equal(errno, ENOTCONN, "getpeername returned invalid error");
421
422 ret = zsock_connect(sock_c, &srv_addr, ADDR_SIZE(family));
423 zassert_equal(ret, 0, "connect failed");
424
425 memset(&peer_addr, 0, sizeof(peer_addr));
426 peer_addr_len = ADDR_SIZE(family);
427 ret = zsock_getpeername(sock_c, &peer_addr, &peer_addr_len);
428 zassert_equal(ret, 0, "getpeername failed");
429 zassert_mem_equal(&peer_addr, &srv_addr, ADDR_SIZE(family),
430 "obtained wrong address");
431
432 ret = zsock_close(sock_c);
433 zassert_equal(ret, 0, "close failed, %d", errno);
434
435 /* TCP socket */
436 sock_c = zsock_socket(family, SOCK_STREAM, IPPROTO_TCP);
437 zassert_true(sock_c >= 0, "socket open failed");
438 sock_s = zsock_socket(family, SOCK_STREAM, IPPROTO_TCP);
439 zassert_true(sock_s >= 0, "socket open failed");
440
441 ret = zsock_bind(sock_s, &srv_addr, ADDR_SIZE(family));
442 zassert_equal(ret, 0, "bind failed, %d", errno);
443
444 ret = zsock_listen(sock_s, 1);
445 zassert_equal(ret, 0, "listen failed, %d", errno);
446
447 peer_addr_len = ADDR_SIZE(family);
448 ret = zsock_getpeername(sock_c, &peer_addr, &peer_addr_len);
449 zassert_equal(ret, -1, "getpeername shouldn've failed");
450 zassert_equal(errno, ENOTCONN, "getpeername returned invalid error");
451
452 ret = zsock_connect(sock_c, &srv_addr, ADDR_SIZE(family));
453 zassert_equal(ret, 0, "connect failed");
454
455 memset(&peer_addr, 0, sizeof(peer_addr));
456 peer_addr_len = ADDR_SIZE(family);
457 ret = zsock_getpeername(sock_c, &peer_addr, &peer_addr_len);
458 zassert_equal(ret, 0, "getpeername failed");
459 zassert_mem_equal(&peer_addr, &srv_addr, ADDR_SIZE(family),
460 "obtained wrong address");
461
462 ret = zsock_close(sock_c);
463 zassert_equal(ret, 0, "close failed, %d", errno);
464 ret = zsock_close(sock_s);
465 zassert_equal(ret, 0, "close failed, %d", errno);
466
467 k_sleep(K_MSEC(2 * CONFIG_NET_TCP_TIME_WAIT_DELAY));
468 }
469
470
test_ipv4_getpeername(void)471 void test_ipv4_getpeername(void)
472 {
473 test_getpeername(AF_INET);
474 }
475
test_ipv6_getpeername(void)476 void test_ipv6_getpeername(void)
477 {
478 test_getpeername(AF_INET6);
479 }
480
test_getsockname_tcp(int family)481 void test_getsockname_tcp(int family)
482 {
483 int ret;
484 int sock_c;
485 int sock_s;
486 struct sockaddr local_addr = { 0 };
487 socklen_t local_addr_len = ADDR_SIZE(family);
488 struct sockaddr srv_addr = { 0 };
489
490 srv_addr.sa_family = family;
491 if (family == AF_INET) {
492 net_sin(&srv_addr)->sin_port = htons(DST_PORT);
493 ret = zsock_inet_pton(AF_INET, TEST_MY_IPV4_ADDR,
494 &net_sin(&srv_addr)->sin_addr);
495 } else {
496 net_sin6(&srv_addr)->sin6_port = htons(DST_PORT);
497 ret = zsock_inet_pton(AF_INET6, TEST_MY_IPV6_ADDR,
498 &net_sin6(&srv_addr)->sin6_addr);
499 }
500 zassert_equal(ret, 1, "inet_pton failed");
501
502 sock_c = zsock_socket(family, SOCK_STREAM, IPPROTO_TCP);
503 zassert_true(sock_c >= 0, "socket open failed");
504 sock_s = zsock_socket(family, SOCK_STREAM, IPPROTO_TCP);
505 zassert_true(sock_s >= 0, "socket open failed");
506
507 /* Verify that unbound/unconnected socket has no local address set */
508 ret = zsock_getsockname(sock_c, &local_addr, &local_addr_len);
509 zassert_equal(ret, -1, "getsockname shouldn've failed");
510 zassert_equal(errno, EINVAL, "getsockname returned invalid error");
511 ret = zsock_getsockname(sock_s, &local_addr, &local_addr_len);
512 zassert_equal(ret, -1, "getsockname shouldn've failed");
513 zassert_equal(errno, EINVAL, "getsockname returned invalid error");
514
515 /* Verify that getsockname() can read local address of a bound socket */
516 ret = zsock_bind(sock_s, &srv_addr, ADDR_SIZE(family));
517 zassert_equal(ret, 0, "bind failed, %d", errno);
518
519 memset(&local_addr, 0, sizeof(local_addr));
520 local_addr_len = ADDR_SIZE(family);
521 ret = zsock_getsockname(sock_s, &local_addr, &local_addr_len);
522 zassert_equal(ret, 0, "getsockname failed");
523 zassert_mem_equal(&local_addr, &srv_addr, ADDR_SIZE(family),
524 "obtained wrong address");
525
526 ret = zsock_listen(sock_s, 1);
527 zassert_equal(ret, 0, "listen failed, %d", errno);
528
529 /* Verify that getsockname() can read local address of a connected socket */
530 ret = zsock_connect(sock_c, &srv_addr, ADDR_SIZE(family));
531 zassert_equal(ret, 0, "connect failed");
532
533 memset(&local_addr, 0, sizeof(local_addr));
534 local_addr_len = ADDR_SIZE(family);
535 ret = zsock_getsockname(sock_c, &local_addr, &local_addr_len);
536 zassert_equal(ret, 0, "getsockname failed");
537 zassert_equal(local_addr.sa_family, family, "wrong family");
538 /* Can't verify address/port of client socket here reliably as they're
539 * chosen by net stack
540 */
541
542 ret = zsock_close(sock_c);
543 zassert_equal(ret, 0, "close failed, %d", errno);
544 ret = zsock_close(sock_s);
545 zassert_equal(ret, 0, "close failed, %d", errno);
546
547 k_sleep(K_MSEC(CONFIG_NET_TCP_TIME_WAIT_DELAY));
548 }
549
test_getsockname_udp(int family)550 void test_getsockname_udp(int family)
551 {
552 int ret;
553 int sock_c;
554 int sock_s;
555 struct sockaddr local_addr = { 0 };
556 socklen_t local_addr_len = ADDR_SIZE(family);
557 struct sockaddr srv_addr = { 0 };
558
559 srv_addr.sa_family = family;
560 if (family == AF_INET) {
561 net_sin(&srv_addr)->sin_port = htons(DST_PORT);
562 ret = zsock_inet_pton(AF_INET, TEST_MY_IPV4_ADDR,
563 &net_sin(&srv_addr)->sin_addr);
564 } else {
565 net_sin6(&srv_addr)->sin6_port = htons(DST_PORT);
566 ret = zsock_inet_pton(AF_INET6, TEST_MY_IPV6_ADDR,
567 &net_sin6(&srv_addr)->sin6_addr);
568 }
569 zassert_equal(ret, 1, "inet_pton failed");
570
571 sock_c = zsock_socket(family, SOCK_DGRAM, IPPROTO_UDP);
572 zassert_true(sock_c >= 0, "socket open failed");
573 sock_s = zsock_socket(family, SOCK_DGRAM, IPPROTO_UDP);
574 zassert_true(sock_s >= 0, "socket open failed");
575
576 /* Verify that unbound/unconnected socket has no local address set */
577 ret = zsock_getsockname(sock_c, &local_addr, &local_addr_len);
578 zassert_equal(ret, -1, "getsockname shouldn've failed");
579 zassert_equal(errno, EINVAL, "getsockname returned invalid error");
580 ret = zsock_getsockname(sock_s, &local_addr, &local_addr_len);
581 zassert_equal(ret, -1, "getsockname shouldn've failed");
582 zassert_equal(errno, EINVAL, "getsockname returned invalid error");
583
584 /* Verify that getsockname() can read local address of a bound socket */
585 ret = zsock_bind(sock_s, &srv_addr, ADDR_SIZE(family));
586 zassert_equal(ret, 0, "bind failed, %d", errno);
587
588 memset(&local_addr, 0, sizeof(local_addr));
589 local_addr_len = ADDR_SIZE(family);
590 ret = zsock_getsockname(sock_s, &local_addr, &local_addr_len);
591 zassert_equal(ret, 0, "getsockname failed");
592 zassert_mem_equal(&local_addr, &srv_addr, ADDR_SIZE(family),
593 "obtained wrong address");
594
595 /* Verify that getsockname() can read local address of a connected socket */
596 ret = zsock_connect(sock_c, &srv_addr, ADDR_SIZE(family));
597 zassert_equal(ret, 0, "connect failed");
598
599 memset(&local_addr, 0, sizeof(local_addr));
600 local_addr_len = ADDR_SIZE(family);
601 ret = zsock_getsockname(sock_c, &local_addr, &local_addr_len);
602 zassert_equal(ret, 0, "getsockname failed");
603 zassert_equal(local_addr.sa_family, family, "wrong family");
604 /* Can't verify address/port of client socket here reliably as they're
605 * chosen by net stack
606 */
607
608 ret = zsock_close(sock_c);
609 zassert_equal(ret, 0, "close failed, %d", errno);
610 ret = zsock_close(sock_s);
611 zassert_equal(ret, 0, "close failed, %d", errno);
612 }
613
614 #define MAPPING_PORT 4244
615
test_ipv4_mapped_to_ipv6_disabled(void)616 void test_ipv4_mapped_to_ipv6_disabled(void)
617 {
618 int ret;
619 int sock_s4, sock_s6;
620 struct sockaddr srv_addr4 = { 0 };
621 struct sockaddr srv_addr6 = { 0 };
622
623 if (IS_ENABLED(CONFIG_NET_IPV4_MAPPING_TO_IPV6)) {
624 return;
625 }
626
627 srv_addr4.sa_family = AF_INET;
628 net_sin(&srv_addr4)->sin_port = htons(MAPPING_PORT);
629 ret = zsock_inet_pton(AF_INET, TEST_MY_IPV4_ADDR,
630 &net_sin(&srv_addr4)->sin_addr);
631 zassert_equal(ret, 1, "inet_pton failed");
632
633 srv_addr6.sa_family = AF_INET6;
634 net_sin6(&srv_addr6)->sin6_port = htons(MAPPING_PORT);
635 ret = zsock_inet_pton(AF_INET6, TEST_MY_IPV6_ADDR,
636 &net_sin6(&srv_addr6)->sin6_addr);
637 zassert_equal(ret, 1, "inet_pton failed");
638
639 sock_s4 = zsock_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
640 zassert_true(sock_s4 >= 0, "socket open failed");
641
642 ret = zsock_bind(sock_s4, &srv_addr4, ADDR_SIZE(AF_INET));
643 zassert_equal(ret, 0, "bind failed, %d", errno);
644
645 ret = zsock_listen(sock_s4, 1);
646 zassert_equal(ret, 0, "listen failed, %d", errno);
647
648 sock_s6 = zsock_socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
649 zassert_true(sock_s6 >= 0, "socket open failed");
650
651 ret = zsock_bind(sock_s6, &srv_addr6, ADDR_SIZE(AF_INET6));
652 zassert_equal(ret, 0, "bind failed, %d", errno);
653
654 ret = zsock_close(sock_s4);
655 zassert_equal(ret, 0, "close failed, %d", errno);
656 ret = zsock_close(sock_s6);
657 zassert_equal(ret, 0, "close failed, %d", errno);
658 }
659
test_ipv4_mapped_to_ipv6_enabled(void)660 void test_ipv4_mapped_to_ipv6_enabled(void)
661 {
662 socklen_t optlen = sizeof(int);
663 int off = 0;
664 int ret;
665 int sock_s4, sock_s6;
666 struct sockaddr srv_addr4 = { 0 };
667 struct sockaddr srv_addr6 = { 0 };
668
669 if (!IS_ENABLED(CONFIG_NET_IPV4_MAPPING_TO_IPV6)) {
670 return;
671 }
672
673 /* We must have bound to ANY address so that the
674 * v4-mapping-to-v6 works as expected.
675 */
676 srv_addr4.sa_family = AF_INET;
677 net_sin(&srv_addr4)->sin_port = htons(MAPPING_PORT);
678 ret = zsock_inet_pton(AF_INET, "0.0.0.0",
679 &net_sin(&srv_addr4)->sin_addr);
680 zassert_equal(ret, 1, "inet_pton failed");
681
682 srv_addr6.sa_family = AF_INET6;
683 net_sin6(&srv_addr6)->sin6_port = htons(MAPPING_PORT);
684 ret = zsock_inet_pton(AF_INET6, "::",
685 &net_sin6(&srv_addr6)->sin6_addr);
686 zassert_equal(ret, 1, "inet_pton failed");
687
688 /* First create IPv6 socket */
689 sock_s6 = zsock_socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
690 zassert_true(sock_s6 >= 0, "socket open failed");
691
692 ret = zsock_bind(sock_s6, &srv_addr6, ADDR_SIZE(AF_INET6));
693 zassert_equal(ret, 0, "bind failed, %d", errno);
694
695 ret = zsock_listen(sock_s6, 1);
696 zassert_equal(ret, 0, "listen failed, %d", errno);
697
698 /* Then try to create IPv4 socket to the same port */
699 sock_s4 = zsock_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
700 zassert_true(sock_s4 >= 0, "socket open failed");
701
702 /* Initially the IPV6_V6ONLY is set so the next bind is ok */
703 ret = zsock_bind(sock_s4, &srv_addr4, ADDR_SIZE(AF_INET));
704 zassert_equal(ret, 0, "bind failed, %d", errno);
705
706 ret = zsock_close(sock_s4);
707 zassert_equal(ret, 0, "close failed, %d", errno);
708
709 /* Then we turn off IPV6_V6ONLY which means that IPv4 and IPv6
710 * will have same port space and the next bind should fail.
711 */
712 ret = zsock_setsockopt(sock_s6, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
713 zassert_equal(ret, 0, "setsockopt failed, %d", errno);
714
715 ret = zsock_getsockopt(sock_s6, IPPROTO_IPV6, IPV6_V6ONLY, &off, &optlen);
716 zassert_equal(ret, 0, "getsockopt failed, %d", errno);
717 zassert_equal(off, 0, "IPV6_V6ONLY option setting failed");
718
719 sock_s4 = zsock_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
720 zassert_true(sock_s4 >= 0, "socket open failed");
721
722 /* Now v4 bind should fail */
723 ret = zsock_bind(sock_s4, &srv_addr4, ADDR_SIZE(AF_INET));
724 zassert_equal(ret, -1, "bind failed, %d", errno);
725 zassert_equal(errno, EADDRINUSE, "bind failed");
726
727 ret = zsock_close(sock_s4);
728 zassert_equal(ret, 0, "close failed, %d", errno);
729 ret = zsock_close(sock_s6);
730 zassert_equal(ret, 0, "close failed, %d", errno);
731 }
732
test_ipv4_mapped_to_ipv6_server(void)733 void test_ipv4_mapped_to_ipv6_server(void)
734 {
735 socklen_t optlen = sizeof(int);
736 int off;
737 int ret, len;
738 int sock_c4, sock_c6, sock_s6, new_sock;
739 struct sockaddr srv_addr6 = { 0 };
740 struct sockaddr srv_addr = { 0 };
741 struct sockaddr connect_addr6 = { 0 };
742 struct sockaddr addr = { 0 };
743 socklen_t addrlen = sizeof(addr);
744 struct sockaddr_in6 mapped;
745
746 #define MAX_BUF_SIZE 16
747 char buf[MAX_BUF_SIZE];
748
749 if (!IS_ENABLED(CONFIG_NET_IPV4_MAPPING_TO_IPV6)) {
750 return;
751 }
752
753 len = strlen("foobar");
754
755 /* Create a server socket and try to connect IPv4
756 * socket to it. If v4-mapping-to-v6 is enabled,
757 * this will work and we should be bound internally
758 * to ::ffff:a.b.c.d IPv6 address.
759 */
760 srv_addr.sa_family = AF_INET;
761 net_sin(&srv_addr)->sin_port = htons(MAPPING_PORT);
762 ret = zsock_inet_pton(AF_INET, "192.0.1.1",
763 &net_sin(&srv_addr)->sin_addr);
764 zassert_equal(ret, 1, "inet_pton failed");
765
766 connect_addr6.sa_family = AF_INET6;
767 net_sin6(&connect_addr6)->sin6_port = htons(MAPPING_PORT);
768 ret = zsock_inet_pton(AF_INET6, TEST_PEER_IPV6_ADDR,
769 &net_sin6(&connect_addr6)->sin6_addr);
770 zassert_equal(ret, 1, "inet_pton failed");
771
772 net_ipv6_addr_create_v4_mapped(&net_sin(&srv_addr)->sin_addr,
773 &mapped.sin6_addr);
774
775 /* We must have bound to ANY address so that the
776 * v4-mapping-to-v6 works as expected.
777 */
778 srv_addr6.sa_family = AF_INET6;
779 net_sin6(&srv_addr6)->sin6_port = htons(MAPPING_PORT);
780 ret = zsock_inet_pton(AF_INET6, "::",
781 &net_sin6(&srv_addr6)->sin6_addr);
782 zassert_equal(ret, 1, "inet_pton failed");
783
784 /* First create IPv6 socket */
785 sock_s6 = zsock_socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
786 zassert_true(sock_s6 >= 0, "socket open failed");
787
788 /* Verify that by default the IPV6_V6ONLY option is set */
789 ret = zsock_getsockopt(sock_s6, IPPROTO_IPV6, IPV6_V6ONLY, &off, &optlen);
790 zassert_equal(ret, 0, "getsockopt failed, %d", errno);
791 zassert_not_equal(off, 0, "IPV6_V6ONLY option setting failed");
792
793 /* Then we turn off IPV6_V6ONLY which means that IPv4 and IPv6
794 * will have same port space.
795 */
796 off = 0;
797 ret = zsock_setsockopt(sock_s6, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off));
798 zassert_equal(ret, 0, "setsockopt failed, %d", errno);
799
800 ret = zsock_getsockopt(sock_s6, IPPROTO_IPV6, IPV6_V6ONLY, &off, &optlen);
801 zassert_equal(ret, 0, "getsockopt failed, %d", errno);
802 zassert_equal(off, 0, "IPV6_V6ONLY option setting failed, %d", off);
803
804 ret = zsock_bind(sock_s6, &srv_addr6, ADDR_SIZE(AF_INET6));
805 zassert_equal(ret, 0, "bind failed, %d", errno);
806
807 ret = zsock_listen(sock_s6, 1);
808 zassert_equal(ret, 0, "listen failed, %d", errno);
809
810 /* Then create IPv4 socket and connect to the IPv6 port */
811 sock_c4 = zsock_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
812 zassert_true(sock_c4 >= 0, "socket open failed");
813
814 ret = zsock_connect(sock_c4, &srv_addr, ADDR_SIZE(AF_INET));
815 zassert_equal(ret, 0, "connect failed");
816
817 new_sock = zsock_accept(sock_s6, &addr, &addrlen);
818 zassert_true(new_sock >= 0, "accept failed, %d", errno);
819
820 /* Note that we should get IPv6 address here (mapped from IPv4) */
821 zassert_equal(addr.sa_family, AF_INET6, "wrong family");
822 zassert_equal(addrlen, sizeof(struct sockaddr_in6),
823 "wrong addrlen (%d, expecting %d)", addrlen,
824 sizeof(struct sockaddr_in6));
825 zassert_mem_equal(&mapped.sin6_addr, &net_sin6(&addr)->sin6_addr,
826 sizeof(struct in6_addr),
827 "wrong address (%s, expecting %s)",
828 net_sprint_ipv6_addr(&mapped.sin6_addr),
829 net_sprint_ipv6_addr(&net_sin6(&addr)->sin6_addr));
830
831 /* Send data back to IPv4 client from IPv6 socket */
832 ret = zsock_send(new_sock, "foobar", len, 0);
833 zassert_equal(ret, len, "cannot send (%d vs %d), errno %d", ret, len, errno);
834
835 addrlen = sizeof(struct sockaddr_in);
836 ret = zsock_recv(sock_c4, buf, sizeof(buf), 0);
837 zassert_equal(ret, strlen("foobar"), "cannot recv");
838
839 ret = zsock_close(sock_c4);
840 zassert_equal(ret, 0, "close failed, %d", errno);
841
842 (void)zsock_close(new_sock);
843
844 /* Let the system stabilize and cleanup itself */
845 k_sleep(K_MSEC(200));
846
847 /* Then create IPv6 socket and make sure it works ok too */
848 sock_c6 = zsock_socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
849 zassert_true(sock_c6 >= 0, "socket open failed");
850
851 ret = zsock_connect(sock_c6, &connect_addr6, ADDR_SIZE(AF_INET6));
852 zassert_equal(ret, 0, "connect failed, %d", errno);
853
854 new_sock = zsock_accept(sock_s6, &addr, &addrlen);
855 zassert_true(new_sock >= 0, "accept failed, %d", errno);
856
857 ret = zsock_send(new_sock, "foobar", len, 0);
858 zassert_equal(ret, len, "cannot send (%d vs %d), errno %d", ret, len, errno);
859
860 addrlen = sizeof(struct sockaddr_in);
861 ret = zsock_recv(sock_c6, buf, sizeof(buf), 0);
862 zassert_equal(ret, strlen("foobar"), "cannot recv");
863
864 ret = zsock_close(sock_c6);
865 zassert_equal(ret, 0, "close failed, %d", errno);
866
867 ret = zsock_close(sock_s6);
868 zassert_equal(ret, 0, "close failed, %d", errno);
869 ret = zsock_close(new_sock);
870 zassert_equal(ret, 0, "close failed, %d", errno);
871 }
872
ZTEST_USER(socket_misc_test_suite,test_ipv4_getsockname_tcp)873 ZTEST_USER(socket_misc_test_suite, test_ipv4_getsockname_tcp)
874 {
875 test_getsockname_tcp(AF_INET);
876 }
877
ZTEST_USER(socket_misc_test_suite,test_ipv4_getsockname_udp)878 ZTEST_USER(socket_misc_test_suite, test_ipv4_getsockname_udp)
879 {
880 test_getsockname_udp(AF_INET);
881 }
882
ZTEST_USER(socket_misc_test_suite,test_ipv6_getsockname_tcp)883 ZTEST_USER(socket_misc_test_suite, test_ipv6_getsockname_tcp)
884 {
885 test_getsockname_tcp(AF_INET6);
886 }
887
ZTEST_USER(socket_misc_test_suite,test_ipv6_getsockname_udp)888 ZTEST_USER(socket_misc_test_suite, test_ipv6_getsockname_udp)
889 {
890 test_getsockname_udp(AF_INET6);
891 }
892
setup(void)893 static void *setup(void)
894 {
895 k_thread_system_pool_assign(k_current_get());
896 return NULL;
897 }
898
ZTEST_USER(socket_misc_test_suite,test_ipv4)899 ZTEST_USER(socket_misc_test_suite, test_ipv4)
900 {
901 test_ipv4_so_bindtodevice();
902 test_ipv4_getpeername();
903 }
904
ZTEST_USER(socket_misc_test_suite,test_ipv6)905 ZTEST_USER(socket_misc_test_suite, test_ipv6)
906 {
907 test_ipv6_so_bindtodevice();
908 test_ipv6_getpeername();
909 }
910
ZTEST_USER(socket_misc_test_suite,test_ipv4_mapped_to_ipv6_disabled)911 ZTEST_USER(socket_misc_test_suite, test_ipv4_mapped_to_ipv6_disabled)
912 {
913 test_ipv4_mapped_to_ipv6_disabled();
914 }
915
ZTEST_USER(socket_misc_test_suite,test_ipv4_mapped_to_ipv6_enabled)916 ZTEST_USER(socket_misc_test_suite, test_ipv4_mapped_to_ipv6_enabled)
917 {
918 test_ipv4_mapped_to_ipv6_enabled();
919 }
920
ZTEST(socket_misc_test_suite,test_ipv4_mapped_to_ipv6_server)921 ZTEST(socket_misc_test_suite, test_ipv4_mapped_to_ipv6_server)
922 {
923 test_ipv4_mapped_to_ipv6_server();
924 }
925
ZTEST(socket_misc_test_suite,test_so_domain_socket_option)926 ZTEST(socket_misc_test_suite, test_so_domain_socket_option)
927 {
928 int ret;
929 int sock_u;
930 int sock_t;
931 socklen_t optlen = sizeof(int);
932 int domain;
933
934 sock_t = zsock_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
935 zassert_true(sock_t >= 0, "TCP socket open failed");
936 sock_u = zsock_socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
937 zassert_true(sock_u >= 0, "UDP socket open failed");
938
939 ret = zsock_getsockopt(sock_t, SOL_SOCKET, SO_DOMAIN, &domain, &optlen);
940 zassert_equal(ret, 0, "getsockopt failed, %d", -errno);
941 zassert_equal(domain, AF_INET, "Mismatch domain value %d vs %d",
942 AF_INET, domain);
943
944 ret = zsock_getsockopt(sock_u, SOL_SOCKET, SO_DOMAIN, &domain, &optlen);
945 zassert_equal(ret, 0, "getsockopt failed, %d", -errno);
946 zassert_equal(domain, AF_INET6, "Mismatch domain value %d vs %d",
947 AF_INET6, domain);
948
949 /* setsockopt() is not supported for this option */
950 domain = AF_INET;
951 ret = zsock_setsockopt(sock_u, SOL_SOCKET, SO_DOMAIN, &domain, optlen);
952 zassert_equal(ret, -1, "setsockopt succeed");
953 zassert_equal(errno, ENOPROTOOPT, "Invalid errno %d", errno);
954
955 ret = zsock_close(sock_t);
956 zassert_equal(ret, 0, "close failed, %d", -errno);
957 ret = zsock_close(sock_u);
958 zassert_equal(ret, 0, "close failed, %d", -errno);
959 }
960
961 ZTEST_SUITE(socket_misc_test_suite, NULL, setup, NULL, NULL, NULL);
962
