michaelh/zephyr
1
0
Fork 0
Code Releases Activity

net: Use log_strdup() when printing debug strings

Browse source 
As the debugging print calls are async, all the strings that might
be overwritten must use log_strdup() which will create a copy
of the printable string.

Signed-off-by: Jukka Rissanen <jukka.rissanen@linux.intel.com>
This commit is contained in:
Jukka Rissanen 2018-10-02 14:57:55 +03:00
commit 57a8db7789
46 changed files with 513 additions and 405 deletions
Download patch file Download diff file Expand all files Collapse all files

2
samples/net/coap_server/src/coap-server.c
View file

@ -494,7 +494,7 @@ static int query_get(struct coap_resource *resource,
memcpy(str, options[i].value, options[i].len); memcpy(str, options[i].value, options[i].len);
str[options[i].len] = '\0'; str[options[i].len] = '\0';
NET_INFO("query[%d]: %s\n", i + 1, str); NET_INFO("query[%d]: %s\n", i + 1, log_strdup(str));
} }
NET_INFO("*******\n"); NET_INFO("*******\n");

13
samples/net/dhcpv4_client/src/main.c
View file

@ -41,18 +41,19 @@ static void handler(struct net_mgmt_event_callback *cb,
} }
NET_INFO("Your address: %s", NET_INFO("Your address: %s",
net_addr_ntop(AF_INET, log_strdup(net_addr_ntop(AF_INET,
&iface->config.ip.ipv4->unicast[i].address.in_addr, &iface->config.ip.ipv4->unicast[i].address.in_addr,
buf, sizeof(buf))); buf, sizeof(buf))));
NET_INFO("Lease time: %u seconds", NET_INFO("Lease time: %u seconds",
iface->config.dhcpv4.lease_time); iface->config.dhcpv4.lease_time);
NET_INFO("Subnet: %s", NET_INFO("Subnet: %s",
net_addr_ntop(AF_INET, log_strdup(net_addr_ntop(AF_INET,
&iface->config.ip.ipv4->netmask, &iface->config.ip.ipv4->netmask,
buf, sizeof(buf))); buf, sizeof(buf))));
NET_INFO("Router: %s", NET_INFO("Router: %s",
net_addr_ntop(AF_INET, &iface->config.ip.ipv4->gw, log_strdup(net_addr_ntop(AF_INET,
buf, sizeof(buf))); &iface->config.ip.ipv4->gw,
buf, sizeof(buf))));
} }
} }

33
samples/net/dns_resolve/src/main.c
View file

@ -83,9 +83,10 @@ void dns_result_cb(enum dns_resolve_status status,
return; return;
} }
NET_INFO("%s %s address: %s", user_data ? (char *)user_data : "<null>", hr_family, NET_INFO("%s %s address: %s", user_data ? (char *)user_data : "<null>",
net_addr_ntop(info->ai_family, addr, hr_family,
hr_addr, sizeof(hr_addr))); log_strdup(net_addr_ntop(info->ai_family, addr,
hr_addr, sizeof(hr_addr))));
} }
void mdns_result_cb(enum dns_resolve_status status, void mdns_result_cb(enum dns_resolve_status status,
@ -131,9 +132,10 @@ void mdns_result_cb(enum dns_resolve_status status,
return; return;
} }
NET_INFO("%s %s address: %s", user_data ? (char *)user_data : "<null>", hr_family, NET_INFO("%s %s address: %s", user_data ? (char *)user_data : "<null>",
net_addr_ntop(info->ai_family, addr, hr_family,
hr_addr, sizeof(hr_addr))); log_strdup(net_addr_ntop(info->ai_family, addr,
hr_addr, sizeof(hr_addr))));
} }
#if defined(CONFIG_NET_DHCPV4) #if defined(CONFIG_NET_DHCPV4)
@ -180,17 +182,19 @@ static void ipv4_addr_add_handler(struct net_mgmt_event_callback *cb,
} }
NET_INFO("IPv4 address: %s", NET_INFO("IPv4 address: %s",
net_addr_ntop(AF_INET, &if_addr->address.in_addr, log_strdup(net_addr_ntop(AF_INET,
hr_addr, NET_IPV4_ADDR_LEN)); &if_addr->address.in_addr,
hr_addr, NET_IPV4_ADDR_LEN)));
NET_INFO("Lease time: %u seconds", NET_INFO("Lease time: %u seconds",
iface->config.dhcpv4.lease_time); iface->config.dhcpv4.lease_time);
NET_INFO("Subnet: %s", NET_INFO("Subnet: %s",
net_addr_ntop(AF_INET, log_strdup(net_addr_ntop(AF_INET,
&iface->config.ip.ipv4->netmask, &iface->config.ip.ipv4->netmask,
hr_addr, NET_IPV4_ADDR_LEN)); hr_addr, NET_IPV4_ADDR_LEN)));
NET_INFO("Router: %s", NET_INFO("Router: %s",
net_addr_ntop(AF_INET, &iface->config.ip.ipv4->gw, log_strdup(net_addr_ntop(AF_INET,
hr_addr, NET_IPV4_ADDR_LEN)); &iface->config.ip.ipv4->gw,
hr_addr, NET_IPV4_ADDR_LEN)));
break; break;
} }
@ -265,7 +269,8 @@ static void setup_ipv4(struct net_if *iface)
net_if_ipv4_addr_add(iface, &addr, NET_ADDR_MANUAL, 0); net_if_ipv4_addr_add(iface, &addr, NET_ADDR_MANUAL, 0);
NET_INFO("IPv4 address: %s", NET_INFO("IPv4 address: %s",
net_addr_ntop(AF_INET, &addr, hr_addr, NET_IPV4_ADDR_LEN)); log_strdup(net_addr_ntop(AF_INET, &addr, hr_addr,
NET_IPV4_ADDR_LEN)));
ret = dns_get_addr_info(query, ret = dns_get_addr_info(query,
DNS_QUERY_TYPE_A, DNS_QUERY_TYPE_A,

4
samples/net/gptp/src/main.c
View file

@ -135,8 +135,8 @@ static void gptp_phase_dis_cb(u8_t *gm_identity,
memcpy(id, gm_identity, sizeof(id)); memcpy(id, gm_identity, sizeof(id));
NET_DBG("GM %s last phase %d.%lld", NET_DBG("GM %s last phase %d.%lld",
gptp_sprint_clock_id(gm_identity, output, log_strdup(gptp_sprint_clock_id(gm_identity, output,
sizeof(output)), sizeof(output))),
last_gm_ph_change->high, last_gm_ph_change->high,
last_gm_ph_change->low); last_gm_ph_change->low);
} }

6
samples/net/ipv4_autoconf/src/main.c
View file

@ -46,9 +46,9 @@ static void handler(struct net_mgmt_event_callback *cb,
} }
NET_INFO("Your address: %s", NET_INFO("Your address: %s",
net_addr_ntop(AF_INET, log_strdup(net_addr_ntop(AF_INET,
&cfg->ip.ipv4->unicast[i].address.in_addr, &cfg->ip.ipv4->unicast[i].address.in_addr,
buf, sizeof(buf))); buf, sizeof(buf))));
} }
} }

2
samples/net/nats/src/main.c
View file

@ -106,7 +106,7 @@ static int in_addr_set(sa_family_t family,
} }
if (rc < 0) { if (rc < 0) {
NET_ERR("Invalid IP address: %s", ip_addr); NET_ERR("Invalid IP address: %s", log_strdup(ip_addr));
return -EINVAL; return -EINVAL;
} }
} }

16
samples/net/promiscuous_mode/src/main.c
View file

@ -115,20 +115,24 @@ static void print_info(struct net_pkt *pkt)
if (family == AF_INET) { if (family == AF_INET) {
if (next_hdr == IPPROTO_TCP || next_hdr == IPPROTO_UDP) { if (next_hdr == IPPROTO_TCP || next_hdr == IPPROTO_UDP) {
NET_INFO("%s %s (%zd) %s:%u -> %s:%u", NET_INFO("%s %s (%zd) %s:%u -> %s:%u",
"IPv4", proto, len, src_addr, src_port, "IPv4", proto, len,
dst_addr, dst_port); log_strdup(src_addr), src_port,
log_strdup(dst_addr), dst_port);
} else { } else {
NET_INFO("%s %s (%zd) %s -> %s", "IPv4", proto, NET_INFO("%s %s (%zd) %s -> %s", "IPv4", proto,
len, src_addr, dst_addr); len, log_strdup(src_addr),
log_strdup(dst_addr));
} }
} else { } else {
if (next_hdr == IPPROTO_TCP || next_hdr == IPPROTO_UDP) { if (next_hdr == IPPROTO_TCP || next_hdr == IPPROTO_UDP) {
NET_INFO("%s %s (%zd) [%s]:%u -> [%s]:%u", NET_INFO("%s %s (%zd) [%s]:%u -> [%s]:%u",
"IPv6", proto, len, src_addr, src_port, "IPv6", proto, len,
dst_addr, dst_port); log_strdup(src_addr), src_port,
log_strdup(dst_addr), dst_port);
} else { } else {
NET_INFO("%s %s (%zd) %s -> %s", "IPv6", proto, NET_INFO("%s %s (%zd) %s -> %s", "IPv6", proto,
len, src_addr, dst_addr); len, log_strdup(src_addr),
log_strdup(dst_addr));
} }
} }
} }

21
samples/net/rpl_border_router/src/http.c
View file

@ -1798,7 +1798,8 @@ static void mgmt_cb(struct net_mgmt_event_callback *cb,
return; return;
} }
NET_DBG("NBR add %s", net_sprint_ipv6_addr(&nbr_info->addr)); NET_DBG("NBR add %s",
log_strdup(net_sprint_ipv6_addr(&nbr_info->addr)));
ret = send_ipv6_neighbors(&http_ctx, ws_dst, nbr); ret = send_ipv6_neighbors(&http_ctx, ws_dst, nbr);
if (ret < 0) { if (ret < 0) {
@ -1812,7 +1813,8 @@ static void mgmt_cb(struct net_mgmt_event_callback *cb,
return; return;
} }
NET_DBG("NBR del %s", net_sprint_ipv6_addr(&nbr_info->addr)); NET_DBG("NBR del %s",
log_strdup(net_sprint_ipv6_addr(&nbr_info->addr)));
ret = send_ipv6_neighbor_deletion(&http_ctx, ws_dst, iface, ret = send_ipv6_neighbor_deletion(&http_ctx, ws_dst, iface,
&nbr_info->addr); &nbr_info->addr);
@ -1834,11 +1836,12 @@ static void mgmt_cb(struct net_mgmt_event_callback *cb,
} }
NET_DBG("ROUTE add addr %s/%d", NET_DBG("ROUTE add addr %s/%d",
net_sprint_ipv6_addr(&route_info->addr), log_strdup(net_sprint_ipv6_addr(&route_info->addr)),
route_info->prefix_len); route_info->prefix_len);
{ {
NET_DBG("ROUTE add nexthop %s", NET_DBG("ROUTE add nexthop %s",
net_sprint_ipv6_addr(&route_info->nexthop)); log_strdup(net_sprint_ipv6_addr(
&route_info->nexthop)));
} }
@ -1858,13 +1861,11 @@ static void mgmt_cb(struct net_mgmt_event_callback *cb,
} }
NET_DBG("ROUTE del addr %s/%d", NET_DBG("ROUTE del addr %s/%d",
net_sprint_ipv6_addr(&route_info->addr), log_strdup(net_sprint_ipv6_addr(&route_info->addr)),
route_info->prefix_len); route_info->prefix_len);
{ NET_DBG("ROUTE del nexthop %s",
NET_DBG("ROUTE del nexthop %s", log_strdup(net_sprint_ipv6_addr(
net_sprint_ipv6_addr(&route_info->nexthop)); &route_info->nexthop)));
}
ret = send_ipv6_route_deletion(&http_ctx, ws_dst, iface, ret = send_ipv6_route_deletion(&http_ctx, ws_dst, iface,
route_info); route_info);

14
samples/net/rpl_border_router/src/rpl.c
View file

@ -53,7 +53,7 @@ static bool br_join_dag(struct net_rpl_dio *dio)
NET_DBG("Other root %s, me %s, " NET_DBG("Other root %s, me %s, "
"DIO version %d instance %d", "DIO version %d instance %d",
other, me, log_strdup(other), log_strdup(me),
dio->version, dio->instance_id); dio->version, dio->instance_id);
} }
} }
@ -84,12 +84,12 @@ bool setup_rpl(struct net_if *iface, const char *addr_prefix)
} }
if (rpl.prefix_len == 0) { if (rpl.prefix_len == 0) {
NET_ERR("Invalid prefix length %s", slash + 1); NET_ERR("Invalid prefix length %s", log_strdup(slash + 1));
return false; return false;
} }
if (net_addr_pton(AF_INET6, prefix, &rpl.prefix) < 0) { if (net_addr_pton(AF_INET6, prefix, &rpl.prefix) < 0) {
NET_ERR("Invalid IPv6 prefix %s", prefix); NET_ERR("Invalid IPv6 prefix %s", log_strdup(prefix));
return false; return false;
} }
@ -114,7 +114,8 @@ bool setup_rpl(struct net_if *iface, const char *addr_prefix)
ret = net_rpl_set_prefix(iface, dag, &rpl.prefix, rpl.prefix_len); ret = net_rpl_set_prefix(iface, dag, &rpl.prefix, rpl.prefix_len);
if (!ret) { if (!ret) {
NET_ERR("Cannot set prefix %s/%d", prefix, rpl.prefix_len); NET_ERR("Cannot set prefix %s/%d", log_strdup(prefix),
rpl.prefix_len);
return false; return false;
} }
@ -125,10 +126,11 @@ bool setup_rpl(struct net_if *iface, const char *addr_prefix)
NET_IPV6_ADDR_LEN)) { NET_IPV6_ADDR_LEN)) {
if (rpl.dag_has_version) { if (rpl.dag_has_version) {
NET_DBG("New RPL dag %s/%d version %u created", NET_DBG("New RPL dag %s/%d version %u created",
out, rpl.prefix_len, log_strdup(out), rpl.prefix_len,
rpl.dag_init_version); rpl.dag_init_version);
} else { } else {
NET_DBG("New RPL dag %s/%d created", out, NET_DBG("New RPL dag %s/%d created",
log_strdup(out),
rpl.prefix_len); rpl.prefix_len);
} }
} }

2
samples/net/rpl_node/src/main.c
View file

@ -236,7 +236,7 @@ static int append_rpl_parent(struct coap_packet *response)
parent = net_rpl_get_parent_addr(net_pkt_iface(response->pkt), parent = net_rpl_get_parent_addr(net_pkt_iface(response->pkt),
rpl->current_dag->preferred_parent); rpl->current_dag->preferred_parent);
pos = snprintk(&out[out_len], sizeof(out), "%s", pos = snprintk(&out[out_len], sizeof(out), "%s",
net_sprint_ipv6_addr(parent)); log_strdup(net_sprint_ipv6_addr(parent)));
out_len += pos; out_len += pos;
} }

21
samples/net/telnet/src/telnet.c
View file

