net_ip.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_NET_IP_H_
#define ZEPHYR_INCLUDE_NET_NET_IP_H_

 
#include <string.h>
#include <zephyr/types.h>
#include <stdbool.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/toolchain.h>
 
#include <zephyr/net/net_linkaddr.h>
 
#ifdef __cplusplus
extern "C" {
#endif

/* Specifying VLAN tag here in order to avoid circular dependencies */
#define NET_VLAN_TAG_UNSPEC 0x0fff
 
/* Protocol families. */
#define NET_PF_UNSPEC   0            
#define NET_PF_INET     1            
#define NET_PF_INET6    2            
#define NET_PF_PACKET   3            
#define NET_PF_CAN      4            
#define NET_PF_NET_MGMT 5            
#define NET_PF_LOCAL    6            
#define NET_PF_UNIX     NET_PF_LOCAL 
 
/* Address families. */
#define NET_AF_UNSPEC      NET_PF_UNSPEC   
#define NET_AF_INET        NET_PF_INET     
#define NET_AF_INET6       NET_PF_INET6    
#define NET_AF_PACKET      NET_PF_PACKET   
#define NET_AF_CAN         NET_PF_CAN      
#define NET_AF_NET_MGMT    NET_PF_NET_MGMT 
#define NET_AF_LOCAL       NET_PF_LOCAL    
#define NET_AF_UNIX        NET_PF_UNIX     

enum net_ip_protocol {
        NET_IPPROTO_IP = 0,            
        NET_IPPROTO_ICMP = 1,          
        NET_IPPROTO_IGMP = 2,          
        NET_IPPROTO_ETH_P_ALL = 3,     
        NET_IPPROTO_IPIP = 4,          
        NET_IPPROTO_TCP = 6,           
        NET_IPPROTO_UDP = 17,          
        NET_IPPROTO_IPV6 = 41,         
        NET_IPPROTO_ICMPV6 = 58,       
        NET_IPPROTO_RAW = 255,         
};

enum net_ip_protocol_secure {
        NET_IPPROTO_TLS_1_0 = 256,     
        NET_IPPROTO_TLS_1_1 = 257,     
        NET_IPPROTO_TLS_1_2 = 258,     
        NET_IPPROTO_TLS_1_3 = 259,     
        NET_IPPROTO_DTLS_1_0 = 272,    
        NET_IPPROTO_DTLS_1_2 = 273,    
        NET_IPPROTO_QUIC = 511,        
};

enum net_sock_type {
        NET_SOCK_STREAM = 1,           
        NET_SOCK_DGRAM,                
        NET_SOCK_RAW                   
};

#define net_ntohs(x) sys_be16_to_cpu(x)

#define net_ntohl(x) sys_be32_to_cpu(x)

#define net_ntohll(x) sys_be64_to_cpu(x)

#define net_htons(x) sys_cpu_to_be16(x)

#define net_htonl(x) sys_cpu_to_be32(x)

#define net_htonll(x) sys_cpu_to_be64(x)

struct net_in6_addr {
        union {
                uint8_t s6_addr[16];   
                uint16_t s6_addr16[8]; 
                uint32_t s6_addr32[4]; 
        };
};

#define NET_IPV6_ADDR_SIZE 16

struct net_in_addr {
        union {
                uint8_t s4_addr[4];    
                uint16_t s4_addr16[2]; 
                uint32_t s4_addr32[1]; 
                uint32_t s_addr; 
        };
};

#define NET_IPV4_ADDR_SIZE 4

typedef unsigned short int net_sa_family_t;

typedef uint32_t net_socklen_t;
 
/*
 * Note that the sin_port and sin6_port are in network byte order
 * in various net_sockaddr* structs.
 */

struct net_sockaddr_in6 {
        net_sa_family_t         sin6_family;   
        uint16_t                sin6_port;     
        struct net_in6_addr     sin6_addr;     
        uint8_t                 sin6_scope_id; 
};

struct net_sockaddr_in {
        net_sa_family_t         sin_family;    
        uint16_t                sin_port;      
        struct net_in_addr      sin_addr;      
};

struct net_sockaddr_ll {
        net_sa_family_t sll_family;   
        uint16_t        sll_protocol; 
        int             sll_ifindex;  
        uint16_t        sll_hatype;   
        uint8_t         sll_pkttype;  
        uint8_t         sll_halen;    
        uint8_t         sll_addr[8];  
};

struct net_sockaddr_can {
        net_sa_family_t can_family;   
        int             can_ifindex;  
};

struct net_sockaddr_nm {
        net_sa_family_t nm_family;

        int nm_ifindex;

        uintptr_t nm_pid;

        uint64_t nm_mask;
};


struct net_sockaddr_in6_ptr {
        net_sa_family_t         sin6_family;   
        uint16_t                sin6_port;     
        struct net_in6_addr    *sin6_addr;     
        uint8_t                 sin6_scope_id; 
};

struct net_sockaddr_in_ptr {
        net_sa_family_t         sin_family;    
        uint16_t                sin_port;      
        struct net_in_addr     *sin_addr;      
};

struct net_sockaddr_ll_ptr {
        net_sa_family_t sll_family;   
        uint16_t        sll_protocol; 
        int             sll_ifindex;  
        uint16_t        sll_hatype;   
        uint8_t         sll_pkttype;  
        uint8_t         sll_halen;    
        uint8_t        *sll_addr;     
};

struct net_sockaddr_un_ptr {
        net_sa_family_t sun_family;   
        char           *sun_path;     
};
 
struct net_sockaddr_can_ptr {
        net_sa_family_t can_family;
        int             can_ifindex;
};

 
#if !defined(HAVE_IOVEC)
struct net_iovec {
        void  *iov_base; 
        size_t iov_len;  
};
#endif

struct net_msghdr {
        void             *msg_name;       
        net_socklen_t     msg_namelen;    
        struct net_iovec *msg_iov;        
        size_t            msg_iovlen;     
        void             *msg_control;    
        size_t            msg_controllen; 
        int               msg_flags;      
};

struct net_cmsghdr {
        net_socklen_t cmsg_len;    
        int           cmsg_level;  
        int           cmsg_type;   
        z_max_align_t cmsg_data[]; 
};

struct net_linger {
        int l_onoff;  
        int l_linger; 
};

 
/* Alignment for headers and data. These are arch specific but define
 * them here atm if not found already.
 */
#if !defined(NET_ALIGN_H)
#define NET_ALIGN_H(x) ROUND_UP(x, __alignof__(struct net_cmsghdr))
#endif
#if !defined(NET_ALIGN_D)
#define NET_ALIGN_D(x) ROUND_UP(x, __alignof__(z_max_align_t))
#endif

 
#if !defined(NET_CMSG_FIRSTHDR)
#define NET_CMSG_FIRSTHDR(msghdr)                                 \
        ((msghdr)->msg_controllen >= sizeof(struct net_cmsghdr) ? \
         (struct net_cmsghdr *)((msghdr)->msg_control) : NULL)
#endif
 
#if !defined(NET_CMSG_NXTHDR)
#define NET_CMSG_NXTHDR(msghdr, cmsg)                                    \
        (((cmsg) == NULL) ? NET_CMSG_FIRSTHDR(msghdr) :                  \
         (((cmsg)->cmsg_len < sizeof(struct net_cmsghdr) ||              \
           (cmsg)->cmsg_len > (size_t)((uint8_t *)((msghdr)->msg_control) + \
                                       (msghdr)->msg_controllen -        \
                                       (uint8_t *)(cmsg)) ||             \
           (uint8_t *)(cmsg) + NET_ALIGN_H((cmsg)->cmsg_len) +           \
           NET_ALIGN_D(sizeof(struct net_cmsghdr)) >                     \
           (uint8_t *)((msghdr)->msg_control) + (msghdr)->msg_controllen) ? \
          NULL :                                                         \
          (struct net_cmsghdr *)((uint8_t *)(cmsg) +                     \
                                 NET_ALIGN_H((cmsg)->cmsg_len))))
#endif
 
#if !defined(NET_CMSG_DATA)
#define NET_CMSG_DATA(cmsg) ((uint8_t *)(cmsg) + NET_ALIGN_D(sizeof(struct net_cmsghdr)))
#endif
 
#if !defined(NET_CMSG_SPACE)
#define NET_CMSG_SPACE(length) (NET_ALIGN_D(sizeof(struct net_cmsghdr)) + NET_ALIGN_H(length))
#endif
 
#if !defined(NET_CMSG_LEN)
#define NET_CMSG_LEN(length) (NET_ALIGN_D(sizeof(struct net_cmsghdr)) + length)
#endif

 
/* Packet types.  */
#define NET_PACKET_HOST         0     /* To us            */
#define NET_PACKET_BROADCAST    1     /* To all           */
#define NET_PACKET_MULTICAST    2     /* To group         */
#define NET_PACKET_OTHERHOST    3     /* To someone else  */
#define NET_PACKET_OUTGOING     4     /* Originated by us */
#define NET_PACKET_LOOPBACK     5
#define NET_PACKET_FASTROUTE    6
 
/* ARP protocol HARDWARE identifiers. */
#define NET_ARPHRD_ETHER 1
#define NET_ARPHRD_PPP   512
 
/* Note: These macros are defined in a specific order.
 * The largest sockaddr size is the last one.
 */
#if defined(CONFIG_NET_IPV4)
#undef NET_SOCKADDR_MAX_SIZE
#undef NET_SOCKADDR_PTR_MAX_SIZE
#define NET_SOCKADDR_MAX_SIZE (sizeof(struct net_sockaddr_in))
#define NET_SOCKADDR_PTR_MAX_SIZE (sizeof(struct net_sockaddr_in_ptr))
#endif
 
#if defined(CONFIG_NET_SOCKETS_PACKET)
#undef NET_SOCKADDR_MAX_SIZE
#undef NET_SOCKADDR_PTR_MAX_SIZE
#define NET_SOCKADDR_MAX_SIZE (sizeof(struct net_sockaddr_ll))
#define NET_SOCKADDR_PTR_MAX_SIZE (sizeof(struct net_sockaddr_ll_ptr))
#endif
 
#if defined(CONFIG_NET_IPV6)
#undef NET_SOCKADDR_MAX_SIZE
#define NET_SOCKADDR_MAX_SIZE (sizeof(struct net_sockaddr_in6))
#if !defined(CONFIG_NET_SOCKETS_PACKET)
#undef NET_SOCKADDR_PTR_MAX_SIZE
#define NET_SOCKADDR_PTR_MAX_SIZE (sizeof(struct net_sockaddr_in6_ptr))
#endif
#endif
 
#if defined(CONFIG_NET_NATIVE_OFFLOADED_SOCKETS)
#define UNIX_PATH_MAX 108
#undef NET_SOCKADDR_MAX_SIZE
/* Define NET_SOCKADDR_MAX_SIZE to be struct of net_sa_family_t + char[UNIX_PATH_MAX] */
#define NET_SOCKADDR_MAX_SIZE (UNIX_PATH_MAX+sizeof(net_sa_family_t))
#if !defined(CONFIG_NET_SOCKETS_PACKET)
#undef NET_SOCKADDR_PTR_MAX_SIZE
#define NET_SOCKADDR_PTR_MAX_SIZE (sizeof(struct net_sockaddr_un_ptr))
#endif
#endif
 
#if !defined(CONFIG_NET_IPV4)
#if !defined(CONFIG_NET_IPV6)
#if !defined(CONFIG_NET_SOCKETS_PACKET)
#if !defined(CONFIG_NET_NATIVE_OFFLOADED_SOCKETS)
#define NET_SOCKADDR_MAX_SIZE (sizeof(struct net_sockaddr_in6))
#define NET_SOCKADDR_PTR_MAX_SIZE (sizeof(struct net_sockaddr_in6_ptr))
#endif
#endif
#endif
#endif

 
#define SOCKADDR_ALIGN (4)

struct net_sockaddr {
        net_sa_family_t sa_family; 
        char data[NET_SOCKADDR_MAX_SIZE - sizeof(net_sa_family_t)];
} __aligned(SOCKADDR_ALIGN);

 
struct net_sockaddr_ptr {
        net_sa_family_t family;
        char data[NET_SOCKADDR_PTR_MAX_SIZE - sizeof(net_sa_family_t)];
} __aligned(SOCKADDR_ALIGN);
 
/* Same as sockaddr in our case */
struct net_sockaddr_storage {
        net_sa_family_t ss_family;
        char data[NET_SOCKADDR_MAX_SIZE - sizeof(net_sa_family_t)];
} __aligned(SOCKADDR_ALIGN);
 
/* Socket address struct for UNIX domain sockets */
struct net_sockaddr_un {
        net_sa_family_t sun_family;    /* NET_AF_UNIX */
        char            sun_path[NET_SOCKADDR_MAX_SIZE - sizeof(net_sa_family_t)];
};
 
struct net_addr {
        net_sa_family_t family;
        union {
#if defined(CONFIG_NET_NAMESPACE_COMPAT_MODE)
                struct net_in6_addr net_in6_addr;
                struct net_in_addr net_in_addr;
#else
                struct net_in6_addr in6_addr;
                struct net_in_addr in_addr;
#endif
        };
};

extern const struct net_in6_addr net_in6addr_any;

extern const struct net_in6_addr net_in6addr_loopback;


#define NET_IN6ADDR_ANY_INIT { { { 0, 0, 0, 0, 0, 0, 0, 0,      \
                                   0, 0, 0, 0, 0, 0, 0, 0 } } }

