Zephyr API Documentation 4.5.99
A Scalable Open Source RTOS
Loading...
Searching...
No Matches
net_if.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2016 Intel Corporation.
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
11
12#ifndef ZEPHYR_INCLUDE_NET_NET_IF_H_
13#define ZEPHYR_INCLUDE_NET_NET_IF_H_
14
23
24#include <zephyr/device.h>
25#include <zephyr/sys/slist.h>
27#include <zephyr/net/net_core.h>
28#include <zephyr/net/hostname.h>
30#include <zephyr/net/net_ip.h>
31#include <zephyr/net/net_l2.h>
34
35#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
36#include <zephyr/net/dhcpv4.h>
37#endif
38#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
39#include <zephyr/net/dhcpv6.h>
40#endif
41#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
43#endif
44
46
47#ifdef __cplusplus
48extern "C" {
49#endif
50
52#define NET_IF_IPV6_DAD_NONCE_LEN 6U
53
61 struct net_addr address;
62
67
68#if defined(CONFIG_NET_NATIVE_IPV6)
69 struct net_timeout lifetime;
70#endif
71
74
77
78#if defined(CONFIG_NET_NATIVE_IPV6)
79#if defined(CONFIG_NET_IPV6_PE)
83 uint32_t addr_create_time;
84
87 uint32_t addr_preferred_lifetime;
88
93 int32_t addr_timeout;
94#endif
95#endif /* CONFIG_NET_NATIVE_IPV6 */
96
97 union {
98#if defined(CONFIG_NET_IPV6_DAD)
99 struct {
101 sys_snode_t dad_node;
102
104 sys_snode_t dad_need_node;
105
107 uint32_t dad_start;
108
110 uint8_t dad_count;
111
117 uint8_t dad_tx_failures;
118
121 };
122#endif /* CONFIG_NET_IPV6_DAD */
123#if defined(CONFIG_NET_IPV4_ACD)
124 struct {
126 sys_snode_t acd_node;
127
129 sys_snode_t acd_need_node;
130
132 k_timepoint_t acd_timeout;
133
135 uint8_t acd_count;
136
138 uint8_t acd_state;
139 };
140#endif /* CONFIG_NET_IPV4_ACD */
141 uint8_t _dummy;
142 };
143
144#if defined(CONFIG_NET_IPV6_DAD) || defined(CONFIG_NET_IPV4_ACD)
146 uint8_t ifindex;
147#endif
148
151
154
157
162
165
166 uint8_t _unused : 3;
167};
168
176 struct net_addr address;
177
182
185
186#if defined(CONFIG_NET_IPV4_IGMP)
190 k_timepoint_t igmp_resp_timeout;
191
195 k_timepoint_t igmp_retx_timeout;
196
200 uint8_t igmp_retx_left;
201#endif
202
203#if defined(CONFIG_NET_IPV6_MLD)
207 k_timepoint_t mld_resp_timeout;
208
212 k_timepoint_t mld_retx_timeout;
213
217 uint8_t mld_retx_left;
218#endif
219
220#if defined(CONFIG_NET_IPV4_IGMPV3)
222 struct net_addr sources[CONFIG_NET_IF_MCAST_IPV4_SOURCE_COUNT];
223
225 uint16_t sources_len;
226
228 uint8_t record_type;
229#endif
230
233
236
237 uint8_t _unused : 6;
238};
239
248
251
253 struct net_if *iface;
254
257
260
263
266
267 uint8_t _unused : 5;
268};
269
278
280 struct net_addr address;
281
283 struct net_if *iface;
284
287
290
293
296
299
300 uint8_t _unused : 5;
301};
302
358
369
370#if defined(CONFIG_NET_OFFLOAD)
371struct net_offload;
372#endif /* CONFIG_NET_OFFLOAD */
373
375#if defined(CONFIG_NET_IPV6)
376#define NET_IF_MAX_IPV6_ADDR CONFIG_NET_IF_UNICAST_IPV6_ADDR_COUNT
377#define NET_IF_MAX_IPV6_MADDR CONFIG_NET_IF_MCAST_IPV6_ADDR_COUNT
378#define NET_IF_MAX_IPV6_PREFIX CONFIG_NET_IF_IPV6_PREFIX_COUNT
379#else
380#define NET_IF_MAX_IPV6_ADDR 0
381#define NET_IF_MAX_IPV6_MADDR 0
382#define NET_IF_MAX_IPV6_PREFIX 0
383#endif
384/* @endcond */
385
389 struct net_if_addr unicast[NET_IF_MAX_IPV6_ADDR];
390
392 struct net_if_mcast_addr mcast[NET_IF_MAX_IPV6_MADDR];
393
395 struct net_if_ipv6_prefix prefix[NET_IF_MAX_IPV6_PREFIX];
396
399
402
405
406#if defined(CONFIG_NET_IPV6_IID_STABLE)
408 struct net_if_addr *iid;
409
413 uint32_t network_counter;
414#endif /* CONFIG_NET_IPV6_IID_STABLE */
415
416#if defined(CONFIG_NET_IPV6_PE)
421 uint32_t desync_factor;
422#endif /* CONFIG_NET_IPV6_PE */
423
424#if defined(CONFIG_NET_IPV6_MLD)
428 k_timepoint_t mld_general_timeout;
429
433 k_timepoint_t mld_v1_querier_timeout;
434
438 uint8_t mld_version;
439#endif
440
441#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
443 sys_snode_t rs_node;
444
445 /* RS start time */
446 uint32_t rs_start;
447
449 uint8_t rs_count;
450#endif
451
454
457
458#if defined(CONFIG_NET_IPV6_ND_RA_TX) && defined(CONFIG_NET_NATIVE_IPV6)
462 int64_t ra_last_sent;
463
467 int64_t ra_pending_at;
468
472 uint8_t is_router : 1;
473#endif
474};
475
476#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
478struct net_if_dhcpv6 {
480 sys_snode_t node;
481
483 struct net_dhcpv6_duid_storage clientid;
484
486 struct net_dhcpv6_duid_storage serverid;
487
489 enum net_dhcpv6_state state;
490
492 struct net_dhcpv6_params params;
493
495 uint64_t timeout;
496
498 uint64_t exchange_start;
499
501 uint64_t t1;
502
504 uint64_t t2;
505
509 uint64_t expire;
510
512 uint32_t addr_iaid;
513
515 uint32_t prefix_iaid;
516
518 uint32_t retransmit_timeout;
519
521 uint32_t sol_max_rt;
522
524 uint32_t inf_max_rt;
525
529 uint32_t info_refresh_time;
530
532 int16_t server_preference;
533
535 uint8_t retransmissions;
536
538 bool rebind_on_link_change : 1;
539
541 bool auto_started : 1;
542
544 bool auto_start_disabled : 1;
545
547 bool ra_managed : 1;
548
550 bool ra_other : 1;
551
553 uint8_t tid[DHCPV6_TID_SIZE];
554
556 uint8_t prefix_len;
557
559 struct net_in6_addr prefix;
560
562 struct net_in6_addr addr;
563};
564#endif /* defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6) */
565
567#if defined(CONFIG_NET_IPV4)
568#define NET_IF_MAX_IPV4_ADDR CONFIG_NET_IF_UNICAST_IPV4_ADDR_COUNT
569#define NET_IF_MAX_IPV4_MADDR CONFIG_NET_IF_MCAST_IPV4_ADDR_COUNT
570#else
571#define NET_IF_MAX_IPV4_ADDR 0
572#define NET_IF_MAX_IPV4_MADDR 0
573#endif
575
587
591 struct net_if_addr_ipv4 unicast[NET_IF_MAX_IPV4_ADDR];
592
594 struct net_if_mcast_addr mcast[NET_IF_MAX_IPV4_MADDR];
595
598
601
604
605#if defined(CONFIG_NET_IPV4_IGMP)
609 k_timepoint_t igmp_general_timeout;
610
614 k_timepoint_t igmp_v1_querier_timeout;
615
619 k_timepoint_t igmp_v2_querier_timeout;
620
625 uint8_t igmp_version;
626#endif
627
628#if defined(CONFIG_NET_IPV4_ACD)
630 uint8_t conflict_cnt;
631#endif
632};
633
634#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
635struct net_if_dhcpv4 {
637 sys_snode_t node;
638
640 int64_t timer_start;
641
643 uint32_t request_time;
644
645 uint32_t xid;
646
648 uint32_t lease_time;
649
651 uint32_t renewal_time;
652
654 uint32_t rebinding_time;
655
657 struct net_in_addr server_id;
658
660 struct net_in_addr requested_ip;
661
663 struct net_in_addr netmask;
664
669 enum net_dhcpv4_state state;
670
672 uint8_t attempts;
673
675 uint8_t pending_events;
676
678 struct net_in_addr gw;
679
681 struct net_in_addr gw_before;
682
684 struct net_in_addr request_server_addr;
685
687 struct net_in_addr response_src_addr;
688
689#ifdef CONFIG_NET_DHCPV4_OPTION_NTP_SERVER
691 struct net_in_addr ntp_addr;
692#endif
693};
694#endif /* CONFIG_NET_DHCPV4 */
695
696#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
697struct net_if_ipv4_autoconf {
699 struct net_if *iface;
700
702 struct net_in_addr requested_ip;
703
707};
708#endif /* CONFIG_NET_IPV4_AUTO */
709
713struct net_if_ip {
714#if defined(CONFIG_NET_IPV6)
715 struct net_if_ipv6 *ipv6;
716#endif /* CONFIG_NET_IPV6 */
717
718#if defined(CONFIG_NET_IPV4)
719 struct net_if_ipv4 *ipv4;
720#endif /* CONFIG_NET_IPV4 */
721};
722
727#if defined(CONFIG_NET_IP)
729 struct net_if_ip ip;
730#endif
731
732#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
733 struct net_if_dhcpv4 dhcpv4;
734#endif /* CONFIG_NET_DHCPV4 */
735
736#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
737 struct net_if_dhcpv6 dhcpv6;
738#endif /* CONFIG_NET_DHCPV6 */
739
740#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
741 struct net_if_ipv4_autoconf ipv4auto;
742#endif /* CONFIG_NET_IPV4_AUTO */
743
744#if defined(CONFIG_NET_L2_VIRTUAL)
749 sys_slist_t virtual_interfaces;
750#endif /* CONFIG_NET_L2_VIRTUAL */
751
752#if defined(CONFIG_NET_INTERFACE_NAME)
757 char name[CONFIG_NET_INTERFACE_NAME_LEN + 1];
758#endif
759};
760
772 struct k_fifo fifo;
773
774#if NET_TC_COUNT > 1 || defined(CONFIG_NET_TC_TX_SKIP_FOR_HIGH_PRIO) \
775 || defined(CONFIG_NET_TC_RX_SKIP_FOR_HIGH_PRIO)
777 struct k_sem fifo_slot;
778#endif
779
782
785};
786
793typedef int (*net_socket_create_t)(int, int, int);
794
816 const struct device *dev;
817
819 const struct net_l2 * const l2;
820
822 void *l2_data;
823
825 ATOMIC_DEFINE(flags, NET_IF_NUM_FLAGS);
826
828 struct net_linkaddr link_addr;
829
830#if defined(CONFIG_NET_OFFLOAD)
836 struct net_offload *offload;
837#endif /* CONFIG_NET_OFFLOAD */
838
840 uint16_t mtu;
841
842#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
846 net_socket_create_t socket_offload;
847#endif /* CONFIG_NET_SOCKETS_OFFLOAD */
848
850 enum net_if_oper_state oper_state;
851
861 int64_t oper_state_change_time;
865};
866
875struct net_if {
880 struct net_if_dev *if_dev;
881
882#if defined(CONFIG_NET_STATISTICS_PER_INTERFACE)
884 struct net_stats stats;
885
887 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS,
888 (struct prometheus_collector *collector);)
889#endif /* CONFIG_NET_STATISTICS_PER_INTERFACE */
890
892 struct net_if_config config;
893
894#if defined(CONFIG_NET_POWER_MANAGEMENT)
899 int tx_pending;
900#endif
901
903 struct k_mutex lock;
904
906 struct k_mutex tx_lock;
907
912 uint8_t pe_enabled : 1;
913
917 uint8_t pe_prefer_public : 1;
918
920 uint8_t _unused : 6;
924};
925
927
928static inline void net_if_lock(struct net_if *iface)
929{
930 NET_ASSERT(iface);
931
932 (void)k_mutex_lock(&iface->lock, K_FOREVER);
933}
934
935static inline void net_if_unlock(struct net_if *iface)
936{
937 NET_ASSERT(iface);
938
939 k_mutex_unlock(&iface->lock);
940}
941
942static inline bool net_if_flag_is_set(struct net_if *iface,
943 enum net_if_flag value);
944
945static inline void net_if_tx_lock(struct net_if *iface)
946{
947 NET_ASSERT(iface);
948
950 return;
951 }
952
953 (void)k_mutex_lock(&iface->tx_lock, K_FOREVER);
954}
955
956static inline void net_if_tx_unlock(struct net_if *iface)
957{
958 NET_ASSERT(iface);
959
961 return;
962 }
963
964 k_mutex_unlock(&iface->tx_lock);
965}
966
968
975static inline void net_if_flag_set(struct net_if *iface,
976 enum net_if_flag value)
977{
978 if (iface == NULL) {
979 return;
980 }
981
982 atomic_set_bit(iface->if_dev->flags, value);
983}
984
993static inline bool net_if_flag_test_and_set(struct net_if *iface,
994 enum net_if_flag value)
995{
996 if (iface == NULL) {
997 return false;
998 }
999
1000 return atomic_test_and_set_bit(iface->if_dev->flags, value);
1001}
1002
1009static inline void net_if_flag_clear(struct net_if *iface,
1010 enum net_if_flag value)
1011{
1012 if (iface == NULL) {
1013 return;
1014 }
1015
1016 atomic_clear_bit(iface->if_dev->flags, value);
1017}
1018
1027static inline bool net_if_flag_test_and_clear(struct net_if *iface,
1028 enum net_if_flag value)
1029{
1030 if (iface == NULL) {
1031 return false;
1032 }
1033
1034 return atomic_test_and_clear_bit(iface->if_dev->flags, value);
1035}
1036
1045static inline bool net_if_flag_is_set(struct net_if *iface,
1046 enum net_if_flag value)
1047{
1048 if (iface == NULL) {
1049 return false;
1050 }
1051
1052 return atomic_test_bit(iface->if_dev->flags, value);
1053}
1054
1064 struct net_if *iface, enum net_if_oper_state oper_state)
1065{
1066 if (iface == NULL) {
1067 return NET_IF_OPER_UNKNOWN;
1068 }
1069
1070 if (oper_state <= NET_IF_OPER_UP) {
1071 iface->if_dev->oper_state = oper_state;
1072 }
1073
1074 net_if_lock(iface);
1075
1076 iface->if_dev->oper_state_change_time = k_uptime_get();
1077
1078 net_if_unlock(iface);
1079
1080 return iface->if_dev->oper_state;
1081}
1082
1090static inline enum net_if_oper_state net_if_oper_state(struct net_if *iface)
1091{
1092 if (iface == NULL) {
1093 return NET_IF_OPER_UNKNOWN;
1094 }
1095
1096 return iface->if_dev->oper_state;
1097}
1098
1111static inline int net_if_oper_state_change_time(struct net_if *iface,
1112 int64_t *change_time)
1113{
1114 if (iface == NULL || change_time == NULL) {
1115 return -EINVAL;
1116 }
1117
1118 net_if_lock(iface);
1119
1120 *change_time = iface->if_dev->oper_state_change_time;
1121
1122 net_if_unlock(iface);
1123
1124 return 0;
1125}
1126
1137 struct net_pkt *pkt, k_timeout_t timeout);
1138
1148static inline enum net_verdict net_if_send_data(struct net_if *iface,
1149 struct net_pkt *pkt)
1150{
1152
1153 return net_if_try_send_data(iface, pkt, timeout);
1154}
1155
1163static inline const struct net_l2 *net_if_l2(struct net_if *iface)
1164{
1165 if (iface == NULL) {
1166 return NULL;
1167 }
1168
1169 return iface->if_dev->l2;
1170}
1171
1180enum net_verdict net_if_recv_data(struct net_if *iface, struct net_pkt *pkt);
1181
1189static inline void *net_if_l2_data(struct net_if *iface)
1190{
1191 if (iface == NULL) {
1192 return NULL;
1193 }
1194
1195 return iface->if_dev->l2_data;
1196}
1197
1205static inline const struct device *net_if_get_device(struct net_if *iface)
1206{
1207 if (iface == NULL) {
1208 return NULL;
1209 }
1210
1211 return iface->if_dev->dev;
1212}
1213
1221void net_if_try_queue_tx(struct net_if *iface, struct net_pkt *pkt, k_timeout_t timeout);
1222
1230static inline void net_if_queue_tx(struct net_if *iface, struct net_pkt *pkt)
1231{
1233
1234 net_if_try_queue_tx(iface, pkt, timeout);
1235}
1236
1244static inline bool net_if_is_ip_offloaded(struct net_if *iface)
1245{
1246#if defined(CONFIG_NET_OFFLOAD)
1247 return (iface != NULL && iface->if_dev->offload != NULL);
1248#else
1249 ARG_UNUSED(iface);
1250
1251 return false;
1252#endif
1253}
1254
1262bool net_if_is_offloaded(struct net_if *iface);
1263
1271static inline struct net_offload *net_if_offload(struct net_if *iface)
1272{
1273#if defined(CONFIG_NET_OFFLOAD)
1274 if (iface == NULL) {
1275 return NULL;
1276 }
1277
1278 return iface->if_dev->offload;
1279#else
1280 ARG_UNUSED(iface);
1281
1282 return NULL;
1283#endif
1284}
1285
1292static inline void net_if_offload_set(struct net_if *iface, struct net_offload *offload)
1293{
1294#if defined(CONFIG_NET_OFFLOAD)
1295 if (iface == NULL) {
1296 return;
1297 }
1298
1299 iface->if_dev->offload = offload;
1300#else
1301 ARG_UNUSED(iface);
1302 ARG_UNUSED(offload);
1303#endif
1304}
1305
1313static inline bool net_if_is_socket_offloaded(struct net_if *iface)
1314{
1315#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
1316 if (iface == NULL) {
1317 return false;
1318 }
1319
1320 return (iface->if_dev->socket_offload != NULL);
1321#else
1322 ARG_UNUSED(iface);
1323
1324 return false;
1325#endif
1326}
1327
1334static inline void net_if_socket_offload_set(
1335 struct net_if *iface, net_socket_create_t socket_offload)
1336{
1337#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
1338 if (iface == NULL) {
1339 return;
1340 }
1341
1342 iface->if_dev->socket_offload = socket_offload;
1343#else
1344 ARG_UNUSED(iface);
1345 ARG_UNUSED(socket_offload);
1346#endif
1347}
1348
1357{
1358#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
1359 if (iface == NULL) {
1360 return NULL;
1361 }
1362
1363 return iface->if_dev->socket_offload;
1364#else
1365 ARG_UNUSED(iface);
1366
1367 return NULL;
1368#endif
1369}
1370
1378static inline struct net_linkaddr *net_if_get_link_addr(struct net_if *iface)
1379{
1380 if (iface == NULL) {
1381 return NULL;
1382 }
1383
1384 return &iface->if_dev->link_addr;
1385}
1386
1394static inline struct net_if_config *net_if_get_config(struct net_if *iface)
1395{
1396 if (iface == NULL) {
1397 return NULL;
1398 }
1399
1400 return &iface->config;
1401}
1402
1408#if defined(CONFIG_NET_IPV6_DAD) && defined(CONFIG_NET_NATIVE_IPV6)
1409void net_if_start_dad(struct net_if *iface);
1410#else
1411static inline void net_if_start_dad(struct net_if *iface)
1412{
1413 ARG_UNUSED(iface);
1414}
1415#endif
1416
1422void net_if_start_rs(struct net_if *iface);
1423
1424
1430#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
1431void net_if_stop_rs(struct net_if *iface);
1432#else
1433static inline void net_if_stop_rs(struct net_if *iface)
1434{
1435 ARG_UNUSED(iface);
1436}
1437#endif /* CONFIG_NET_IPV6_ND */
1438
1451#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
1452void net_if_nbr_reachability_hint(struct net_if *iface, const struct net_in6_addr *ipv6_addr);
1453#else
1454static inline void net_if_nbr_reachability_hint(struct net_if *iface,
1455 const struct net_in6_addr *ipv6_addr)
1456{
1457 ARG_UNUSED(iface);
1458 ARG_UNUSED(ipv6_addr);
1459}
1460#endif
1461
1472#if defined(CONFIG_NET_IPV6)
1473void net_if_ipv6_nbr_flush(struct net_if *iface);
1474#else
1475static inline void net_if_ipv6_nbr_flush(struct net_if *iface)
1476{
1477 ARG_UNUSED(iface);
1478}
1479#endif
1480
1493#if defined(CONFIG_NET_IPV6)
1494bool net_if_ipv6_nbr_rm(struct net_if *iface, const struct net_in6_addr *addr);
1495#else
1496static inline bool net_if_ipv6_nbr_rm(struct net_if *iface,
1497 const struct net_in6_addr *addr)
1498{
1499 ARG_UNUSED(iface);
1500 ARG_UNUSED(addr);
1501
1502 return false;
1503}
1504#endif
1505
1507
1508static inline int net_if_set_link_addr_unlocked(struct net_if *iface,
1509 const uint8_t *addr, uint8_t len,
1510 enum net_link_type type)
1511{
1512 int ret;
1513
1514 if (net_if_flag_is_set(iface, NET_IF_RUNNING)) {
1515 return -EPERM;
1516 }
1517
1518 if (len > sizeof(net_if_get_link_addr(iface)->addr)) {
1519 return -EINVAL;
1520 }
1521
1522 ret = net_linkaddr_create(net_if_get_link_addr(iface), addr, len, type);
1523 if (ret < 0) {
1524 return ret;
1525 }
1526
1527 net_hostname_set_postfix(addr, len);
1528
1529 return 0;
1530}
1531
1532int net_if_set_link_addr_locked(struct net_if *iface,
1533 const uint8_t *addr, uint8_t len,
1534 enum net_link_type type);
1535
1536#if CONFIG_NET_IF_LOG_LEVEL >= LOG_LEVEL_DBG
1537extern int net_if_addr_unref_debug(struct net_if *iface,
1538 net_sa_family_t family,
1539 const void *addr,
1540 struct net_if_addr **ifaddr,
1541 const char *caller, int line);
1542#define net_if_addr_unref(iface, family, addr, ifaddr) \
1543 net_if_addr_unref_debug(iface, family, addr, ifaddr, __func__, __LINE__)
1544
1545extern struct net_if_addr *net_if_addr_ref_debug(struct net_if *iface,
1546 net_sa_family_t family,
1547 const void *addr,
1548 const char *caller,
1549 int line);
1550#define net_if_addr_ref(iface, family, addr) \
1551 net_if_addr_ref_debug(iface, family, addr, __func__, __LINE__)
1552#else
1553extern int net_if_addr_unref(struct net_if *iface,
1554 net_sa_family_t family,
1555 const void *addr,
1556 struct net_if_addr **ifaddr);
1557extern struct net_if_addr *net_if_addr_ref(struct net_if *iface,
1558 net_sa_family_t family,
1559 const void *addr);
1560#endif /* CONFIG_NET_IF_LOG_LEVEL */
1561
1563
1574static inline int net_if_set_link_addr(struct net_if *iface,
1575 const uint8_t *addr, uint8_t len,
1576 enum net_link_type type)
1577{
1578#if defined(CONFIG_NET_RAW_MODE)
1579 return net_if_set_link_addr_unlocked(iface, addr, len, type);
1580#else
1581 return net_if_set_link_addr_locked(iface, addr, len, type);
1582#endif
1583}
1584
1592static inline uint16_t net_if_get_mtu(struct net_if *iface)
1593{
1594 if (iface == NULL) {
1595 return 0U;
1596 }
1597
1598 return iface->if_dev->mtu;
1599}
1600
1607static inline void net_if_set_mtu(struct net_if *iface,
1608 uint16_t mtu)
1609{
1610 if (iface == NULL) {
1611 return;
1612 }
1613
1614 iface->if_dev->mtu = mtu;
1615}
1616
1623static inline void net_if_addr_set_lf(struct net_if_addr *ifaddr,
1624 bool is_infinite)
1625{
1626 if (ifaddr == NULL) {
1627 return;
1628 }
1629
1630 ifaddr->is_infinite = is_infinite;
1631}
1632
1641
1649struct net_if *net_if_lookup_by_dev(const struct device *dev);
1650
1656void net_if_router_rm(struct net_if_router *router);
1657
1663void net_if_set_default(struct net_if *iface);
1664
1671
1680struct net_if *net_if_get_first_by_type(const struct net_l2 *l2);
1681
1689
1690#if defined(CONFIG_NET_L2_IEEE802154)
1697static inline struct net_if *net_if_get_ieee802154(void)
1698{
1699 return net_if_get_first_by_type(&NET_L2_GET_NAME(IEEE802154));
1700}
1701#endif /* CONFIG_NET_L2_IEEE802154 */
1702
1714 struct net_if_ipv6 **ipv6);
1715
1732
1733
1735struct net_if_addr *net_if_ipv6_addr_lookup_raw(const uint8_t *addr,
1736 struct net_if **ret);
1738
1748 struct net_if **iface);
1749
1751struct net_if_addr *net_if_ipv6_addr_lookup_by_iface_raw(struct net_if *iface,
1752 const uint8_t *addr);
1754
1763#if defined(CONFIG_NET_IPV6)
1765 const struct net_in6_addr *addr);
1766#else
1768 struct net_if *iface, const struct net_in6_addr *addr)
1769{
1770 ARG_UNUSED(iface);
1771 ARG_UNUSED(addr);
1772
1773 return NULL;
1774}
1775#endif
1776
1785__syscall int net_if_ipv6_addr_lookup_by_index(const struct net_in6_addr *addr);
1786
1798 const struct net_in6_addr *addr,
1800 uint32_t vlifetime);
1801
1812__syscall bool net_if_ipv6_addr_add_by_index(int index,
1813 const struct net_in6_addr *addr,
1815 uint32_t vlifetime);
1816
1824 uint32_t vlifetime);
1825
1834bool net_if_ipv6_addr_rm(struct net_if *iface, const struct net_in6_addr *addr);
1835
1844__syscall bool net_if_ipv6_addr_rm_by_index(int index,
1845 const struct net_in6_addr *addr);
1846
1855typedef void (*net_if_ip_addr_cb_t)(struct net_if *iface,
1856 struct net_if_addr *addr,
1857 void *user_data);
1858
1868 void *user_data);
1869
1879 const struct net_in6_addr *addr);
1880
1889bool net_if_ipv6_maddr_rm(struct net_if *iface, const struct net_in6_addr *addr);
1890
1899typedef void (*net_if_ip_maddr_cb_t)(struct net_if *iface,
1900 struct net_if_mcast_addr *maddr,
1901 void *user_data);
1902
1912 void *user_data);
1913
1914
1916struct net_if_mcast_addr *net_if_ipv6_maddr_lookup_raw(const uint8_t *maddr,
1917 struct net_if **ret);
1919
1931 struct net_if **iface);
1932
1943typedef void (*net_if_mcast_callback_t)(struct net_if *iface,
1944 const struct net_addr *addr,
1945 bool is_joined);
1946
1965
1975 struct net_if *iface,
1977
1984
1992void net_if_mcast_monitor(struct net_if *iface, const struct net_addr *addr,
1993 bool is_joined);
1994
2002 struct net_if_mcast_addr *addr);
2003
2011static inline bool net_if_ipv6_maddr_is_joined(struct net_if_mcast_addr *addr)
2012{
2013 if (addr == NULL) {
2014 return false;
2015 }
2016
2017 return addr->is_joined;
2018}
2019
2027 struct net_if_mcast_addr *addr);
2028
2038 const struct net_in6_addr *addr);
2039
2050 const struct net_in6_addr *addr,
2051 uint8_t len);
2052
2064 const struct net_in6_addr *prefix,
2065 uint8_t len,
2067
2077bool net_if_ipv6_prefix_rm(struct net_if *iface, const struct net_in6_addr *addr,
2078 uint8_t len);
2079
2087 bool is_infinite)
2088{
2089 prefix->is_infinite = is_infinite;
2090}
2091
2100
2107
2123 const struct net_in6_addr *prefix,
2124 uint8_t len, bool advertise);
2125
2139
2148
2159bool net_if_ipv6_addr_onlink(struct net_if **iface, const struct net_in6_addr *addr);
2160
2167#if defined(CONFIG_NET_NATIVE_IPV6)
2168static inline struct net_in6_addr *net_if_router_ipv6(struct net_if_router *router)
2169{
2170 if (router == NULL) {
2171 return NULL;
2172 }
2173
2174 return &router->address.in6_addr;
2175}
2176#else
2177static inline struct net_in6_addr *net_if_router_ipv6(struct net_if_router *router)
2178{
2179 static struct net_in6_addr addr;
2180
2181 ARG_UNUSED(router);
2182
2183 return &addr;
2184}
2185#endif
2186
2197 const struct net_in6_addr *addr);
2198
2209 const struct net_in6_addr *addr);
2210
2219
2231 const struct net_in6_addr *addr,
2232 bool is_default,
2233 uint16_t router_lifetime);
2234
2243
2252#if defined(CONFIG_NET_NATIVE_IPV6)
2254#else
2256{
2257 ARG_UNUSED(iface);
2258
2259 return 0;
2260}
2261#endif /* CONFIG_NET_NATIVE_IPV6 */
2262
2269#if defined(CONFIG_NET_NATIVE_IPV6)
2270void net_if_ipv6_set_hop_limit(struct net_if *iface, uint8_t hop_limit);
2271#else
2272static inline void net_if_ipv6_set_hop_limit(struct net_if *iface,
2273 uint8_t hop_limit)
2274{
2275 ARG_UNUSED(iface);
2276 ARG_UNUSED(hop_limit);
2277}
2278#endif /* CONFIG_NET_NATIVE_IPV6 */
2279
2288#if defined(CONFIG_NET_NATIVE_IPV6)
2290#else
2292{
2293 ARG_UNUSED(iface);
2294
2295 return 0;
2296}
2297#endif /* CONFIG_NET_NATIVE_IPV6 */
2298
2305#if defined(CONFIG_NET_NATIVE_IPV6)
2306void net_if_ipv6_set_mcast_hop_limit(struct net_if *iface, uint8_t hop_limit);
2307#else
2309 uint8_t hop_limit)
2310{
2311 ARG_UNUSED(iface);
2312 ARG_UNUSED(hop_limit);
2313}
2314#endif /* CONFIG_NET_NATIVE_IPV6 */
2315
2325#define NET_IPV6_MAX_REACHABLE_TIME 3600000U
2326
2335 uint32_t reachable_time)
2336{
2337#if defined(CONFIG_NET_NATIVE_IPV6)
2338 if (iface == NULL) {
2339 return;
2340 }
2341
2342 if (!iface->config.ip.ipv6) {
2343 return;
2344 }
2345
2346 if (reachable_time > NET_IPV6_MAX_REACHABLE_TIME) {
2347 reachable_time = NET_IPV6_MAX_REACHABLE_TIME;
2348 }
2349
2350 iface->config.ip.ipv6->base_reachable_time = reachable_time;
2351#else
2352 ARG_UNUSED(iface);
2353 ARG_UNUSED(reachable_time);
2354
2355#endif
2356}
2357
2366{
2367#if defined(CONFIG_NET_NATIVE_IPV6)
2368 if (iface == NULL) {
2369 return 0;
2370 }
2371
2372 if (iface->config.ip.ipv6 == NULL) {
2373 return 0;
2374 }
2375
2376 return iface->config.ip.ipv6->base_reachable_time;
2377#else
2378 ARG_UNUSED(iface);
2379 return 0;
2380#endif
2381}
2382
2391{
2392#if defined(CONFIG_NET_NATIVE_IPV6)
2393 if (iface == NULL) {
2394 return 0;
2395 }
2396
2397 if (!iface->config.ip.ipv6) {
2398 return 0;
2399 }
2400
2401 return iface->config.ip.ipv6->reachable_time;
2402#else
2403 ARG_UNUSED(iface);
2404 return 0;
2405#endif
2406}
2407
2416
2423static inline void net_if_ipv6_set_reachable_time(struct net_if_ipv6 *ipv6)
2424{
2425#if defined(CONFIG_NET_NATIVE_IPV6)
2426 if (ipv6 == NULL) {
2427 return;
2428 }
2429
2431#else
2432 ARG_UNUSED(ipv6);
2433#endif
2434}
2435
2442static inline void net_if_ipv6_set_retrans_timer(struct net_if *iface,
2443 uint32_t retrans_timer)
2444{
2445#if defined(CONFIG_NET_NATIVE_IPV6)
2446 if (iface == NULL) {
2447 return;
2448 }
2449
2450 if (!iface->config.ip.ipv6) {
2451 return;
2452 }
2453
2454 iface->config.ip.ipv6->retrans_timer = retrans_timer;
2455#else
2456 ARG_UNUSED(iface);
2457 ARG_UNUSED(retrans_timer);
2458#endif
2459}
2460
2469{
2470#if defined(CONFIG_NET_NATIVE_IPV6)
2471 if (iface == NULL) {
2472 return 0;
2473 }
2474
2475 if (!iface->config.ip.ipv6) {
2476 return 0;
2477 }
2478
2479 return iface->config.ip.ipv6->retrans_timer;
2480#else
2481 ARG_UNUSED(iface);
2482 return 0;
2483#endif
2484}
2485
2497#if defined(CONFIG_NET_IPV6)
2498const struct net_in6_addr *net_if_ipv6_select_src_addr(struct net_if *iface,
2499 const struct net_in6_addr *dst);
2500#else
2501static inline const struct net_in6_addr *net_if_ipv6_select_src_addr(
2502 struct net_if *iface, const struct net_in6_addr *dst)
2503{
2504 ARG_UNUSED(iface);
2505 ARG_UNUSED(dst);
2506
2507 return NULL;
2508}
2509#endif
2510
2524#if defined(CONFIG_NET_IPV6)
2525const struct net_in6_addr *net_if_ipv6_select_src_addr_hint(struct net_if *iface,
2526 const struct net_in6_addr *dst,
2527 int flags);
2528#else
2530 struct net_if *iface, const struct net_in6_addr *dst, int flags)
2531{
2532 ARG_UNUSED(iface);
2533 ARG_UNUSED(dst);
2534 ARG_UNUSED(flags);
2535
2536 return NULL;
2537}
2538#endif
2539
2549#if defined(CONFIG_NET_IPV6)
2550struct net_if *net_if_ipv6_select_src_iface(const struct net_in6_addr *dst);
2551#else
2553 const struct net_in6_addr *dst)
2554{
2555 ARG_UNUSED(dst);
2556
2557 return NULL;
2558}
2559#endif
2560
2573#if defined(CONFIG_NET_IPV6)
2574struct net_if *net_if_ipv6_select_src_iface_addr(const struct net_in6_addr *dst,
2575 const struct net_in6_addr **src_addr);
2576#else
2578 const struct net_in6_addr *dst, const struct net_in6_addr **src_addr)
2579{
2580 ARG_UNUSED(dst);
2581 ARG_UNUSED(src_addr);
2582
2583 return NULL;
2584}
2585#endif /* CONFIG_NET_IPV6 */
2586
2597 enum net_addr_state addr_state);
2598
2609 struct net_if **iface);
2610
2618void net_if_ipv6_dad_failed(struct net_if *iface, const struct net_in6_addr *addr);
2619
2632 struct net_if **iface);
2633
2645 struct net_if_ipv4 **ipv4);
2646
2663
2672
2679void net_if_ipv4_set_ttl(struct net_if *iface, uint8_t ttl);
2680
2689
2697
2708bool net_if_ipv4_addr_onlink(struct net_if **iface, const struct net_in_addr *addr);
2709
2719 struct net_if **iface);
2720
2722struct net_if_addr *net_if_ipv4_addr_lookup_by_iface_raw(struct net_if *iface,
2723 const uint8_t *addr);
2725
2734#if defined(CONFIG_NET_IPV4)
2736 const struct net_in_addr *addr);
2737#else
2739 struct net_if *iface, const struct net_in_addr *addr)
2740{
2741 ARG_UNUSED(iface);
2742 ARG_UNUSED(addr);
2743
2744 return NULL;
2745}
2746#endif
2747
2759 const struct net_in_addr *addr,
2761 uint32_t vlifetime);
2762
2771bool net_if_ipv4_addr_rm(struct net_if *iface, const struct net_in_addr *addr);
2772
2781__syscall int net_if_ipv4_addr_lookup_by_index(const struct net_in_addr *addr);
2782
2793__syscall bool net_if_ipv4_addr_add_by_index(int index,
2794 const struct net_in_addr *addr,
2796 uint32_t vlifetime);
2797
2806__syscall bool net_if_ipv4_addr_rm_by_index(int index,
2807 const struct net_in_addr *addr);
2808
2818 void *user_data);
2819
2829 const struct net_in_addr *addr);
2830
2839bool net_if_ipv4_maddr_rm(struct net_if *iface, const struct net_in_addr *addr);
2840
2850 void *user_data);
2851
2863 struct net_if **iface);
2864
2872 struct net_if_mcast_addr *addr);
2873
2881static inline bool net_if_ipv4_maddr_is_joined(struct net_if_mcast_addr *addr)
2882{
2883 if (addr == NULL) {
2884 return false;
2885 }
2886
2887 return addr->is_joined;
2888}
2889
2897 struct net_if_mcast_addr *addr);
2898
2910#if defined(CONFIG_NET_IPV4)
2911void net_if_ipv4_nbr_flush(struct net_if *iface);
2912#else
2913static inline void net_if_ipv4_nbr_flush(struct net_if *iface)
2914{
2915 ARG_UNUSED(iface);
2916}
2917#endif
2918
2931#if defined(CONFIG_NET_IPV4)
2932bool net_if_ipv4_nbr_rm(struct net_if *iface, const struct net_in_addr *addr);
2933#else
2934static inline bool net_if_ipv4_nbr_rm(struct net_if *iface,
2935 const struct net_in_addr *addr)
2936{
2937 ARG_UNUSED(iface);
2938 ARG_UNUSED(addr);
2939
2940 return false;
2941}
2942#endif
2943
2950#if defined(CONFIG_NET_NATIVE_IPV4)
2951static inline struct net_in_addr *net_if_router_ipv4(struct net_if_router *router)
2952{
2953 if (router == NULL) {
2954 return NULL;
2955 }
2956
2957 return &router->address.in_addr;
2958}
2959#else
2960static inline struct net_in_addr *net_if_router_ipv4(struct net_if_router *router)
2961{
2962 static struct net_in_addr addr;
2963
2964 ARG_UNUSED(router);
2965
2966 return &addr;
2967}
2968#endif
2969
2980 const struct net_in_addr *addr);
2981
2992 const struct net_in_addr *addr);
3004 const struct net_in_addr *addr,
3005 bool is_default,
3006 uint16_t router_lifetime);
3007
3016
3030int net_if_ipv4_route_add(struct net_if *iface, const struct net_in_addr *addr, uint8_t mask_len,
3031 const struct net_in_addr *nexthop, uint32_t lifetime);
3032
3042 const struct net_in_addr *addr);
3043
3053 const struct net_in_addr *addr);
3054
3064#if defined(CONFIG_NET_IPV4)
3065struct net_if *net_if_ipv4_select_src_iface(const struct net_in_addr *dst);
3066#else
3068 const struct net_in_addr *dst)
3069{
3070 ARG_UNUSED(dst);
3071
3072 return NULL;
3073}
3074#endif
3075
3088#if defined(CONFIG_NET_IPV4)
3089struct net_if *net_if_ipv4_select_src_iface_addr(const struct net_in_addr *dst,
3090 const struct net_in_addr **src_addr);
3091#else
3093 const struct net_in_addr *dst, const struct net_in_addr **src_addr)
3094{
3095 ARG_UNUSED(dst);
3096 ARG_UNUSED(src_addr);
3097
3098 return NULL;
3099}
3100#endif /* CONFIG_NET_IPV4 */
3101
3113#if defined(CONFIG_NET_IPV4)
3114const struct net_in_addr *net_if_ipv4_select_src_addr(struct net_if *iface,
3115 const struct net_in_addr *dst);
3116#else
3117static inline const struct net_in_addr *net_if_ipv4_select_src_addr(
3118 struct net_if *iface, const struct net_in_addr *dst)
3119{
3120 ARG_UNUSED(iface);
3121 ARG_UNUSED(dst);
3122
3123 return NULL;
3124}
3125#endif
3126
3137 enum net_addr_state addr_state);
3138
3151 enum net_addr_state addr_state);
3152
3163 const struct net_in_addr *addr);
3164
3175 const struct net_in_addr *addr,
3176 const struct net_in_addr *netmask);
3177
3188 const struct net_in_addr *addr,
3189 const struct net_in_addr *netmask);
3190
3199
3206void net_if_ipv4_set_gw(struct net_if *iface, const struct net_in_addr *gw);
3207
3216__syscall bool net_if_ipv4_set_gw_by_index(int index, const struct net_in_addr *gw);
3217
3229
3238typedef void (*net_if_link_callback_t)(struct net_if *iface,
3239 struct net_linkaddr *dst,
3240 int status);
3241
3257
3266
3273
3281void net_if_call_link_cb(struct net_if *iface, struct net_linkaddr *lladdr,
3282 int status);
3283
3285
3286/* used to ensure encoding of checksum support in net_if.h and
3287 * ethernet.h is the same
3288 */
3289#define NET_IF_CHECKSUM_NONE_BIT 0
3290#define NET_IF_CHECKSUM_IPV4_HEADER_BIT BIT(0)
3291#define NET_IF_CHECKSUM_IPV4_ICMP_BIT BIT(1)
3292#define NET_IF_CHECKSUM_IPV4_TCP_BIT BIT(2)
3293#define NET_IF_CHECKSUM_IPV4_UDP_BIT BIT(3)
3294/* Space for future protocols and restrictions for IPV4 */
3295#define NET_IF_CHECKSUM_IPV6_ICMP_BIT BIT(11)
3296#define NET_IF_CHECKSUM_IPV6_TCP_BIT BIT(12)
3297#define NET_IF_CHECKSUM_IPV6_UDP_BIT BIT(13)
3298/* Space for future protocols and restrictions for IPV6 */
3299
3301
3307 NET_IF_CHECKSUM_IPV4_HEADER = NET_IF_CHECKSUM_IPV4_HEADER_BIT,
3309 NET_IF_CHECKSUM_IPV4_TCP = NET_IF_CHECKSUM_IPV4_TCP_BIT,
3311 NET_IF_CHECKSUM_IPV4_UDP = NET_IF_CHECKSUM_IPV4_UDP_BIT,
3313 NET_IF_CHECKSUM_IPV4_ICMP = NET_IF_CHECKSUM_IPV4_ICMP_BIT,
3317 NET_IF_CHECKSUM_IPV6_TCP = NET_IF_CHECKSUM_IPV6_TCP_BIT,
3319 NET_IF_CHECKSUM_IPV6_UDP = NET_IF_CHECKSUM_IPV6_UDP_BIT,
3321 NET_IF_CHECKSUM_IPV6_ICMP = NET_IF_CHECKSUM_IPV6_ICMP_BIT
3322};
3323
3334#if defined(CONFIG_NET_CHECKSUM_OFFLOAD)
3335bool net_if_need_calc_rx_checksum(struct net_if *iface,
3336 enum net_if_checksum_type chksum_type);
3337#else /* CONFIG_NET_CHECKSUM_OFFLOAD */
3338static inline bool net_if_need_calc_rx_checksum(struct net_if *iface,
3339 enum net_if_checksum_type chksum_type)
3340{
3341 ARG_UNUSED(iface);
3342 ARG_UNUSED(chksum_type);
3343 return true;
3344}
3345#endif /* CONFIG_NET_CHECKSUM_OFFLOAD */
3346
3358#if defined(CONFIG_NET_CHECKSUM_OFFLOAD)
3359bool net_if_need_calc_tx_checksum(struct net_if *iface,
3360 enum net_if_checksum_type chksum_type);
3361#else /* CONFIG_NET_CHECKSUM_OFFLOAD */
3362static inline bool net_if_need_calc_tx_checksum(struct net_if *iface,
3363 enum net_if_checksum_type chksum_type)
3364{
3365 ARG_UNUSED(iface);
3366 ARG_UNUSED(chksum_type);
3367 return true;
3368}
3369#endif /* CONFIG_NET_CHECKSUM_OFFLOAD */
3370
3381__syscall struct net_if *net_if_get_by_index(int index);
3382
3390int net_if_get_by_iface(struct net_if *iface);
3391
3399typedef void (*net_if_cb_t)(struct net_if *iface, void *user_data);
3400
3408void net_if_foreach(net_if_cb_t cb, void *user_data);
3409
3417int net_if_up(struct net_if *iface);
3418
3426static inline bool net_if_is_up(struct net_if *iface)
3427{
3428 if (iface == NULL) {
3429 return false;
3430 }
3431
3432 return net_if_flag_is_set(iface, NET_IF_UP) &&
3434}
3435
3443int net_if_down(struct net_if *iface);
3444
3452static inline bool net_if_is_admin_up(struct net_if *iface)
3453{
3454 if (iface == NULL) {
3455 return false;
3456 }
3457
3458 return net_if_flag_is_set(iface, NET_IF_UP);
3459}
3460
3469void net_if_carrier_on(struct net_if *iface);
3470
3479void net_if_carrier_off(struct net_if *iface);
3480
3488static inline bool net_if_is_carrier_ok(struct net_if *iface)
3489{
3490 if (iface == NULL) {
3491 return false;
3492 }
3493
3494 return net_if_flag_is_set(iface, NET_IF_LOWER_UP);
3495}
3496
3507void net_if_dormant_on(struct net_if *iface);
3508
3517void net_if_dormant_off(struct net_if *iface);
3518
3526static inline bool net_if_is_dormant(struct net_if *iface)
3527{
3528 if (iface == NULL) {
3529 return false;
3530 }
3531
3532 return net_if_flag_is_set(iface, NET_IF_DORMANT);
3533}
3534
3535#if defined(CONFIG_NET_PKT_TIMESTAMP_THREAD) || defined(__DOXYGEN__)
3543typedef void (*net_if_timestamp_callback_t)(struct net_pkt *pkt);
3544
3570
3582 struct net_pkt *pkt,
3583 struct net_if *iface,
3585
3592
3599
3600/*
3601 * @brief Add timestamped TX buffer to be handled
3602 *
3603 * @param pkt Timestamped buffer
3604 */
3606#endif /* CONFIG_NET_PKT_TIMESTAMP_THREAD */
3607
3617#if defined(CONFIG_NET_PROMISCUOUS_MODE)
3618int net_if_set_promisc(struct net_if *iface);
3619#else
3620static inline int net_if_set_promisc(struct net_if *iface)
3621{
3622 ARG_UNUSED(iface);
3623
3624 return -ENOTSUP;
3625}
3626#endif
3627
3633#if defined(CONFIG_NET_PROMISCUOUS_MODE)
3634void net_if_unset_promisc(struct net_if *iface);
3635#else
3636static inline void net_if_unset_promisc(struct net_if *iface)
3637{
3638 ARG_UNUSED(iface);
3639}
3640#endif
3641
3650#if defined(CONFIG_NET_PROMISCUOUS_MODE)
3651bool net_if_is_promisc(struct net_if *iface);
3652#else
3653static inline bool net_if_is_promisc(struct net_if *iface)
3654{
3655 ARG_UNUSED(iface);
3656
3657 return false;
3658}
3659#endif
3660
3670static inline bool net_if_are_pending_tx_packets(struct net_if *iface)
3671{
3672#if defined(CONFIG_NET_POWER_MANAGEMENT)
3673 return !!iface->tx_pending;
3674#else
3675 ARG_UNUSED(iface);
3676
3677 return false;
3678#endif
3679}
3680
3681#ifdef CONFIG_NET_POWER_MANAGEMENT
3689int net_if_suspend(struct net_if *iface);
3690
3698int net_if_resume(struct net_if *iface);
3699
3707bool net_if_is_suspended(struct net_if *iface);
3708#endif /* CONFIG_NET_POWER_MANAGEMENT */
3709
3717bool net_if_is_ethernet(struct net_if *iface);
3718
3725
3733bool net_if_is_wifi(struct net_if *iface);
3734
3741
3748
3755
3770int net_if_get_name(struct net_if *iface, char *buf, int len);
3771
3786int net_if_set_name(struct net_if *iface, const char *buf);
3787
3795int net_if_get_by_name(const char *name);
3796
3798__subsystem struct net_if_driver_api {
3799 void (*init)(struct net_if *iface);
3800};
3801
3802#define NET_IF_DHCPV4_INIT \
3803 IF_ENABLED(UTIL_AND(IS_ENABLED(CONFIG_NET_DHCPV4), \
3804 IS_ENABLED(CONFIG_NET_NATIVE_IPV4)), \
3805 (.dhcpv4.state = NET_DHCPV4_DISABLED,))
3806
3807#define NET_IF_DHCPV6_INIT \
3808 IF_ENABLED(UTIL_AND(IS_ENABLED(CONFIG_NET_DHCPV6), \
3809 IS_ENABLED(CONFIG_NET_NATIVE_IPV6)), \
3810 (.dhcpv6.state = NET_DHCPV6_DISABLED,))
3811
3812#define NET_IF_CONFIG_INIT \
3813 .config = { \
3814 IF_ENABLED(CONFIG_NET_IP, (.ip = {},)) \
3815 NET_IF_DHCPV4_INIT \
3816 NET_IF_DHCPV6_INIT \
3817 }
3818
3819#define NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, sfx) \
3820 net_stats_##dev_id##_##sfx##_collector
3821#define NET_PROMETHEUS_INIT(dev_id, sfx) \
3822 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS, \
3823 (.collector = &NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, sfx),))
3824
3825#define NET_IF_GET_NAME(dev_id, sfx) __net_if_##dev_id##_##sfx
3826#define NET_IF_DEV_GET_NAME(dev_id, sfx) __net_if_dev_##dev_id##_##sfx
3827
3828#define NET_IF_GET(dev_id, sfx) \
3829 ((struct net_if *)&NET_IF_GET_NAME(dev_id, sfx))
3830
3831#if defined(CONFIG_NET_STATISTICS_VIA_PROMETHEUS)
3832extern int net_stats_prometheus_scrape(struct prometheus_collector *collector,
3833 struct prometheus_metric *metric,
3834 void *user_data);
3835#endif /* CONFIG_NET_STATISTICS_VIA_PROMETHEUS */
3836
3837#define NET_IF_INIT(dev_id, sfx, _l2, _mtu) \
3838 static STRUCT_SECTION_ITERABLE(net_if_dev, \
3839 NET_IF_DEV_GET_NAME(dev_id, sfx)) = { \
3840 .dev = &(DEVICE_NAME_GET(dev_id)), \
3841 .l2 = &(NET_L2_GET_NAME(_l2)), \
3842 .l2_data = &(NET_L2_GET_DATA(dev_id, sfx)), \
3843 .mtu = _mtu, \
3844 .flags = {BIT(NET_IF_LOWER_UP)}, \
3845 }; \
3846 static STRUCT_SECTION_ITERABLE(net_if, \
3847 NET_IF_GET_NAME(dev_id, sfx)) = { \
3848 .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)), \
3849 NET_IF_CONFIG_INIT \
3850 }; \
3851 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS, \
3852 (static PROMETHEUS_COLLECTOR_DEFINE( \
3853 NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, \
3854 sfx), \
3855 net_stats_prometheus_scrape, \
3856 NET_IF_GET(dev_id, sfx)); \
3857 NET_STATS_PROMETHEUS(NET_IF_GET(dev_id, sfx), \
3858 dev_id, sfx);))
3859
3860#define NET_IF_OFFLOAD_INIT(dev_id, sfx, _mtu) \
3861 static STRUCT_SECTION_ITERABLE(net_if_dev, \
3862 NET_IF_DEV_GET_NAME(dev_id, sfx)) = { \
3863 .dev = &(DEVICE_NAME_GET(dev_id)), \
3864 .mtu = _mtu, \
3865 .l2 = &(NET_L2_GET_NAME(OFFLOADED_NETDEV)), \
3866 .flags = {BIT(NET_IF_LOWER_UP)}, \
3867 }; \
3868 static STRUCT_SECTION_ITERABLE(net_if, \
3869 NET_IF_GET_NAME(dev_id, sfx)) = { \
3870 .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)), \
3871 NET_IF_CONFIG_INIT \
3872 }; \
3873 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS, \
3874 (static PROMETHEUS_COLLECTOR_DEFINE( \
3875 NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, \
3876 sfx), \
3877 net_stats_prometheus_scrape, \
3878 NET_IF_GET(dev_id, sfx)); \
3879 NET_STATS_PROMETHEUS(NET_IF_GET(dev_id, sfx), \
3880 dev_id, sfx);))
3881
3882
3884
3885/* Network device initialization macros */
3886
3895#define NET_IF_DECLARE(dev_id, inst) \
3896 static struct net_if NET_IF_GET_NAME(dev_id, inst)
3897
3898#define Z_NET_DEVICE_IF_INIT_INSTANCE(dev_id, instance, l2, \
3899 l2_ctx_type, mtu) \
3900 NET_L2_DATA_INIT(dev_id, instance, l2_ctx_type); \
3901 NET_IF_INIT(dev_id, instance, l2, mtu)
3902
3903#define Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, instance, \
3904 init_fn, pm, data, config, prio, \
3905 api, l2, l2_ctx_type, mtu) \
3906 Z_DEVICE_STATE_DEFINE(dev_id); \
3907 Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, NULL, \
3908 Z_DEVICE_DT_FLAGS(node_id), pm, data, \
3909 config, POST_KERNEL, prio, api, \
3910 &Z_DEVICE_STATE_NAME(dev_id)); \
3911 Z_NET_DEVICE_IF_INIT_INSTANCE(dev_id, instance, l2, \
3912 l2_ctx_type, mtu)
3913
3914#define Z_NET_DEVICE_INIT(node_id, dev_id, name, init_fn, pm, data, \
3915 config, prio, api, l2, l2_ctx_type, mtu) \
3916 Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, 0, init_fn, \
3917 pm, data, config, prio, api, l2, \
3918 l2_ctx_type, mtu)
3919
3926#define NET_IF_DT_DECLARE(node_id, instance) \
3927 NET_IF_DECLARE(Z_DEVICE_DT_DEV_ID(node_id), instance)
3928
3936#define NET_IF_DT_INST_DECLARE(inst, ...) NET_IF_DT_DECLARE(DT_DRV_INST(inst), __VA_ARGS__)
3937
3945#define NET_IF_DT_GET(node_id, instance) NET_IF_GET(Z_DEVICE_DT_DEV_ID(node_id), instance)
3946
3955#define NET_IF_DT_INST_GET(inst, ...) NET_IF_DT_GET(DT_DRV_INST(inst), __VA_ARGS__)
3956
3976#define NET_DEVICE_INIT(dev_id, name, init_fn, pm, data, config, prio, \
3977 api, l2, l2_ctx_type, mtu) \
3978 Z_NET_DEVICE_INIT(DT_INVALID_NODE, dev_id, name, init_fn, pm, \
3979 data, config, prio, api, l2, l2_ctx_type, mtu)
3980
3992#define NET_DEVICE_DT_ADD_IFACE(node_id, l2, l2_ctx_type, mtu, instance) \
3993 Z_NET_DEVICE_IF_INIT_INSTANCE(Z_DEVICE_DT_DEV_ID(node_id), instance, l2, l2_ctx_type, mtu)
3994
4003#define NET_DEVICE_DT_INST_ADD_IFACE(inst, ...) \
4004 NET_DEVICE_DT_ADD_IFACE(DT_DRV_INST(inst), __VA_ARGS__)
4005
4024#define NET_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, \
4025 config, prio, api, l2, l2_ctx_type, mtu) \
4026 Z_NET_DEVICE_INIT(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
4027 DEVICE_DT_NAME(node_id), init_fn, pm, data, \
4028 config, prio, api, l2, l2_ctx_type, mtu)
4029
4038#define NET_DEVICE_DT_INST_DEFINE(inst, ...) \
4039 NET_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
4040
4064#define NET_DEVICE_INIT_INSTANCE(dev_id, name, instance, init_fn, pm, \
4065 data, config, prio, api, l2, \
4066 l2_ctx_type, mtu) \
4067 Z_NET_DEVICE_INIT_INSTANCE(DT_INVALID_NODE, dev_id, name, \
4068 instance, init_fn, pm, data, config, \
4069 prio, api, l2, l2_ctx_type, mtu)
4070
4093#define NET_DEVICE_DT_DEFINE_INSTANCE(node_id, instance, init_fn, pm, \
4094 data, config, prio, api, l2, \
4095 l2_ctx_type, mtu) \
4096 Z_NET_DEVICE_INIT_INSTANCE(node_id, \
4097 Z_DEVICE_DT_DEV_ID(node_id), \
4098 DEVICE_DT_NAME(node_id), instance, \
4099 init_fn, pm, data, config, prio, \
4100 api, l2, l2_ctx_type, mtu)
4101
4111#define NET_DEVICE_DT_INST_DEFINE_INSTANCE(inst, ...) \
4112 NET_DEVICE_DT_DEFINE_INSTANCE(DT_DRV_INST(inst), __VA_ARGS__)
4113
4114#define Z_NET_DEVICE_OFFLOAD_INIT(node_id, dev_id, name, init_fn, pm, \
4115 data, config, prio, api, mtu) \
4116 Z_DEVICE_STATE_DEFINE(dev_id); \
4117 Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, NULL, \
4118 Z_DEVICE_DT_FLAGS(node_id), pm, data, \
4119 config, POST_KERNEL, prio, api, \
4120 &Z_DEVICE_STATE_NAME(dev_id)); \
4121 NET_IF_OFFLOAD_INIT(dev_id, 0, mtu)
4122
4142#define NET_DEVICE_OFFLOAD_INIT(dev_id, name, init_fn, pm, data, \
4143 config, prio, api, mtu) \
4144 Z_NET_DEVICE_OFFLOAD_INIT(DT_INVALID_NODE, dev_id, name, \
4145 init_fn, pm, data, config, prio, api, \
4146 mtu)
4147
4166#define NET_DEVICE_DT_OFFLOAD_DEFINE(node_id, init_fn, pm, data, \
4167 config, prio, api, mtu) \
4168 Z_NET_DEVICE_OFFLOAD_INIT(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
4169 DEVICE_DT_NAME(node_id), init_fn, pm, \
4170 data, config, prio, api, mtu)
4171
4181#define NET_DEVICE_DT_INST_OFFLOAD_DEFINE(inst, ...) \
4182 NET_DEVICE_DT_OFFLOAD_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
4183
4189#define NET_IFACE_COUNT(_dst) \
4190 do { \
4191 extern struct net_if _net_if_list_start[]; \
4192 extern struct net_if _net_if_list_end[]; \
4193 *(_dst) = ((uintptr_t)_net_if_list_end - \
4194 (uintptr_t)_net_if_list_start) / \
4195 sizeof(struct net_if); \
4196 } while (0)
4197
4198#ifdef __cplusplus
4199}
4200#endif
4201
4202#include <zephyr/syscalls/net_if.h>
4203
4207
4208#endif /* ZEPHYR_INCLUDE_NET_NET_IF_H_ */
struct z_thread_stack_element k_thread_stack_t
Typedef of struct z_thread_stack_element.
Definition arch_interface.h:44
Prometheus collector APIs.
APIs and macros for the Zephyr device model.
DHCPv4 Client Handler.
DHCPv6 client.
static _Bool atomic_test_and_set_bit(atomic_t *target, int bit)
Atomically set a bit and test it.
Definition atomic.h:181
long atomic_t
Atomic integer variable.
Definition atomic_types.h:34
static _Bool atomic_test_bit(const atomic_t *target, int bit)
Atomically get and test a bit.
Definition atomic.h:138
static void atomic_set_bit(atomic_t *target, int bit)
Atomically set a bit.
Definition atomic.h:245
static void atomic_clear_bit(atomic_t *target, int bit)
Atomically clear a bit.
Definition atomic.h:227
#define ATOMIC_DEFINE(name, num_bits)
Define an array of atomic variables.
Definition atomic.h:122
static _Bool atomic_test_and_clear_bit(atomic_t *target, int bit)
Atomically clear a bit and test it.
Definition atomic.h:158
#define K_FOREVER
Generate infinite timeout delay.
Definition kernel.h:1727
#define K_NO_WAIT
Generate null timeout delay.
Definition kernel.h:1617
static int64_t k_uptime_get(void)
Get system uptime.
Definition kernel.h:2229
net_addr_state
What is the current state of the network address.
Definition net_ip.h:590
unsigned short int net_sa_family_t
Socket address family type.
Definition net_ip.h:169
net_addr_type
How the network address is assigned to network interface.
Definition net_ip.h:598
bool k_is_in_isr(void)
Determine if code is running at interrupt level.
int k_mutex_unlock(struct k_mutex *mutex)
Unlock a mutex.
int k_mutex_lock(struct k_mutex *mutex, k_timeout_t timeout)
Lock a mutex.
net_verdict
Net Verdict.
Definition net_core.h:84
static int net_hostname_set_postfix(const uint8_t *hostname_postfix, int postfix_len)
Set the device hostname postfix.
Definition hostname.h:118
#define NET_IPV6_MAX_REACHABLE_TIME
Maximum IPv6 base reachable time in milliseconds.
Definition net_if.h:2325
int net_if_get_by_iface(struct net_if *iface)
Get interface index according to pointer.
int net_if_up(struct net_if *iface)
Bring interface up.
struct net_if * net_if_get_first_up(void)
Get the first network interface which is up.
int net_if_set_name(struct net_if *iface, const char *buf)
Set network interface name.
struct net_if_router * net_if_ipv4_router_add(struct net_if *iface, const struct net_in_addr *addr, bool is_default, uint16_t router_lifetime)
Add IPv4 router to the system.
void net_if_ipv4_set_gw(struct net_if *iface, const struct net_in_addr *gw)
Set IPv4 gateway for an interface.
static bool net_if_is_carrier_ok(struct net_if *iface)
Check if carrier is present on network device.
Definition net_if.h:3488
static bool net_if_is_admin_up(struct net_if *iface)
Check if interface was brought up by the administrator.
Definition net_if.h:3452
void net_if_set_default(struct net_if *iface)
Set the default network interface.
void(* net_if_mcast_callback_t)(struct net_if *iface, const struct net_addr *addr, bool is_joined)
Define a callback that is called whenever a IPv6 or IPv4 multicast address group is joined or left.
Definition net_if.h:1943
static bool net_if_need_calc_tx_checksum(struct net_if *iface, enum net_if_checksum_type chksum_type)
Check if network packet checksum calculation can be avoided or not when sending the packet.
Definition net_if.h:3362
bool net_if_ipv4_addr_onlink(struct net_if **iface, const struct net_in_addr *addr)
Check if this IPv4 address is part of the subnet of our network interface.
void(* net_if_link_callback_t)(struct net_if *iface, struct net_linkaddr *dst, int status)
Define callback that is called after a network packet has been sent.
Definition net_if.h:3238
struct net_if * net_if_get_wifi_sta(void)
Get Wi-Fi network station interface.
struct net_in_addr net_if_ipv4_get_gw(struct net_if *iface)
Get IPv4 gateway of an interface.
void net_if_add_tx_timestamp(struct net_pkt *pkt)
void net_if_ipv4_maddr_leave(struct net_if *iface, struct net_if_mcast_addr *addr)
Mark a given multicast address to be left.
struct net_if_mcast_addr * net_if_ipv6_maddr_add(struct net_if *iface, const struct net_in6_addr *addr)
Add a IPv6 multicast address to an interface.
int net_if_get_by_name(const char *name)
Get interface index according to its name.
static struct net_in6_addr * net_if_router_ipv6(struct net_if_router *router)
Get the IPv6 address of the given router.
Definition net_if.h:2177
void net_if_register_timestamp_cb(struct net_if_timestamp_cb *handle, struct net_pkt *pkt, struct net_if *iface, net_if_timestamp_callback_t cb)
Register a timestamp callback.
struct net_if * net_if_get_by_link_addr(struct net_linkaddr *ll_addr)
Get an interface according to link layer address.
bool net_if_ipv4_addr_rm_by_index(int index, const struct net_in_addr *addr)
Remove a IPv4 address from an interface by interface index.
int net_if_ipv6_router_start(struct net_if *iface)
Enable the IPv6 router role on the interface.
void net_if_dormant_off(struct net_if *iface)
Mark interface as not dormant.
bool net_if_ipv6_router_rm(struct net_if_router *router)
Remove IPv6 router from the system.
static struct net_if * net_if_ipv4_select_src_iface(const struct net_in_addr *dst)
Get a network interface that should be used when sending IPv4 network data to destination.
Definition net_if.h:3067
static enum net_if_oper_state net_if_oper_state_set(struct net_if *iface, enum net_if_oper_state oper_state)
Set an operational state on an interface.
Definition net_if.h:1063
int net_if_down(struct net_if *iface)
Bring interface down.
struct net_if_ipv6_prefix * net_if_ipv6_prefix_add(struct net_if *iface, const struct net_in6_addr *prefix, uint8_t len, uint32_t lifetime)
Add a IPv6 prefix to an network interface.
bool net_if_ipv4_addr_rm(struct net_if *iface, const struct net_in_addr *addr)
Remove a IPv4 address from an interface.
static struct net_if * net_if_ipv4_select_src_iface_addr(const struct net_in_addr *dst, const struct net_in_addr **src_addr)
Get a network interface that should be used when sending IPv4 network data to destination.
Definition net_if.h:3092
static void net_if_queue_tx(struct net_if *iface, struct net_pkt *pkt)
Queue a packet to the net interface TX queue.
Definition net_if.h:1230
#define NET_IF_IPV6_DAD_NONCE_LEN
RFC 7527, section-4 Enhanced DAD nonce payload length in bytes.
Definition net_if.h:52
void net_if_ipv6_prefix_unset_timer(struct net_if_ipv6_prefix *prefix)
Unset the prefix lifetime timer.
bool net_if_ipv4_addr_add_by_index(int index, const struct net_in_addr *addr, enum net_addr_type addr_type, uint32_t vlifetime)
Add a IPv4 address to an interface by network interface index.
int net_if_config_ipv4_get(struct net_if *iface, struct net_if_ipv4 **ipv4)
Allocate network interface IPv4 config.
void net_if_carrier_on(struct net_if *iface)
Underlying network device has detected the carrier (cable connected).
void net_if_try_queue_tx(struct net_if *iface, struct net_pkt *pkt, k_timeout_t timeout)
Try enqueuing a packet to the net interface TX queue.
static struct net_if * net_if_ipv6_select_src_iface(const struct net_in6_addr *dst)
Get a network interface that should be used when sending IPv6 network data to destination.
Definition net_if.h:2552
void net_if_mcast_monitor(struct net_if *iface, const struct net_addr *addr, bool is_joined)
Call registered multicast monitors.
static int net_if_set_link_addr(struct net_if *iface, const uint8_t *addr, uint8_t len, enum net_link_type type)
Set a network interface's link address.
Definition net_if.h:1574
struct net_if_addr * net_if_ipv6_addr_add(struct net_if *iface, const struct net_in6_addr *addr, enum net_addr_type addr_type, uint32_t vlifetime)
Add a IPv6 address to an interface.
static void * net_if_l2_data(struct net_if *iface)
Get a pointer to the interface L2 private data.
Definition net_if.h:1189
static bool net_if_are_pending_tx_packets(struct net_if *iface)
Check if there are any pending TX network data for a given network interface.
Definition net_if.h:3670
static bool net_if_flag_test_and_set(struct net_if *iface, enum net_if_flag value)
Test and set a value in network interface flags.
Definition net_if.h:993
struct net_if_addr * net_if_ipv6_addr_lookup(const struct net_in6_addr *addr, struct net_if **iface)
Check if this IPv6 address belongs to one of the interfaces.
bool net_if_ipv4_is_addr_bcast(struct net_if *iface, const struct net_in_addr *addr)
Check if the given IPv4 address is a broadcast address.
static struct net_linkaddr * net_if_get_link_addr(struct net_if *iface)
Get an network interface's link address.
Definition net_if.h:1378
void net_if_ipv6_maddr_join(struct net_if *iface, struct net_if_mcast_addr *addr)
Mark a given multicast address to be joined.
struct net_if_router * net_if_ipv4_router_lookup(struct net_if *iface, const struct net_in_addr *addr)
Check if IPv4 address is one of the routers configured in the system.
bool net_if_ipv6_prefix_rm(struct net_if *iface, const struct net_in6_addr *addr, uint8_t len)
Remove an IPv6 prefix from an interface.
static struct net_in_addr * net_if_router_ipv4(struct net_if_router *router)
Get the IPv4 address of the given router.
Definition net_if.h:2960
static struct net_offload * net_if_offload(struct net_if *iface)
Return the IP offload plugin.
Definition net_if.h:1271
struct net_if * net_if_get_first_ethernet(void)
Get first Cabled Ethernet network interface.
static void net_if_flag_set(struct net_if *iface, enum net_if_flag value)
Set a value in network interface flags.
Definition net_if.h:975
bool net_if_ipv6_addr_onlink(struct net_if **iface, const struct net_in6_addr *addr)
Check if this IPv6 address is part of the subnet of our network interface.
struct net_if_addr * net_if_ipv4_addr_lookup(const struct net_in_addr *addr, struct net_if **iface)
Check if this IPv4 address belongs to one of the interfaces.
struct net_if * net_if_get_default(void)
Get the default network interface.
void net_if_ipv4_set_ttl(struct net_if *iface, uint8_t ttl)
Set IPv4 time-to-live value specified to a given interface.
static const struct net_in6_addr * net_if_ipv6_select_src_addr_hint(struct net_if *iface, const struct net_in6_addr *dst, int flags)
Get a IPv6 source address that should be used when sending network data to destination.
Definition net_if.h:2529
int net_if_config_ipv6_get(struct net_if *iface, struct net_if_ipv6 **ipv6)
Allocate network interface IPv6 config.
static uint8_t net_if_ipv6_get_mcast_hop_limit(struct net_if *iface)
Get IPv6 multicast hop limit specified for a given interface.
Definition net_if.h:2291
void net_if_ipv6_addr_foreach(struct net_if *iface, net_if_ip_addr_cb_t cb, void *user_data)
Go through all IPv6 addresses on a network interface and call callback for each used address.
static void net_if_ipv6_set_hop_limit(struct net_if *iface, uint8_t hop_limit)
Set the default IPv6 hop limit of a given interface.
Definition net_if.h:2272
enum net_verdict net_if_try_send_data(struct net_if *iface, struct net_pkt *pkt, k_timeout_t timeout)
Try sending a packet through a net iface.
static bool net_if_ipv4_nbr_rm(struct net_if *iface, const struct net_in_addr *addr)
Remove one neighbor from the IPv4 neighbor cache.
Definition net_if.h:2934
int net_if_get_name(struct net_if *iface, char *buf, int len)
Get network interface name.
static const struct net_in6_addr * net_if_ipv6_select_src_addr(struct net_if *iface, const struct net_in6_addr *dst)
Get a IPv6 source address that should be used when sending network data to destination.
Definition net_if.h:2501
static struct net_if_addr * net_if_ipv6_addr_lookup_by_iface(struct net_if *iface, const struct net_in6_addr *addr)
Check if this IPv6 address belongs to this specific interfaces.
Definition net_if.h:1767
static void net_if_nbr_reachability_hint(struct net_if *iface, const struct net_in6_addr *ipv6_addr)
Provide a reachability hint for IPv6 Neighbor Discovery.
Definition net_if.h:1454
void(* net_if_timestamp_callback_t)(struct net_pkt *pkt)
Define callback that is called after a network packet has been timestamped.
Definition net_if.h:3543
static uint8_t net_if_ipv6_get_hop_limit(struct net_if *iface)
Get IPv6 hop limit specified for a given interface.
Definition net_if.h:2255
void net_if_carrier_off(struct net_if *iface)
Underlying network device has lost the carrier (cable disconnected).
void net_if_ipv6_prefix_set_timer(struct net_if_ipv6_prefix *prefix, uint32_t lifetime)
Set the prefix lifetime timer.
void net_if_unregister_link_cb(struct net_if_link_cb *link)
Unregister a link callback.
bool net_if_ipv4_router_rm(struct net_if_router *router)
Remove IPv4 router from the system.
static bool net_if_is_ip_offloaded(struct net_if *iface)
Return the IP offload status.
Definition net_if.h:1244
bool net_if_ipv6_maddr_rm(struct net_if *iface, const struct net_in6_addr *addr)
Remove an IPv6 multicast address from an interface.
static bool net_if_is_dormant(struct net_if *iface)
Check if the interface is dormant.
Definition net_if.h:3526
struct net_if * net_if_get_first_wifi(void)
Get first Wi-Fi network interface.
struct net_in_addr * net_if_ipv4_get_ll(struct net_if *iface, enum net_addr_state addr_state)
Get a IPv4 link local address in a given state.
bool net_if_is_ethernet(struct net_if *iface)
Check if the network interface is cabled ethernet.
uint8_t net_if_ipv4_get_mcast_ttl(struct net_if *iface)
Get IPv4 multicast time-to-live value specified for a given interface.
static uint32_t net_if_ipv6_get_base_reachable_time(struct net_if *iface)
Get IPv6 base reachable time for a given interface.
Definition net_if.h:2365
struct net_if_mcast_addr * net_if_ipv4_maddr_add(struct net_if *iface, const struct net_in_addr *addr)
Add a IPv4 multicast address to an interface.
void(* net_if_ip_maddr_cb_t)(struct net_if *iface, struct net_if_mcast_addr *maddr, void *user_data)
Callback used while iterating over network interface multicast IP addresses.
Definition net_if.h:1899
struct net_if * net_if_get_by_index(int index)
Get interface according to index.
enum net_verdict net_if_recv_data(struct net_if *iface, struct net_pkt *pkt)
Input a packet through a net iface.
struct net_if * net_if_get_first_by_type(const struct net_l2 *l2)
Get the first network interface according to its type.
struct net_in_addr * net_if_ipv4_get_global_addr(struct net_if *iface, enum net_addr_state addr_state)
Get an IPv4 global address in a given state.
static void net_if_set_mtu(struct net_if *iface, uint16_t mtu)
Set an network interface's MTU.
Definition net_if.h:1607
struct net_in6_addr * net_if_ipv6_get_ll(struct net_if *iface, enum net_addr_state addr_state)
Get a IPv6 link local address in a given state.
uint8_t net_if_ipv4_get_ttl(struct net_if *iface)
Get IPv4 time-to-live value specified for a given interface.
static bool net_if_is_up(struct net_if *iface)
Check if interface is up and running.
Definition net_if.h:3426
static void net_if_ipv4_nbr_flush(struct net_if *iface)
Flush the IPv4 neighbor cache of a network interface.
Definition net_if.h:2913
struct net_if_addr * net_if_ipv4_addr_add(struct net_if *iface, const struct net_in_addr *addr, enum net_addr_type addr_type, uint32_t vlifetime)
Add a IPv4 address to an interface.
static void net_if_ipv6_set_reachable_time(struct net_if_ipv6 *ipv6)
Set IPv6 reachable time for a given interface.
Definition net_if.h:2423
static enum net_verdict net_if_send_data(struct net_if *iface, struct net_pkt *pkt)
Send a packet through a net iface.
Definition net_if.h:1148
bool net_if_ipv4_set_gw_by_index(int index, const struct net_in_addr *gw)
Set IPv4 gateway for an interface index.
int net_if_config_ipv4_put(struct net_if *iface)
Release network interface IPv4 config.
void net_if_dormant_on(struct net_if *iface)
Mark interface as dormant.
struct net_in6_addr * net_if_ipv6_get_ll_addr(enum net_addr_state state, struct net_if **iface)
Return link local IPv6 address from the first interface that has a link local address matching give s...
int net_if_config_ipv6_put(struct net_if *iface)
Release network interface IPv6 config.
static struct net_if * net_if_ipv6_select_src_iface_addr(const struct net_in6_addr *dst, const struct net_in6_addr **src_addr)
Get a network interface that should be used when sending IPv6 network data to destination.
Definition net_if.h:2577
struct net_if_router * net_if_ipv6_router_add(struct net_if *iface, const struct net_in6_addr *addr, bool is_default, uint16_t router_lifetime)
Add IPv6 router to the system.
net_if_checksum_type
Type of checksum for which support in the interface will be queried.
Definition net_if.h:3305
void net_if_ipv6_dad_failed(struct net_if *iface, const struct net_in6_addr *addr)
Stop IPv6 Duplicate Address Detection (DAD) procedure if we find out that our IPv6 address is already...
void net_if_mcast_mon_register(struct net_if_mcast_monitor *mon, struct net_if *iface, net_if_mcast_callback_t cb)
Register a multicast monitor.
bool net_if_ipv4_addr_mask_cmp(struct net_if *iface, const struct net_in_addr *addr)
Check if the given IPv4 address belongs to local subnet.
void net_if_ipv4_set_mcast_ttl(struct net_if *iface, uint8_t ttl)
Set IPv4 multicast time-to-live value specified to a given interface.
static void net_if_start_dad(struct net_if *iface)
Start duplicate address detection procedure.
Definition net_if.h:1411
void net_if_foreach(net_if_cb_t cb, void *user_data)
Go through all the network interfaces and call callback for each interface.
struct net_if_ipv6_prefix * net_if_ipv6_prefix_lookup(struct net_if *iface, const struct net_in6_addr *addr, uint8_t len)
Check if this IPv6 prefix belongs to this interface.
struct net_if_ipv6_prefix * net_if_ipv6_prefix_get(struct net_if *iface, const struct net_in6_addr *addr)
Return prefix that corresponds to this IPv6 address.
static void net_if_unset_promisc(struct net_if *iface)
Set network interface into normal mode.
Definition net_if.h:3636
static void net_if_socket_offload_set(struct net_if *iface, net_socket_create_t socket_offload)
Set the function to create an offloaded socket.
Definition net_if.h:1334
static uint32_t net_if_ipv6_get_reachable_time(struct net_if *iface)
Get IPv6 reachable timeout specified for a given interface.
Definition net_if.h:2390
static bool net_if_is_promisc(struct net_if *iface)
Check if promiscuous mode is set or not.
Definition net_if.h:3653
int net_if_ipv6_prefix_set_advertise(struct net_if *iface, const struct net_in6_addr *prefix, uint8_t len, bool advertise)
Mark (or unmark) an IPv6 prefix for advertisement in Router Advertisements sent on the interface.
static bool net_if_ipv4_maddr_is_joined(struct net_if_mcast_addr *addr)
Check if given multicast address is joined or not.
Definition net_if.h:2881
static void net_if_ipv6_prefix_set_lf(struct net_if_ipv6_prefix *prefix, bool is_infinite)
Set the infinite status of the prefix.
Definition net_if.h:2086
bool net_if_ipv4_set_netmask_by_addr(struct net_if *iface, const struct net_in_addr *addr, const struct net_in_addr *netmask)
Set IPv4 netmask for an interface index for a given address.
bool net_if_is_wifi(struct net_if *iface)
Check if the network interface supports Wi-Fi.
bool net_if_ipv4_set_netmask_by_addr_by_index(int index, const struct net_in_addr *addr, const struct net_in_addr *netmask)
Set IPv4 netmask for an interface index for a given address.
int net_if_ipv6_router_stop(struct net_if *iface)
Disable the IPv6 router role on the interface.
void net_if_unregister_timestamp_cb(struct net_if_timestamp_cb *handle)
Unregister a timestamp callback.
bool net_if_ipv4_maddr_rm(struct net_if *iface, const struct net_in_addr *addr)
Remove an IPv4 multicast address from an interface.
void net_if_register_link_cb(struct net_if_link_cb *link, net_if_link_callback_t cb)
Register a link callback.
void net_if_call_link_cb(struct net_if *iface, struct net_linkaddr *lladdr, int status)
Call a link callback function.
static void net_if_ipv6_nbr_flush(struct net_if *iface)
Flush the IPv6 neighbor cache of a network interface.
Definition net_if.h:1475
int net_if_ipv6_addr_lookup_by_index(const struct net_in6_addr *addr)
Check if this IPv6 address belongs to one of the interface indices.
void net_if_ipv6_router_update_lifetime(struct net_if_router *router, uint16_t lifetime)
Update validity lifetime time of a router.
void net_if_ipv4_addr_foreach(struct net_if *iface, net_if_ip_addr_cb_t cb, void *user_data)
Go through all IPv4 addresses on a network interface and call callback for each used address.
struct net_in_addr net_if_ipv4_get_netmask_by_addr(struct net_if *iface, const struct net_in_addr *addr)
Get IPv4 netmask related to an address of an interface.
static void net_if_stop_rs(struct net_if *iface)
Stop neighbor discovery.
Definition net_if.h:1433
uint32_t net_if_ipv6_calc_reachable_time(struct net_if_ipv6 *ipv6)
Calculate next reachable time value for IPv6 reachable time.
static void net_if_ipv6_set_base_reachable_time(struct net_if *iface, uint32_t reachable_time)
Set IPv6 reachable time for a given interface.
Definition net_if.h:2334
struct net_if * net_if_select_src_iface(const struct net_sockaddr *dst)
Get a network interface that should be used when sending IPv6 or IPv4 network data to destination.
void(* net_if_ip_addr_cb_t)(struct net_if *iface, struct net_if_addr *addr, void *user_data)
Callback used while iterating over network interface IP addresses.
Definition net_if.h:1855
void net_if_ipv6_maddr_foreach(struct net_if *iface, net_if_ip_maddr_cb_t cb, void *user_data)
Go through all IPv6 multicast addresses on a network interface and call callback for each used addres...
struct net_if_mcast_addr * net_if_ipv4_maddr_lookup(const struct net_in_addr *addr, struct net_if **iface)
Check if this IPv4 multicast address belongs to a specific interface or one of the interfaces.
static bool net_if_flag_test_and_clear(struct net_if *iface, enum net_if_flag value)
Test and clear a value in network interface flags.
Definition net_if.h:1027
void net_if_start_rs(struct net_if *iface)
Start neighbor discovery and send router solicitation message.
static int net_if_oper_state_change_time(struct net_if *iface, int64_t *change_time)
Get an operational state change time of an interface.
Definition net_if.h:1111
static bool net_if_ipv6_maddr_is_joined(struct net_if_mcast_addr *addr)
Check if given multicast address is joined or not.
Definition net_if.h:2011
struct net_if_router * net_if_ipv6_router_find_default(struct net_if *iface, const struct net_in6_addr *addr)
Find default router for this IPv6 address.
static bool net_if_need_calc_rx_checksum(struct net_if *iface, enum net_if_checksum_type chksum_type)
Check if received network packet checksum calculation can be avoided or not.
Definition net_if.h:3338
void(* net_if_cb_t)(struct net_if *iface, void *user_data)
Callback used while iterating over network interfaces.
Definition net_if.h:3399
struct net_if_router * net_if_ipv6_router_lookup(struct net_if *iface, const struct net_in6_addr *addr)
Check if IPv6 address is one of the routers configured in the system.
static bool net_if_ipv6_nbr_rm(struct net_if *iface, const struct net_in6_addr *addr)
Remove one neighbor from the IPv6 neighbor cache.
Definition net_if.h:1496
static uint16_t net_if_get_mtu(struct net_if *iface)
Get an network interface's MTU.
Definition net_if.h:1592
bool net_if_ipv6_addr_rm(struct net_if *iface, const struct net_in6_addr *addr)
Remove an IPv6 address from an interface.
static struct net_if_addr * net_if_ipv4_addr_lookup_by_iface(struct net_if *iface, const struct net_in_addr *addr)
Check if this IPv4 address belongs to this specific interfaces.
Definition net_if.h:2738
void net_if_ipv6_maddr_leave(struct net_if *iface, struct net_if_mcast_addr *addr)
Mark a given multicast address to be left.
void net_if_mcast_mon_unregister(struct net_if_mcast_monitor *mon)
Unregister a multicast monitor.
struct net_if_mcast_addr * net_if_ipv6_maddr_lookup(const struct net_in6_addr *addr, struct net_if **iface)
Check if this IPv6 multicast address belongs to a specific interface or one of the interfaces.
bool net_if_ipv6_addr_add_by_index(int index, const struct net_in6_addr *addr, enum net_addr_type addr_type, uint32_t vlifetime)
Add a IPv6 address to an interface by index.
static void net_if_ipv6_set_retrans_timer(struct net_if *iface, uint32_t retrans_timer)
Set IPv6 retransmit timer for a given interface.
Definition net_if.h:2442
void net_if_call_timestamp_cb(struct net_pkt *pkt)
Call a timestamp callback function.
struct net_if * net_if_lookup_by_dev(const struct device *dev)
Find an interface from it's related device.
bool net_if_ipv6_addr_rm_by_index(int index, const struct net_in6_addr *addr)
Remove an IPv6 address from an interface by index.
void net_if_router_rm(struct net_if_router *router)
Remove a router from the system.
int net_if_ipv4_route_add(struct net_if *iface, const struct net_in_addr *addr, uint8_t mask_len, const struct net_in_addr *nexthop, uint32_t lifetime)
Add an IPv4 route to the system routing table.
static uint32_t net_if_ipv6_get_retrans_timer(struct net_if *iface)
Get IPv6 retransmit timer specified for a given interface.
Definition net_if.h:2468
net_if_oper_state
Network interface operational status (RFC 2863).
Definition net_if.h:360
static bool net_if_flag_is_set(struct net_if *iface, enum net_if_flag value)
Check if a value in network interface flags is set.
Definition net_if.h:1045
static struct net_if_config * net_if_get_config(struct net_if *iface)
Return network configuration for this network interface.
Definition net_if.h:1394
void net_if_ipv4_maddr_join(struct net_if *iface, struct net_if_mcast_addr *addr)
Mark a given multicast address to be joined.
static void net_if_addr_set_lf(struct net_if_addr *ifaddr, bool is_infinite)
Set the infinite status of the network interface address.
Definition net_if.h:1623
net_if_flag
Network interface flags.
Definition net_if.h:304
int net_if_ipv4_addr_lookup_by_index(const struct net_in_addr *addr)
Check if this IPv4 address belongs to one of the interface indices.
static const struct net_in_addr * net_if_ipv4_select_src_addr(struct net_if *iface, const struct net_in_addr *dst)
Get a IPv4 source address that should be used when sending network data to destination.
Definition net_if.h:3117
void net_if_ipv4_maddr_foreach(struct net_if *iface, net_if_ip_maddr_cb_t cb, void *user_data)
Go through all IPv4 multicast addresses on a network interface and call callback for each used addres...
static const struct device * net_if_get_device(struct net_if *iface)
Get an network interface's device.
Definition net_if.h:1205
bool net_if_is_offloaded(struct net_if *iface)
Return offload status of a given network interface.
int(* net_socket_create_t)(int, int, int)
A function prototype to create an offloaded socket.
Definition net_if.h:793
void net_if_ipv6_addr_update_lifetime(struct net_if_addr *ifaddr, uint32_t vlifetime)
Update validity lifetime time of an IPv6 address.
static void net_if_offload_set(struct net_if *iface, struct net_offload *offload)
Set the IP offload plugin.
Definition net_if.h:1292
static bool net_if_is_socket_offloaded(struct net_if *iface)
Return the socket offload status.
Definition net_if.h:1313
struct net_in6_addr * net_if_ipv6_get_global_addr(enum net_addr_state state, struct net_if **iface)
Return global IPv6 address from the first interface that has a global IPv6 address matching the given...
static void net_if_ipv6_set_mcast_hop_limit(struct net_if *iface, uint8_t hop_limit)
Set the default IPv6 multicast hop limit of a given interface.
Definition net_if.h:2308
struct net_if * net_if_get_wifi_sap(void)
Get first Wi-Fi network Soft-AP interface.
static int net_if_set_promisc(struct net_if *iface)
Set network interface into promiscuous mode.
Definition net_if.h:3620
static const struct net_l2 * net_if_l2(struct net_if *iface)
Get a pointer to the interface L2.
Definition net_if.h:1163
static net_socket_create_t net_if_socket_offload(struct net_if *iface)
Return the function to create an offloaded socket.
Definition net_if.h:1356
static void net_if_flag_clear(struct net_if *iface, enum net_if_flag value)
Clear a value in network interface flags.
Definition net_if.h:1009
struct net_if_router * net_if_ipv4_router_find_default(struct net_if *iface, const struct net_in_addr *addr)
Find default router for this IPv4 address.
@ NET_IF_CHECKSUM_IPV4_ICMP
Interface supports checksum calculation for ICMP4 payload in IPv4.
Definition net_if.h:3313
@ NET_IF_CHECKSUM_IPV6_TCP
Interface supports checksum calculation for TCP payload in IPv6.
Definition net_if.h:3317
@ NET_IF_CHECKSUM_IPV6_UDP
Interface supports checksum calculation for UDP payload in IPv6.
Definition net_if.h:3319
@ NET_IF_CHECKSUM_IPV4_HEADER
Interface supports IP version 4 header checksum calculation.
Definition net_if.h:3307
@ NET_IF_CHECKSUM_IPV4_TCP
Interface supports checksum calculation for TCP payload in IPv4.
Definition net_if.h:3309
@ NET_IF_CHECKSUM_IPV6_HEADER
Definition net_if.h:3315
@ NET_IF_CHECKSUM_IPV6_ICMP
Interface supports checksum calculation for ICMP6 payload in IPv6.
Definition net_if.h:3321
@ NET_IF_CHECKSUM_IPV4_UDP
Interface supports checksum calculation for UDP payload in IPv4.
Definition net_if.h:3311
@ NET_IF_OPER_TESTING
Training mode.
Definition net_if.h:365
@ NET_IF_OPER_DORMANT
Waiting external action.
Definition net_if.h:366
@ NET_IF_OPER_UP
Interface is up.
Definition net_if.h:367
@ NET_IF_OPER_NOTPRESENT
Hardware missing.
Definition net_if.h:362
@ NET_IF_OPER_UNKNOWN
Initial (unknown) value.
Definition net_if.h:361
@ NET_IF_OPER_DOWN
Interface is down.
Definition net_if.h:363
@ NET_IF_OPER_LOWERLAYERDOWN
Lower layer interface is down.
Definition net_if.h:364
@ NET_IF_NO_AUTO_START
Do not bring the interface immediately up after initialization.
Definition net_if.h:318
@ NET_IF_IPV6_NO_MLD
IPv6 Multicast Listener Discovery disabled.
Definition net_if.h:348
@ NET_IF_POINTOPOINT
Interface is pointopoint.
Definition net_if.h:309
@ NET_IF_IPV6_NO_ND
IPv6 Neighbor Discovery disabled.
Definition net_if.h:345
@ NET_IF_FORWARD_MULTICASTS
Flag defines if received multicasts of other interface are forwarded on this interface.
Definition net_if.h:327
@ NET_IF_IPV4
Interface supports IPv4.
Definition net_if.h:330
@ NET_IF_PROMISC
Interface is in promiscuous mode.
Definition net_if.h:312
@ NET_IF_DORMANT
Driver signals dormant.
Definition net_if.h:342
@ NET_IF_SUSPENDED
Power management specific: interface is being suspended.
Definition net_if.h:321
@ NET_IF_IPV6
Interface supports IPv6.
Definition net_if.h:333
@ NET_IF_UP
Interface is admin up.
Definition net_if.h:306
@ NET_IF_LOWER_UP
Driver signals L1 is up.
Definition net_if.h:339
@ NET_IF_RUNNING
Interface up and running (ready to receive and transmit).
Definition net_if.h:336
@ NET_IF_NO_TX_LOCK
Mutex locking on TX data path disabled on the interface.
Definition net_if.h:351
net_link_type
Type of the link address.
Definition net_linkaddr.h:58
static int net_linkaddr_create(struct net_linkaddr *lladdr, const uint8_t *addr, uint8_t len, enum net_link_type type)
Create a link address structure.
Definition net_linkaddr.h:179
struct _slist sys_slist_t
Single-linked list structure.
Definition slist.h:54
struct _snode sys_snode_t
Single-linked list node structure.
Definition slist.h:44
#define BIT(n)
Unsigned integer with bit position n set (signed in assembly language).
Definition util_macro.h:44
#define IF_ENABLED(_flag, _code)
Insert code if _flag is defined and equals 1.
Definition util_macro.h:290
#define EINVAL
Invalid argument.
Definition errno.h:61
#define ENOTSUP
Unsupported value.
Definition errno.h:115
#define EPERM
Not owner.
Definition errno.h:40
Hostname configuration definitions.
IPv4 Autoconfiguration.
net_ipv4_autoconf_state
Current state of IPv4 Autoconfiguration.
Definition ipv4_autoconf.h:15
Network core definitions.
IPv6 and IPv4 definitions.
Public API for network L2 interface.
Public API for network link address.
Network statistics.
Network timer with wrap around.
flags
Definition parser.h:86
state
Definition parser_state.h:29
Header file for the single-linked list API.
__UINT32_TYPE__ uint32_t
Definition stdint.h:90
__INT32_TYPE__ int32_t
Definition stdint.h:74
__UINT64_TYPE__ uint64_t
Definition stdint.h:91
__UINT8_TYPE__ uint8_t
Definition stdint.h:88
__UINT16_TYPE__ uint16_t
Definition stdint.h:89
__INT64_TYPE__ int64_t
Definition stdint.h:75
__INT16_TYPE__ int16_t
Definition stdint.h:73
Runtime device structure (in ROM) per driver instance.
Definition device.h:543
Kernel FIFO structure.
Definition kernel.h:3107
Kernel mutex structure.
Definition kernel.h:3764
Semaphore structure.
Definition kernel.h:4002
Thread Structure.
Definition thread.h:258
Kernel timeout type.
Definition clock.h:65
Kernel timepoint type.
Definition clock.h:289
DHCPv6 client configuration parameters.
Definition dhcpv6.h:71
Network Interface unicast IPv4 address and netmask.
Definition net_if.h:581
struct net_in_addr netmask
Netmask.
Definition net_if.h:585
struct net_if_addr ipv4
IPv4 address.
Definition net_if.h:583
Network Interface unicast IP addresses.
Definition net_if.h:59
struct net_addr address
IP address.
Definition net_if.h:61
uint8_t is_mesh_local
Is this IP address usage limited to the subnet (mesh) or not.
Definition net_if.h:156
uint8_t is_temporary
Is this IP address temporary and generated for example by IPv6 privacy extension (RFC 8981).
Definition net_if.h:161
enum net_addr_state addr_state
What is the current state of the address.
Definition net_if.h:76
uint8_t is_infinite
Is the IP address valid forever.
Definition net_if.h:150
atomic_t atomic_ref
Reference counter.
Definition net_if.h:66
uint8_t is_added
Was this address added or not.
Definition net_if.h:164
enum net_addr_type addr_type
How the IP address was set.
Definition net_if.h:73
uint8_t is_used
Is this IP address used or not.
Definition net_if.h:153
IP and other configuration related data for network interface.
Definition net_if.h:726
Network Interface Device structure.
Definition net_if.h:811
Network interface IP address configuration.
Definition net_if.h:713
IPv4 configuration.
Definition net_if.h:589
uint8_t mcast_ttl
IPv4 time-to-live for multicast packets.
Definition net_if.h:603
struct net_if_addr_ipv4 unicast[NET_IF_MAX_IPV4_ADDR]
Unicast IP addresses.
Definition net_if.h:591
struct net_in_addr gw
Gateway.
Definition net_if.h:597
uint8_t ttl
IPv4 time-to-live.
Definition net_if.h:600
struct net_if_mcast_addr mcast[NET_IF_MAX_IPV4_MADDR]
Multicast IP addresses.
Definition net_if.h:594
Network Interface IPv6 prefixes.
Definition net_if.h:245
struct net_if * iface
Backpointer to network interface where this prefix is used.
Definition net_if.h:253
uint8_t is_infinite
Is the IP prefix valid forever.
Definition net_if.h:259
uint8_t len
Prefix length.
Definition net_if.h:256
uint8_t is_used
Is this prefix used or not.
Definition net_if.h:262
struct net_timeout lifetime
Prefix lifetime.
Definition net_if.h:247
struct net_in6_addr prefix
IPv6 prefix.
Definition net_if.h:250
uint8_t is_advertised
Is this prefix advertised in Router Advertisements.
Definition net_if.h:265
IPv6 configuration.
Definition net_if.h:387
struct net_if_ipv6_prefix prefix[NET_IF_MAX_IPV6_PREFIX]
Prefixes.
Definition net_if.h:395
uint32_t base_reachable_time
Default reachable time (RFC 4861, page-52).
Definition net_if.h:398
uint8_t hop_limit
IPv6 hop limit.
Definition net_if.h:453
struct net_if_mcast_addr mcast[NET_IF_MAX_IPV6_MADDR]
Multicast IP addresses.
Definition net_if.h:392
uint32_t retrans_timer
Retransmit timer (RFC 4861, page-52).
Definition net_if.h:404
struct net_if_addr unicast[NET_IF_MAX_IPV6_ADDR]
Unicast IP addresses.
Definition net_if.h:389
uint8_t mcast_hop_limit
IPv6 multicast hop limit.
Definition net_if.h:456
uint32_t reachable_time
Reachable time (RFC 4861, page-20).
Definition net_if.h:401
Network Interface multicast IP addresses.
Definition net_if.h:174
struct net_addr address
IP address.
Definition net_if.h:176
uint8_t is_joined
Did we join to this group.
Definition net_if.h:235
sys_snode_t rejoin_node
Rejoining multicast groups list node.
Definition net_if.h:184
atomic_t atomic_ref
Reference counter.
Definition net_if.h:181
uint8_t is_used
Is this multicast IP address used or not.
Definition net_if.h:232
Multicast monitor handler struct.
Definition net_if.h:1955
sys_snode_t node
Node information for the slist.
Definition net_if.h:1957
net_if_mcast_callback_t cb
Multicast callback.
Definition net_if.h:1963
struct net_if * iface
Network interface.
Definition net_if.h:1960
Information about routers in the system.
Definition net_if.h:275
struct net_if * iface
Network interface the router is connected to.
Definition net_if.h:283
uint8_t is_default
Is default router.
Definition net_if.h:295
uint16_t lifetime
Router lifetime.
Definition net_if.h:289
uint8_t is_infinite
Is the router valid forever.
Definition net_if.h:298
uint8_t is_used
Is this router used or not.
Definition net_if.h:292
struct net_addr address
IP address.
Definition net_if.h:280
sys_snode_t node
Slist lifetime timer node.
Definition net_if.h:277
uint32_t life_start
Router life timer start.
Definition net_if.h:286
Timestamp callback handler struct.
Definition net_if.h:3553
sys_snode_t node
Node information for the slist.
Definition net_if.h:3555
struct net_if * iface
Net interface for which the callback is needed.
Definition net_if.h:3565
struct net_pkt * pkt
Packet for which the callback is needed.
Definition net_if.h:3560
net_if_timestamp_callback_t cb
Timestamp callback.
Definition net_if.h:3568
Network Interface structure.
Definition net_if.h:875
IPv6 address struct.
Definition net_ip.h:144
IPv4 address struct.
Definition net_ip.h:156
Network L2 structure.
Definition net_l2.h:58
Hardware link address structure.
Definition net_linkaddr.h:83
Network packet.
Definition net_pkt.h:119
Generic sockaddr struct.
Definition net_ip.h:462
All network statistics in one struct.
Definition net_stats.h:423
Generic struct for handling network timeouts.
Definition net_timeout.h:57
Network traffic class.
Definition net_if.h:770
k_thread_stack_t * stack
Stack for this handler.
Definition net_if.h:784
struct k_thread handler
Traffic class handler thread.
Definition net_if.h:781
struct k_fifo fifo
Fifo for handling this Tx or Rx packet.
Definition net_if.h:772
Prometheus collector definition.
Definition collector.h:50
Type used to represent a Prometheus metric base.
Definition metric.h:47
Iterable sections helpers.