/** * @file * Sockets BSD-Like API module * *//* * 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 "lwip/opt.h"#if LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */#include "lwip/sockets.h"#include "lwip/api.h"#include "lwip/sys.h"#include "lwip/igmp.h"#include "lwip/inet.h"#include "lwip/tcp.h"#include "lwip/raw.h"#include "lwip/udp.h"#include "lwip/tcpip.h"#include <string.h>#define NUM_SOCKETS MEMP_NUM_NETCONN/** Contains all internal pointers and states used for a socket */struct lwip_socket {  /** sockets currently are built on netconns, each socket has one netconn */  struct netconn *conn;  /** data that was left from the previous read */  struct netbuf *lastdata;  /** offset in the data that was left from the previous read */  u16_t lastoffset;  /** number of times data was received, set by event_callback(),      tested by the receive and select functions */  u16_t rcvevent;  /** number of times data was received, set by event_callback(),      tested by select */  u16_t sendevent;  /** socket flags (currently, only used for O_NONBLOCK) */  u16_t flags;  /** last error that occurred on this socket */  int err;};/** Description for a task waiting in select */struct lwip_select_cb {  /** Pointer to the next waiting task */  struct lwip_select_cb *next;  /** readset passed to select */  fd_set *readset;  /** writeset passed to select */  fd_set *writeset;  /** unimplemented: exceptset passed to select */  fd_set *exceptset;  /** don't signal the same semaphore twice: set to 1 when signalled */  int sem_signalled;  /** semaphore to wake up a task waiting for select */  sys_sem_t sem;};/** This struct is used to pass data to the set/getsockopt_internal * functions running in tcpip_thread context (only a void* is allowed) */struct lwip_setgetsockopt_data {  /** socket struct for which to change options */  struct lwip_socket *sock;  /** socket index for which to change options */  int s;  /** level of the option to process */  int level;  /** name of the option to process */  int optname;  /** set: value to set the option to    * get: value of the option is stored here */  void *optval;  /** size of *optval */  socklen_t *optlen;  /** if an error occures, it is temporarily stored here */  err_t err;};/** The global array of available sockets */static struct lwip_socket sockets[NUM_SOCKETS];/** The global list of tasks waiting for select */static struct lwip_select_cb *select_cb_list;/** Semaphore protecting the sockets array */static sys_sem_t socksem;/** Semaphore protecting select_cb_list */static sys_sem_t selectsem;/** Table to quickly map an lwIP error (err_t) to a socket error  * by using -err as an index */static const int err_to_errno_table[] = {  0,             /* ERR_OK          0      No error, everything OK. */  ENOMEM,        /* ERR_MEM        -1      Out of memory error.     */  ENOBUFS,       /* ERR_BUF        -2      Buffer error.            */  EHOSTUNREACH,  /* ERR_RTE        -3      Routing problem.         */  ECONNABORTED,  /* ERR_ABRT       -4      Connection aborted.      */  ECONNRESET,    /* ERR_RST        -5      Connection reset.        */  ESHUTDOWN,     /* ERR_CLSD       -6      Connection closed.       */  ENOTCONN,      /* ERR_CONN       -7      Not connected.           */  EINVAL,        /* ERR_VAL        -8      Illegal value.           */  EIO,           /* ERR_ARG        -9      Illegal argument.        */  EADDRINUSE,    /* ERR_USE        -10     Address in use.          */  -1,            /* ERR_IF         -11     Low-level netif error    */  -1,            /* ERR_ISCONN     -12     Already connected.       */  ETIMEDOUT,     /* ERR_TIMEOUT    -13     Timeout                  */  EINPROGRESS    /* ERR_INPROGRESS -14     Operation in progress    */};#define ERR_TO_ERRNO_TABLE_SIZE \  (sizeof(err_to_errno_table)/sizeof(err_to_errno_table[0]))#define err_to_errno(err) \  ((unsigned)(-(err)) < ERR_TO_ERRNO_TABLE_SIZE ? \    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)/* Forward delcaration of some functions */static void event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len);static void lwip_getsockopt_internal(void *arg);static void lwip_setsockopt_internal(void *arg);/** * Initialize this module. This function has to be called before any other * functions in this module! */voidlwip_socket_init(void){  socksem   = sys_sem_new(1);  selectsem = sys_sem_new(1);}/** * Map a externally used socket index to the internal socket representation. * * @param s externally used socket index * @return struct lwip_socket for the socket or NULL if not found */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;}/** * Allocate a new socket for a given netconn. * * @param newconn the netconn for which to allocate a socket * @return the index of the new socket; -1 on error */static intalloc_socket(struct netconn *newconn){  int i;  /* 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;}/* Below this, the well-known socket functions are implemented. * Use google.com or opengroup.org to get a good description :-) * * Exceptions are documented! */intlwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen){  struct lwip_socket *sock, *nsock;  struct netconn *newconn;  struct ip_addr naddr;  u16_t port;  int newsock;  struct sockaddr_in sin;  err_t err;  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d)...\n", s));  sock = get_socket(s);  if (!sock)    return -1;  newconn = netconn_accept(sock->conn);  if (!newconn) {    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) failed, err=%d\n", s, sock->conn->err));    sock_set_errno(sock, err_to_errno(sock->conn->err));    return -1;  }  /* get the IP address and port of the remote host */  err = netconn_peer(newconn, &naddr, &port);  if (err != ERR_OK) {    netconn_delete(newconn);    sock_set_errno(sock, err_to_errno(err));    return -1;  }  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);  SMEMCPY(addr, &sin, *addrlen);  newsock = alloc_socket(newconn);  if (newsock == -1) {    netconn_delete(newconn);    sock_set_errno(sock, ENFILE);    return -1;  }  LWIP_ASSERT("invalid socket index", (newsock >= 0) && (newsock < NUM_SOCKETS));  newconn->callback = event_callback;  nsock = &sockets[newsock];  LWIP_ASSERT("invalid socket pointer", nsock != NULL);  sys_sem_wait(socksem);  /* See event_callback: If data comes in right away after an accept, even   * though the server task might not have created a new socket yet.   * In that case, newconn->socket is counted down (newconn->socket--),   * so nsock->rcvevent is >= 1 here!   */  nsock->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)    return -1;  LWIP_ERROR("lwip_bind: invalid address", ((namelen == sizeof(struct sockaddr_in)) &&             ((((struct sockaddr_in *)name)->sin_family) == AF_INET)),             sock_set_errno(sock, err_to_errno(ERR_ARG)); 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));  sock = get_socket(s);  if (!sock) {    return -1;  }  netconn_delete(sock->conn);  sys_sem_wait(socksem);  if (sock->lastdata) {    netbuf_delete(sock->lastdata);  }  sock->lastdata   = NULL;  sock->lastoffset = 0;  sock->conn       = NULL;  sock_set_errno(sock, 0);  sys_sem_signal(socksem);  return 0;}intlwip_connect(int s, const struct sockaddr *name, socklen_t namelen){  struct lwip_socket *sock;  err_t err;  sock = get_socket(s);  if (!sock)    return -1;  LWIP_ERROR("lwip_connect: invalid address", ((namelen == sizeof(struct sockaddr_in)) &&             ((((struct sockaddr_in *)name)->sin_family) == AF_INET)),             sock_set_errno(sock, err_to_errno(ERR_ARG)); 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;}/** * Set a socket into listen mode. * The socket may not have been used for another connection previously. * * @param s the socket to set to listening mode * @param backlog (ATTENTION: need TCP_LISTEN_BACKLOG=1) * @return 0 on success, non-zero on failure */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)    return -1;  /* limit the "backlog" parameter to fit in an u8_t */  if (backlog < 0) {    backlog = 0;  }  if (backlog > 0xff) {    backlog = 0xff;  }  err = netconn_listen_with_backlog(sock->conn, backlog);  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, off = 0;  struct ip_addr     *addr;  u16_t               port;  u8_t                done = 0;  LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d, %p, %d, 0x%x, ..)\n", s, mem, len, flags));  sock = get_socket(s);  if (!sock)    return -1;  do {    LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom: top while sock->lastdata=%p\n", (void*)sock->lastdata));    /* Check if there is data left from the last recv operation. */    if (sock->lastdata) {