#define NET_IN6ADDR_LOOPBACK_INIT { { { 0, 0, 0, 0, 0, 0, 0, 0, \
                                        0, 0, 0, 0, 0, 0, 0, 1 } } }

#define NET_INADDR_ANY 0

#define NET_INADDR_BROADCAST 0xffffffff

#define NET_INADDR_ANY_INIT { { { NET_INADDR_ANY } } }

#define NET_INADDR_LOOPBACK_INIT  { { { 127, 0, 0, 1 } } }

#define NET_INET_ADDRSTRLEN 16

#define NET_INET6_ADDRSTRLEN 46

 
/* These are for internal usage of the stack */
#define NET_IPV6_ADDR_LEN sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxx.xxx.xxx.xxx")
#define NET_IPV4_ADDR_LEN sizeof("xxx.xxx.xxx.xxx")


enum net_ip_mtu {
#if defined(CONFIG_NET_NATIVE_IPV6)
        NET_IPV6_MTU = CONFIG_NET_IPV6_MTU,
#else
        NET_IPV6_MTU = 1280,
#endif

#if defined(CONFIG_NET_NATIVE_IPV4)
        NET_IPV4_MTU = CONFIG_NET_IPV4_MTU,
#else
        NET_IPV4_MTU = 576,
#endif
};

