michaelh/zephyr
1
0
Fork 0
Code Releases Activity

net: ipv4: Remove in_addr from packed net_ipv4_hdr struct

Browse source 
Replace unpacked in_addr structures with raw buffers in net_ipv4_hdr
struct, to prevent compiler warnings about unaligned access.

Signed-off-by: Robert Lubos <robert.lubos@nordicsemi.no>
This commit is contained in:
Robert Lubos 2021-10-04 14:40:22 +02:00 • committed by Anas Nashif
commit 064200b420
18 changed files with 94 additions and 88 deletions
Download patch file Download diff file Expand all files Collapse all files

8
drivers/net/loopback.c
View file

@ -86,10 +86,10 @@ static int loopback_send(const struct device *dev, struct net_pkt *pkt)
} else {
struct in_addr addr;
net_ipaddr_copy(&addr, &NET_IPV4_HDR(pkt)->src);
net_ipaddr_copy(&NET_IPV4_HDR(pkt)->src,
&NET_IPV4_HDR(pkt)->dst);
net_ipaddr_copy(&NET_IPV4_HDR(pkt)->dst, &addr);
net_ipv4_addr_copy_raw((uint8_t *)&addr, NET_IPV4_HDR(pkt)->src);
net_ipv4_addr_copy_raw(NET_IPV4_HDR(pkt)->src,
NET_IPV4_HDR(pkt)->dst);
net_ipv4_addr_copy_raw(NET_IPV4_HDR(pkt)->dst, (uint8_t *)&addr);
}
/* We should simulate normal driver meaning that if the packet is

4
include/net/net_ip.h
View file

@ -486,8 +486,8 @@ struct net_ipv4_hdr {
uint8_t ttl;
uint8_t proto;
uint16_t chksum;
struct in_addr src;
struct in_addr dst;
uint8_t src[NET_IPV4_ADDR_SIZE];
uint8_t dst[NET_IPV4_ADDR_SIZE];
} __packed;
struct net_icmp_hdr {

2
samples/net/zperf/src/zperf_session.c
View file

@ -50,7 +50,7 @@ struct session *get_session(struct net_pkt *pkt,
if (net_pkt_family(pkt) == AF_INET6) {
net_ipaddr_copy(&ipv6, &ip_hdr->ipv6->src);
} else if (net_pkt_family(pkt) == AF_INET) {
net_ipaddr_copy(&ipv4, &ip_hdr->ipv4->src);
net_ipv4_addr_copy_raw((uint8_t *)&ipv4, ip_hdr->ipv4->src);
} else {
printk("Error! unsupported protocol %d\n",
net_pkt_family(pkt));

4
samples/net/zperf/src/zperf_udp_receiver.c
View file

@ -44,8 +44,8 @@ static inline void set_dst_addr(const struct shell *shell,
}
if (IS_ENABLED(CONFIG_NET_IPV4) && family == AF_INET) {
net_ipaddr_copy(&net_sin(dst_addr)->sin_addr,
&ip_hdr->ipv4->src);
net_ipv4_addr_copy_raw((uint8_t *)&net_sin(dst_addr)->sin_addr,
ip_hdr->ipv4->src);
net_sin(dst_addr)->sin_family = AF_INET;
net_sin(dst_addr)->sin_port = udp_hdr->src_port;
}

20
subsys/net/ip/connection.c
View file

@ -440,16 +440,16 @@ static bool conn_addr_cmp(struct net_pkt *pkt,
} else if (IS_ENABLED(CONFIG_NET_IPV4) &&
net_pkt_family(pkt) == AF_INET &&
addr->sa_family == AF_INET) {
struct in_addr *addr4;
uint8_t *addr4;
if (is_remote) {
addr4 = &ip_hdr->ipv4->src;
addr4 = ip_hdr->ipv4->src;
} else {
addr4 = &ip_hdr->ipv4->dst;
addr4 = ip_hdr->ipv4->dst;
}
if (net_sin(addr)->sin_addr.s_addr) {
if (!net_ipv4_addr_cmp(&net_sin(addr)->sin_addr,
if (!net_ipv4_addr_cmp_raw((uint8_t *)&net_sin(addr)->sin_addr,
addr4)) {
return false;
}
@ -494,9 +494,9 @@ static bool conn_are_end_points_valid(struct net_pkt *pkt,
}
if (IS_ENABLED(CONFIG_NET_IPV4) && net_pkt_family(pkt) == AF_INET) {
if (net_ipv4_addr_cmp(&ip_hdr->ipv4->src,
&ip_hdr->ipv4->dst) ||
net_ipv4_is_my_addr(&ip_hdr->ipv4->src)) {
if (net_ipv4_addr_cmp_raw(ip_hdr->ipv4->src,
ip_hdr->ipv4->dst) ||
net_ipv4_is_my_addr((struct in_addr *)ip_hdr->ipv4->src)) {
my_src_addr = true;
}
} else if (IS_ENABLED(CONFIG_NET_IPV6) &&
@ -614,10 +614,10 @@ enum net_verdict net_conn_input(struct net_pkt *pkt,
* need to deliver the packet to multiple recipients.
*/
if (IS_ENABLED(CONFIG_NET_IPV4) && net_pkt_family(pkt) == AF_INET) {
if (net_ipv4_is_addr_mcast(&ip_hdr->ipv4->dst)) {
if (net_ipv4_is_addr_mcast((struct in_addr *)ip_hdr->ipv4->dst)) {
is_mcast_pkt = true;
} else if (net_if_ipv4_is_addr_bcast(pkt_iface,
&ip_hdr->ipv4->dst)) {
} else if (net_if_ipv4_is_addr_bcast(
pkt_iface, (struct in_addr *)ip_hdr->ipv4->dst)) {
is_bcast_pkt = true;
}
} else if (IS_ENABLED(CONFIG_NET_IPV6) &&

19
subsys/net/ip/icmpv4.c
View file

@ -418,7 +418,7 @@ static enum net_verdict icmpv4_handle_echo_request(struct net_pkt *pkt,
/* If interface can not select src address based on dst addr
* and src address is unspecified, drop the echo request.
*/
if (net_ipv4_is_addr_unspecified(&ip_hdr->src)) {
if (net_ipv4_is_addr_unspecified((struct in_addr *)ip_hdr->src)) {
NET_DBG("DROP: src addr is unspecified");
goto drop;
}
@ -445,15 +445,16 @@ static enum net_verdict icmpv4_handle_echo_request(struct net_pkt *pkt,
goto drop;
}
if (net_ipv4_is_addr_mcast(&ip_hdr->dst) ||
net_ipv4_is_addr_bcast(net_pkt_iface(pkt), &ip_hdr->dst)) {
if (net_ipv4_is_addr_mcast((struct in_addr *)ip_hdr->dst) ||
net_ipv4_is_addr_bcast(net_pkt_iface(pkt),
(struct in_addr *)ip_hdr->dst)) {
src = net_if_ipv4_select_src_addr(net_pkt_iface(pkt),
&ip_hdr->dst);
(struct in_addr *)ip_hdr->dst);
} else {
src = &ip_hdr->dst;
src = (struct in_addr *)ip_hdr->dst;
}
if (net_ipv4_create(reply, src, &ip_hdr->src)) {
if (net_ipv4_create(reply, src, (struct in_addr *)ip_hdr->src)) {
goto drop;
}
@ -618,7 +619,8 @@ int net_icmpv4_send_error(struct net_pkt *orig, uint8_t type, uint8_t code)
goto drop_no_pkt;
}
if (net_ipv4_create(pkt, &ip_hdr->dst, &ip_hdr->src) ||
if (net_ipv4_create(pkt, (struct in_addr *)ip_hdr->dst,
(struct in_addr *)ip_hdr->src) ||
icmpv4_create(pkt, type, code) ||
net_pkt_memset(pkt, 0, NET_ICMPV4_UNUSED_LEN) ||
net_pkt_copy(pkt, orig, copy_len)) {
@ -680,7 +682,8 @@ enum net_verdict net_icmpv4_input(struct net_pkt *pkt,
goto drop;
}
if (net_ipv4_is_addr_bcast(net_pkt_iface(pkt), &ip_hdr->dst) &&
if (net_ipv4_is_addr_bcast(net_pkt_iface(pkt),
(struct in_addr *)ip_hdr->dst) &&
(!IS_ENABLED(CONFIG_NET_ICMPV4_ACCEPT_BROADCAST) ||
icmp_hdr->type != NET_ICMPV4_ECHO_REQUEST)) {
NET_DBG("DROP: broadcast pkt");

2
subsys/net/ip/igmp.c
View file

@ -189,7 +189,7 @@ enum net_verdict net_ipv4_igmp_input(struct net_pkt *pkt,
/* TODO: receive from arbitrary group address instead of
* all_systems
*/
if (!net_ipv4_addr_cmp(&ip_hdr->dst, &all_systems)) {
if (!net_ipv4_addr_cmp_raw(ip_hdr->dst, (uint8_t *)&all_systems)) {
NET_DBG("DROP: Invalid dst address");
return NET_DROP;
}

22
subsys/net/ip/ipv4.c
View file

@ -63,8 +63,8 @@ int net_ipv4_create_full(struct net_pkt *pkt,
ipv4_hdr->proto = 0U;
ipv4_hdr->chksum = 0U;
net_ipaddr_copy(&ipv4_hdr->dst, dst);
net_ipaddr_copy(&ipv4_hdr->src, src);
net_ipv4_addr_copy_raw(ipv4_hdr->dst, (uint8_t *)dst);
net_ipv4_addr_copy_raw(ipv4_hdr->src, (uint8_t *)src);
net_pkt_set_ip_hdr_len(pkt, sizeof(struct net_ipv4_hdr));
@ -268,17 +268,17 @@ enum net_verdict net_ipv4_input(struct net_pkt *pkt)
net_pkt_update_length(pkt, pkt_len);
}
if (net_ipv4_is_addr_mcast(&hdr->src)) {
if (net_ipv4_is_addr_mcast((struct in_addr *)hdr->src)) {
NET_DBG("DROP: src addr is %s", "mcast");
goto drop;
}
if (net_ipv4_is_addr_bcast(net_pkt_iface(pkt), &hdr->src)) {
if (net_ipv4_is_addr_bcast(net_pkt_iface(pkt), (struct in_addr *)hdr->src)) {
NET_DBG("DROP: src addr is %s", "bcast");
goto drop;
}
if (net_ipv4_is_addr_unspecified(&hdr->src)) {
if (net_ipv4_is_addr_unspecified((struct in_addr *)hdr->src)) {
NET_DBG("DROP: src addr is %s", "unspecified");
goto drop;
}
@ -289,16 +289,16 @@ enum net_verdict net_ipv4_input(struct net_pkt *pkt)
goto drop;
}
if ((!net_ipv4_is_my_addr(&hdr->dst) &&
!net_ipv4_is_addr_mcast(&hdr->dst) &&
if ((!net_ipv4_is_my_addr((struct in_addr *)hdr->dst) &&
!net_ipv4_is_addr_mcast((struct in_addr *)hdr->dst) &&
!(hdr->proto == IPPROTO_UDP &&
(net_ipv4_addr_cmp(&hdr->dst, net_ipv4_broadcast_address()) ||
(net_ipv4_addr_cmp((struct in_addr *)hdr->dst, net_ipv4_broadcast_address()) ||
/* RFC 1122 ch. 3.3.6 The 0.0.0.0 is non-standard bcast addr */
(IS_ENABLED(CONFIG_NET_IPV4_ACCEPT_ZERO_BROADCAST) &&
net_ipv4_addr_cmp(&hdr->dst,
net_ipv4_addr_cmp((struct in_addr *)hdr->dst,
net_ipv4_unspecified_address()))))) ||
(hdr->proto == IPPROTO_TCP &&
net_ipv4_is_addr_bcast(net_pkt_iface(pkt), &hdr->dst))) {
net_ipv4_is_addr_bcast(net_pkt_iface(pkt), (struct in_addr *)hdr->dst))) {
NET_DBG("DROP: not for me");
goto drop;
}
@ -355,7 +355,7 @@ enum net_verdict net_ipv4_input(struct net_pkt *pkt)
struct net_addr remote_addr;
remote_addr.family = AF_INET;
net_ipaddr_copy(&remote_addr.in_addr, &hdr->src);
net_ipv4_addr_copy_raw((uint8_t *)&remote_addr.in_addr, hdr->src);
/* Get rid of the old IP header */
net_pkt_cursor_restore(pkt, &hdr_start);

18
subsys/net/ip/net_core.c
View file

@ -246,7 +246,7 @@ static inline int check_ip_addr(struct net_pkt *pkt)
#if defined(CONFIG_NET_IPV4)
if (net_pkt_family(pkt) == AF_INET) {
if (net_ipv4_addr_cmp(&NET_IPV4_HDR(pkt)->dst,
if (net_ipv4_addr_cmp((struct in_addr *)NET_IPV4_HDR(pkt)->dst,
net_ipv4_unspecified_address())) {
NET_DBG("IPv4 dst address missing");
return -EADDRNOTAVAIL;
@ -255,19 +255,19 @@ static inline int check_ip_addr(struct net_pkt *pkt)
/* If the destination address is our own, then route it
* back to us.
*/
if (net_ipv4_is_addr_loopback(&NET_IPV4_HDR(pkt)->dst) ||
if (net_ipv4_is_addr_loopback((struct in_addr *)NET_IPV4_HDR(pkt)->dst) ||
(net_ipv4_is_addr_bcast(net_pkt_iface(pkt),
&NET_IPV4_HDR(pkt)->dst) == false &&
net_ipv4_is_my_addr(&NET_IPV4_HDR(pkt)->dst))) {
(struct in_addr *)NET_IPV4_HDR(pkt)->dst) == false &&
net_ipv4_is_my_addr((struct in_addr *)NET_IPV4_HDR(pkt)->dst))) {
struct in_addr addr;
/* Swap the addresses so that in receiving side
* the packet is accepted.
*/
net_ipaddr_copy(&addr, &NET_IPV4_HDR(pkt)->src);
net_ipaddr_copy(&NET_IPV4_HDR(pkt)->src,
&NET_IPV4_HDR(pkt)->dst);
net_ipaddr_copy(&NET_IPV4_HDR(pkt)->dst, &addr);
net_ipv4_addr_copy_raw((uint8_t *)&addr, NET_IPV4_HDR(pkt)->src);
net_ipv4_addr_copy_raw(NET_IPV4_HDR(pkt)->src,
NET_IPV4_HDR(pkt)->dst);
net_ipv4_addr_copy_raw(NET_IPV4_HDR(pkt)->dst, (uint8_t *)&addr);
return 1;
}
@ -276,7 +276,7 @@ static inline int check_ip_addr(struct net_pkt *pkt)
* as having src 127.0.0.0/8 is perfectly ok if dst is in
* localhost subnet too.
*/
if (net_ipv4_is_addr_loopback(&NET_IPV4_HDR(pkt)->src)) {
if (net_ipv4_is_addr_loopback((struct in_addr *)NET_IPV4_HDR(pkt)->src)) {
NET_DBG("IPv4 loopback src address");
return -EADDRNOTAVAIL;
}

10
subsys/net/ip/tcp.c
View file

@ -161,9 +161,9 @@ static int tcp_endpoint_set(union tcp_endpoint *ep, struct net_pkt *pkt,
ep->sin.sin_port = src == TCP_EP_SRC ? th_sport(th) :
th_dport(th);
net_ipaddr_copy(&ep->sin.sin_addr,
net_ipv4_addr_copy_raw((uint8_t *)&ep->sin.sin_addr,
src == TCP_EP_SRC ?
&ip->src : &ip->dst);
ip->src : ip->dst);
ep->sa.sa_family = AF_INET;
} else {
ret = -EINVAL;
@ -828,8 +828,10 @@ static int net_tcp_set_mss_opt(struct tcp *conn, struct net_pkt *pkt)
static bool is_destination_local(struct net_pkt *pkt)
{
if (IS_ENABLED(CONFIG_NET_IPV4) && net_pkt_family(pkt) == AF_INET) {
if (net_ipv4_is_addr_loopback(&NET_IPV4_HDR(pkt)->dst) ||
net_ipv4_is_my_addr(&NET_IPV4_HDR(pkt)->dst)) {
if (net_ipv4_is_addr_loopback(
(struct in_addr *)NET_IPV4_HDR(pkt)->dst) ||
net_ipv4_is_my_addr(
(struct in_addr *)NET_IPV4_HDR(pkt)->dst)) {
return true;
}
}

17
subsys/net/l2/ethernet/ethernet.c
View file

@ -179,9 +179,9 @@ enum net_verdict ethernet_check_ipv4_bcast_addr(struct net_pkt *pkt,
struct net_eth_hdr *hdr)
{
if (net_eth_is_addr_broadcast(&hdr->dst) &&
!(net_ipv4_is_addr_mcast(&NET_IPV4_HDR(pkt)->dst) ||
!(net_ipv4_is_addr_mcast((struct in_addr *)NET_IPV4_HDR(pkt)->dst) ||
net_ipv4_is_addr_bcast(net_pkt_iface(pkt),
&NET_IPV4_HDR(pkt)->dst))) {
(struct in_addr *)NET_IPV4_HDR(pkt)->dst))) {
return NET_DROP;
}
@ -353,8 +353,8 @@ drop:
static inline bool ethernet_ipv4_dst_is_broadcast_or_mcast(struct net_pkt *pkt)
{
if (net_ipv4_is_addr_bcast(net_pkt_iface(pkt),
&NET_IPV4_HDR(pkt)->dst) ||
net_ipv4_is_addr_mcast(&NET_IPV4_HDR(pkt)->dst)) {
(struct in_addr *)NET_IPV4_HDR(pkt)->dst) ||
net_ipv4_is_addr_mcast((struct in_addr *)NET_IPV4_HDR(pkt)->dst)) {
return true;
}
@ -365,9 +365,10 @@ static bool ethernet_fill_in_dst_on_ipv4_mcast(struct net_pkt *pkt,
struct net_eth_addr *dst)
{
if (net_pkt_family(pkt) == AF_INET &&
net_ipv4_is_addr_mcast(&NET_IPV4_HDR(pkt)->dst)) {
net_ipv4_is_addr_mcast((struct in_addr *)NET_IPV4_HDR(pkt)->dst)) {
/* Multicast address */
net_eth_ipv4_mcast_to_mac_addr(&NET_IPV4_HDR(pkt)->dst, dst);
net_eth_ipv4_mcast_to_mac_addr(
(struct in_addr *)NET_IPV4_HDR(pkt)->dst, dst);
return true;
}
@ -385,7 +386,7 @@ static struct net_pkt *ethernet_ll_prepare_on_ipv4(struct net_if *iface,
if (IS_ENABLED(CONFIG_NET_ARP)) {
struct net_pkt *arp_pkt;
arp_pkt = net_arp_prepare(pkt, &NET_IPV4_HDR(pkt)->dst, NULL);
arp_pkt = net_arp_prepare(pkt, (struct in_addr *)NET_IPV4_HDR(pkt)->dst, NULL);
if (!arp_pkt) {
return NULL;
}
@ -461,7 +462,7 @@ static enum net_verdict set_vlan_tag(struct ethernet_context *ctx,
if (net_pkt_family(pkt) == AF_INET) {
struct net_if *target;
if (net_if_ipv4_addr_lookup(&NET_IPV4_HDR(pkt)->src,
if (net_if_ipv4_addr_lookup((struct in_addr *)NET_IPV4_HDR(pkt)->src,
&target)) {
if (target != iface) {
NET_DBG("Iface %p should be %p", iface,

2
subsys/net/l2/virtual/ipip/ipip.c
View file

@ -368,7 +368,7 @@ static enum net_verdict interface_input(struct net_if *input_iface,
return NET_DROP;
}
iface = net_if_ipv4_select_src_iface(&hdr->dst);
iface = net_if_ipv4_select_src_iface((struct in_addr *)hdr->dst);
if (iface == NULL) {
NET_DBG("DROP: not for me (dst %s)",
net_sprint_ipv4_addr(&hdr->dst));

4
subsys/net/lib/dns/llmnr_responder.c
View file

@ -104,7 +104,7 @@ static void create_ipv4_dst_addr(struct net_pkt *pkt,
addr->sin_family = AF_INET;
addr->sin_port = udp_hdr->src_port;
net_ipaddr_copy(&addr->sin_addr, &NET_IPV4_HDR(pkt)->src);
net_ipv4_addr_copy_raw((uint8_t *)&addr->sin_addr, NET_IPV4_HDR(pkt)->src);
}
#endif
@ -352,7 +352,7 @@ static int create_ipv6_answer(struct net_context *ctx,
} else if (qtype == DNS_RR_TYPE_A) {
#if defined(CONFIG_NET_IPV4)
addr = get_ipv4_src(net_pkt_iface(pkt),
&ip_hdr->ipv4->src);
(struct in_addr *)ip_hdr->ipv4->src);
if (!addr) {
return -ENOENT;
}

4
subsys/net/lib/dns/mdns_responder.c
View file

@ -253,7 +253,7 @@ static int send_response(struct net_context *ctx,
const struct in_addr *addr;
addr = net_if_ipv4_select_src_addr(net_pkt_iface(pkt),
&ip_hdr->ipv4->src);
(struct in_addr *)ip_hdr->ipv4->src);
ret = create_answer(ctx, query, qtype,
sizeof(struct in_addr), (uint8_t *)addr);
@ -347,7 +347,7 @@ static void send_sd_response(struct net_context *ctx,
if (IS_ENABLED(CONFIG_NET_IPV4)) {
/* Look up the local IPv4 address */
addr4 = net_if_ipv4_select_src_addr(net_pkt_iface(pkt),
&ip_hdr->ipv4->src);
(struct in_addr *)ip_hdr->ipv4->src);
}
if (IS_ENABLED(CONFIG_NET_IPV6)) {

2
subsys/net/lib/sockets/sockets.c
View file

@ -866,7 +866,7 @@ static int sock_get_pkt_src_addr(struct net_pkt *pkt,
goto error;
}
net_ipaddr_copy(&addr4->sin_addr, &ipv4_hdr->src);
net_ipv4_addr_copy_raw((uint8_t *)&addr4->sin_addr, ipv4_hdr->src);
port = &addr4->sin_port;
} else if (IS_ENABLED(CONFIG_NET_IPV6) &&
net_pkt_family(pkt) == AF_INET6) {

24
tests/net/arp/src/main.c
View file

@ -369,12 +369,12 @@ void test_arp(void)
ipv4 = (struct net_ipv4_hdr *)net_buf_add(pkt->buffer,
sizeof(struct net_ipv4_hdr));
net_ipaddr_copy(&ipv4->src, &src);
net_ipaddr_copy(&ipv4->dst, &dst);
net_ipv4_addr_copy_raw(ipv4->src, (uint8_t *)&src);
net_ipv4_addr_copy_raw(ipv4->dst, (uint8_t *)&dst);
memcpy(net_buf_add(pkt->buffer, len), app_data, len);
pkt2 = net_arp_prepare(pkt, &NET_IPV4_HDR(pkt)->dst, NULL);
pkt2 = net_arp_prepare(pkt, &dst, NULL);
/* pkt2 is the ARP packet and pkt is the IPv4 packet and it was
* stored in ARP table.
@ -431,7 +431,7 @@ void test_arp(void)
}
if (!net_ipv4_addr_cmp_raw(arp_hdr->dst_ipaddr,
(uint8_t *)&NET_IPV4_HDR(pkt)->dst)) {
NET_IPV4_HDR(pkt)->dst)) {
printk("ARP IP dest invalid %s, should be %s",
net_sprint_ipv4_addr(&arp_hdr->dst_ipaddr),
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->dst));
@ -439,7 +439,7 @@ void test_arp(void)
}
if (!net_ipv4_addr_cmp_raw(arp_hdr->src_ipaddr,
(uint8_t *)&NET_IPV4_HDR(pkt)->src)) {
NET_IPV4_HDR(pkt)->src)) {
printk("ARP IP src invalid %s, should be %s",
net_sprint_ipv4_addr(&arp_hdr->src_ipaddr),
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src));
@ -455,9 +455,9 @@ void test_arp(void)
"ARP cache should own the original packet");
/* Then a case where target is not in the same subnet */
net_ipaddr_copy(&ipv4->dst, &dst_far);
net_ipv4_addr_copy_raw(ipv4->dst, (uint8_t *)&dst_far);
pkt2 = net_arp_prepare(pkt, &NET_IPV4_HDR(pkt)->dst, NULL);
pkt2 = net_arp_prepare(pkt, &dst_far, NULL);
zassert_not_equal((void *)(pkt2), (void *)(pkt),
"ARP cache should not find anything");
@ -481,14 +481,14 @@ void test_arp(void)
/* Try to find the same destination again, this should fail as there
* is a pending request in ARP cache.
*/
net_ipaddr_copy(&ipv4->dst, &dst_far);
net_ipv4_addr_copy_raw(ipv4->dst, (uint8_t *)&dst_far);
/* Make sure prepare will not free the pkt because it will be
* needed in the later test case.
*/
net_pkt_ref(pkt);
pkt2 = net_arp_prepare(pkt, &NET_IPV4_HDR(pkt)->dst, NULL);
pkt2 = net_arp_prepare(pkt, &dst_far, NULL);
zassert_not_null(pkt2,
"ARP cache is not sending the request again");
@ -498,14 +498,14 @@ void test_arp(void)
/* Try to find the different destination, this should fail too
* as the cache table should be full.
*/
net_ipaddr_copy(&ipv4->dst, &dst_far2);
net_ipv4_addr_copy_raw(ipv4->dst, (uint8_t *)&dst_far2);
/* Make sure prepare will not free the pkt because it will be
* needed in the next test case.
*/
net_pkt_ref(pkt);
pkt2 = net_arp_prepare(pkt, &NET_IPV4_HDR(pkt)->dst, NULL);
pkt2 = net_arp_prepare(pkt, &dst_far2, NULL);
zassert_not_null(pkt2,
"ARP cache did not send a req");
@ -513,7 +513,7 @@ void test_arp(void)
/* Restore the original address so that following test case can
* work properly.
*/
net_ipaddr_copy(&ipv4->dst, &dst);
net_ipv4_addr_copy_raw(ipv4->dst, (uint8_t *)&dst);
/* The arp request packet is now verified, create an arp reply.
* The previous value of pkt is stored in arp table and is not lost.

8
tests/net/checksum_offload/src/main.c
View file

@ -170,10 +170,10 @@ static int eth_tx_offloading_disabled(const struct device *dev,
} else {
struct in_addr addr;
net_ipaddr_copy(&addr, &NET_IPV4_HDR(pkt)->src);
net_ipaddr_copy(&NET_IPV4_HDR(pkt)->src,
&NET_IPV4_HDR(pkt)->dst);
net_ipaddr_copy(&NET_IPV4_HDR(pkt)->dst, &addr);
net_ipv4_addr_copy_raw((uint8_t *)&addr, NET_IPV4_HDR(pkt)->src);
net_ipv4_addr_copy_raw(NET_IPV4_HDR(pkt)->src,
NET_IPV4_HDR(pkt)->dst);
net_ipv4_addr_copy_raw(NET_IPV4_HDR(pkt)->dst, (uint8_t *)&addr);
}
udp_hdr = net_udp_get_hdr(pkt, &hdr);

8
tests/net/context/src/main.c
View file

@ -921,10 +921,10 @@ static int tester_send(const struct device *dev, struct net_pkt *pkt)
} else {
struct in_addr addr;
net_ipaddr_copy(&addr, &NET_IPV4_HDR(pkt)->src);
net_ipaddr_copy(&NET_IPV4_HDR(pkt)->src,
&NET_IPV4_HDR(pkt)->dst);
net_ipaddr_copy(&NET_IPV4_HDR(pkt)->dst, &addr);
net_ipv4_addr_copy_raw((uint8_t *)&addr, NET_IPV4_HDR(pkt)->src);
net_ipv4_addr_copy_raw(NET_IPV4_HDR(pkt)->src,
NET_IPV4_HDR(pkt)->dst);
net_ipv4_addr_copy_raw(NET_IPV4_HDR(pkt)->dst, (uint8_t *)&addr);
}
udp_hdr = net_udp_get_hdr(pkt, &hdr);