@ -40,16 +40,19 @@ static void ipv4_addr_add_handler(struct net_mgmt_event_callback *cb,
} }
NET_INFO("IPv4 address: %s", NET_INFO("IPv4 address: %s",
net_addr_ntop(AF_INET, &if_addr->address.in_addr, log_strdup(net_addr_ntop(AF_INET,
hr_addr, NET_IPV4_ADDR_LEN)); &if_addr->address.in_addr,
hr_addr, NET_IPV4_ADDR_LEN)));
NET_INFO("Lease time: %u seconds", NET_INFO("Lease time: %u seconds",
iface->config.dhcpv4.lease_time); iface->config.dhcpv4.lease_time);
NET_INFO("Subnet: %s", NET_INFO("Subnet: %s",
net_addr_ntop(AF_INET, &iface->config.ip.ipv4->netmask, log_strdup(net_addr_ntop(AF_INET,
hr_addr, NET_IPV4_ADDR_LEN)); &iface->config.ip.ipv4->netmask,
hr_addr, NET_IPV4_ADDR_LEN)));
NET_INFO("Router: %s", NET_INFO("Router: %s",
net_addr_ntop(AF_INET, &iface->config.ip.ipv4->gw, log_strdup(net_addr_ntop(AF_INET,
hr_addr, NET_IPV4_ADDR_LEN)); &iface->config.ip.ipv4->gw,
hr_addr, NET_IPV4_ADDR_LEN)));
break; break;
} }
} }
@ -88,7 +91,8 @@ static void setup_ipv4(struct net_if *iface)
net_if_ipv4_addr_add(iface, &addr, NET_ADDR_MANUAL, 0); net_if_ipv4_addr_add(iface, &addr, NET_ADDR_MANUAL, 0);
NET_INFO("IPv4 address: %s", NET_INFO("IPv4 address: %s",
net_addr_ntop(AF_INET, &addr, hr_addr, NET_IPV4_ADDR_LEN)); log_strdup(net_addr_ntop(AF_INET, &addr, hr_addr,
NET_IPV4_ADDR_LEN)));
} }
#else #else
@ -116,7 +120,8 @@ static void setup_ipv6(struct net_if *iface)
net_if_ipv6_addr_add(iface, &addr, NET_ADDR_MANUAL, 0); net_if_ipv6_addr_add(iface, &addr, NET_ADDR_MANUAL, 0);
NET_INFO("IPv6 address: %s", NET_INFO("IPv6 address: %s",
net_addr_ntop(AF_INET6, &addr, hr_addr, NET_IPV6_ADDR_LEN)); log_strdup(net_addr_ntop(AF_INET6, &addr, hr_addr,
NET_IPV6_ADDR_LEN)));
if (net_addr_pton(AF_INET6, MCAST_IP6ADDR, &addr)) { if (net_addr_pton(AF_INET6, MCAST_IP6ADDR, &addr)) {
NET_ERR("Invalid address: %s", MCAST_IP6ADDR); NET_ERR("Invalid address: %s", MCAST_IP6ADDR);

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

@ -397,8 +397,8 @@ void prepare_register_debug_print(char *dst, int dst_len,
if (remote_addr && remote_addr->sa_family == AF_INET6) { if (remote_addr && remote_addr->sa_family == AF_INET6) {
if (IS_ENABLED(CONFIG_NET_IPV6)) { if (IS_ENABLED(CONFIG_NET_IPV6)) {
snprintk(dst, dst_len, "%s", snprintk(dst, dst_len, "%s",
net_sprint_ipv6_addr(&net_sin6(remote_addr)-> log_strdup(net_sprint_ipv6_addr(
sin6_addr)); &net_sin6(remote_addr)->sin6_addr)));
} else { } else {
snprintk(dst, dst_len, "%s", "?"); snprintk(dst, dst_len, "%s", "?");
} }
@ -406,8 +406,8 @@ void prepare_register_debug_print(char *dst, int dst_len,
} else if (remote_addr && remote_addr->sa_family == AF_INET) { } else if (remote_addr && remote_addr->sa_family == AF_INET) {
if (IS_ENABLED(CONFIG_NET_IPV4)) { if (IS_ENABLED(CONFIG_NET_IPV4)) {
snprintk(dst, dst_len, "%s", snprintk(dst, dst_len, "%s",
net_sprint_ipv4_addr(&net_sin(remote_addr)-> log_strdup(net_sprint_ipv4_addr(
sin_addr)); &net_sin(remote_addr)->sin_addr)));
} else { } else {
snprintk(dst, dst_len, "%s", "?"); snprintk(dst, dst_len, "%s", "?");
} }
@ -419,8 +419,8 @@ void prepare_register_debug_print(char *dst, int dst_len,
if (local_addr && local_addr->sa_family == AF_INET6) { if (local_addr && local_addr->sa_family == AF_INET6) {
if (IS_ENABLED(CONFIG_NET_IPV6)) { if (IS_ENABLED(CONFIG_NET_IPV6)) {
snprintk(src, src_len, "%s", snprintk(src, src_len, "%s",
net_sprint_ipv6_addr(&net_sin6(local_addr)-> log_strdup(net_sprint_ipv6_addr(
sin6_addr)); &net_sin6(local_addr)->sin6_addr)));
} else { } else {
snprintk(src, src_len, "%s", "?"); snprintk(src, src_len, "%s", "?");
} }
@ -428,8 +428,8 @@ void prepare_register_debug_print(char *dst, int dst_len,
} else if (local_addr && local_addr->sa_family == AF_INET) { } else if (local_addr && local_addr->sa_family == AF_INET) {
if (IS_ENABLED(CONFIG_NET_IPV4)) { if (IS_ENABLED(CONFIG_NET_IPV4)) {
snprintk(src, src_len, "%s", snprintk(src, src_len, "%s",
net_sprint_ipv4_addr(&net_sin(local_addr)-> log_strdup(net_sprint_ipv4_addr(
sin_addr)); &net_sin(local_addr)->sin_addr)));
} else { } else {
snprintk(src, src_len, "%s", "?"); snprintk(src, src_len, "%s", "?");
} }
@ -686,9 +686,10 @@ int net_conn_register(enum net_ip_protocol proto,
NET_DBG("[%d/%d/%u/0x%02x] remote %p/%s/%u ", i, NET_DBG("[%d/%d/%u/0x%02x] remote %p/%s/%u ", i,
local_addr ? local_addr->sa_family : AF_UNSPEC, local_addr ? local_addr->sa_family : AF_UNSPEC,
proto, rank, remote_addr, dst, remote_port); proto, rank, remote_addr, log_strdup(dst),
remote_port);
NET_DBG(" local %p/%s/%u cb %p ud %p", NET_DBG(" local %p/%s/%u cb %p ud %p",
local_addr, src, local_port, local_addr, log_strdup(src), local_port,
cb, user_data); cb, user_data);
} }

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

@ -318,9 +318,10 @@ static u32_t dhcpv4_send_request(struct net_if *iface)
iface->config.dhcpv4.attempts++; iface->config.dhcpv4.attempts++;
NET_DBG("send request dst=%s xid=0x%x ciaddr=%s%s%s timeout=%us", NET_DBG("send request dst=%s xid=0x%x ciaddr=%s%s%s timeout=%us",
net_sprint_ipv4_addr(server_addr), log_strdup(net_sprint_ipv4_addr(server_addr)),
iface->config.dhcpv4.xid, iface->config.dhcpv4.xid,
ciaddr ? net_sprint_ipv4_addr(ciaddr) : "<unknown>", ciaddr ?
log_strdup(net_sprint_ipv4_addr(ciaddr)) : "<unknown>",
with_server_id ? " +server-id" : "", with_server_id ? " +server-id" : "",
with_requested_ip ? " +requested-ip" : "", with_requested_ip ? " +requested-ip" : "",
timeout); timeout);
@ -649,7 +650,7 @@ static enum net_verdict dhcpv4_parse_options(struct net_if *iface,
net_if_ipv4_set_netmask(iface, &netmask); net_if_ipv4_set_netmask(iface, &netmask);
NET_DBG("options_subnet_mask %s", NET_DBG("options_subnet_mask %s",
net_sprint_ipv4_addr(&netmask)); log_strdup(net_sprint_ipv4_addr(&netmask)));
break; break;
} }
case DHCPV4_OPTIONS_ROUTER: { case DHCPV4_OPTIONS_ROUTER: {
@ -674,7 +675,7 @@ static enum net_verdict dhcpv4_parse_options(struct net_if *iface,
} }
NET_DBG("options_router: %s", NET_DBG("options_router: %s",
net_sprint_ipv4_addr(&router)); log_strdup(net_sprint_ipv4_addr(&router)));
net_if_ipv4_set_gw(iface, &router); net_if_ipv4_set_gw(iface, &router);
break; break;
} }
@ -777,8 +778,8 @@ static enum net_verdict dhcpv4_parse_options(struct net_if *iface,
frag = net_frag_read(frag, pos, &pos, length, frag = net_frag_read(frag, pos, &pos, length,
iface->config.dhcpv4.server_id.s4_addr); iface->config.dhcpv4.server_id.s4_addr);
NET_DBG("options_server_id: %s", NET_DBG("options_server_id: %s",
net_sprint_ipv4_addr( log_strdup(net_sprint_ipv4_addr(
&iface->config.dhcpv4.server_id)); &iface->config.dhcpv4.server_id)));
break; break;
case DHCPV4_OPTIONS_MSG_TYPE: { case DHCPV4_OPTIONS_MSG_TYPE: {
u8_t v; u8_t v;
@ -833,8 +834,8 @@ static void dhcpv4_handle_msg_ack(struct net_if *iface)
break; break;
case NET_DHCPV4_REQUESTING: case NET_DHCPV4_REQUESTING:
NET_INFO("Received: %s", NET_INFO("Received: %s",
net_sprint_ipv4_addr( log_strdup(net_sprint_ipv4_addr(
&iface->config.dhcpv4.requested_ip)); &iface->config.dhcpv4.requested_ip)));
if (!net_if_ipv4_addr_add(iface, if (!net_if_ipv4_addr_add(iface,
&iface->config.dhcpv4.requested_ip, &iface->config.dhcpv4.requested_ip,
@ -941,7 +942,8 @@ static enum net_verdict net_dhcpv4_input(struct net_conn *conn,
NET_DBG("Received dhcp msg [op=0x%x htype=0x%x hlen=%u xid=0x%x " NET_DBG("Received dhcp msg [op=0x%x htype=0x%x hlen=%u xid=0x%x "
"secs=%u flags=0x%x chaddr=%s", "secs=%u flags=0x%x chaddr=%s",
msg->op, msg->htype, msg->hlen, ntohl(msg->xid), msg->op, msg->htype, msg->hlen, ntohl(msg->xid),
msg->secs, msg->flags, net_sprint_ll_addr(msg->chaddr, 6)); msg->secs, msg->flags,
log_strdup(net_sprint_ll_addr(msg->chaddr, 6)));
NET_DBG(" ciaddr=%d.%d.%d.%d", NET_DBG(" ciaddr=%d.%d.%d.%d",
msg->ciaddr[0], msg->ciaddr[1], msg->ciaddr[2], msg->ciaddr[3]); msg->ciaddr[0], msg->ciaddr[1], msg->ciaddr[2], msg->ciaddr[3]);
NET_DBG(" yiaddr=%d.%d.%d.%d", NET_DBG(" yiaddr=%d.%d.%d.%d",

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

@ -105,8 +105,8 @@ static inline enum net_verdict icmpv4_handle_echo_request(struct net_pkt *pkt)
int ret; int ret;
NET_DBG("Received Echo Request from %s to %s", NET_DBG("Received Echo Request from %s to %s",
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src), log_strdup(net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src)),
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->dst)); log_strdup(net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->dst)));
net_ipaddr_copy(&addr, &NET_IPV4_HDR(pkt)->src); net_ipaddr_copy(&addr, &NET_IPV4_HDR(pkt)->src);
net_ipaddr_copy(&NET_IPV4_HDR(pkt)->src, net_ipaddr_copy(&NET_IPV4_HDR(pkt)->src,
@ -127,8 +127,8 @@ static inline enum net_verdict icmpv4_handle_echo_request(struct net_pkt *pkt)
} }
NET_DBG("Sending Echo Reply from %s to %s", NET_DBG("Sending Echo Reply from %s to %s",
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src), log_strdup(net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src)),
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->dst)); log_strdup(net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->dst)));
if (net_send_data(pkt) < 0) { if (net_send_data(pkt) < 0) {
net_stats_update_icmp_drop(net_pkt_iface(pkt)); net_stats_update_icmp_drop(net_pkt_iface(pkt));
@ -204,8 +204,8 @@ int net_icmpv4_send_echo_request(struct net_if *iface,
NET_DBG("Sending ICMPv4 Echo Request type %d from %s to %s", NET_DBG("Sending ICMPv4 Echo Request type %d from %s to %s",
NET_ICMPV4_ECHO_REQUEST, NET_ICMPV4_ECHO_REQUEST,
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src), log_strdup(net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src)),
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->dst)); log_strdup(net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->dst)));
if (net_send_data(pkt) >= 0) { if (net_send_data(pkt) >= 0) {
net_stats_update_icmp_sent(iface); net_stats_update_icmp_sent(iface);
@ -303,8 +303,8 @@ int net_icmpv4_send_error(struct net_pkt *orig, u8_t type, u8_t code)
NET_DBG("Sending ICMPv4 Error Message type %d code %d from %s to %s", NET_DBG("Sending ICMPv4 Error Message type %d code %d from %s to %s",
type, code, type, code,
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src), log_strdup(net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src)),
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->dst)); log_strdup(net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->dst)));
if (net_send_data(pkt) >= 0) { if (net_send_data(pkt) >= 0) {
net_stats_update_icmp_sent(iface); net_stats_update_icmp_sent(iface);

16
subsys/net/ip/icmpv6.c
View file

@ -299,8 +299,8 @@ static enum net_verdict handle_echo_request(struct net_pkt *orig)
int ret; int ret;
NET_DBG("Received Echo Request from %s to %s", NET_DBG("Received Echo Request from %s to %s",
net_sprint_ipv6_addr(&NET_IPV6_HDR(orig)->src), log_strdup(net_sprint_ipv6_addr(&NET_IPV6_HDR(orig)->src)),
net_sprint_ipv6_addr(&NET_IPV6_HDR(orig)->dst)); log_strdup(net_sprint_ipv6_addr(&NET_IPV6_HDR(orig)->dst)));
iface = net_pkt_iface(orig); iface = net_pkt_iface(orig);
@ -382,8 +382,8 @@ static enum net_verdict handle_echo_request(struct net_pkt *orig)
net_icmpv6_set_chksum(pkt); net_icmpv6_set_chksum(pkt);
NET_DBG("Sending Echo Reply from %s to %s", NET_DBG("Sending Echo Reply from %s to %s",
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src), log_strdup(net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src)),
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->dst)); log_strdup(net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->dst)));
if (net_send_data(pkt) < 0) { if (net_send_data(pkt) < 0) {
goto drop; goto drop;
@ -509,8 +509,8 @@ int net_icmpv6_send_error(struct net_pkt *orig, u8_t type, u8_t code,
NET_DBG("Sending ICMPv6 Error Message type %d code %d param %d" NET_DBG("Sending ICMPv6 Error Message type %d code %d param %d"
" from %s to %s", type, code, param, " from %s to %s", type, code, param,
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src), log_strdup(net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src)),
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->dst)); log_strdup(net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->dst)));
if (net_send_data(pkt) >= 0) { if (net_send_data(pkt) >= 0) {
net_stats_update_icmp_sent(iface); net_stats_update_icmp_sent(iface);
@ -576,8 +576,8 @@ int net_icmpv6_send_echo_request(struct net_if *iface,
NET_DBG("Sending ICMPv6 Echo Request type %d from %s to %s", NET_DBG("Sending ICMPv6 Echo Request type %d from %s to %s",
NET_ICMPV6_ECHO_REQUEST, NET_ICMPV6_ECHO_REQUEST,
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src), log_strdup(net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src)),
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->dst)); log_strdup(net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->dst)));
if (net_send_data(pkt) >= 0) { if (net_send_data(pkt) >= 0) {
net_stats_update_icmp_sent(iface); net_stats_update_icmp_sent(iface);

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

@ -123,8 +123,8 @@ enum net_verdict net_ipv4_process_pkt(struct net_pkt *pkt)
} }
NET_DBG("IPv4 packet received from %s to %s", NET_DBG("IPv4 packet received from %s to %s",
net_sprint_ipv4_addr(&hdr->src), log_strdup(net_sprint_ipv4_addr(&hdr->src)),
net_sprint_ipv4_addr(&hdr->dst)); log_strdup(net_sprint_ipv4_addr(&hdr->dst)));
net_pkt_set_ip_hdr_len(pkt, sizeof(struct net_ipv4_hdr)); net_pkt_set_ip_hdr_len(pkt, sizeof(struct net_ipv4_hdr));
net_pkt_set_ipv4_ttl(pkt, NET_IPV4_HDR(pkt)->ttl); net_pkt_set_ipv4_ttl(pkt, NET_IPV4_HDR(pkt)->ttl);

6
subsys/net/ip/ipv4_autoconf.c
View file

@ -139,9 +139,9 @@ enum net_verdict net_ipv4_autoconf_input(struct net_if *iface,
} }
NET_DBG("Conflict detected from %s for %s, state %d", NET_DBG("Conflict detected from %s for %s, state %d",
net_sprint_ll_addr((u8_t *)&arp_hdr->src_hwaddr, log_strdup(net_sprint_ll_addr((u8_t *)&arp_hdr->src_hwaddr,
arp_hdr->hwlen), arp_hdr->hwlen)),
net_sprint_ipv4_addr(&arp_hdr->dst_ipaddr), log_strdup(net_sprint_ipv4_addr(&arp_hdr->dst_ipaddr)),
cfg->ipv4auto.state); cfg->ipv4auto.state);
cfg->ipv4auto.conflict_cnt++; cfg->ipv4auto.conflict_cnt++;

13
subsys/net/ip/ipv6.c
View file

@ -336,7 +336,7 @@ static struct net_route_entry *add_route(struct net_if *iface,
route = net_route_add(iface, addr, prefix_len, addr); route = net_route_add(iface, addr, prefix_len, addr);
NET_DBG("%s route to %s/%d iface %p", route ? "Add" : "Cannot add", NET_DBG("%s route to %s/%d iface %p", route ? "Add" : "Cannot add",
net_sprint_ipv6_addr(addr), prefix_len, iface); log_strdup(net_sprint_ipv6_addr(addr)), prefix_len, iface);
return route; return route;
} }
@ -347,7 +347,8 @@ static void no_route_info(struct net_pkt *pkt,
struct in6_addr *dst) struct in6_addr *dst)
{ {
NET_DBG("Will not route pkt %p ll src %s to dst %s between interfaces", NET_DBG("Will not route pkt %p ll src %s to dst %s between interfaces",
pkt, net_sprint_ipv6_addr(src), net_sprint_ipv6_addr(dst)); pkt, log_strdup(net_sprint_ipv6_addr(src)),
log_strdup(net_sprint_ipv6_addr(dst)));
} }
#if defined(CONFIG_NET_ROUTE) #if defined(CONFIG_NET_ROUTE)
@ -405,14 +406,14 @@ static enum net_verdict route_ipv6_packet(struct net_pkt *pkt,
if (ret < 0) { if (ret < 0) {
NET_DBG("Cannot re-route pkt %p via %s " NET_DBG("Cannot re-route pkt %p via %s "
"at iface %p (%d)", "at iface %p (%d)",
pkt, net_sprint_ipv6_addr(nexthop), pkt, log_strdup(net_sprint_ipv6_addr(nexthop)),
net_pkt_iface(pkt), ret); net_pkt_iface(pkt), ret);
} else { } else {
return NET_OK; return NET_OK;
} }
} else { } else {
NET_DBG("No route to %s pkt %p dropped", NET_DBG("No route to %s pkt %p dropped",
net_sprint_ipv6_addr(&hdr->dst), pkt); log_strdup(net_sprint_ipv6_addr(&hdr->dst)), pkt);
} }
drop: drop:
@ -441,8 +442,8 @@ enum net_verdict net_ipv6_process_pkt(struct net_pkt *pkt)
} }
NET_DBG("IPv6 packet len %d received from %s to %s", real_len, NET_DBG("IPv6 packet len %d received from %s to %s", real_len,
net_sprint_ipv6_addr(&hdr->src), log_strdup(net_sprint_ipv6_addr(&hdr->src)),
net_sprint_ipv6_addr(&hdr->dst)); log_strdup(net_sprint_ipv6_addr(&hdr->dst)));
if (net_is_ipv6_addr_mcast(&hdr->src)) { if (net_is_ipv6_addr_mcast(&hdr->src)) {
NET_DBG("Dropping src multicast packet"); NET_DBG("Dropping src multicast packet");

4
subsys/net/ip/ipv6_fragment.c
View file

@ -269,8 +269,8 @@ static void reassembly_info(char *str, struct net_ipv6_reassembly *reass)
} }
NET_DBG("%s id 0x%x src %s dst %s remain %d ms len %d", str, reass->id, NET_DBG("%s id 0x%x src %s dst %s remain %d ms len %d", str, reass->id,
net_sprint_ipv6_addr(&reass->src), log_strdup(net_sprint_ipv6_addr(&reass->src)),
net_sprint_ipv6_addr(&reass->dst), log_strdup(net_sprint_ipv6_addr(&reass->dst)),
k_delayed_work_remaining_get(&reass->timer), len); k_delayed_work_remaining_get(&reass->timer), len);
} }

6
subsys/net/ip/ipv6_mld.c
View file

@ -296,8 +296,8 @@ drop:
#define dbg_addr(action, pkt_str, src, dst) \ #define dbg_addr(action, pkt_str, src, dst) \
do { \ do { \
NET_DBG("%s %s from %s to %s", action, pkt_str, \ NET_DBG("%s %s from %s to %s", action, pkt_str, \
net_sprint_ipv6_addr(src), \ log_strdup(net_sprint_ipv6_addr(src)), \
net_sprint_ipv6_addr(dst)); \ log_strdup(net_sprint_ipv6_addr(dst))); \
} while (0) } while (0)
#define dbg_addr_recv(pkt_str, src, dst) \ #define dbg_addr_recv(pkt_str, src, dst) \
@ -354,7 +354,7 @@ static enum net_verdict handle_mld_query(struct net_pkt *pkt)
/* Currently we only support a unspecified address query. */ /* Currently we only support a unspecified address query. */
if (!net_ipv6_addr_cmp(&mcast, net_ipv6_unspecified_address())) { if (!net_ipv6_addr_cmp(&mcast, net_ipv6_unspecified_address())) {
NET_DBG("Only supporting unspecified address query (%s)", NET_DBG("Only supporting unspecified address query (%s)",
net_sprint_ipv6_addr(&mcast)); log_strdup(net_sprint_ipv6_addr(&mcast)));
goto drop; goto drop;
} }

145
subsys/net/ip/ipv6_nbr.c
View file