enum net_priority {
        NET_PRIORITY_BK = 1, 
        NET_PRIORITY_BE = 0, 
        NET_PRIORITY_EE = 2, 
        NET_PRIORITY_CA = 3, 
        NET_PRIORITY_VI = 4, 
        NET_PRIORITY_VO = 5, 
        NET_PRIORITY_IC = 6, 
        NET_PRIORITY_NC = 7  
} __packed;
 
#define NET_MAX_PRIORITIES 8 

struct net_tuple {
        struct net_addr *remote_addr;  
        struct net_addr *local_addr;   
        uint16_t remote_port;          
        uint16_t local_port;           
        enum net_ip_protocol ip_proto; 
};

enum net_addr_state {
        NET_ADDR_ANY_STATE = -1, 
        NET_ADDR_TENTATIVE = 0,  
        NET_ADDR_PREFERRED,      
        NET_ADDR_DEPRECATED,     
} __packed;

enum net_addr_type {
        NET_ADDR_ANY = 0,
        NET_ADDR_AUTOCONF,
        NET_ADDR_DHCP,
        NET_ADDR_MANUAL,
        NET_ADDR_OVERRIDABLE,
} __packed;

 
struct net_ipv6_hdr {
        uint8_t vtc;
        uint8_t tcflow;
        uint16_t flow;
        uint16_t len;
        uint8_t nexthdr;
        uint8_t hop_limit;
        uint8_t src[NET_IPV6_ADDR_SIZE];
        uint8_t dst[NET_IPV6_ADDR_SIZE];
} __packed;
 
struct net_ipv6_frag_hdr {
        uint8_t nexthdr;
        uint8_t reserved;
        uint16_t offset;
        uint32_t id;
} __packed;
 
struct net_ipv4_hdr {
        uint8_t vhl;
        uint8_t tos;
        uint16_t len;
        uint8_t id[2];
        uint8_t offset[2];
        uint8_t ttl;
        uint8_t proto;
        uint16_t chksum;
        uint8_t src[NET_IPV4_ADDR_SIZE];
        uint8_t dst[NET_IPV4_ADDR_SIZE];
} __packed;
 
struct net_icmp_hdr {
        uint8_t type;
        uint8_t code;
        uint16_t chksum;
} __packed;
 
struct net_udp_hdr {
        uint16_t src_port;
        uint16_t dst_port;
        uint16_t len;
        uint16_t chksum;
} __packed;

struct net_udp_opt_mrds {
        uint16_t size;
        uint8_t segs;
};

struct net_udp_opt_time {
        uint32_t tsval;
        uint32_t tsecr;
};
 
struct net_tcp_hdr {
        uint16_t src_port;
        uint16_t dst_port;
        uint8_t seq[4];
        uint8_t ack[4];
        uint8_t offset;
        uint8_t flags;
        uint8_t wnd[2];
        uint16_t chksum;
        uint8_t urg[2];
        uint8_t optdata[0];
} __packed;
 
static inline const char *net_addr_type2str(enum net_addr_type type)
{
        switch (type) {
        case NET_ADDR_AUTOCONF:
                return "AUTO";
        case NET_ADDR_DHCP:
                return "DHCP";
        case NET_ADDR_MANUAL:
                return "MANUAL";
        case NET_ADDR_OVERRIDABLE:
                return "OVERRIDE";
        case NET_ADDR_ANY:
        default:
                break;
        }
 
        return "<unknown>";
}
 
/* IPv6 extension headers types */
#define NET_IPV6_NEXTHDR_HBHO        0
#define NET_IPV6_NEXTHDR_DESTO       60
#define NET_IPV6_NEXTHDR_ROUTING     43
#define NET_IPV6_NEXTHDR_FRAG        44
#define NET_IPV6_NEXTHDR_NONE        59

union net_ip_header {
        struct net_ipv4_hdr *ipv4;
        struct net_ipv6_hdr *ipv6;
};
 
union net_proto_header {
        struct net_udp_hdr *udp;
        struct net_tcp_hdr *tcp;
};
 
#define NET_UDPH_LEN    8                       /* Size of UDP header */
#define NET_TCPH_LEN    20                      /* Size of TCP header */
#define NET_ICMPH_LEN   4                       /* Size of ICMP header */
 
#define NET_IPV6H_LEN      40                   /* Size of IPv6 header */
#define NET_ICMPV6H_LEN    NET_ICMPH_LEN        /* Size of ICMPv6 header */
#define NET_IPV6UDPH_LEN   (NET_UDPH_LEN + NET_IPV6H_LEN) /* IPv6 + UDP */
#define NET_IPV6TCPH_LEN   (NET_TCPH_LEN + NET_IPV6H_LEN) /* IPv6 + TCP */
#define NET_IPV6ICMPH_LEN  (NET_IPV6H_LEN + NET_ICMPH_LEN) /* ICMPv6 + IPv6 */
#define NET_IPV6_FRAGH_LEN 8
 
#define NET_IPV4H_LEN      20                   /* Size of IPv4 header */
#define NET_ICMPV4H_LEN    NET_ICMPH_LEN        /* Size of ICMPv4 header */
#define NET_IPV4UDPH_LEN   (NET_UDPH_LEN + NET_IPV4H_LEN) /* IPv4 + UDP */
#define NET_IPV4TCPH_LEN   (NET_TCPH_LEN + NET_IPV4H_LEN) /* IPv4 + TCP */
#define NET_IPV4ICMPH_LEN  (NET_IPV4H_LEN + NET_ICMPH_LEN) /* ICMPv4 + IPv4 */
 
