Zephyr API Documentation  3.6.99
A Scalable Open Source RTOS
Loading...
Searching...
No Matches
net_if.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2016 Intel Corporation.
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
12#ifndef ZEPHYR_INCLUDE_NET_NET_IF_H_
13#define ZEPHYR_INCLUDE_NET_NET_IF_H_
14
22#include <zephyr/device.h>
23#include <zephyr/sys/slist.h>
25#include <zephyr/net/net_core.h>
26#include <zephyr/net/hostname.h>
28#include <zephyr/net/net_ip.h>
29#include <zephyr/net/net_l2.h>
32
33#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
34#include <zephyr/net/dhcpv4.h>
35#endif
36#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
37#include <zephyr/net/dhcpv6.h>
38#endif
39#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
41#endif
42
43#ifdef __cplusplus
44extern "C" {
45#endif
46
54 struct net_addr address;
55
60
61#if defined(CONFIG_NET_NATIVE_IPV6)
62 struct net_timeout lifetime;
63#endif
64
67
70
71#if defined(CONFIG_NET_NATIVE_IPV6)
72#if defined(CONFIG_NET_IPV6_PE)
76 uint32_t addr_create_time;
77
80 uint32_t addr_preferred_lifetime;
81
86 int32_t addr_timeout;
87#endif
88#endif /* CONFIG_NET_NATIVE_IPV6 */
89
90 union {
91#if defined(CONFIG_NET_IPV6_DAD)
92 struct {
94 sys_snode_t dad_node;
95 uint32_t dad_start;
96
98 uint8_t dad_count;
99 };
100#endif /* CONFIG_NET_IPV6_DAD */
101#if defined(CONFIG_NET_IPV4_ACD)
102 struct {
104 sys_snode_t acd_node;
105 k_timepoint_t acd_timeout;
106
108 uint8_t acd_count;
109
111 uint8_t acd_state;
112 };
113#endif /* CONFIG_NET_IPV4_ACD */
114 };
115
116#if defined(CONFIG_NET_IPV6_DAD) || defined(CONFIG_NET_IPV4_ACD)
118 uint8_t ifindex;
119#endif
120
123
126
129
134
135 uint8_t _unused : 4;
136};
137
145 struct net_addr address;
146
147#if defined(CONFIG_NET_IPV4_IGMPV3)
149 struct net_addr sources[CONFIG_NET_IF_MCAST_IPV4_SOURCE_COUNT];
150
152 uint16_t sources_len;
153
155 uint8_t record_type;
156#endif
157
160
163
164 uint8_t _unused : 6;
165};
166
175
178
180 struct net_if *iface;
181
184
187
190
191 uint8_t _unused : 6;
192};
193
202
204 struct net_addr address;
205
207 struct net_if *iface;
208
211
214
217
220
223
224 uint8_t _unused : 5;
225};
226
231
234
237
245
248
254
257
260
263
266
269
272
275
278
280 /* Total number of flags - must be at the end of the enum */
281 NET_IF_NUM_FLAGS
283};
284
294} __packed;
295
296#if defined(CONFIG_NET_OFFLOAD)
297struct net_offload;
298#endif /* CONFIG_NET_OFFLOAD */
299
301#if defined(CONFIG_NET_NATIVE_IPV6)
302#define NET_IF_MAX_IPV6_ADDR CONFIG_NET_IF_UNICAST_IPV6_ADDR_COUNT
303#define NET_IF_MAX_IPV6_MADDR CONFIG_NET_IF_MCAST_IPV6_ADDR_COUNT
304#define NET_IF_MAX_IPV6_PREFIX CONFIG_NET_IF_IPV6_PREFIX_COUNT
305#else
306#define NET_IF_MAX_IPV6_ADDR 0
307#define NET_IF_MAX_IPV6_MADDR 0
308#define NET_IF_MAX_IPV6_PREFIX 0
309#endif
310/* @endcond */
311
315 struct net_if_addr unicast[NET_IF_MAX_IPV6_ADDR];
316
318 struct net_if_mcast_addr mcast[NET_IF_MAX_IPV6_MADDR];
319
321 struct net_if_ipv6_prefix prefix[NET_IF_MAX_IPV6_PREFIX];
322
325
328
331
332#if defined(CONFIG_NET_IPV6_PE)
337 uint32_t desync_factor;
338#endif /* CONFIG_NET_IPV6_PE */
339
340#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
342 sys_snode_t rs_node;
343
344 /* RS start time */
345 uint32_t rs_start;
346
348 uint8_t rs_count;
349#endif
350
353
356};
357
358#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
360struct net_if_dhcpv6 {
362 sys_snode_t node;
363
365 struct net_dhcpv6_duid_storage clientid;
366
368 struct net_dhcpv6_duid_storage serverid;
369
371 enum net_dhcpv6_state state;
372
374 struct net_dhcpv6_params params;
375
377 uint64_t timeout;
378
380 uint64_t exchange_start;
381
383 uint64_t t1;
384
386 uint64_t t2;
387
391 uint64_t expire;
392
394 uint32_t addr_iaid;
395
397 uint32_t prefix_iaid;
398
400 uint32_t retransmit_timeout;
401
403 int16_t server_preference;
404
406 uint8_t retransmissions;
407
409 uint8_t tid[DHCPV6_TID_SIZE];
410
412 uint8_t prefix_len;
413
415 struct in6_addr prefix;
416
418 struct in6_addr addr;
419};
420#endif /* defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6) */
421
423#if defined(CONFIG_NET_NATIVE_IPV4)
424#define NET_IF_MAX_IPV4_ADDR CONFIG_NET_IF_UNICAST_IPV4_ADDR_COUNT
425#define NET_IF_MAX_IPV4_MADDR CONFIG_NET_IF_MCAST_IPV4_ADDR_COUNT
426#else
427#define NET_IF_MAX_IPV4_ADDR 0
428#define NET_IF_MAX_IPV4_MADDR 0
429#endif
442};
443
447 struct net_if_addr_ipv4 unicast[NET_IF_MAX_IPV4_ADDR];
448
450 struct net_if_mcast_addr mcast[NET_IF_MAX_IPV4_MADDR];
451
453 struct in_addr gw;
454
457
460
461#if defined(CONFIG_NET_IPV4_ACD)
463 uint8_t conflict_cnt;
464#endif
465};
466
467#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
468struct net_if_dhcpv4 {
470 sys_snode_t node;
471
473 int64_t timer_start;
474
476 uint32_t request_time;
477
478 uint32_t xid;
479
481 uint32_t lease_time;
482
484 uint32_t renewal_time;
485
487 uint32_t rebinding_time;
488
490 struct in_addr server_id;
491
493 struct in_addr requested_ip;
494
496 struct in_addr netmask;
497
502 enum net_dhcpv4_state state;
503
505 uint8_t attempts;
506
508 struct in_addr request_server_addr;
509
511 struct in_addr response_src_addr;
512
513#ifdef CONFIG_NET_DHCPV4_OPTION_NTP_SERVER
515 struct in_addr ntp_addr;
516#endif
517};
518#endif /* CONFIG_NET_DHCPV4 */
519
520#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
521struct net_if_ipv4_autoconf {
523 struct net_if *iface;
524
526 struct in_addr requested_ip;
527
531};
532#endif /* CONFIG_NET_IPV4_AUTO */
533
535/* We always need to have at least one IP config */
536#define NET_IF_MAX_CONFIGS 1
542struct net_if_ip {
543#if defined(CONFIG_NET_NATIVE_IPV6)
544 struct net_if_ipv6 *ipv6;
545#endif /* CONFIG_NET_IPV6 */
546
547#if defined(CONFIG_NET_NATIVE_IPV4)
548 struct net_if_ipv4 *ipv4;
549#endif /* CONFIG_NET_IPV4 */
550};
551
556#if defined(CONFIG_NET_IP)
558 struct net_if_ip ip;
559#endif
560
561#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
562 struct net_if_dhcpv4 dhcpv4;
563#endif /* CONFIG_NET_DHCPV4 */
564
565#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
566 struct net_if_dhcpv6 dhcpv6;
567#endif /* CONFIG_NET_DHCPV6 */
568
569#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
570 struct net_if_ipv4_autoconf ipv4auto;
571#endif /* CONFIG_NET_IPV4_AUTO */
572
573#if defined(CONFIG_NET_L2_VIRTUAL)
578 sys_slist_t virtual_interfaces;
579#endif /* CONFIG_NET_L2_VIRTUAL */
580
581#if defined(CONFIG_NET_INTERFACE_NAME)
586 char name[CONFIG_NET_INTERFACE_NAME_LEN + 1];
587#endif
588};
589
601 struct k_fifo fifo;
602
605
608};
609
616typedef int (*net_socket_create_t)(int, int, int);
617
634 const struct device *dev;
635
637 const struct net_l2 * const l2;
638
640 void *l2_data;
641
643 ATOMIC_DEFINE(flags, NET_IF_NUM_FLAGS);
644
647
648#if defined(CONFIG_NET_OFFLOAD)
654 struct net_offload *offload;
655#endif /* CONFIG_NET_OFFLOAD */
656
659
660#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
664 net_socket_create_t socket_offload;
665#endif /* CONFIG_NET_SOCKETS_OFFLOAD */
666
669};
670
678struct net_if {
681
682#if defined(CONFIG_NET_STATISTICS_PER_INTERFACE)
684 struct net_stats stats;
685#endif /* CONFIG_NET_STATISTICS_PER_INTERFACE */
686
689
690#if defined(CONFIG_NET_POWER_MANAGEMENT)
695 int tx_pending;
696#endif
697
699 struct k_mutex lock;
700
703
709
714
716 uint8_t _unused : 6;
717};
718
721static inline void net_if_lock(struct net_if *iface)
722{
723 NET_ASSERT(iface);
724
725 (void)k_mutex_lock(&iface->lock, K_FOREVER);
726}
727
728static inline void net_if_unlock(struct net_if *iface)
729{
730 NET_ASSERT(iface);
731
732 k_mutex_unlock(&iface->lock);
733}
734
735static inline bool net_if_flag_is_set(struct net_if *iface,
736 enum net_if_flag value);
737
738static inline void net_if_tx_lock(struct net_if *iface)
739{
740 NET_ASSERT(iface);
741
743 return;
744 }
745
746 (void)k_mutex_lock(&iface->tx_lock, K_FOREVER);
747}
748
749static inline void net_if_tx_unlock(struct net_if *iface)
750{
751 NET_ASSERT(iface);
752
754 return;
755 }
756
757 k_mutex_unlock(&iface->tx_lock);
758}
759
768static inline void net_if_flag_set(struct net_if *iface,
769 enum net_if_flag value)
770{
771 NET_ASSERT(iface);
772 NET_ASSERT(iface->if_dev);
773
774 atomic_set_bit(iface->if_dev->flags, value);
775}
776
785static inline bool net_if_flag_test_and_set(struct net_if *iface,
786 enum net_if_flag value)
787{
788 NET_ASSERT(iface);
789 NET_ASSERT(iface->if_dev);
790
791 return atomic_test_and_set_bit(iface->if_dev->flags, value);
792}
793
800static inline void net_if_flag_clear(struct net_if *iface,
801 enum net_if_flag value)
802{
803 NET_ASSERT(iface);
804 NET_ASSERT(iface->if_dev);
805
806 atomic_clear_bit(iface->if_dev->flags, value);
807}
808
817static inline bool net_if_flag_test_and_clear(struct net_if *iface,
818 enum net_if_flag value)
819{
820 NET_ASSERT(iface);
821 NET_ASSERT(iface->if_dev);
822
823 return atomic_test_and_clear_bit(iface->if_dev->flags, value);
824}
825
834static inline bool net_if_flag_is_set(struct net_if *iface,
835 enum net_if_flag value)
836{
837 NET_ASSERT(iface);
838 NET_ASSERT(iface->if_dev);
839
840 if (iface == NULL) {
841 return false;
842 }
843
844 return atomic_test_bit(iface->if_dev->flags, value);
845}
846
856 struct net_if *iface, enum net_if_oper_state oper_state)
857{
858 NET_ASSERT(iface);
859 NET_ASSERT(iface->if_dev);
860
861 if (oper_state >= NET_IF_OPER_UNKNOWN && oper_state <= NET_IF_OPER_UP) {
862 iface->if_dev->oper_state = oper_state;
863 }
864
865 return iface->if_dev->oper_state;
866}
867
875static inline enum net_if_oper_state net_if_oper_state(struct net_if *iface)
876{
877 NET_ASSERT(iface);
878 NET_ASSERT(iface->if_dev);
879
880 return iface->if_dev->oper_state;
881}
882
891enum net_verdict net_if_send_data(struct net_if *iface, struct net_pkt *pkt);
892
900static inline const struct net_l2 *net_if_l2(struct net_if *iface)
901{
902 if (!iface || !iface->if_dev) {
903 return NULL;
904 }
905
906 return iface->if_dev->l2;
907}
908
917enum net_verdict net_if_recv_data(struct net_if *iface, struct net_pkt *pkt);
918
926static inline void *net_if_l2_data(struct net_if *iface)
927{
928 NET_ASSERT(iface);
929 NET_ASSERT(iface->if_dev);
930
931 return iface->if_dev->l2_data;
932}
933
941static inline const struct device *net_if_get_device(struct net_if *iface)
942{
943 NET_ASSERT(iface);
944 NET_ASSERT(iface->if_dev);
945
946 return iface->if_dev->dev;
947}
948
955void net_if_queue_tx(struct net_if *iface, struct net_pkt *pkt);
956
964static inline bool net_if_is_ip_offloaded(struct net_if *iface)
965{
966#if defined(CONFIG_NET_OFFLOAD)
967 return (iface != NULL && iface->if_dev != NULL &&
968 iface->if_dev->offload != NULL);
969#else
970 ARG_UNUSED(iface);
971
972 return false;
973#endif
974}
975
983bool net_if_is_offloaded(struct net_if *iface);
984
992static inline struct net_offload *net_if_offload(struct net_if *iface)
993{
994#if defined(CONFIG_NET_OFFLOAD)
995 NET_ASSERT(iface);
996 NET_ASSERT(iface->if_dev);
997
998 return iface->if_dev->offload;
999#else
1000 ARG_UNUSED(iface);
1001
1002 return NULL;
1003#endif
1004}
1005
1013static inline bool net_if_is_socket_offloaded(struct net_if *iface)
1014{
1015#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
1016 NET_ASSERT(iface);
1017 NET_ASSERT(iface->if_dev);
1018
1019 return (iface->if_dev->socket_offload != NULL);
1020#else
1021 ARG_UNUSED(iface);
1022
1023 return false;
1024#endif
1025}
1026
1033static inline void net_if_socket_offload_set(
1034 struct net_if *iface, net_socket_create_t socket_offload)
1035{
1036#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
1037 NET_ASSERT(iface);
1038 NET_ASSERT(iface->if_dev);
1039
1040 iface->if_dev->socket_offload = socket_offload;
1041#else
1042 ARG_UNUSED(iface);
1043 ARG_UNUSED(socket_offload);
1044#endif
1045}
1046
1055{
1056#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
1057 NET_ASSERT(iface);
1058 NET_ASSERT(iface->if_dev);
1059
1060 return iface->if_dev->socket_offload;
1061#else
1062 ARG_UNUSED(iface);
1063
1064 return NULL;
1065#endif
1066}
1067
1075static inline struct net_linkaddr *net_if_get_link_addr(struct net_if *iface)
1076{
1077 NET_ASSERT(iface);
1078 NET_ASSERT(iface->if_dev);
1079
1080 return &iface->if_dev->link_addr;
1081}
1082
1090static inline struct net_if_config *net_if_get_config(struct net_if *iface)
1091{
1092 NET_ASSERT(iface);
1093
1094 return &iface->config;
1095}
1096
1102#if defined(CONFIG_NET_IPV6_DAD) && defined(CONFIG_NET_NATIVE_IPV6)
1103void net_if_start_dad(struct net_if *iface);
1104#else
1105static inline void net_if_start_dad(struct net_if *iface)
1106{
1107 ARG_UNUSED(iface);
1108}
1109#endif
1110
1116void net_if_start_rs(struct net_if *iface);
1117
1118
1124#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
1125void net_if_stop_rs(struct net_if *iface);
1126#else
1127static inline void net_if_stop_rs(struct net_if *iface)
1128{
1129 ARG_UNUSED(iface);
1130}
1131#endif /* CONFIG_NET_IPV6_ND */
1132
1145#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
1146void net_if_nbr_reachability_hint(struct net_if *iface, const struct in6_addr *ipv6_addr);
1147#else
1148static inline void net_if_nbr_reachability_hint(struct net_if *iface,
1149 const struct in6_addr *ipv6_addr)
1150{
1151 ARG_UNUSED(iface);
1152 ARG_UNUSED(ipv6_addr);
1153}
1154#endif
1155
1158static inline int net_if_set_link_addr_unlocked(struct net_if *iface,
1159 uint8_t *addr, uint8_t len,
1160 enum net_link_type type)
1161{
1162 if (net_if_flag_is_set(iface, NET_IF_RUNNING)) {
1163 return -EPERM;
1164 }
1165
1166 net_if_get_link_addr(iface)->addr = addr;
1167 net_if_get_link_addr(iface)->len = len;
1168 net_if_get_link_addr(iface)->type = type;
1169
1170 net_hostname_set_postfix(addr, len);
1171
1172 return 0;
1173}
1174
1175int net_if_set_link_addr_locked(struct net_if *iface,
1176 uint8_t *addr, uint8_t len,
1177 enum net_link_type type);
1178
1179#if CONFIG_NET_IF_LOG_LEVEL >= LOG_LEVEL_DBG
1180extern int net_if_addr_unref_debug(struct net_if *iface,
1181 sa_family_t family,
1182 const void *addr,
1183 const char *caller, int line);
1184#define net_if_addr_unref(iface, family, addr) \
1185 net_if_addr_unref_debug(iface, family, addr, __func__, __LINE__)
1186
1187extern struct net_if_addr *net_if_addr_ref_debug(struct net_if *iface,
1188 sa_family_t family,
1189 const void *addr,
1190 const char *caller,
1191 int line);
1192#define net_if_addr_ref(iface, family, addr) \
1193 net_if_addr_ref_debug(iface, family, addr, __func__, __LINE__)
1194#else
1195extern int net_if_addr_unref(struct net_if *iface,
1196 sa_family_t family,
1197 const void *addr);
1198extern struct net_if_addr *net_if_addr_ref(struct net_if *iface,
1199 sa_family_t family,
1200 const void *addr);
1201#endif /* CONFIG_NET_IF_LOG_LEVEL */
1202
1216static inline int net_if_set_link_addr(struct net_if *iface,
1217 uint8_t *addr, uint8_t len,
1218 enum net_link_type type)
1219{
1220#if defined(CONFIG_NET_RAW_MODE)
1221 return net_if_set_link_addr_unlocked(iface, addr, len, type);
1222#else
1223 return net_if_set_link_addr_locked(iface, addr, len, type);
1224#endif
1225}
1226
1234static inline uint16_t net_if_get_mtu(struct net_if *iface)
1235{
1236 if (iface == NULL) {
1237 return 0U;
1238 }
1239
1240 NET_ASSERT(iface->if_dev);
1241
1242 return iface->if_dev->mtu;
1243}
1244
1251static inline void net_if_set_mtu(struct net_if *iface,
1252 uint16_t mtu)
1253{
1254 if (iface == NULL) {
1255 return;
1256 }
1257
1258 NET_ASSERT(iface->if_dev);
1259
1260 iface->if_dev->mtu = mtu;
1261}
1262
1269static inline void net_if_addr_set_lf(struct net_if_addr *ifaddr,
1270 bool is_infinite)
1271{
1272 NET_ASSERT(ifaddr);
1273
1274 ifaddr->is_infinite = is_infinite;
1275}
1276
1285
1293struct net_if *net_if_lookup_by_dev(const struct device *dev);
1294
1302static inline struct net_if_config *net_if_config_get(struct net_if *iface)
1303{
1304 NET_ASSERT(iface);
1305
1306 return &iface->config;
1307}
1308
1314void net_if_router_rm(struct net_if_router *router);
1315
1321void net_if_set_default(struct net_if *iface);
1322
1329
1338struct net_if *net_if_get_first_by_type(const struct net_l2 *l2);
1339
1347
1348#if defined(CONFIG_NET_L2_IEEE802154)
1355static inline struct net_if *net_if_get_ieee802154(void)
1356{
1357 return net_if_get_first_by_type(&NET_L2_GET_NAME(IEEE802154));
1358}
1359#endif /* CONFIG_NET_L2_IEEE802154 */
1360
1372 struct net_if_ipv6 **ipv6);
1373
1382
1392 struct net_if **iface);
1393
1403 struct in6_addr *addr);
1404
1413__syscall int net_if_ipv6_addr_lookup_by_index(const struct in6_addr *addr);
1414
1426 struct in6_addr *addr,
1428 uint32_t vlifetime);
1429
1440__syscall bool net_if_ipv6_addr_add_by_index(int index,
1441 struct in6_addr *addr,
1443 uint32_t vlifetime);
1444
1452 uint32_t vlifetime);
1453
1462bool net_if_ipv6_addr_rm(struct net_if *iface, const struct in6_addr *addr);
1463
1472__syscall bool net_if_ipv6_addr_rm_by_index(int index,
1473 const struct in6_addr *addr);
1474
1483typedef void (*net_if_ip_addr_cb_t)(struct net_if *iface,
1484 struct net_if_addr *addr,
1485 void *user_data);
1486
1496 void *user_data);
1497
1507 const struct in6_addr *addr);
1508
1517bool net_if_ipv6_maddr_rm(struct net_if *iface, const struct in6_addr *addr);
1518
1527typedef void (*net_if_ip_maddr_cb_t)(struct net_if *iface,
1528 struct net_if_mcast_addr *maddr,
1529 void *user_data);
1530
1540 void *user_data);
1541
1553 struct net_if **iface);
1554
1565typedef void (*net_if_mcast_callback_t)(struct net_if *iface,
1566 const struct net_addr *addr,
1567 bool is_joined);
1568
1580
1582 struct net_if *iface;
1583
1586};
1587
1597 struct net_if *iface,
1599
1606
1614void net_if_mcast_monitor(struct net_if *iface, const struct net_addr *addr,
1615 bool is_joined);
1616
1624 struct net_if_mcast_addr *addr);
1625
1633static inline bool net_if_ipv6_maddr_is_joined(struct net_if_mcast_addr *addr)
1634{
1635 NET_ASSERT(addr);
1636
1637 return addr->is_joined;
1638}
1639
1647 struct net_if_mcast_addr *addr);
1648
1658 const struct in6_addr *addr);
1659
1670 struct in6_addr *addr,
1671 uint8_t len);
1672
1684 struct in6_addr *prefix,
1685 uint8_t len,
1687
1697bool net_if_ipv6_prefix_rm(struct net_if *iface, struct in6_addr *addr,
1698 uint8_t len);
1699
1707 bool is_infinite)
1708{
1709 prefix->is_infinite = is_infinite;
1710}
1711
1720
1727
1738bool net_if_ipv6_addr_onlink(struct net_if **iface, struct in6_addr *addr);
1739
1746#if defined(CONFIG_NET_NATIVE_IPV6)
1747static inline struct in6_addr *net_if_router_ipv6(struct net_if_router *router)
1748{
1749 NET_ASSERT(router);
1750
1751 return &router->address.in6_addr;
1752}
1753#else
1754static inline struct in6_addr *net_if_router_ipv6(struct net_if_router *router)
1755{
1756 static struct in6_addr addr;
1757
1758 ARG_UNUSED(router);
1759
1760 return &addr;
1761}
1762#endif
1763
1774 struct in6_addr *addr);
1775
1786 struct in6_addr *addr);
1787
1796
1807 struct in6_addr *addr,
1808 uint16_t router_lifetime);
1809
1818
1828
1836
1839/* The old hop limit setter function is deprecated because the naming
1840 * of it was incorrect. The API name was missing "_if_" so this function
1841 * should not be used.
1842 */
1843__deprecated
1844static inline void net_ipv6_set_hop_limit(struct net_if *iface,
1845 uint8_t hop_limit)
1846{
1847 net_if_ipv6_set_hop_limit(iface, hop_limit);
1848}
1849
1861
1869
1877 uint32_t reachable_time)
1878{
1879#if defined(CONFIG_NET_NATIVE_IPV6)
1880 NET_ASSERT(iface);
1881
1882 if (!iface->config.ip.ipv6) {
1883 return;
1884 }
1885
1886 iface->config.ip.ipv6->base_reachable_time = reachable_time;
1887#else
1888 ARG_UNUSED(iface);
1889 ARG_UNUSED(reachable_time);
1890
1891#endif
1892}
1893
1902{
1903#if defined(CONFIG_NET_NATIVE_IPV6)
1904 NET_ASSERT(iface);
1905
1906 if (!iface->config.ip.ipv6) {
1907 return 0;
1908 }
1909
1910 return iface->config.ip.ipv6->reachable_time;
1911#else
1912 ARG_UNUSED(iface);
1913 return 0;
1914#endif
1915}
1916
1925
1932static inline void net_if_ipv6_set_reachable_time(struct net_if_ipv6 *ipv6)
1933{
1934#if defined(CONFIG_NET_NATIVE_IPV6)
1935 if (ipv6 == NULL) {
1936 return;
1937 }
1938
1940#else
1941 ARG_UNUSED(ipv6);
1942#endif
1943}
1944
1951static inline void net_if_ipv6_set_retrans_timer(struct net_if *iface,
1952 uint32_t retrans_timer)
1953{
1954#if defined(CONFIG_NET_NATIVE_IPV6)
1955 NET_ASSERT(iface);
1956
1957 if (!iface->config.ip.ipv6) {
1958 return;
1959 }
1960
1961 iface->config.ip.ipv6->retrans_timer = retrans_timer;
1962#else
1963 ARG_UNUSED(iface);
1964 ARG_UNUSED(retrans_timer);
1965#endif
1966}
1967
1976{
1977#if defined(CONFIG_NET_NATIVE_IPV6)
1978 NET_ASSERT(iface);
1979
1980 if (!iface->config.ip.ipv6) {
1981 return 0;
1982 }
1983
1984 return iface->config.ip.ipv6->retrans_timer;
1985#else
1986 ARG_UNUSED(iface);
1987 return 0;
1988#endif
1989}
1990
2002#if defined(CONFIG_NET_NATIVE_IPV6)
2003const struct in6_addr *net_if_ipv6_select_src_addr(struct net_if *iface,
2004 const struct in6_addr *dst);
2005#else
2006static inline const struct in6_addr *net_if_ipv6_select_src_addr(
2007 struct net_if *iface, const struct in6_addr *dst)
2008{
2009 ARG_UNUSED(iface);
2010 ARG_UNUSED(dst);
2011
2012 return NULL;
2013}
2014#endif
2015
2029#if defined(CONFIG_NET_NATIVE_IPV6)
2030const struct in6_addr *net_if_ipv6_select_src_addr_hint(struct net_if *iface,
2031 const struct in6_addr *dst,
2032 int flags);
2033#else
2034static inline const struct in6_addr *net_if_ipv6_select_src_addr_hint(
2035 struct net_if *iface, const struct in6_addr *dst, int flags)
2036{
2037 ARG_UNUSED(iface);
2038 ARG_UNUSED(dst);
2039 ARG_UNUSED(flags);
2040
2041 return NULL;
2042}
2043#endif
2044
2054#if defined(CONFIG_NET_NATIVE_IPV6)
2055struct net_if *net_if_ipv6_select_src_iface(const struct in6_addr *dst);
2056#else
2058 const struct in6_addr *dst)
2059{
2060 ARG_UNUSED(dst);
2061
2062 return NULL;
2063}
2064#endif
2065
2075struct in6_addr *net_if_ipv6_get_ll(struct net_if *iface,
2076 enum net_addr_state addr_state);
2077
2088 struct net_if **iface);
2089
2097void net_if_ipv6_dad_failed(struct net_if *iface, const struct in6_addr *addr);
2098
2111 struct net_if **iface);
2112
2124 struct net_if_ipv4 **ipv4);
2125
2134
2143
2150void net_if_ipv4_set_ttl(struct net_if *iface, uint8_t ttl);
2151
2160
2168
2178 struct net_if **iface);
2179
2191 struct in_addr *addr,
2193 uint32_t vlifetime);
2194
2203bool net_if_ipv4_addr_rm(struct net_if *iface, const struct in_addr *addr);
2204
2213__syscall int net_if_ipv4_addr_lookup_by_index(const struct in_addr *addr);
2214
2225__syscall bool net_if_ipv4_addr_add_by_index(int index,
2226 struct in_addr *addr,
2228 uint32_t vlifetime);
2229
2238__syscall bool net_if_ipv4_addr_rm_by_index(int index,
2239 const struct in_addr *addr);
2240
2250 void *user_data);
2251
2261 const struct in_addr *addr);
2262
2271bool net_if_ipv4_maddr_rm(struct net_if *iface, const struct in_addr *addr);
2272
2282 void *user_data);
2283
2295 struct net_if **iface);
2296
2304 struct net_if_mcast_addr *addr);
2305
2313static inline bool net_if_ipv4_maddr_is_joined(struct net_if_mcast_addr *addr)
2314{
2315 NET_ASSERT(addr);
2316
2317 return addr->is_joined;
2318}
2319
2327 struct net_if_mcast_addr *addr);
2328
2335#if defined(CONFIG_NET_NATIVE_IPV4)
2336static inline struct in_addr *net_if_router_ipv4(struct net_if_router *router)
2337{
2338 NET_ASSERT(router);
2339
2340 return &router->address.in_addr;
2341}
2342#else
2343static inline struct in_addr *net_if_router_ipv4(struct net_if_router *router)
2344{
2345 static struct in_addr addr;
2346
2347 ARG_UNUSED(router);
2348
2349 return &addr;
2350}
2351#endif
2352
2363 struct in_addr *addr);
2364
2375 struct in_addr *addr);
2387 struct in_addr *addr,
2388 bool is_default,
2389 uint16_t router_lifetime);
2390
2399
2409 const struct in_addr *addr);
2410
2420 const struct in_addr *addr);
2421
2431#if defined(CONFIG_NET_NATIVE_IPV4)
2432struct net_if *net_if_ipv4_select_src_iface(const struct in_addr *dst);
2433#else
2435 const struct in_addr *dst)
2436{
2437 ARG_UNUSED(dst);
2438
2439 return NULL;
2440}
2441#endif
2442
2454#if defined(CONFIG_NET_NATIVE_IPV4)
2455const struct in_addr *net_if_ipv4_select_src_addr(struct net_if *iface,
2456 const struct in_addr *dst);
2457#else
2458static inline const struct in_addr *net_if_ipv4_select_src_addr(
2459 struct net_if *iface, const struct in_addr *dst)
2460{
2461 ARG_UNUSED(iface);
2462 ARG_UNUSED(dst);
2463
2464 return NULL;
2465}
2466#endif
2467
2477struct in_addr *net_if_ipv4_get_ll(struct net_if *iface,
2478 enum net_addr_state addr_state);
2479
2490 enum net_addr_state addr_state);
2491
2502 const struct in_addr *addr);
2503
2513__deprecated struct in_addr net_if_ipv4_get_netmask(struct net_if *iface);
2514
2523__deprecated void net_if_ipv4_set_netmask(struct net_if *iface,
2524 const struct in_addr *netmask);
2525
2536__deprecated __syscall bool net_if_ipv4_set_netmask_by_index(int index,
2537 const struct in_addr *netmask);
2538
2549 const struct in_addr *addr,
2550 const struct in_addr *netmask);
2551
2562 const struct in_addr *addr,
2563 const struct in_addr *netmask);
2564
2571void net_if_ipv4_set_gw(struct net_if *iface, const struct in_addr *gw);
2572
2581__syscall bool net_if_ipv4_set_gw_by_index(int index, const struct in_addr *gw);
2582
2593struct net_if *net_if_select_src_iface(const struct sockaddr *dst);
2594
2603typedef void (*net_if_link_callback_t)(struct net_if *iface,
2604 struct net_linkaddr *dst,
2605 int status);
2606
2618
2621};
2622
2631
2638
2646void net_if_call_link_cb(struct net_if *iface, struct net_linkaddr *lladdr,
2647 int status);
2648
2659
2671
2682__syscall struct net_if *net_if_get_by_index(int index);
2683
2691int net_if_get_by_iface(struct net_if *iface);
2692
2700typedef void (*net_if_cb_t)(struct net_if *iface, void *user_data);
2701
2709void net_if_foreach(net_if_cb_t cb, void *user_data);
2710
2718int net_if_up(struct net_if *iface);
2719
2727static inline bool net_if_is_up(struct net_if *iface)
2728{
2729 NET_ASSERT(iface);
2730
2731 return net_if_flag_is_set(iface, NET_IF_UP) &&
2733}
2734
2742int net_if_down(struct net_if *iface);
2743
2751static inline bool net_if_is_admin_up(struct net_if *iface)
2752{
2753 NET_ASSERT(iface);
2754
2755 return net_if_flag_is_set(iface, NET_IF_UP);
2756}
2757
2766void net_if_carrier_on(struct net_if *iface);
2767
2776void net_if_carrier_off(struct net_if *iface);
2777
2785static inline bool net_if_is_carrier_ok(struct net_if *iface)
2786{
2787 NET_ASSERT(iface);
2788
2789 return net_if_flag_is_set(iface, NET_IF_LOWER_UP);
2790}
2791
2802void net_if_dormant_on(struct net_if *iface);
2803
2812void net_if_dormant_off(struct net_if *iface);
2813
2821static inline bool net_if_is_dormant(struct net_if *iface)
2822{
2823 NET_ASSERT(iface);
2824
2825 return net_if_flag_is_set(iface, NET_IF_DORMANT);
2826}
2827
2828#if defined(CONFIG_NET_PKT_TIMESTAMP) && defined(CONFIG_NET_NATIVE)
2836typedef void (*net_if_timestamp_callback_t)(struct net_pkt *pkt);
2837
2846struct net_if_timestamp_cb {
2848 sys_snode_t node;
2849
2853 struct net_pkt *pkt;
2854
2858 struct net_if *iface;
2859
2861 net_if_timestamp_callback_t cb;
2862};
2863
2874void net_if_register_timestamp_cb(struct net_if_timestamp_cb *handle,
2875 struct net_pkt *pkt,
2876 struct net_if *iface,
2877 net_if_timestamp_callback_t cb);
2878
2884void net_if_unregister_timestamp_cb(struct net_if_timestamp_cb *handle);
2885
2891void net_if_call_timestamp_cb(struct net_pkt *pkt);
2892
2893/*
2894 * @brief Add timestamped TX buffer to be handled
2895 *
2896 * @param pkt Timestamped buffer
2897 */
2898void net_if_add_tx_timestamp(struct net_pkt *pkt);
2899#endif /* CONFIG_NET_PKT_TIMESTAMP */
2900
2910#if defined(CONFIG_NET_PROMISCUOUS_MODE)
2911int net_if_set_promisc(struct net_if *iface);
2912#else
2913static inline int net_if_set_promisc(struct net_if *iface)
2914{
2915 ARG_UNUSED(iface);
2916
2917 return -ENOTSUP;
2918}
2919#endif
2920
2926#if defined(CONFIG_NET_PROMISCUOUS_MODE)
2927void net_if_unset_promisc(struct net_if *iface);
2928#else
2929static inline void net_if_unset_promisc(struct net_if *iface)
2930{
2931 ARG_UNUSED(iface);
2932}
2933#endif
2934
2943#if defined(CONFIG_NET_PROMISCUOUS_MODE)
2944bool net_if_is_promisc(struct net_if *iface);
2945#else
2946static inline bool net_if_is_promisc(struct net_if *iface)
2947{
2948 ARG_UNUSED(iface);
2949
2950 return false;
2951}
2952#endif
2953
2963static inline bool net_if_are_pending_tx_packets(struct net_if *iface)
2964{
2965#if defined(CONFIG_NET_POWER_MANAGEMENT)
2966 return !!iface->tx_pending;
2967#else
2968 ARG_UNUSED(iface);
2969
2970 return false;
2971#endif
2972}
2973
2974#ifdef CONFIG_NET_POWER_MANAGEMENT
2982int net_if_suspend(struct net_if *iface);
2983
2991int net_if_resume(struct net_if *iface);
2992
3000bool net_if_is_suspended(struct net_if *iface);
3001#endif /* CONFIG_NET_POWER_MANAGEMENT */
3002
3010bool net_if_is_wifi(struct net_if *iface);
3011
3018
3033int net_if_get_name(struct net_if *iface, char *buf, int len);
3034
3049int net_if_set_name(struct net_if *iface, const char *buf);
3050
3058int net_if_get_by_name(const char *name);
3059
3061struct net_if_api {
3062 void (*init)(struct net_if *iface);
3063};
3064
3065#define NET_IF_DHCPV4_INIT \
3066 IF_ENABLED(UTIL_AND(IS_ENABLED(CONFIG_NET_DHCPV4), \
3067 IS_ENABLED(CONFIG_NET_NATIVE_IPV4)), \
3068 (.dhcpv4.state = NET_DHCPV4_DISABLED,))
3069
3070#define NET_IF_DHCPV6_INIT \
3071 IF_ENABLED(UTIL_AND(IS_ENABLED(CONFIG_NET_DHCPV6), \
3072 IS_ENABLED(CONFIG_NET_NATIVE_IPV6)), \
3073 (.dhcpv6.state = NET_DHCPV6_DISABLED,))
3074
3075#define NET_IF_CONFIG_INIT \
3076 .config = { \
3077 IF_ENABLED(CONFIG_NET_IP, (.ip = {},)) \
3078 NET_IF_DHCPV4_INIT \
3079 NET_IF_DHCPV6_INIT \
3080 }
3081
3082#define NET_IF_GET_NAME(dev_id, sfx) __net_if_##dev_id##_##sfx
3083#define NET_IF_DEV_GET_NAME(dev_id, sfx) __net_if_dev_##dev_id##_##sfx
3084
3085#define NET_IF_GET(dev_id, sfx) \
3086 ((struct net_if *)&NET_IF_GET_NAME(dev_id, sfx))
3087
3088#define NET_IF_INIT(dev_id, sfx, _l2, _mtu, _num_configs) \
3089 static STRUCT_SECTION_ITERABLE(net_if_dev, \
3090 NET_IF_DEV_GET_NAME(dev_id, sfx)) = { \
3091 .dev = &(DEVICE_NAME_GET(dev_id)), \
3092 .l2 = &(NET_L2_GET_NAME(_l2)), \
3093 .l2_data = &(NET_L2_GET_DATA(dev_id, sfx)), \
3094 .mtu = _mtu, \
3095 .flags = {BIT(NET_IF_LOWER_UP)}, \
3096 }; \
3097 static Z_DECL_ALIGN(struct net_if) \
3098 NET_IF_GET_NAME(dev_id, sfx)[_num_configs] \
3099 __used __in_section(_net_if, static, \
3100 dev_id) = { \
3101 [0 ... (_num_configs - 1)] = { \
3102 .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)), \
3103 NET_IF_CONFIG_INIT \
3104 } \
3105 }
3106
3107#define NET_IF_OFFLOAD_INIT(dev_id, sfx, _mtu) \
3108 static STRUCT_SECTION_ITERABLE(net_if_dev, \
3109 NET_IF_DEV_GET_NAME(dev_id, sfx)) = { \
3110 .dev = &(DEVICE_NAME_GET(dev_id)), \
3111 .mtu = _mtu, \
3112 .l2 = &(NET_L2_GET_NAME(OFFLOADED_NETDEV)), \
3113 .flags = {BIT(NET_IF_LOWER_UP)}, \
3114 }; \
3115 static Z_DECL_ALIGN(struct net_if) \
3116 NET_IF_GET_NAME(dev_id, sfx)[NET_IF_MAX_CONFIGS] \
3117 __used __in_section(_net_if, static, \
3118 dev_id) = { \
3119 [0 ... (NET_IF_MAX_CONFIGS - 1)] = { \
3120 .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)), \
3121 NET_IF_CONFIG_INIT \
3122 } \
3123 }
3124
3127/* Network device initialization macros */
3128
3129#define Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, instance, \
3130 init_fn, pm, data, config, prio, \
3131 api, l2, l2_ctx_type, mtu) \
3132 Z_DEVICE_STATE_DEFINE(dev_id); \
3133 Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, pm, data, \
3134 config, POST_KERNEL, prio, api, \
3135 &Z_DEVICE_STATE_NAME(dev_id)); \
3136 NET_L2_DATA_INIT(dev_id, instance, l2_ctx_type); \
3137 NET_IF_INIT(dev_id, instance, l2, mtu, NET_IF_MAX_CONFIGS)
3138
3139#define Z_NET_DEVICE_INIT(node_id, dev_id, name, init_fn, pm, data, \
3140 config, prio, api, l2, l2_ctx_type, mtu) \
3141 Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, 0, init_fn, \
3142 pm, data, config, prio, api, l2, \
3143 l2_ctx_type, mtu)
3144
3164#define NET_DEVICE_INIT(dev_id, name, init_fn, pm, data, config, prio, \
3165 api, l2, l2_ctx_type, mtu) \
3166 Z_NET_DEVICE_INIT(DT_INVALID_NODE, dev_id, name, init_fn, pm, \
3167 data, config, prio, api, l2, l2_ctx_type, mtu)
3168
3187#define NET_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, \
3188 config, prio, api, l2, l2_ctx_type, mtu) \
3189 Z_NET_DEVICE_INIT(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
3190 DEVICE_DT_NAME(node_id), init_fn, pm, data, \
3191 config, prio, api, l2, l2_ctx_type, mtu)
3192
3201#define NET_DEVICE_DT_INST_DEFINE(inst, ...) \
3202 NET_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
3203
3227#define NET_DEVICE_INIT_INSTANCE(dev_id, name, instance, init_fn, pm, \
3228 data, config, prio, api, l2, \
3229 l2_ctx_type, mtu) \
3230 Z_NET_DEVICE_INIT_INSTANCE(DT_INVALID_NODE, dev_id, name, \
3231 instance, init_fn, pm, data, config, \
3232 prio, api, l2, l2_ctx_type, mtu)
3233
3256#define NET_DEVICE_DT_DEFINE_INSTANCE(node_id, instance, init_fn, pm, \
3257 data, config, prio, api, l2, \
3258 l2_ctx_type, mtu) \
3259 Z_NET_DEVICE_INIT_INSTANCE(node_id, \
3260 Z_DEVICE_DT_DEV_ID(node_id), \
3261 DEVICE_DT_NAME(node_id), instance, \
3262 init_fn, pm, data, config, prio, \
3263 api, l2, l2_ctx_type, mtu)
3264
3274#define NET_DEVICE_DT_INST_DEFINE_INSTANCE(inst, ...) \
3275 NET_DEVICE_DT_DEFINE_INSTANCE(DT_DRV_INST(inst), __VA_ARGS__)
3276
3277#define Z_NET_DEVICE_OFFLOAD_INIT(node_id, dev_id, name, init_fn, pm, \
3278 data, config, prio, api, mtu) \
3279 Z_DEVICE_STATE_DEFINE(dev_id); \
3280 Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, pm, data, \
3281 config, POST_KERNEL, prio, api, \
3282 &Z_DEVICE_STATE_NAME(dev_id)); \
3283 NET_IF_OFFLOAD_INIT(dev_id, 0, mtu)
3284
3304#define NET_DEVICE_OFFLOAD_INIT(dev_id, name, init_fn, pm, data, \
3305 config, prio, api, mtu) \
3306 Z_NET_DEVICE_OFFLOAD_INIT(DT_INVALID_NODE, dev_id, name, \
3307 init_fn, pm, data, config, prio, api, \
3308 mtu)
3309
3328#define NET_DEVICE_DT_OFFLOAD_DEFINE(node_id, init_fn, pm, data, \
3329 config, prio, api, mtu) \
3330 Z_NET_DEVICE_OFFLOAD_INIT(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
3331 DEVICE_DT_NAME(node_id), init_fn, pm, \
3332 data, config, prio, api, mtu)
3333
3343#define NET_DEVICE_DT_INST_OFFLOAD_DEFINE(inst, ...) \
3344 NET_DEVICE_DT_OFFLOAD_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
3345
3351#define NET_IFACE_COUNT(_dst) \
3352 do { \
3353 extern struct net_if _net_if_list_start[]; \
3354 extern struct net_if _net_if_list_end[]; \
3355 *(_dst) = ((uintptr_t)_net_if_list_end - \
3356 (uintptr_t)_net_if_list_start) / \
3357 sizeof(struct net_if); \
3358 } while (0)
3359
3360#ifdef __cplusplus
3361}
3362#endif
3363
3364#include <zephyr/syscalls/net_if.h>
3365
3370#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
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 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 test and clear a bit.
Definition: atomic.h:147
static bool atomic_test_and_set_bit(atomic_t *target, int bit)
Atomically set a bit.
Definition: atomic.h:170
#define K_FOREVER
Generate infinite timeout delay.
Definition: kernel.h:1363
unsigned short int sa_family_t
Socket address family type.
Definition: net_ip.h:164
net_addr_state
What is the current state of the network address.
Definition: net_ip.h:500
net_addr_type
How the network address is assigned to network interface.
Definition: net_ip.h:508
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:100
static int net_hostname_set_postfix(const uint8_t *hostname_postfix, int postfix_len)
Set the device hostname postfix.
Definition: hostname.h:108
struct net_if * net_if_select_src_iface(const struct sockaddr *dst)
Get a network interface that should be used when sending IPv6 or IPv4 network data to destination.
struct net_if_router * net_if_ipv4_router_lookup(struct net_if *iface, struct in_addr *addr)
Check if IPv4 address is one of the routers configured in the system.
int net_if_get_by_iface(struct net_if *iface)
Get interface index according to pointer.
int net_if_up(struct net_if *iface)
Bring interface up.
struct net_if * net_if_get_first_up(void)
Get the first network interface which is up.
struct net_if_addr * net_if_ipv4_addr_lookup(const struct in_addr *addr, struct net_if **iface)
Check if this IPv4 address belongs to one of the interfaces.
int net_if_set_name(struct net_if *iface, const char *buf)
Set network interface name.
static bool net_if_is_carrier_ok(struct net_if *iface)
Check if carrier is present on network device.
Definition: net_if.h:2785
static bool net_if_is_admin_up(struct net_if *iface)
Check if interface was brought up by the administrator.
Definition: net_if.h:2751
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.
int(* net_socket_create_t)(int, int, int)
A function prototype to create an offloaded socket.
Definition: net_if.h:616
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:855
int net_if_down(struct net_if *iface)
Bring interface down.
bool net_if_need_calc_tx_checksum(struct net_if *iface)
Check if network packet checksum calculation can be avoided or not when sending the packet.
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:2343
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).
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_ipv6_set_mcast_hop_limit(struct net_if *iface, uint8_t hop_limit)
Set the default IPv6 multicast hop limit of a given interface.
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.
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:2603
static void * net_if_l2_data(struct net_if *iface)
Get a pointer to the interface L2 private data.
Definition: net_if.h:926
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:2963
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:785
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:1075
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:2006
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:1148
static struct net_offload * net_if_offload(struct net_if *iface)
Return the IP offload plugin.
Definition: net_if.h:992
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:1216
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:768
uint8_t net_if_ipv6_get_hop_limit(struct net_if *iface)
Get IPv6 hop limit specified for a given interface.
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.
void net_if_queue_tx(struct net_if *iface, struct net_pkt *pkt)
Queue a packet to the net interface TX queue.
int net_if_config_ipv6_get(struct net_if *iface, struct net_if_ipv6 **ipv6)
Allocate network interface IPv6 config.
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 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:2034
int net_if_get_name(struct net_if *iface, char *buf, int len)
Get network interface name.
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:1527
bool net_if_ipv6_addr_rm(struct net_if *iface, const struct in6_addr *addr)
Remove an IPv6 address from an interface.
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:964
static bool net_if_is_dormant(struct net_if *iface)
Check if the interface is dormant.
Definition: net_if.h:2821
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.
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.
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:1565
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:1251
bool net_if_need_calc_rx_checksum(struct net_if *iface)
Check if received network packet checksum calculation can be avoided or not.
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 is up and running.
Definition: net_if.h:2727
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:1932
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.
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.
uint8_t net_if_ipv6_get_mcast_hop_limit(struct net_if *iface)
Get IPv6 multicast hop limit specified for a given interface.
static void net_if_start_dad(struct net_if *iface)
Start duplicate address detection procedure.
Definition: net_if.h:1105
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:2929
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:1033
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:1901
static bool net_if_is_promisc(struct net_if *iface)
Check if promiscuous mode is set or not.
Definition: net_if.h:2946
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:2313
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:1706
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:1127
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:1876
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_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:817
void net_if_start_rs(struct net_if *iface)
Start neighbor discovery and send router solicitation message.
static bool net_if_ipv6_maddr_is_joined(struct net_if_mcast_addr *addr)
Check if given multicast address is joined or not.
Definition: net_if.h:1633
bool net_if_ipv6_addr_rm_by_index(int index, const struct in6_addr *addr)
Remove an IPv6 address from an interface by index.
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:1234
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:2458
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:1951
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.
enum net_verdict net_if_send_data(struct net_if *iface, struct net_pkt *pkt)
Send a packet through a net iface.
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:1754
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:1975
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:1483
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:286
struct net_if_addr * net_if_ipv6_addr_add(struct net_if *iface, struct in6_addr *addr, enum net_addr_type addr_type, uint32_t vlifetime)
Add a IPv6 address to an interface.
static struct net_if * net_if_ipv6_select_src_iface(const struct in6_addr *dst)
Get a network interface that should be used when sending IPv6 network data to destination.
Definition: net_if.h:2057
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:834
static struct net_if_config * net_if_config_get(struct net_if *iface)
Get network interface IP config.
Definition: net_if.h:1302
static struct net_if_config * net_if_get_config(struct net_if *iface)
Return network configuration for this network interface.
Definition: net_if.h:1090
void net_if_ipv4_maddr_join(struct net_if *iface, struct net_if_mcast_addr *addr)
Mark a given multicast address to be joined.
static void net_if_addr_set_lf(struct net_if_addr *ifaddr, bool is_infinite)
Set the infinite status of the network interface address.
Definition: net_if.h:1269
net_if_flag
Network interface flags.
Definition: net_if.h:228
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:941
void(* net_if_cb_t)(struct net_if *iface, void *user_data)
Callback used while iterating over network interfaces.
Definition: net_if.h:2700
bool net_if_is_offloaded(struct net_if *iface)
Return offload status of a given network interface.
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:1013
static int net_if_set_promisc(struct net_if *iface)
Set network interface into promiscuous mode.
Definition: net_if.h:2913
static const struct net_l2 * net_if_l2(struct net_if *iface)
Get a pointer to the interface L2.
Definition: net_if.h:900
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:1054
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:2434
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:800
@ NET_IF_OPER_TESTING
Training mode.
Definition: net_if.h:291
@ NET_IF_OPER_DORMANT
Waiting external action.
Definition: net_if.h:292
@ NET_IF_OPER_UP
Interface is up.
Definition: net_if.h:293
@ NET_IF_OPER_NOTPRESENT
Hardware missing.
Definition: net_if.h:288
@ NET_IF_OPER_UNKNOWN
Initial (unknown) value.
Definition: net_if.h:287
@ NET_IF_OPER_DOWN
Interface is down.
Definition: net_if.h:289
@ NET_IF_OPER_LOWERLAYERDOWN
Lower layer interface is down.
Definition: net_if.h:290
@ NET_IF_NO_AUTO_START
Do not start the interface immediately after initialization.
Definition: net_if.h:244
@ NET_IF_IPV6_NO_MLD
IPv6 Multicast Listener Discovery disabled.
Definition: net_if.h:274
@ NET_IF_POINTOPOINT
Interface is pointopoint.
Definition: net_if.h:233
@ NET_IF_IPV6_NO_ND
IPv6 Neighbor Discovery disabled.
Definition: net_if.h:271
@ NET_IF_FORWARD_MULTICASTS
Flag defines if received multicasts of other interface are forwarded on this interface.
Definition: net_if.h:253
@ NET_IF_IPV4
Interface supports IPv4.
Definition: net_if.h:256
@ NET_IF_PROMISC
Interface is in promiscuous mode.
Definition: net_if.h:236
@ NET_IF_DORMANT
Driver signals dormant.
Definition: net_if.h:268
@ NET_IF_SUSPENDED
Power management specific: interface is being suspended.
Definition: net_if.h:247
@ NET_IF_IPV6
Interface supports IPv6.
Definition: net_if.h:259
@ NET_IF_UP
Interface is admin up.
Definition: net_if.h:230
@ NET_IF_LOWER_UP
Driver signals L1 is up.
Definition: net_if.h:265
@ NET_IF_RUNNING
Interface up and running (ready to receive and transmit).
Definition: net_if.h:262
@ NET_IF_NO_TX_LOCK
Mutex locking on TX data path disabled on the interface.
Definition: net_if.h:277
net_link_type
Type of the link address.
Definition: net_linkaddr.h:47
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 ENOTSUP
Unsupported value.
Definition: errno.h:115
#define EPERM
Not owner.
Definition: errno.h:40
Hostname configuration definitions.
IPv4 Autoconfiguration.
net_ipv4_autoconf_state
Current state of IPv4 Autoconfiguration.
Definition: ipv4_autoconf.h:15
Network core definitions.
IPv6 and IPv4 definitions.
Public API for network L2 interface.
Public API for network link address.
Network statistics.
Network timer with wrap around.
flags
Definition: parser.h:96
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:403
IPv6 address struct.
Definition: net_ip.h:139
IPv4 address struct.
Definition: net_ip.h:151
Definition: kernel.h:2388
Mutex Structure.
Definition: kernel.h:2914
Thread Structure.
Definition: thread.h:259
Kernel timepoint type.
Definition: sys_clock.h:219
DHCPv6 client configuration parameters.
Definition: dhcpv6.h:61
Network Interface unicast IPv4 address and netmask.
Definition: net_if.h:437
struct net_if_addr ipv4
IPv4 address.
Definition: net_if.h:439
struct in_addr netmask
Netmask.
Definition: net_if.h:441
Network Interface unicast IP addresses.
Definition: net_if.h:52
struct net_addr address
IP address.
Definition: net_if.h:54
uint8_t is_mesh_local
Is this IP address usage limited to the subnet (mesh) or not.
Definition: net_if.h:128
uint8_t is_temporary
Is this IP address temporary and generated for example by IPv6 privacy extension (RFC 8981)
Definition: net_if.h:133
enum net_addr_state addr_state
What is the current state of the address.
Definition: net_if.h:69
uint8_t is_infinite
Is the IP address valid forever.
Definition: net_if.h:122
atomic_t atomic_ref
Reference counter.
Definition: net_if.h:59
enum net_addr_type addr_type
How the IP address was set.
Definition: net_if.h:66
uint8_t is_used
Is this IP address used or not.
Definition: net_if.h:125
IP and other configuration related data for network interface.
Definition: net_if.h:555
Network Interface Device structure.
Definition: net_if.h:632
enum net_if_oper_state oper_state
RFC 2863 operational status.
Definition: net_if.h:668
const struct net_l2 *const l2
Interface's L2 layer.
Definition: net_if.h:637
void * l2_data
Interface's private L2 data pointer.
Definition: net_if.h:640
uint16_t mtu
The hardware MTU.
Definition: net_if.h:658
const struct device * dev
The actually device driver instance the net_if is related to.
Definition: net_if.h:634
struct net_linkaddr link_addr
The hardware link address.
Definition: net_if.h:646
atomic_t flags[ATOMIC_BITMAP_SIZE(NET_IF_NUM_FLAGS)]
For internal use.
Definition: net_if.h:643
Network interface IP address configuration.
Definition: net_if.h:542
IPv4 configuration.
Definition: net_if.h:445
uint8_t mcast_ttl
IPv4 time-to-live for multicast packets.
Definition: net_if.h:459
struct net_if_addr_ipv4 unicast[NET_IF_MAX_IPV4_ADDR]
Unicast IP addresses.
Definition: net_if.h:447
struct in_addr gw
Gateway.
Definition: net_if.h:453
uint8_t ttl
IPv4 time-to-live.
Definition: net_if.h:456
struct net_if_mcast_addr mcast[NET_IF_MAX_IPV4_MADDR]
Multicast IP addresses.
Definition: net_if.h:450
Network Interface IPv6 prefixes.
Definition: net_if.h:172
struct net_if * iface
Backpointer to network interface where this prefix is used.
Definition: net_if.h:180
uint8_t is_infinite
Is the IP prefix valid forever.
Definition: net_if.h:186
uint8_t len
Prefix length.
Definition: net_if.h:183
struct in6_addr prefix
IPv6 prefix.
Definition: net_if.h:177
uint8_t is_used
Is this prefix used or not.
Definition: net_if.h:189
struct net_timeout lifetime
Prefix lifetime.
Definition: net_if.h:174
IPv6 configuration.
Definition: net_if.h:313
struct net_if_ipv6_prefix prefix[NET_IF_MAX_IPV6_PREFIX]
Prefixes.
Definition: net_if.h:321
uint32_t base_reachable_time
Default reachable time (RFC 4861, page 52)
Definition: net_if.h:324
uint8_t hop_limit
IPv6 hop limit.
Definition: net_if.h:352
struct net_if_mcast_addr mcast[NET_IF_MAX_IPV6_MADDR]
Multicast IP addresses.
Definition: net_if.h:318
uint32_t retrans_timer
Retransmit timer (RFC 4861, page 52)
Definition: net_if.h:330
struct net_if_addr unicast[NET_IF_MAX_IPV6_ADDR]
Unicast IP addresses.
Definition: net_if.h:315
uint8_t mcast_hop_limit
IPv6 multicast hop limit.
Definition: net_if.h:355
uint32_t reachable_time
Reachable time (RFC 4861, page 20)
Definition: net_if.h:327
Network Interface multicast IP addresses.
Definition: net_if.h:143
struct net_addr address
IP address.
Definition: net_if.h:145
uint8_t is_joined
Did we join to this group.
Definition: net_if.h:162
uint8_t is_used
Is this multicast IP address used or not.
Definition: net_if.h:159
Multicast monitor handler struct.
Definition: net_if.h:1577
sys_snode_t node
Node information for the slist.
Definition: net_if.h:1579
net_if_mcast_callback_t cb
Multicast callback.
Definition: net_if.h:1585
struct net_if * iface
Network interface.
Definition: net_if.h:1582
Information about routers in the system.
Definition: net_if.h:199
struct net_if * iface
Network interface the router is connected to.
Definition: net_if.h:207
uint8_t is_default
Is default router.
Definition: net_if.h:219
uint16_t lifetime
Router lifetime.
Definition: net_if.h:213
uint8_t is_infinite
Is the router valid forever.
Definition: net_if.h:222
uint8_t is_used
Is this router used or not.
Definition: net_if.h:216
struct net_addr address
IP address.
Definition: net_if.h:204
sys_snode_t node
Slist lifetime timer node.
Definition: net_if.h:201
uint32_t life_start
Router life timer start.
Definition: net_if.h:210
Network Interface structure.
Definition: net_if.h:678
struct net_if_dev * if_dev
The net_if_dev instance the net_if is related to.
Definition: net_if.h:680
struct net_if_config config
Network interface instance configuration.
Definition: net_if.h:688
uint8_t pe_enabled
Network interface specific flags.
Definition: net_if.h:708
struct k_mutex lock
Mutex protecting this network interface instance.
Definition: net_if.h:699
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:713
struct k_mutex tx_lock
Mutex used when sending data.
Definition: net_if.h:702
Network L2 structure.
Definition: net_l2.h:55
Hardware link address structure.
Definition: net_linkaddr.h:67
uint8_t * addr
The array of byte representing the address.
Definition: net_linkaddr.h:69
uint8_t type
What kind of address is this for.
Definition: net_linkaddr.h:75
uint8_t len
Length of that address array.
Definition: net_linkaddr.h:72
Network packet.
Definition: net_pkt.h:67
All network statistics in one struct.
Definition: net_stats.h:323
Generic struct for handling network timeouts.
Definition: net_timeout.h:55
Network traffic class.
Definition: net_if.h:599
k_thread_stack_t * stack
Stack for this handler.
Definition: net_if.h:607
struct k_thread handler
Traffic class handler thread.
Definition: net_if.h:604
struct k_fifo fifo
Fifo for handling this Tx or Rx packet.
Definition: net_if.h:601
Generic sockaddr struct.
Definition: net_ip.h:385