static int get_local_addr(struct http_client_ctx *ctx) { if (ctx->tcp.local.family == AF_INET6) { #if defined(CONFIG_NET_IPV6) struct in6_addr *dst = &net_sin6(&ctx->tcp.remote)->sin6_addr; net_ipaddr_copy(&net_sin6(&ctx->tcp.local)->sin6_addr, net_if_ipv6_select_src_addr(NULL, dst)); #else return -EPFNOSUPPORT; #endif } else if (ctx->tcp.local.family == AF_INET) { #if defined(CONFIG_NET_IPV4) struct net_if *iface = net_if_get_default(); /* For IPv4 we take the first address in the interface */ net_ipaddr_copy(&net_sin(&ctx->tcp.local)->sin_addr, &iface->ipv4.unicast[0].address.in_addr); #else return -EPFNOSUPPORT; #endif } return 0; }
static int shell_cmd_get_ext_addr(int argc, char *argv[]) { struct net_if *iface = net_if_get_default(); u8_t addr[IEEE802154_EXT_ADDR_LENGTH]; if (net_mgmt(NET_REQUEST_IEEE802154_GET_EXT_ADDR, iface, addr, IEEE802154_EXT_ADDR_LENGTH)) { printk("Could not get extended address\n"); } else { int i; printk("Extended address: "); for (i = 0; i < IEEE802154_EXT_ADDR_LENGTH; i++) { printk("%02X", addr[i]); if (i < (IEEE802154_EXT_ADDR_LENGTH - 1)) { printk(":"); } } printk("\n"); } return 0; }
static inline int init_app(void) { if (!net_if_ipv4_addr_add(net_if_get_default(), &client_addr, NET_ADDR_MANUAL, 0)) { return -EIO; } return 0; }
static inline int init_app(void) { #if defined(CONFIG_NET_APP_MY_IPV6_ADDR) if (net_addr_pton(AF_INET6, CONFIG_NET_APP_MY_IPV6_ADDR, &server_addr) < 0) { mbedtls_printf("Invalid IPv6 address %s", CONFIG_NET_APP_MY_IPV6_ADDR); } #endif if (!net_if_ipv6_addr_add(net_if_get_default(), &server_addr, NET_ADDR_MANUAL, 0)) { return -EIO; } net_if_ipv6_maddr_add(net_if_get_default(), &mcast_addr); return 0; }
static inline void init_app(void) { NET_INFO("Run echo server"); k_sem_init(&quit_lock, 0, UINT_MAX); #if defined(CONFIG_NET_IPV6) #if defined(CONFIG_NET_APP_MY_IPV6_ADDR) if (net_addr_pton(AF_INET6, CONFIG_NET_APP_MY_IPV6_ADDR, &in6addr_my) < 0) { NET_ERR("Invalid IPv6 address %s", CONFIG_NET_APP_MY_IPV6_ADDR); } #endif do { struct net_if_addr *ifaddr; ifaddr = net_if_ipv6_addr_add(net_if_get_default(), &in6addr_my, NET_ADDR_MANUAL, 0); } while (0); #endif #if defined(CONFIG_NET_IPV4) #if defined(CONFIG_NET_DHCPV4) net_dhcpv4_start(net_if_get_default()); #else #if defined(CONFIG_NET_APP_MY_IPV4_ADDR) if (net_addr_pton(AF_INET, CONFIG_NET_APP_MY_IPV4_ADDR, &in4addr_my) < 0) { NET_ERR("Invalid IPv4 address %s", CONFIG_NET_APP_MY_IPV4_ADDR); } net_if_ipv4_addr_add(net_if_get_default(), &in4addr_my, NET_ADDR_MANUAL, 0); #endif #endif /* CONFIG_NET_DHCPV4 */ #endif /* CONFIG_NET_IPV4 */ }
void main(void) { struct net_if *iface = net_if_get_default(); NET_INFO("Starting Telnet sample"); setup_ipv4(iface); setup_dhcpv4(iface); setup_ipv6(iface); }
static inline void init_app(void) { printk("Run IPSP sample"); k_sem_init(&quit_lock, 0, UINT_MAX); if (net_addr_pton(AF_INET6, CONFIG_NET_APP_MY_IPV6_ADDR, &in6addr_my) < 0) { printk("Invalid IPv6 address %s", CONFIG_NET_APP_MY_IPV6_ADDR); } do { struct net_if_addr *ifaddr; ifaddr = net_if_ipv6_addr_add(net_if_get_default(), &in6addr_my, NET_ADDR_MANUAL, 0); } while (0); net_if_ipv6_maddr_add(net_if_get_default(), &in6addr_mcast); }
static int shell_cmd_scan(int argc, char *argv[]) { struct net_if *iface = net_if_get_default(); u32_t scan_type; int ret; memset(¶ms, 0, sizeof(struct ieee802154_req_params)); net_mgmt_init_event_callback(&scan_cb, scan_result_cb, NET_EVENT_IEEE802154_SCAN_RESULT); if (!strcmp(argv[1], "active")) { scan_type = NET_REQUEST_IEEE802154_ACTIVE_SCAN; } else if (!strcmp(argv[1], "passive")) { scan_type = NET_REQUEST_IEEE802154_PASSIVE_SCAN; } else { return -EINVAL; } if (!strcmp(argv[2], "all")) { params.channel_set = IEEE802154_ALL_CHANNELS; } else { params.channel_set = parse_channel_set(argv[2]); } if (!params.channel_set) { return -EINVAL; } params.duration = atoi(argv[3]); printk("%s Scanning (channel set: 0x%08x, duration %u ms)...", scan_type == NET_REQUEST_IEEE802154_ACTIVE_SCAN ? "Active" : "Passive", params.channel_set, params.duration); if (scan_type == NET_REQUEST_IEEE802154_ACTIVE_SCAN) { ret = net_mgmt(NET_REQUEST_IEEE802154_ACTIVE_SCAN, iface, ¶ms, sizeof(struct ieee802154_req_params)); } else { ret = net_mgmt(NET_REQUEST_IEEE802154_PASSIVE_SCAN, iface, ¶ms, sizeof(struct ieee802154_req_params)); } if (ret) { printk("Could not raise a scan (status: %i)\n", ret); } else { printk("Done\n"); } return 0; }
static int shell_cmd_get_short_addr(int argc, char *argv[]) { struct net_if *iface = net_if_get_default(); u16_t short_addr; if (net_mgmt(NET_REQUEST_IEEE802154_GET_SHORT_ADDR, iface, &short_addr, sizeof(u16_t))) { printk("Could not get short address\n"); } else { printk("Short address %u\n", short_addr); } return 0; }
static int shell_cmd_get_tx_power(int argc, char *argv[]) { struct net_if *iface = net_if_get_default(); s16_t tx_power; if (net_mgmt(NET_REQUEST_IEEE802154_GET_SHORT_ADDR, iface, &tx_power, sizeof(s16_t))) { printk("Could not get TX power\n"); } else { printk("TX power (in dbm) %d\n", tx_power); } return 0; }
static int shell_cmd_get_pan_id(int argc, char *argv[]) { struct net_if *iface = net_if_get_default(); u16_t pan_id; if (net_mgmt(NET_REQUEST_IEEE802154_GET_PAN_ID, iface, &pan_id, sizeof(u16_t))) { printk("Could not get PAN ID\n"); } else { printk("PAN ID %u\n", pan_id); } return 0; }
static int shell_cmd_get_chan(int argc, char *argv[]) { struct net_if *iface = net_if_get_default(); u16_t channel; if (net_mgmt(NET_REQUEST_IEEE802154_GET_CHANNEL, iface, &channel, sizeof(u16_t))) { printk("Could not get channel\n"); } else { printk("Channel %u\n", channel); } return 0; }
static int shell_cmd_set_chan(int argc, char *argv[]) { struct net_if *iface = net_if_get_default(); uint16_t channel = (uint16_t) atoi(argv[1]); if (net_mgmt(NET_REQUEST_IEEE802154_SET_CHAN, iface, &channel, sizeof(uint16_t))) { printk("Could not set channel %u\n", channel); } else { printk("Channel %u set\n", channel); } return 0; }
static int shell_cmd_set_tx_power(int argc, char *argv[]) { struct net_if *iface = net_if_get_default(); s16_t tx_power = (s16_t) atoi(argv[1]); if (net_mgmt(NET_REQUEST_IEEE802154_SET_TX_POWER, iface, &tx_power, sizeof(s16_t))) { printk("Could not set TX power %d\n", tx_power); } else { printk("TX power %d set\n", tx_power); } return 0; }
static inline void init_app(void) { struct net_if *iface; NET_INFO("Run dhcpv4 client"); iface = net_if_get_default(); net_dhcpv4_start(iface); k_sem_init(&quit_lock, 0, UINT_MAX); net_mgmt_init_event_callback(&mgmt_cb, handler, NET_EVENT_IPV4_ADDR_ADD); net_mgmt_add_event_callback(&mgmt_cb); }
static int shell_cmd_disassociate(int argc, char *argv[]) { struct net_if *iface = net_if_get_default(); int ret; ret = net_mgmt(NET_REQUEST_IEEE802154_DISASSOCIATE, iface, NULL, 0); if (ret == -EALREADY) { printk("Interface is not associated\n"); } else if (ret) { printk("Could not disassociate? (status: %i)\n", ret); } else { printk("Interface is now disassociated\n"); } return 0; }
static int shell_cmd_ack(int argc, char *argv[]) { struct net_if *iface = net_if_get_default(); if (!strcmp(argv[1], "set") || !strcmp(argv[1], "1")) { net_mgmt(NET_REQUEST_IEEE802154_SET_ACK, iface, NULL, 0); printk("ACK flag set on outgoing packets\n"); return 0; } if (!strcmp(argv[1], "unset") || !strcmp(argv[1], "0")) { net_mgmt(NET_REQUEST_IEEE802154_SET_ACK, iface, NULL, 0); printk("ACK flag unset on outgoing packets\n"); return 0; } return -EINVAL; }
static int shell_cmd_set_ext_addr(int argc, char *argv[]) { struct net_if *iface = net_if_get_default(); u8_t addr[IEEE802154_EXT_ADDR_LENGTH]; if (strlen(argv[2]) != 23) { printk("23 characters needed\n"); return 0; } parse_extended_address(argv[2], addr); if (net_mgmt(NET_REQUEST_IEEE802154_SET_EXT_ADDR, iface, addr, IEEE802154_EXT_ADDR_LENGTH)) { printk("Could not set extended address\n"); } else { printk("Extended address %s set\n", argv[2]); } return 0; }
static int shell_cmd_associate(int argc, char *argv[]) { struct net_if *iface = net_if_get_default(); params.pan_id = atoi(argv[1]); if (strlen(argv[2]) == 23) { parse_extended_address(argv[2], params.addr); params.len = IEEE802154_EXT_ADDR_LENGTH; } else { params.short_addr = (u16_t) atoi(argv[2]); params.len = IEEE802154_SHORT_ADDR_LENGTH; } if (net_mgmt(NET_REQUEST_IEEE802154_ASSOCIATE, iface, ¶ms, sizeof(struct ieee802154_req_params))) { printk("Could not associate to %s on PAN ID %u\n", argv[2], params.pan_id); } else { printk("Associated to PAN ID %u\n", params.pan_id); } return 0; }
static bool run_tests(void) { struct net_pkt *pkt, *pkt2; struct net_buf *frag; struct net_if *iface; struct net_if_addr *ifaddr; struct net_arp_hdr *arp_hdr; struct net_ipv4_hdr *ipv4; struct net_eth_hdr *eth_hdr; int len; struct in_addr dst = { { { 192, 168, 0, 2 } } }; struct in_addr dst_far = { { { 10, 11, 12, 13 } } }; struct in_addr dst_far2 = { { { 172, 16, 14, 186 } } }; struct in_addr src = { { { 192, 168, 0, 1 } } }; struct in_addr netmask = { { { 255, 255, 255, 0 } } }; struct in_addr gw = { { { 192, 168, 0, 42 } } }; net_arp_init(); iface = net_if_get_default(); net_if_ipv4_set_gw(iface, &gw); net_if_ipv4_set_netmask(iface, &netmask); /* Unicast test */ ifaddr = net_if_ipv4_addr_add(iface, &src, NET_ADDR_MANUAL, 0); ifaddr->addr_state = NET_ADDR_PREFERRED; /* Application data for testing */ pkt = net_pkt_get_reserve_tx(sizeof(struct net_eth_hdr), K_FOREVER); if (!pkt) { printk("Out of mem TX\n"); return false; } frag = net_pkt_get_frag(pkt, K_FOREVER); if (!frag) { printk("Out of mem DATA\n"); return false; } net_pkt_frag_add(pkt, frag); net_pkt_set_iface(pkt, iface); setup_eth_header(iface, pkt, &hwaddr, NET_ETH_PTYPE_IP); len = strlen(app_data); if (net_pkt_ll_reserve(pkt) != sizeof(struct net_eth_hdr)) { printk("LL reserve invalid, should be %zd was %d\n", sizeof(struct net_eth_hdr), net_pkt_ll_reserve(pkt)); return false; } ipv4 = (struct net_ipv4_hdr *)net_buf_add(frag, sizeof(struct net_ipv4_hdr)); net_ipaddr_copy(&ipv4->src, &src); net_ipaddr_copy(&ipv4->dst, &dst); memcpy(net_buf_add(frag, len), app_data, len); pkt2 = net_arp_prepare(pkt); /* pkt2 is the ARP packet and pkt is the IPv4 packet and it was * stored in ARP table. */ if (pkt2 == pkt) { /* The packets cannot be the same as the ARP cache has * still room for the pkt. */ printk("ARP cache should still have free space\n"); return false; } if (!pkt2) { printk("ARP pkt is empty\n"); return false; } /* The ARP cache should now have a link to pending net_pkt * that is to be sent after we have got an ARP reply. */ if (!pkt->frags) { printk("Pending pkt fragment is NULL\n"); return false; } pending_pkt = pkt; /* pkt2 should contain the arp header, verify it */ if (memcmp(net_pkt_ll(pkt2), net_eth_broadcast_addr(), sizeof(struct net_eth_addr))) { printk("ARP ETH dest address invalid\n"); net_hexdump("ETH dest wrong ", net_pkt_ll(pkt2), sizeof(struct net_eth_addr)); net_hexdump("ETH dest correct", (u8_t *)net_eth_broadcast_addr(), sizeof(struct net_eth_addr)); return false; } if (memcmp(net_pkt_ll(pkt2) + sizeof(struct net_eth_addr), iface->link_addr.addr, sizeof(struct net_eth_addr))) { printk("ARP ETH source address invalid\n"); net_hexdump("ETH src correct", iface->link_addr.addr, sizeof(struct net_eth_addr)); net_hexdump("ETH src wrong ", net_pkt_ll(pkt2) + sizeof(struct net_eth_addr), sizeof(struct net_eth_addr)); return false; } arp_hdr = NET_ARP_HDR(pkt2); eth_hdr = NET_ETH_HDR(pkt2); if (eth_hdr->type != htons(NET_ETH_PTYPE_ARP)) { printk("ETH type 0x%x, should be 0x%x\n", eth_hdr->type, htons(NET_ETH_PTYPE_ARP)); return false; } if (arp_hdr->hwtype != htons(NET_ARP_HTYPE_ETH)) { printk("ARP hwtype 0x%x, should be 0x%x\n", arp_hdr->hwtype, htons(NET_ARP_HTYPE_ETH)); return false; } if (arp_hdr->protocol != htons(NET_ETH_PTYPE_IP)) { printk("ARP protocol 0x%x, should be 0x%x\n", arp_hdr->protocol, htons(NET_ETH_PTYPE_IP)); return false; } if (arp_hdr->hwlen != sizeof(struct net_eth_addr)) { printk("ARP hwlen 0x%x, should be 0x%zx\n", arp_hdr->hwlen, sizeof(struct net_eth_addr)); return false; } if (arp_hdr->protolen != sizeof(struct in_addr)) { printk("ARP IP addr len 0x%x, should be 0x%zx\n", arp_hdr->protolen, sizeof(struct in_addr)); return false; } if (arp_hdr->opcode != htons(NET_ARP_REQUEST)) { printk("ARP opcode 0x%x, should be 0x%x\n", arp_hdr->opcode, htons(NET_ARP_REQUEST)); return false; } if (!net_ipv4_addr_cmp(&arp_hdr->dst_ipaddr, &NET_IPV4_HDR(pkt)->dst)) { char out[sizeof("xxx.xxx.xxx.xxx")]; snprintk(out, sizeof(out), "%s", net_sprint_ipv4_addr(&arp_hdr->dst_ipaddr)); printk("ARP IP dest invalid %s, should be %s", out, net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->dst)); return false; } if (!net_ipv4_addr_cmp(&arp_hdr->src_ipaddr, &NET_IPV4_HDR(pkt)->src)) { char out[sizeof("xxx.xxx.xxx.xxx")]; snprintk(out, sizeof(out), "%s", net_sprint_ipv4_addr(&arp_hdr->src_ipaddr)); printk("ARP IP src invalid %s, should be %s", out, net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src)); return false; } /* We could have send the new ARP request but for this test we * just free it. */ net_pkt_unref(pkt2); if (pkt->ref != 2) { printk("ARP cache should own the original packet\n"); return false; } /* Then a case where target is not in the same subnet */ net_ipaddr_copy(&ipv4->dst, &dst_far); pkt2 = net_arp_prepare(pkt); if (pkt2 == pkt) { printk("ARP cache should not find anything\n"); return false; } if (!pkt2) { printk("ARP pkt2 is empty\n"); return false; } arp_hdr = NET_ARP_HDR(pkt2); if (!net_ipv4_addr_cmp(&arp_hdr->dst_ipaddr, &iface->ipv4.gw)) { char out[sizeof("xxx.xxx.xxx.xxx")]; snprintk(out, sizeof(out), "%s", net_sprint_ipv4_addr(&arp_hdr->dst_ipaddr)); printk("ARP IP dst invalid %s, should be %s\n", out, net_sprint_ipv4_addr(&iface->ipv4.gw)); return false; } net_pkt_unref(pkt2); /* Try to find the same destination again, this should fail as there * is a pending request in ARP cache. */ net_ipaddr_copy(&ipv4->dst, &dst_far); /* Make sure prepare will not free the pkt because it will be * needed in the later test case. */ net_pkt_ref(pkt); pkt2 = net_arp_prepare(pkt); if (!pkt2) { printk("ARP cache is not sending the request again\n"); return false; } net_pkt_unref(pkt2); /* Try to find the different destination, this should fail too * as the cache table should be full. */ net_ipaddr_copy(&ipv4->dst, &dst_far2); /* Make sure prepare will not free the pkt because it will be * needed in the next test case. */ net_pkt_ref(pkt); pkt2 = net_arp_prepare(pkt); if (!pkt2) { printk("ARP cache did not send a req\n"); return false; } /* Restore the original address so that following test case can * work properly. */ net_ipaddr_copy(&ipv4->dst, &dst); /* The arp request packet is now verified, create an arp reply. * The previous value of pkt is stored in arp table and is not lost. */ pkt = net_pkt_get_reserve_rx(sizeof(struct net_eth_hdr), K_FOREVER); if (!pkt) { printk("Out of mem RX reply\n"); return false; } printk("%d pkt %p\n", __LINE__, pkt); frag = net_pkt_get_frag(pkt, K_FOREVER); if (!frag) { printk("Out of mem DATA reply\n"); return false; } printk("%d frag %p\n", __LINE__, frag); net_pkt_frag_add(pkt, frag); net_pkt_set_iface(pkt, iface); arp_hdr = NET_ARP_HDR(pkt); net_buf_add(frag, sizeof(struct net_arp_hdr)); net_ipaddr_copy(&arp_hdr->dst_ipaddr, &dst); net_ipaddr_copy(&arp_hdr->src_ipaddr, &src); pkt2 = prepare_arp_reply(iface, pkt, &hwaddr); if (!pkt2) { printk("ARP reply generation failed."); return false; } /* The pending packet should now be sent */ switch (net_arp_input(pkt2)) { case NET_OK: case NET_CONTINUE: break; case NET_DROP: break; } /* Yielding so that network interface TX thread can proceed. */ k_yield(); if (send_status < 0) { printk("ARP reply was not sent\n"); return false; } if (pkt->ref != 1) { printk("ARP cache should no longer own the original packet\n"); return false; } net_pkt_unref(pkt); /* Then feed in ARP request */ pkt = net_pkt_get_reserve_rx(sizeof(struct net_eth_hdr), K_FOREVER); if (!pkt) { printk("Out of mem RX request\n"); return false; } frag = net_pkt_get_frag(pkt, K_FOREVER); if (!frag) { printk("Out of mem DATA request\n"); return false; } net_pkt_frag_add(pkt, frag); net_pkt_set_iface(pkt, iface); send_status = -EINVAL; arp_hdr = NET_ARP_HDR(pkt); net_buf_add(frag, sizeof(struct net_arp_hdr)); net_ipaddr_copy(&arp_hdr->dst_ipaddr, &src); net_ipaddr_copy(&arp_hdr->src_ipaddr, &dst); setup_eth_header(iface, pkt, &hwaddr, NET_ETH_PTYPE_ARP); pkt2 = prepare_arp_request(iface, pkt, &hwaddr); if (!pkt2) { printk("ARP request generation failed."); return false; } req_test = true; switch (net_arp_input(pkt2)) { case NET_OK: case NET_CONTINUE: break; case NET_DROP: break; } /* Yielding so that network interface TX thread can proceed. */ k_yield(); if (send_status < 0) { printk("ARP req was not sent\n"); return false; } net_pkt_unref(pkt); printk("Network ARP checks passed\n"); return true; }
void run_tests(void) { k_thread_priority_set(k_current_get(), K_PRIO_COOP(7)); test_failed = false; struct net_conn_handle *handlers[CONFIG_NET_MAX_CONN]; struct net_if *iface = net_if_get_default(); struct net_if_addr *ifaddr; struct ud *ud; int ret, i = 0; bool st; struct sockaddr_in6 any_addr6; const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT; struct sockaddr_in6 my_addr6; struct in6_addr in6addr_my = { { { 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x1 } } }; struct sockaddr_in6 peer_addr6; struct in6_addr in6addr_peer = { { { 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0x4e, 0x11, 0, 0, 0x2 } } }; struct sockaddr_in any_addr4; const struct in_addr in4addr_any = { { { 0 } } }; struct sockaddr_in my_addr4; struct in_addr in4addr_my = { { { 192, 0, 2, 1 } } }; struct sockaddr_in peer_addr4; struct in_addr in4addr_peer = { { { 192, 0, 2, 9 } } }; net_ipaddr_copy(&any_addr6.sin6_addr, &in6addr_any); any_addr6.sin6_family = AF_INET6; net_ipaddr_copy(&my_addr6.sin6_addr, &in6addr_my); my_addr6.sin6_family = AF_INET6; net_ipaddr_copy(&peer_addr6.sin6_addr, &in6addr_peer); peer_addr6.sin6_family = AF_INET6; net_ipaddr_copy(&any_addr4.sin_addr, &in4addr_any); any_addr4.sin_family = AF_INET; net_ipaddr_copy(&my_addr4.sin_addr, &in4addr_my); my_addr4.sin_family = AF_INET; net_ipaddr_copy(&peer_addr4.sin_addr, &in4addr_peer); peer_addr4.sin_family = AF_INET; k_sem_init(&recv_lock, 0, UINT_MAX); ifaddr = net_if_ipv6_addr_add(iface, &in6addr_my, NET_ADDR_MANUAL, 0); if (!ifaddr) { printk("Cannot add %s to interface %p\n", net_sprint_ipv6_addr(&in6addr_my), iface); zassert_true(0, "exiting"); } ifaddr = net_if_ipv4_addr_add(iface, &in4addr_my, NET_ADDR_MANUAL, 0); if (!ifaddr) { printk("Cannot add %s to interface %p\n", net_sprint_ipv4_addr(&in4addr_my), iface); zassert_true(0, "exiting"); } #define REGISTER(family, raddr, laddr, rport, lport) \ ({ \ static struct ud user_data; \ \ user_data.remote_addr = (struct sockaddr *)raddr; \ user_data.local_addr = (struct sockaddr *)laddr; \ user_data.remote_port = rport; \ user_data.local_port = lport; \ user_data.test = "DST="#raddr"-SRC="#laddr"-RP="#rport \ "-LP="#lport; \ \ set_port(family, (struct sockaddr *)raddr, \ (struct sockaddr *)laddr, rport, lport); \ \ ret = net_udp_register((struct sockaddr *)raddr, \ (struct sockaddr *)laddr, \ rport, lport, \ test_ok, &user_data, \ &handlers[i]); \ if (ret) { \ printk("UDP register %s failed (%d)\n", \ user_data.test, ret); \ zassert_true(0, "exiting"); \ } \ user_data.handle = handlers[i++]; \ &user_data; \ }) #define REGISTER_FAIL(raddr, laddr, rport, lport) \ ret = net_udp_register((struct sockaddr *)raddr, \ (struct sockaddr *)laddr, \ rport, lport, \ test_fail, INT_TO_POINTER(0), NULL); \ if (!ret) { \ printk("UDP register invalid match %s failed\n", \ "DST="#raddr"-SRC="#laddr"-RP="#rport"-LP="#lport); \ zassert_true(0, "exiting"); \ } #define UNREGISTER(ud) \ ret = net_udp_unregister(ud->handle); \ if (ret) { \ printk("UDP unregister %p failed (%d)\n", ud->handle, \ ret); \ zassert_true(0, "exiting"); \ } #define TEST_IPV6_OK(ud, raddr, laddr, rport, lport) \ st = send_ipv6_udp_msg(iface, raddr, laddr, rport, lport, ud, \ false); \ if (!st) { \ printk("%d: UDP test \"%s\" fail\n", __LINE__, \ ud->test); \ zassert_true(0, "exiting"); \ } #define TEST_IPV6_LONG_OK(ud, raddr, laddr, rport, lport) \ st = send_ipv6_udp_long_msg(iface, raddr, laddr, rport, lport, ud, \ false); \ if (!st) { \ printk("%d: UDP long test \"%s\" fail\n", __LINE__, \ ud->test); \ zassert_true(0, "exiting"); \ } #define TEST_IPV4_OK(ud, raddr, laddr, rport, lport) \ st = send_ipv4_udp_msg(iface, raddr, laddr, rport, lport, ud, \ false); \ if (!st) { \ printk("%d: UDP test \"%s\" fail\n", __LINE__, \ ud->test); \ zassert_true(0, "exiting"); \ } #define TEST_IPV6_FAIL(ud, raddr, laddr, rport, lport) \ st = send_ipv6_udp_msg(iface, raddr, laddr, rport, lport, ud, \ true); \ if (!st) { \ printk("%d: UDP neg test \"%s\" fail\n", __LINE__, \ ud->test); \ zassert_true(0, "exiting"); \ } #define TEST_IPV4_FAIL(ud, raddr, laddr, rport, lport) \ st = send_ipv4_udp_msg(iface, raddr, laddr, rport, lport, ud, \ true); \ if (!st) { \ printk("%d: UDP neg test \"%s\" fail\n", __LINE__, \ ud->test); \ zassert_true(0, "exiting"); \ } ud = REGISTER(AF_INET6, &any_addr6, &any_addr6, 1234, 4242); TEST_IPV6_OK(ud, &in6addr_peer, &in6addr_my, 1234, 4242); TEST_IPV6_OK(ud, &in6addr_peer, &in6addr_my, 1234, 4242); TEST_IPV6_LONG_OK(ud, &in6addr_peer, &in6addr_my, 1234, 4242); TEST_IPV6_LONG_OK(ud, &in6addr_peer, &in6addr_my, 1234, 4242); TEST_IPV6_FAIL(ud, &in6addr_peer, &in6addr_my, 1234, 61400); TEST_IPV6_FAIL(ud, &in6addr_peer, &in6addr_my, 1234, 61400); UNREGISTER(ud); ud = REGISTER(AF_INET, &any_addr4, &any_addr4, 1234, 4242); TEST_IPV4_OK(ud, &in4addr_peer, &in4addr_my, 1234, 4242); TEST_IPV4_OK(ud, &in4addr_peer, &in4addr_my, 1234, 4242); TEST_IPV4_FAIL(ud, &in4addr_peer, &in4addr_my, 1234, 4325); TEST_IPV4_FAIL(ud, &in4addr_peer, &in4addr_my, 1234, 4325); UNREGISTER(ud); ud = REGISTER(AF_INET6, &any_addr6, NULL, 1234, 4242); TEST_IPV6_OK(ud, &in6addr_peer, &in6addr_my, 1234, 4242); TEST_IPV6_OK(ud, &in6addr_peer, &in6addr_my, 1234, 4242); TEST_IPV6_FAIL(ud, &in6addr_peer, &in6addr_my, 1234, 61400); TEST_IPV6_FAIL(ud, &in6addr_peer, &in6addr_my, 1234, 61400); UNREGISTER(ud); ud = REGISTER(AF_INET6, NULL, &any_addr6, 1234, 4242); TEST_IPV6_OK(ud, &in6addr_peer, &in6addr_my, 1234, 4242); TEST_IPV6_OK(ud, &in6addr_peer, &in6addr_my, 1234, 4242); TEST_IPV6_LONG_OK(ud, &in6addr_peer, &in6addr_my, 1234, 4242); TEST_IPV6_LONG_OK(ud, &in6addr_peer, &in6addr_my, 1234, 4242); TEST_IPV6_FAIL(ud, &in6addr_peer, &in6addr_my, 1234, 61400); TEST_IPV6_FAIL(ud, &in6addr_peer, &in6addr_my, 1234, 61400); UNREGISTER(ud); ud = REGISTER(AF_INET6, &peer_addr6, &my_addr6, 1234, 4242); TEST_IPV6_OK(ud, &in6addr_peer, &in6addr_my, 1234, 4242); TEST_IPV6_FAIL(ud, &in6addr_peer, &in6addr_my, 1234, 4243); ud = REGISTER(AF_INET, &peer_addr4, &my_addr4, 1234, 4242); TEST_IPV4_OK(ud, &in4addr_peer, &in4addr_my, 1234, 4242); TEST_IPV4_FAIL(ud, &in4addr_peer, &in4addr_my, 1234, 4243); ud = REGISTER(AF_UNSPEC, NULL, NULL, 1234, 42423); TEST_IPV4_OK(ud, &in4addr_peer, &in4addr_my, 1234, 42423); TEST_IPV6_OK(ud, &in6addr_peer, &in6addr_my, 1234, 42423); ud = REGISTER(AF_UNSPEC, NULL, NULL, 1234, 0); TEST_IPV4_OK(ud, &in4addr_peer, &in4addr_my, 1234, 42422); TEST_IPV6_OK(ud, &in6addr_peer, &in6addr_my, 1234, 42422); TEST_IPV4_OK(ud, &in4addr_peer, &in4addr_my, 1234, 42422); TEST_IPV6_OK(ud, &in6addr_peer, &in6addr_my, 1234, 42422); TEST_IPV4_FAIL(ud, &in4addr_peer, &in4addr_my, 12345, 42421); TEST_IPV6_FAIL(ud, &in6addr_peer, &in6addr_my, 12345, 42421); ud = REGISTER(AF_UNSPEC, NULL, NULL, 0, 0); TEST_IPV4_OK(ud, &in4addr_peer, &in4addr_my, 12345, 42421); TEST_IPV6_OK(ud, &in6addr_peer, &in6addr_my, 12345, 42421); TEST_IPV6_LONG_OK(ud, &in6addr_peer, &in6addr_my, 12345, 42421); /* Remote addr same as local addr, these two will never match */ REGISTER(AF_INET6, &my_addr6, NULL, 1234, 4242); REGISTER(AF_INET, &my_addr4, NULL, 1234, 4242); /* IPv4 remote addr and IPv6 remote addr, impossible combination */ REGISTER_FAIL(&my_addr4, &my_addr6, 1234, 4242); /**TESTPOINT: Check if tests passed*/ zassert_false(fail, "Tests failed"); i--; while (i) { ret = net_udp_unregister(handlers[i]); if (ret < 0 && ret != -ENOENT) { printk("Cannot unregister udp %d\n", i); zassert_true(0, "exiting"); } i--; } zassert_true((net_udp_unregister(NULL) < 0), "Unregister udp failed"); zassert_false(test_failed, "udp tests failed"); }