#define NET_IPV6H_LENGTH_OFFSET         0x04    /* Offset of the Length field in the IPv6 header */
 
#define NET_IPV6_FRAGH_OFFSET_MASK      0xfff8  /* Mask for the 13-bit Fragment Offset field */
#define NET_IPV4_FRAGH_OFFSET_MASK      0x1fff  /* Mask for the 13-bit Fragment Offset field */
#define NET_IPV4_MORE_FRAG_MASK         0x2000  /* Mask for the 1-bit More Fragments field */
#define NET_IPV4_DO_NOT_FRAG_MASK       0x4000  /* Mask for the 1-bit Do Not Fragment field */

#if defined(CONFIG_NET_INTERFACE_NAME)
#define NET_IFNAMSIZ CONFIG_NET_INTERFACE_NAME_LEN
#else
#if defined(Z_DEVICE_MAX_NAME_LEN)
#define NET_IFNAMSIZ Z_DEVICE_MAX_NAME_LEN
#else
#define NET_IFNAMSIZ 1
#endif /* Z_DEVICE_MAX_NAME_LEN */
#endif /* CONFIG_NET_INTERFACE_NAME */



struct net_ifreq {
        char ifr_name[NET_IFNAMSIZ]; 
};


struct net_in_pktinfo {
        unsigned int       ipi_ifindex;   
        struct net_in_addr ipi_spec_dst;  
        struct net_in_addr ipi_addr;      
};

struct net_ip_mreqn {
        struct net_in_addr imr_multiaddr; 
        struct net_in_addr imr_address;   
        int                imr_ifindex;   
};

struct net_ip_mreq  {
        struct net_in_addr imr_multiaddr; 
        struct net_in_addr imr_interface; 
};

struct net_ipv6_mreq {
        struct net_in6_addr ipv6mr_multiaddr;

        int ipv6mr_ifindex;
};

struct net_packet_mreq {
        int mr_ifindex;

        uint16_t mr_type;

        uint16_t mr_alen;

        uint8_t mr_address[NET_LINK_ADDR_MAX_LENGTH];
};

#define NET_PACKET_MR_MULTICAST 0 
#define NET_PACKET_MR_PROMISC   1 
#define NET_PACKET_MR_ALLMULTI  2 

struct net_in6_pktinfo {
        struct net_in6_addr ipi6_addr;    
        unsigned int        ipi6_ifindex; 
};

static inline bool net_ipv6_is_addr_loopback_raw(const uint8_t *addr)
{
        return UNALIGNED_GET((uint32_t *)addr) == 0 &&
               UNALIGNED_GET((uint32_t *)addr + 1) == 0 &&
               UNALIGNED_GET((uint32_t *)addr + 2) == 0 &&
               net_ntohl(UNALIGNED_GET((uint32_t *)addr + 3)) == 1;
}

static inline bool net_ipv6_is_addr_loopback(const struct net_in6_addr *addr)
{
        return net_ipv6_is_addr_loopback_raw(addr->s6_addr);
}

static inline bool net_ipv6_is_addr_mcast_raw(const uint8_t *addr)
{
        return addr[0] == 0xff;
}

static inline bool net_ipv6_is_addr_mcast(const struct net_in6_addr *addr)
{
        return net_ipv6_is_addr_mcast_raw(addr->s6_addr);
}
 
struct net_if;
struct net_if_config;

extern struct net_if_addr *net_if_ipv6_addr_lookup_raw(const uint8_t *addr,
                                                       struct net_if **ret);
 
static inline bool net_ipv6_is_my_addr_raw(const uint8_t *addr)
{
        return net_if_ipv6_addr_lookup_raw(addr, NULL) != NULL;
}
 
extern struct net_if_addr *net_if_ipv6_addr_lookup(const struct net_in6_addr *addr,
                                                   struct net_if **iface);

static inline bool net_ipv6_is_my_addr(struct net_in6_addr *addr)
{
        return net_if_ipv6_addr_lookup(addr, NULL) != NULL;
}
 
extern struct net_if_mcast_addr *net_if_ipv6_maddr_lookup(
        const struct net_in6_addr *addr, struct net_if **iface);

static inline bool net_ipv6_is_my_maddr(struct net_in6_addr *maddr)
{
        return net_if_ipv6_maddr_lookup(maddr, NULL) != NULL;
}

static inline bool net_ipv6_is_prefix(const uint8_t *addr1,
                                      const uint8_t *addr2,
                                      uint8_t length)
{
        uint8_t bits = 128 - length;
        uint8_t bytes = length / 8U;
        uint8_t remain = bits % 8;
        uint8_t mask;
 
        if (length > 128) {
                return false;
        }
 
        if (memcmp(addr1, addr2, bytes)) {
                return false;
        }
 
        if (!remain) {
                /* No remaining bits, the prefixes are the same as first
                 * bytes are the same.
                 */
                return true;
        }
 
        /* Create a mask that has remaining most significant bits set */
        mask = (uint8_t)((0xff << (8 - remain)) ^ 0xff) << remain;
 
        return (addr1[bytes] & mask) == (addr2[bytes] & mask);
}
 

static inline void net_ipv6_addr_prefix_mask(const uint8_t *inaddr,
                                             uint8_t *outaddr,
                                             uint8_t prefix_len)
{
        uint8_t bits = 128 - prefix_len;
        uint8_t bytes = prefix_len / 8U;
        uint8_t remain = bits % 8;
        uint8_t mask;
 
        memset(outaddr, 0, 16U);
        memcpy(outaddr, inaddr, bytes);
 
        if (!remain) {
                /* No remaining bits, the prefixes are the same as first
                 * bytes are the same.
                 */
                return;
        }
 
        /* Create a mask that has remaining most significant bits set */
        mask = (uint8_t)((0xff << (8 - remain)) ^ 0xff) << remain;
        outaddr[bytes] = inaddr[bytes] & mask;
}

static inline bool net_ipv4_is_addr_loopback_raw(const uint8_t *addr)
{
        return addr[0] == 127U;
}

static inline bool net_ipv4_is_addr_loopback(const struct net_in_addr *addr)
{
        return net_ipv4_is_addr_loopback_raw(addr->s4_addr);
}

static inline bool net_ipv4_is_addr_unspecified_raw(const uint8_t *addr)
{
        return UNALIGNED_GET((uint32_t *)addr) == 0;
}

static inline bool net_ipv4_is_addr_unspecified(const struct net_in_addr *addr)
{
        return net_ipv4_is_addr_unspecified_raw(addr->s4_addr);
}