@ -236,10 +236,11 @@ void nbr_print(void)
net_ipv6_nbr_data(nbr)->pending, net_ipv6_nbr_data(nbr)->pending,
nbr->iface, nbr->idx, nbr->iface, nbr->idx,
nbr->idx == NET_NBR_LLADDR_UNKNOWN ? "?" : nbr->idx == NET_NBR_LLADDR_UNKNOWN ? "?" :
net_sprint_ll_addr( log_strdup(net_sprint_ll_addr(
net_nbr_get_lladdr(nbr->idx)->addr, net_nbr_get_lladdr(nbr->idx)->addr,
net_nbr_get_lladdr(nbr->idx)->len), net_nbr_get_lladdr(nbr->idx)->len)),
net_sprint_ipv6_addr(&net_ipv6_nbr_data(nbr)->addr)); log_strdup(net_sprint_ipv6_addr(
&net_ipv6_nbr_data(nbr)->addr)));
} }
} }
#else #else
@ -376,8 +377,8 @@ static void ipv6_ns_reply_timeout(struct k_work *work)
NET_DBG("NS nbr %p pending %p timeout to %s", nbr, NET_DBG("NS nbr %p pending %p timeout to %s", nbr,
data->pending, data->pending,
net_sprint_ipv6_addr( log_strdup(net_sprint_ipv6_addr(
&NET_IPV6_HDR(data->pending)->dst)); &NET_IPV6_HDR(data->pending)->dst)));
/* To unref when pending variable was set */ /* To unref when pending variable was set */
net_pkt_unref(data->pending); net_pkt_unref(data->pending);
@ -423,7 +424,8 @@ static struct net_nbr *nbr_new(struct net_if *iface,
nbr_init(nbr, iface, addr, true, state); nbr_init(nbr, iface, addr, true, state);
NET_DBG("nbr %p iface %p state %d IPv6 %s", NET_DBG("nbr %p iface %p state %d IPv6 %s",
nbr, iface, state, net_sprint_ipv6_addr(addr)); nbr, iface, state,
log_strdup(net_sprint_ipv6_addr(addr)));
return nbr; return nbr;
} }
@ -438,9 +440,10 @@ static void dbg_update_neighbor_lladdr(struct net_linkaddr *new_lladdr,
net_sprint_ll_addr(old_lladdr->addr, old_lladdr->len)); net_sprint_ll_addr(old_lladdr->addr, old_lladdr->len));
NET_DBG("Updating neighbor %s lladdr %s (was %s)", NET_DBG("Updating neighbor %s lladdr %s (was %s)",
net_sprint_ipv6_addr(addr), log_strdup(net_sprint_ipv6_addr(addr)),
net_sprint_ll_addr(new_lladdr->addr, new_lladdr->len), log_strdup(net_sprint_ll_addr(new_lladdr->addr,
out); new_lladdr->len)),
log_strdup(out));
} }
static void dbg_update_neighbor_lladdr_raw(u8_t *new_lladdr, static void dbg_update_neighbor_lladdr_raw(u8_t *new_lladdr,
@ -458,8 +461,8 @@ static void dbg_update_neighbor_lladdr_raw(u8_t *new_lladdr,
#define dbg_addr(action, pkt_str, src, dst) \ #define dbg_addr(action, pkt_str, src, dst) \
do { \ do { \
NET_DBG("%s %s from %s to %s", action, pkt_str, \ NET_DBG("%s %s from %s to %s", action, pkt_str, \
net_sprint_ipv6_addr(src), \ log_strdup(net_sprint_ipv6_addr(src)), \
net_sprint_ipv6_addr(dst)); \ log_strdup(net_sprint_ipv6_addr(dst))); \
} while (0) } while (0)
#define dbg_addr_recv(pkt_str, src, dst) \ #define dbg_addr_recv(pkt_str, src, dst) \
@ -472,9 +475,9 @@ static void dbg_update_neighbor_lladdr_raw(u8_t *new_lladdr,
do { \ do { \
NET_DBG("%s %s from %s to %s, target %s", action, \ NET_DBG("%s %s from %s to %s, target %s", action, \
pkt_str, \ pkt_str, \
net_sprint_ipv6_addr(src), \ log_strdup(net_sprint_ipv6_addr(src)), \
net_sprint_ipv6_addr(dst), \ log_strdup(net_sprint_ipv6_addr(dst)), \
net_sprint_ipv6_addr(target)); \ log_strdup(net_sprint_ipv6_addr(target))); \
} while (0) } while (0)
#define dbg_addr_recv_tgt(pkt_str, src, dst, tgt) \ #define dbg_addr_recv_tgt(pkt_str, src, dst, tgt) \
@ -500,8 +503,9 @@ struct net_nbr *net_ipv6_nbr_add(struct net_if *iface,
nbr = nbr_new(iface, addr, is_router, state); nbr = nbr_new(iface, addr, is_router, state);
if (!nbr) { if (!nbr) {
NET_ERR("Could not add router neighbor %s [%s]", NET_ERR("Could not add router neighbor %s [%s]",
net_sprint_ipv6_addr(addr), log_strdup(net_sprint_ipv6_addr(addr)),
net_sprint_ll_addr(lladdr->addr, lladdr->len)); log_strdup(net_sprint_ll_addr(lladdr->addr,
lladdr->len)));
return NULL; return NULL;
} }
} }
@ -538,8 +542,8 @@ struct net_nbr *net_ipv6_nbr_add(struct net_if *iface,
NET_DBG("[%d] nbr %p state %d router %d IPv6 %s ll %s iface %p", NET_DBG("[%d] nbr %p state %d router %d IPv6 %s ll %s iface %p",
nbr->idx, nbr, state, is_router, nbr->idx, nbr, state, is_router,
net_sprint_ipv6_addr(addr), log_strdup(net_sprint_ipv6_addr(addr)),
net_sprint_ll_addr(lladdr->addr, lladdr->len), log_strdup(net_sprint_ll_addr(lladdr->addr, lladdr->len)),
nbr->iface); nbr->iface);
#if defined(CONFIG_NET_MGMT_EVENT_INFO) #if defined(CONFIG_NET_MGMT_EVENT_INFO)
@ -672,15 +676,19 @@ static struct net_pkt *update_ll_reserve(struct net_pkt *pkt,
*/ */
if (0) { if (0) {
NET_DBG("ll src %s", NET_DBG("ll src %s",
net_sprint_ll_addr(net_pkt_lladdr_src(pkt)->addr, log_strdup(net_sprint_ll_addr(
net_pkt_lladdr_src(pkt)->len)); net_pkt_lladdr_src(pkt)->addr,
net_pkt_lladdr_src(pkt)->len)));
NET_DBG("ll dst %s", NET_DBG("ll dst %s",
net_sprint_ll_addr(net_pkt_lladdr_dst(pkt)->addr, log_strdup(net_sprint_ll_addr(
net_pkt_lladdr_dst(pkt)->len)); net_pkt_lladdr_dst(pkt)->addr,
net_pkt_lladdr_dst(pkt)->len)));
NET_DBG("ip src %s", NET_DBG("ip src %s",
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src)); log_strdup(net_sprint_ipv6_addr(
&NET_IPV6_HDR(pkt)->src)));
NET_DBG("ip dst %s", NET_DBG("ip dst %s",
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->dst)); log_strdup(net_sprint_ipv6_addr(
&NET_IPV6_HDR(pkt)->dst)));
} }
net_pkt_set_ll_reserve(pkt, reserve); net_pkt_set_ll_reserve(pkt, reserve);
@ -755,7 +763,8 @@ static struct in6_addr *check_route(struct net_if *iface,
nexthop = net_route_get_nexthop(route); nexthop = net_route_get_nexthop(route);
NET_DBG("Route %p nexthop %s", route, NET_DBG("Route %p nexthop %s", route,
nexthop ? net_sprint_ipv6_addr(nexthop) : "<unknown>"); nexthop ? log_strdup(net_sprint_ipv6_addr(nexthop)) :
"<unknown>");
if (!nexthop) { if (!nexthop) {
net_route_del(route); net_route_del(route);
@ -763,7 +772,7 @@ static struct in6_addr *check_route(struct net_if *iface,
net_rpl_global_repair(route); net_rpl_global_repair(route);
NET_DBG("No route to host %s", NET_DBG("No route to host %s",
net_sprint_ipv6_addr(dst)); log_strdup(net_sprint_ipv6_addr(dst)));
return NULL; return NULL;
} }
@ -774,7 +783,7 @@ static struct in6_addr *check_route(struct net_if *iface,
router = net_if_ipv6_router_find_default(NULL, dst); router = net_if_ipv6_router_find_default(NULL, dst);
if (!router) { if (!router) {
NET_DBG("No default route to %s", NET_DBG("No default route to %s",
net_sprint_ipv6_addr(dst)); log_strdup(net_sprint_ipv6_addr(dst)));
/* Try to send the packet anyway */ /* Try to send the packet anyway */
nexthop = dst; nexthop = dst;
@ -788,7 +797,7 @@ static struct in6_addr *check_route(struct net_if *iface,
nexthop = &router->address.in6_addr; nexthop = &router->address.in6_addr;
NET_DBG("Router %p nexthop %s", router, NET_DBG("Router %p nexthop %s", router,
net_sprint_ipv6_addr(nexthop)); log_strdup(net_sprint_ipv6_addr(nexthop)));
} }
return nexthop; return nexthop;
@ -930,7 +939,7 @@ try_send:
NET_DBG("Neighbor lookup %p (%d) iface %p addr %s state %s", nbr, NET_DBG("Neighbor lookup %p (%d) iface %p addr %s state %s", nbr,
nbr ? nbr->idx : NET_NBR_LLADDR_UNKNOWN, iface, nbr ? nbr->idx : NET_NBR_LLADDR_UNKNOWN, iface,
net_sprint_ipv6_addr(nexthop), log_strdup(net_sprint_ipv6_addr(nexthop)),
nbr ? net_ipv6_nbr_state2str(net_ipv6_nbr_data(nbr)->state) : nbr ? net_ipv6_nbr_state2str(net_ipv6_nbr_data(nbr)->state) :
"-"); "-");
@ -943,7 +952,8 @@ try_send:
net_pkt_lladdr_dst(pkt)->len = lladdr->len; net_pkt_lladdr_dst(pkt)->len = lladdr->len;
NET_DBG("Neighbor %p addr %s", nbr, NET_DBG("Neighbor %p addr %s", nbr,
net_sprint_ll_addr(lladdr->addr, lladdr->len)); log_strdup(net_sprint_ll_addr(lladdr->addr,
lladdr->len)));
/* Start the NUD if we are in STALE state. /* Start the NUD if we are in STALE state.
* See RFC 4861 ch 7.3.3 for details. * See RFC 4861 ch 7.3.3 for details.
@ -1201,11 +1211,13 @@ static void ns_routing_info(struct net_pkt *pkt,
net_sprint_ipv6_addr(nexthop)); net_sprint_ipv6_addr(nexthop));
if (net_ipv6_addr_cmp(nexthop, tgt)) { if (net_ipv6_addr_cmp(nexthop, tgt)) {
NET_DBG("Routing to %s iface %p", out, NET_DBG("Routing to %s iface %p",
log_strdup(out),
net_pkt_iface(pkt)); net_pkt_iface(pkt));
} else { } else {
NET_DBG("Routing to %s via %s iface %p", NET_DBG("Routing to %s via %s iface %p",
net_sprint_ipv6_addr(tgt), out, log_strdup(net_sprint_ipv6_addr(tgt)),
log_strdup(out),
net_pkt_iface(pkt)); net_pkt_iface(pkt));
} }
} }
@ -1345,8 +1357,9 @@ static enum net_verdict handle_ns_input(struct net_pkt *pkt)
if (!src) { if (!src) {
NET_DBG("No interface address for " NET_DBG("No interface address for "
"dst %s iface %p", "dst %s iface %p",
net_sprint_ipv6_addr( log_strdup(
&NET_IPV6_HDR(pkt)->src), net_sprint_ipv6_addr(
&NET_IPV6_HDR(pkt)->src)),
net_pkt_iface(pkt)); net_pkt_iface(pkt));
goto drop; goto drop;
} }
@ -1357,7 +1370,7 @@ static enum net_verdict handle_ns_input(struct net_pkt *pkt)
} }
NET_DBG("No such interface address %s", NET_DBG("No such interface address %s",
net_sprint_ipv6_addr(&ns_hdr.tgt)); log_strdup(net_sprint_ipv6_addr(&ns_hdr.tgt)));
goto drop; goto drop;
} else { } else {
tgt = &ifaddr->address.in6_addr; tgt = &ifaddr->address.in6_addr;
@ -1382,13 +1395,15 @@ nexthop_found:
if (!net_is_ipv6_addr_solicited_node(&NET_IPV6_HDR(pkt)->dst)) { if (!net_is_ipv6_addr_solicited_node(&NET_IPV6_HDR(pkt)->dst)) {
NET_DBG("Not solicited node addr %s", NET_DBG("Not solicited node addr %s",
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->dst)); log_strdup(net_sprint_ipv6_addr(
&NET_IPV6_HDR(pkt)->dst)));
goto drop; goto drop;
} }
if (ifaddr->addr_state == NET_ADDR_TENTATIVE) { if (ifaddr->addr_state == NET_ADDR_TENTATIVE) {
NET_DBG("DAD failed for %s iface %p", NET_DBG("DAD failed for %s iface %p",
net_sprint_ipv6_addr(&ifaddr->address.in6_addr), log_strdup(net_sprint_ipv6_addr(
&ifaddr->address.in6_addr)),
net_pkt_iface(pkt)); net_pkt_iface(pkt));
dad_failed(net_pkt_iface(pkt), dad_failed(net_pkt_iface(pkt),
@ -1408,7 +1423,8 @@ nexthop_found:
if (net_is_my_ipv6_addr(&NET_IPV6_HDR(pkt)->src)) { if (net_is_my_ipv6_addr(&NET_IPV6_HDR(pkt)->src)) {
NET_DBG("Duplicate IPv6 %s address", NET_DBG("Duplicate IPv6 %s address",
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src)); log_strdup(net_sprint_ipv6_addr(
&NET_IPV6_HDR(pkt)->src)));
goto drop; goto drop;
} }
@ -1548,13 +1564,15 @@ static void ipv6_nd_reachable_timeout(struct k_work *work)
data->state = NET_IPV6_NBR_STATE_STALE; data->state = NET_IPV6_NBR_STATE_STALE;
NET_DBG("nbr %p moving %s state to STALE (%d)", NET_DBG("nbr %p moving %s state to STALE (%d)",
nbr, net_sprint_ipv6_addr(&data->addr), nbr,
log_strdup(net_sprint_ipv6_addr(&data->addr)),
data->state); data->state);
break; break;
case NET_IPV6_NBR_STATE_STALE: case NET_IPV6_NBR_STATE_STALE:
NET_DBG("nbr %p removing stale address %s", NET_DBG("nbr %p removing stale address %s",
nbr, net_sprint_ipv6_addr(&data->addr)); nbr,
log_strdup(net_sprint_ipv6_addr(&data->addr)));
nbr_free(nbr); nbr_free(nbr);
break; break;
@ -1563,7 +1581,8 @@ static void ipv6_nd_reachable_timeout(struct k_work *work)
data->ns_count = 0; data->ns_count = 0;
NET_DBG("nbr %p moving %s state to PROBE (%d)", NET_DBG("nbr %p moving %s state to PROBE (%d)",
nbr, net_sprint_ipv6_addr(&data->addr), nbr,
log_strdup(net_sprint_ipv6_addr(&data->addr)),
data->state); data->state);
/* Intentionally continuing to probe state */ /* Intentionally continuing to probe state */
@ -1577,8 +1596,9 @@ static void ipv6_nd_reachable_timeout(struct k_work *work)
if (router && !router->is_infinite) { if (router && !router->is_infinite) {
NET_DBG("nbr %p address %s PROBE ended (%d)", NET_DBG("nbr %p address %s PROBE ended (%d)",
nbr, nbr,
net_sprint_ipv6_addr( log_strdup(
&data->addr), net_sprint_ipv6_addr(
&data->addr)),
data->state); data->state);
net_if_ipv6_router_rm(router); net_if_ipv6_router_rm(router);
@ -1653,7 +1673,7 @@ static inline bool handle_na_neighbor(struct net_pkt *pkt,
NET_DBG("Neighbor lookup %p iface %p addr %s", nbr, NET_DBG("Neighbor lookup %p iface %p addr %s", nbr,
net_pkt_iface(pkt), net_pkt_iface(pkt),
net_sprint_ipv6_addr(&na_hdr->tgt)); log_strdup(net_sprint_ipv6_addr(&na_hdr->tgt)));
if (!nbr) { if (!nbr) {
nbr_print(); nbr_print();
@ -1690,8 +1710,9 @@ static inline bool handle_na_neighbor(struct net_pkt *pkt,
NET_DBG("[%d] nbr %p state %d IPv6 %s ll %s", NET_DBG("[%d] nbr %p state %d IPv6 %s ll %s",
nbr->idx, nbr, net_ipv6_nbr_data(nbr)->state, nbr->idx, nbr, net_ipv6_nbr_data(nbr)->state,
net_sprint_ipv6_addr(&na_hdr->tgt), log_strdup(net_sprint_ipv6_addr(&na_hdr->tgt)),
net_sprint_ll_addr(nbr_lladdr.addr, nbr_lladdr.len)); log_strdup(net_sprint_ll_addr(nbr_lladdr.addr,
nbr_lladdr.len)));
} }
cached_lladdr = net_nbr_get_lladdr(nbr->idx); cached_lladdr = net_nbr_get_lladdr(nbr->idx);
@ -1795,9 +1816,10 @@ send_pending:
if (pending) { if (pending) {
NET_DBG("Sending pending %p to %s lladdr %s", pending, NET_DBG("Sending pending %p to %s lladdr %s", pending,
net_sprint_ipv6_addr(&NET_IPV6_HDR(pending)->dst), log_strdup(net_sprint_ipv6_addr(
net_sprint_ll_addr(cached_lladdr->addr, &NET_IPV6_HDR(pending)->dst)),
cached_lladdr->len)); log_strdup(net_sprint_ll_addr(cached_lladdr->addr,
cached_lladdr->len)));
if (net_send_data(pending) < 0) { if (net_send_data(pending) < 0) {
nbr_clear_ns_pending(net_ipv6_nbr_data(nbr)); nbr_clear_ns_pending(net_ipv6_nbr_data(nbr));
@ -1895,7 +1917,7 @@ static enum net_verdict handle_na_input(struct net_pkt *pkt)
if (ifaddr) { if (ifaddr) {
NET_DBG("Interface %p already has address %s", NET_DBG("Interface %p already has address %s",
net_pkt_iface(pkt), net_pkt_iface(pkt),
net_sprint_ipv6_addr(&na_hdr.tgt)); log_strdup(net_sprint_ipv6_addr(&na_hdr.tgt)));
#if defined(CONFIG_NET_IPV6_DAD) #if defined(CONFIG_NET_IPV6_DAD)
if (ifaddr->addr_state == NET_ADDR_TENTATIVE) { if (ifaddr->addr_state == NET_ADDR_TENTATIVE) {
@ -2026,7 +2048,7 @@ int net_ipv6_send_ns(struct net_if *iface,
NET_IPV6_NBR_STATE_INCOMPLETE); NET_IPV6_NBR_STATE_INCOMPLETE);
if (!nbr) { if (!nbr) {
NET_DBG("Could not create new neighbor %s", NET_DBG("Could not create new neighbor %s",
net_sprint_ipv6_addr(&ns_hdr.tgt)); log_strdup(net_sprint_ipv6_addr(&ns_hdr.tgt)));
if (pending) { if (pending) {
net_pkt_unref(pending); net_pkt_unref(pending);
} }
@ -2229,12 +2251,14 @@ static inline void handle_prefix_onlink(struct net_pkt *pkt,
if (prefix) { if (prefix) {
NET_DBG("Interface %p add prefix %s/%d lifetime %u", NET_DBG("Interface %p add prefix %s/%d lifetime %u",
net_pkt_iface(pkt), net_pkt_iface(pkt),
net_sprint_ipv6_addr(&prefix_info->prefix), log_strdup(net_sprint_ipv6_addr(
&prefix_info->prefix)),
prefix_info->prefix_len, prefix_info->prefix_len,
prefix_info->valid_lifetime); prefix_info->valid_lifetime);
} else { } else {
NET_ERR("Prefix %s/%d could not be added to iface %p", NET_ERR("Prefix %s/%d could not be added to iface %p",
net_sprint_ipv6_addr(&prefix_info->prefix), log_strdup(net_sprint_ipv6_addr(
&prefix_info->prefix)),
prefix_info->prefix_len, prefix_info->prefix_len,
net_pkt_iface(pkt)); net_pkt_iface(pkt));
@ -2246,7 +2270,7 @@ static inline void handle_prefix_onlink(struct net_pkt *pkt,
case 0: case 0:
NET_DBG("Interface %p delete prefix %s/%d", NET_DBG("Interface %p delete prefix %s/%d",
net_pkt_iface(pkt), net_pkt_iface(pkt),
net_sprint_ipv6_addr(&prefix_info->prefix), log_strdup(net_sprint_ipv6_addr(&prefix_info->prefix)),
prefix_info->prefix_len); prefix_info->prefix_len);
net_if_ipv6_prefix_rm(net_pkt_iface(pkt), net_if_ipv6_prefix_rm(net_pkt_iface(pkt),
@ -2257,7 +2281,7 @@ static inline void handle_prefix_onlink(struct net_pkt *pkt,
case NET_IPV6_ND_INFINITE_LIFETIME: case NET_IPV6_ND_INFINITE_LIFETIME:
NET_DBG("Interface %p prefix %s/%d infinite", NET_DBG("Interface %p prefix %s/%d infinite",
net_pkt_iface(pkt), net_pkt_iface(pkt),
net_sprint_ipv6_addr(&prefix->prefix), log_strdup(net_sprint_ipv6_addr(&prefix->prefix)),
prefix->len); prefix->len);
net_if_ipv6_prefix_set_lf(prefix, true); net_if_ipv6_prefix_set_lf(prefix, true);
@ -2266,7 +2290,7 @@ static inline void handle_prefix_onlink(struct net_pkt *pkt,
default: default:
NET_DBG("Interface %p update prefix %s/%u lifetime %u", NET_DBG("Interface %p update prefix %s/%u lifetime %u",
net_pkt_iface(pkt), net_pkt_iface(pkt),
net_sprint_ipv6_addr(&prefix_info->prefix), log_strdup(net_sprint_ipv6_addr(&prefix_info->prefix)),
prefix_info->prefix_len, prefix_info->prefix_len,
prefix_info->valid_lifetime); prefix_info->valid_lifetime);
@ -2329,7 +2353,7 @@ static inline void handle_prefix_autonomous(struct net_pkt *pkt,
remaining_lifetime(ifaddr))) { remaining_lifetime(ifaddr))) {
NET_DBG("Timer updating for address %s " NET_DBG("Timer updating for address %s "
"long lifetime %u secs", "long lifetime %u secs",
net_sprint_ipv6_addr(&addr), log_strdup(net_sprint_ipv6_addr(&addr)),
prefix_info->valid_lifetime); prefix_info->valid_lifetime);
net_if_ipv6_addr_update_lifetime(ifaddr, net_if_ipv6_addr_update_lifetime(ifaddr,
@ -2337,7 +2361,8 @@ static inline void handle_prefix_autonomous(struct net_pkt *pkt,
} else { } else {
NET_DBG("Timer updating for address %s " NET_DBG("Timer updating for address %s "
"lifetime %u secs", "lifetime %u secs",
net_sprint_ipv6_addr(&addr), TWO_HOURS); log_strdup(net_sprint_ipv6_addr(&addr)),
TWO_HOURS);
net_if_ipv6_addr_update_lifetime(ifaddr, TWO_HOURS); net_if_ipv6_addr_update_lifetime(ifaddr, TWO_HOURS);
} }
@ -2653,8 +2678,8 @@ static enum net_verdict handle_ra_input(struct net_pkt *pkt)
if (nbr && net_ipv6_nbr_data(nbr)->pending) { if (nbr && net_ipv6_nbr_data(nbr)->pending) {
NET_DBG("Sending pending pkt %p to %s", NET_DBG("Sending pending pkt %p to %s",
net_ipv6_nbr_data(nbr)->pending, net_ipv6_nbr_data(nbr)->pending,
net_sprint_ipv6_addr(&NET_IPV6_HDR( log_strdup(net_sprint_ipv6_addr(&NET_IPV6_HDR(
net_ipv6_nbr_data(nbr)->pending)->dst)); net_ipv6_nbr_data(nbr)->pending)->dst)));
if (net_send_data(net_ipv6_nbr_data(nbr)->pending) < 0) { if (net_send_data(net_ipv6_nbr_data(nbr)->pending) < 0) {
net_pkt_unref(net_ipv6_nbr_data(nbr)->pending); net_pkt_unref(net_ipv6_nbr_data(nbr)->pending);

6
subsys/net/ip/nbr.c
View file

@ -222,9 +222,9 @@ void net_nbr_print(struct net_nbr_table *table)
nbr->idx, nbr->idx,
nbr->idx == NET_NBR_LLADDR_UNKNOWN ? nbr->idx == NET_NBR_LLADDR_UNKNOWN ?
"<unknown>" : "<unknown>" :
net_sprint_ll_addr( log_strdup(net_sprint_ll_addr(
net_neighbor_lladdr[nbr->idx].lladdr.addr, net_neighbor_lladdr[nbr->idx].lladdr.addr,
net_neighbor_lladdr[nbr->idx].lladdr.len)); net_neighbor_lladdr[nbr->idx].lladdr.len)));
} }
} }
} }

12
subsys/net/ip/net_context.c
View file

@ -448,7 +448,8 @@ int net_context_bind(struct net_context *context, const struct sockaddr *addr,
if (!iface) { if (!iface) {
NET_ERR("Cannot bind to %s", NET_ERR("Cannot bind to %s",
net_sprint_ipv6_addr(&addr6->sin6_addr)); log_strdup(net_sprint_ipv6_addr(
&addr6->sin6_addr)));
return -EADDRNOTAVAIL; return -EADDRNOTAVAIL;
} }
@ -487,8 +488,8 @@ int net_context_bind(struct net_context *context, const struct sockaddr *addr,
NET_DBG("Context %p binding to %s [%s]:%d iface %p", NET_DBG("Context %p binding to %s [%s]:%d iface %p",
context, context,
net_proto2str(net_context_get_ip_proto(context)), net_proto2str(net_context_get_ip_proto(context)),
net_sprint_ipv6_addr(ptr), ntohs(addr6->sin6_port), log_strdup(net_sprint_ipv6_addr(ptr)),
iface); ntohs(addr6->sin6_port), iface);
return 0; return 0;
} }
@ -534,7 +535,8 @@ int net_context_bind(struct net_context *context, const struct sockaddr *addr,
if (!iface) { if (!iface) {
NET_ERR("Cannot bind to %s", NET_ERR("Cannot bind to %s",
net_sprint_ipv4_addr(&addr4->sin_addr)); log_strdup(net_sprint_ipv4_addr(
&addr4->sin_addr)));
return -EADDRNOTAVAIL; return -EADDRNOTAVAIL;
} }
@ -573,7 +575,7 @@ int net_context_bind(struct net_context *context, const struct sockaddr *addr,
NET_DBG("Context %p binding to %s %s:%d iface %p", NET_DBG("Context %p binding to %s %s:%d iface %p",
context, context,
net_proto2str(net_context_get_ip_proto(context)), net_proto2str(net_context_get_ip_proto(context)),
net_sprint_ipv4_addr(ptr), log_strdup(net_sprint_ipv4_addr(ptr)),
ntohs(addr4->sin_port), iface); ntohs(addr4->sin_port), iface);
return 0; return 0;

73
subsys/net/ip/net_if.c
View file

@ -487,7 +487,7 @@ static void join_mcast_allnodes(struct net_if *iface)
ret = net_ipv6_mld_join(iface, &addr); ret = net_ipv6_mld_join(iface, &addr);
if (ret < 0 && ret != -EALREADY) { if (ret < 0 && ret != -EALREADY) {
NET_ERR("Cannot join all nodes address %s (%d)", NET_ERR("Cannot join all nodes address %s (%d)",
net_sprint_ipv6_addr(&addr), ret); log_strdup(net_sprint_ipv6_addr(&addr)), ret);
} }
} }
@ -503,7 +503,7 @@ static void join_mcast_solicit_node(struct net_if *iface,
ret = net_ipv6_mld_join(iface, &addr); ret = net_ipv6_mld_join(iface, &addr);
if (ret < 0 && ret != -EALREADY) { if (ret < 0 && ret != -EALREADY) {
NET_ERR("Cannot join solicit node address %s (%d)", NET_ERR("Cannot join solicit node address %s (%d)",
net_sprint_ipv6_addr(&addr), ret); log_strdup(net_sprint_ipv6_addr(&addr)), ret);
} }
} }
@ -543,7 +543,7 @@ static void dad_timeout(struct k_work *work)
struct net_if *iface = NULL; struct net_if *iface = NULL;
NET_DBG("DAD succeeded for %s", NET_DBG("DAD succeeded for %s",
net_sprint_ipv6_addr(&ifaddr->address.in6_addr)); log_strdup(net_sprint_ipv6_addr(&ifaddr->address.in6_addr)));
ifaddr->addr_state = NET_ADDR_PREFERRED; ifaddr->addr_state = NET_ADDR_PREFERRED;
@ -569,9 +569,11 @@ static void net_if_ipv6_start_dad(struct net_if *iface,
if (net_if_is_up(iface)) { if (net_if_is_up(iface)) {
NET_DBG("Interface %p ll addr %s tentative IPv6 addr %s", NET_DBG("Interface %p ll addr %s tentative IPv6 addr %s",
iface, iface,
net_sprint_ll_addr(net_if_get_link_addr(iface)->addr, log_strdup(net_sprint_ll_addr(
net_if_get_link_addr(iface)->len), net_if_get_link_addr(iface)->addr,
net_sprint_ipv6_addr(&ifaddr->address.in6_addr)); net_if_get_link_addr(iface)->len)),
log_strdup(net_sprint_ipv6_addr(
&ifaddr->address.in6_addr)));
ifaddr->dad_count = 1; ifaddr->dad_count = 1;
@ -581,7 +583,8 @@ static void net_if_ipv6_start_dad(struct net_if *iface,
} else { } else {
NET_DBG("Interface %p is down, starting DAD for %s later.", NET_DBG("Interface %p is down, starting DAD for %s later.",
iface, iface,
net_sprint_ipv6_addr(&ifaddr->address.in6_addr)); log_strdup(net_sprint_ipv6_addr(
&ifaddr->address.in6_addr)));
} }
} }
@ -606,7 +609,7 @@ void net_if_start_dad(struct net_if *iface)
ifaddr = net_if_ipv6_addr_add(iface, &addr, NET_ADDR_AUTOCONF, 0); ifaddr = net_if_ipv6_addr_add(iface, &addr, NET_ADDR_AUTOCONF, 0);
if (!ifaddr) { if (!ifaddr) {
NET_ERR("Cannot add %s address to interface %p, DAD fails", NET_ERR("Cannot add %s address to interface %p, DAD fails",
net_sprint_ipv6_addr(&addr), iface); log_strdup(net_sprint_ipv6_addr(&addr)), iface);
} }
/* Start DAD for all the addresses that were added earlier when /* Start DAD for all the addresses that were added earlier when
@ -630,7 +633,7 @@ void net_if_ipv6_dad_failed(struct net_if *iface, const struct in6_addr *addr)
ifaddr = net_if_ipv6_addr_lookup(addr, &iface); ifaddr = net_if_ipv6_addr_lookup(addr, &iface);
if (!ifaddr) { if (!ifaddr) {
NET_ERR("Cannot find %s address in interface %p", NET_ERR("Cannot find %s address in interface %p",
net_sprint_ipv6_addr(addr), iface); log_strdup(net_sprint_ipv6_addr(addr)), iface);
return; return;
} }
@ -776,7 +779,7 @@ static bool check_timeout(u32_t start, s32_t timeout, u32_t counter,
static void address_expired(struct net_if_addr *ifaddr) static void address_expired(struct net_if_addr *ifaddr)
{ {
NET_DBG("IPv6 address %s is deprecated", NET_DBG("IPv6 address %s is deprecated",
net_sprint_ipv6_addr(&ifaddr->address.in6_addr)); log_strdup(net_sprint_ipv6_addr(&ifaddr->address.in6_addr)));
ifaddr->addr_state = NET_ADDR_DEPRECATED; ifaddr->addr_state = NET_ADDR_DEPRECATED;
ifaddr->lifetime.timer_timeout = 0; ifaddr->lifetime.timer_timeout = 0;
@ -903,7 +906,7 @@ void net_if_ipv6_addr_update_lifetime(struct net_if_addr *ifaddr,
u32_t vlifetime) u32_t vlifetime)
{ {
NET_DBG("Updating expire time of %s by %u secs", NET_DBG("Updating expire time of %s by %u secs",
net_sprint_ipv6_addr(&ifaddr->address.in6_addr), log_strdup(net_sprint_ipv6_addr(&ifaddr->address.in6_addr)),
vlifetime); vlifetime);
ifaddr->addr_state = NET_ADDR_PREFERRED; ifaddr->addr_state = NET_ADDR_PREFERRED;
@ -951,7 +954,8 @@ static inline void net_if_addr_init(struct net_if_addr *ifaddr,
if (vlifetime) { if (vlifetime) {
ifaddr->is_infinite = false; ifaddr->is_infinite = false;
NET_DBG("Expiring %s in %u secs", net_sprint_ipv6_addr(addr), NET_DBG("Expiring %s in %u secs",
log_strdup(net_sprint_ipv6_addr(addr)),
vlifetime); vlifetime);
net_if_ipv6_addr_update_lifetime(ifaddr, vlifetime); net_if_ipv6_addr_update_lifetime(ifaddr, vlifetime);
@ -1032,7 +1036,7 @@ struct net_if_addr *net_if_ipv6_addr_add(struct net_if *iface,
vlifetime); vlifetime);
NET_DBG("[%d] interface %p address %s type %s added", i, NET_DBG("[%d] interface %p address %s type %s added", i,
iface, net_sprint_ipv6_addr(addr), iface, log_strdup(net_sprint_ipv6_addr(addr)),
net_addr_type2str(addr_type)); net_addr_type2str(addr_type));
/* RFC 4862 5.4.2 /* RFC 4862 5.4.2
@ -1104,7 +1108,7 @@ bool net_if_ipv6_addr_rm(struct net_if *iface, const struct in6_addr *addr)
net_if_ipv6_maddr_rm(iface, &maddr); net_if_ipv6_maddr_rm(iface, &maddr);
NET_DBG("[%d] interface %p address %s type %s removed", NET_DBG("[%d] interface %p address %s type %s removed",
i, iface, net_sprint_ipv6_addr(addr), i, iface, log_strdup(net_sprint_ipv6_addr(addr)),
net_addr_type2str(ipv6->unicast[i].addr_type)); net_addr_type2str(ipv6->unicast[i].addr_type));
net_mgmt_event_notify(NET_EVENT_IPV6_ADDR_DEL, iface); net_mgmt_event_notify(NET_EVENT_IPV6_ADDR_DEL, iface);
@ -1127,7 +1131,7 @@ struct net_if_mcast_addr *net_if_ipv6_maddr_add(struct net_if *iface,
if (!net_is_ipv6_addr_mcast(addr)) { if (!net_is_ipv6_addr_mcast(addr)) {
NET_DBG("Address %s is not a multicast address.", NET_DBG("Address %s is not a multicast address.",
net_sprint_ipv6_addr(addr)); log_strdup(net_sprint_ipv6_addr(addr)));
return NULL; return NULL;
} }
@ -1141,7 +1145,7 @@ struct net_if_mcast_addr *net_if_ipv6_maddr_add(struct net_if *iface,
memcpy(&ipv6->mcast[i].address.in6_addr, addr, 16); memcpy(&ipv6->mcast[i].address.in6_addr, addr, 16);
NET_DBG("[%d] interface %p address %s added", i, iface, NET_DBG("[%d] interface %p address %s added", i, iface,
net_sprint_ipv6_addr(addr)); log_strdup(net_sprint_ipv6_addr(addr)));
net_mgmt_event_notify(NET_EVENT_IPV6_MADDR_ADD, iface); net_mgmt_event_notify(NET_EVENT_IPV6_MADDR_ADD, iface);
@ -1173,7 +1177,7 @@ bool net_if_ipv6_maddr_rm(struct net_if *iface, const struct in6_addr *addr)
ipv6->mcast[i].is_used = false; ipv6->mcast[i].is_used = false;
NET_DBG("[%d] interface %p address %s removed", NET_DBG("[%d] interface %p address %s removed",
i, iface, net_sprint_ipv6_addr(addr)); i, iface, log_strdup(net_sprint_ipv6_addr(addr)));
net_mgmt_event_notify(NET_EVENT_IPV6_MADDR_DEL, iface); net_mgmt_event_notify(NET_EVENT_IPV6_MADDR_DEL, iface);
@ -1281,7 +1285,8 @@ static void prefix_lifetime_expired(struct net_if_ipv6_prefix *ifprefix)
struct net_if_ipv6 *ipv6; struct net_if_ipv6 *ipv6;
NET_DBG("Prefix %s/%d expired", NET_DBG("Prefix %s/%d expired",
net_sprint_ipv6_addr(&ifprefix->prefix), ifprefix->len); log_strdup(net_sprint_ipv6_addr(&ifprefix->prefix)),
ifprefix->len);
ifprefix->is_used = false; ifprefix->is_used = false;
@ -1300,7 +1305,7 @@ static void prefix_lifetime_expired(struct net_if_ipv6_prefix *ifprefix)
static void prefix_timer_remove(struct net_if_ipv6_prefix *ifprefix) static void prefix_timer_remove(struct net_if_ipv6_prefix *ifprefix)
{ {
NET_DBG("IPv6 prefix %s/%d removed", NET_DBG("IPv6 prefix %s/%d removed",
net_sprint_ipv6_addr(&ifprefix->prefix), log_strdup(net_sprint_ipv6_addr(&ifprefix->prefix)),
ifprefix->len); ifprefix->len);
ifprefix->lifetime.timer_timeout = 0; ifprefix->lifetime.timer_timeout = 0;
@ -1489,7 +1494,7 @@ struct net_if_ipv6_prefix *net_if_ipv6_prefix_add(struct net_if *iface,
len, lifetime); len, lifetime);
NET_DBG("[%d] interface %p prefix %s/%d added", i, iface, NET_DBG("[%d] interface %p prefix %s/%d added", i, iface,
net_sprint_ipv6_addr(prefix), len); log_strdup(net_sprint_ipv6_addr(prefix)), len);
net_mgmt_event_notify(NET_EVENT_IPV6_PREFIX_ADD, iface); net_mgmt_event_notify(NET_EVENT_IPV6_PREFIX_ADD, iface);
@ -1698,7 +1703,7 @@ static void ipv6_router_expired(struct k_work *work)
lifetime); lifetime);
NET_DBG("IPv6 router %s is expired", NET_DBG("IPv6 router %s is expired",
net_sprint_ipv6_addr(&router->address.in6_addr)); log_strdup(net_sprint_ipv6_addr(&router->address.in6_addr)));
router->is_used = false; router->is_used = false;
} }
@ -1707,7 +1712,7 @@ void net_if_ipv6_router_update_lifetime(struct net_if_router *router,
u32_t lifetime) u32_t lifetime)
{ {
NET_DBG("Updating expire time of %s by %u secs", NET_DBG("Updating expire time of %s by %u secs",
net_sprint_ipv6_addr(&router->address.in6_addr), log_strdup(net_sprint_ipv6_addr(&router->address.in6_addr)),
lifetime); lifetime);
k_delayed_work_submit(&router->lifetime, K_SECONDS(lifetime)); k_delayed_work_submit(&router->lifetime, K_SECONDS(lifetime));
@ -1732,7 +1737,8 @@ static inline void net_if_router_init(struct net_if_router *router,
k_delayed_work_init(&router->lifetime, ipv6_router_expired); k_delayed_work_init(&router->lifetime, ipv6_router_expired);
k_delayed_work_submit(&router->lifetime, K_SECONDS(lifetime)); k_delayed_work_submit(&router->lifetime, K_SECONDS(lifetime));
NET_DBG("Expiring %s in %u secs", net_sprint_ipv6_addr(addr), NET_DBG("Expiring %s in %u secs",
log_strdup(net_sprint_ipv6_addr(addr)),
lifetime); lifetime);
} else { } else {
router->is_default = false; router->is_default = false;
@ -1755,8 +1761,8 @@ struct net_if_router *net_if_ipv6_router_add(struct net_if *iface,
NET_DBG("[%d] interface %p router %s lifetime %u default %d " NET_DBG("[%d] interface %p router %s lifetime %u default %d "
"added", "added",
i, iface, net_sprint_ipv6_addr(addr), lifetime, i, iface, log_strdup(net_sprint_ipv6_addr(addr)),
routers[i].is_default); lifetime, routers[i].is_default);
net_mgmt_event_notify(NET_EVENT_IPV6_ROUTER_ADD, iface); net_mgmt_event_notify(NET_EVENT_IPV6_ROUTER_ADD, iface);
@ -1787,7 +1793,8 @@ bool net_if_ipv6_router_rm(struct net_if_router *router)
routers[i].iface); routers[i].iface);
NET_DBG("[%d] router %s removed", NET_DBG("[%d] router %s removed",
i, net_sprint_ipv6_addr(&routers[i].address.in6_addr)); i, log_strdup(net_sprint_ipv6_addr(
&routers[i].address.in6_addr)));
return true; return true;
} }
@ -2104,8 +2111,8 @@ struct net_if_router *net_if_ipv4_router_add(struct net_if *iface,
NET_DBG("[%d] interface %p router %s lifetime %u default %d " NET_DBG("[%d] interface %p router %s lifetime %u default %d "
"added", "added",
i, iface, net_sprint_ipv4_addr(addr), lifetime, i, iface, log_strdup(net_sprint_ipv4_addr(addr)),
is_default); lifetime, is_default);
net_mgmt_event_notify(NET_EVENT_IPV4_ROUTER_ADD, iface); net_mgmt_event_notify(NET_EVENT_IPV4_ROUTER_ADD, iface);
@ -2392,7 +2399,7 @@ struct net_if_addr *net_if_ipv4_addr_add(struct net_if *iface,
ifaddr->addr_state = NET_ADDR_PREFERRED; ifaddr->addr_state = NET_ADDR_PREFERRED;
NET_DBG("[%d] interface %p address %s type %s added", i, iface, NET_DBG("[%d] interface %p address %s type %s added", i, iface,
net_sprint_ipv4_addr(addr), log_strdup(net_sprint_ipv4_addr(addr)),
net_addr_type2str(addr_type)); net_addr_type2str(addr_type));
net_mgmt_event_notify(NET_EVENT_IPV4_ADDR_ADD, iface); net_mgmt_event_notify(NET_EVENT_IPV4_ADDR_ADD, iface);
@ -2425,7 +2432,7 @@ bool net_if_ipv4_addr_rm(struct net_if *iface, struct in_addr *addr)
ipv4->unicast[i].is_used = false; ipv4->unicast[i].is_used = false;
NET_DBG("[%d] interface %p address %s removed", NET_DBG("[%d] interface %p address %s removed",
i, iface, net_sprint_ipv4_addr(addr)); i, iface, log_strdup(net_sprint_ipv4_addr(addr)));
net_mgmt_event_notify(NET_EVENT_IPV4_ADDR_DEL, iface); net_mgmt_event_notify(NET_EVENT_IPV4_ADDR_DEL, iface);
@ -2476,7 +2483,7 @@ struct net_if_mcast_addr *net_if_ipv4_maddr_add(struct net_if *iface,
if (!net_is_ipv4_addr_mcast(addr)) { if (!net_is_ipv4_addr_mcast(addr)) {
NET_DBG("Address %s is not a multicast address.", NET_DBG("Address %s is not a multicast address.",
net_sprint_ipv4_addr(addr)); log_strdup(net_sprint_ipv4_addr(addr)));
return NULL; return NULL;
} }
@ -2487,7 +2494,7 @@ struct net_if_mcast_addr *net_if_ipv4_maddr_add(struct net_if *iface,
maddr->address.in_addr.s4_addr32[0] = addr->s4_addr32[0]; maddr->address.in_addr.s4_addr32[0] = addr->s4_addr32[0];
NET_DBG("interface %p address %s added", iface, NET_DBG("interface %p address %s added", iface,
net_sprint_ipv4_addr(addr)); log_strdup(net_sprint_ipv4_addr(addr)));
} }
return maddr; return maddr;
@ -2502,7 +2509,7 @@ bool net_if_ipv4_maddr_rm(struct net_if *iface, const struct in_addr *addr)
maddr->is_used = false; maddr->is_used = false;
NET_DBG("interface %p address %s removed", NET_DBG("interface %p address %s removed",
iface, net_sprint_ipv4_addr(addr)); iface, log_strdup(net_sprint_ipv4_addr(addr)));
return true; return true;
} }

45
subsys/net/ip/route.c
View file

@ -157,14 +157,15 @@ void net_routes_print(void)
NET_DBG("[%d] %p %d addr %s/%d", NET_DBG("[%d] %p %d addr %s/%d",
i, nbr, nbr->ref, i, nbr, nbr->ref,
net_sprint_ipv6_addr(&net_route_data(nbr)->addr), log_strdup(net_sprint_ipv6_addr(
&net_route_data(nbr)->addr)),
net_route_data(nbr)->prefix_len); net_route_data(nbr)->prefix_len);
NET_DBG(" iface %p idx %d ll %s", NET_DBG(" iface %p idx %d ll %s",
nbr->iface, nbr->idx, nbr->iface, nbr->idx,
nbr->idx == NET_NBR_LLADDR_UNKNOWN ? "?" : nbr->idx == NET_NBR_LLADDR_UNKNOWN ? "?" :
net_sprint_ll_addr( log_strdup(net_sprint_ll_addr(
net_nbr_get_lladdr(nbr->idx)->addr, net_nbr_get_lladdr(nbr->idx)->addr,
net_nbr_get_lladdr(nbr->idx)->len)); net_nbr_get_lladdr(nbr->idx)->len)));
} }
} }
@ -192,7 +193,7 @@ static struct net_nbr *nbr_new(struct net_if *iface,
NET_DBG("[%d] nbr %p iface %p IPv6 %s/%d", NET_DBG("[%d] nbr %p iface %p IPv6 %s/%d",
nbr->idx, nbr, iface, nbr->idx, nbr, iface,
net_sprint_ipv6_addr(&net_route_data(nbr)->addr), log_strdup(net_sprint_ipv6_addr(&net_route_data(nbr)->addr)),
prefix_len); prefix_len);
return nbr; return nbr;
@ -209,12 +210,13 @@ static struct net_nbr *nbr_nexthop_get(struct net_if *iface,
NET_ASSERT_INFO(nbr, "Next hop neighbor not found!"); NET_ASSERT_INFO(nbr, "Next hop neighbor not found!");
NET_ASSERT_INFO(nbr->idx != NET_NBR_LLADDR_UNKNOWN, NET_ASSERT_INFO(nbr->idx != NET_NBR_LLADDR_UNKNOWN,
"Nexthop %s not in neighbor cache!", "Nexthop %s not in neighbor cache!",
net_sprint_ipv6_addr(addr)); log_strdup(net_sprint_ipv6_addr(addr)));
net_nbr_ref(nbr); net_nbr_ref(nbr);
NET_DBG("[%d] nbr %p iface %p IPv6 %s", NET_DBG("[%d] nbr %p iface %p IPv6 %s",
nbr->idx, nbr, iface, net_sprint_ipv6_addr(addr)); nbr->idx, nbr, iface,
log_strdup(net_sprint_ipv6_addr(addr)));
return nbr; return nbr;
} }
@ -238,8 +240,9 @@ static int nbr_nexthop_put(struct net_nbr *nbr)
NET_ASSERT_INFO(naddr, "Unknown nexthop address"); \ NET_ASSERT_INFO(naddr, "Unknown nexthop address"); \
\ \
NET_DBG("%s route to %s via %s (iface %p)", str, \ NET_DBG("%s route to %s via %s (iface %p)", str, \
net_sprint_ipv6_addr(dst), \ log_strdup(net_sprint_ipv6_addr(dst)), \
net_sprint_ipv6_addr(naddr), route->iface); \ log_strdup(net_sprint_ipv6_addr(naddr)), \
route->iface); \
} while (0) } while (0)
/* Route was accessed, so place it in front of the routes list */ /* Route was accessed, so place it in front of the routes list */
@ -312,7 +315,7 @@ struct net_route_entry *net_route_add(struct net_if *iface,
nbr_nexthop = net_ipv6_nbr_lookup(iface, nexthop); nbr_nexthop = net_ipv6_nbr_lookup(iface, nexthop);
if (!nbr_nexthop) { if (!nbr_nexthop) {
NET_DBG("No such neighbor %s found", NET_DBG("No such neighbor %s found",
net_sprint_ipv6_addr(nexthop)); log_strdup(net_sprint_ipv6_addr(nexthop)));
return NULL; return NULL;
} }
@ -320,8 +323,10 @@ struct net_route_entry *net_route_add(struct net_if *iface,
NET_ASSERT(nexthop_lladdr); NET_ASSERT(nexthop_lladdr);
NET_DBG("Nexthop %s lladdr is %s", net_sprint_ipv6_addr(nexthop), NET_DBG("Nexthop %s lladdr is %s",
net_sprint_ll_addr(nexthop_lladdr->addr, nexthop_lladdr->len)); log_strdup(net_sprint_ipv6_addr(nexthop)),
log_strdup(net_sprint_ll_addr(nexthop_lladdr->addr,
nexthop_lladdr->len)));
route = net_route_lookup(iface, addr); route = net_route_lookup(iface, addr);
if (route) { if (route) {
@ -335,7 +340,7 @@ struct net_route_entry *net_route_add(struct net_if *iface,
} }
NET_DBG("Old route to %s found", NET_DBG("Old route to %s found",
net_sprint_ipv6_addr(nexthop_addr)); log_strdup(net_sprint_ipv6_addr(nexthop_addr)));
net_route_del(route); net_route_del(route);
} }
@ -362,10 +367,12 @@ struct net_route_entry *net_route_add(struct net_if *iface,
NET_DBG("Removing the oldest route %s " NET_DBG("Removing the oldest route %s "
"via %s [%s]", "via %s [%s]",
net_sprint_ipv6_addr(&route->addr), log_strdup(net_sprint_ipv6_addr(
net_sprint_ipv6_addr(tmp), &route->addr)),
net_sprint_ll_addr(llstorage->addr, log_strdup(net_sprint_ipv6_addr(tmp)),
llstorage->len)); log_strdup(net_sprint_ll_addr(
llstorage->addr,
llstorage->len)));
} }
} }
@ -685,7 +692,7 @@ bool net_route_mcast_del(struct net_route_entry_mcast *route)
NET_ASSERT_INFO(route->is_used, NET_ASSERT_INFO(route->is_used,
"Multicast route %p to %s was already removed", route, "Multicast route %p to %s was already removed", route,
net_sprint_ipv6_addr(&route->group)); log_strdup(net_sprint_ipv6_addr(&route->group)));
route->is_used = false; route->is_used = false;
@ -760,14 +767,14 @@ int net_route_packet(struct net_pkt *pkt, struct in6_addr *nexthop)
nbr = net_ipv6_nbr_lookup(NULL, nexthop); nbr = net_ipv6_nbr_lookup(NULL, nexthop);
if (!nbr) { if (!nbr) {
NET_DBG("Cannot find %s neighbor", NET_DBG("Cannot find %s neighbor",
net_sprint_ipv6_addr(nexthop)); log_strdup(net_sprint_ipv6_addr(nexthop)));
return -ENOENT; return -ENOENT;
} }
lladdr = net_nbr_get_lladdr(nbr->idx); lladdr = net_nbr_get_lladdr(nbr->idx);
if (!lladdr) { if (!lladdr) {
NET_DBG("Cannot find %s neighbor link layer address.", NET_DBG("Cannot find %s neighbor link layer address.",
net_sprint_ipv6_addr(nexthop)); log_strdup(net_sprint_ipv6_addr(nexthop)));
return -ESRCH; return -ESRCH;
} }

6
subsys/net/ip/rpl-of0.c
View file

@ -116,10 +116,12 @@ net_rpl_of0_best_parent(struct net_if *iface,
NET_DBG("Comparing parent %s (confidence %d, rank %d) with " NET_DBG("Comparing parent %s (confidence %d, rank %d) with "
"parent %s (confidence %d, rank %d)", "parent %s (confidence %d, rank %d)",
net_sprint_ipv6_addr(net_rpl_get_parent_addr(iface, parent1)), log_strdup(net_sprint_ipv6_addr(
net_rpl_get_parent_addr(iface, parent1))),
net_ipv6_nbr_data(nbr1)->link_metric, net_ipv6_nbr_data(nbr1)->link_metric,
parent1->rank, parent1->rank,
net_sprint_ipv6_addr(net_rpl_get_parent_addr(iface, parent2))), log_strdup(net_sprint_ipv6_addr(
net_rpl_get_parent_addr(iface, parent2)))),
net_ipv6_nbr_data(nbr2)->link_metric, net_ipv6_nbr_data(nbr2)->link_metric,
parent2->rank); parent2->rank);

162
subsys/net/ip/rpl.c
View file

@ -219,8 +219,10 @@ NET_NBR_TABLE_INIT(NET_NBR_LOCAL, rpl_parents, net_rpl_neighbor_pool,
#define net_rpl_info(pkt, req) \ #define net_rpl_info(pkt, req) \
do { \ do { \
NET_DBG("Received %s from %s to %s", req, \ NET_DBG("Received %s from %s to %s", req, \
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src), \ log_strdup(net_sprint_ipv6_addr( \
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->dst)); \ &NET_IPV6_HDR(pkt)->src)), \
log_strdup(net_sprint_ipv6_addr( \
&NET_IPV6_HDR(pkt)->dst))); \
} while (0) } while (0)
#define net_rpl_dao_info(pkt, src, dst, prefix) \ #define net_rpl_dao_info(pkt, src, dst, prefix) \
@ -233,7 +235,9 @@ NET_NBR_TABLE_INIT(NET_NBR_LOCAL, rpl_parents, net_rpl_neighbor_pool,
snprintk(prf, sizeof(prf), "%s", \ snprintk(prf, sizeof(prf), "%s", \
net_sprint_ipv6_addr(prefix)); \ net_sprint_ipv6_addr(prefix)); \
NET_DBG("Send DAO with prefix %s from %s to %s", \ NET_DBG("Send DAO with prefix %s from %s to %s", \
prf, net_sprint_ipv6_addr(src), out); \ log_strdup(prf), \
log_strdup(net_sprint_ipv6_addr(src)), \
log_strdup(out)); \
} while (0) } while (0)
static void new_dio_interval(struct net_rpl_instance *instance); static void new_dio_interval(struct net_rpl_instance *instance);
@ -308,8 +312,8 @@ static struct net_nbr *nbr_add(struct net_if *iface,
} }
NET_DBG("[%d] nbr %p IPv6 %s ll %s iface %p", NET_DBG("[%d] nbr %p IPv6 %s ll %s iface %p",
nbr->idx, nbr, net_sprint_ipv6_addr(addr), nbr->idx, nbr, log_strdup(net_sprint_ipv6_addr(addr)),
net_sprint_ll_addr(lladdr->addr, lladdr->len), log_strdup(net_sprint_ll_addr(lladdr->addr, lladdr->len)),
nbr->iface); nbr->iface);
return nbr; return nbr;
@ -383,8 +387,9 @@ static void net_rpl_print_parents(void)
NET_DBG("[%d] nbr %s %5u %5u => %5u %c (last tx %u min ago)", NET_DBG("[%d] nbr %s %5u %5u => %5u %c (last tx %u min ago)",
nbr->idx, nbr->idx,
net_sprint_ll_addr(net_nbr_get_lladdr(nbr->idx)->addr, log_strdup(net_sprint_ll_addr(
net_nbr_get_lladdr(nbr->idx)->len), net_nbr_get_lladdr(nbr->idx)->addr,
net_nbr_get_lladdr(nbr->idx)->len)),
parent->rank, parent->rank,
ipv6_nbr ? ipv6_nbr ?
net_ipv6_nbr_data(ipv6_nbr)->link_metric : 0, net_ipv6_nbr_data(ipv6_nbr)->link_metric : 0,
@ -424,8 +429,8 @@ struct net_route_entry *net_rpl_add_route(struct net_rpl_dag *dag,
extra->route_source = NET_RPL_ROUTE_INTERNAL; extra->route_source = NET_RPL_ROUTE_INTERNAL;
NET_DBG("Added route to %s via %s (iface %p)", NET_DBG("Added route to %s via %s (iface %p)",
net_sprint_ipv6_addr(addr), log_strdup(net_sprint_ipv6_addr(addr)),
net_sprint_ipv6_addr(nexthop), route->iface); log_strdup(net_sprint_ipv6_addr(nexthop)), route->iface);
return route; return route;
} }
@ -787,7 +792,7 @@ int net_rpl_dis_send(struct in6_addr *dst, struct net_if *iface)
if (ret >= 0) { if (ret >= 0) {
NET_DBG("Sent a %s DIS to %s (iface %p)", NET_DBG("Sent a %s DIS to %s (iface %p)",
dst ? "unicast" : "multicast", dst ? "unicast" : "multicast",
net_sprint_ipv6_addr(dst_addr), iface); log_strdup(net_sprint_ipv6_addr(dst_addr)), iface);
net_stats_update_icmp_sent(iface); net_stats_update_icmp_sent(iface);
net_stats_update_rpl_dis_sent(iface); net_stats_update_rpl_dis_sent(iface);
@ -957,8 +962,10 @@ static void rpl_probing_timer(struct k_work *work)
lladdr = net_nbr_get_lladdr(nbr->idx); lladdr = net_nbr_get_lladdr(nbr->idx);
NET_DBG("Probing %s [%s]", net_sprint_ipv6_addr(dst), NET_DBG("Probing %s [%s]",
net_sprint_ll_addr(lladdr->addr, lladdr->len)); log_strdup(net_sprint_ipv6_addr(dst)),
log_strdup(net_sprint_ll_addr(lladdr->addr,
lladdr->len)));
src = (struct in6_addr *) src = (struct in6_addr *)
net_if_ipv6_select_src_addr(instance->iface, dst); net_if_ipv6_select_src_addr(instance->iface, dst);
@ -1225,7 +1232,7 @@ static void check_prefix(struct net_if *iface,
last_prefix->flags == new_prefix->flags) { last_prefix->flags == new_prefix->flags) {
/* Nothing has changed. */ /* Nothing has changed. */
NET_DBG("Same prefix %s/%d flags 0x%x", NET_DBG("Same prefix %s/%d flags 0x%x",
net_sprint_ipv6_addr(&new_prefix->prefix), log_strdup(net_sprint_ipv6_addr(&new_prefix->prefix)),
new_prefix->length, new_prefix->flags); new_prefix->length, new_prefix->flags);
return; return;
} }
@ -1236,7 +1243,7 @@ static void check_prefix(struct net_if *iface,
if (net_if_ipv6_addr_rm(iface, &addr)) { if (net_if_ipv6_addr_rm(iface, &addr)) {
NET_DBG("Removed global IP address %s", NET_DBG("Removed global IP address %s",
net_sprint_ipv6_addr(&addr)); log_strdup(net_sprint_ipv6_addr(&addr)));
} }
} }
@ -1246,7 +1253,7 @@ static void check_prefix(struct net_if *iface,
if (net_if_ipv6_addr_add(iface, &addr, NET_ADDR_AUTOCONF, 0)) { if (net_if_ipv6_addr_add(iface, &addr, NET_ADDR_AUTOCONF, 0)) {
NET_DBG("Added global IP address %s", NET_DBG("Added global IP address %s",
net_sprint_ipv6_addr(&addr)); log_strdup(net_sprint_ipv6_addr(&addr)));
} }
} }
} }
@ -1255,7 +1262,7 @@ static void net_rpl_free_dag(struct net_if *iface, struct net_rpl_dag *dag)
{ {
if (net_rpl_dag_is_joined(dag)) { if (net_rpl_dag_is_joined(dag)) {
NET_DBG("Leaving the DAG %s", NET_DBG("Leaving the DAG %s",
net_sprint_ipv6_addr(&dag->dag_id)); log_strdup(net_sprint_ipv6_addr(&dag->dag_id)));
net_rpl_dag_unjoin(dag); net_rpl_dag_unjoin(dag);
@ -1281,13 +1288,14 @@ static void net_rpl_set_preferred_parent(struct net_if *iface,
struct in6_addr *addr = net_rpl_get_parent_addr(iface, parent); struct in6_addr *addr = net_rpl_get_parent_addr(iface, parent);
NET_DBG("Preferred parent %s", NET_DBG("Preferred parent %s",
parent ? net_sprint_ipv6_addr(addr) : "not set"); parent ?
log_strdup(net_sprint_ipv6_addr(addr)) : "not set");
addr = net_rpl_get_parent_addr(iface, dag->preferred_parent); addr = net_rpl_get_parent_addr(iface, dag->preferred_parent);
NET_DBG("It used to be %s", NET_DBG("It used to be %s",
dag->preferred_parent ? dag->preferred_parent ?
net_sprint_ipv6_addr(addr) : "not set"); log_strdup(net_sprint_ipv6_addr(addr)) : "not set");
dag->preferred_parent = parent; dag->preferred_parent = parent;
} }
@ -1398,7 +1406,7 @@ struct net_rpl_dag *net_rpl_set_root_with_version(struct net_if *iface,
rpl_default_instance = instance; rpl_default_instance = instance;
NET_DBG("Node set to be a DAG root with DAG ID %s", NET_DBG("Node set to be a DAG root with DAG ID %s",
net_sprint_ipv6_addr(&dag->dag_id)); log_strdup(net_sprint_ipv6_addr(&dag->dag_id)));
instance->iface = iface; instance->iface = iface;
net_rpl_reset_dio_timer(instance); net_rpl_reset_dio_timer(instance);
@ -1505,7 +1513,7 @@ static void net_rpl_nullify_parent(struct net_if *iface,
if (dag->instance->default_route) { if (dag->instance->default_route) {
NET_DBG("Removing default route %s", NET_DBG("Removing default route %s",
net_sprint_ipv6_addr(addr)); log_strdup(net_sprint_ipv6_addr(addr)));
net_if_ipv6_router_rm(dag->instance->default_route); net_if_ipv6_router_rm(dag->instance->default_route);
dag->instance->default_route = NULL; dag->instance->default_route = NULL;
@ -1518,7 +1526,7 @@ static void net_rpl_nullify_parent(struct net_if *iface,
} }
} }
NET_DBG("Nullifying parent %s", net_sprint_ipv6_addr(addr)); NET_DBG("Nullifying parent %s", log_strdup(net_sprint_ipv6_addr(addr)));
} }
static void net_rpl_remove_parent(struct net_if *iface, static void net_rpl_remove_parent(struct net_if *iface,
@ -1541,8 +1549,10 @@ static void net_rpl_remove_parent(struct net_if *iface,
addr = net_rpl_get_parent_addr(iface, parent); addr = net_rpl_get_parent_addr(iface, parent);
lladdr = net_nbr_get_lladdr(nbr->idx); lladdr = net_nbr_get_lladdr(nbr->idx);
NET_DBG("Removing parent %s [%s]", net_sprint_ipv6_addr(addr), NET_DBG("Removing parent %s [%s]",
net_sprint_ll_addr(lladdr->addr, lladdr->len)); log_strdup(net_sprint_ipv6_addr(addr)),
log_strdup(net_sprint_ll_addr(lladdr->addr,
lladdr->len)));
} }
net_rpl_nullify_parent(iface, parent); net_rpl_nullify_parent(iface, parent);
@ -1600,8 +1610,9 @@ static struct net_rpl_parent *net_rpl_add_parent(struct net_if *iface,
&lladdr); &lladdr);
if (!rpl_nbr) { if (!rpl_nbr) {
NET_DBG("Add parent %s [%s]", NET_DBG("Add parent %s [%s]",
net_sprint_ipv6_addr(addr), log_strdup(net_sprint_ipv6_addr(addr)),
net_sprint_ll_addr(lladdr.addr, lladdr.len)); log_strdup(net_sprint_ll_addr(lladdr.addr,
lladdr.len)));
rpl_nbr = nbr_add(iface, addr, &lladdr); rpl_nbr = nbr_add(iface, addr, &lladdr);
if (!rpl_nbr) { if (!rpl_nbr) {
@ -1737,15 +1748,15 @@ static int net_rpl_set_default_route(struct net_if *iface,
{ {
if (instance->default_route) { if (instance->default_route) {
NET_DBG("Removing default route through %s", NET_DBG("Removing default route through %s",
net_sprint_ipv6_addr(&instance->default_route->address. log_strdup(net_sprint_ipv6_addr(
in6_addr)); &instance->default_route->address.in6_addr)));
net_if_ipv6_router_rm(instance->default_route); net_if_ipv6_router_rm(instance->default_route);
instance->default_route = NULL; instance->default_route = NULL;
} }
if (from) { if (from) {
NET_DBG("Adding default route through %s", NET_DBG("Adding default route through %s",
net_sprint_ipv6_addr(from)); log_strdup(net_sprint_ipv6_addr(from)));
instance->default_route = instance->default_route =
net_if_ipv6_router_add(iface, from, net_if_ipv6_router_add(iface, from,
@ -1757,9 +1768,8 @@ static int net_rpl_set_default_route(struct net_if *iface,
} else { } else {
if (instance->default_route) { if (instance->default_route) {
NET_DBG("Removing default route through %s", NET_DBG("Removing default route through %s",
net_sprint_ipv6_addr(&instance-> log_strdup(net_sprint_ipv6_addr(
default_route->address. &instance->default_route->address.in6_addr)));
in6_addr));
net_if_ipv6_router_rm(instance->default_route); net_if_ipv6_router_rm(instance->default_route);
instance->default_route = NULL; instance->default_route = NULL;
} else { } else {
@ -1878,7 +1888,7 @@ struct net_rpl_dag *net_rpl_select_dag(struct net_if *iface,
net_rpl_remove_routes(instance->current_dag); net_rpl_remove_routes(instance->current_dag);
NET_DBG("New preferred DAG %s", NET_DBG("New preferred DAG %s",
net_sprint_ipv6_addr(&best_dag->dag_id)); log_strdup(net_sprint_ipv6_addr(&best_dag->dag_id)));
if (best_dag->prefix_info.flags & if (best_dag->prefix_info.flags &
NET_ICMPV6_RA_FLAG_AUTONOMOUS) { NET_ICMPV6_RA_FLAG_AUTONOMOUS) {
@ -2050,15 +2060,12 @@ static bool net_rpl_process_parent_event(struct net_if *iface,
if (instance->current_dag->rank != if (instance->current_dag->rank !=
NET_RPL_INFINITE_RANK) { NET_RPL_INFINITE_RANK) {
NET_DBG("The preferred parent is %s (rank %u)", NET_DBG("The preferred parent is %s (rank %u)",
net_sprint_ipv6_addr( log_strdup(net_sprint_ipv6_addr(
net_rpl_get_parent_addr(iface, net_rpl_get_parent_addr(iface,
instance->current_dag-> instance->current_dag->preferred_parent))),
preferred_parent)), NET_RPL_DAG_RANK(
instance->current_dag->preferred_parent->rank,
NET_RPL_DAG_RANK( instance));
instance->current_dag->
preferred_parent->rank,
instance));
} else { } else {
NET_DBG("We don't have any parent"); NET_DBG("We don't have any parent");
} }
@ -2167,8 +2174,8 @@ static void global_repair(struct net_if *iface,
NET_DBG("Preferred DAG %s rank %d min_rank %d " \ NET_DBG("Preferred DAG %s rank %d min_rank %d " \
"parent rank %d parent etx %d link metric %d " \ "parent rank %d parent etx %d link metric %d " \
"instance etx %d", \ "instance etx %d", \
net_sprint_ipv6_addr(&(instance)->current_dag-> \ log_strdup(net_sprint_ipv6_addr( \
dag_id), \ &(instance)->current_dag->dag_id)), \
(instance)->current_dag->rank, \ (instance)->current_dag->rank, \
(instance)->current_dag->min_rank, \ (instance)->current_dag->min_rank, \
(parent)->rank, -1, \ (parent)->rank, -1, \
@ -2237,12 +2244,12 @@ static void net_rpl_join_instance(struct net_if *iface,
instance->is_used = false; instance->is_used = false;
NET_DBG("Cannot add %s as a parent", NET_DBG("Cannot add %s as a parent",
net_sprint_ipv6_addr(from)); log_strdup(net_sprint_ipv6_addr(from)));
return; return;
} }
NET_DBG("Add %s as a parent", net_sprint_ipv6_addr(from)); NET_DBG("Add %s as a parent", log_strdup(net_sprint_ipv6_addr(from)));
parent->dtsn = dio->dtsn; parent->dtsn = dio->dtsn;
@ -2308,7 +2315,7 @@ static void net_rpl_join_instance(struct net_if *iface,
NET_DBG("Joined DAG with instance ID %d rank %d DAG ID %s", NET_DBG("Joined DAG with instance ID %d rank %d DAG ID %s",
dio->instance_id, dag->min_rank, dio->instance_id, dag->min_rank,
net_sprint_ipv6_addr(&dag->dag_id)); log_strdup(net_sprint_ipv6_addr(&dag->dag_id)));
net_rpl_reset_dio_timer(instance); net_rpl_reset_dio_timer(instance);
net_rpl_set_default_route(iface, instance, from); net_rpl_set_default_route(iface, instance, from);
@ -2407,7 +2414,7 @@ static void net_rpl_move_parent(struct net_if *iface,
if (net_rpl_dag_is_joined(dag_src) && if (net_rpl_dag_is_joined(dag_src) &&
dag_src->instance->default_route) { dag_src->instance->default_route) {
NET_DBG("Removing default route %s", NET_DBG("Removing default route %s",
net_sprint_ipv6_addr(addr)); log_strdup(net_sprint_ipv6_addr(addr)));
net_if_ipv6_router_rm(dag_src->instance->default_route); net_if_ipv6_router_rm(dag_src->instance->default_route);
dag_src->instance->default_route = NULL; dag_src->instance->default_route = NULL;
@ -2420,7 +2427,7 @@ static void net_rpl_move_parent(struct net_if *iface,
net_route_del_by_nexthop_data(iface, addr, dag_src); net_route_del_by_nexthop_data(iface, addr, dag_src);
} }
NET_DBG("Moving parent %s", net_sprint_ipv6_addr(addr)); NET_DBG("Moving parent %s", log_strdup(net_sprint_ipv6_addr(addr)));
parent->dag = dag_dst; parent->dag = dag_dst;
} }
@ -2482,14 +2489,14 @@ static void net_rpl_add_dag(struct net_if *iface,
parent = net_rpl_add_parent(iface, dag, dio, from); parent = net_rpl_add_parent(iface, dag, dio, from);
if (!parent) { if (!parent) {
NET_DBG("Adding %s as a parent failed.", NET_DBG("Adding %s as a parent failed.",
net_sprint_ipv6_addr(from)); log_strdup(net_sprint_ipv6_addr(from)));
net_rpl_dag_set_not_used(dag); net_rpl_dag_set_not_used(dag);
return; return;
} }
NET_DBG("Adding %s as a parent.", NET_DBG("Adding %s as a parent.",
net_sprint_ipv6_addr(from)); log_strdup(net_sprint_ipv6_addr(from)));
} else { } else {
parent = find_parent(iface, previous_dag, from); parent = find_parent(iface, previous_dag, from);
if (parent) { if (parent) {
@ -2538,7 +2545,7 @@ static void net_rpl_add_dag(struct net_if *iface,
NET_DBG("Joined DAG with instance ID %d rank %d DAG ID %s", NET_DBG("Joined DAG with instance ID %d rank %d DAG ID %s",
dio->instance_id, dag->min_rank, dio->instance_id, dag->min_rank,
net_sprint_ipv6_addr(&dag->dag_id)); log_strdup(net_sprint_ipv6_addr(&dag->dag_id)));
net_rpl_process_parent_event(iface, instance, parent); net_rpl_process_parent_event(iface, instance, parent);
parent->dtsn = dio->dtsn; parent->dtsn = dio->dtsn;
@ -2721,12 +2728,13 @@ static void net_rpl_process_dio(struct net_if *iface,
parent = net_rpl_add_parent(iface, dag, dio, from); parent = net_rpl_add_parent(iface, dag, dio, from);
if (!parent) { if (!parent) {
NET_DBG("Failed to add a new parent %s", NET_DBG("Failed to add a new parent %s",
net_sprint_ipv6_addr(from)); log_strdup(net_sprint_ipv6_addr(from)));
return; return;
} }
NET_DBG("New candidate parent %s with rank %d", NET_DBG("New candidate parent %s with rank %d",
net_sprint_ipv6_addr(from), parent->rank); log_strdup(net_sprint_ipv6_addr(from)),
parent->rank);
} else { } else {
parent = find_parent(iface, previous_dag, from); parent = find_parent(iface, previous_dag, from);
if (parent) { if (parent) {
@ -2734,7 +2742,7 @@ static void net_rpl_process_dio(struct net_if *iface,
dag, parent); dag, parent);
} else { } else {
NET_DBG("No parent %s found", NET_DBG("No parent %s found",
net_sprint_ipv6_addr(from)); log_strdup(net_sprint_ipv6_addr(from)));
return; return;
} }
} }
@ -3075,7 +3083,7 @@ int net_rpl_dao_send(struct net_if *iface,
if (net_ipv6_addr_cmp(src, net_ipv6_unspecified_address())) { if (net_ipv6_addr_cmp(src, net_ipv6_unspecified_address())) {
NET_DBG("Invalid src addr %s found", NET_DBG("Invalid src addr %s found",
net_sprint_ipv6_addr(src)); log_strdup(net_sprint_ipv6_addr(src)));
return -EINVAL; return -EINVAL;
} }
@ -3217,7 +3225,7 @@ static int dao_ack_send(struct in6_addr *src,
int ret; int ret;
NET_DBG("Sending a DAO ACK with sequence number %d to %s", NET_DBG("Sending a DAO ACK with sequence number %d to %s",
sequence, net_sprint_ipv6_addr(dst)); sequence, log_strdup(net_sprint_ipv6_addr(dst)));
pkt = net_pkt_get_reserve_tx(net_if_get_ll_reserve(iface, dst), pkt = net_pkt_get_reserve_tx(net_if_get_ll_reserve(iface, dst),
BUF_TIMEOUT); BUF_TIMEOUT);
@ -3252,8 +3260,8 @@ static int dao_ack_send(struct in6_addr *src,
NET_DBG("Send DAO-ACK (id %d, seq %d) from %s to %s", NET_DBG("Send DAO-ACK (id %d, seq %d) from %s to %s",
instance->instance_id, sequence, instance->instance_id, sequence,
net_sprint_ipv6_addr(src), log_strdup(net_sprint_ipv6_addr(src)),
net_sprint_ipv6_addr(dst)); log_strdup(net_sprint_ipv6_addr(dst)));
net_stats_update_icmp_sent(iface); net_stats_update_icmp_sent(iface);
net_stats_update_rpl_dao_ack_sent(iface); net_stats_update_rpl_dao_ack_sent(iface);
@ -3282,7 +3290,7 @@ static int forwarding_dao(struct net_rpl_instance *instance,
paddr = net_rpl_get_parent_addr(instance->iface, paddr = net_rpl_get_parent_addr(instance->iface,
dag->preferred_parent); dag->preferred_parent);
if (paddr) { if (paddr) {
NET_DBG("%s %s", str, net_sprint_ipv6_addr(paddr)); NET_DBG("%s %s", str, log_strdup(net_sprint_ipv6_addr(paddr)));
net_ipaddr_copy(&src, &NET_IPV6_HDR(pkt)->src); net_ipaddr_copy(&src, &NET_IPV6_HDR(pkt)->src);
net_ipaddr_copy(&dst, &NET_IPV6_HDR(pkt)->dst); net_ipaddr_copy(&dst, &NET_IPV6_HDR(pkt)->dst);
@ -3385,7 +3393,7 @@ static enum net_verdict handle_dao(struct net_pkt *pkt)
if (memcmp(&dag->dag_id, &addr, sizeof(dag->dag_id))) { if (memcmp(&dag->dag_id, &addr, sizeof(dag->dag_id))) {
NET_DBG("Ignoring DAO for a DAG %s different from ours", NET_DBG("Ignoring DAO for a DAG %s different from ours",
net_sprint_ipv6_addr(&dag->dag_id)); log_strdup(net_sprint_ipv6_addr(&dag->dag_id)));
return NET_DROP; return NET_DROP;
} }
} }
@ -3473,7 +3481,7 @@ static enum net_verdict handle_dao(struct net_pkt *pkt)
} }
NET_DBG("DAO lifetime %d addr %s/%d", lifetime, NET_DBG("DAO lifetime %d addr %s/%d", lifetime,
net_sprint_ipv6_addr(&addr), target_len); log_strdup(net_sprint_ipv6_addr(&addr)), target_len);
#if NET_RPL_MULTICAST #if NET_RPL_MULTICAST
if (net_is_ipv6_addr_mcast_global(&addr)) { if (net_is_ipv6_addr_mcast_global(&addr)) {
@ -3509,7 +3517,7 @@ static enum net_verdict handle_dao(struct net_pkt *pkt)
route->prefix_len == target_len && nexthop && route->prefix_len == target_len && nexthop &&
net_ipv6_addr_cmp(nexthop, dao_sender)) { net_ipv6_addr_cmp(nexthop, dao_sender)) {
NET_DBG("Setting expiration timer for target %s", NET_DBG("Setting expiration timer for target %s",
net_sprint_ipv6_addr(&addr)); log_strdup(net_sprint_ipv6_addr(&addr)));
extra->no_path_received = true; extra->no_path_received = true;
extra->lifetime = NET_RPL_DAO_EXPIRATION_TIMEOUT; extra->lifetime = NET_RPL_DAO_EXPIRATION_TIMEOUT;
@ -3537,7 +3545,8 @@ static enum net_verdict handle_dao(struct net_pkt *pkt)
return NET_DROP; return NET_DROP;
} }
NET_DBG("Adding DAO route to %s", net_sprint_ipv6_addr(dao_sender)); NET_DBG("Adding DAO route to %s",
log_strdup(net_sprint_ipv6_addr(dao_sender)));
ipv6_nbr = net_ipv6_nbr_lookup(net_pkt_iface(pkt), dao_sender); ipv6_nbr = net_ipv6_nbr_lookup(net_pkt_iface(pkt), dao_sender);
if (ipv6_nbr) { if (ipv6_nbr) {
@ -3545,9 +3554,10 @@ static enum net_verdict handle_dao(struct net_pkt *pkt)
struct net_linkaddr *src_lladdr; struct net_linkaddr *src_lladdr;
NET_DBG("Neighbor %s [%s] already in neighbor cache", NET_DBG("Neighbor %s [%s] already in neighbor cache",
net_sprint_ipv6_addr(dao_sender), log_strdup(net_sprint_ipv6_addr(dao_sender)),
net_sprint_ll_addr(net_pkt_lladdr_src(pkt)->addr, log_strdup(net_sprint_ll_addr(
net_pkt_lladdr_src(pkt)->len)); net_pkt_lladdr_src(pkt)->addr,
net_pkt_lladdr_src(pkt)->len)));
nbr_lladdr = net_nbr_get_lladdr(ipv6_nbr->idx); nbr_lladdr = net_nbr_get_lladdr(ipv6_nbr->idx);
if (!nbr_lladdr) { if (!nbr_lladdr) {
@ -3569,7 +3579,8 @@ static enum net_verdict handle_dao(struct net_pkt *pkt)
if (!net_ipv6_nbr_rm(net_pkt_iface(pkt), dao_sender)) { if (!net_ipv6_nbr_rm(net_pkt_iface(pkt), dao_sender)) {
NET_ERR("Failed to remove %s, doesn't exist", NET_ERR("Failed to remove %s, doesn't exist",
net_sprint_ipv6_addr(dao_sender)); log_strdup(net_sprint_ipv6_addr(
dao_sender)));
return NET_DROP; return NET_DROP;
} }
@ -3587,16 +3598,16 @@ static enum net_verdict handle_dao(struct net_pkt *pkt)
ipv6_nbr); ipv6_nbr);
NET_DBG("Neighbor %s [%s] added to neighbor cache", NET_DBG("Neighbor %s [%s] added to neighbor cache",
net_sprint_ipv6_addr(dao_sender), log_strdup(net_sprint_ipv6_addr(dao_sender)),
net_sprint_ll_addr( log_strdup(net_sprint_ll_addr(
net_pkt_lladdr_src(pkt)->addr, net_pkt_lladdr_src(pkt)->addr,
net_pkt_lladdr_src(pkt)->len)); net_pkt_lladdr_src(pkt)->len)));
} else { } else {
NET_DBG("Out of memory, dropping DAO from %s [%s]", NET_DBG("Out of memory, dropping DAO from %s [%s]",
net_sprint_ipv6_addr(dao_sender), log_strdup(net_sprint_ipv6_addr(dao_sender)),
net_sprint_ll_addr( log_strdup(net_sprint_ll_addr(
net_pkt_lladdr_src(pkt)->addr, net_pkt_lladdr_src(pkt)->addr,
net_pkt_lladdr_src(pkt)->len)); net_pkt_lladdr_src(pkt)->len)));
return NET_DROP; return NET_DROP;
} }
} }
@ -3640,7 +3651,8 @@ fwd_dao:
if (IS_ENABLED(CONFIG_NET_RPL_DAO_ACK) && (flags & NET_RPL_DAO_K_FLAG) if (IS_ENABLED(CONFIG_NET_RPL_DAO_ACK) && (flags & NET_RPL_DAO_K_FLAG)
&& is_root(instance)) { && is_root(instance)) {
NET_DBG("Sending DAO-ACK to %s (iface %p)", NET_DBG("Sending DAO-ACK to %s (iface %p)",
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src), log_strdup(net_sprint_ipv6_addr(
&NET_IPV6_HDR(pkt)->src)),
net_pkt_iface(pkt)); net_pkt_iface(pkt));
r = dao_ack_send(&NET_IPV6_HDR(pkt)->dst, r = dao_ack_send(&NET_IPV6_HDR(pkt)->dst,
@ -3699,7 +3711,7 @@ static enum net_verdict handle_dao_ack(struct net_pkt *pkt)
NET_DBG("Received a DAO ACK with seq number %d(%d) status %d from %s", NET_DBG("Received a DAO ACK with seq number %d(%d) status %d from %s",
sequence, rpl_dao_sequence, status, sequence, rpl_dao_sequence, status,
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src)); log_strdup(net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src)));
if (sequence == rpl_dao_sequence) { if (sequence == rpl_dao_sequence) {
NET_DBG("Status %s", status < 128 ? "ACK" : "NACK"); NET_DBG("Status %s", status < 128 ? "ACK" : "NACK");

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

@ -1829,11 +1829,13 @@ int net_tcp_unref(struct net_context *context)
if (IS_ENABLED(CONFIG_NET_TCP_LOG_LEVEL_DBG)) { \ if (IS_ENABLED(CONFIG_NET_TCP_LOG_LEVEL_DBG)) { \
if (net_context_get_family(context) == AF_INET6) { \ if (net_context_get_family(context) == AF_INET6) { \
NET_DBG("%s received from %s port %d", str, \ NET_DBG("%s received from %s port %d", str, \
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src),\ log_strdup(net_sprint_ipv6_addr( \
&NET_IPV6_HDR(pkt)->src)), \
ntohs(port)); \ ntohs(port)); \
} else if (net_context_get_family(context) == AF_INET) {\ } else if (net_context_get_family(context) == AF_INET) {\
NET_DBG("%s received from %s port %d", str, \ NET_DBG("%s received from %s port %d", str, \
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src),\ log_strdup(net_sprint_ipv4_addr( \
&NET_IPV4_HDR(pkt)->src)), \
ntohs(port)); \ ntohs(port)); \
} \ } \
} }
@ -1843,11 +1845,13 @@ int net_tcp_unref(struct net_context *context)
struct net_context *ctx = net_pkt_context(pkt); \ struct net_context *ctx = net_pkt_context(pkt); \
if (net_context_get_family(ctx) == AF_INET6) { \ if (net_context_get_family(ctx) == AF_INET6) { \
NET_DBG("%s sent to %s port %d", str, \ NET_DBG("%s sent to %s port %d", str, \
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->dst),\ log_strdup(net_sprint_ipv6_addr( \
&NET_IPV6_HDR(pkt)->dst)), \
ntohs(port)); \ ntohs(port)); \
} else if (net_context_get_family(ctx) == AF_INET) { \ } else if (net_context_get_family(ctx) == AF_INET) { \
NET_DBG("%s sent to %s port %d", str, \ NET_DBG("%s sent to %s port %d", str, \
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->dst),\ log_strdup(net_sprint_ipv4_addr( \
&NET_IPV4_HDR(pkt)->dst)), \
ntohs(port)); \ ntohs(port)); \
} \ } \
} }

12
subsys/net/ip/utils.c
View file

@ -617,13 +617,13 @@ static bool parse_ipv6(const char *str, size_t str_len,
net_sin6(addr)->sin6_port = htons(port); net_sin6(addr)->sin6_port = htons(port);
NET_DBG("IPv6 host %s port %d", NET_DBG("IPv6 host %s port %d",
net_addr_ntop(AF_INET6, addr6, log_strdup(net_addr_ntop(AF_INET6, addr6,
ipaddr, sizeof(ipaddr) - 1), ipaddr, sizeof(ipaddr) - 1)),
port); port);
} else { } else {
NET_DBG("IPv6 host %s", NET_DBG("IPv6 host %s",
net_addr_ntop(AF_INET6, addr6, log_strdup(net_addr_ntop(AF_INET6, addr6,
ipaddr, sizeof(ipaddr) - 1)); ipaddr, sizeof(ipaddr) - 1)));
} }
return true; return true;
@ -688,8 +688,8 @@ static bool parse_ipv4(const char *str, size_t str_len,
net_sin(addr)->sin_port = htons(port); net_sin(addr)->sin_port = htons(port);
NET_DBG("IPv4 host %s port %d", NET_DBG("IPv4 host %s port %d",
net_addr_ntop(AF_INET, addr4, log_strdup(net_addr_ntop(AF_INET, addr4,
ipaddr, sizeof(ipaddr) - 1), ipaddr, sizeof(ipaddr) - 1)),
port); port);
return true; return true;
} }

11
subsys/net/l2/bluetooth/bluetooth.c
View file

@ -134,7 +134,7 @@ static void ipsp_connected(struct bt_l2cap_chan *chan)
bt_addr_le_to_str(info.le.dst, dst, sizeof(dst)); bt_addr_le_to_str(info.le.dst, dst, sizeof(dst));
NET_DBG("Channel %p Source %s connected to Destination %s", NET_DBG("Channel %p Source %s connected to Destination %s",
chan, src, dst); chan, log_strdup(src), log_strdup(dst));
} }
/* Swap bytes since net APIs expect big endian address */ /* Swap bytes since net APIs expect big endian address */
@ -385,7 +385,7 @@ static bool eir_found(u8_t type, const u8_t *data, u8_t data_len,
char dev[BT_ADDR_LE_STR_LEN]; char dev[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(addr, dev, sizeof(dev)); bt_addr_le_to_str(addr, dev, sizeof(dev));
NET_DBG("[DEVICE]: %s", dev); NET_DBG("[DEVICE]: %s", log_strdup(dev));
} }
/* TODO: Notify device address found */ /* TODO: Notify device address found */
@ -512,7 +512,8 @@ static void connected(struct bt_conn *conn, u8_t err)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, bt_addr_le_to_str(bt_conn_get_dst(conn), addr,
sizeof(addr)); sizeof(addr));
NET_ERR("Failed to connect to %s (%u)\n", addr, err); NET_ERR("Failed to connect to %s (%u)\n",
log_strdup(addr), err);
} }
return; return;
@ -534,9 +535,11 @@ static void disconnected(struct bt_conn *conn, u8_t reason)
if (NET_LOG_LEVEL >= LOG_LEVEL_DBG) { if (NET_LOG_LEVEL >= LOG_LEVEL_DBG) {
char addr[BT_ADDR_LE_STR_LEN]; char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr)); bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
NET_DBG("Disconnected: %s (reason %u)\n", addr, reason); NET_DBG("Disconnected: %s (reason %u)\n",
log_strdup(addr), reason);
} }
bt_conn_unref(default_conn); bt_conn_unref(default_conn);

29
subsys/net/l2/ethernet/arp.c
View file

@ -58,7 +58,7 @@ static struct arp_entry *arp_entry_find(sys_slist_t *list,
SYS_SLIST_FOR_EACH_CONTAINER(list, entry, node) { SYS_SLIST_FOR_EACH_CONTAINER(list, entry, node) {
NET_DBG("iface %p dst %s", NET_DBG("iface %p dst %s",
iface, net_sprint_ipv4_addr(&entry->ip)); iface, log_strdup(net_sprint_ipv4_addr(&entry->ip)));
if (entry->iface == iface && if (entry->iface == iface &&
net_ipv4_addr_cmp(&entry->ip, dst)) { net_ipv4_addr_cmp(&entry->ip, dst)) {
@ -79,7 +79,7 @@ static inline struct arp_entry *arp_entry_find_move_first(struct net_if *iface,
sys_snode_t *prev = NULL; sys_snode_t *prev = NULL;
struct arp_entry *entry; struct arp_entry *entry;
NET_DBG("dst %s", net_sprint_ipv4_addr(dst)); NET_DBG("dst %s", log_strdup(net_sprint_ipv4_addr(dst)));
entry = arp_entry_find(&arp_table, iface, dst, &prev); entry = arp_entry_find(&arp_table, iface, dst, &prev);
if (entry) { if (entry) {
@ -101,7 +101,7 @@ static inline
struct arp_entry *arp_entry_find_pending(struct net_if *iface, struct arp_entry *arp_entry_find_pending(struct net_if *iface,
struct in_addr *dst) struct in_addr *dst)
{ {
NET_DBG("dst %s", net_sprint_ipv4_addr(dst)); NET_DBG("dst %s", log_strdup(net_sprint_ipv4_addr(dst)));
return arp_entry_find(&arp_pending_entries, iface, dst, NULL); return arp_entry_find(&arp_pending_entries, iface, dst, NULL);
} }
@ -112,7 +112,7 @@ static struct arp_entry *arp_entry_get_pending(struct net_if *iface,
sys_snode_t *prev = NULL; sys_snode_t *prev = NULL;
struct arp_entry *entry; struct arp_entry *entry;
NET_DBG("dst %s", net_sprint_ipv4_addr(dst)); NET_DBG("dst %s", log_strdup(net_sprint_ipv4_addr(dst)));
entry = arp_entry_find(&arp_pending_entries, iface, dst, &prev); entry = arp_entry_find(&arp_pending_entries, iface, dst, &prev);
if (entry) { if (entry) {
@ -163,7 +163,7 @@ static struct arp_entry *arp_entry_get_last_from_table(void)
static void arp_entry_register_pending(struct arp_entry *entry) static void arp_entry_register_pending(struct arp_entry *entry)
{ {
NET_DBG("dst %s", net_sprint_ipv4_addr(&entry->ip)); NET_DBG("dst %s", log_strdup(net_sprint_ipv4_addr(&entry->ip)));
sys_slist_append(&arp_pending_entries, &entry->node); sys_slist_append(&arp_pending_entries, &entry->node);
@ -433,8 +433,9 @@ struct net_pkt *net_arp_prepare(struct net_pkt *pkt,
ll = net_if_get_link_addr(entry->iface); ll = net_if_get_link_addr(entry->iface);
NET_DBG("ARP using ll %s for IP %s", NET_DBG("ARP using ll %s for IP %s",
net_sprint_ll_addr(ll->addr, sizeof(struct net_eth_addr)), log_strdup(net_sprint_ll_addr(ll->addr,
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src)); sizeof(struct net_eth_addr))),
log_strdup(net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src)));
net_eth_fill_header(ctx, pkt, net_eth_fill_header(ctx, pkt,
current_ip == NULL ? htons(NET_ETH_PTYPE_IP) : current_ip == NULL ? htons(NET_ETH_PTYPE_IP) :
@ -451,7 +452,7 @@ static inline void arp_update(struct net_if *iface,
struct arp_entry *entry; struct arp_entry *entry;
struct net_pkt *pkt; struct net_pkt *pkt;
NET_DBG("src %s", net_sprint_ipv4_addr(src)); NET_DBG("src %s", log_strdup(net_sprint_ipv4_addr(src)));
entry = arp_entry_get_pending(iface, src); entry = arp_entry_get_pending(iface, src);
if (!entry) { if (!entry) {
@ -464,7 +465,7 @@ static inline void arp_update(struct net_if *iface,
(u8_t *) &NET_ETH_HDR(entry->pending)->dst.addr; (u8_t *) &NET_ETH_HDR(entry->pending)->dst.addr;
NET_DBG("dst %s pending %p frag %p", NET_DBG("dst %s pending %p frag %p",
net_sprint_ipv4_addr(&entry->ip), log_strdup(net_sprint_ipv4_addr(&entry->ip)),
entry->pending, entry->pending->frags); entry->pending, entry->pending->frags);
pkt = entry->pending; pkt = entry->pending;
@ -574,10 +575,12 @@ enum net_verdict net_arp_input(struct net_pkt *pkt)
} }
NET_DBG("ARP request from %s [%s] for %s", NET_DBG("ARP request from %s [%s] for %s",
net_sprint_ipv4_addr(&arp_hdr->src_ipaddr), log_strdup(net_sprint_ipv4_addr(&arp_hdr->src_ipaddr)),
net_sprint_ll_addr((u8_t *)&arp_hdr->src_hwaddr, log_strdup(net_sprint_ll_addr(
arp_hdr->hwlen), (u8_t *)&arp_hdr->src_hwaddr,
net_sprint_ipv4_addr(&arp_hdr->dst_ipaddr)); arp_hdr->hwlen)),
log_strdup(net_sprint_ipv4_addr(
&arp_hdr->dst_ipaddr)));
/* Send reply */ /* Send reply */
reply = arp_prepare_reply(net_pkt_iface(pkt), pkt); reply = arp_prepare_reply(net_pkt_iface(pkt), pkt);

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

@ -57,9 +57,9 @@ void net_eth_ipv6_mcast_to_mac_addr(const struct in6_addr *ipv6_addr,
sizeof(struct net_eth_addr))); \ sizeof(struct net_eth_addr))); \
\ \
NET_DBG("iface %p src %s dst %s type 0x%x len %zu", \ NET_DBG("iface %p src %s dst %s type 0x%x len %zu", \
net_pkt_iface(pkt), out, \ net_pkt_iface(pkt), log_strdup(out), \
net_sprint_ll_addr((dst)->addr, \ log_strdup(net_sprint_ll_addr((dst)->addr, \
sizeof(struct net_eth_addr)), \ sizeof(struct net_eth_addr))), \
type, (size_t)len); \ type, (size_t)len); \
} }
@ -73,9 +73,9 @@ void net_eth_ipv6_mcast_to_mac_addr(const struct in6_addr *ipv6_addr,
\ \
NET_DBG("iface %p src %s dst %s type 0x%x tag %d pri %d " \ NET_DBG("iface %p src %s dst %s type 0x%x tag %d pri %d " \
"len %zu", \ "len %zu", \
net_pkt_iface(pkt), out, \ net_pkt_iface(pkt), log_strdup(out), \
net_sprint_ll_addr((dst)->addr, \ log_strdup(net_sprint_ll_addr((dst)->addr, \
sizeof(struct net_eth_addr)), \ sizeof(struct net_eth_addr))), \
type, net_eth_vlan_get_vid(tci), \ type, net_eth_vlan_get_vid(tci), \
net_eth_vlan_get_pcp(tci), (size_t)len); \ net_eth_vlan_get_pcp(tci), (size_t)len); \
} }
@ -201,8 +201,9 @@ static enum net_verdict ethernet_recv(struct net_if *iface,
* are different. * are different.
*/ */
NET_DBG("Dropping frame, not for me [%s]", NET_DBG("Dropping frame, not for me [%s]",
net_sprint_ll_addr(net_if_get_link_addr(iface)->addr, log_strdup(net_sprint_ll_addr(
sizeof(struct net_eth_addr))); net_if_get_link_addr(iface)->addr,
sizeof(struct net_eth_addr))));
return NET_DROP; return NET_DROP;
} }
@ -213,8 +214,9 @@ static enum net_verdict ethernet_recv(struct net_if *iface,
#ifdef CONFIG_NET_ARP #ifdef CONFIG_NET_ARP
if (family == AF_INET && type == NET_ETH_PTYPE_ARP) { if (family == AF_INET && type == NET_ETH_PTYPE_ARP) {
NET_DBG("ARP packet from %s received", NET_DBG("ARP packet from %s received",
net_sprint_ll_addr((u8_t *)hdr->src.addr, log_strdup(net_sprint_ll_addr(
sizeof(struct net_eth_addr))); (u8_t *)hdr->src.addr,
sizeof(struct net_eth_addr))));
#ifdef CONFIG_NET_IPV4_AUTO #ifdef CONFIG_NET_IPV4_AUTO
if (net_ipv4_autoconf_input(iface, pkt) == NET_DROP) { if (net_ipv4_autoconf_input(iface, pkt) == NET_DROP) {
return NET_DROP; return NET_DROP;
@ -522,8 +524,9 @@ static enum net_verdict ethernet_send(struct net_if *iface,
net_pkt_lladdr_dst(pkt)->len = sizeof(struct net_eth_addr); net_pkt_lladdr_dst(pkt)->len = sizeof(struct net_eth_addr);
NET_DBG("Destination address was not set, using %s", NET_DBG("Destination address was not set, using %s",
net_sprint_ll_addr(net_pkt_lladdr_dst(pkt)->addr, log_strdup(net_sprint_ll_addr(
net_pkt_lladdr_dst(pkt)->len)); net_pkt_lladdr_dst(pkt)->addr,
net_pkt_lladdr_dst(pkt)->len)));
} }
setup_hdr: setup_hdr:

2
subsys/net/l2/ethernet/gptp/gptp.c
View file

@ -87,7 +87,7 @@ static void gptp_compute_clock_identity(int port)
} }
#define PRINT_INFO(msg, hdr, pkt) \ #define PRINT_INFO(msg, hdr, pkt) \
NET_DBG("Received %s seq %d pkt %p", msg, \ NET_DBG("Received %s seq %d pkt %p", log_strdup(msg), \
ntohs(hdr->sequence_id), pkt) \ ntohs(hdr->sequence_id), pkt) \

10
subsys/net/l2/ethernet/gptp/gptp_messages.c
View file

@ -37,17 +37,19 @@ static const struct net_eth_addr gptp_multicast_eth_addr = {
output, \ output, \
sizeof(output)); \ sizeof(output)); \
\ \
NET_DBG("Sending %s seq %d pkt %p",\ NET_DBG("Sending %s seq %d pkt %p", \
msg, ntohs(hdr->sequence_id), pkt); \ log_strdup(msg), \
ntohs(hdr->sequence_id), pkt); \
\ \
NET_DBG(" GM %d/%d/0x%x/%d/%s",\ NET_DBG(" GM %d/%d/0x%x/%d/%s",\
ann->root_system_id.grand_master_prio1, \ ann->root_system_id.grand_master_prio1, \
ann->root_system_id.clk_quality.clock_class, \ ann->root_system_id.clk_quality.clock_class, \
ann->root_system_id.clk_quality.clock_accuracy,\ ann->root_system_id.clk_quality.clock_accuracy,\
ann->root_system_id.grand_master_prio2, \ ann->root_system_id.grand_master_prio2, \
output); \ log_strdup(output)); \
} else { \ } else { \
NET_DBG("Sending %s seq %d pkt %p", msg, \ NET_DBG("Sending %s seq %d pkt %p", \
log_strdup(msg), \
ntohs(hdr->sequence_id), pkt); \ ntohs(hdr->sequence_id), pkt); \
} \ } \
} }

2
subsys/net/l2/openthread/openthread.c
View file

@ -311,7 +311,7 @@ static int openthread_init(struct net_if *iface)
otThreadSetNetworkName(ot_context->instance, CONFIG_OPENTHREAD_NETWORK_NAME); otThreadSetNetworkName(ot_context->instance, CONFIG_OPENTHREAD_NETWORK_NAME);
NET_INFO("Network name: %s", NET_INFO("Network name: %s",
otThreadGetNetworkName(ot_context->instance)); log_strdup(otThreadGetNetworkName(ot_context->instance)));
otLinkSetChannel(ot_context->instance, CONFIG_OPENTHREAD_CHANNEL); otLinkSetChannel(ot_context->instance, CONFIG_OPENTHREAD_CHANNEL);
otLinkSetPanId(ot_context->instance, CONFIG_OPENTHREAD_PANID); otLinkSetPanId(ot_context->instance, CONFIG_OPENTHREAD_PANID);

29
subsys/net/l2/openthread/openthread_utils.c
View file

@ -74,9 +74,9 @@ void add_ipv6_addr_to_zephyr(struct openthread_context *context)
char buf[NET_IPV6_ADDR_LEN]; char buf[NET_IPV6_ADDR_LEN];
NET_DBG("Adding %s", NET_DBG("Adding %s",
net_addr_ntop(AF_INET6, log_strdup(net_addr_ntop(AF_INET6,
(struct in6_addr *)(&address->mAddress), (struct in6_addr *)(&address->mAddress),
buf, sizeof(buf))); buf, sizeof(buf))));
#endif #endif
net_if_ipv6_addr_add(context->iface, net_if_ipv6_addr_add(context->iface,
(struct in6_addr *)(&address->mAddress), (struct in6_addr *)(&address->mAddress),
@ -118,9 +118,10 @@ void add_ipv6_addr_to_ot(struct openthread_context *context)
{ {
char buf[NET_IPV6_ADDR_LEN]; char buf[NET_IPV6_ADDR_LEN];
NET_DBG("Added %s", net_addr_ntop(AF_INET6, NET_DBG("Added %s",
&addr.mAddress, buf, log_strdup(net_addr_ntop(AF_INET6,
sizeof(buf))); &addr.mAddress, buf,
sizeof(buf))));
} }
#endif #endif
} }
@ -153,8 +154,8 @@ void add_ipv6_maddr_to_ot(struct openthread_context *context)
char buf[NET_IPV6_ADDR_LEN]; char buf[NET_IPV6_ADDR_LEN];
NET_DBG("Added multicast %s", NET_DBG("Added multicast %s",
net_addr_ntop(AF_INET6, &addr, log_strdup(net_addr_ntop(AF_INET6, &addr,
buf, sizeof(buf))); buf, sizeof(buf))));
} }
#endif #endif
} }
@ -175,9 +176,9 @@ void add_ipv6_maddr_to_zephyr(struct openthread_context *context)
char buf[NET_IPV6_ADDR_LEN]; char buf[NET_IPV6_ADDR_LEN];
NET_DBG("Adding multicast %s", NET_DBG("Adding multicast %s",
net_addr_ntop(AF_INET6, log_strdup(net_addr_ntop(AF_INET6,
(struct in6_addr *)(&maddress->mAddress), (struct in6_addr *)(&maddress->mAddress),
buf, sizeof(buf))); buf, sizeof(buf))));
#endif #endif
net_if_ipv6_maddr_add(context->iface, net_if_ipv6_maddr_add(context->iface,
(struct in6_addr *)(&maddress->mAddress)); (struct in6_addr *)(&maddress->mAddress));
@ -221,9 +222,9 @@ void rm_ipv6_addr_from_zephyr(struct openthread_context *context)
char buf[NET_IPV6_ADDR_LEN]; char buf[NET_IPV6_ADDR_LEN];
NET_DBG("Removing %s", NET_DBG("Removing %s",
net_addr_ntop(AF_INET6, log_strdup(net_addr_ntop(AF_INET6,
&zephyr_addr->address.in6_addr, &zephyr_addr->address.in6_addr,
buf, sizeof(buf))); buf, sizeof(buf))));
#endif #endif
net_if_ipv6_addr_rm(context->iface, net_if_ipv6_addr_rm(context->iface,
&zephyr_addr->address.in6_addr); &zephyr_addr->address.in6_addr);
@ -268,9 +269,9 @@ void rm_ipv6_maddr_from_zephyr(struct openthread_context *context)
char buf[NET_IPV6_ADDR_LEN]; char buf[NET_IPV6_ADDR_LEN];
NET_DBG("Removing multicast %s", NET_DBG("Removing multicast %s",
net_addr_ntop(AF_INET6, log_strdup(net_addr_ntop(AF_INET6,
&zephyr_addr->address.in6_addr, &zephyr_addr->address.in6_addr,
buf, sizeof(buf))); buf, sizeof(buf))));
#endif #endif
net_if_ipv6_maddr_rm(context->iface, net_if_ipv6_maddr_rm(context->iface,
&zephyr_addr->address.in6_addr); &zephyr_addr->address.in6_addr);

9
subsys/net/lib/app/client.c
View file

@ -77,7 +77,8 @@ static int resolve_name(struct net_app_ctx *ctx,
ret = dns_get_addr_info(peer_addr_str, type, &ctx->client.dns_id, ret = dns_get_addr_info(peer_addr_str, type, &ctx->client.dns_id,
dns_cb, ctx, timeout); dns_cb, ctx, timeout);
if (ret < 0) { if (ret < 0) {
NET_ERR("Cannot resolve %s (%d)", peer_addr_str, ret); NET_ERR("Cannot resolve %s (%d)", log_strdup(peer_addr_str),
ret);
ctx->client.dns_id = 0; ctx->client.dns_id = 0;
return ret; return ret;
} }
@ -86,7 +87,8 @@ static int resolve_name(struct net_app_ctx *ctx,
* the DNS will timeout before the semaphore. * the DNS will timeout before the semaphore.
*/ */
if (k_sem_take(&ctx->client.dns_wait, timeout + K_SECONDS(1))) { if (k_sem_take(&ctx->client.dns_wait, timeout + K_SECONDS(1))) {
NET_ERR("Timeout while resolving %s", peer_addr_str); NET_ERR("Timeout while resolving %s",
log_strdup(peer_addr_str));
ctx->client.dns_id = 0; ctx->client.dns_id = 0;
return -ETIMEDOUT; return -ETIMEDOUT;
} }
@ -113,7 +115,8 @@ static int try_resolve(struct net_app_ctx *ctx,
ret = resolve_name(ctx, peer_addr_str, type, timeout); ret = resolve_name(ctx, peer_addr_str, type, timeout);
if (ret < 0) { if (ret < 0) {
NET_ERR("Cannot resolve %s (%d)", peer_addr_str, ret); NET_ERR("Cannot resolve %s (%d)",
log_strdup(peer_addr_str), ret);
} }
return ret; return ret;

11
subsys/net/lib/app/net_app.c
View file

@ -105,7 +105,7 @@ char *_net_app_sprint_ipaddr(char *buf, int buflen,
net_addr_ntop(addr->sa_family, net_addr_ntop(addr->sa_family,
&net_sin6(addr)->sin6_addr, &net_sin6(addr)->sin6_addr,
ipaddr, sizeof(ipaddr)); ipaddr, sizeof(ipaddr));
snprintk(buf, buflen, "[%s]:%u", ipaddr, snprintk(buf, buflen, "[%s]:%u", log_strdup(ipaddr),
ntohs(net_sin6(addr)->sin6_port)); ntohs(net_sin6(addr)->sin6_port));
#endif #endif
} else if (addr->sa_family == AF_INET) { } else if (addr->sa_family == AF_INET) {
@ -115,7 +115,7 @@ char *_net_app_sprint_ipaddr(char *buf, int buflen,
net_addr_ntop(addr->sa_family, net_addr_ntop(addr->sa_family,
&net_sin(addr)->sin_addr, &net_sin(addr)->sin_addr,
ipaddr, sizeof(ipaddr)); ipaddr, sizeof(ipaddr));
snprintk(buf, buflen, "%s:%u", ipaddr, snprintk(buf, buflen, "%s:%u", log_strdup(ipaddr),
ntohs(net_sin(addr)->sin_port)); ntohs(net_sin(addr)->sin_port));
#endif #endif
} else { } else {
@ -137,9 +137,9 @@ void _net_app_print_info(struct net_app_ctx *ctx)
&ctx->default_ctx->remote); &ctx->default_ctx->remote);
NET_DBG("net app connect %s %s %s", NET_DBG("net app connect %s %s %s",
local, log_strdup(local),
ctx->app_type == NET_APP_CLIENT ? "->" : "<-", ctx->app_type == NET_APP_CLIENT ? "->" : "<-",
remote); log_strdup(remote));
} }
#if defined(CONFIG_NET_APP_SERVER) || defined(CONFIG_NET_APP_CLIENT) #if defined(CONFIG_NET_APP_SERVER) || defined(CONFIG_NET_APP_CLIENT)
@ -1179,7 +1179,8 @@ static void my_debug(void *ctx, int level,
((char *)str)[len - 1] = '\0'; ((char *)str)[len - 1] = '\0';
} }
NET_DBG("%s:%04d: |%d| %s", basename, line, level, str); NET_DBG("%s:%04d: |%d| %s", basename, line, level,
log_strdup(str));
} }
#endif /* MBEDTLS_DEBUG_C && NET_LOG_LEVEL >= LOG_LEVEL_DBG */ #endif /* MBEDTLS_DEBUG_C && NET_LOG_LEVEL >= LOG_LEVEL_DBG */

2
subsys/net/lib/app/net_app_private.h
View file

@ -22,7 +22,7 @@
\ \
mbedtls_strerror(ret, error, sizeof(error)); \ mbedtls_strerror(ret, error, sizeof(error)); \
\ \
NET_ERR(fmt " (%s)", -ret, error); \ NET_ERR(fmt " (%s)", -ret, log_strdup(error)); \
} while (0) } while (0)
#else #else
#define _net_app_print_error(fmt, ret) NET_ERR(fmt, -ret) #define _net_app_print_error(fmt, ret) NET_ERR(fmt, -ret)

12
subsys/net/lib/app/server.c
View file

@ -36,7 +36,7 @@ static void new_client(struct net_context *net_ctx,
#endif #endif
NET_INFO("Connection from %s (%p)", NET_INFO("Connection from %s (%p)",
_net_app_sprint_ipaddr(buf, sizeof(buf), addr), log_strdup(_net_app_sprint_ipaddr(buf, sizeof(buf), addr)),
net_ctx); net_ctx);
#endif #endif
} }
@ -298,14 +298,16 @@ static inline void new_server(struct net_app_ctx *ctx,
#endif #endif
#if defined(CONFIG_NET_IPV6) #if defined(CONFIG_NET_IPV6)
NET_INFO("%s %s (%p)", server_banner, NET_INFO("%s %s (%p)", log_strdup(server_banner),
_net_app_sprint_ipaddr(buf, sizeof(buf), &ctx->ipv6.local), log_strdup(_net_app_sprint_ipaddr(buf, sizeof(buf),
&ctx->ipv6.local)),
ctx); ctx);
#endif #endif
#if defined(CONFIG_NET_IPV4) #if defined(CONFIG_NET_IPV4)
NET_INFO("%s %s (%p)", server_banner, NET_INFO("%s %s (%p)", log_strdup(server_banner),
_net_app_sprint_ipaddr(buf, sizeof(buf), &ctx->ipv4.local), log_strdup(_net_app_sprint_ipaddr(buf, sizeof(buf),
&ctx->ipv4.local)),
ctx); ctx);
#endif #endif
#endif #endif

23
subsys/net/lib/config/init.c
View file

@ -56,17 +56,19 @@ static void ipv4_addr_add_handler(struct net_mgmt_event_callback *cb,
#if NET_LOG_LEVEL > 2 #if NET_LOG_LEVEL > 2
NET_INFO("IPv4 address: %s", NET_INFO("IPv4 address: %s",
net_addr_ntop(AF_INET, &if_addr->address.in_addr, log_strdup(net_addr_ntop(AF_INET,
hr_addr, sizeof(hr_addr))); &if_addr->address.in_addr,
hr_addr, sizeof(hr_addr))));
NET_INFO("Lease time: %u seconds", NET_INFO("Lease time: %u seconds",
iface->config.dhcpv4.lease_time); iface->config.dhcpv4.lease_time);
NET_INFO("Subnet: %s", NET_INFO("Subnet: %s",
net_addr_ntop(AF_INET, log_strdup(net_addr_ntop(AF_INET,
&iface->config.ip.ipv4->netmask, &iface->config.ip.ipv4->netmask,
hr_addr, sizeof(hr_addr))); hr_addr, sizeof(hr_addr))));
NET_INFO("Router: %s", NET_INFO("Router: %s",
net_addr_ntop(AF_INET, &iface->config.ip.ipv4->gw, log_strdup(net_addr_ntop(AF_INET,
hr_addr, sizeof(hr_addr))); &iface->config.ip.ipv4->gw,
hr_addr, sizeof(hr_addr))));
#endif #endif
break; break;
} }
@ -132,7 +134,8 @@ static void setup_ipv4(struct net_if *iface)
#if NET_LOG_LEVEL > 2 #if NET_LOG_LEVEL > 2
NET_INFO("IPv4 address: %s", NET_INFO("IPv4 address: %s",
net_addr_ntop(AF_INET, &addr, hr_addr, sizeof(hr_addr))); log_strdup(net_addr_ntop(AF_INET, &addr, hr_addr,
sizeof(hr_addr))));
#endif #endif
if (sizeof(CONFIG_NET_CONFIG_MY_IPV4_NETMASK) > 1) { if (sizeof(CONFIG_NET_CONFIG_MY_IPV4_NETMASK) > 1) {
@ -210,8 +213,8 @@ static void ipv6_event_handler(struct net_mgmt_event_callback *cb,
#if NET_LOG_LEVEL > 2 #if NET_LOG_LEVEL > 2
NET_INFO("IPv6 address: %s", NET_INFO("IPv6 address: %s",
net_addr_ntop(AF_INET6, &laddr, hr_addr, log_strdup(net_addr_ntop(AF_INET6, &laddr, hr_addr,
NET_IPV6_ADDR_LEN)); NET_IPV6_ADDR_LEN)));
#endif #endif
k_sem_take(&counter, K_NO_WAIT); k_sem_take(&counter, K_NO_WAIT);
@ -283,7 +286,7 @@ int net_config_init(const char *app_info, u32_t flags, s32_t timeout)
int count = 0; int count = 0;
if (app_info) { if (app_info) {
NET_INFO("%s", app_info); NET_INFO("%s", log_strdup(app_info));
} }
if (!iface) { if (!iface) {

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

@ -437,8 +437,10 @@ static int send_response(struct net_context *ctx, struct net_pkt *pkt,
if (ret < 0) { if (ret < 0) {
NET_DBG("Cannot send LLMNR reply to %s (%d)", NET_DBG("Cannot send LLMNR reply to %s (%d)",
net_pkt_family(pkt) == AF_INET ? net_pkt_family(pkt) == AF_INET ?
net_sprint_ipv4_addr(&net_sin(&dst)->sin_addr) : log_strdup(net_sprint_ipv4_addr(
net_sprint_ipv6_addr(&net_sin6(&dst)->sin6_addr), &net_sin(&dst)->sin_addr)) :
log_strdup(net_sprint_ipv6_addr(
&net_sin6(&dst)->sin6_addr)),
ret); ret);
net_pkt_unref(reply); net_pkt_unref(reply);
@ -498,8 +500,9 @@ static int dns_read(struct net_context *ctx,
NET_DBG("Received %d %s from %s (id 0x%04x)", queries, NET_DBG("Received %d %s from %s (id 0x%04x)", queries,
queries > 1 ? "queries" : "query", queries > 1 ? "queries" : "query",
net_pkt_family(pkt) == AF_INET ? net_pkt_family(pkt) == AF_INET ?
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src) : log_strdup(net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src)) :
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src), dns_id); log_strdup(net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src)),
dns_id);
do { do {
enum dns_rr_type qtype; enum dns_rr_type qtype;
@ -515,7 +518,7 @@ static int dns_read(struct net_context *ctx,
NET_DBG("[%d] query %s/%s label %s (%d bytes)", queries, NET_DBG("[%d] query %s/%s label %s (%d bytes)", queries,
qtype == DNS_RR_TYPE_A ? "A" : "AAAA", "IN", qtype == DNS_RR_TYPE_A ? "A" : "AAAA", "IN",
result->data, ret); log_strdup(result->data), ret);
/* If the query matches to our hostname, then send reply */ /* If the query matches to our hostname, then send reply */
if (!strncasecmp(hostname, result->data + 1, hostname_len) && if (!strncasecmp(hostname, result->data + 1, hostname_len) &&
@ -581,7 +584,7 @@ static void iface_ipv6_cb(struct net_if *iface, void *user_data)
ret = net_ipv6_mld_join(iface, addr); ret = net_ipv6_mld_join(iface, addr);
if (ret < 0) { if (ret < 0) {
NET_DBG("Cannot join %s IPv6 multicast group (%d)", NET_DBG("Cannot join %s IPv6 multicast group (%d)",
net_sprint_ipv6_addr(addr), ret); log_strdup(net_sprint_ipv6_addr(addr)), ret);
} }
} }

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

@ -331,8 +331,8 @@ static int dns_read(struct net_context *ctx,
NET_DBG("Received %d %s from %s", queries, NET_DBG("Received %d %s from %s", queries,
queries > 1 ? "queries" : "query", queries > 1 ? "queries" : "query",
net_pkt_family(pkt) == AF_INET ? net_pkt_family(pkt) == AF_INET ?
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src) : log_strdup(net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src)) :
net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src)); log_strdup(net_sprint_ipv6_addr(&NET_IPV6_HDR(pkt)->src)));
do { do {
enum dns_rr_type qtype; enum dns_rr_type qtype;
@ -355,7 +355,7 @@ static int dns_read(struct net_context *ctx,
NET_DBG("[%d] query %s/%s label %s (%d bytes)", queries, NET_DBG("[%d] query %s/%s label %s (%d bytes)", queries,
qtype == DNS_RR_TYPE_A ? "A" : "AAAA", "IN", qtype == DNS_RR_TYPE_A ? "A" : "AAAA", "IN",
result->data, ret); log_strdup(result->data), ret);
/* If the query matches to our hostname, then send reply. /* If the query matches to our hostname, then send reply.
* We skip the first dot, and make sure there is dot after * We skip the first dot, and make sure there is dot after
@ -426,7 +426,7 @@ static void iface_ipv6_cb(struct net_if *iface, void *user_data)
ret = net_ipv6_mld_join(iface, addr); ret = net_ipv6_mld_join(iface, addr);
if (ret < 0) { if (ret < 0) {
NET_DBG("Cannot join %s IPv6 multicast group (%d)", NET_DBG("Cannot join %s IPv6 multicast group (%d)",
net_sprint_ipv6_addr(addr), ret); log_strdup(net_sprint_ipv6_addr(addr)), ret);
} }
} }

2
subsys/net/lib/dns/resolve.c
View file

@ -222,7 +222,7 @@ int dns_resolve_init(struct dns_resolve_context *ctx, const char *servers[],
dns_postprocess_server(ctx, idx); dns_postprocess_server(ctx, idx);
NET_DBG("[%d] %s", i, servers[i]); NET_DBG("[%d] %s", i, log_strdup(servers[i]));
idx++; idx++;
} }

10
subsys/net/lib/http/http_client.c
View file

@ -194,8 +194,9 @@ static inline void print_info(struct http_ctx *ctx,
&ctx->app_ctx.default_ctx->remote); &ctx->app_ctx.default_ctx->remote);
NET_DBG("HTTP %s (%s) %s -> %s port %d", NET_DBG("HTTP %s (%s) %s -> %s port %d",
http_method_str(method), ctx->http.req.host, local, http_method_str(method),
remote, log_strdup(ctx->http.req.host), log_strdup(local),
log_strdup(remote),
ntohs(net_sin(&ctx->app_ctx.default_ctx->remote)-> ntohs(net_sin(&ctx->app_ctx.default_ctx->remote)->
sin_port)); sin_port));
} }
@ -283,7 +284,7 @@ static void print_header_field(size_t len, const char *str)
snprintk(output, len + 1, "%s", str); snprintk(output, len + 1, "%s", str);
NET_DBG("[%zd] %s", len, output); NET_DBG("[%zd] %s", len, log_strdup(output));
} }
} }
@ -307,7 +308,8 @@ static int on_status(struct http_parser *parser, const char *at, size_t length)
memcpy(ctx->http.rsp.http_status, at, len); memcpy(ctx->http.rsp.http_status, at, len);
ctx->http.rsp.http_status[len] = 0; ctx->http.rsp.http_status[len] = 0;
NET_DBG("HTTP response status %s", ctx->http.rsp.http_status); NET_DBG("HTTP response status %s",
log_strdup(ctx->http.rsp.http_status));
return 0; return 0;
} }

3
subsys/net/lib/sockets/sockets_tls.c
View file

@ -162,7 +162,8 @@ static void tls_debug(void *ctx, int level, const char *file,
} }
} }
NET_DBG("%s:%04d: |%d| %s", basename, line, level, str); NET_DBG("%s:%04d: |%d| %s", basename, line, level,
log_strdup(str));
} }
#endif /* defined(MBEDTLS_DEBUG_C) && defined(CONFIG_NET_TLS_DEBUG) */ #endif /* defined(MBEDTLS_DEBUG_C) && defined(CONFIG_NET_TLS_DEBUG) */