Zephyr API Documentation 4.2.0-rc3
A Scalable Open Source RTOS
 4.2.0-rc3
net_if.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2016 Intel Corporation.
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
11
12#ifndef ZEPHYR_INCLUDE_NET_NET_IF_H_
13#define ZEPHYR_INCLUDE_NET_NET_IF_H_
14
23
24#include <zephyr/device.h>
25#include <zephyr/sys/slist.h>
27#include <zephyr/net/net_core.h>
28#include <zephyr/net/hostname.h>
30#include <zephyr/net/net_ip.h>
31#include <zephyr/net/net_l2.h>
34
35#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
36#include <zephyr/net/dhcpv4.h>
37#endif
38#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
39#include <zephyr/net/dhcpv6.h>
40#endif
41#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
43#endif
44
46
47#ifdef __cplusplus
48extern "C" {
49#endif
50
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
462
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
569
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
772
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
813
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
1290
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
1346
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
1525
1527struct net_if_addr *net_if_ipv6_addr_lookup_raw(const uint8_t *addr,
1528 struct net_if **ret);
1530
1540 struct net_if **iface);
1541
1543struct net_if_addr *net_if_ipv6_addr_lookup_by_iface_raw(struct net_if *iface,
1544 const uint8_t *addr);
1546
1556 struct in6_addr *addr);
1557
1566__syscall int net_if_ipv6_addr_lookup_by_index(const struct in6_addr *addr);
1567
1579 struct in6_addr *addr,
1581 uint32_t vlifetime);
1582
1593__syscall bool net_if_ipv6_addr_add_by_index(int index,
1594 struct in6_addr *addr,
1596 uint32_t vlifetime);
1597
1605 uint32_t vlifetime);
1606
1615bool net_if_ipv6_addr_rm(struct net_if *iface, const struct in6_addr *addr);
1616
1625__syscall bool net_if_ipv6_addr_rm_by_index(int index,
1626 const struct in6_addr *addr);
1627
1636typedef void (*net_if_ip_addr_cb_t)(struct net_if *iface,
1637 struct net_if_addr *addr,
1638 void *user_data);
1639
1649 void *user_data);
1650
1660 const struct in6_addr *addr);
1661
1670bool net_if_ipv6_maddr_rm(struct net_if *iface, const struct in6_addr *addr);
1671
1680typedef void (*net_if_ip_maddr_cb_t)(struct net_if *iface,
1681 struct net_if_mcast_addr *maddr,
1682 void *user_data);
1683
1693 void *user_data);
1694
1695
1697struct net_if_mcast_addr *net_if_ipv6_maddr_lookup_raw(const uint8_t *maddr,
1698 struct net_if **ret);
1700
1712 struct net_if **iface);
1713
1724typedef void (*net_if_mcast_callback_t)(struct net_if *iface,
1725 const struct net_addr *addr,
1726 bool is_joined);
1727
1746
1756 struct net_if *iface,
1758
1765
1773void net_if_mcast_monitor(struct net_if *iface, const struct net_addr *addr,
1774 bool is_joined);
1775
1783 struct net_if_mcast_addr *addr);
1784
1792static inline bool net_if_ipv6_maddr_is_joined(struct net_if_mcast_addr *addr)
1793{
1794 if (addr == NULL) {
1795 return false;
1796 }
1797
1798 return addr->is_joined;
1799}
1800
1808 struct net_if_mcast_addr *addr);
1809
1819 const struct in6_addr *addr);
1820
1831 struct in6_addr *addr,
1832 uint8_t len);
1833
1845 struct in6_addr *prefix,
1846 uint8_t len,
1848
1858bool net_if_ipv6_prefix_rm(struct net_if *iface, struct in6_addr *addr,
1859 uint8_t len);
1860
1868 bool is_infinite)
1869{
1870 prefix->is_infinite = is_infinite;
1871}
1872
1881
1888
1899bool net_if_ipv6_addr_onlink(struct net_if **iface, struct in6_addr *addr);
1900
1907#if defined(CONFIG_NET_NATIVE_IPV6)
1908static inline struct in6_addr *net_if_router_ipv6(struct net_if_router *router)
1909{
1910 if (router == NULL) {
1911 return NULL;
1912 }
1913
1914 return &router->address.in6_addr;
1915}
1916#else
1917static inline struct in6_addr *net_if_router_ipv6(struct net_if_router *router)
1918{
1919 static struct in6_addr addr;
1920
1921 ARG_UNUSED(router);
1922
1923 return &addr;
1924}
1925#endif
1926
1937 struct in6_addr *addr);
1938
1949 struct in6_addr *addr);
1950
1959
1970 struct in6_addr *addr,
1971 uint16_t router_lifetime);
1972
1981
1990#if defined(CONFIG_NET_NATIVE_IPV6)
1992#else
1994{
1995 ARG_UNUSED(iface);
1996
1997 return 0;
1998}
1999#endif /* CONFIG_NET_NATIVE_IPV6 */
2000
2007#if defined(CONFIG_NET_NATIVE_IPV6)
2008void net_if_ipv6_set_hop_limit(struct net_if *iface, uint8_t hop_limit);
2009#else
2010static inline void net_if_ipv6_set_hop_limit(struct net_if *iface,
2011 uint8_t hop_limit)
2012{
2013 ARG_UNUSED(iface);
2014 ARG_UNUSED(hop_limit);
2015}
2016#endif /* CONFIG_NET_NATIVE_IPV6 */
2017
2019
2020/* The old hop limit setter function is deprecated because the naming
2021 * of it was incorrect. The API name was missing "_if_" so this function
2022 * should not be used.
2023 */
2024__deprecated
2025static inline void net_ipv6_set_hop_limit(struct net_if *iface,
2026 uint8_t hop_limit)
2027{
2028 net_if_ipv6_set_hop_limit(iface, hop_limit);
2029}
2030
2032
2041#if defined(CONFIG_NET_NATIVE_IPV6)
2043#else
2045{
2046 ARG_UNUSED(iface);
2047
2048 return 0;
2049}
2050#endif /* CONFIG_NET_NATIVE_IPV6 */
2051
2058#if defined(CONFIG_NET_NATIVE_IPV6)
2059void net_if_ipv6_set_mcast_hop_limit(struct net_if *iface, uint8_t hop_limit);
2060#else
2062 uint8_t hop_limit)
2063{
2064 ARG_UNUSED(iface);
2065 ARG_UNUSED(hop_limit);
2066}
2067#endif /* CONFIG_NET_NATIVE_IPV6 */
2068
2076 uint32_t reachable_time)
2077{
2078#if defined(CONFIG_NET_NATIVE_IPV6)
2079 if (iface == NULL) {
2080 return;
2081 }
2082
2083 if (!iface->config.ip.ipv6) {
2084 return;
2085 }
2086
2087 iface->config.ip.ipv6->base_reachable_time = reachable_time;
2088#else
2089 ARG_UNUSED(iface);
2090 ARG_UNUSED(reachable_time);
2091
2092#endif
2093}
2094
2103{
2104#if defined(CONFIG_NET_NATIVE_IPV6)
2105 if (iface == NULL) {
2106 return 0;
2107 }
2108
2109 if (!iface->config.ip.ipv6) {
2110 return 0;
2111 }
2112
2113 return iface->config.ip.ipv6->reachable_time;
2114#else
2115 ARG_UNUSED(iface);
2116 return 0;
2117#endif
2118}
2119
2128
2135static inline void net_if_ipv6_set_reachable_time(struct net_if_ipv6 *ipv6)
2136{
2137#if defined(CONFIG_NET_NATIVE_IPV6)
2138 if (ipv6 == NULL) {
2139 return;
2140 }
2141
2143#else
2144 ARG_UNUSED(ipv6);
2145#endif
2146}
2147
2154static inline void net_if_ipv6_set_retrans_timer(struct net_if *iface,
2155 uint32_t retrans_timer)
2156{
2157#if defined(CONFIG_NET_NATIVE_IPV6)
2158 if (iface == NULL) {
2159 return;
2160 }
2161
2162 if (!iface->config.ip.ipv6) {
2163 return;
2164 }
2165
2166 iface->config.ip.ipv6->retrans_timer = retrans_timer;
2167#else
2168 ARG_UNUSED(iface);
2169 ARG_UNUSED(retrans_timer);
2170#endif
2171}
2172
2181{
2182#if defined(CONFIG_NET_NATIVE_IPV6)
2183 if (iface == NULL) {
2184 return 0;
2185 }
2186
2187 if (!iface->config.ip.ipv6) {
2188 return 0;
2189 }
2190
2191 return iface->config.ip.ipv6->retrans_timer;
2192#else
2193 ARG_UNUSED(iface);
2194 return 0;
2195#endif
2196}
2197
2209#if defined(CONFIG_NET_IPV6)
2210const struct in6_addr *net_if_ipv6_select_src_addr(struct net_if *iface,
2211 const struct in6_addr *dst);
2212#else
2213static inline const struct in6_addr *net_if_ipv6_select_src_addr(
2214 struct net_if *iface, const struct in6_addr *dst)
2215{
2216 ARG_UNUSED(iface);
2217 ARG_UNUSED(dst);
2218
2219 return NULL;
2220}
2221#endif
2222
2236#if defined(CONFIG_NET_IPV6)
2237const struct in6_addr *net_if_ipv6_select_src_addr_hint(struct net_if *iface,
2238 const struct in6_addr *dst,
2239 int flags);
2240#else
2241static inline const struct in6_addr *net_if_ipv6_select_src_addr_hint(
2242 struct net_if *iface, const struct in6_addr *dst, int flags)
2243{
2244 ARG_UNUSED(iface);
2245 ARG_UNUSED(dst);
2246 ARG_UNUSED(flags);
2247
2248 return NULL;
2249}
2250#endif
2251
2261#if defined(CONFIG_NET_IPV6)
2262struct net_if *net_if_ipv6_select_src_iface(const struct in6_addr *dst);
2263#else
2265 const struct in6_addr *dst)
2266{
2267 ARG_UNUSED(dst);
2268
2269 return NULL;
2270}
2271#endif
2272
2285#if defined(CONFIG_NET_IPV6)
2286struct net_if *net_if_ipv6_select_src_iface_addr(const struct in6_addr *dst,
2287 const struct in6_addr **src_addr);
2288#else
2290 const struct in6_addr *dst, const struct in6_addr **src_addr)
2291{
2292 ARG_UNUSED(dst);
2293 ARG_UNUSED(src_addr);
2294
2295 return NULL;
2296}
2297#endif /* CONFIG_NET_IPV6 */
2298
2308struct in6_addr *net_if_ipv6_get_ll(struct net_if *iface,
2309 enum net_addr_state addr_state);
2310
2321 struct net_if **iface);
2322
2330void net_if_ipv6_dad_failed(struct net_if *iface, const struct in6_addr *addr);
2331
2344 struct net_if **iface);
2345
2357 struct net_if_ipv4 **ipv4);
2358
2367
2376
2383void net_if_ipv4_set_ttl(struct net_if *iface, uint8_t ttl);
2384
2393
2401
2411 struct net_if **iface);
2412
2424 struct in_addr *addr,
2426 uint32_t vlifetime);
2427
2436bool net_if_ipv4_addr_rm(struct net_if *iface, const struct in_addr *addr);
2437
2446__syscall int net_if_ipv4_addr_lookup_by_index(const struct in_addr *addr);
2447
2458__syscall bool net_if_ipv4_addr_add_by_index(int index,
2459 struct in_addr *addr,
2461 uint32_t vlifetime);
2462
2471__syscall bool net_if_ipv4_addr_rm_by_index(int index,
2472 const struct in_addr *addr);
2473
2483 void *user_data);
2484
2494 const struct in_addr *addr);
2495
2504bool net_if_ipv4_maddr_rm(struct net_if *iface, const struct in_addr *addr);
2505
2515 void *user_data);
2516
2528 struct net_if **iface);
2529
2537 struct net_if_mcast_addr *addr);
2538
2546static inline bool net_if_ipv4_maddr_is_joined(struct net_if_mcast_addr *addr)
2547{
2548 if (addr == NULL) {
2549 return false;
2550 }
2551
2552 return addr->is_joined;
2553}
2554
2562 struct net_if_mcast_addr *addr);
2563
2570#if defined(CONFIG_NET_NATIVE_IPV4)
2571static inline struct in_addr *net_if_router_ipv4(struct net_if_router *router)
2572{
2573 if (router == NULL) {
2574 return NULL;
2575 }
2576
2577 return &router->address.in_addr;
2578}
2579#else
2580static inline struct in_addr *net_if_router_ipv4(struct net_if_router *router)
2581{
2582 static struct in_addr addr;
2583
2584 ARG_UNUSED(router);
2585
2586 return &addr;
2587}
2588#endif
2589
2600 struct in_addr *addr);
2601
2612 struct in_addr *addr);
2624 struct in_addr *addr,
2625 bool is_default,
2626 uint16_t router_lifetime);
2627
2636
2646 const struct in_addr *addr);
2647
2657 const struct in_addr *addr);
2658
2668#if defined(CONFIG_NET_IPV4)
2669struct net_if *net_if_ipv4_select_src_iface(const struct in_addr *dst);
2670#else
2672 const struct in_addr *dst)
2673{
2674 ARG_UNUSED(dst);
2675
2676 return NULL;
2677}
2678#endif
2679
2692#if defined(CONFIG_NET_IPV4)
2693struct net_if *net_if_ipv4_select_src_iface_addr(const struct in_addr *dst,
2694 const struct in_addr **src_addr);
2695#else
2697 const struct in_addr *dst, const struct in_addr **src_addr)
2698{
2699 ARG_UNUSED(dst);
2700 ARG_UNUSED(src_addr);
2701
2702 return NULL;
2703}
2704#endif /* CONFIG_NET_IPV4 */
2705
2717#if defined(CONFIG_NET_IPV4)
2718const struct in_addr *net_if_ipv4_select_src_addr(struct net_if *iface,
2719 const struct in_addr *dst);
2720#else
2721static inline const struct in_addr *net_if_ipv4_select_src_addr(
2722 struct net_if *iface, const struct in_addr *dst)
2723{
2724 ARG_UNUSED(iface);
2725 ARG_UNUSED(dst);
2726
2727 return NULL;
2728}
2729#endif
2730
2740struct in_addr *net_if_ipv4_get_ll(struct net_if *iface,
2741 enum net_addr_state addr_state);
2742
2753 enum net_addr_state addr_state);
2754
2765 const struct in_addr *addr);
2766
2776__deprecated struct in_addr net_if_ipv4_get_netmask(struct net_if *iface);
2777
2786__deprecated void net_if_ipv4_set_netmask(struct net_if *iface,
2787 const struct in_addr *netmask);
2788
2799__deprecated __syscall bool net_if_ipv4_set_netmask_by_index(int index,
2800 const struct in_addr *netmask);
2801
2812 const struct in_addr *addr,
2813 const struct in_addr *netmask);
2814
2825 const struct in_addr *addr,
2826 const struct in_addr *netmask);
2827
2835struct in_addr net_if_ipv4_get_gw(struct net_if *iface);
2836
2843void net_if_ipv4_set_gw(struct net_if *iface, const struct in_addr *gw);
2844
2853__syscall bool net_if_ipv4_set_gw_by_index(int index, const struct in_addr *gw);
2854
2865struct net_if *net_if_select_src_iface(const struct sockaddr *dst);
2866
2875typedef void (*net_if_link_callback_t)(struct net_if *iface,
2876 struct net_linkaddr *dst,
2877 int status);
2878
2894
2903
2910
2918void net_if_call_link_cb(struct net_if *iface, struct net_linkaddr *lladdr,
2919 int status);
2920
2922
2923/* used to ensure encoding of checksum support in net_if.h and
2924 * ethernet.h is the same
2925 */
2926#define NET_IF_CHECKSUM_NONE_BIT 0
2927#define NET_IF_CHECKSUM_IPV4_HEADER_BIT BIT(0)
2928#define NET_IF_CHECKSUM_IPV4_ICMP_BIT BIT(1)
2929/* Space for future protocols and restrictions for IPV4 */
2930#define NET_IF_CHECKSUM_IPV6_HEADER_BIT BIT(10)
2931#define NET_IF_CHECKSUM_IPV6_ICMP_BIT BIT(11)
2932/* Space for future protocols and restrictions for IPV6 */
2933#define NET_IF_CHECKSUM_TCP_BIT BIT(21)
2934#define NET_IF_CHECKSUM_UDP_BIT BIT(22)
2935
2937
2943 NET_IF_CHECKSUM_IPV4_HEADER = NET_IF_CHECKSUM_IPV4_HEADER_BIT,
2945 NET_IF_CHECKSUM_IPV4_TCP = NET_IF_CHECKSUM_IPV4_HEADER_BIT |
2946 NET_IF_CHECKSUM_TCP_BIT,
2948 NET_IF_CHECKSUM_IPV4_UDP = NET_IF_CHECKSUM_IPV4_HEADER_BIT |
2949 NET_IF_CHECKSUM_UDP_BIT,
2951 NET_IF_CHECKSUM_IPV4_ICMP = NET_IF_CHECKSUM_IPV4_ICMP_BIT,
2953 NET_IF_CHECKSUM_IPV6_HEADER = NET_IF_CHECKSUM_IPV6_HEADER_BIT,
2955 NET_IF_CHECKSUM_IPV6_TCP = NET_IF_CHECKSUM_IPV6_HEADER_BIT |
2956 NET_IF_CHECKSUM_TCP_BIT,
2958 NET_IF_CHECKSUM_IPV6_UDP = NET_IF_CHECKSUM_IPV6_HEADER_BIT |
2959 NET_IF_CHECKSUM_UDP_BIT,
2961 NET_IF_CHECKSUM_IPV6_ICMP = NET_IF_CHECKSUM_IPV6_ICMP_BIT
2962};
2963
2975 enum net_if_checksum_type chksum_type);
2976
2989 enum net_if_checksum_type chksum_type);
2990
3001__syscall struct net_if *net_if_get_by_index(int index);
3002
3010int net_if_get_by_iface(struct net_if *iface);
3011
3019typedef void (*net_if_cb_t)(struct net_if *iface, void *user_data);
3020
3028void net_if_foreach(net_if_cb_t cb, void *user_data);
3029
3037int net_if_up(struct net_if *iface);
3038
3046static inline bool net_if_is_up(struct net_if *iface)
3047{
3048 if (iface == NULL) {
3049 return false;
3050 }
3051
3052 return net_if_flag_is_set(iface, NET_IF_UP) &&
3054}
3055
3063int net_if_down(struct net_if *iface);
3064
3072static inline bool net_if_is_admin_up(struct net_if *iface)
3073{
3074 if (iface == NULL) {
3075 return false;
3076 }
3077
3078 return net_if_flag_is_set(iface, NET_IF_UP);
3079}
3080
3089void net_if_carrier_on(struct net_if *iface);
3090
3099void net_if_carrier_off(struct net_if *iface);
3100
3108static inline bool net_if_is_carrier_ok(struct net_if *iface)
3109{
3110 if (iface == NULL) {
3111 return false;
3112 }
3113
3114 return net_if_flag_is_set(iface, NET_IF_LOWER_UP);
3115}
3116
3127void net_if_dormant_on(struct net_if *iface);
3128
3137void net_if_dormant_off(struct net_if *iface);
3138
3146static inline bool net_if_is_dormant(struct net_if *iface)
3147{
3148 if (iface == NULL) {
3149 return false;
3150 }
3151
3152 return net_if_flag_is_set(iface, NET_IF_DORMANT);
3153}
3154
3155#if defined(CONFIG_NET_PKT_TIMESTAMP) && defined(CONFIG_NET_NATIVE)
3163typedef void (*net_if_timestamp_callback_t)(struct net_pkt *pkt);
3164
3173struct net_if_timestamp_cb {
3175 sys_snode_t node;
3176
3180 struct net_pkt *pkt;
3181
3185 struct net_if *iface;
3186
3188 net_if_timestamp_callback_t cb;
3189};
3190
3201void net_if_register_timestamp_cb(struct net_if_timestamp_cb *handle,
3202 struct net_pkt *pkt,
3203 struct net_if *iface,
3204 net_if_timestamp_callback_t cb);
3205
3211void net_if_unregister_timestamp_cb(struct net_if_timestamp_cb *handle);
3212
3218void net_if_call_timestamp_cb(struct net_pkt *pkt);
3219
3220/*
3221 * @brief Add timestamped TX buffer to be handled
3222 *
3223 * @param pkt Timestamped buffer
3224 */
3225void net_if_add_tx_timestamp(struct net_pkt *pkt);
3226#endif /* CONFIG_NET_PKT_TIMESTAMP */
3227
3237#if defined(CONFIG_NET_PROMISCUOUS_MODE)
3238int net_if_set_promisc(struct net_if *iface);
3239#else
3240static inline int net_if_set_promisc(struct net_if *iface)
3241{
3242 ARG_UNUSED(iface);
3243
3244 return -ENOTSUP;
3245}
3246#endif
3247
3253#if defined(CONFIG_NET_PROMISCUOUS_MODE)
3254void net_if_unset_promisc(struct net_if *iface);
3255#else
3256static inline void net_if_unset_promisc(struct net_if *iface)
3257{
3258 ARG_UNUSED(iface);
3259}
3260#endif
3261
3270#if defined(CONFIG_NET_PROMISCUOUS_MODE)
3271bool net_if_is_promisc(struct net_if *iface);
3272#else
3273static inline bool net_if_is_promisc(struct net_if *iface)
3274{
3275 ARG_UNUSED(iface);
3276
3277 return false;
3278}
3279#endif
3280
3290static inline bool net_if_are_pending_tx_packets(struct net_if *iface)
3291{
3292#if defined(CONFIG_NET_POWER_MANAGEMENT)
3293 return !!iface->tx_pending;
3294#else
3295 ARG_UNUSED(iface);
3296
3297 return false;
3298#endif
3299}
3300
3301#ifdef CONFIG_NET_POWER_MANAGEMENT
3309int net_if_suspend(struct net_if *iface);
3310
3318int net_if_resume(struct net_if *iface);
3319
3327bool net_if_is_suspended(struct net_if *iface);
3328#endif /* CONFIG_NET_POWER_MANAGEMENT */
3329
3337bool net_if_is_wifi(struct net_if *iface);
3338
3345
3352
3359
3374int net_if_get_name(struct net_if *iface, char *buf, int len);
3375
3390int net_if_set_name(struct net_if *iface, const char *buf);
3391
3399int net_if_get_by_name(const char *name);
3400
3402struct net_if_api {
3403 void (*init)(struct net_if *iface);
3404};
3405
3406#define NET_IF_DHCPV4_INIT \
3407 IF_ENABLED(UTIL_AND(IS_ENABLED(CONFIG_NET_DHCPV4), \
3408 IS_ENABLED(CONFIG_NET_NATIVE_IPV4)), \
3409 (.dhcpv4.state = NET_DHCPV4_DISABLED,))
3410
3411#define NET_IF_DHCPV6_INIT \
3412 IF_ENABLED(UTIL_AND(IS_ENABLED(CONFIG_NET_DHCPV6), \
3413 IS_ENABLED(CONFIG_NET_NATIVE_IPV6)), \
3414 (.dhcpv6.state = NET_DHCPV6_DISABLED,))
3415
3416#define NET_IF_CONFIG_INIT \
3417 .config = { \
3418 IF_ENABLED(CONFIG_NET_IP, (.ip = {},)) \
3419 NET_IF_DHCPV4_INIT \
3420 NET_IF_DHCPV6_INIT \
3421 }
3422
3423#define NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, sfx) \
3424 net_stats_##dev_id##_##sfx##_collector
3425#define NET_PROMETHEUS_INIT(dev_id, sfx) \
3426 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS, \
3427 (.collector = &NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, sfx),))
3428
3429#define NET_IF_GET_NAME(dev_id, sfx) __net_if_##dev_id##_##sfx
3430#define NET_IF_DEV_GET_NAME(dev_id, sfx) __net_if_dev_##dev_id##_##sfx
3431
3432#define NET_IF_GET(dev_id, sfx) \
3433 ((struct net_if *)&NET_IF_GET_NAME(dev_id, sfx))
3434
3435#if defined(CONFIG_NET_STATISTICS_VIA_PROMETHEUS)
3436extern int net_stats_prometheus_scrape(struct prometheus_collector *collector,
3437 struct prometheus_metric *metric,
3438 void *user_data);
3439#endif /* CONFIG_NET_STATISTICS_VIA_PROMETHEUS */
3440
3441#define NET_IF_INIT(dev_id, sfx, _l2, _mtu, _num_configs) \
3442 static STRUCT_SECTION_ITERABLE(net_if_dev, \
3443 NET_IF_DEV_GET_NAME(dev_id, sfx)) = { \
3444 .dev = &(DEVICE_NAME_GET(dev_id)), \
3445 .l2 = &(NET_L2_GET_NAME(_l2)), \
3446 .l2_data = &(NET_L2_GET_DATA(dev_id, sfx)), \
3447 .mtu = _mtu, \
3448 .flags = {BIT(NET_IF_LOWER_UP)}, \
3449 }; \
3450 static Z_DECL_ALIGN(struct net_if) \
3451 NET_IF_GET_NAME(dev_id, sfx)[_num_configs] \
3452 __used __noasan __in_section(_net_if, static, \
3453 dev_id) = { \
3454 [0 ... (_num_configs - 1)] = { \
3455 .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)), \
3456 NET_IF_CONFIG_INIT \
3457 } \
3458 }; \
3459 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS, \
3460 (static PROMETHEUS_COLLECTOR_DEFINE( \
3461 NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, \
3462 sfx), \
3463 net_stats_prometheus_scrape, \
3464 NET_IF_GET(dev_id, sfx)); \
3465 NET_STATS_PROMETHEUS(NET_IF_GET(dev_id, sfx), \
3466 dev_id, sfx);))
3467
3468#define NET_IF_OFFLOAD_INIT(dev_id, sfx, _mtu) \
3469 static STRUCT_SECTION_ITERABLE(net_if_dev, \
3470 NET_IF_DEV_GET_NAME(dev_id, sfx)) = { \
3471 .dev = &(DEVICE_NAME_GET(dev_id)), \
3472 .mtu = _mtu, \
3473 .l2 = &(NET_L2_GET_NAME(OFFLOADED_NETDEV)), \
3474 .flags = {BIT(NET_IF_LOWER_UP)}, \
3475 }; \
3476 static Z_DECL_ALIGN(struct net_if) \
3477 NET_IF_GET_NAME(dev_id, sfx)[NET_IF_MAX_CONFIGS] \
3478 __used __in_section(_net_if, static, \
3479 dev_id) = { \
3480 [0 ... (NET_IF_MAX_CONFIGS - 1)] = { \
3481 .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)), \
3482 NET_IF_CONFIG_INIT \
3483 } \
3484 }; \
3485 IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS, \
3486 (static PROMETHEUS_COLLECTOR_DEFINE( \
3487 NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, \
3488 sfx), \
3489 net_stats_prometheus_scrape, \
3490 NET_IF_GET(dev_id, sfx)); \
3491 NET_STATS_PROMETHEUS(NET_IF_GET(dev_id, sfx), \
3492 dev_id, sfx);))
3493
3494
3496
3497/* Network device initialization macros */
3498
3499#define Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, instance, \
3500 init_fn, pm, data, config, prio, \
3501 api, l2, l2_ctx_type, mtu) \
3502 Z_DEVICE_STATE_DEFINE(dev_id); \
3503 Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, NULL, \
3504 Z_DEVICE_DT_FLAGS(node_id), pm, data, \
3505 config, POST_KERNEL, prio, api, \
3506 &Z_DEVICE_STATE_NAME(dev_id)); \
3507 NET_L2_DATA_INIT(dev_id, instance, l2_ctx_type); \
3508 NET_IF_INIT(dev_id, instance, l2, mtu, NET_IF_MAX_CONFIGS)
3509
3510#define Z_NET_DEVICE_INIT(node_id, dev_id, name, init_fn, pm, data, \
3511 config, prio, api, l2, l2_ctx_type, mtu) \
3512 Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, 0, init_fn, \
3513 pm, data, config, prio, api, l2, \
3514 l2_ctx_type, mtu)
3515
3535#define NET_DEVICE_INIT(dev_id, name, init_fn, pm, data, config, prio, \
3536 api, l2, l2_ctx_type, mtu) \
3537 Z_NET_DEVICE_INIT(DT_INVALID_NODE, dev_id, name, init_fn, pm, \
3538 data, config, prio, api, l2, l2_ctx_type, mtu)
3539
3558#define NET_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, \
3559 config, prio, api, l2, l2_ctx_type, mtu) \
3560 Z_NET_DEVICE_INIT(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
3561 DEVICE_DT_NAME(node_id), init_fn, pm, data, \
3562 config, prio, api, l2, l2_ctx_type, mtu)
3563
3572#define NET_DEVICE_DT_INST_DEFINE(inst, ...) \
3573 NET_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
3574
3598#define NET_DEVICE_INIT_INSTANCE(dev_id, name, instance, init_fn, pm, \
3599 data, config, prio, api, l2, \
3600 l2_ctx_type, mtu) \
3601 Z_NET_DEVICE_INIT_INSTANCE(DT_INVALID_NODE, dev_id, name, \
3602 instance, init_fn, pm, data, config, \
3603 prio, api, l2, l2_ctx_type, mtu)
3604
3627#define NET_DEVICE_DT_DEFINE_INSTANCE(node_id, instance, init_fn, pm, \
3628 data, config, prio, api, l2, \
3629 l2_ctx_type, mtu) \
3630 Z_NET_DEVICE_INIT_INSTANCE(node_id, \
3631 Z_DEVICE_DT_DEV_ID(node_id), \
3632 DEVICE_DT_NAME(node_id), instance, \
3633 init_fn, pm, data, config, prio, \
3634 api, l2, l2_ctx_type, mtu)
3635
3645#define NET_DEVICE_DT_INST_DEFINE_INSTANCE(inst, ...) \
3646 NET_DEVICE_DT_DEFINE_INSTANCE(DT_DRV_INST(inst), __VA_ARGS__)
3647
3648#define Z_NET_DEVICE_OFFLOAD_INIT(node_id, dev_id, name, init_fn, pm, \
3649 data, config, prio, api, mtu) \
3650 Z_DEVICE_STATE_DEFINE(dev_id); \
3651 Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, NULL, \
3652 Z_DEVICE_DT_FLAGS(node_id), pm, data, \
3653 config, POST_KERNEL, prio, api, \
3654 &Z_DEVICE_STATE_NAME(dev_id)); \
3655 NET_IF_OFFLOAD_INIT(dev_id, 0, mtu)
3656
3676#define NET_DEVICE_OFFLOAD_INIT(dev_id, name, init_fn, pm, data, \
3677 config, prio, api, mtu) \
3678 Z_NET_DEVICE_OFFLOAD_INIT(DT_INVALID_NODE, dev_id, name, \
3679 init_fn, pm, data, config, prio, api, \
3680 mtu)
3681
3700#define NET_DEVICE_DT_OFFLOAD_DEFINE(node_id, init_fn, pm, data, \
3701 config, prio, api, mtu) \
3702 Z_NET_DEVICE_OFFLOAD_INIT(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
3703 DEVICE_DT_NAME(node_id), init_fn, pm, \
3704 data, config, prio, api, mtu)
3705
3715#define NET_DEVICE_DT_INST_OFFLOAD_DEFINE(inst, ...) \
3716 NET_DEVICE_DT_OFFLOAD_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
3717
3723#define NET_IFACE_COUNT(_dst) \
3724 do { \
3725 extern struct net_if _net_if_list_start[]; \
3726 extern struct net_if _net_if_list_end[]; \
3727 *(_dst) = ((uintptr_t)_net_if_list_end - \
3728 (uintptr_t)_net_if_list_start) / \
3729 sizeof(struct net_if); \
3730 } while (0)
3731
3732#ifdef __cplusplus
3733}
3734#endif
3735
3736#include <zephyr/syscalls/net_if.h>
3737
3741
3742#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:532
net_addr_type
How the network address is assigned to network interface.
Definition net_ip.h:540
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:2696
static bool net_if_is_carrier_ok(struct net_if *iface)
Check if carrier is present on network device.
Definition net_if.h:3108
static bool net_if_is_admin_up(struct net_if *iface)
Check if interface was brought up by the administrator.
Definition net_if.h:3072
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:1724
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:2875
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:2580
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:3290
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:2213
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:2044
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:2010
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:2241
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:1993
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:3146
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:1680
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:3046
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:2135
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:2941
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:3256
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:2102
static bool net_if_is_promisc(struct net_if *iface)
Check if promiscuous mode is set or not.
Definition net_if.h:3273
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:2546
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:1867
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:2075
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:1636
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:1792
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:3019
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:2721
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:2154
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:1917
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:2180
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:2289
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:2264
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:2061
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:3240
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:2671
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:2951
@ NET_IF_CHECKSUM_IPV6_TCP
Interface supports checksum calculation for TCP payload in IPv6.
Definition net_if.h:2955
@ NET_IF_CHECKSUM_IPV6_UDP
Interface supports checksum calculation for UDP payload in IPv6.
Definition net_if.h:2958
@ NET_IF_CHECKSUM_IPV4_HEADER
Interface supports IP version 4 header checksum calculation.
Definition net_if.h:2943
@ NET_IF_CHECKSUM_IPV4_TCP
Interface supports checksum calculation for TCP payload in IPv4.
Definition net_if.h:2945
@ NET_IF_CHECKSUM_IPV6_HEADER
Interface supports IP version 6 header checksum calculation.
Definition net_if.h:2953
@ NET_IF_CHECKSUM_IPV6_ICMP
Interface supports checksum calculation for ICMP6 payload in IPv6.
Definition net_if.h:2961
@ NET_IF_CHECKSUM_IPV4_UDP
Interface supports checksum calculation for UDP payload in IPv4.
Definition net_if.h:2948
@ 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:1736
sys_snode_t node
Node information for the slist.
Definition net_if.h:1738
net_if_mcast_callback_t cb
Multicast callback.
Definition net_if.h:1744
struct net_if * iface
Network interface.
Definition net_if.h:1741
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:410