static inline bool net_ipv4_is_addr_mcast_raw(const uint8_t *addr)
{
        return (net_ntohl(UNALIGNED_GET((uint32_t *)addr)) & 0xF0000000) == 0xE0000000;
}

static inline bool net_ipv4_is_addr_mcast(const struct net_in_addr *addr)
{
        return net_ipv4_is_addr_mcast_raw(addr->s4_addr);
}

static inline bool net_ipv4_is_ll_addr_raw(const uint8_t *addr)
{
        return (net_ntohl(UNALIGNED_GET((uint32_t *)addr)) & 0xFFFF0000) == 0xA9FE0000;
}

static inline bool net_ipv4_is_ll_addr(const struct net_in_addr *addr)
{
        return net_ipv4_is_ll_addr_raw(addr->s4_addr);
}

static inline bool net_ipv4_is_private_addr(const struct net_in_addr *addr)
{
        uint32_t masked_24, masked_16, masked_12, masked_10, masked_8;
 
        masked_24 = net_ntohl(UNALIGNED_GET(&addr->s_addr)) & 0xFFFFFF00;
        masked_16 = masked_24 & 0xFFFF0000;
        masked_12 = masked_24 & 0xFFF00000;
        masked_10 = masked_24 & 0xFFC00000;
        masked_8 = masked_24 & 0xFF000000;
 
        return masked_8  == 0x0A000000 || /* 10.0.0.0/8      */
               masked_10 == 0x64400000 || /* 100.64.0.0/10   */
               masked_12 == 0xAC100000 || /* 172.16.0.0/12   */
               masked_16 == 0xC0A80000 || /* 192.168.0.0/16  */
               masked_24 == 0xC0000200 || /* 192.0.2.0/24    */
               masked_24 == 0xC0336400 || /* 192.51.100.0/24 */
               masked_24 == 0xCB007100;   /* 203.0.113.0/24  */
}

#define net_ipaddr_copy(dest, src) \
        UNALIGNED_PUT(UNALIGNED_GET(src), dest)

static inline void net_ipv4_addr_copy_raw(uint8_t *dest,
                                          const uint8_t *src)
{
        net_ipaddr_copy((struct net_in_addr *)dest, (const struct net_in_addr *)src);
}

static inline void net_ipv6_addr_copy_raw(uint8_t *dest,
                                          const uint8_t *src)
{
        memcpy(dest, src, sizeof(struct net_in6_addr));
}

static inline bool net_ipv4_addr_cmp_raw(const uint8_t *addr1,
                                         const uint8_t *addr2)
{
        return UNALIGNED_GET((uint32_t *)addr1) == UNALIGNED_GET((uint32_t *)addr2);
}

static inline bool net_ipv4_addr_cmp(const struct net_in_addr *addr1,
                                     const struct net_in_addr *addr2)
{
        return net_ipv4_addr_cmp_raw(addr1->s4_addr, addr2->s4_addr);
}

static inline bool net_ipv6_addr_cmp(const struct net_in6_addr *addr1,
                                     const struct net_in6_addr *addr2)
{
        return !memcmp(addr1, addr2, sizeof(struct net_in6_addr));
}

static inline bool net_ipv6_addr_cmp_raw(const uint8_t *addr1,
                                         const uint8_t *addr2)
{
        return net_ipv6_addr_cmp((const struct net_in6_addr *)addr1,
                                 (const struct net_in6_addr *)addr2);
}

static inline bool net_ipv6_is_ll_addr_raw(const uint8_t *addr)
{
        return UNALIGNED_GET((uint16_t *)addr) == net_htons(0xFE80);
}

static inline bool net_ipv6_is_ll_addr(const struct net_in6_addr *addr)
{
        return net_ipv6_is_ll_addr_raw(addr->s6_addr);
}

static inline bool net_ipv6_is_sl_addr(const struct net_in6_addr *addr)
{
        return UNALIGNED_GET(&addr->s6_addr16[0]) == net_htons(0xFEC0);
}
 

static inline bool net_ipv6_is_ula_addr(const struct net_in6_addr *addr)
{
        return addr->s6_addr[0] == 0xFD;
}

static inline bool net_ipv6_is_global_addr(const struct net_in6_addr *addr)
{
        return (addr->s6_addr[0] & 0xE0) == 0x20;
}

static inline bool net_ipv6_is_private_addr(const struct net_in6_addr *addr)
{
        uint32_t masked_32, masked_7;
 
        masked_32 = net_ntohl(UNALIGNED_GET(&addr->s6_addr32[0]));
        masked_7 = masked_32 & 0xfc000000;
 
        return masked_32 == 0x20010db8 || /* 2001:db8::/32 */
               masked_7  == 0xfc000000;   /* fc00::/7      */
}

const struct net_in6_addr *net_ipv6_unspecified_address(void);

const struct net_in_addr *net_ipv4_unspecified_address(void);

const struct net_in_addr *net_ipv4_broadcast_address(void);
 
struct net_if;
extern bool net_if_ipv4_addr_mask_cmp(struct net_if *iface,
                                      const struct net_in_addr *addr);

static inline bool net_ipv4_addr_mask_cmp(struct net_if *iface,
                                          const struct net_in_addr *addr)
{
        return net_if_ipv4_addr_mask_cmp(iface, addr);
}

extern bool net_if_ipv4_is_addr_bcast_raw(struct net_if *iface,
                                          const uint8_t *addr);
 
#if defined(CONFIG_NET_NATIVE_IPV4)
static inline bool net_ipv4_is_addr_bcast_raw(struct net_if *iface,
                                              const uint8_t *addr)
{
        if (net_ipv4_addr_cmp_raw(addr, net_ipv4_broadcast_address()->s4_addr)) {
                return true;
        }
 
        return net_if_ipv4_is_addr_bcast_raw(iface, addr);
}
#else
static inline bool net_ipv4_is_addr_bcast_raw(struct net_if *iface,
                                              const uint8_t *addr)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(addr);
 
        return false;
}
#endif
 
extern bool net_if_ipv4_is_addr_bcast(struct net_if *iface,
                                      const struct net_in_addr *addr);

#if defined(CONFIG_NET_NATIVE_IPV4)
static inline bool net_ipv4_is_addr_bcast(struct net_if *iface,
                                          const struct net_in_addr *addr)
{
        if (net_ipv4_addr_cmp(addr, net_ipv4_broadcast_address())) {
                return true;
        }
 
        return net_if_ipv4_is_addr_bcast(iface, addr);
}
#else
static inline bool net_ipv4_is_addr_bcast(struct net_if *iface,
                                          const struct net_in_addr *addr)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(addr);
 
        return false;
}
#endif

