Zephyr API Documentation 4.2.0-rc1
A Scalable Open Source RTOS
 4.2.0-rc1
All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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 uint8_t _dummy;
129 };
130
131#if defined(CONFIG_NET_IPV6_DAD) || defined(CONFIG_NET_IPV4_ACD)
133 uint8_t ifindex;
134#endif
135
138
141
144
149
152
153 uint8_t _unused : 3;
154};
155
163 struct net_addr address;
164
167
168#if defined(CONFIG_NET_IPV4_IGMPV3)
170 struct net_addr sources[CONFIG_NET_IF_MCAST_IPV4_SOURCE_COUNT];
171
173 uint16_t sources_len;
174
176 uint8_t record_type;
177#endif
178
181
184
185 uint8_t _unused : 6;
186};
187
196
199
201 struct net_if *iface;
202
205
208
211
212 uint8_t _unused : 6;
213};
214
223
225 struct net_addr address;
226
228 struct net_if *iface;
229
232
235
238
241
244
245 uint8_t _unused : 5;
246};
247
305
316
317#if defined(CONFIG_NET_OFFLOAD)
318struct net_offload;
319#endif /* CONFIG_NET_OFFLOAD */
320
322#if defined(CONFIG_NET_IPV6)
323#define NET_IF_MAX_IPV6_ADDR CONFIG_NET_IF_UNICAST_IPV6_ADDR_COUNT
324#define NET_IF_MAX_IPV6_MADDR CONFIG_NET_IF_MCAST_IPV6_ADDR_COUNT
325#define NET_IF_MAX_IPV6_PREFIX CONFIG_NET_IF_IPV6_PREFIX_COUNT
326#else
327#define NET_IF_MAX_IPV6_ADDR 0
328#define NET_IF_MAX_IPV6_MADDR 0
329#define NET_IF_MAX_IPV6_PREFIX 0
330#endif
331/* @endcond */
332
336 struct net_if_addr unicast[NET_IF_MAX_IPV6_ADDR];
337
339 struct net_if_mcast_addr mcast[NET_IF_MAX_IPV6_MADDR];
340
342 struct net_if_ipv6_prefix prefix[NET_IF_MAX_IPV6_PREFIX];
343
346
349
352
353#if defined(CONFIG_NET_IPV6_IID_STABLE)
355 struct net_if_addr *iid;
356
360 uint32_t network_counter;
361#endif /* CONFIG_NET_IPV6_IID_STABLE */
362
363#if defined(CONFIG_NET_IPV6_PE)
368 uint32_t desync_factor;
369#endif /* CONFIG_NET_IPV6_PE */
370
371#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
373 sys_snode_t rs_node;
374
375 /* RS start time */
376 uint32_t rs_start;
377
379 uint8_t rs_count;
380#endif
381
384
387};
388
389#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
391struct net_if_dhcpv6 {
393 sys_snode_t node;
394
396 struct net_dhcpv6_duid_storage clientid;
397
399 struct net_dhcpv6_duid_storage serverid;
400
402 enum net_dhcpv6_state state;
403
405 struct net_dhcpv6_params params;
406
408 uint64_t timeout;
409
411 uint64_t exchange_start;
412
414 uint64_t t1;
415
417 uint64_t t2;
418
422 uint64_t expire;
423
425 uint32_t addr_iaid;
426
428 uint32_t prefix_iaid;
429
431 uint32_t retransmit_timeout;
432
434 int16_t server_preference;
435
437 uint8_t retransmissions;
438
440 uint8_t tid[DHCPV6_TID_SIZE];
441
443 uint8_t prefix_len;
444
446 struct in6_addr prefix;
447
449 struct in6_addr addr;
450};
451#endif /* defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6) */
452
454#if defined(CONFIG_NET_IPV4)
455#define NET_IF_MAX_IPV4_ADDR CONFIG_NET_IF_UNICAST_IPV4_ADDR_COUNT
456#define NET_IF_MAX_IPV4_MADDR CONFIG_NET_IF_MCAST_IPV4_ADDR_COUNT
457#else
458#define NET_IF_MAX_IPV4_ADDR 0
459#define NET_IF_MAX_IPV4_MADDR 0
460#endif
474
478 struct net_if_addr_ipv4 unicast[NET_IF_MAX_IPV4_ADDR];
479
481 struct net_if_mcast_addr mcast[NET_IF_MAX_IPV4_MADDR];
482
484 struct in_addr gw;
485
488
491
492#if defined(CONFIG_NET_IPV4_ACD)
494 uint8_t conflict_cnt;
495#endif
496};
497
498#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
499struct net_if_dhcpv4 {
501 sys_snode_t node;
502
504 int64_t timer_start;
505
507 uint32_t request_time;
508
509 uint32_t xid;
510
512 uint32_t lease_time;
513
515 uint32_t renewal_time;
516
518 uint32_t rebinding_time;
519
521 struct in_addr server_id;
522
524 struct in_addr requested_ip;
525
527 struct in_addr netmask;
528
533 enum net_dhcpv4_state state;
534
536 uint8_t attempts;
537
539 struct in_addr request_server_addr;
540
542 struct in_addr response_src_addr;
543
544#ifdef CONFIG_NET_DHCPV4_OPTION_NTP_SERVER
546 struct in_addr ntp_addr;
547#endif
548};
549#endif /* CONFIG_NET_DHCPV4 */
550
551#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
552struct net_if_ipv4_autoconf {
554 struct net_if *iface;
555
557 struct in_addr requested_ip;
558
562};
563#endif /* CONFIG_NET_IPV4_AUTO */
564
566/* We always need to have at least one IP config */
567#define NET_IF_MAX_CONFIGS 1
573struct net_if_ip {
574#if defined(CONFIG_NET_IPV6)
575 struct net_if_ipv6 *ipv6;
576#endif /* CONFIG_NET_IPV6 */
577
578#if defined(CONFIG_NET_IPV4)
579 struct net_if_ipv4 *ipv4;
580#endif /* CONFIG_NET_IPV4 */
581};
582
587#if defined(CONFIG_NET_IP)
589 struct net_if_ip ip;
590#endif
591
592#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
593 struct net_if_dhcpv4 dhcpv4;
594#endif /* CONFIG_NET_DHCPV4 */
595
596#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
597 struct net_if_dhcpv6 dhcpv6;
598#endif /* CONFIG_NET_DHCPV6 */
599
600#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
601 struct net_if_ipv4_autoconf ipv4auto;
602#endif /* CONFIG_NET_IPV4_AUTO */
603
604#if defined(CONFIG_NET_L2_VIRTUAL)
609 sys_slist_t virtual_interfaces;
610#endif /* CONFIG_NET_L2_VIRTUAL */
611
612#if defined(CONFIG_NET_INTERFACE_NAME)
617 char name[CONFIG_NET_INTERFACE_NAME_LEN + 1];
618#endif
619};
620
632 struct k_fifo fifo;
633
634#if NET_TC_COUNT > 1 || defined(CONFIG_NET_TC_TX_SKIP_FOR_HIGH_PRIO) \
635 || defined(CONFIG_NET_TC_RX_SKIP_FOR_HIGH_PRIO)
637 struct k_sem fifo_slot;
638#endif
639
642
645};
646
653typedef int (*net_socket_create_t)(int, int, int);
654
671 const struct device *dev;
672
674 const struct net_l2 * const l2;
675
677 void *l2_data;
678
680 ATOMIC_DEFINE(flags, NET_IF_NUM_FLAGS);
681
684
685#if defined(CONFIG_NET_OFFLOAD)
691 struct net_offload *offload;
692#endif /* CONFIG_NET_OFFLOAD */
693
696
697#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
701 net_socket_create_t socket_offload;
702#endif /* CONFIG_NET_SOCKETS_OFFLOAD */
703
706
717};
718
726struct net_if {
729
730#if defined(CONFIG_NET_STATISTICS_PER_INTERFACE)
732 struct net_stats stats;
733
735 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS,
736 (struct prometheus_collector *collector);)
737#endif /* CONFIG_NET_STATISTICS_PER_INTERFACE */
738
741
742#if defined(CONFIG_NET_POWER_MANAGEMENT)
747 int tx_pending;
748#endif
749
751 struct k_mutex lock;
752
755
761
766
768 uint8_t _unused : 6;
769};
770
773static inline void net_if_lock(struct net_if *iface)
774{
775 NET_ASSERT(iface);
776
777 (void)k_mutex_lock(&iface->lock, K_FOREVER);
778}
779
780static inline void net_if_unlock(struct net_if *iface)
781{
782 NET_ASSERT(iface);
783
784 k_mutex_unlock(&iface->lock);
785}
786
787static inline bool net_if_flag_is_set(struct net_if *iface,
788 enum net_if_flag value);
789
790static inline void net_if_tx_lock(struct net_if *iface)
791{
792 NET_ASSERT(iface);
793
795 return;
796 }
797
798 (void)k_mutex_lock(&iface->tx_lock, K_FOREVER);
799}
800
801static inline void net_if_tx_unlock(struct net_if *iface)
802{
803 NET_ASSERT(iface);
804
806 return;
807 }
808
809 k_mutex_unlock(&iface->tx_lock);
810}
811
820static inline void net_if_flag_set(struct net_if *iface,
821 enum net_if_flag value)
822{
823 if (iface == NULL || iface->if_dev == NULL) {
824 return;
825 }
826
827 atomic_set_bit(iface->if_dev->flags, value);
828}
829
838static inline bool net_if_flag_test_and_set(struct net_if *iface,
839 enum net_if_flag value)
840{
841 if (iface == NULL || iface->if_dev == NULL) {
842 return false;
843 }
844
845 return atomic_test_and_set_bit(iface->if_dev->flags, value);
846}
847
854static inline void net_if_flag_clear(struct net_if *iface,
855 enum net_if_flag value)
856{
857 if (iface == NULL || iface->if_dev == NULL) {
858 return;
859 }
860
861 atomic_clear_bit(iface->if_dev->flags, value);
862}
863
872static inline bool net_if_flag_test_and_clear(struct net_if *iface,
873 enum net_if_flag value)
874{
875 if (iface == NULL || iface->if_dev == NULL) {
876 return false;
877 }
878
879 return atomic_test_and_clear_bit(iface->if_dev->flags, value);
880}
881
890static inline bool net_if_flag_is_set(struct net_if *iface,
891 enum net_if_flag value)
892{
893 if (iface == NULL || iface->if_dev == NULL) {
894 return false;
895 }
896
897 return atomic_test_bit(iface->if_dev->flags, value);
898}
899
909 struct net_if *iface, enum net_if_oper_state oper_state)
910{
911 if (iface == NULL || iface->if_dev == NULL) {
912 return NET_IF_OPER_UNKNOWN;
913 }
914
915 BUILD_ASSERT((enum net_if_oper_state)(-1) > 0 && NET_IF_OPER_UNKNOWN == 0);
916 if (oper_state <= NET_IF_OPER_UP) {
917 iface->if_dev->oper_state = oper_state;
918 }
919
920 net_if_lock(iface);
921
923
924 net_if_unlock(iface);
925
926 return iface->if_dev->oper_state;
927}
928
936static inline enum net_if_oper_state net_if_oper_state(struct net_if *iface)
937{
938 if (iface == NULL || iface->if_dev == NULL) {
939 return NET_IF_OPER_UNKNOWN;
940 }
941
942 return iface->if_dev->oper_state;
943}
944
957static inline int net_if_oper_state_change_time(struct net_if *iface,
958 int64_t *change_time)
959{
960 if (iface == NULL || iface->if_dev == NULL || change_time == NULL) {
961 return -EINVAL;
962 }
963
964 net_if_lock(iface);
965
966 *change_time = iface->if_dev->oper_state_change_time;
967
968 net_if_unlock(iface);
969
970 return 0;
971}
972
983 struct net_pkt *pkt, k_timeout_t timeout);
984
994static inline enum net_verdict net_if_send_data(struct net_if *iface,
995 struct net_pkt *pkt)
996{
998
999 return net_if_try_send_data(iface, pkt, timeout);
1000}
1001
1009static inline const struct net_l2 *net_if_l2(struct net_if *iface)
1010{
1011 if (iface == NULL || iface->if_dev == NULL) {
1012 return NULL;
1013 }
1014
1015 return iface->if_dev->l2;
1016}
1017
1026enum net_verdict net_if_recv_data(struct net_if *iface, struct net_pkt *pkt);
1027
1035static inline void *net_if_l2_data(struct net_if *iface)
1036{
1037 if (iface == NULL || iface->if_dev == NULL) {
1038 return NULL;
1039 }
1040
1041 return iface->if_dev->l2_data;
1042}
1043
1051static inline const struct device *net_if_get_device(struct net_if *iface)
1052{
1053 if (iface == NULL || iface->if_dev == NULL) {
1054 return NULL;
1055 }
1056
1057 return iface->if_dev->dev;
1058}
1059
1067void net_if_try_queue_tx(struct net_if *iface, struct net_pkt *pkt, k_timeout_t timeout);
1068
1076static inline void net_if_queue_tx(struct net_if *iface, struct net_pkt *pkt)
1077{
1079
1080 net_if_try_queue_tx(iface, pkt, timeout);
1081}
1082
1090static inline bool net_if_is_ip_offloaded(struct net_if *iface)
1091{
1092#if defined(CONFIG_NET_OFFLOAD)
1093 return (iface != NULL && iface->if_dev != NULL &&
1094 iface->if_dev->offload != NULL);
1095#else
1096 ARG_UNUSED(iface);
1097
1098 return false;
1099#endif
1100}
1101
1109bool net_if_is_offloaded(struct net_if *iface);
1110
1118static inline struct net_offload *net_if_offload(struct net_if *iface)
1119{
1120#if defined(CONFIG_NET_OFFLOAD)
1121 if (iface == NULL || iface->if_dev == NULL) {
1122 return NULL;
1123 }
1124
1125 return iface->if_dev->offload;
1126#else
1127 ARG_UNUSED(iface);
1128
1129 return NULL;
1130#endif
1131}
1132
1140static inline bool net_if_is_socket_offloaded(struct net_if *iface)
1141{
1142#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
1143 if (iface == NULL || iface->if_dev == NULL) {
1144 return false;
1145 }
1146
1147 return (iface->if_dev->socket_offload != NULL);
1148#else
1149 ARG_UNUSED(iface);
1150
1151 return false;
1152#endif
1153}
1154
1161static inline void net_if_socket_offload_set(
1162 struct net_if *iface, net_socket_create_t socket_offload)
1163{
1164#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
1165 if (iface == NULL || iface->if_dev == NULL) {
1166 return;
1167 }
1168
1169 iface->if_dev->socket_offload = socket_offload;
1170#else
1171 ARG_UNUSED(iface);
1172 ARG_UNUSED(socket_offload);
1173#endif
1174}
1175
1184{
1185#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
1186 if (iface == NULL || iface->if_dev == NULL) {
1187 return NULL;
1188 }
1189
1190 return iface->if_dev->socket_offload;
1191#else
1192 ARG_UNUSED(iface);
1193
1194 return NULL;
1195#endif
1196}
1197
1205static inline struct net_linkaddr *net_if_get_link_addr(struct net_if *iface)
1206{
1207 if (iface == NULL || iface->if_dev == NULL) {
1208 return NULL;
1209 }
1210
1211 return &iface->if_dev->link_addr;
1212}
1213
1221static inline struct net_if_config *net_if_get_config(struct net_if *iface)
1222{
1223 if (iface == NULL) {
1224 return NULL;
1225 }
1226
1227 return &iface->config;
1228}
1229
1235#if defined(CONFIG_NET_IPV6_DAD) && defined(CONFIG_NET_NATIVE_IPV6)
1236void net_if_start_dad(struct net_if *iface);
1237#else
1238static inline void net_if_start_dad(struct net_if *iface)
1239{
1240 ARG_UNUSED(iface);
1241}
1242#endif
1243
1249void net_if_start_rs(struct net_if *iface);
1250
1251
1257#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
1258void net_if_stop_rs(struct net_if *iface);
1259#else
1260static inline void net_if_stop_rs(struct net_if *iface)
1261{
1262 ARG_UNUSED(iface);
1263}
1264#endif /* CONFIG_NET_IPV6_ND */
1265
1278#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
1279void net_if_nbr_reachability_hint(struct net_if *iface, const struct in6_addr *ipv6_addr);
1280#else
1281static inline void net_if_nbr_reachability_hint(struct net_if *iface,
1282 const struct in6_addr *ipv6_addr)
1283{
1284 ARG_UNUSED(iface);
1285 ARG_UNUSED(ipv6_addr);
1286}
1287#endif
1288
1291static inline int net_if_set_link_addr_unlocked(struct net_if *iface,
1292 uint8_t *addr, uint8_t len,
1293 enum net_link_type type)
1294{
1295 int ret;
1296
1297 if (net_if_flag_is_set(iface, NET_IF_RUNNING)) {
1298 return -EPERM;
1299 }
1300
1301 if (len > sizeof(net_if_get_link_addr(iface)->addr)) {
1302 return -EINVAL;
1303 }
1304
1305 ret = net_linkaddr_create(net_if_get_link_addr(iface), addr, len, type);
1306 if (ret < 0) {
1307 return ret;
1308 }
1309
1310 net_hostname_set_postfix(addr, len);
1311
1312 return 0;
1313}
1314
1315int net_if_set_link_addr_locked(struct net_if *iface,
1316 uint8_t *addr, uint8_t len,
1317 enum net_link_type type);
1318
1319#if CONFIG_NET_IF_LOG_LEVEL >= LOG_LEVEL_DBG
1320extern int net_if_addr_unref_debug(struct net_if *iface,
1321 sa_family_t family,
1322 const void *addr,
1323 struct net_if_addr **ifaddr,
1324 const char *caller, int line);
1325#define net_if_addr_unref(iface, family, addr, ifaddr) \
1326 net_if_addr_unref_debug(iface, family, addr, ifaddr, __func__, __LINE__)
1327
1328extern struct net_if_addr *net_if_addr_ref_debug(struct net_if *iface,
1329 sa_family_t family,
1330 const void *addr,
1331 const char *caller,
1332 int line);
1333#define net_if_addr_ref(iface, family, addr) \
1334 net_if_addr_ref_debug(iface, family, addr, __func__, __LINE__)
1335#else
1336extern int net_if_addr_unref(struct net_if *iface,
1337 sa_family_t family,
1338 const void *addr,
1339 struct net_if_addr **ifaddr);
1340extern struct net_if_addr *net_if_addr_ref(struct net_if *iface,
1341 sa_family_t family,
1342 const void *addr);
1343#endif /* CONFIG_NET_IF_LOG_LEVEL */
1344
1358static inline int net_if_set_link_addr(struct net_if *iface,
1359 uint8_t *addr, uint8_t len,
1360 enum net_link_type type)
1361{
1362#if defined(CONFIG_NET_RAW_MODE)
1363 return net_if_set_link_addr_unlocked(iface, addr, len, type);
1364#else
1365 return net_if_set_link_addr_locked(iface, addr, len, type);
1366#endif
1367}
1368
1376static inline uint16_t net_if_get_mtu(struct net_if *iface)
1377{
1378 if (iface == NULL || iface->if_dev == NULL) {
1379 return 0U;
1380 }
1381
1382 return iface->if_dev->mtu;
1383}
1384
1391static inline void net_if_set_mtu(struct net_if *iface,
1392 uint16_t mtu)
1393{
1394 if (iface == NULL || iface->if_dev == NULL) {
1395 return;
1396 }
1397
1398 iface->if_dev->mtu = mtu;
1399}
1400
1407static inline void net_if_addr_set_lf(struct net_if_addr *ifaddr,
1408 bool is_infinite)
1409{
1410 if (ifaddr == NULL) {
1411 return;
1412 }
1413
1414 ifaddr->is_infinite = is_infinite;
1415}
1416
1425
1433struct net_if *net_if_lookup_by_dev(const struct device *dev);
1434
1442static inline struct net_if_config *net_if_config_get(struct net_if *iface)
1443{
1444 if (iface == NULL) {
1445 return NULL;
1446 }
1447
1448 return &iface->config;
1449}
1450
1456void net_if_router_rm(struct net_if_router *router);
1457
1463void net_if_set_default(struct net_if *iface);
1464
1471
1480struct net_if *net_if_get_first_by_type(const struct net_l2 *l2);
1481
1489
1490#if defined(CONFIG_NET_L2_IEEE802154)
1497static inline struct net_if *net_if_get_ieee802154(void)
1498{
1499 return net_if_get_first_by_type(&NET_L2_GET_NAME(IEEE802154));
1500}
1501#endif /* CONFIG_NET_L2_IEEE802154 */
1502
1514 struct net_if_ipv6 **ipv6);
1515
1524
1534 struct net_if **iface);
1535
1545 struct in6_addr *addr);
1546
1555__syscall int net_if_ipv6_addr_lookup_by_index(const struct in6_addr *addr);
1556
1568 struct in6_addr *addr,
1570 uint32_t vlifetime);
1571
1582__syscall bool net_if_ipv6_addr_add_by_index(int index,
1583 struct in6_addr *addr,
1585 uint32_t vlifetime);
1586
1594 uint32_t vlifetime);
1595
1604bool net_if_ipv6_addr_rm(struct net_if *iface, const struct in6_addr *addr);
1605
1614__syscall bool net_if_ipv6_addr_rm_by_index(int index,
1615 const struct in6_addr *addr);
1616
1625typedef void (*net_if_ip_addr_cb_t)(struct net_if *iface,
1626 struct net_if_addr *addr,
1627 void *user_data);
1628
1638 void *user_data);
1639
1649 const struct in6_addr *addr);
1650
1659bool net_if_ipv6_maddr_rm(struct net_if *iface, const struct in6_addr *addr);
1660
1669typedef void (*net_if_ip_maddr_cb_t)(struct net_if *iface,
1670 struct net_if_mcast_addr *maddr,
1671 void *user_data);
1672
1682 void *user_data);
1683
1695 struct net_if **iface);
1696
1707typedef void (*net_if_mcast_callback_t)(struct net_if *iface,
1708 const struct net_addr *addr,
1709 bool is_joined);
1710
1729
1739 struct net_if *iface,
1741
1748
1756void net_if_mcast_monitor(struct net_if *iface, const struct net_addr *addr,
1757 bool is_joined);
1758
1766 struct net_if_mcast_addr *addr);
1767
1775static inline bool net_if_ipv6_maddr_is_joined(struct net_if_mcast_addr *addr)
1776{
1777 if (addr == NULL) {
1778 return false;
1779 }
1780
1781 return addr->is_joined;
1782}
1783
1791 struct net_if_mcast_addr *addr);
1792
1802 const struct in6_addr *addr);
1803
1814 struct in6_addr *addr,
1815 uint8_t len);
1816
1828 struct in6_addr *prefix,
1829 uint8_t len,
1831
1841bool net_if_ipv6_prefix_rm(struct net_if *iface, struct in6_addr *addr,
1842 uint8_t len);
1843
1851 bool is_infinite)
1852{
1853 prefix->is_infinite = is_infinite;
1854}
1855
1864
1871
1882bool net_if_ipv6_addr_onlink(struct net_if **iface, struct in6_addr *addr);
1883
1890#if defined(CONFIG_NET_NATIVE_IPV6)
1891static inline struct in6_addr *net_if_router_ipv6(struct net_if_router *router)
1892{
1893 if (router == NULL) {
1894 return NULL;
1895 }
1896
1897 return &router->address.in6_addr;
1898}
1899#else
1900static inline struct in6_addr *net_if_router_ipv6(struct net_if_router *router)
1901{
1902 static struct in6_addr addr;
1903
1904 ARG_UNUSED(router);
1905
1906 return &addr;
1907}
1908#endif
1909
1920 struct in6_addr *addr);
1921
1932 struct in6_addr *addr);
1933
1942
1953 struct in6_addr *addr,
1954 uint16_t router_lifetime);
1955
1964
1973#if defined(CONFIG_NET_NATIVE_IPV6)
1975#else
1977{
1978 ARG_UNUSED(iface);
1979
1980 return 0;
1981}
1982#endif /* CONFIG_NET_NATIVE_IPV6 */
1983
1990#if defined(CONFIG_NET_NATIVE_IPV6)
1991void net_if_ipv6_set_hop_limit(struct net_if *iface, uint8_t hop_limit);
1992#else
1993static inline void net_if_ipv6_set_hop_limit(struct net_if *iface,
1994 uint8_t hop_limit)
1995{
1996 ARG_UNUSED(iface);
1997 ARG_UNUSED(hop_limit);
1998}
1999#endif /* CONFIG_NET_NATIVE_IPV6 */
2000
2003/* The old hop limit setter function is deprecated because the naming
2004 * of it was incorrect. The API name was missing "_if_" so this function
2005 * should not be used.
2006 */
2007__deprecated
2008static inline void net_ipv6_set_hop_limit(struct net_if *iface,
2009 uint8_t hop_limit)
2010{
2011 net_if_ipv6_set_hop_limit(iface, hop_limit);
2012}
2013
2024#if defined(CONFIG_NET_NATIVE_IPV6)
2026#else
2028{
2029 ARG_UNUSED(iface);
2030
2031 return 0;
2032}
2033#endif /* CONFIG_NET_NATIVE_IPV6 */
2034
2041#if defined(CONFIG_NET_NATIVE_IPV6)
2042void net_if_ipv6_set_mcast_hop_limit(struct net_if *iface, uint8_t hop_limit);
2043#else
2045 uint8_t hop_limit)
2046{
2047 ARG_UNUSED(iface);
2048 ARG_UNUSED(hop_limit);
2049}
2050#endif /* CONFIG_NET_NATIVE_IPV6 */
2051
2059 uint32_t reachable_time)
2060{
2061#if defined(CONFIG_NET_NATIVE_IPV6)
2062 if (iface == NULL) {
2063 return;
2064 }
2065
2066 if (!iface->config.ip.ipv6) {
2067 return;
2068 }
2069
2070 iface->config.ip.ipv6->base_reachable_time = reachable_time;
2071#else
2072 ARG_UNUSED(iface);
2073 ARG_UNUSED(reachable_time);
2074
2075#endif
2076}
2077
2086{
2087#if defined(CONFIG_NET_NATIVE_IPV6)
2088 if (iface == NULL) {
2089 return 0;
2090 }
2091
2092 if (!iface->config.ip.ipv6) {
2093 return 0;
2094 }
2095
2096 return iface->config.ip.ipv6->reachable_time;
2097#else
2098 ARG_UNUSED(iface);
2099 return 0;
2100#endif
2101}
2102
2111
2118static inline void net_if_ipv6_set_reachable_time(struct net_if_ipv6 *ipv6)
2119{
2120#if defined(CONFIG_NET_NATIVE_IPV6)
2121 if (ipv6 == NULL) {
2122 return;
2123 }
2124
2126#else
2127 ARG_UNUSED(ipv6);
2128#endif
2129}
2130
2137static inline void net_if_ipv6_set_retrans_timer(struct net_if *iface,
2138 uint32_t retrans_timer)
2139{
2140#if defined(CONFIG_NET_NATIVE_IPV6)
2141 if (iface == NULL) {
2142 return;
2143 }
2144
2145 if (!iface->config.ip.ipv6) {
2146 return;
2147 }
2148
2149 iface->config.ip.ipv6->retrans_timer = retrans_timer;
2150#else
2151 ARG_UNUSED(iface);
2152 ARG_UNUSED(retrans_timer);
2153#endif
2154}
2155
2164{
2165#if defined(CONFIG_NET_NATIVE_IPV6)
2166 if (iface == NULL) {
2167 return 0;
2168 }
2169
2170 if (!iface->config.ip.ipv6) {
2171 return 0;
2172 }
2173
2174 return iface->config.ip.ipv6->retrans_timer;
2175#else
2176 ARG_UNUSED(iface);
2177 return 0;
2178#endif
2179}
2180
2192#if defined(CONFIG_NET_IPV6)
2193const struct in6_addr *net_if_ipv6_select_src_addr(struct net_if *iface,
2194 const struct in6_addr *dst);
2195#else
2196static inline const struct in6_addr *net_if_ipv6_select_src_addr(
2197 struct net_if *iface, const struct in6_addr *dst)
2198{
2199 ARG_UNUSED(iface);
2200 ARG_UNUSED(dst);
2201
2202 return NULL;
2203}
2204#endif
2205
2219#if defined(CONFIG_NET_IPV6)
2220const struct in6_addr *net_if_ipv6_select_src_addr_hint(struct net_if *iface,
2221 const struct in6_addr *dst,
2222 int flags);
2223#else
2224static inline const struct in6_addr *net_if_ipv6_select_src_addr_hint(
2225 struct net_if *iface, const struct in6_addr *dst, int flags)
2226{
2227 ARG_UNUSED(iface);
2228 ARG_UNUSED(dst);
2229 ARG_UNUSED(flags);
2230
2231 return NULL;
2232}
2233#endif
2234
2244#if defined(CONFIG_NET_IPV6)
2245struct net_if *net_if_ipv6_select_src_iface(const struct in6_addr *dst);
2246#else
2248 const struct in6_addr *dst)
2249{
2250 ARG_UNUSED(dst);
2251
2252 return NULL;
2253}
2254#endif
2255
2268#if defined(CONFIG_NET_IPV6)
2269struct net_if *net_if_ipv6_select_src_iface_addr(const struct in6_addr *dst,
2270 const struct in6_addr **src_addr);
2271#else
2273 const struct in6_addr *dst, const struct in6_addr **src_addr)
2274{
2275 ARG_UNUSED(dst);
2276 ARG_UNUSED(src_addr);
2277
2278 return NULL;
2279}
2280#endif /* CONFIG_NET_IPV6 */
2281
2291struct in6_addr *net_if_ipv6_get_ll(struct net_if *iface,
2292 enum net_addr_state addr_state);
2293
2304 struct net_if **iface);
2305
2313void net_if_ipv6_dad_failed(struct net_if *iface, const struct in6_addr *addr);
2314
2327 struct net_if **iface);
2328
2340 struct net_if_ipv4 **ipv4);
2341
2350
2359
2366void net_if_ipv4_set_ttl(struct net_if *iface, uint8_t ttl);
2367
2376
2384
2394 struct net_if **iface);
2395
2407 struct in_addr *addr,
2409 uint32_t vlifetime);
2410
2419bool net_if_ipv4_addr_rm(struct net_if *iface, const struct in_addr *addr);
2420
2429__syscall int net_if_ipv4_addr_lookup_by_index(const struct in_addr *addr);
2430
2441__syscall bool net_if_ipv4_addr_add_by_index(int index,
2442 struct in_addr *addr,
2444 uint32_t vlifetime);
2445
2454__syscall bool net_if_ipv4_addr_rm_by_index(int index,
2455 const struct in_addr *addr);
2456
2466 void *user_data);
2467
2477 const struct in_addr *addr);
2478
2487bool net_if_ipv4_maddr_rm(struct net_if *iface, const struct in_addr *addr);
2488
2498 void *user_data);
2499
2511 struct net_if **iface);
2512
2520 struct net_if_mcast_addr *addr);
2521
2529static inline bool net_if_ipv4_maddr_is_joined(struct net_if_mcast_addr *addr)
2530{
2531 if (addr == NULL) {
2532 return false;
2533 }
2534
2535 return addr->is_joined;
2536}
2537
2545 struct net_if_mcast_addr *addr);
2546
2553#if defined(CONFIG_NET_NATIVE_IPV4)
2554static inline struct in_addr *net_if_router_ipv4(struct net_if_router *router)
2555{
2556 if (router == NULL) {
2557 return NULL;
2558 }
2559
2560 return &router->address.in_addr;
2561}
2562#else
2563static inline struct in_addr *net_if_router_ipv4(struct net_if_router *router)
2564{
2565 static struct in_addr addr;
2566
2567 ARG_UNUSED(router);
2568
2569 return &addr;
2570}
2571#endif
2572
2583 struct in_addr *addr);
2584
2595 struct in_addr *addr);
2607 struct in_addr *addr,
2608 bool is_default,
2609 uint16_t router_lifetime);
2610
2619
2629 const struct in_addr *addr);
2630
2640 const struct in_addr *addr);
2641
2651#if defined(CONFIG_NET_IPV4)
2652struct net_if *net_if_ipv4_select_src_iface(const struct in_addr *dst);
2653#else
2655 const struct in_addr *dst)
2656{
2657 ARG_UNUSED(dst);
2658
2659 return NULL;
2660}
2661#endif
2662
2675#if defined(CONFIG_NET_IPV4)
2676struct net_if *net_if_ipv4_select_src_iface_addr(const struct in_addr *dst,
2677 const struct in_addr **src_addr);
2678#else
2680 const struct in_addr *dst, const struct in_addr **src_addr)
2681{
2682 ARG_UNUSED(dst);
2683 ARG_UNUSED(src_addr);
2684
2685 return NULL;
2686}
2687#endif /* CONFIG_NET_IPV4 */
2688
2700#if defined(CONFIG_NET_IPV4)
2701const struct in_addr *net_if_ipv4_select_src_addr(struct net_if *iface,
2702 const struct in_addr *dst);
2703#else
2704static inline const struct in_addr *net_if_ipv4_select_src_addr(
2705 struct net_if *iface, const struct in_addr *dst)
2706{
2707 ARG_UNUSED(iface);
2708 ARG_UNUSED(dst);
2709
2710 return NULL;
2711}
2712#endif
2713
2723struct in_addr *net_if_ipv4_get_ll(struct net_if *iface,
2724 enum net_addr_state addr_state);
2725
2736 enum net_addr_state addr_state);
2737
2748 const struct in_addr *addr);
2749
2759__deprecated struct in_addr net_if_ipv4_get_netmask(struct net_if *iface);
2760
2769__deprecated void net_if_ipv4_set_netmask(struct net_if *iface,
2770 const struct in_addr *netmask);
2771
2782__deprecated __syscall bool net_if_ipv4_set_netmask_by_index(int index,
2783 const struct in_addr *netmask);
2784
2795 const struct in_addr *addr,
2796 const struct in_addr *netmask);
2797
2808 const struct in_addr *addr,
2809 const struct in_addr *netmask);
2810
2818struct in_addr net_if_ipv4_get_gw(struct net_if *iface);
2819
2826void net_if_ipv4_set_gw(struct net_if *iface, const struct in_addr *gw);
2827
2836__syscall bool net_if_ipv4_set_gw_by_index(int index, const struct in_addr *gw);
2837
2848struct net_if *net_if_select_src_iface(const struct sockaddr *dst);
2849
2858typedef void (*net_if_link_callback_t)(struct net_if *iface,
2859 struct net_linkaddr *dst,
2860 int status);
2861
2877
2886
2893
2901void net_if_call_link_cb(struct net_if *iface, struct net_linkaddr *lladdr,
2902 int status);
2903
2906/* used to ensure encoding of checksum support in net_if.h and
2907 * ethernet.h is the same
2908 */
2909#define NET_IF_CHECKSUM_NONE_BIT 0
2910#define NET_IF_CHECKSUM_IPV4_HEADER_BIT BIT(0)
2911#define NET_IF_CHECKSUM_IPV4_ICMP_BIT BIT(1)
2912/* Space for future protocols and restrictions for IPV4 */
2913#define NET_IF_CHECKSUM_IPV6_HEADER_BIT BIT(10)
2914#define NET_IF_CHECKSUM_IPV6_ICMP_BIT BIT(11)
2915/* Space for future protocols and restrictions for IPV6 */
2916#define NET_IF_CHECKSUM_TCP_BIT BIT(21)
2917#define NET_IF_CHECKSUM_UDP_BIT BIT(22)
2918
2926 NET_IF_CHECKSUM_IPV4_HEADER = NET_IF_CHECKSUM_IPV4_HEADER_BIT,
2928 NET_IF_CHECKSUM_IPV4_TCP = NET_IF_CHECKSUM_IPV4_HEADER_BIT |
2929 NET_IF_CHECKSUM_TCP_BIT,
2931 NET_IF_CHECKSUM_IPV4_UDP = NET_IF_CHECKSUM_IPV4_HEADER_BIT |
2932 NET_IF_CHECKSUM_UDP_BIT,
2934 NET_IF_CHECKSUM_IPV4_ICMP = NET_IF_CHECKSUM_IPV4_ICMP_BIT,
2936 NET_IF_CHECKSUM_IPV6_HEADER = NET_IF_CHECKSUM_IPV6_HEADER_BIT,
2938 NET_IF_CHECKSUM_IPV6_TCP = NET_IF_CHECKSUM_IPV6_HEADER_BIT |
2939 NET_IF_CHECKSUM_TCP_BIT,
2941 NET_IF_CHECKSUM_IPV6_UDP = NET_IF_CHECKSUM_IPV6_HEADER_BIT |
2942 NET_IF_CHECKSUM_UDP_BIT,
2944 NET_IF_CHECKSUM_IPV6_ICMP = NET_IF_CHECKSUM_IPV6_ICMP_BIT
2946
2958 enum net_if_checksum_type chksum_type);
2959
2972 enum net_if_checksum_type chksum_type);
2973
2984__syscall struct net_if *net_if_get_by_index(int index);
2985
2993int net_if_get_by_iface(struct net_if *iface);
2994
3002typedef void (*net_if_cb_t)(struct net_if *iface, void *user_data);
3003
3011void net_if_foreach(net_if_cb_t cb, void *user_data);
3012
3020int net_if_up(struct net_if *iface);
3021
3029static inline bool net_if_is_up(struct net_if *iface)
3030{
3031 if (iface == NULL) {
3032 return false;
3033 }
3034
3035 return net_if_flag_is_set(iface, NET_IF_UP) &&
3037}
3038
3046int net_if_down(struct net_if *iface);
3047
3055static inline bool net_if_is_admin_up(struct net_if *iface)
3056{
3057 if (iface == NULL) {
3058 return false;
3059 }
3060
3061 return net_if_flag_is_set(iface, NET_IF_UP);
3062}
3063
3072void net_if_carrier_on(struct net_if *iface);
3073
3082void net_if_carrier_off(struct net_if *iface);
3083
3091static inline bool net_if_is_carrier_ok(struct net_if *iface)
3092{
3093 if (iface == NULL) {
3094 return false;
3095 }
3096
3097 return net_if_flag_is_set(iface, NET_IF_LOWER_UP);
3098}
3099
3110void net_if_dormant_on(struct net_if *iface);
3111
3120void net_if_dormant_off(struct net_if *iface);
3121
3129static inline bool net_if_is_dormant(struct net_if *iface)
3130{
3131 if (iface == NULL) {
3132 return false;
3133 }
3134
3135 return net_if_flag_is_set(iface, NET_IF_DORMANT);
3136}
3137
3138#if defined(CONFIG_NET_PKT_TIMESTAMP) && defined(CONFIG_NET_NATIVE)
3146typedef void (*net_if_timestamp_callback_t)(struct net_pkt *pkt);
3147
3156struct net_if_timestamp_cb {
3158 sys_snode_t node;
3159
3163 struct net_pkt *pkt;
3164
3168 struct net_if *iface;
3169
3171 net_if_timestamp_callback_t cb;
3172};
3173
3184void net_if_register_timestamp_cb(struct net_if_timestamp_cb *handle,
3185 struct net_pkt *pkt,
3186 struct net_if *iface,
3187 net_if_timestamp_callback_t cb);
3188
3194void net_if_unregister_timestamp_cb(struct net_if_timestamp_cb *handle);
3195
3201void net_if_call_timestamp_cb(struct net_pkt *pkt);
3202
3203/*
3204 * @brief Add timestamped TX buffer to be handled
3205 *
3206 * @param pkt Timestamped buffer
3207 */
3208void net_if_add_tx_timestamp(struct net_pkt *pkt);
3209#endif /* CONFIG_NET_PKT_TIMESTAMP */
3210
3220#if defined(CONFIG_NET_PROMISCUOUS_MODE)
3221int net_if_set_promisc(struct net_if *iface);
3222#else
3223static inline int net_if_set_promisc(struct net_if *iface)
3224{
3225 ARG_UNUSED(iface);
3226
3227 return -ENOTSUP;
3228}
3229#endif
3230
3236#if defined(CONFIG_NET_PROMISCUOUS_MODE)
3237void net_if_unset_promisc(struct net_if *iface);
3238#else
3239static inline void net_if_unset_promisc(struct net_if *iface)
3240{
3241 ARG_UNUSED(iface);
3242}
3243#endif
3244
3253#if defined(CONFIG_NET_PROMISCUOUS_MODE)
3254bool net_if_is_promisc(struct net_if *iface);
3255#else
3256static inline bool net_if_is_promisc(struct net_if *iface)
3257{
3258 ARG_UNUSED(iface);
3259
3260 return false;
3261}
3262#endif
3263
3273static inline bool net_if_are_pending_tx_packets(struct net_if *iface)
3274{
3275#if defined(CONFIG_NET_POWER_MANAGEMENT)
3276 return !!iface->tx_pending;
3277#else
3278 ARG_UNUSED(iface);
3279
3280 return false;
3281#endif
3282}
3283
3284#ifdef CONFIG_NET_POWER_MANAGEMENT
3292int net_if_suspend(struct net_if *iface);
3293
3301int net_if_resume(struct net_if *iface);
3302
3310bool net_if_is_suspended(struct net_if *iface);
3311#endif /* CONFIG_NET_POWER_MANAGEMENT */
3312
3320bool net_if_is_wifi(struct net_if *iface);
3321
3328
3335
3342
3357int net_if_get_name(struct net_if *iface, char *buf, int len);
3358
3373int net_if_set_name(struct net_if *iface, const char *buf);
3374
3382int net_if_get_by_name(const char *name);
3383
3385struct net_if_api {
3386 void (*init)(struct net_if *iface);
3387};
3388
3389#define NET_IF_DHCPV4_INIT \
3390 IF_ENABLED(UTIL_AND(IS_ENABLED(CONFIG_NET_DHCPV4), \
3391 IS_ENABLED(CONFIG_NET_NATIVE_IPV4)), \
3392 (.dhcpv4.state = NET_DHCPV4_DISABLED,))
3393
3394#define NET_IF_DHCPV6_INIT \
3395 IF_ENABLED(UTIL_AND(IS_ENABLED(CONFIG_NET_DHCPV6), \
3396 IS_ENABLED(CONFIG_NET_NATIVE_IPV6)), \
3397 (.dhcpv6.state = NET_DHCPV6_DISABLED,))
3398
3399#define NET_IF_CONFIG_INIT \
3400 .config = { \
3401 IF_ENABLED(CONFIG_NET_IP, (.ip = {},)) \
3402 NET_IF_DHCPV4_INIT \
3403 NET_IF_DHCPV6_INIT \
3404 }
3405
3406#define NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, sfx) \
3407 net_stats_##dev_id##_##sfx##_collector
3408#define NET_PROMETHEUS_INIT(dev_id, sfx) \
3409 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS, \
3410 (.collector = &NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, sfx),))
3411
3412#define NET_IF_GET_NAME(dev_id, sfx) __net_if_##dev_id##_##sfx
3413#define NET_IF_DEV_GET_NAME(dev_id, sfx) __net_if_dev_##dev_id##_##sfx
3414
3415#define NET_IF_GET(dev_id, sfx) \
3416 ((struct net_if *)&NET_IF_GET_NAME(dev_id, sfx))
3417
3418#if defined(CONFIG_NET_STATISTICS_VIA_PROMETHEUS)
3419extern int net_stats_prometheus_scrape(struct prometheus_collector *collector,
3420 struct prometheus_metric *metric,
3421 void *user_data);
3422#endif /* CONFIG_NET_STATISTICS_VIA_PROMETHEUS */
3423
3424#define NET_IF_INIT(dev_id, sfx, _l2, _mtu, _num_configs) \
3425 static STRUCT_SECTION_ITERABLE(net_if_dev, \
3426 NET_IF_DEV_GET_NAME(dev_id, sfx)) = { \
3427 .dev = &(DEVICE_NAME_GET(dev_id)), \
3428 .l2 = &(NET_L2_GET_NAME(_l2)), \
3429 .l2_data = &(NET_L2_GET_DATA(dev_id, sfx)), \
3430 .mtu = _mtu, \
3431 .flags = {BIT(NET_IF_LOWER_UP)}, \
3432 }; \
3433 static Z_DECL_ALIGN(struct net_if) \
3434 NET_IF_GET_NAME(dev_id, sfx)[_num_configs] \
3435 __used __noasan __in_section(_net_if, static, \
3436 dev_id) = { \
3437 [0 ... (_num_configs - 1)] = { \
3438 .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)), \
3439 NET_IF_CONFIG_INIT \
3440 } \
3441 }; \
3442 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS, \
3443 (static PROMETHEUS_COLLECTOR_DEFINE( \
3444 NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, \
3445 sfx), \
3446 net_stats_prometheus_scrape, \
3447 NET_IF_GET(dev_id, sfx)); \
3448 NET_STATS_PROMETHEUS(NET_IF_GET(dev_id, sfx), \
3449 dev_id, sfx);))
3450
3451#define NET_IF_OFFLOAD_INIT(dev_id, sfx, _mtu) \
3452 static STRUCT_SECTION_ITERABLE(net_if_dev, \
3453 NET_IF_DEV_GET_NAME(dev_id, sfx)) = { \
3454 .dev = &(DEVICE_NAME_GET(dev_id)), \
3455 .mtu = _mtu, \
3456 .l2 = &(NET_L2_GET_NAME(OFFLOADED_NETDEV)), \
3457 .flags = {BIT(NET_IF_LOWER_UP)}, \
3458 }; \
3459 static Z_DECL_ALIGN(struct net_if) \
3460 NET_IF_GET_NAME(dev_id, sfx)[NET_IF_MAX_CONFIGS] \
3461 __used __in_section(_net_if, static, \
3462 dev_id) = { \
3463 [0 ... (NET_IF_MAX_CONFIGS - 1)] = { \
3464 .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)), \
3465 NET_IF_CONFIG_INIT \
3466 } \
3467 }; \
3468 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS, \
3469 (static PROMETHEUS_COLLECTOR_DEFINE( \
3470 NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, \
3471 sfx), \
3472 net_stats_prometheus_scrape, \
3473 NET_IF_GET(dev_id, sfx)); \
3474 NET_STATS_PROMETHEUS(NET_IF_GET(dev_id, sfx), \
3475 dev_id, sfx);))
3476
3477
3480/* Network device initialization macros */
3481
3482#define Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, instance, \
3483 init_fn, pm, data, config, prio, \
3484 api, l2, l2_ctx_type, mtu) \
3485 Z_DEVICE_STATE_DEFINE(dev_id); \
3486 Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, NULL, \
3487 Z_DEVICE_DT_FLAGS(node_id), pm, data, \
3488 config, POST_KERNEL, prio, api, \
3489 &Z_DEVICE_STATE_NAME(dev_id)); \
3490 NET_L2_DATA_INIT(dev_id, instance, l2_ctx_type); \
3491 NET_IF_INIT(dev_id, instance, l2, mtu, NET_IF_MAX_CONFIGS)
3492
3493#define Z_NET_DEVICE_INIT(node_id, dev_id, name, init_fn, pm, data, \
3494 config, prio, api, l2, l2_ctx_type, mtu) \
3495 Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, 0, init_fn, \
3496 pm, data, config, prio, api, l2, \
3497 l2_ctx_type, mtu)
3498
3518#define NET_DEVICE_INIT(dev_id, name, init_fn, pm, data, config, prio, \
3519 api, l2, l2_ctx_type, mtu) \
3520 Z_NET_DEVICE_INIT(DT_INVALID_NODE, dev_id, name, init_fn, pm, \
3521 data, config, prio, api, l2, l2_ctx_type, mtu)
3522
3541#define NET_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, \
3542 config, prio, api, l2, l2_ctx_type, mtu) \
3543 Z_NET_DEVICE_INIT(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
3544 DEVICE_DT_NAME(node_id), init_fn, pm, data, \
3545 config, prio, api, l2, l2_ctx_type, mtu)
3546
3555#define NET_DEVICE_DT_INST_DEFINE(inst, ...) \
3556 NET_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
3557
3581#define NET_DEVICE_INIT_INSTANCE(dev_id, name, instance, init_fn, pm, \
3582 data, config, prio, api, l2, \
3583 l2_ctx_type, mtu) \
3584 Z_NET_DEVICE_INIT_INSTANCE(DT_INVALID_NODE, dev_id, name, \
3585 instance, init_fn, pm, data, config, \
3586 prio, api, l2, l2_ctx_type, mtu)
3587
3610#define NET_DEVICE_DT_DEFINE_INSTANCE(node_id, instance, init_fn, pm, \
3611 data, config, prio, api, l2, \
3612 l2_ctx_type, mtu) \
3613 Z_NET_DEVICE_INIT_INSTANCE(node_id, \
3614 Z_DEVICE_DT_DEV_ID(node_id), \
3615 DEVICE_DT_NAME(node_id), instance, \
3616 init_fn, pm, data, config, prio, \
3617 api, l2, l2_ctx_type, mtu)
3618
3628#define NET_DEVICE_DT_INST_DEFINE_INSTANCE(inst, ...) \
3629 NET_DEVICE_DT_DEFINE_INSTANCE(DT_DRV_INST(inst), __VA_ARGS__)
3630
3631#define Z_NET_DEVICE_OFFLOAD_INIT(node_id, dev_id, name, init_fn, pm, \
3632 data, config, prio, api, mtu) \
3633 Z_DEVICE_STATE_DEFINE(dev_id); \
3634 Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, NULL, \
3635 Z_DEVICE_DT_FLAGS(node_id), pm, data, \
3636 config, POST_KERNEL, prio, api, \
3637 &Z_DEVICE_STATE_NAME(dev_id)); \
3638 NET_IF_OFFLOAD_INIT(dev_id, 0, mtu)
3639
3659#define NET_DEVICE_OFFLOAD_INIT(dev_id, name, init_fn, pm, data, \
3660 config, prio, api, mtu) \
3661 Z_NET_DEVICE_OFFLOAD_INIT(DT_INVALID_NODE, dev_id, name, \
3662 init_fn, pm, data, config, prio, api, \
3663 mtu)
3664
3683#define NET_DEVICE_DT_OFFLOAD_DEFINE(node_id, init_fn, pm, data, \
3684 config, prio, api, mtu) \
3685 Z_NET_DEVICE_OFFLOAD_INIT(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
3686 DEVICE_DT_NAME(node_id), init_fn, pm, \
3687 data, config, prio, api, mtu)
3688
3698#define NET_DEVICE_DT_INST_OFFLOAD_DEFINE(inst, ...) \
3699 NET_DEVICE_DT_OFFLOAD_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
3700
3706#define NET_IFACE_COUNT(_dst) \
3707 do { \
3708 extern struct net_if _net_if_list_start[]; \
3709 extern struct net_if _net_if_list_end[]; \
3710 *(_dst) = ((uintptr_t)_net_if_list_end - \
3711 (uintptr_t)_net_if_list_start) / \
3712 sizeof(struct net_if); \
3713 } while (0)
3714
3715#ifdef __cplusplus
3716}
3717#endif
3718
3719#include <zephyr/syscalls/net_if.h>
3720
3725#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:1481
#define K_NO_WAIT
Generate null timeout delay.
Definition kernel.h:1371
static int64_t k_uptime_get(void)
Get system uptime.
Definition kernel.h:1883
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:530
net_addr_type
How the network address is assigned to network interface.
Definition net_ip.h:538
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 struct net_if * net_if_ipv4_select_src_iface_addr(const struct in_addr *dst, const struct in_addr **src_addr)
Get a network interface that should be used when sending IPv4 network data to destination.
Definition net_if.h:2679
static bool net_if_is_carrier_ok(struct net_if *iface)
Check if carrier is present on network device.
Definition net_if.h:3091
static bool net_if_is_admin_up(struct net_if *iface)
Check if interface was brought up by the administrator.
Definition net_if.h:3055
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:1707
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:2858
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:908
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:2563
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:1076
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:1035
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:3273
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:838
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:1205
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:2196
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:1281
static struct net_offload * net_if_offload(struct net_if *iface)
Return the IP offload plugin.
Definition net_if.h:1118
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:1358
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:820
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:2027
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:1993
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:2224
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:1976
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:1090
static bool net_if_is_dormant(struct net_if *iface)
Check if the interface is dormant.
Definition net_if.h:3129
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:1669
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:1391
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:3029
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:2118
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:994
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:2924
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:1238
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:3239
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:1161
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:2085
static bool net_if_is_promisc(struct net_if *iface)
Check if promiscuous mode is set or not.
Definition net_if.h:3256
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:2529
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:1850
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:1260
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:2058
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:1625
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:872
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:957
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:1775
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:3002
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:1376
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:2704
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:2137
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:1900
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:2163
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:307
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_addr(const struct in6_addr *dst, const struct in6_addr **src_addr)
Get a network interface that should be used when sending IPv6 network data to destination.
Definition net_if.h:2272
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:2247
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:890
static struct net_if_config * net_if_config_get(struct net_if *iface)
Get network interface IP config.
Definition net_if.h:1442
static struct net_if_config * net_if_get_config(struct net_if *iface)
Return network configuration for this network interface.
Definition net_if.h:1221
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:1407
net_if_flag
Network interface flags.
Definition net_if.h:249
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:1051
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:653
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:1140
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:2044
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:3223
static const struct net_l2 * net_if_l2(struct net_if *iface)
Get a pointer to the interface L2.
Definition net_if.h:1009
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:1183
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:2654
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:854
@ NET_IF_CHECKSUM_IPV4_ICMP
Interface supports checksum calculation for ICMP4 payload in IPv4.
Definition net_if.h:2934
@ NET_IF_CHECKSUM_IPV6_TCP
Interface supports checksum calculation for TCP payload in IPv6.
Definition net_if.h:2938
@ NET_IF_CHECKSUM_IPV6_UDP
Interface supports checksum calculation for UDP payload in IPv6.
Definition net_if.h:2941
@ NET_IF_CHECKSUM_IPV4_HEADER
Interface supports IP version 4 header checksum calculation.
Definition net_if.h:2926
@ NET_IF_CHECKSUM_IPV4_TCP
Interface supports checksum calculation for TCP payload in IPv4.
Definition net_if.h:2928
@ NET_IF_CHECKSUM_IPV6_HEADER
Interface supports IP version 6 header checksum calculation.
Definition net_if.h:2936
@ NET_IF_CHECKSUM_IPV6_ICMP
Interface supports checksum calculation for ICMP6 payload in IPv6.
Definition net_if.h:2944
@ NET_IF_CHECKSUM_IPV4_UDP
Interface supports checksum calculation for UDP payload in IPv4.
Definition net_if.h:2931
@ NET_IF_OPER_TESTING
Training mode.
Definition net_if.h:312
@ NET_IF_OPER_DORMANT
Waiting external action.
Definition net_if.h:313
@ NET_IF_OPER_UP
Interface is up.
Definition net_if.h:314
@ NET_IF_OPER_NOTPRESENT
Hardware missing.
Definition net_if.h:309
@ NET_IF_OPER_UNKNOWN
Initial (unknown) value.
Definition net_if.h:308
@ NET_IF_OPER_DOWN
Interface is down.
Definition net_if.h:310
@ NET_IF_OPER_LOWERLAYERDOWN
Lower layer interface is down.
Definition net_if.h:311
@ NET_IF_NO_AUTO_START
Do not start the interface immediately after initialization.
Definition net_if.h:265
@ NET_IF_IPV6_NO_MLD
IPv6 Multicast Listener Discovery disabled.
Definition net_if.h:295
@ NET_IF_POINTOPOINT
Interface is pointopoint.
Definition net_if.h:254
@ NET_IF_IPV6_NO_ND
IPv6 Neighbor Discovery disabled.
Definition net_if.h:292
@ NET_IF_FORWARD_MULTICASTS
Flag defines if received multicasts of other interface are forwarded on this interface.
Definition net_if.h:274
@ NET_IF_IPV4
Interface supports IPv4.
Definition net_if.h:277
@ NET_IF_PROMISC
Interface is in promiscuous mode.
Definition net_if.h:257
@ NET_IF_DORMANT
Driver signals dormant.
Definition net_if.h:289
@ NET_IF_SUSPENDED
Power management specific: interface is being suspended.
Definition net_if.h:268
@ NET_IF_IPV6
Interface supports IPv6.
Definition net_if.h:280
@ NET_IF_UP
Interface is admin up.
Definition net_if.h:251
@ NET_IF_LOWER_UP
Driver signals L1 is up.
Definition net_if.h:286
@ NET_IF_RUNNING
Interface up and running (ready to receive and transmit).
Definition net_if.h:283
@ NET_IF_NO_TX_LOCK
Mutex locking on TX data path disabled on the interface.
Definition net_if.h:298
net_link_type
Type of the link address.
Definition net_linkaddr.h:45
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:166
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 EINVAL
Invalid argument.
Definition errno.h:60
#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:510
IPv6 address struct.
Definition net_ip.h:143
IPv4 address struct.
Definition net_ip.h:155
Definition kernel.h:2540
Mutex Structure.
Definition kernel.h:3070
Semaphore structure.
Definition kernel.h:3275
Thread Structure.
Definition thread.h:262
Kernel timeout type.
Definition clock.h:65
Kernel timepoint type.
Definition clock.h:242
DHCPv6 client configuration parameters.
Definition dhcpv6.h:63
Network Interface unicast IPv4 address and netmask.
Definition net_if.h:468
struct net_if_addr ipv4
IPv4 address.
Definition net_if.h:470
struct in_addr netmask
Netmask.
Definition net_if.h:472
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:143
uint8_t is_temporary
Is this IP address temporary and generated for example by IPv6 privacy extension (RFC 8981)
Definition net_if.h:148
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:137
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:151
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:140
IP and other configuration related data for network interface.
Definition net_if.h:586
Network Interface Device structure.
Definition net_if.h:669
enum net_if_oper_state oper_state
RFC 2863 operational status.
Definition net_if.h:705
const struct net_l2 *const l2
Interface's L2 layer.
Definition net_if.h:674
void * l2_data
Interface's private L2 data pointer.
Definition net_if.h:677
uint16_t mtu
The hardware MTU.
Definition net_if.h:695
const struct device * dev
The actually device driver instance the net_if is related to.
Definition net_if.h:671
struct net_linkaddr link_addr
The hardware link address.
Definition net_if.h:683
atomic_t flags[ATOMIC_BITMAP_SIZE(NET_IF_NUM_FLAGS)]
For internal use.
Definition net_if.h:680
int64_t oper_state_change_time
Last time the operational state was changed.
Definition net_if.h:716
Network interface IP address configuration.
Definition net_if.h:573
IPv4 configuration.
Definition net_if.h:476
uint8_t mcast_ttl
IPv4 time-to-live for multicast packets.
Definition net_if.h:490
struct net_if_addr_ipv4 unicast[NET_IF_MAX_IPV4_ADDR]
Unicast IP addresses.
Definition net_if.h:478
struct in_addr gw
Gateway.
Definition net_if.h:484
uint8_t ttl
IPv4 time-to-live.
Definition net_if.h:487
struct net_if_mcast_addr mcast[NET_IF_MAX_IPV4_MADDR]
Multicast IP addresses.
Definition net_if.h:481
Network Interface IPv6 prefixes.
Definition net_if.h:193
struct net_if * iface
Backpointer to network interface where this prefix is used.
Definition net_if.h:201
uint8_t is_infinite
Is the IP prefix valid forever.
Definition net_if.h:207
uint8_t len
Prefix length.
Definition net_if.h:204
struct in6_addr prefix
IPv6 prefix.
Definition net_if.h:198
uint8_t is_used
Is this prefix used or not.
Definition net_if.h:210
struct net_timeout lifetime
Prefix lifetime.
Definition net_if.h:195
IPv6 configuration.
Definition net_if.h:334
struct net_if_ipv6_prefix prefix[NET_IF_MAX_IPV6_PREFIX]
Prefixes.
Definition net_if.h:342
uint32_t base_reachable_time
Default reachable time (RFC 4861, page 52)
Definition net_if.h:345
uint8_t hop_limit
IPv6 hop limit.
Definition net_if.h:383
struct net_if_mcast_addr mcast[NET_IF_MAX_IPV6_MADDR]
Multicast IP addresses.
Definition net_if.h:339
uint32_t retrans_timer
Retransmit timer (RFC 4861, page 52)
Definition net_if.h:351
struct net_if_addr unicast[NET_IF_MAX_IPV6_ADDR]
Unicast IP addresses.
Definition net_if.h:336
uint8_t mcast_hop_limit
IPv6 multicast hop limit.
Definition net_if.h:386
uint32_t reachable_time
Reachable time (RFC 4861, page 20)
Definition net_if.h:348
Network Interface multicast IP addresses.
Definition net_if.h:161
struct net_addr address
IP address.
Definition net_if.h:163
uint8_t is_joined
Did we join to this group.
Definition net_if.h:183
sys_snode_t rejoin_node
Rejoining multicast groups list node.
Definition net_if.h:166
uint8_t is_used
Is this multicast IP address used or not.
Definition net_if.h:180
Multicast monitor handler struct.
Definition net_if.h:1719
sys_snode_t node
Node information for the slist.
Definition net_if.h:1721
net_if_mcast_callback_t cb
Multicast callback.
Definition net_if.h:1727
struct net_if * iface
Network interface.
Definition net_if.h:1724
Information about routers in the system.
Definition net_if.h:220
struct net_if * iface
Network interface the router is connected to.
Definition net_if.h:228
uint8_t is_default
Is default router.
Definition net_if.h:240
uint16_t lifetime
Router lifetime.
Definition net_if.h:234
uint8_t is_infinite
Is the router valid forever.
Definition net_if.h:243
uint8_t is_used
Is this router used or not.
Definition net_if.h:237
struct net_addr address
IP address.
Definition net_if.h:225
sys_snode_t node
Slist lifetime timer node.
Definition net_if.h:222
uint32_t life_start
Router life timer start.
Definition net_if.h:231
Network Interface structure.
Definition net_if.h:726
struct net_if_dev * if_dev
The net_if_dev instance the net_if is related to.
Definition net_if.h:728
struct net_if_config config
Network interface instance configuration.
Definition net_if.h:740
uint8_t pe_enabled
Network interface specific flags.
Definition net_if.h:760
struct k_mutex lock
Mutex protecting this network interface instance.
Definition net_if.h:751
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:765
struct k_mutex tx_lock
Mutex used when sending data.
Definition net_if.h:754
Network L2 structure.
Definition net_l2.h:58
Hardware link address structure.
Definition net_linkaddr.h:70
Network packet.
Definition net_pkt.h:91
All network statistics in one struct.
Definition net_stats.h:406
Generic struct for handling network timeouts.
Definition net_timeout.h:57
Network traffic class.
Definition net_if.h:630
k_thread_stack_t * stack
Stack for this handler.
Definition net_if.h:644
struct k_thread handler
Traffic class handler thread.
Definition net_if.h:641
struct k_fifo fifo
Fifo for handling this Tx or Rx packet.
Definition net_if.h:632
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