LWIPBP3595Interface library for mbed-os.
Dependents: LWIPBP3595Interface_STA_for_mbed-os
Fork of LWIPBP3595Interface by
Diff: lwip_wifi_stack.c
- Revision:
- 3:2ff2514e4fca
- Parent:
- 2:c7e325599570
- Child:
- 5:d03489ec5033
diff -r c7e325599570 -r 2ff2514e4fca lwip_wifi_stack.c --- a/lwip_wifi_stack.c Tue Sep 13 09:31:41 2016 +0000 +++ b/lwip_wifi_stack.c Thu Oct 27 09:30:15 2016 +0000 @@ -29,7 +29,19 @@ #include "lwip/tcpip.h" #include "lwip/tcp.h" #include "lwip/ip.h" +#include "lwip/mld6.h" +#include "lwip/dns.h" +#include "lwip/udp.h" +#include "emac_api.h" + +#if DEVICE_EMAC + #define MBED_NETIF_INIT_FN emac_lwip_if_init +#else + #define MBED_NETIF_INIT_FN wifi_arch_enetif_init +#endif + +#define DHCP_TIMEOUT 15000 /* Static arena of sockets */ static struct lwip_socket { @@ -43,12 +55,14 @@ void *data; } lwip_arena[MEMP_NUM_NETCONN]; -static void lwip_arena_init(void) +static bool lwip_connected = false; + +static void mbed_lwip_wifi_arena_init(void) { memset(lwip_arena, 0, sizeof lwip_arena); } -static struct lwip_socket *lwip_arena_alloc(void) +static struct lwip_socket *mbed_lwip_wifi_arena_alloc(void) { sys_prot_t prot = sys_arch_protect(); @@ -66,12 +80,12 @@ return 0; } -static void lwip_arena_dealloc(struct lwip_socket *s) +static void mbed_lwip_wifi_arena_dealloc(struct lwip_socket *s) { s->in_use = false; } -static void lwip_socket_callback(struct netconn *nc, enum netconn_evt eh, u16_t len) +static void mbed_lwip_wifi_socket_callback(struct netconn *nc, enum netconn_evt eh, u16_t len) { sys_prot_t prot = sys_arch_protect(); @@ -89,113 +103,424 @@ /* TCP/IP and Network Interface Initialisation */ static struct netif lwip_netif; +static bool lwip_dhcp = false; +static char lwip_mac_address[NSAPI_MAC_SIZE] = "\0"; -static char lwip_ip_addr[NSAPI_IP_SIZE] = "\0"; -static char lwip_mac_addr[NSAPI_MAC_SIZE] = "\0"; +#if !LWIP_IPV4 || !LWIP_IPV6 +static bool all_zeros(const uint8_t *p, int len) +{ + for (int i = 0; i < len; i++) { + if (p[i]) { + return false; + } + } + + return true; +} +#endif + +static bool convert_mbed_addr_to_lwip(ip_addr_t *out, const nsapi_addr_t *in) +{ +#if LWIP_IPV6 + if (in->version == NSAPI_IPv6) { + IP_SET_TYPE(out, IPADDR_TYPE_V6); + MEMCPY(ip_2_ip6(out), in->bytes, sizeof(ip6_addr_t)); + return true; + } +#if !LWIP_IPV4 + /* For bind() and other purposes, need to accept "null" of other type */ + /* (People use IPv4 0.0.0.0 as a general null) */ + if (in->version == NSAPI_IPv4 && all_zeros(in->bytes, 4)) { + ip_addr_set_zero_ip6(out); + return true; + } +#endif +#endif + +#if LWIP_IPV4 + if (in->version == NSAPI_IPv4) { + IP_SET_TYPE(out, IPADDR_TYPE_V4); + MEMCPY(ip_2_ip4(out), in->bytes, sizeof(ip4_addr_t)); + return true; + } +#if !LWIP_IPV6 + /* For symmetry with above, accept IPv6 :: as a general null */ + if (in->version == NSAPI_IPv6 && all_zeros(in->bytes, 16)) { + ip_addr_set_zero_ip4(out); + return true; + } +#endif +#endif + + return false; +} + +static bool convert_lwip_addr_to_mbed(nsapi_addr_t *out, const ip_addr_t *in) +{ +#if LWIP_IPV6 + if (IP_IS_V6(in)) { + out->version = NSAPI_IPv6; + MEMCPY(out->bytes, ip_2_ip6(in), sizeof(ip6_addr_t)); + return true; + } +#endif +#if LWIP_IPV4 + if (IP_IS_V4(in)) { + out->version = NSAPI_IPv4; + MEMCPY(out->bytes, ip_2_ip4(in), sizeof(ip4_addr_t)); + return true; + } +#endif + return false; +} + +static const ip_addr_t *mbed_lwip_wifi_get_ipv4_addr(const struct netif *netif) +{ +#if LWIP_IPV4 + if (!netif_is_up(netif)) { + return NULL; + } + + if (!ip4_addr_isany(netif_ip4_addr(netif))) { + return netif_ip_addr4(netif); + } +#endif + + return NULL; +} + +static const ip_addr_t *mbed_lwip_wifi_get_ipv6_addr(const struct netif *netif) +{ +#if LWIP_IPV6 + if (!netif_is_up(netif)) { + return NULL; + } + + for (int i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && + !ip6_addr_islinklocal(netif_ip6_addr(netif, i))) { + return netif_ip_addr6(netif, i); + } + } +#endif + + return NULL; + +} + +const ip_addr_t *mbed_lwip_wifi_get_ip_addr(bool any_addr, const struct netif *netif) +{ + const ip_addr_t *pref_ip_addr = 0; + const ip_addr_t *npref_ip_addr = 0; + +#if IP_VERSION_PREF == PREF_IPV4 + pref_ip_addr = mbed_lwip_wifi_get_ipv4_addr(netif); + npref_ip_addr = mbed_lwip_wifi_get_ipv6_addr(netif); +#else + pref_ip_addr = mbed_lwip_wifi_get_ipv6_addr(netif); + npref_ip_addr = mbed_lwip_wifi_get_ipv4_addr(netif); +#endif + + if (pref_ip_addr) { + return pref_ip_addr; + } else if (npref_ip_addr && any_addr) { + return npref_ip_addr; + } + + return NULL; +} + +#if LWIP_IPV6 +void add_dns_addr(struct netif *lwip_netif) +{ + const ip_addr_t *ip_addr = mbed_lwip_wifi_get_ip_addr(true, lwip_netif); + if (ip_addr) { + if (IP_IS_V6(ip_addr)) { + const ip_addr_t *dns_ip_addr; + bool dns_addr_exists = false; + + for (char numdns = 0; numdns < DNS_MAX_SERVERS; numdns++) { + dns_ip_addr = dns_getserver(numdns); + if (!ip_addr_isany(dns_ip_addr)) { + dns_addr_exists = true; + break; + } + } + + if (!dns_addr_exists) { + /* 2001:4860:4860::8888 google */ + ip_addr_t ipv6_dns_addr = IPADDR6_INIT( + PP_HTONL(0x20014860UL), + PP_HTONL(0x48600000UL), + PP_HTONL(0x00000000UL), + PP_HTONL(0x00008888UL)); + dns_setserver(0, &ipv6_dns_addr); + } + } + } +} +#endif static sys_sem_t lwip_tcpip_inited; -static void lwip_tcpip_init_irq(void *eh) +static void mbed_lwip_wifi_tcpip_init_irq(void *eh) { sys_sem_signal(&lwip_tcpip_inited); } static sys_sem_t lwip_netif_linked; -static void lwip_netif_link_irq(struct netif *lwip_netif) +static void mbed_lwip_wifi_netif_link_irq(struct netif *lwip_netif) { if (netif_is_link_up(lwip_netif)) { sys_sem_signal(&lwip_netif_linked); } } -static sys_sem_t lwip_netif_up; -static void lwip_netif_status_irq(struct netif *lwip_netif) +static sys_sem_t lwip_netif_has_addr; +static void mbed_lwip_wifi_netif_status_irq(struct netif *lwip_netif) { - if (netif_is_up(lwip_netif)) { - strcpy(lwip_ip_addr, inet_ntoa(lwip_netif->ip_addr)); - sys_sem_signal(&lwip_netif_up); + static bool any_addr = true; + + // Indicates that has address + if (any_addr == true && mbed_lwip_wifi_get_ip_addr(true, lwip_netif)) { + sys_sem_signal(&lwip_netif_has_addr); + any_addr = false; + return; + } + + // Indicates that has preferred address + if (mbed_lwip_wifi_get_ip_addr(false, lwip_netif)) { + sys_sem_signal(&lwip_netif_has_addr); } } -static void lwip_set_mac_address(void) +static void mbed_lwip_wifi_set_mac_address(void) { - snprintf(lwip_mac_addr, 19, "%02x:%02x:%02x:%02x:%02x:%02x", lwip_netif.hwaddr[0], lwip_netif.hwaddr[1], + snprintf(lwip_mac_address, 19, "%02x:%02x:%02x:%02x:%02x:%02x", lwip_netif.hwaddr[0], lwip_netif.hwaddr[1], lwip_netif.hwaddr[2], lwip_netif.hwaddr[3], lwip_netif.hwaddr[4], lwip_netif.hwaddr[5]); } +/* LWIP interface implementation */ +const char *mbed_lwip_wifi_get_mac_address(void) +{ + return lwip_mac_address[0] ? lwip_mac_address : 0; +} -/* LWIP interface implementation */ -const char *lwip_wifi_get_mac_address(void) +char *mbed_lwip_wifi_get_ip_address(char *buf, int buflen) { - return lwip_mac_addr[0] ? lwip_mac_addr : 0; + const ip_addr_t *addr = mbed_lwip_wifi_get_ip_addr(true, &lwip_netif); + if (!addr) { + return NULL; + } +#if LWIP_IPV6 + if (IP_IS_V6(addr)) { + return ip6addr_ntoa_r(ip_2_ip6(addr), buf, buflen); + } +#endif +#if LWIP_IPV4 + if (IP_IS_V4(addr)) { + return ip4addr_ntoa_r(ip_2_ip4(addr), buf, buflen); + } +#endif + return NULL; } -const char *lwip_wifi_get_ip_address(void) +const char *mbed_lwip_wifi_get_netmask(char *buf, int buflen) { - return lwip_ip_addr[0] ? lwip_ip_addr : 0; +#if LWIP_IPV4 + const ip4_addr_t *addr = netif_ip4_netmask(&lwip_netif); + if (!ip4_addr_isany(addr)) { + return ip4addr_ntoa_r(addr, buf, buflen); + } else { + return NULL; + } +#else + return NULL; +#endif } -int lwip_wifi_init(void) +char *mbed_lwip_wifi_get_gateway(char *buf, int buflen) { - // Check if we've already connected - if (!lwip_wifi_get_mac_address()) { +#if LWIP_IPV4 + const ip4_addr_t *addr = netif_ip4_gw(&lwip_netif); + if (!ip4_addr_isany(addr)) { + return ip4addr_ntoa_r(addr, buf, buflen); + } else { + return NULL; + } +#else + return NULL; +#endif +} + +int mbed_lwip_wifi_init(emac_interface_t *emac) +{ + // Check if we've already brought up lwip + if (!mbed_lwip_wifi_get_mac_address()) { // Set up network sys_sem_new(&lwip_tcpip_inited, 0); sys_sem_new(&lwip_netif_linked, 0); - sys_sem_new(&lwip_netif_up, 0); + sys_sem_new(&lwip_netif_has_addr, 0); - tcpip_init(lwip_tcpip_init_irq, NULL); + tcpip_init(mbed_lwip_wifi_tcpip_init_irq, NULL); sys_arch_sem_wait(&lwip_tcpip_inited, 0); memset(&lwip_netif, 0, sizeof lwip_netif); - netif_add(&lwip_netif, 0, 0, 0, NULL, wifi_arch_enetif_init, tcpip_input); + if (!netif_add(&lwip_netif, +#if LWIP_IPV4 + 0, 0, 0, +#endif + emac, MBED_NETIF_INIT_FN, tcpip_input)) { + return NSAPI_ERROR_DEVICE_ERROR; + } + netif_set_default(&lwip_netif); - netif_set_link_callback (&lwip_netif, lwip_netif_link_irq); - netif_set_status_callback(&lwip_netif, lwip_netif_status_irq); - lwip_set_mac_address(); + netif_set_link_callback(&lwip_netif, mbed_lwip_wifi_netif_link_irq); + netif_set_status_callback(&lwip_netif, mbed_lwip_wifi_netif_status_irq); + mbed_lwip_wifi_set_mac_address(); + +#if !DEVICE_EMAC wifi_arch_enable_interrupts(); - return 0; +#endif } - return -1; + return NSAPI_ERROR_OK; } -int lwip_wifi_bringup(void) +int mbed_lwip_wifi_bringup(bool dhcp, const char *ip, const char *netmask, const char *gw) { + // Check if we've already connected + if (lwip_connected) { + return NSAPI_ERROR_PARAMETER; + } + + if(mbed_lwip_wifi_init(NULL) != NSAPI_ERROR_OK) { + return NSAPI_ERROR_DEVICE_ERROR; + } + // Zero out socket set - lwip_arena_init(); + mbed_lwip_wifi_arena_init(); + +#if LWIP_IPV6 + netif_create_ip6_linklocal_address(&lwip_netif, 1/*from MAC*/); +#if LWIP_IPV6_MLD + /* + * For hardware/netifs that implement MAC filtering. + * All-nodes link-local is handled by default, so we must let the hardware know + * to allow multicast packets in. + * Should set mld_mac_filter previously. */ + if (lwip_netif.mld_mac_filter != NULL) { + ip6_addr_t ip6_allnodes_ll; + ip6_addr_set_allnodes_linklocal(&ip6_allnodes_ll); + lwip_netif.mld_mac_filter(&lwip_netif, &ip6_allnodes_ll, MLD6_ADD_MAC_FILTER); + } +#endif /* LWIP_IPV6_MLD */ + +#if LWIP_IPV6_AUTOCONFIG + /* IPv6 address autoconfiguration not enabled by default */ + lwip_netif.ip6_autoconfig_enabled = 1; +#endif /* LWIP_IPV6_AUTOCONFIG */ + +#endif + + u32_t ret; + if (!netif_is_link_up(&lwip_netif)) { + ret = sys_arch_sem_wait(&lwip_netif_linked, 15000); + + if (ret == SYS_ARCH_TIMEOUT) { + return NSAPI_ERROR_NO_CONNECTION; + } + } + +#if LWIP_IPV4 + if (!dhcp) { + ip4_addr_t ip_addr; + ip4_addr_t netmask_addr; + ip4_addr_t gw_addr; + + if (!inet_aton(ip, &ip_addr) || + !inet_aton(netmask, &netmask_addr) || + !inet_aton(gw, &gw_addr)) { + return NSAPI_ERROR_PARAMETER; + } + + netif_set_addr(&lwip_netif, &ip_addr, &netmask_addr, &gw_addr); + } +#endif + + netif_set_up(&lwip_netif); + +#if LWIP_IPV4 // Connect to the network - dhcp_start(&lwip_netif); + lwip_dhcp = dhcp; + + if (lwip_dhcp) { + err_t err = dhcp_start(&lwip_netif); + if (err) { + return NSAPI_ERROR_DHCP_FAILURE; + } + } +#endif - // Wait for an IP Address - u32_t ret = sys_arch_sem_wait(&lwip_netif_up, 30000); - if (ret == SYS_ARCH_TIMEOUT) { - return NSAPI_ERROR_DHCP_FAILURE; + // If doesn't have address + if (!mbed_lwip_wifi_get_ip_addr(true, &lwip_netif)) { + ret = sys_arch_sem_wait(&lwip_netif_has_addr, 15000); + if (ret == SYS_ARCH_TIMEOUT) { + return NSAPI_ERROR_DHCP_FAILURE; + } + lwip_connected = true; } +#if ADDR_TIMEOUT + // If address is not for preferred stack waits a while to see + // if preferred stack address is acquired + if (!mbed_lwip_wifi_get_ip_addr(false, &lwip_netif)) { + ret = sys_arch_sem_wait(&lwip_netif_has_addr, ADDR_TIMEOUT * 1000); + } +#endif + +#if LWIP_IPV6 + add_dns_addr(&lwip_netif); +#endif + return 0; } -void lwip_wifi_bringdown(void) +int mbed_lwip_wifi_bringdown(void) { + // Check if we've connected + if (!lwip_connected) { + return NSAPI_ERROR_PARAMETER; + } + +#if LWIP_IPV4 // Disconnect from the network - dhcp_release(&lwip_netif); - dhcp_stop(&lwip_netif); - lwip_ip_addr[0] = '\0'; + if (lwip_dhcp) { + dhcp_release(&lwip_netif); + dhcp_stop(&lwip_netif); + lwip_dhcp = false; + } else { + netif_set_down(&lwip_netif); + } +#endif + + lwip_connected = false; + // TO DO - actually remove addresses from stack, and shut down properly + return 0; } - /* LWIP error remapping */ -static int lwip_err_remap(err_t err) { +static int mbed_lwip_wifi_err_remap(err_t err) { switch (err) { case ERR_OK: + case ERR_CLSD: + case ERR_RST: return 0; case ERR_MEM: return NSAPI_ERROR_NO_MEMORY; case ERR_CONN: - case ERR_CLSD: return NSAPI_ERROR_NO_CONNECTION; case ERR_TIMEOUT: case ERR_RTE: @@ -212,44 +537,83 @@ } } - /* LWIP network stack implementation */ -static nsapi_addr_t lwip_getaddr(nsapi_stack_t *stack) +static int mbed_lwip_wifi_gethostbyname(nsapi_stack_t *stack, const char *host, nsapi_addr_t *addr, nsapi_version_t version) { - if (!lwip_wifi_get_ip_address()) { - return (nsapi_addr_t){0}; - } + ip_addr_t lwip_addr; - nsapi_addr_t addr; - addr.version = NSAPI_IPv4; - inet_aton(lwip_wifi_get_ip_address(), (ip_addr_t *)addr.bytes); - return addr; -} +#if LWIP_IPV4 && LWIP_IPV6 + u8_t addr_type; + if (version == NSAPI_UNSPEC) { + const ip_addr_t *ip_addr; + ip_addr = mbed_lwip_wifi_get_ip_addr(true, &lwip_netif); + if (IP_IS_V6(ip_addr)) { + addr_type = NETCONN_DNS_IPV6; + } else { + addr_type = NETCONN_DNS_IPV4; + } + } else if (version == NSAPI_IPv4) { + addr_type = NETCONN_DNS_IPV4; + } else if (version == NSAPI_IPv6) { + addr_type = NETCONN_DNS_IPV6; + } + err_t err = netconn_gethostbyname_addrtype(host, &lwip_addr, addr_type); +#elif LWIP_IPV4 + if (version != NSAPI_IPv4 && version != NSAPI_UNSPEC) { + return NSAPI_ERROR_DNS_FAILURE; + } + err_t err = netconn_gethostbyname(host, &lwip_addr); +#elif LWIP_IPV6 + if (version != NSAPI_IPv6 && version != NSAPI_UNSPEC) { + return NSAPI_ERROR_DNS_FAILURE; + } + err_t err = netconn_gethostbyname(host, &lwip_addr); +#endif -static int lwip_gethostbyname(nsapi_stack_t *stack, nsapi_addr_t *addr, const char *host) -{ - err_t err = netconn_gethostbyname(host, (ip_addr_t *)addr->bytes); if (err != ERR_OK) { return NSAPI_ERROR_DNS_FAILURE; } - addr->version = NSAPI_IPv4; + convert_lwip_addr_to_mbed(addr, &lwip_addr); + return 0; } -static int lwip_socket_open(nsapi_stack_t *stack, nsapi_socket_t *handle, nsapi_protocol_t proto) +static int mbed_lwip_wifi_socket_open(nsapi_stack_t *stack, nsapi_socket_t *handle, nsapi_protocol_t proto) { - struct lwip_socket *s = lwip_arena_alloc(); + // check if network is connected + if (!lwip_connected) { + return NSAPI_ERROR_NO_CONNECTION; + } + + // allocate a socket + struct lwip_socket *s = mbed_lwip_wifi_arena_alloc(); if (!s) { return NSAPI_ERROR_NO_SOCKET; } - s->conn = netconn_new_with_callback( - proto == NSAPI_TCP ? NETCONN_TCP : NETCONN_UDP, - lwip_socket_callback); + u8_t lwip_proto = proto == NSAPI_TCP ? NETCONN_TCP : NETCONN_UDP; + +#if LWIP_IPV6 && LWIP_IPV4 + const ip_addr_t *ip_addr; + ip_addr = mbed_lwip_wifi_get_ip_addr(true, &lwip_netif); + + if (IP_IS_V6(ip_addr)) { + // Enable IPv6 (or dual-stack). LWIP dual-stack support is + // currently incomplete as of 2.0.0rc2 - eg we will only be able + // to do a UDP sendto to an address matching the type selected + // here. Matching "get_ip_addr" and DNS logic, use v4 if + // available. + lwip_proto |= NETCONN_TYPE_IPV6; + } +#elif LWIP_IPV6 + lwip_proto |= NETCONN_TYPE_IPV6; +#endif + + s->conn = netconn_new_with_callback(lwip_proto, mbed_lwip_wifi_socket_callback); if (!s->conn) { - lwip_arena_dealloc(s); + mbed_lwip_wifi_arena_dealloc(s); return NSAPI_ERROR_NO_SOCKET; } @@ -258,82 +622,95 @@ return 0; } -static int lwip_socket_close(nsapi_stack_t *stack, nsapi_socket_t handle) +static int mbed_lwip_wifi_socket_close(nsapi_stack_t *stack, nsapi_socket_t handle) { struct lwip_socket *s = (struct lwip_socket *)handle; err_t err = netconn_delete(s->conn); - lwip_arena_dealloc(s); - return lwip_err_remap(err); + mbed_lwip_wifi_arena_dealloc(s); + return mbed_lwip_wifi_err_remap(err); } - -static int lwip_socket_bind(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t addr, uint16_t port) +static int mbed_lwip_wifi_socket_bind(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t addr, uint16_t port) { struct lwip_socket *s = (struct lwip_socket *)handle; - if (addr.version != NSAPI_IPv4) { + ip_addr_t ip_addr; + + if ((s->conn->type == NETCONN_TCP && s->conn->pcb.tcp->local_port != 0) || + (s->conn->type == NETCONN_UDP && s->conn->pcb.udp->local_port != 0)) { return NSAPI_ERROR_PARAMETER; } - err_t err = netconn_bind(s->conn, (ip_addr_t *)addr.bytes, port); - return lwip_err_remap(err); + if (!convert_mbed_addr_to_lwip(&ip_addr, &addr)) { + return NSAPI_ERROR_PARAMETER; + } + + err_t err = netconn_bind(s->conn, &ip_addr, port); + return mbed_lwip_wifi_err_remap(err); } -static int lwip_socket_listen(nsapi_stack_t *stack, nsapi_socket_t handle, int backlog) +static int mbed_lwip_wifi_socket_listen(nsapi_stack_t *stack, nsapi_socket_t handle, int backlog) { struct lwip_socket *s = (struct lwip_socket *)handle; err_t err = netconn_listen_with_backlog(s->conn, backlog); - return lwip_err_remap(err); + return mbed_lwip_wifi_err_remap(err); } -static int lwip_socket_connect(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t addr, uint16_t port) +static int mbed_lwip_wifi_socket_connect(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t addr, uint16_t port) { struct lwip_socket *s = (struct lwip_socket *)handle; - if (addr.version != NSAPI_IPv4) { + ip_addr_t ip_addr; + + if (!convert_mbed_addr_to_lwip(&ip_addr, &addr)) { return NSAPI_ERROR_PARAMETER; } netconn_set_nonblocking(s->conn, false); - err_t err = netconn_connect(s->conn, (ip_addr_t *)addr.bytes, port); + err_t err = netconn_connect(s->conn, &ip_addr, port); netconn_set_nonblocking(s->conn, true); - return lwip_err_remap(err); + return mbed_lwip_wifi_err_remap(err); } -static int lwip_socket_accept(nsapi_stack_t *stack, nsapi_socket_t server, nsapi_socket_t *handle, nsapi_addr_t *addr, uint16_t *port) +static int mbed_lwip_wifi_socket_accept(nsapi_stack_t *stack, nsapi_socket_t server, nsapi_socket_t *handle, nsapi_addr_t *addr, uint16_t *port) { struct lwip_socket *s = (struct lwip_socket *)server; - struct lwip_socket *ns = lwip_arena_alloc(); + struct lwip_socket *ns = mbed_lwip_wifi_arena_alloc(); + if (!ns) { + return NSAPI_ERROR_NO_SOCKET; + } err_t err = netconn_accept(s->conn, &ns->conn); if (err != ERR_OK) { - lwip_arena_dealloc(ns); - return lwip_err_remap(err); + mbed_lwip_wifi_arena_dealloc(ns); + return mbed_lwip_wifi_err_remap(err); } netconn_set_recvtimeout(ns->conn, 1); *(struct lwip_socket **)handle = ns; - (void) netconn_peer(ns->conn, (ip_addr_t *)addr->bytes, port); - addr->version = NSAPI_IPv4; + ip_addr_t peer_addr; + (void) netconn_peer(ns->conn, &peer_addr, port); + convert_lwip_addr_to_mbed(addr, &peer_addr); return 0; } -static int lwip_socket_send(nsapi_stack_t *stack, nsapi_socket_t handle, const void *data, unsigned size) +static int mbed_lwip_wifi_socket_send(nsapi_stack_t *stack, nsapi_socket_t handle, const void *data, unsigned size) { struct lwip_socket *s = (struct lwip_socket *)handle; + size_t bytes_written = 0; - err_t err = netconn_write(s->conn, data, size, NETCONN_COPY); + err_t err = netconn_write_partly(s->conn, data, size, NETCONN_COPY, &bytes_written); if (err != ERR_OK) { - return lwip_err_remap(err); + return mbed_lwip_wifi_err_remap(err); } - return size; + return (int)bytes_written; } -static int lwip_socket_recv(nsapi_stack_t *stack, nsapi_socket_t handle, void *data, unsigned size) +static int mbed_lwip_wifi_socket_recv(nsapi_stack_t *stack, nsapi_socket_t handle, void *data, unsigned size) { struct lwip_socket *s = (struct lwip_socket *)handle; @@ -342,7 +719,7 @@ s->offset = 0; if (err != ERR_OK) { - return (err == ERR_CLSD) ? 0 : lwip_err_remap(err); + return mbed_lwip_wifi_err_remap(err); } } @@ -357,10 +734,12 @@ return recv; } -static int lwip_socket_sendto(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t addr, uint16_t port, const void *data, unsigned size) +static int mbed_lwip_wifi_socket_sendto(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t addr, uint16_t port, const void *data, unsigned size) { struct lwip_socket *s = (struct lwip_socket *)handle; - if (addr.version != NSAPI_IPv4) { + ip_addr_t ip_addr; + + if (!convert_mbed_addr_to_lwip(&ip_addr, &addr)) { return NSAPI_ERROR_PARAMETER; } @@ -368,30 +747,29 @@ err_t err = netbuf_ref(buf, data, (u16_t)size); if (err != ERR_OK) { netbuf_free(buf); - return lwip_err_remap(err);; + return mbed_lwip_wifi_err_remap(err); } - err = netconn_sendto(s->conn, buf, (ip_addr_t *)addr.bytes, port); + err = netconn_sendto(s->conn, buf, &ip_addr, port); netbuf_delete(buf); if (err != ERR_OK) { - return lwip_err_remap(err); + return mbed_lwip_wifi_err_remap(err); } return size; } -static int lwip_socket_recvfrom(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t *addr, uint16_t *port, void *data, unsigned size) +static int mbed_lwip_wifi_socket_recvfrom(nsapi_stack_t *stack, nsapi_socket_t handle, nsapi_addr_t *addr, uint16_t *port, void *data, unsigned size) { struct lwip_socket *s = (struct lwip_socket *)handle; + struct netbuf *buf; - struct netbuf *buf; err_t err = netconn_recv(s->conn, &buf); if (err != ERR_OK) { - return lwip_err_remap(err); + return mbed_lwip_wifi_err_remap(err); } - addr->version = NSAPI_IPv4; - memcpy(addr->bytes, netbuf_fromaddr(buf), sizeof addr->bytes); + convert_lwip_addr_to_mbed(addr, netbuf_fromaddr(buf)); *port = netbuf_fromport(buf); u16_t recv = netbuf_copy(buf, data, (u16_t)size); @@ -400,7 +778,7 @@ return recv; } -static int lwip_setsockopt(nsapi_stack_t *stack, nsapi_socket_t handle, int level, int optname, const void *optval, unsigned optlen) +static int mbed_lwip_wifi_setsockopt(nsapi_stack_t *stack, nsapi_socket_t handle, int level, int optname, const void *optval, unsigned optlen) { struct lwip_socket *s = (struct lwip_socket *)handle; @@ -446,7 +824,7 @@ } } -static void lwip_socket_attach(nsapi_stack_t *stack, nsapi_socket_t handle, void (*callback)(void *), void *data) +static void mbed_lwip_wifi_socket_attach(nsapi_stack_t *stack, nsapi_socket_t handle, void (*callback)(void *), void *data) { struct lwip_socket *s = (struct lwip_socket *)handle; @@ -454,26 +832,23 @@ s->data = data; } - /* LWIP network stack */ const nsapi_stack_api_t lwip_wifi_stack_api = { - .get_ip_address = lwip_getaddr, - .gethostbyname = lwip_gethostbyname, - .socket_open = lwip_socket_open, - .socket_close = lwip_socket_close, - .socket_bind = lwip_socket_bind, - .socket_listen = lwip_socket_listen, - .socket_connect = lwip_socket_connect, - .socket_accept = lwip_socket_accept, - .socket_send = lwip_socket_send, - .socket_recv = lwip_socket_recv, - .socket_sendto = lwip_socket_sendto, - .socket_recvfrom = lwip_socket_recvfrom, - .setsockopt = lwip_setsockopt, - .socket_attach = lwip_socket_attach, + .gethostbyname = mbed_lwip_wifi_gethostbyname, + .socket_open = mbed_lwip_wifi_socket_open, + .socket_close = mbed_lwip_wifi_socket_close, + .socket_bind = mbed_lwip_wifi_socket_bind, + .socket_listen = mbed_lwip_wifi_socket_listen, + .socket_connect = mbed_lwip_wifi_socket_connect, + .socket_accept = mbed_lwip_wifi_socket_accept, + .socket_send = mbed_lwip_wifi_socket_send, + .socket_recv = mbed_lwip_wifi_socket_recv, + .socket_sendto = mbed_lwip_wifi_socket_sendto, + .socket_recvfrom = mbed_lwip_wifi_socket_recvfrom, + .setsockopt = mbed_lwip_wifi_setsockopt, + .socket_attach = mbed_lwip_wifi_socket_attach, }; nsapi_stack_t lwip_wifi_stack = { .stack_api = &lwip_wifi_stack_api, }; -