extern struct net_if_addr *net_if_ipv4_addr_lookup_raw(const uint8_t *addr,
                                                       struct net_if **ret);
 
static inline bool net_ipv4_is_my_addr_raw(const uint8_t *addr)
{
        bool ret;
 
        ret = net_if_ipv4_addr_lookup_raw(addr, NULL) != NULL;
        if (!ret) {
                ret = net_ipv4_is_addr_bcast_raw(NULL, addr);
        }
 
        return ret;
}
 
extern struct net_if_addr *net_if_ipv4_addr_lookup(const struct net_in_addr *addr,
                                                   struct net_if **iface);

static inline bool net_ipv4_is_my_addr(const struct net_in_addr *addr)
{
        bool ret;
 
        ret = net_if_ipv4_addr_lookup(addr, NULL) != NULL;
        if (!ret) {
                ret = net_ipv4_is_addr_bcast(NULL, addr);
        }
 
        return ret;
}

static inline bool net_ipv6_is_addr_unspecified_raw(const uint8_t *addr)
{
        return UNALIGNED_GET((uint32_t *)addr) == 0 &&
               UNALIGNED_GET((uint32_t *)addr + 1) == 0 &&
               UNALIGNED_GET((uint32_t *)addr + 2) == 0 &&
               UNALIGNED_GET((uint32_t *)addr + 3) == 0;
}

static inline bool net_ipv6_is_addr_unspecified(const struct net_in6_addr *addr)
{
        return net_ipv6_is_addr_unspecified_raw(addr->s6_addr);
}

static inline bool net_ipv6_is_addr_solicited_node_raw(const uint8_t *addr)
{
        return UNALIGNED_GET((uint32_t *)addr) == net_htonl(0xff020000) &&
               UNALIGNED_GET((uint32_t *)addr + 1) == 0x00000000 &&
               UNALIGNED_GET((uint32_t *)addr + 2) == net_htonl(0x00000001) &&
               ((UNALIGNED_GET((uint32_t *)addr + 3) & net_htonl(0xff000000)) ==
                net_htonl(0xff000000));
}

static inline bool net_ipv6_is_addr_solicited_node(const struct net_in6_addr *addr)
{
        return net_ipv6_is_addr_solicited_node_raw(addr->s6_addr);
}

static inline bool net_ipv6_is_addr_mcast_scope_raw(const uint8_t *addr,
                                                    int scope)
{
        return (addr[0] == 0xff) && ((addr[1] & 0xF) == scope);
}

static inline int net_ipv6_get_addr_mcast_scope_raw(const uint8_t *addr)
{
        if (addr[0] == 0xff) {
                return (addr[1] & 0xF);
        }
 
        return -1;
}

static inline bool net_ipv6_is_addr_mcast_scope(const struct net_in6_addr *addr,
                                                int scope)
{
        return net_ipv6_is_addr_mcast_scope_raw(addr->s6_addr, scope);
}

static inline bool net_ipv6_is_same_mcast_scope(const struct net_in6_addr *addr_1,
                                                const struct net_in6_addr *addr_2)
{
        return (addr_1->s6_addr[0] == 0xff) && (addr_2->s6_addr[0] == 0xff) &&
                (addr_1->s6_addr[1] == addr_2->s6_addr[1]);
}

static inline int net_ipv6_get_addr_mcast_scope(const struct net_in6_addr *addr)
{
        return net_ipv6_get_addr_mcast_scope_raw(addr->s6_addr);
}

static inline bool net_ipv6_is_addr_mcast_iface_raw(const uint8_t *addr)
{
        return net_ipv6_is_addr_mcast_scope_raw(addr, 0x01);
}
 
static inline bool net_ipv6_is_addr_mcast_link_raw(const uint8_t *addr)
{
        return net_ipv6_is_addr_mcast_scope_raw(addr, 0x02);
}
 
static inline bool net_ipv6_is_addr_mcast_mesh_raw(const uint8_t *addr)
{
        return net_ipv6_is_addr_mcast_scope_raw(addr, 0x03);
}
 
static inline bool net_ipv6_is_addr_mcast_site_raw(const uint8_t *addr)
{
        return net_ipv6_is_addr_mcast_scope_raw(addr, 0x05);
}
 
static inline bool net_ipv6_is_addr_mcast_org_raw(const uint8_t *addr)
{
        return net_ipv6_is_addr_mcast_scope_raw(addr, 0x08);
}

static inline bool net_ipv6_is_addr_mcast_global(const struct net_in6_addr *addr)
{
        return net_ipv6_is_addr_mcast_scope(addr, 0x0e);
}

static inline bool net_ipv6_is_addr_mcast_iface(const struct net_in6_addr *addr)
{
        return net_ipv6_is_addr_mcast_scope(addr, 0x01);
}

static inline bool net_ipv6_is_addr_mcast_link(const struct net_in6_addr *addr)
{
        return net_ipv6_is_addr_mcast_scope(addr, 0x02);
}

static inline bool net_ipv6_is_addr_mcast_mesh(const struct net_in6_addr *addr)
{
        return net_ipv6_is_addr_mcast_scope(addr, 0x03);
}

static inline bool net_ipv6_is_addr_mcast_site(const struct net_in6_addr *addr)
{
        return net_ipv6_is_addr_mcast_scope(addr, 0x05);
}

static inline bool net_ipv6_is_addr_mcast_org(const struct net_in6_addr *addr)
{
        return net_ipv6_is_addr_mcast_scope(addr, 0x08);
}

static inline bool net_ipv6_is_addr_mcast_group_raw(const uint8_t *addr,
                                                    const uint8_t *group)
{
        return UNALIGNED_GET((uint16_t *)addr + 1) == UNALIGNED_GET((uint16_t *)group + 1) &&
               UNALIGNED_GET((uint32_t *)addr + 1) == UNALIGNED_GET((uint32_t *)group + 1) &&
               UNALIGNED_GET((uint32_t *)addr + 2) == UNALIGNED_GET((uint32_t *)group + 2) &&
               UNALIGNED_GET((uint32_t *)addr + 3) == UNALIGNED_GET((uint32_t *)group + 3);
}

static inline bool net_ipv6_is_addr_mcast_group(const struct net_in6_addr *addr,
                                                const struct net_in6_addr *group)
{
        return net_ipv6_is_addr_mcast_group_raw(addr->s6_addr, group->s6_addr);
}

static inline bool net_ipv6_is_addr_mcast_all_nodes_group_raw(const uint8_t *addr)
{
        static const uint8_t all_nodes_mcast_group[NET_IPV6_ADDR_SIZE] = {
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
        };
 
        return net_ipv6_is_addr_mcast_group_raw(addr, all_nodes_mcast_group);
}

