Zephyr API Documentation 4.1.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
12#ifndef ZEPHYR_INCLUDE_NET_NET_IF_H_
13#define ZEPHYR_INCLUDE_NET_NET_IF_H_
14
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
58 struct net_addr address;
59
64
65#if defined(CONFIG_NET_NATIVE_IPV6)
66 struct net_timeout lifetime;
67#endif
68
71
74
75#if defined(CONFIG_NET_NATIVE_IPV6)
76#if defined(CONFIG_NET_IPV6_PE)
80 uint32_t addr_create_time;
81
84 uint32_t addr_preferred_lifetime;
85
90 int32_t addr_timeout;
91#endif
92#endif /* CONFIG_NET_NATIVE_IPV6 */
93
94 union {
95#if defined(CONFIG_NET_IPV6_DAD)
96 struct {
98 sys_snode_t dad_node;
99
101 sys_snode_t dad_need_node;
102
104 uint32_t dad_start;
105
107 uint8_t dad_count;
108 };
109#endif /* CONFIG_NET_IPV6_DAD */
110#if defined(CONFIG_NET_IPV4_ACD)
111 struct {
113 sys_snode_t acd_node;
114
116 sys_snode_t acd_need_node;
117
119 k_timepoint_t acd_timeout;
120
122 uint8_t acd_count;
123
125 uint8_t acd_state;
126 };
127#endif /* CONFIG_NET_IPV4_ACD */
128 };
129
130#if defined(CONFIG_NET_IPV6_DAD) || defined(CONFIG_NET_IPV4_ACD)
132 uint8_t ifindex;
133#endif
134
137
140
143
148
151
152 uint8_t _unused : 3;
153};
154
162 struct net_addr address;
163
166
167#if defined(CONFIG_NET_IPV4_IGMPV3)
169 struct net_addr sources[CONFIG_NET_IF_MCAST_IPV4_SOURCE_COUNT];
170
172 uint16_t sources_len;
173
175 uint8_t record_type;
176#endif
177
180
183
184 uint8_t _unused : 6;
185};
186
195
198
200 struct net_if *iface;
201
204
207
210
211 uint8_t _unused : 6;
212};
213
222
224 struct net_addr address;
225
227 struct net_if *iface;
228
231
234
237
240
243
244 uint8_t _unused : 5;
245};
246
304
315
316#if defined(CONFIG_NET_OFFLOAD)
317struct net_offload;
318#endif /* CONFIG_NET_OFFLOAD */
319
321#if defined(CONFIG_NET_IPV6)
322#define NET_IF_MAX_IPV6_ADDR CONFIG_NET_IF_UNICAST_IPV6_ADDR_COUNT
323#define NET_IF_MAX_IPV6_MADDR CONFIG_NET_IF_MCAST_IPV6_ADDR_COUNT
324#define NET_IF_MAX_IPV6_PREFIX CONFIG_NET_IF_IPV6_PREFIX_COUNT
325#else
326#define NET_IF_MAX_IPV6_ADDR 0
327#define NET_IF_MAX_IPV6_MADDR 0
328#define NET_IF_MAX_IPV6_PREFIX 0
329#endif
330/* @endcond */
331
335 struct net_if_addr unicast[NET_IF_MAX_IPV6_ADDR];
336
338 struct net_if_mcast_addr mcast[NET_IF_MAX_IPV6_MADDR];
339
341 struct net_if_ipv6_prefix prefix[NET_IF_MAX_IPV6_PREFIX];
342
345
348
351
352#if defined(CONFIG_NET_IPV6_IID_STABLE)
354 struct net_if_addr *iid;
355
359 uint32_t network_counter;
360#endif /* CONFIG_NET_IPV6_IID_STABLE */
361
362#if defined(CONFIG_NET_IPV6_PE)
367 uint32_t desync_factor;
368#endif /* CONFIG_NET_IPV6_PE */
369
370#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
372 sys_snode_t rs_node;
373
374 /* RS start time */
375 uint32_t rs_start;
376
378 uint8_t rs_count;
379#endif
380
383
386};
387
388#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
390struct net_if_dhcpv6 {
392 sys_snode_t node;
393
395 struct net_dhcpv6_duid_storage clientid;
396
398 struct net_dhcpv6_duid_storage serverid;
399
401 enum net_dhcpv6_state state;
402
404 struct net_dhcpv6_params params;
405
407 uint64_t timeout;
408
410 uint64_t exchange_start;
411
413 uint64_t t1;
414
416 uint64_t t2;
417
421 uint64_t expire;
422
424 uint32_t addr_iaid;
425
427 uint32_t prefix_iaid;
428
430 uint32_t retransmit_timeout;
431
433 int16_t server_preference;
434
436 uint8_t retransmissions;
437
439 uint8_t tid[DHCPV6_TID_SIZE];
440
442 uint8_t prefix_len;
443
445 struct in6_addr prefix;
446
448 struct in6_addr addr;
449};
450#endif /* defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6) */
451
453#if defined(CONFIG_NET_IPV4)
454#define NET_IF_MAX_IPV4_ADDR CONFIG_NET_IF_UNICAST_IPV4_ADDR_COUNT
455#define NET_IF_MAX_IPV4_MADDR CONFIG_NET_IF_MCAST_IPV4_ADDR_COUNT
456#else
457#define NET_IF_MAX_IPV4_ADDR 0
458#define NET_IF_MAX_IPV4_MADDR 0
459#endif
473
477 struct net_if_addr_ipv4 unicast[NET_IF_MAX_IPV4_ADDR];
478
480 struct net_if_mcast_addr mcast[NET_IF_MAX_IPV4_MADDR];
481
483 struct in_addr gw;
484
487
490
491#if defined(CONFIG_NET_IPV4_ACD)
493 uint8_t conflict_cnt;
494#endif
495};
496
497#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
498struct net_if_dhcpv4 {
500 sys_snode_t node;
501
503 int64_t timer_start;
504
506 uint32_t request_time;
507
508 uint32_t xid;
509
511 uint32_t lease_time;
512
514 uint32_t renewal_time;
515
517 uint32_t rebinding_time;
518
520 struct in_addr server_id;
521
523 struct in_addr requested_ip;
524
526 struct in_addr netmask;
527
532 enum net_dhcpv4_state state;
533
535 uint8_t attempts;
536
538 struct in_addr request_server_addr;
539
541 struct in_addr response_src_addr;
542
543#ifdef CONFIG_NET_DHCPV4_OPTION_NTP_SERVER
545 struct in_addr ntp_addr;
546#endif
547};
548#endif /* CONFIG_NET_DHCPV4 */
549
550#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
551struct net_if_ipv4_autoconf {
553 struct net_if *iface;
554
556 struct in_addr requested_ip;
557
561};
562#endif /* CONFIG_NET_IPV4_AUTO */
563
565/* We always need to have at least one IP config */
566#define NET_IF_MAX_CONFIGS 1
572struct net_if_ip {
573#if defined(CONFIG_NET_IPV6)
574 struct net_if_ipv6 *ipv6;
575#endif /* CONFIG_NET_IPV6 */
576
577#if defined(CONFIG_NET_IPV4)
578 struct net_if_ipv4 *ipv4;
579#endif /* CONFIG_NET_IPV4 */
580};
581
586#if defined(CONFIG_NET_IP)
588 struct net_if_ip ip;
589#endif
590
591#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
592 struct net_if_dhcpv4 dhcpv4;
593#endif /* CONFIG_NET_DHCPV4 */
594
595#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
596 struct net_if_dhcpv6 dhcpv6;
597#endif /* CONFIG_NET_DHCPV6 */
598
599#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
600 struct net_if_ipv4_autoconf ipv4auto;
601#endif /* CONFIG_NET_IPV4_AUTO */
602
603#if defined(CONFIG_NET_L2_VIRTUAL)
608 sys_slist_t virtual_interfaces;
609#endif /* CONFIG_NET_L2_VIRTUAL */
610
611#if defined(CONFIG_NET_INTERFACE_NAME)
616 char name[CONFIG_NET_INTERFACE_NAME_LEN + 1];
617#endif
618};
619
631 struct k_fifo fifo;
632
633#if NET_TC_COUNT > 1 || defined(CONFIG_NET_TC_TX_SKIP_FOR_HIGH_PRIO) \
634 || defined(CONFIG_NET_TC_RX_SKIP_FOR_HIGH_PRIO)
636 struct k_sem fifo_slot;
637#endif
638
641
644};
645
652typedef int (*net_socket_create_t)(int, int, int);
653
670 const struct device *dev;
671
673 const struct net_l2 * const l2;
674
676 void *l2_data;
677
679 ATOMIC_DEFINE(flags, NET_IF_NUM_FLAGS);
680
683
684#if defined(CONFIG_NET_OFFLOAD)
690 struct net_offload *offload;
691#endif /* CONFIG_NET_OFFLOAD */
692
695
696#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
700 net_socket_create_t socket_offload;
701#endif /* CONFIG_NET_SOCKETS_OFFLOAD */
702
705};
706
714struct net_if {
717
718#if defined(CONFIG_NET_STATISTICS_PER_INTERFACE)
720 struct net_stats stats;
721
723 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS,
724 (struct prometheus_collector *collector);)
725#endif /* CONFIG_NET_STATISTICS_PER_INTERFACE */
726
729
730#if defined(CONFIG_NET_POWER_MANAGEMENT)
735 int tx_pending;
736#endif
737
739 struct k_mutex lock;
740
743
749
754
756 uint8_t _unused : 6;
757};
758
761static inline void net_if_lock(struct net_if *iface)
762{
763 NET_ASSERT(iface);
764
765 (void)k_mutex_lock(&iface->lock, K_FOREVER);
766}
767
768static inline void net_if_unlock(struct net_if *iface)
769{
770 NET_ASSERT(iface);
771
772 k_mutex_unlock(&iface->lock);
773}
774
775static inline bool net_if_flag_is_set(struct net_if *iface,
776 enum net_if_flag value);
777
778static inline void net_if_tx_lock(struct net_if *iface)
779{
780 NET_ASSERT(iface);
781
783 return;
784 }
785
786 (void)k_mutex_lock(&iface->tx_lock, K_FOREVER);
787}
788
789static inline void net_if_tx_unlock(struct net_if *iface)
790{
791 NET_ASSERT(iface);
792
794 return;
795 }
796
797 k_mutex_unlock(&iface->tx_lock);
798}
799
808static inline void net_if_flag_set(struct net_if *iface,
809 enum net_if_flag value)
810{
811 if (iface == NULL || iface->if_dev == NULL) {
812 return;
813 }
814
815 atomic_set_bit(iface->if_dev->flags, value);
816}
817
826static inline bool net_if_flag_test_and_set(struct net_if *iface,
827 enum net_if_flag value)
828{
829 if (iface == NULL || iface->if_dev == NULL) {
830 return false;
831 }
832
833 return atomic_test_and_set_bit(iface->if_dev->flags, value);
834}
835
842static inline void net_if_flag_clear(struct net_if *iface,
843 enum net_if_flag value)
844{
845 if (iface == NULL || iface->if_dev == NULL) {
846 return;
847 }
848
849 atomic_clear_bit(iface->if_dev->flags, value);
850}
851
860static inline bool net_if_flag_test_and_clear(struct net_if *iface,
861 enum net_if_flag value)
862{
863 if (iface == NULL || iface->if_dev == NULL) {
864 return false;
865 }
866
867 return atomic_test_and_clear_bit(iface->if_dev->flags, value);
868}
869
878static inline bool net_if_flag_is_set(struct net_if *iface,
879 enum net_if_flag value)
880{
881 if (iface == NULL || iface->if_dev == NULL) {
882 return false;
883 }
884
885 return atomic_test_bit(iface->if_dev->flags, value);
886}
887
897 struct net_if *iface, enum net_if_oper_state oper_state)
898{
899 if (iface == NULL || iface->if_dev == NULL) {
900 return NET_IF_OPER_UNKNOWN;
901 }
902
903 BUILD_ASSERT((enum net_if_oper_state)(-1) > 0 && NET_IF_OPER_UNKNOWN == 0);
904 if (oper_state <= NET_IF_OPER_UP) {
905 iface->if_dev->oper_state = oper_state;
906 }
907
908 return iface->if_dev->oper_state;
909}
910
918static inline enum net_if_oper_state net_if_oper_state(struct net_if *iface)
919{
920 if (iface == NULL || iface->if_dev == NULL) {
921 return NET_IF_OPER_UNKNOWN;
922 }
923
924 return iface->if_dev->oper_state;
925}
926
937 struct net_pkt *pkt, k_timeout_t timeout);
938
948static inline enum net_verdict net_if_send_data(struct net_if *iface,
949 struct net_pkt *pkt)
950{
952
953 return net_if_try_send_data(iface, pkt, timeout);
954}
955
963static inline const struct net_l2 *net_if_l2(struct net_if *iface)
964{
965 if (iface == NULL || iface->if_dev == NULL) {
966 return NULL;
967 }
968
969 return iface->if_dev->l2;
970}
971
980enum net_verdict net_if_recv_data(struct net_if *iface, struct net_pkt *pkt);
981
989static inline void *net_if_l2_data(struct net_if *iface)
990{
991 if (iface == NULL || iface->if_dev == NULL) {
992 return NULL;
993 }
994
995 return iface->if_dev->l2_data;
996}
997
1005static inline const struct device *net_if_get_device(struct net_if *iface)
1006{
1007 if (iface == NULL || iface->if_dev == NULL) {
1008 return NULL;
1009 }
1010
1011 return iface->if_dev->dev;
1012}
1013
1021void net_if_try_queue_tx(struct net_if *iface, struct net_pkt *pkt, k_timeout_t timeout);
1022
1030static inline void net_if_queue_tx(struct net_if *iface, struct net_pkt *pkt)
1031{
1033
1034 net_if_try_queue_tx(iface, pkt, timeout);
1035}
1036
1044static inline bool net_if_is_ip_offloaded(struct net_if *iface)
1045{
1046#if defined(CONFIG_NET_OFFLOAD)
1047 return (iface != NULL && iface->if_dev != NULL &&
1048 iface->if_dev->offload != NULL);
1049#else
1050 ARG_UNUSED(iface);
1051
1052 return false;
1053#endif
1054}
1055
1063bool net_if_is_offloaded(struct net_if *iface);
1064
1072static inline struct net_offload *net_if_offload(struct net_if *iface)
1073{
1074#if defined(CONFIG_NET_OFFLOAD)
1075 if (iface == NULL || iface->if_dev == NULL) {
1076 return NULL;
1077 }
1078
1079 return iface->if_dev->offload;
1080#else
1081 ARG_UNUSED(iface);
1082
1083 return NULL;
1084#endif
1085}
1086
1094static inline bool net_if_is_socket_offloaded(struct net_if *iface)
1095{
1096#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
1097 if (iface == NULL || iface->if_dev == NULL) {
1098 return false;
1099 }
1100
1101 return (iface->if_dev->socket_offload != NULL);
1102#else
1103 ARG_UNUSED(iface);
1104
1105 return false;
1106#endif
1107}
1108
1115static inline void net_if_socket_offload_set(
1116 struct net_if *iface, net_socket_create_t socket_offload)
1117{
1118#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
1119 if (iface == NULL || iface->if_dev == NULL) {
1120 return;
1121 }
1122
1123 iface->if_dev->socket_offload = socket_offload;
1124#else
1125 ARG_UNUSED(iface);
1126 ARG_UNUSED(socket_offload);
1127#endif
1128}
1129
1138{
1139#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
1140 if (iface == NULL || iface->if_dev == NULL) {
1141 return NULL;
1142 }
1143
1144 return iface->if_dev->socket_offload;
1145#else
1146 ARG_UNUSED(iface);
1147
1148 return NULL;
1149#endif
1150}
1151
1159static inline struct net_linkaddr *net_if_get_link_addr(struct net_if *iface)
1160{
1161 if (iface == NULL || iface->if_dev == NULL) {
1162 return NULL;
1163 }
1164
1165 return &iface->if_dev->link_addr;
1166}
1167
1175static inline struct net_if_config *net_if_get_config(struct net_if *iface)
1176{
1177 if (iface == NULL) {
1178 return NULL;
1179 }
1180
1181 return &iface->config;
1182}
1183
1189#if defined(CONFIG_NET_IPV6_DAD) && defined(CONFIG_NET_NATIVE_IPV6)
1190void net_if_start_dad(struct net_if *iface);
1191#else
1192static inline void net_if_start_dad(struct net_if *iface)
1193{
1194 ARG_UNUSED(iface);
1195}
1196#endif
1197
1203void net_if_start_rs(struct net_if *iface);
1204
1205
1211#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
1212void net_if_stop_rs(struct net_if *iface);
1213#else
1214static inline void net_if_stop_rs(struct net_if *iface)
1215{
1216 ARG_UNUSED(iface);
1217}
1218#endif /* CONFIG_NET_IPV6_ND */
1219
1232#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
1233void net_if_nbr_reachability_hint(struct net_if *iface, const struct in6_addr *ipv6_addr);
1234#else
1235static inline void net_if_nbr_reachability_hint(struct net_if *iface,
1236 const struct in6_addr *ipv6_addr)
1237{
1238 ARG_UNUSED(iface);
1239 ARG_UNUSED(ipv6_addr);
1240}
1241#endif
1242
1245static inline int net_if_set_link_addr_unlocked(struct net_if *iface,
1246 uint8_t *addr, uint8_t len,
1247 enum net_link_type type)
1248{
1249 if (net_if_flag_is_set(iface, NET_IF_RUNNING)) {
1250 return -EPERM;
1251 }
1252
1253 net_if_get_link_addr(iface)->addr = addr;
1254 net_if_get_link_addr(iface)->len = len;
1255 net_if_get_link_addr(iface)->type = type;
1256
1257 net_hostname_set_postfix(addr, len);
1258
1259 return 0;
1260}
1261
1262int net_if_set_link_addr_locked(struct net_if *iface,
1263 uint8_t *addr, uint8_t len,
1264 enum net_link_type type);
1265
1266#if CONFIG_NET_IF_LOG_LEVEL >= LOG_LEVEL_DBG
1267extern int net_if_addr_unref_debug(struct net_if *iface,
1268 sa_family_t family,
1269 const void *addr,
1270 struct net_if_addr **ifaddr,
1271 const char *caller, int line);
1272#define net_if_addr_unref(iface, family, addr, ifaddr) \
1273 net_if_addr_unref_debug(iface, family, addr, ifaddr, __func__, __LINE__)
1274
1275extern struct net_if_addr *net_if_addr_ref_debug(struct net_if *iface,
1276 sa_family_t family,
1277 const void *addr,
1278 const char *caller,
1279 int line);
1280#define net_if_addr_ref(iface, family, addr) \
1281 net_if_addr_ref_debug(iface, family, addr, __func__, __LINE__)
1282#else
1283extern int net_if_addr_unref(struct net_if *iface,
1284 sa_family_t family,
1285 const void *addr,
1286 struct net_if_addr **ifaddr);
1287extern struct net_if_addr *net_if_addr_ref(struct net_if *iface,
1288 sa_family_t family,
1289 const void *addr);
1290#endif /* CONFIG_NET_IF_LOG_LEVEL */
1291
1305static inline int net_if_set_link_addr(struct net_if *iface,
1306 uint8_t *addr, uint8_t len,
1307 enum net_link_type type)
1308{
1309#if defined(CONFIG_NET_RAW_MODE)
1310 return net_if_set_link_addr_unlocked(iface, addr, len, type);
1311#else
1312 return net_if_set_link_addr_locked(iface, addr, len, type);
1313#endif
1314}
1315
1323static inline uint16_t net_if_get_mtu(struct net_if *iface)
1324{
1325 if (iface == NULL || iface->if_dev == NULL) {
1326 return 0U;
1327 }
1328
1329 return iface->if_dev->mtu;
1330}
1331
1338static inline void net_if_set_mtu(struct net_if *iface,
1339 uint16_t mtu)
1340{
1341 if (iface == NULL || iface->if_dev == NULL) {
1342 return;
1343 }
1344
1345 iface->if_dev->mtu = mtu;
1346}
1347
1354static inline void net_if_addr_set_lf(struct net_if_addr *ifaddr,
1355 bool is_infinite)
1356{
1357 if (ifaddr == NULL) {
1358 return;
1359 }
1360
1361 ifaddr->is_infinite = is_infinite;
1362}
1363
1372
1380struct net_if *net_if_lookup_by_dev(const struct device *dev);
1381
1389static inline struct net_if_config *net_if_config_get(struct net_if *iface)
1390{
1391 if (iface == NULL) {
1392 return NULL;
1393 }
1394
1395 return &iface->config;
1396}
1397
1403void net_if_router_rm(struct net_if_router *router);
1404
1410void net_if_set_default(struct net_if *iface);
1411
1418
1427struct net_if *net_if_get_first_by_type(const struct net_l2 *l2);
1428
1436
1437#if defined(CONFIG_NET_L2_IEEE802154)
1444static inline struct net_if *net_if_get_ieee802154(void)
1445{
1446 return net_if_get_first_by_type(&NET_L2_GET_NAME(IEEE802154));
1447}
1448#endif /* CONFIG_NET_L2_IEEE802154 */
1449
1461 struct net_if_ipv6 **ipv6);
1462
1471
1481 struct net_if **iface);
1482
1492 struct in6_addr *addr);
1493
1502__syscall int net_if_ipv6_addr_lookup_by_index(const struct in6_addr *addr);
1503
1515 struct in6_addr *addr,
1517 uint32_t vlifetime);
1518
1529__syscall bool net_if_ipv6_addr_add_by_index(int index,
1530 struct in6_addr *addr,
1532 uint32_t vlifetime);
1533
1541 uint32_t vlifetime);
1542
1551bool net_if_ipv6_addr_rm(struct net_if *iface, const struct in6_addr *addr);
1552
1561__syscall bool net_if_ipv6_addr_rm_by_index(int index,
1562 const struct in6_addr *addr);
1563
1572typedef void (*net_if_ip_addr_cb_t)(struct net_if *iface,
1573 struct net_if_addr *addr,
1574 void *user_data);
1575
1585 void *user_data);
1586
1596 const struct in6_addr *addr);
1597
1606bool net_if_ipv6_maddr_rm(struct net_if *iface, const struct in6_addr *addr);
1607
1616typedef void (*net_if_ip_maddr_cb_t)(struct net_if *iface,
1617 struct net_if_mcast_addr *maddr,
1618 void *user_data);
1619
1629 void *user_data);
1630
1642 struct net_if **iface);
1643
1654typedef void (*net_if_mcast_callback_t)(struct net_if *iface,
1655 const struct net_addr *addr,
1656 bool is_joined);
1657
1676
1686 struct net_if *iface,
1688
1695
1703void net_if_mcast_monitor(struct net_if *iface, const struct net_addr *addr,
1704 bool is_joined);
1705
1713 struct net_if_mcast_addr *addr);
1714
1722static inline bool net_if_ipv6_maddr_is_joined(struct net_if_mcast_addr *addr)
1723{
1724 if (addr == NULL) {
1725 return false;
1726 }
1727
1728 return addr->is_joined;
1729}
1730
1738 struct net_if_mcast_addr *addr);
1739
1749 const struct in6_addr *addr);
1750
1761 struct in6_addr *addr,
1762 uint8_t len);
1763
1775 struct in6_addr *prefix,
1776 uint8_t len,
1778
1788bool net_if_ipv6_prefix_rm(struct net_if *iface, struct in6_addr *addr,
1789 uint8_t len);
1790
1798 bool is_infinite)
1799{
1800 prefix->is_infinite = is_infinite;
1801}
1802
1811
1818
1829bool net_if_ipv6_addr_onlink(struct net_if **iface, struct in6_addr *addr);
1830
1837#if defined(CONFIG_NET_NATIVE_IPV6)
1838static inline struct in6_addr *net_if_router_ipv6(struct net_if_router *router)
1839{
1840 if (router == NULL) {
1841 return NULL;
1842 }
1843
1844 return &router->address.in6_addr;
1845}
1846#else
1847static inline struct in6_addr *net_if_router_ipv6(struct net_if_router *router)
1848{
1849 static struct in6_addr addr;
1850
1851 ARG_UNUSED(router);
1852
1853 return &addr;
1854}
1855#endif
1856
1867 struct in6_addr *addr);
1868
1879 struct in6_addr *addr);
1880
1889
1900 struct in6_addr *addr,
1901 uint16_t router_lifetime);
1902
1911
1920#if defined(CONFIG_NET_NATIVE_IPV6)
1922#else
1924{
1925 ARG_UNUSED(iface);
1926
1927 return 0;
1928}
1929#endif /* CONFIG_NET_NATIVE_IPV6 */
1930
1937#if defined(CONFIG_NET_NATIVE_IPV6)
1938void net_if_ipv6_set_hop_limit(struct net_if *iface, uint8_t hop_limit);
1939#else
1940static inline void net_if_ipv6_set_hop_limit(struct net_if *iface,
1941 uint8_t hop_limit)
1942{
1943 ARG_UNUSED(iface);
1944 ARG_UNUSED(hop_limit);
1945}
1946#endif /* CONFIG_NET_NATIVE_IPV6 */
1947
1950/* The old hop limit setter function is deprecated because the naming
1951 * of it was incorrect. The API name was missing "_if_" so this function
1952 * should not be used.
1953 */
1954__deprecated
1955static inline void net_ipv6_set_hop_limit(struct net_if *iface,
1956 uint8_t hop_limit)
1957{
1958 net_if_ipv6_set_hop_limit(iface, hop_limit);
1959}
1960
1971#if defined(CONFIG_NET_NATIVE_IPV6)
1973#else
1975{
1976 ARG_UNUSED(iface);
1977
1978 return 0;
1979}
1980#endif /* CONFIG_NET_NATIVE_IPV6 */
1981
1988#if defined(CONFIG_NET_NATIVE_IPV6)
1989void net_if_ipv6_set_mcast_hop_limit(struct net_if *iface, uint8_t hop_limit);
1990#else
1992 uint8_t hop_limit)
1993{
1994 ARG_UNUSED(iface);
1995 ARG_UNUSED(hop_limit);
1996}
1997#endif /* CONFIG_NET_NATIVE_IPV6 */
1998
2006 uint32_t reachable_time)
2007{
2008#if defined(CONFIG_NET_NATIVE_IPV6)
2009 if (iface == NULL) {
2010 return;
2011 }
2012
2013 if (!iface->config.ip.ipv6) {
2014 return;
2015 }
2016
2017 iface->config.ip.ipv6->base_reachable_time = reachable_time;
2018#else
2019 ARG_UNUSED(iface);
2020 ARG_UNUSED(reachable_time);
2021
2022#endif
2023}
2024
2033{
2034#if defined(CONFIG_NET_NATIVE_IPV6)
2035 if (iface == NULL) {
2036 return 0;
2037 }
2038
2039 if (!iface->config.ip.ipv6) {
2040 return 0;
2041 }
2042
2043 return iface->config.ip.ipv6->reachable_time;
2044#else
2045 ARG_UNUSED(iface);
2046 return 0;
2047#endif
2048}
2049
2058
2065static inline void net_if_ipv6_set_reachable_time(struct net_if_ipv6 *ipv6)
2066{
2067#if defined(CONFIG_NET_NATIVE_IPV6)
2068 if (ipv6 == NULL) {
2069 return;
2070 }
2071
2073#else
2074 ARG_UNUSED(ipv6);
2075#endif
2076}
2077
2084static inline void net_if_ipv6_set_retrans_timer(struct net_if *iface,
2085 uint32_t retrans_timer)
2086{
2087#if defined(CONFIG_NET_NATIVE_IPV6)
2088 if (iface == NULL) {
2089 return;
2090 }
2091
2092 if (!iface->config.ip.ipv6) {
2093 return;
2094 }
2095
2096 iface->config.ip.ipv6->retrans_timer = retrans_timer;
2097#else
2098 ARG_UNUSED(iface);
2099 ARG_UNUSED(retrans_timer);
2100#endif
2101}
2102
2111{
2112#if defined(CONFIG_NET_NATIVE_IPV6)
2113 if (iface == NULL) {
2114 return 0;
2115 }
2116
2117 if (!iface->config.ip.ipv6) {
2118 return 0;
2119 }
2120
2121 return iface->config.ip.ipv6->retrans_timer;
2122#else
2123 ARG_UNUSED(iface);
2124 return 0;
2125#endif
2126}
2127
2139#if defined(CONFIG_NET_IPV6)
2140const struct in6_addr *net_if_ipv6_select_src_addr(struct net_if *iface,
2141 const struct in6_addr *dst);
2142#else
2143static inline const struct in6_addr *net_if_ipv6_select_src_addr(
2144 struct net_if *iface, const struct in6_addr *dst)
2145{
2146 ARG_UNUSED(iface);
2147 ARG_UNUSED(dst);
2148
2149 return NULL;
2150}
2151#endif
2152
2166#if defined(CONFIG_NET_IPV6)
2167const struct in6_addr *net_if_ipv6_select_src_addr_hint(struct net_if *iface,
2168 const struct in6_addr *dst,
2169 int flags);
2170#else
2171static inline const struct in6_addr *net_if_ipv6_select_src_addr_hint(
2172 struct net_if *iface, const struct in6_addr *dst, int flags)
2173{
2174 ARG_UNUSED(iface);
2175 ARG_UNUSED(dst);
2176 ARG_UNUSED(flags);
2177
2178 return NULL;
2179}
2180#endif
2181
2191#if defined(CONFIG_NET_IPV6)
2192struct net_if *net_if_ipv6_select_src_iface(const struct in6_addr *dst);
2193#else
2195 const struct in6_addr *dst)
2196{
2197 ARG_UNUSED(dst);
2198
2199 return NULL;
2200}
2201#endif
2202
2212struct in6_addr *net_if_ipv6_get_ll(struct net_if *iface,
2213 enum net_addr_state addr_state);
2214
2225 struct net_if **iface);
2226
2234void net_if_ipv6_dad_failed(struct net_if *iface, const struct in6_addr *addr);
2235
2248 struct net_if **iface);
2249
2261 struct net_if_ipv4 **ipv4);
2262
2271
2280
2287void net_if_ipv4_set_ttl(struct net_if *iface, uint8_t ttl);
2288
2297
2305
2315 struct net_if **iface);
2316
2328 struct in_addr *addr,
2330 uint32_t vlifetime);
2331
2340bool net_if_ipv4_addr_rm(struct net_if *iface, const struct in_addr *addr);
2341
2350__syscall int net_if_ipv4_addr_lookup_by_index(const struct in_addr *addr);
2351
2362__syscall bool net_if_ipv4_addr_add_by_index(int index,
2363 struct in_addr *addr,
2365 uint32_t vlifetime);
2366
2375__syscall bool net_if_ipv4_addr_rm_by_index(int index,
2376 const struct in_addr *addr);
2377
2387 void *user_data);
2388
2398 const struct in_addr *addr);
2399
2408bool net_if_ipv4_maddr_rm(struct net_if *iface, const struct in_addr *addr);
2409
2419 void *user_data);
2420
2432 struct net_if **iface);
2433
2441 struct net_if_mcast_addr *addr);
2442
2450static inline bool net_if_ipv4_maddr_is_joined(struct net_if_mcast_addr *addr)
2451{
2452 if (addr == NULL) {
2453 return false;
2454 }
2455
2456 return addr->is_joined;
2457}
2458
2466 struct net_if_mcast_addr *addr);
2467
2474#if defined(CONFIG_NET_NATIVE_IPV4)
2475static inline struct in_addr *net_if_router_ipv4(struct net_if_router *router)
2476{
2477 if (router == NULL) {
2478 return NULL;
2479 }
2480
2481 return &router->address.in_addr;
2482}
2483#else
2484static inline struct in_addr *net_if_router_ipv4(struct net_if_router *router)
2485{
2486 static struct in_addr addr;
2487
2488 ARG_UNUSED(router);
2489
2490 return &addr;
2491}
2492#endif
2493
2504 struct in_addr *addr);
2505
2516 struct in_addr *addr);
2528 struct in_addr *addr,
2529 bool is_default,
2530 uint16_t router_lifetime);
2531
2540
2550 const struct in_addr *addr);
2551
2561 const struct in_addr *addr);
2562
2572#if defined(CONFIG_NET_IPV4)
2573struct net_if *net_if_ipv4_select_src_iface(const struct in_addr *dst);
2574#else
2576 const struct in_addr *dst)
2577{
2578 ARG_UNUSED(dst);
2579
2580 return NULL;
2581}
2582#endif
2583
2595#if defined(CONFIG_NET_IPV4)
2596const struct in_addr *net_if_ipv4_select_src_addr(struct net_if *iface,
2597 const struct in_addr *dst);
2598#else
2599static inline const struct in_addr *net_if_ipv4_select_src_addr(
2600 struct net_if *iface, const struct in_addr *dst)
2601{
2602 ARG_UNUSED(iface);
2603 ARG_UNUSED(dst);
2604
2605 return NULL;
2606}
2607#endif
2608
2618struct in_addr *net_if_ipv4_get_ll(struct net_if *iface,
2619 enum net_addr_state addr_state);
2620
2631 enum net_addr_state addr_state);
2632
2643 const struct in_addr *addr);
2644
2654__deprecated struct in_addr net_if_ipv4_get_netmask(struct net_if *iface);
2655
2664__deprecated void net_if_ipv4_set_netmask(struct net_if *iface,
2665 const struct in_addr *netmask);
2666
2677__deprecated __syscall bool net_if_ipv4_set_netmask_by_index(int index,
2678 const struct in_addr *netmask);
2679
2690 const struct in_addr *addr,
2691 const struct in_addr *netmask);
2692
2703 const struct in_addr *addr,
2704 const struct in_addr *netmask);
2705
2713struct in_addr net_if_ipv4_get_gw(struct net_if *iface);
2714
2721void net_if_ipv4_set_gw(struct net_if *iface, const struct in_addr *gw);
2722
2731__syscall bool net_if_ipv4_set_gw_by_index(int index, const struct in_addr *gw);
2732
2743struct net_if *net_if_select_src_iface(const struct sockaddr *dst);
2744
2753typedef void (*net_if_link_callback_t)(struct net_if *iface,
2754 struct net_linkaddr *dst,
2755 int status);
2756
2772
2781
2788
2796void net_if_call_link_cb(struct net_if *iface, struct net_linkaddr *lladdr,
2797 int status);
2798
2801/* used to ensure encoding of checksum support in net_if.h and
2802 * ethernet.h is the same
2803 */
2804#define NET_IF_CHECKSUM_NONE_BIT 0
2805#define NET_IF_CHECKSUM_IPV4_HEADER_BIT BIT(0)
2806#define NET_IF_CHECKSUM_IPV4_ICMP_BIT BIT(1)
2807/* Space for future protocols and restrictions for IPV4 */
2808#define NET_IF_CHECKSUM_IPV6_HEADER_BIT BIT(10)
2809#define NET_IF_CHECKSUM_IPV6_ICMP_BIT BIT(11)
2810/* Space for future protocols and restrictions for IPV6 */
2811#define NET_IF_CHECKSUM_TCP_BIT BIT(21)
2812#define NET_IF_CHECKSUM_UDP_BIT BIT(22)
2813
2821 NET_IF_CHECKSUM_IPV4_HEADER = NET_IF_CHECKSUM_IPV4_HEADER_BIT,
2823 NET_IF_CHECKSUM_IPV4_TCP = NET_IF_CHECKSUM_IPV4_HEADER_BIT |
2824 NET_IF_CHECKSUM_TCP_BIT,
2826 NET_IF_CHECKSUM_IPV4_UDP = NET_IF_CHECKSUM_IPV4_HEADER_BIT |
2827 NET_IF_CHECKSUM_UDP_BIT,
2829 NET_IF_CHECKSUM_IPV4_ICMP = NET_IF_CHECKSUM_IPV4_ICMP_BIT,
2831 NET_IF_CHECKSUM_IPV6_HEADER = NET_IF_CHECKSUM_IPV6_HEADER_BIT,
2833 NET_IF_CHECKSUM_IPV6_TCP = NET_IF_CHECKSUM_IPV6_HEADER_BIT |
2834 NET_IF_CHECKSUM_TCP_BIT,
2836 NET_IF_CHECKSUM_IPV6_UDP = NET_IF_CHECKSUM_IPV6_HEADER_BIT |
2837 NET_IF_CHECKSUM_UDP_BIT,
2839 NET_IF_CHECKSUM_IPV6_ICMP = NET_IF_CHECKSUM_IPV6_ICMP_BIT
2841
2853 enum net_if_checksum_type chksum_type);
2854
2867 enum net_if_checksum_type chksum_type);
2868
2879__syscall struct net_if *net_if_get_by_index(int index);
2880
2888int net_if_get_by_iface(struct net_if *iface);
2889
2897typedef void (*net_if_cb_t)(struct net_if *iface, void *user_data);
2898
2906void net_if_foreach(net_if_cb_t cb, void *user_data);
2907
2915int net_if_up(struct net_if *iface);
2916
2924static inline bool net_if_is_up(struct net_if *iface)
2925{
2926 if (iface == NULL) {
2927 return false;
2928 }
2929
2930 return net_if_flag_is_set(iface, NET_IF_UP) &&
2932}
2933
2941int net_if_down(struct net_if *iface);
2942
2950static inline bool net_if_is_admin_up(struct net_if *iface)
2951{
2952 if (iface == NULL) {
2953 return false;
2954 }
2955
2956 return net_if_flag_is_set(iface, NET_IF_UP);
2957}
2958
2967void net_if_carrier_on(struct net_if *iface);
2968
2977void net_if_carrier_off(struct net_if *iface);
2978
2986static inline bool net_if_is_carrier_ok(struct net_if *iface)
2987{
2988 if (iface == NULL) {
2989 return false;
2990 }
2991
2992 return net_if_flag_is_set(iface, NET_IF_LOWER_UP);
2993}
2994
3005void net_if_dormant_on(struct net_if *iface);
3006
3015void net_if_dormant_off(struct net_if *iface);
3016
3024static inline bool net_if_is_dormant(struct net_if *iface)
3025{
3026 if (iface == NULL) {
3027 return false;
3028 }
3029
3030 return net_if_flag_is_set(iface, NET_IF_DORMANT);
3031}
3032
3033#if defined(CONFIG_NET_PKT_TIMESTAMP) && defined(CONFIG_NET_NATIVE)
3041typedef void (*net_if_timestamp_callback_t)(struct net_pkt *pkt);
3042
3051struct net_if_timestamp_cb {
3053 sys_snode_t node;
3054
3058 struct net_pkt *pkt;
3059
3063 struct net_if *iface;
3064
3066 net_if_timestamp_callback_t cb;
3067};
3068
3079void net_if_register_timestamp_cb(struct net_if_timestamp_cb *handle,
3080 struct net_pkt *pkt,
3081 struct net_if *iface,
3082 net_if_timestamp_callback_t cb);
3083
3089void net_if_unregister_timestamp_cb(struct net_if_timestamp_cb *handle);
3090
3096void net_if_call_timestamp_cb(struct net_pkt *pkt);
3097
3098/*
3099 * @brief Add timestamped TX buffer to be handled
3100 *
3101 * @param pkt Timestamped buffer
3102 */
3103void net_if_add_tx_timestamp(struct net_pkt *pkt);
3104#endif /* CONFIG_NET_PKT_TIMESTAMP */
3105
3115#if defined(CONFIG_NET_PROMISCUOUS_MODE)
3116int net_if_set_promisc(struct net_if *iface);
3117#else
3118static inline int net_if_set_promisc(struct net_if *iface)
3119{
3120 ARG_UNUSED(iface);
3121
3122 return -ENOTSUP;
3123}
3124#endif
3125
3131#if defined(CONFIG_NET_PROMISCUOUS_MODE)
3132void net_if_unset_promisc(struct net_if *iface);
3133#else
3134static inline void net_if_unset_promisc(struct net_if *iface)
3135{
3136 ARG_UNUSED(iface);
3137}
3138#endif
3139
3148#if defined(CONFIG_NET_PROMISCUOUS_MODE)
3149bool net_if_is_promisc(struct net_if *iface);
3150#else
3151static inline bool net_if_is_promisc(struct net_if *iface)
3152{
3153 ARG_UNUSED(iface);
3154
3155 return false;
3156}
3157#endif
3158
3168static inline bool net_if_are_pending_tx_packets(struct net_if *iface)
3169{
3170#if defined(CONFIG_NET_POWER_MANAGEMENT)
3171 return !!iface->tx_pending;
3172#else
3173 ARG_UNUSED(iface);
3174
3175 return false;
3176#endif
3177}
3178
3179#ifdef CONFIG_NET_POWER_MANAGEMENT
3187int net_if_suspend(struct net_if *iface);
3188
3196int net_if_resume(struct net_if *iface);
3197
3205bool net_if_is_suspended(struct net_if *iface);
3206#endif /* CONFIG_NET_POWER_MANAGEMENT */
3207
3215bool net_if_is_wifi(struct net_if *iface);
3216
3223
3230
3237
3252int net_if_get_name(struct net_if *iface, char *buf, int len);
3253
3268int net_if_set_name(struct net_if *iface, const char *buf);
3269
3277int net_if_get_by_name(const char *name);
3278
3280struct net_if_api {
3281 void (*init)(struct net_if *iface);
3282};
3283
3284#define NET_IF_DHCPV4_INIT \
3285 IF_ENABLED(UTIL_AND(IS_ENABLED(CONFIG_NET_DHCPV4), \
3286 IS_ENABLED(CONFIG_NET_NATIVE_IPV4)), \
3287 (.dhcpv4.state = NET_DHCPV4_DISABLED,))
3288
3289#define NET_IF_DHCPV6_INIT \
3290 IF_ENABLED(UTIL_AND(IS_ENABLED(CONFIG_NET_DHCPV6), \
3291 IS_ENABLED(CONFIG_NET_NATIVE_IPV6)), \
3292 (.dhcpv6.state = NET_DHCPV6_DISABLED,))
3293
3294#define NET_IF_CONFIG_INIT \
3295 .config = { \
3296 IF_ENABLED(CONFIG_NET_IP, (.ip = {},)) \
3297 NET_IF_DHCPV4_INIT \
3298 NET_IF_DHCPV6_INIT \
3299 }
3300
3301#define NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, sfx) \
3302 net_stats_##dev_id##_##sfx##_collector
3303#define NET_PROMETHEUS_INIT(dev_id, sfx) \
3304 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS, \
3305 (.collector = &NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, sfx),))
3306
3307#define NET_IF_GET_NAME(dev_id, sfx) __net_if_##dev_id##_##sfx
3308#define NET_IF_DEV_GET_NAME(dev_id, sfx) __net_if_dev_##dev_id##_##sfx
3309
3310#define NET_IF_GET(dev_id, sfx) \
3311 ((struct net_if *)&NET_IF_GET_NAME(dev_id, sfx))
3312
3313#if defined(CONFIG_NET_STATISTICS_VIA_PROMETHEUS)
3314extern int net_stats_prometheus_scrape(struct prometheus_collector *collector,
3315 struct prometheus_metric *metric,
3316 void *user_data);
3317#endif /* CONFIG_NET_STATISTICS_VIA_PROMETHEUS */
3318
3319#define NET_IF_INIT(dev_id, sfx, _l2, _mtu, _num_configs) \
3320 static STRUCT_SECTION_ITERABLE(net_if_dev, \
3321 NET_IF_DEV_GET_NAME(dev_id, sfx)) = { \
3322 .dev = &(DEVICE_NAME_GET(dev_id)), \
3323 .l2 = &(NET_L2_GET_NAME(_l2)), \
3324 .l2_data = &(NET_L2_GET_DATA(dev_id, sfx)), \
3325 .mtu = _mtu, \
3326 .flags = {BIT(NET_IF_LOWER_UP)}, \
3327 }; \
3328 static Z_DECL_ALIGN(struct net_if) \
3329 NET_IF_GET_NAME(dev_id, sfx)[_num_configs] \
3330 __used __noasan __in_section(_net_if, static, \
3331 dev_id) = { \
3332 [0 ... (_num_configs - 1)] = { \
3333 .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)), \
3334 NET_IF_CONFIG_INIT \
3335 } \
3336 }; \
3337 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS, \
3338 (static PROMETHEUS_COLLECTOR_DEFINE( \
3339 NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, \
3340 sfx), \
3341 net_stats_prometheus_scrape, \
3342 NET_IF_GET(dev_id, sfx)); \
3343 NET_STATS_PROMETHEUS(NET_IF_GET(dev_id, sfx), \
3344 dev_id, sfx);))
3345
3346#define NET_IF_OFFLOAD_INIT(dev_id, sfx, _mtu) \
3347 static STRUCT_SECTION_ITERABLE(net_if_dev, \
3348 NET_IF_DEV_GET_NAME(dev_id, sfx)) = { \
3349 .dev = &(DEVICE_NAME_GET(dev_id)), \
3350 .mtu = _mtu, \
3351 .l2 = &(NET_L2_GET_NAME(OFFLOADED_NETDEV)), \
3352 .flags = {BIT(NET_IF_LOWER_UP)}, \
3353 }; \
3354 static Z_DECL_ALIGN(struct net_if) \
3355 NET_IF_GET_NAME(dev_id, sfx)[NET_IF_MAX_CONFIGS] \
3356 __used __in_section(_net_if, static, \
3357 dev_id) = { \
3358 [0 ... (NET_IF_MAX_CONFIGS - 1)] = { \
3359 .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)), \
3360 NET_IF_CONFIG_INIT \
3361 } \
3362 }; \
3363 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS, \
3364 (static PROMETHEUS_COLLECTOR_DEFINE( \
3365 NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, \
3366 sfx), \
3367 net_stats_prometheus_scrape, \
3368 NET_IF_GET(dev_id, sfx)); \
3369 NET_STATS_PROMETHEUS(NET_IF_GET(dev_id, sfx), \
3370 dev_id, sfx);))
3371
3372
3375/* Network device initialization macros */
3376
3377#define Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, instance, \
3378 init_fn, pm, data, config, prio, \
3379 api, l2, l2_ctx_type, mtu) \
3380 Z_DEVICE_STATE_DEFINE(dev_id); \
3381 Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, NULL, \
3382 Z_DEVICE_DT_FLAGS(node_id), pm, data, \
3383 config, POST_KERNEL, prio, api, \
3384 &Z_DEVICE_STATE_NAME(dev_id)); \
3385 NET_L2_DATA_INIT(dev_id, instance, l2_ctx_type); \
3386 NET_IF_INIT(dev_id, instance, l2, mtu, NET_IF_MAX_CONFIGS)
3387
3388#define Z_NET_DEVICE_INIT(node_id, dev_id, name, init_fn, pm, data, \
3389 config, prio, api, l2, l2_ctx_type, mtu) \
3390 Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, 0, init_fn, \
3391 pm, data, config, prio, api, l2, \
3392 l2_ctx_type, mtu)
3393
3413#define NET_DEVICE_INIT(dev_id, name, init_fn, pm, data, config, prio, \
3414 api, l2, l2_ctx_type, mtu) \
3415 Z_NET_DEVICE_INIT(DT_INVALID_NODE, dev_id, name, init_fn, pm, \
3416 data, config, prio, api, l2, l2_ctx_type, mtu)
3417
3436#define NET_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, \
3437 config, prio, api, l2, l2_ctx_type, mtu) \
3438 Z_NET_DEVICE_INIT(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
3439 DEVICE_DT_NAME(node_id), init_fn, pm, data, \
3440 config, prio, api, l2, l2_ctx_type, mtu)
3441
3450#define NET_DEVICE_DT_INST_DEFINE(inst, ...) \
3451 NET_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
3452
3476#define NET_DEVICE_INIT_INSTANCE(dev_id, name, instance, init_fn, pm, \
3477 data, config, prio, api, l2, \
3478 l2_ctx_type, mtu) \
3479 Z_NET_DEVICE_INIT_INSTANCE(DT_INVALID_NODE, dev_id, name, \
3480 instance, init_fn, pm, data, config, \
3481 prio, api, l2, l2_ctx_type, mtu)
3482
3505#define NET_DEVICE_DT_DEFINE_INSTANCE(node_id, instance, init_fn, pm, \
3506 data, config, prio, api, l2, \
3507 l2_ctx_type, mtu) \
3508 Z_NET_DEVICE_INIT_INSTANCE(node_id, \
3509 Z_DEVICE_DT_DEV_ID(node_id), \
3510 DEVICE_DT_NAME(node_id), instance, \
3511 init_fn, pm, data, config, prio, \
3512 api, l2, l2_ctx_type, mtu)
3513
3523#define NET_DEVICE_DT_INST_DEFINE_INSTANCE(inst, ...) \
3524 NET_DEVICE_DT_DEFINE_INSTANCE(DT_DRV_INST(inst), __VA_ARGS__)
3525
3526#define Z_NET_DEVICE_OFFLOAD_INIT(node_id, dev_id, name, init_fn, pm, \
3527 data, config, prio, api, mtu) \
3528 Z_DEVICE_STATE_DEFINE(dev_id); \
3529 Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, NULL, \
3530 Z_DEVICE_DT_FLAGS(node_id), pm, data, \
3531 config, POST_KERNEL, prio, api, \
3532 &Z_DEVICE_STATE_NAME(dev_id)); \
3533 NET_IF_OFFLOAD_INIT(dev_id, 0, mtu)
3534
3554#define NET_DEVICE_OFFLOAD_INIT(dev_id, name, init_fn, pm, data, \
3555 config, prio, api, mtu) \
3556 Z_NET_DEVICE_OFFLOAD_INIT(DT_INVALID_NODE, dev_id, name, \
3557 init_fn, pm, data, config, prio, api, \
3558 mtu)
3559
3578#define NET_DEVICE_DT_OFFLOAD_DEFINE(node_id, init_fn, pm, data, \
3579 config, prio, api, mtu) \
3580 Z_NET_DEVICE_OFFLOAD_INIT(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
3581 DEVICE_DT_NAME(node_id), init_fn, pm, \
3582 data, config, prio, api, mtu)
3583
3593#define NET_DEVICE_DT_INST_OFFLOAD_DEFINE(inst, ...) \
3594 NET_DEVICE_DT_OFFLOAD_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
3595
3601#define NET_IFACE_COUNT(_dst) \
3602 do { \
3603 extern struct net_if _net_if_list_start[]; \
3604 extern struct net_if _net_if_list_end[]; \
3605 *(_dst) = ((uintptr_t)_net_if_list_end - \
3606 (uintptr_t)_net_if_list_start) / \
3607 sizeof(struct net_if); \
3608 } while (0)
3609
3610#ifdef __cplusplus
3611}
3612#endif
3613
3614#include <zephyr/syscalls/net_if.h>
3615
3620#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:46
long atomic_t
Definition atomic_types.h:15
Prometheus collector APIs.
DHCPv4 Client Handler.
DHCPv6 client.
static void atomic_set_bit(atomic_t *target, int bit)
Atomically set a bit.
Definition atomic.h:209
static bool atomic_test_bit(const atomic_t *target, int bit)
Atomically get and test a bit.
Definition atomic.h:127
static void atomic_clear_bit(atomic_t *target, int bit)
Atomically clear a bit.
Definition atomic.h:191
#define ATOMIC_DEFINE(name, num_bits)
Define an array of atomic variables.
Definition atomic.h:111
static bool atomic_test_and_clear_bit(atomic_t *target, int bit)
Atomically clear a bit and test it.
Definition atomic.h:147
static bool atomic_test_and_set_bit(atomic_t *target, int bit)
Atomically set a bit and test it.
Definition atomic.h:170
#define K_FOREVER
Generate infinite timeout delay.
Definition kernel.h:1468
#define K_NO_WAIT
Generate null timeout delay.
Definition kernel.h:1358
unsigned short int sa_family_t
Socket address family type.
Definition net_ip.h:168
net_addr_state
What is the current state of the network address.
Definition net_ip.h:526
net_addr_type
How the network address is assigned to network interface.
Definition net_ip.h:534
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:103
static int net_hostname_set_postfix(const uint8_t *hostname_postfix, int postfix_len)
Set the device hostname postfix.
Definition hostname.h:113
struct net_if * net_if_select_src_iface(const struct sockaddr *dst)
Get a network interface that should be used when sending IPv6 or IPv4 network data to destination.
struct net_if_router * net_if_ipv4_router_lookup(struct net_if *iface, struct in_addr *addr)
Check if IPv4 address is one of the routers configured in the system.
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.
struct net_if_addr * net_if_ipv4_addr_lookup(const struct in_addr *addr, struct net_if **iface)
Check if this IPv4 address belongs to one of the interfaces.
int net_if_set_name(struct net_if *iface, const char *buf)
Set network interface name.
static bool net_if_is_carrier_ok(struct net_if *iface)
Check if carrier is present on network device.
Definition net_if.h:2986
static bool net_if_is_admin_up(struct net_if *iface)
Check if interface was brought up by the administrator.
Definition net_if.h:2950
void net_if_set_default(struct net_if *iface)
Set the default network interface.
int net_if_ipv4_addr_lookup_by_index(const struct in_addr *addr)
Check if this IPv4 address belongs to one of the interface indices.
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:1654
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:2753
struct net_if * net_if_get_wifi_sta(void)
Get Wi-Fi network station interface.
struct net_if_addr * net_if_ipv6_addr_lookup(const struct in6_addr *addr, struct net_if **iface)
Check if this IPv6 address belongs to one of the interfaces.
void net_if_ipv4_maddr_leave(struct net_if *iface, struct net_if_mcast_addr *addr)
Mark a given multicast address to be left.
int net_if_ipv6_addr_lookup_by_index(const struct in6_addr *addr)
Check if this IPv6 address belongs to one of the interface indices.
int net_if_get_by_name(const char *name)
Get interface index according to its name.
struct net_if * net_if_get_by_link_addr(struct net_linkaddr *ll_addr)
Get an interface according to link layer address.
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.
bool net_if_ipv4_maddr_rm(struct net_if *iface, const struct in_addr *addr)
Remove an IPv4 multicast address from an interface.
void net_if_ipv6_dad_failed(struct net_if *iface, const struct in6_addr *addr)
Stop IPv6 Duplicate Address Detection (DAD) procedure if we find out that our IPv6 address is already...
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:896
int net_if_down(struct net_if *iface)
Bring interface down.
struct net_if_router * net_if_ipv4_router_find_default(struct net_if *iface, struct in_addr *addr)
Find default router for this IPv4 address.
bool net_if_ipv6_addr_onlink(struct net_if **iface, struct in6_addr *addr)
Check if this IPv6 address is part of the subnet of our network interface.
static struct in_addr * net_if_router_ipv4(struct net_if_router *router)
Get the IPv4 address of the given router.
Definition net_if.h:2484
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:1030
void net_if_ipv6_prefix_unset_timer(struct net_if_ipv6_prefix *prefix)
Unset the prefix lifetime timer.
struct net_if_ipv6_prefix * net_if_ipv6_prefix_add(struct net_if *iface, struct in6_addr *prefix, uint8_t len, uint32_t lifetime)
Add a IPv6 prefix to an network interface.
void net_if_ipv4_set_gw(struct net_if *iface, const struct in_addr *gw)
Set IPv4 gateway for an interface.
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.
struct net_if_router * net_if_ipv6_router_find_default(struct net_if *iface, struct in6_addr *addr)
Find default router for this IPv6 address.
bool net_if_ipv6_prefix_rm(struct net_if *iface, struct in6_addr *addr, uint8_t len)
Remove an IPv6 prefix from an interface.
void net_if_mcast_monitor(struct net_if *iface, const struct net_addr *addr, bool is_joined)
Call registered multicast monitors.
static void * net_if_l2_data(struct net_if *iface)
Get a pointer to the interface L2 private data.
Definition net_if.h:989
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:3168
struct in_addr net_if_ipv4_get_netmask(struct net_if *iface)
Get IPv4 netmask of an interface.
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:826
bool net_if_ipv4_addr_rm(struct net_if *iface, const struct in_addr *addr)
Remove a IPv4 address from an interface.
struct net_if_router * net_if_ipv4_router_add(struct net_if *iface, struct in_addr *addr, bool is_default, uint16_t router_lifetime)
Add IPv4 router to the system.
static struct net_linkaddr * net_if_get_link_addr(struct net_if *iface)
Get an network interface's link address.
Definition net_if.h:1159
void net_if_ipv6_maddr_join(struct net_if *iface, struct net_if_mcast_addr *addr)
Mark a given multicast address to be joined.
static const struct in6_addr * net_if_ipv6_select_src_addr(struct net_if *iface, const struct in6_addr *dst)
Get a IPv6 source address that should be used when sending network data to destination.
Definition net_if.h:2143
static void net_if_nbr_reachability_hint(struct net_if *iface, const struct in6_addr *ipv6_addr)
Provide a reachability hint for IPv6 Neighbor Discovery.
Definition net_if.h:1235
static struct net_offload * net_if_offload(struct net_if *iface)
Return the IP offload plugin.
Definition net_if.h:1072
static int net_if_set_link_addr(struct net_if *iface, uint8_t *addr, uint8_t len, enum net_link_type type)
Set a network interface's link address.
Definition net_if.h:1305
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:808
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.
bool net_if_ipv4_addr_mask_cmp(struct net_if *iface, const struct in_addr *addr)
Check if the given IPv4 address belongs to local subnet.
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:1974
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:1940
static const struct in6_addr * net_if_ipv6_select_src_addr_hint(struct net_if *iface, const struct in6_addr *dst, int flags)
Get a IPv6 source address that should be used when sending network data to destination.
Definition net_if.h:2171
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.
int net_if_get_name(struct net_if *iface, char *buf, int len)
Get network interface name.
bool net_if_ipv6_addr_rm(struct net_if *iface, const struct in6_addr *addr)
Remove an IPv6 address from an interface.
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:1923
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:1044
static bool net_if_is_dormant(struct net_if *iface)
Check if the interface is dormant.
Definition net_if.h:3024
struct net_if * net_if_get_first_wifi(void)
Get first Wi-Fi network interface.
struct net_if_addr * net_if_ipv4_addr_add(struct net_if *iface, struct in_addr *addr, enum net_addr_type addr_type, uint32_t vlifetime)
Add a IPv4 address to an interface.
uint8_t net_if_ipv4_get_mcast_ttl(struct net_if *iface)
Get IPv4 multicast time-to-live value specified for a given 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:1616
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.
static void net_if_set_mtu(struct net_if *iface, uint16_t mtu)
Set an network interface's MTU.
Definition net_if.h:1338
struct net_if_mcast_addr * net_if_ipv6_maddr_add(struct net_if *iface, const struct in6_addr *addr)
Add a IPv6 multicast address to an interface.
bool net_if_ipv4_set_netmask_by_addr(struct net_if *iface, const struct in_addr *addr, const struct in_addr *netmask)
Set IPv4 netmask for an interface index for a given address.
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:2924
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.
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:2065
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:948
struct 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_ipv4_put(struct net_if *iface)
Release network interface IPv4 config.
bool net_if_ipv4_set_netmask_by_addr_by_index(int index, const struct in_addr *addr, const struct in_addr *netmask)
Set IPv4 netmask for an interface index for a given address.
void net_if_dormant_on(struct net_if *iface)
Mark interface as dormant.
int net_if_config_ipv6_put(struct net_if *iface)
Release network interface IPv6 config.
net_if_checksum_type
Type of checksum for which support in the interface will be queried.
Definition net_if.h:2819
bool net_if_ipv4_is_addr_bcast(struct net_if *iface, const struct in_addr *addr)
Check if the given IPv4 address is a broadcast address.
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.
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.
bool net_if_ipv4_set_netmask_by_index(int index, const struct in_addr *netmask)
Set IPv4 netmask for an interface index.
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.
static void net_if_start_dad(struct net_if *iface)
Start duplicate address detection procedure.
Definition net_if.h:1192
void net_if_foreach(net_if_cb_t cb, void *user_data)
Go through all the network interfaces and call callback for each interface.
bool net_if_ipv6_addr_add_by_index(int index, struct in6_addr *addr, enum net_addr_type addr_type, uint32_t vlifetime)
Add a IPv6 address to an interface by index.
struct net_if_router * net_if_ipv6_router_add(struct net_if *iface, struct in6_addr *addr, uint16_t router_lifetime)
Add IPv6 router to the system.
static void net_if_unset_promisc(struct net_if *iface)
Set network interface into normal mode.
Definition net_if.h:3134
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:1115
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:2032
static bool net_if_is_promisc(struct net_if *iface)
Check if promiscuous mode is set or not.
Definition net_if.h:3151
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:2450
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:1797
struct net_if_mcast_addr * net_if_ipv4_maddr_add(struct net_if *iface, const struct in_addr *addr)
Add a IPv4 multicast address to an interface.
bool net_if_is_wifi(struct net_if *iface)
Check if the network interface supports Wi-Fi.
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.
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_if_ipv6_prefix * net_if_ipv6_prefix_lookup(struct net_if *iface, struct in6_addr *addr, uint8_t len)
Check if this IPv6 prefix belongs to this interface.
static void net_if_stop_rs(struct net_if *iface)
Stop neighbor discovery.
Definition net_if.h:1214
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:2005
struct net_if_addr * net_if_ipv6_addr_lookup_by_iface(struct net_if *iface, struct in6_addr *addr)
Check if this IPv6 address belongs to this specific interfaces.
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:1572
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...
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:860
void net_if_start_rs(struct net_if *iface)
Start neighbor discovery and send router solicitation message.
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:1722
bool net_if_ipv6_addr_rm_by_index(int index, const struct in6_addr *addr)
Remove an IPv6 address from an interface by index.
void(* net_if_cb_t)(struct net_if *iface, void *user_data)
Callback used while iterating over network interfaces.
Definition net_if.h:2897
bool net_if_ipv4_addr_rm_by_index(int index, const struct in_addr *addr)
Remove a IPv4 address from an interface by interface index.
struct 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 uint16_t net_if_get_mtu(struct net_if *iface)
Get an network interface's MTU.
Definition net_if.h:1323
struct net_if_router * net_if_ipv6_router_lookup(struct net_if *iface, struct in6_addr *addr)
Check if IPv6 address is one of the routers configured in the system.
bool net_if_ipv4_addr_add_by_index(int index, struct in_addr *addr, enum net_addr_type addr_type, uint32_t vlifetime)
Add a IPv4 address to an interface by network interface index.
void net_if_ipv6_maddr_leave(struct net_if *iface, struct net_if_mcast_addr *addr)
Mark a given multicast address to be left.
struct 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.
void net_if_mcast_mon_unregister(struct net_if_mcast_monitor *mon)
Unregister a multicast monitor.
void net_if_ipv4_set_netmask(struct net_if *iface, const struct in_addr *netmask)
Set IPv4 netmask for an interface.
static const struct in_addr * net_if_ipv4_select_src_addr(struct net_if *iface, const struct in_addr *dst)
Get a IPv4 source address that should be used when sending network data to destination.
Definition net_if.h:2599
struct 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.
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:2084
struct in_addr * net_if_ipv4_get_global_addr(struct net_if *iface, enum net_addr_state addr_state)
Get a IPv4 global address in a given state.
struct net_if_mcast_addr * net_if_ipv6_maddr_lookup(const struct in6_addr *addr, struct net_if **iface)
Check if this IPv6 multicast address belongs to a specific interface or one of the interfaces.
struct net_if * net_if_lookup_by_dev(const struct device *dev)
Find an interface from it's related device.
static struct in6_addr * net_if_router_ipv6(struct net_if_router *router)
Get the IPv6 address of the given router.
Definition net_if.h:1847
struct net_if_mcast_addr * net_if_ipv4_maddr_lookup(const struct in_addr *addr, struct net_if **iface)
Check if this IPv4 multicast address belongs to a specific interface or one of the interfaces.
void net_if_router_rm(struct net_if_router *router)
Remove a router from the system.
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:2110
bool net_if_ipv4_set_gw_by_index(int index, const struct in_addr *gw)
Set IPv4 gateway for an interface index.
struct in_addr net_if_ipv4_get_netmask_by_addr(struct net_if *iface, const struct in_addr *addr)
Get IPv4 netmask related to an address of an interface.
net_if_oper_state
Network interface operational status (RFC 2863).
Definition net_if.h:306
struct net_if_addr * net_if_ipv6_addr_add(struct net_if *iface, struct in6_addr *addr, enum net_addr_type addr_type, uint32_t vlifetime)
Add a IPv6 address to an interface.
static struct net_if * net_if_ipv6_select_src_iface(const struct in6_addr *dst)
Get a network interface that should be used when sending IPv6 network data to destination.
Definition net_if.h:2194
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:878
static struct net_if_config * net_if_config_get(struct net_if *iface)
Get network interface IP config.
Definition net_if.h:1389
static struct net_if_config * net_if_get_config(struct net_if *iface)
Return network configuration for this network interface.
Definition net_if.h:1175
void net_if_ipv4_maddr_join(struct net_if *iface, struct net_if_mcast_addr *addr)
Mark a given multicast address to be joined.
struct in_addr net_if_ipv4_get_gw(struct net_if *iface)
Get IPv4 gateway of an interface.
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:1354
net_if_flag
Network interface flags.
Definition net_if.h:248
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...
struct net_if_ipv6_prefix * net_if_ipv6_prefix_get(struct net_if *iface, const struct in6_addr *addr)
Return prefix that corresponds to this IPv6 address.
static const struct device * net_if_get_device(struct net_if *iface)
Get an network interface's device.
Definition net_if.h:1005
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:652
void net_if_ipv6_addr_update_lifetime(struct net_if_addr *ifaddr, uint32_t vlifetime)
Update validity lifetime time of an IPv6 address.
bool net_if_ipv6_maddr_rm(struct net_if *iface, const struct in6_addr *addr)
Remove an IPv6 multicast address from an interface.
static bool net_if_is_socket_offloaded(struct net_if *iface)
Return the socket offload status.
Definition net_if.h:1094
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:1991
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:3118
static const struct net_l2 * net_if_l2(struct net_if *iface)
Get a pointer to the interface L2.
Definition net_if.h:963
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:1137
static struct net_if * net_if_ipv4_select_src_iface(const struct in_addr *dst)
Get a network interface that should be used when sending IPv4 network data to destination.
Definition net_if.h:2575
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:842
@ NET_IF_CHECKSUM_IPV4_ICMP
Interface supports checksum calculation for ICMP4 payload in IPv4.
Definition net_if.h:2829
@ NET_IF_CHECKSUM_IPV6_TCP
Interface supports checksum calculation for TCP payload in IPv6.
Definition net_if.h:2833
@ NET_IF_CHECKSUM_IPV6_UDP
Interface supports checksum calculation for UDP payload in IPv6.
Definition net_if.h:2836
@ NET_IF_CHECKSUM_IPV4_HEADER
Interface supports IP version 4 header checksum calculation.
Definition net_if.h:2821
@ NET_IF_CHECKSUM_IPV4_TCP
Interface supports checksum calculation for TCP payload in IPv4.
Definition net_if.h:2823
@ NET_IF_CHECKSUM_IPV6_HEADER
Interface supports IP version 6 header checksum calculation.
Definition net_if.h:2831
@ NET_IF_CHECKSUM_IPV6_ICMP
Interface supports checksum calculation for ICMP6 payload in IPv6.
Definition net_if.h:2839
@ NET_IF_CHECKSUM_IPV4_UDP
Interface supports checksum calculation for UDP payload in IPv4.
Definition net_if.h:2826
@ NET_IF_OPER_TESTING
Training mode.
Definition net_if.h:311
@ NET_IF_OPER_DORMANT
Waiting external action.
Definition net_if.h:312
@ NET_IF_OPER_UP
Interface is up.
Definition net_if.h:313
@ NET_IF_OPER_NOTPRESENT
Hardware missing.
Definition net_if.h:308
@ NET_IF_OPER_UNKNOWN
Initial (unknown) value.
Definition net_if.h:307
@ NET_IF_OPER_DOWN
Interface is down.
Definition net_if.h:309
@ NET_IF_OPER_LOWERLAYERDOWN
Lower layer interface is down.
Definition net_if.h:310
@ NET_IF_NO_AUTO_START
Do not start the interface immediately after initialization.
Definition net_if.h:264
@ NET_IF_IPV6_NO_MLD
IPv6 Multicast Listener Discovery disabled.
Definition net_if.h:294
@ NET_IF_POINTOPOINT
Interface is pointopoint.
Definition net_if.h:253
@ NET_IF_IPV6_NO_ND
IPv6 Neighbor Discovery disabled.
Definition net_if.h:291
@ NET_IF_FORWARD_MULTICASTS
Flag defines if received multicasts of other interface are forwarded on this interface.
Definition net_if.h:273
@ NET_IF_IPV4
Interface supports IPv4.
Definition net_if.h:276
@ NET_IF_PROMISC
Interface is in promiscuous mode.
Definition net_if.h:256
@ NET_IF_DORMANT
Driver signals dormant.
Definition net_if.h:288
@ NET_IF_SUSPENDED
Power management specific: interface is being suspended.
Definition net_if.h:267
@ NET_IF_IPV6
Interface supports IPv6.
Definition net_if.h:279
@ NET_IF_UP
Interface is admin up.
Definition net_if.h:250
@ NET_IF_LOWER_UP
Driver signals L1 is up.
Definition net_if.h:285
@ NET_IF_RUNNING
Interface up and running (ready to receive and transmit).
Definition net_if.h:282
@ NET_IF_NO_TX_LOCK
Mutex locking on TX data path disabled on the interface.
Definition net_if.h:297
net_link_type
Type of the link address.
Definition net_linkaddr.h:49
struct _slist sys_slist_t
Single-linked list structure.
Definition slist.h:49
struct _snode sys_snode_t
Single-linked list node structure.
Definition slist.h:39
#define IF_ENABLED(_flag, _code)
Insert code if _flag is defined and equals 1.
Definition util_macro.h:247
#define ENOTSUP
Unsupported value.
Definition errno.h:114
#define EPERM
Not owner.
Definition errno.h:39
Hostname configuration definitions.
#define NULL
Definition iar_missing_defs.h:20
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:97
state
Definition parser_state.h:29
__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:504
IPv6 address struct.
Definition net_ip.h:143
IPv4 address struct.
Definition net_ip.h:155
Definition kernel.h:2496
Mutex Structure.
Definition kernel.h:3026
Thread Structure.
Definition thread.h:261
Kernel timeout type.
Definition sys_clock.h:65
Kernel timepoint type.
Definition sys_clock.h:227
DHCPv6 client configuration parameters.
Definition dhcpv6.h:63
Network Interface unicast IPv4 address and netmask.
Definition net_if.h:467
struct net_if_addr ipv4
IPv4 address.
Definition net_if.h:469
struct in_addr netmask
Netmask.
Definition net_if.h:471
Network Interface unicast IP addresses.
Definition net_if.h:56
struct net_addr address
IP address.
Definition net_if.h:58
uint8_t is_mesh_local
Is this IP address usage limited to the subnet (mesh) or not.
Definition net_if.h:142
uint8_t is_temporary
Is this IP address temporary and generated for example by IPv6 privacy extension (RFC 8981)
Definition net_if.h:147
enum net_addr_state addr_state
What is the current state of the address.
Definition net_if.h:73
uint8_t is_infinite
Is the IP address valid forever.
Definition net_if.h:136
atomic_t atomic_ref
Reference counter.
Definition net_if.h:63
uint8_t is_added
Was this address added or not.
Definition net_if.h:150
enum net_addr_type addr_type
How the IP address was set.
Definition net_if.h:70
uint8_t is_used
Is this IP address used or not.
Definition net_if.h:139
IP and other configuration related data for network interface.
Definition net_if.h:585
Network Interface Device structure.
Definition net_if.h:668
enum net_if_oper_state oper_state
RFC 2863 operational status.
Definition net_if.h:704
const struct net_l2 *const l2
Interface's L2 layer.
Definition net_if.h:673
void * l2_data
Interface's private L2 data pointer.
Definition net_if.h:676
uint16_t mtu
The hardware MTU.
Definition net_if.h:694
const struct device * dev
The actually device driver instance the net_if is related to.
Definition net_if.h:670
struct net_linkaddr link_addr
The hardware link address.
Definition net_if.h:682
atomic_t flags[ATOMIC_BITMAP_SIZE(NET_IF_NUM_FLAGS)]
For internal use.
Definition net_if.h:679
Network interface IP address configuration.
Definition net_if.h:572
IPv4 configuration.
Definition net_if.h:475
uint8_t mcast_ttl
IPv4 time-to-live for multicast packets.
Definition net_if.h:489
struct net_if_addr_ipv4 unicast[NET_IF_MAX_IPV4_ADDR]
Unicast IP addresses.
Definition net_if.h:477
struct in_addr gw
Gateway.
Definition net_if.h:483
uint8_t ttl
IPv4 time-to-live.
Definition net_if.h:486
struct net_if_mcast_addr mcast[NET_IF_MAX_IPV4_MADDR]
Multicast IP addresses.
Definition net_if.h:480
Network Interface IPv6 prefixes.
Definition net_if.h:192
struct net_if * iface
Backpointer to network interface where this prefix is used.
Definition net_if.h:200
uint8_t is_infinite
Is the IP prefix valid forever.
Definition net_if.h:206
uint8_t len
Prefix length.
Definition net_if.h:203
struct in6_addr prefix
IPv6 prefix.
Definition net_if.h:197
uint8_t is_used
Is this prefix used or not.
Definition net_if.h:209
struct net_timeout lifetime
Prefix lifetime.
Definition net_if.h:194
IPv6 configuration.
Definition net_if.h:333
struct net_if_ipv6_prefix prefix[NET_IF_MAX_IPV6_PREFIX]
Prefixes.
Definition net_if.h:341
uint32_t base_reachable_time
Default reachable time (RFC 4861, page 52)
Definition net_if.h:344
uint8_t hop_limit
IPv6 hop limit.
Definition net_if.h:382
struct net_if_mcast_addr mcast[NET_IF_MAX_IPV6_MADDR]
Multicast IP addresses.
Definition net_if.h:338
uint32_t retrans_timer
Retransmit timer (RFC 4861, page 52)
Definition net_if.h:350
struct net_if_addr unicast[NET_IF_MAX_IPV6_ADDR]
Unicast IP addresses.
Definition net_if.h:335
uint8_t mcast_hop_limit
IPv6 multicast hop limit.
Definition net_if.h:385
uint32_t reachable_time
Reachable time (RFC 4861, page 20)
Definition net_if.h:347
Network Interface multicast IP addresses.
Definition net_if.h:160
struct net_addr address
IP address.
Definition net_if.h:162
uint8_t is_joined
Did we join to this group.
Definition net_if.h:182
sys_snode_t rejoin_node
Rejoining multicast groups list node.
Definition net_if.h:165
uint8_t is_used
Is this multicast IP address used or not.
Definition net_if.h:179
Multicast monitor handler struct.
Definition net_if.h:1666
sys_snode_t node
Node information for the slist.
Definition net_if.h:1668
net_if_mcast_callback_t cb
Multicast callback.
Definition net_if.h:1674
struct net_if * iface
Network interface.
Definition net_if.h:1671
Information about routers in the system.
Definition net_if.h:219
struct net_if * iface
Network interface the router is connected to.
Definition net_if.h:227
uint8_t is_default
Is default router.
Definition net_if.h:239
uint16_t lifetime
Router lifetime.
Definition net_if.h:233
uint8_t is_infinite
Is the router valid forever.
Definition net_if.h:242
uint8_t is_used
Is this router used or not.
Definition net_if.h:236
struct net_addr address
IP address.
Definition net_if.h:224
sys_snode_t node
Slist lifetime timer node.
Definition net_if.h:221
uint32_t life_start
Router life timer start.
Definition net_if.h:230
Network Interface structure.
Definition net_if.h:714
struct net_if_dev * if_dev
The net_if_dev instance the net_if is related to.
Definition net_if.h:716
struct net_if_config config
Network interface instance configuration.
Definition net_if.h:728
uint8_t pe_enabled
Network interface specific flags.
Definition net_if.h:748
struct k_mutex lock
Mutex protecting this network interface instance.
Definition net_if.h:739
uint8_t pe_prefer_public
If PE is enabled, then this tells whether public addresses are preferred over temporary ones for this...
Definition net_if.h:753
struct k_mutex tx_lock
Mutex used when sending data.
Definition net_if.h:742
Network L2 structure.
Definition net_l2.h:58
Hardware link address structure.
Definition net_linkaddr.h:69
uint8_t * addr
The array of byte representing the address.
Definition net_linkaddr.h:71
uint8_t type
What kind of address is this for.
Definition net_linkaddr.h:77
uint8_t len
Length of that address array.
Definition net_linkaddr.h:74
Network packet.
Definition net_pkt.h:91
All network statistics in one struct.
Definition net_stats.h:378
Generic struct for handling network timeouts.
Definition net_timeout.h:57
Network traffic class.
Definition net_if.h:629
k_thread_stack_t * stack
Stack for this handler.
Definition net_if.h:643
struct k_thread handler
Traffic class handler thread.
Definition net_if.h:640
struct k_fifo fifo
Fifo for handling this Tx or Rx packet.
Definition net_if.h:631
Prometheus collector definition.
Definition collector.h:50
Type used to represent a Prometheus metric base.
Definition metric.h:47
Generic sockaddr struct.
Definition net_ip.h:408