/* * Copyright (c) 2001-2004 Swedish Institute of Computer Science. * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, *    this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, *    this list of conditions and the following disclaimer in the documentation *    and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products *    derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY * OF SUCH DAMAGE. * * This file is part of the lwIP TCP/IP stack. * * Author: Adam Dunkels <adam@sics.se> * * Improved by Marc Boucher <marc@mbsi.ca> and David Haas <dhaas@alum.rpi.edu> * */#include <string.h>#include <errno.h>#include "lwip/opt.h"#include "lwip/api.h"#include "lwip/arch.h"#include "lwip/sys.h"#include "lwip/sockets.h"#define NUM_SOCKETS MEMP_NUM_NETCONNstruct lwip_socket {  struct netconn *conn;  struct netbuf *lastdata;  u16_t lastoffset;  u16_t rcvevent;  u16_t sendevent;  u16_t  flags;  int err;};struct lwip_select_cb{    struct lwip_select_cb *next;    fd_set *readset;    fd_set *writeset;    fd_set *exceptset;    int sem_signalled;    sys_sem_t sem;};static struct lwip_socket sockets[NUM_SOCKETS];static struct lwip_select_cb *select_cb_list = 0;static sys_sem_t socksem = 0;static sys_sem_t selectsem = 0;static voidevent_callback(struct netconn *conn, enum netconn_evt evt, u16_t len);static int err_to_errno_table[11] = {    0,      /* ERR_OK    0      No error, everything OK. */    ENOMEM,    /* ERR_MEM  -1      Out of memory error.     */    ENOBUFS,    /* ERR_BUF  -2      Buffer error.            */    ECONNABORTED,  /* ERR_ABRT -3      Connection aborted.      */    ECONNRESET,    /* ERR_RST  -4      Connection reset.        */    ESHUTDOWN,    /* ERR_CLSD -5      Connection closed.       */    ENOTCONN,    /* ERR_CONN -6      Not connected.           */    EINVAL,    /* ERR_VAL  -7      Illegal value.           */    EIO,    /* ERR_ARG  -8      Illegal argument.        */    EHOSTUNREACH,  /* ERR_RTE  -9      Routing problem.         */    EADDRINUSE    /* ERR_USE  -10     Address in use.          */};#define err_to_errno(err) \  ((err) < (sizeof(err_to_errno_table)/sizeof(int))) ? \    err_to_errno_table[-(err)] : EIO#ifdef ERRNO#define set_errno(err) errno = (err)#else#define set_errno(err)#endif#define sock_set_errno(sk, e) do { \      sk->err = (e); \      set_errno(sk->err); \} while (0)static struct lwip_socket *get_socket(int s){  struct lwip_socket *sock;  if ((s < 0) || (s > NUM_SOCKETS)) {    LWIP_DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): invalid\n", s));    set_errno(EBADF);    return NULL;  }  sock = &sockets[s];  if (!sock->conn) {    LWIP_DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): not active\n", s));    set_errno(EBADF);    return NULL;  }  return sock;}static intalloc_socket(struct netconn *newconn){  int i;  if (!socksem)      socksem = sys_sem_new(1);  /* Protect socket array */  sys_sem_wait(socksem);  /* allocate a new socket identifier */  for(i = 0; i < NUM_SOCKETS; ++i) {    if (!sockets[i].conn) {      sockets[i].conn = newconn;      sockets[i].lastdata = NULL;      sockets[i].lastoffset = 0;      sockets[i].rcvevent = 0;      sockets[i].sendevent = 1; /* TCP send buf is empty */      sockets[i].flags = 0;      sockets[i].err = 0;      sys_sem_signal(socksem);      return i;    }  }  sys_sem_signal(socksem);  return -1;}intlwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen){  struct lwip_socket *sock;  struct netconn *newconn;  struct ip_addr naddr;  u16_t port;  int newsock;  struct sockaddr_in sin;  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d)...\n", s));  sock = get_socket(s);  if (!sock) {    set_errno(EBADF);    return -1;  }  newconn = netconn_accept(sock->conn);  /* get the IP address and port of the remote host */  netconn_peer(newconn, &naddr, &port);  memset(&sin, 0, sizeof(sin));  sin.sin_len = sizeof(sin);  sin.sin_family = AF_INET;  sin.sin_port = htons(port);  sin.sin_addr.s_addr = naddr.addr;  if (*addrlen > sizeof(sin))      *addrlen = sizeof(sin);  memcpy(addr, &sin, *addrlen);  newsock = alloc_socket(newconn);  if (newsock == -1) {    netconn_delete(newconn);  sock_set_errno(sock, ENOBUFS);  return -1;  }  newconn->callback = event_callback;  sock = get_socket(newsock);  sys_sem_wait(socksem);  sock->rcvevent += -1 - newconn->socket;  newconn->socket = newsock;  sys_sem_signal(socksem);  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) returning new sock=%d addr=", s, newsock));  ip_addr_debug_print(SOCKETS_DEBUG, &naddr);  LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u\n", port));  sock_set_errno(sock, 0);  return newsock;}intlwip_bind(int s, struct sockaddr *name, socklen_t namelen){  struct lwip_socket *sock;  struct ip_addr local_addr;  u16_t local_port;  err_t err;  sock = get_socket(s);  if (!sock) {    set_errno(EBADF);    return -1;  }  local_addr.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr;  local_port = ((struct sockaddr_in *)name)->sin_port;  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d, addr=", s));  ip_addr_debug_print(SOCKETS_DEBUG, &local_addr);  LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u)\n", ntohs(local_port)));  err = netconn_bind(sock->conn, &local_addr, ntohs(local_port));  if (err != ERR_OK) {    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) failed, err=%d\n", s, err));    sock_set_errno(sock, err_to_errno(err));    return -1;  }  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) succeeded\n", s));  sock_set_errno(sock, 0);  return 0;}intlwip_close(int s){  struct lwip_socket *sock;  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_close(%d)\n", s));  if (!socksem)      socksem = sys_sem_new(1);  /* We cannot allow multiple closes of the same socket. */  sys_sem_wait(socksem);  sock = get_socket(s);  if (!sock) {      sys_sem_signal(socksem);      set_errno(EBADF);      return -1;  }  netconn_delete(sock->conn);  if (sock->lastdata) {    netbuf_delete(sock->lastdata);  }  sock->lastdata = NULL;  sock->lastoffset = 0;  sock->conn = NULL;  sys_sem_signal(socksem);  sock_set_errno(sock, 0);  return 0;}intlwip_connect(int s, struct sockaddr *name, socklen_t namelen){  struct lwip_socket *sock;  err_t err;  sock = get_socket(s);  if (!sock) {    set_errno(EBADF);    return -1;  }  if (((struct sockaddr_in *)name)->sin_family == AF_UNSPEC) {    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, AF_UNSPEC)\n", s));    err = netconn_disconnect(sock->conn);  } else {    struct ip_addr remote_addr;    u16_t remote_port;    remote_addr.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr;    remote_port = ((struct sockaddr_in *)name)->sin_port;    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, addr=", s));    ip_addr_debug_print(SOCKETS_DEBUG, &remote_addr);    LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u)\n", ntohs(remote_port)));    err = netconn_connect(sock->conn, &remote_addr, ntohs(remote_port));   }  if (err != ERR_OK) {    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) failed, err=%d\n", s, err));    sock_set_errno(sock, err_to_errno(err));    return -1;  }  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) succeeded\n", s));  sock_set_errno(sock, 0);  return 0;}intlwip_listen(int s, int backlog){  struct lwip_socket *sock;  err_t err;  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d, backlog=%d)\n", s, backlog));  sock = get_socket(s);  if (!sock) {    set_errno(EBADF);    return -1;  }  err = netconn_listen(sock->conn);  if (err != ERR_OK) {    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d) failed, err=%d\n", s, err));    sock_set_errno(sock, err_to_errno(err));    return -1;  }  sock_set_errno(sock, 0);  return 0;}intlwip_recvfrom(int s, void *mem, int len, unsigned int flags,        struct sockaddr *from, socklen_t *fromlen){  struct lwip_socket *sock;  struct netbuf *buf;  u16_t buflen, copylen;  struct ip_addr *addr;  u16_t port;  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d, %p, %d, 0x%x, ..)\n", s, mem, len, flags));  sock = get_socket(s);  if (!sock) {    set_errno(EBADF);    return -1;  }  /* Check if there is data left from the last recv operation. */  if (sock->lastdata) {    buf = sock->lastdata;  } else {    /* If this is non-blocking call, then check first */    if (((flags & MSG_DONTWAIT) || (sock->flags & O_NONBLOCK))  && !sock->rcvevent)    {      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): returning EWOULDBLOCK\n", s));      sock_set_errno(sock, EWOULDBLOCK);      return -1;    }    /* No data was left from the previous operation, so we try to get       some from the network. */    buf = netconn_recv(sock->conn);    if (!buf) {      /* We should really do some error checking here. */      LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): buf == NULL!\n", s));      sock_set_errno(sock, 0);      return 0;    }  }  buflen = netbuf_len(buf);  buflen -= sock->lastoffset;  if (len > buflen) {    copylen = buflen;  } else {    copylen = len;  }  /* copy the contents of the received buffer into     the supplied memory pointer mem */  netbuf_copy_partial(buf, mem, copylen, sock->lastoffset);  /* Check to see from where the data was. */  if (from && fromlen) {    struct sockaddr_in sin;    addr = netbuf_fromaddr(buf);    port = netbuf_fromport(buf);    memset(&sin, 0, sizeof(sin));    sin.sin_len = sizeof(sin);    sin.sin_family = AF_INET;    sin.sin_port = htons(port);    sin.sin_addr.s_addr = addr->addr;    if (*fromlen > sizeof(sin))      *fromlen = sizeof(sin);    memcpy(from, &sin, *fromlen);    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): addr=", s));    ip_addr_debug_print(SOCKETS_DEBUG, addr);    LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u len=%u\n", port, copylen));  } else {#if SOCKETS_DEBUG    addr = netbuf_fromaddr(buf);    port = netbuf_fromport(buf);    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d): addr=", s));    ip_addr_debug_print(SOCKETS_DEBUG, addr);    LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%u len=%u\n", port, copylen));#endif  }  /* If this is a TCP socket, check if there is data left in the     buffer. If so, it should be saved in the sock structure for next     time around. */  if (netconn_type(sock->conn) == NETCONN_TCP && buflen - copylen > 0) {    sock->lastdata = buf;    sock->lastoffset += copylen;  } else {    sock->lastdata = NULL;    sock->lastoffset = 0;    netbuf_delete(buf);  }  sock_set_errno(sock, 0);  return copylen;}intlwip_read(int s, void *mem, int len){  return lwip_recvfrom(s, mem, len, 0, NULL, NULL);}