static inline bool
net_ipv6_is_addr_mcast_all_nodes_group(const struct net_in6_addr *addr)
{
        return net_ipv6_is_addr_mcast_all_nodes_group_raw(addr->s6_addr);
}

static inline bool
net_ipv6_is_addr_mcast_iface_all_nodes(const struct net_in6_addr *addr)
{
        return net_ipv6_is_addr_mcast_iface(addr) &&
               net_ipv6_is_addr_mcast_all_nodes_group(addr);
}

static inline bool net_ipv6_is_addr_mcast_link_all_nodes_raw(const uint8_t *addr)
{
        return net_ipv6_is_addr_mcast_link_raw(addr) &&
               net_ipv6_is_addr_mcast_all_nodes_group_raw(addr);
}

static inline bool
net_ipv6_is_addr_mcast_link_all_nodes(const struct net_in6_addr *addr)
{
        return net_ipv6_is_addr_mcast_link(addr) &&
               net_ipv6_is_addr_mcast_all_nodes_group(addr);
}

static inline
void net_ipv6_addr_create_solicited_node(const struct net_in6_addr *src,
                                         struct net_in6_addr *dst)
{
        dst->s6_addr[0]   = 0xFF;
        dst->s6_addr[1]   = 0x02;
        UNALIGNED_PUT(0, &dst->s6_addr16[1]);
        UNALIGNED_PUT(0, &dst->s6_addr16[2]);
        UNALIGNED_PUT(0, &dst->s6_addr16[3]);
        UNALIGNED_PUT(0, &dst->s6_addr16[4]);
        dst->s6_addr[10]  = 0U;
        dst->s6_addr[11]  = 0x01;
        dst->s6_addr[12]  = 0xFF;
        dst->s6_addr[13]  = src->s6_addr[13];
        UNALIGNED_PUT(UNALIGNED_GET(&src->s6_addr16[7]), &dst->s6_addr16[7]);
}

static inline void net_ipv6_addr_create(struct net_in6_addr *addr,
                                        uint16_t addr0, uint16_t addr1,
                                        uint16_t addr2, uint16_t addr3,
                                        uint16_t addr4, uint16_t addr5,
                                        uint16_t addr6, uint16_t addr7)
{
        UNALIGNED_PUT(net_htons(addr0), &addr->s6_addr16[0]);
        UNALIGNED_PUT(net_htons(addr1), &addr->s6_addr16[1]);
        UNALIGNED_PUT(net_htons(addr2), &addr->s6_addr16[2]);
        UNALIGNED_PUT(net_htons(addr3), &addr->s6_addr16[3]);
        UNALIGNED_PUT(net_htons(addr4), &addr->s6_addr16[4]);
        UNALIGNED_PUT(net_htons(addr5), &addr->s6_addr16[5]);
        UNALIGNED_PUT(net_htons(addr6), &addr->s6_addr16[6]);
        UNALIGNED_PUT(net_htons(addr7), &addr->s6_addr16[7]);
}

static inline void net_ipv6_addr_create_ll_allnodes_mcast(struct net_in6_addr *addr)
{
        net_ipv6_addr_create(addr, 0xff02, 0, 0, 0, 0, 0, 0, 0x0001);
}

static inline void net_ipv6_addr_create_ll_allrouters_mcast(struct net_in6_addr *addr)
{
        net_ipv6_addr_create(addr, 0xff02, 0, 0, 0, 0, 0, 0, 0x0002);
}

static inline void net_ipv6_addr_create_v4_mapped(const struct net_in_addr *addr4,
                                                  struct net_in6_addr *addr6)
{
        net_ipv6_addr_create(addr6, 0, 0, 0, 0, 0, 0xffff,
                             net_ntohs(addr4->s4_addr16[0]),
                             net_ntohs(addr4->s4_addr16[1]));
}

static inline bool net_ipv6_addr_is_v4_mapped(const struct net_in6_addr *addr)
{
        if (UNALIGNED_GET(&addr->s6_addr32[0]) == 0 &&
            UNALIGNED_GET(&addr->s6_addr32[1]) == 0 &&
            UNALIGNED_GET(&addr->s6_addr16[5]) == 0xffff) {
                return true;
        }
 
        return false;
}

static inline void net_ipv6_addr_get_v4_mapped(const struct net_in6_addr *addr6,
                                               struct net_in_addr *addr4)
{
        addr4->s_addr = UNALIGNED_GET(&addr6->s6_addr32[3]);
}

int net_ipv6_addr_generate_iid(struct net_if *iface,
                               const struct net_in6_addr *prefix,
                               uint8_t *network_id, size_t network_id_len,
                               uint8_t dad_counter,
                               struct net_in6_addr *addr,
                               struct net_linkaddr *lladdr);

static inline void net_ipv6_addr_create_iid(struct net_in6_addr *addr,
                                            struct net_linkaddr *lladdr)
{
        (void)net_ipv6_addr_generate_iid(NULL, NULL, NULL, 0, 0, addr, lladdr);
}

static inline bool net_ipv6_addr_based_on_ll_raw(const uint8_t *addr,
                                                 const struct net_linkaddr *lladdr)
{
        if (addr == NULL || lladdr == NULL) {
                return false;
        }
 
        switch (lladdr->len) {
        case 2:
                if (!memcmp(&addr[14], lladdr->addr, lladdr->len) &&
                    addr[8]  == 0U &&
                    addr[9]  == 0U &&
                    addr[10] == 0U &&
                    addr[11] == 0xff &&
                    addr[12] == 0xfe) {
                        return true;
                }
 
                break;
        case 6:
                if (lladdr->type == NET_LINK_ETHERNET) {
                        if (!memcmp(&addr[9], &lladdr->addr[1], 2) &&
                            !memcmp(&addr[13], &lladdr->addr[3], 3) &&
                            addr[11] == 0xff &&
                            addr[12] == 0xfe &&
                            (addr[8] ^ 0x02) == lladdr->addr[0]) {
                                return true;
                        }
                }
 
                break;
        case 8:
                if (sizeof(lladdr->addr) < 8) {
                        return false;
                }
 
                if (!memcmp(&addr[9], &lladdr->addr[1],
                            lladdr->len - 1) &&
                    (addr[8] ^ 0x02) == lladdr->addr[0]) {
                        return true;
                }
 
                break;
        default:
                return false;
        }
 
        return false;
}

static inline bool net_ipv6_addr_based_on_ll(const struct net_in6_addr *addr,
                                             const struct net_linkaddr *lladdr)
{
        if (addr == NULL || lladdr == NULL) {
                return false;
        }
 
        return net_ipv6_addr_based_on_ll_raw(addr->s6_addr, lladdr);
}

static ALWAYS_INLINE struct net_sockaddr *net_sad(const struct net_sockaddr_storage *addr)
{
        return (struct net_sockaddr *)addr;
}

