Daiki Kato
LWIPBP3595Interface library for mbed-os.
Dependents: LWIPBP3595Interface_STA_for_mbed-os
Fork of
LWIPBP3595Interface
by 
Rohm
Diff: lwip_wifi_stack.c
- Revision:
- 3:2ff2514e4fca
- Parent:
- 2:c7e325599570
- Child:
- 5:d03489ec5033
--- 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,
};
-