static ALWAYS_INLINE struct net_sockaddr_storage *net_sas(const struct net_sockaddr *addr)
{
        return (struct net_sockaddr_storage *)addr;
}

static ALWAYS_INLINE struct net_sockaddr_in6 *net_sin6(const struct net_sockaddr *addr)
{
        return (struct net_sockaddr_in6 *)addr;
}

static ALWAYS_INLINE struct net_sockaddr_in *net_sin(const struct net_sockaddr *addr)
{
        return (struct net_sockaddr_in *)addr;
}

static ALWAYS_INLINE
struct net_sockaddr_in6_ptr *net_sin6_ptr(const struct net_sockaddr_ptr *addr)
{
        return (struct net_sockaddr_in6_ptr *)addr;
}

static ALWAYS_INLINE
struct net_sockaddr_in_ptr *net_sin_ptr(const struct net_sockaddr_ptr *addr)
{
        return (struct net_sockaddr_in_ptr *)addr;
}

static ALWAYS_INLINE
struct net_sockaddr_ll_ptr *net_sll_ptr(const struct net_sockaddr_ptr *addr)
{
        return (struct net_sockaddr_ll_ptr *)addr;
}

static ALWAYS_INLINE
struct net_sockaddr_can_ptr *net_can_ptr(const struct net_sockaddr_ptr *addr)
{
        return (struct net_sockaddr_can_ptr *)addr;
}

__syscall int net_addr_pton(net_sa_family_t family, const char *src, void *dst);

__syscall char *net_addr_ntop(net_sa_family_t family, const void *src,
                              char *dst, size_t size);

int net_mask_len_to_netmask(net_sa_family_t family, uint8_t mask_len,
                            struct net_sockaddr *mask);

int net_netmask_to_mask_len(net_sa_family_t family, struct net_sockaddr *mask,
                            uint8_t *mask_len);

bool net_ipaddr_parse(const char *str, size_t str_len,
                      struct net_sockaddr *addr);

const char *net_ipaddr_parse_mask(const char *str, size_t str_len,
                                  struct net_sockaddr *addr, uint8_t *mask_len);

int net_port_set_default(struct net_sockaddr *addr, uint16_t default_port);

int net_port_set(struct net_sockaddr *addr, uint16_t port);

int net_port_get(struct net_sockaddr *addr, uint16_t *port);

static inline bool net_sockaddr_cmp(const struct net_sockaddr *a, const struct net_sockaddr *b)
{
        if (a->sa_family != b->sa_family) {
                return false;
        }
 
        switch (a->sa_family) {
        case NET_AF_INET: {
                const struct net_sockaddr_in *a4 = net_sin(a);
                const struct net_sockaddr_in *b4 = net_sin(b);
 
                if (a4->sin_port != b4->sin_port) {
                        return false;
                }
 
                return net_ipv4_addr_cmp(&a4->sin_addr, &b4->sin_addr);
        }
 
        case NET_AF_INET6: {
                const struct net_sockaddr_in6 *a6 = net_sin6(a);
                const struct net_sockaddr_in6 *b6 = net_sin6(b);
 
                if (a6->sin6_port != b6->sin6_port) {
                        return false;
                }
 
                return net_ipv6_addr_cmp(&a6->sin6_addr, &b6->sin6_addr);
        }
 
        default:
                /* Invalid address family */
                return false;
        }
}

static inline int32_t net_tcp_seq_cmp(uint32_t seq1, uint32_t seq2)
{
        return (int32_t)(seq1 - seq2);
}

static inline bool net_tcp_seq_greater(uint32_t seq1, uint32_t seq2)
{
        return net_tcp_seq_cmp(seq1, seq2) > 0;
}

int net_bytes_from_str(uint8_t *buf, int buf_len, const char *src);

int net_tx_priority2tc(enum net_priority prio);

int net_rx_priority2tc(enum net_priority prio);

static inline enum net_priority net_vlan2priority(uint8_t priority)
{
        /* Map according to IEEE 802.1Q */
        static const uint8_t vlan2priority[] = {
                NET_PRIORITY_BE,
                NET_PRIORITY_BK,
                NET_PRIORITY_EE,
                NET_PRIORITY_CA,
                NET_PRIORITY_VI,
                NET_PRIORITY_VO,
                NET_PRIORITY_IC,
                NET_PRIORITY_NC
        };
 
        if (priority >= ARRAY_SIZE(vlan2priority)) {
                /* Use Best Effort as the default priority */
                return NET_PRIORITY_BE;
        }
 
        return (enum net_priority)vlan2priority[priority];
}

static inline uint8_t net_priority2vlan(enum net_priority priority)
{
        /* The conversion works both ways */
        return (uint8_t)net_vlan2priority(priority);
}

const char *net_family2str(net_sa_family_t family);

static inline size_t net_family2size(net_sa_family_t family)
{
        switch (family) {
        case NET_AF_INET:
                return sizeof(struct net_sockaddr_in);
        case NET_AF_INET6:
                return sizeof(struct net_sockaddr_in6);
        case NET_AF_PACKET:
                return sizeof(struct net_sockaddr_ll);
        case NET_AF_UNIX:
                return sizeof(struct net_sockaddr_un);
        case NET_AF_CAN:
                return sizeof(struct net_sockaddr_can);
        case NET_AF_NET_MGMT:
                return sizeof(struct net_sockaddr_nm);
        default:
                return 0;
        }
}

#if defined(CONFIG_NET_IPV6_PE)
int net_ipv6_pe_add_filter(struct net_in6_addr *addr, bool is_denylist);
#else
static inline int net_ipv6_pe_add_filter(struct net_in6_addr *addr,
                                         bool is_denylist)
{
        ARG_UNUSED(addr);
        ARG_UNUSED(is_denylist);
 
        return -ENOTSUP;
}
#endif /* CONFIG_NET_IPV6_PE */

#if defined(CONFIG_NET_IPV6_PE)
int net_ipv6_pe_del_filter(struct net_in6_addr *addr);
#else
static inline int net_ipv6_pe_del_filter(struct net_in6_addr *addr)
{
        ARG_UNUSED(addr);
 
        return -ENOTSUP;
}
#endif /* CONFIG_NET_IPV6_PE */
 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/net_ip.h>
 
#if defined(CONFIG_NET_NAMESPACE_COMPAT_MODE)
#define ZEPHYR_INCLUDE_NET_COMPAT_MODE_SYMBOLS
#include <zephyr/net/net_compat.h>
#undef ZEPHYR_INCLUDE_NET_COMPAT_MODE_SYMBOLS
#endif /* CONFIG_NET_NAMESPACE_COMPAT_MODE */

 
#endif /* ZEPHYR_INCLUDE_NET_NET_IP_H_ */