/** * @file * Sequential API External 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> * *//* This is the part of the API that is linked with   the application */#include "lwip/opt.h"#if LWIP_NETCONN /* don't build if not configured for use in lwipopts.h */#include "lwip/api.h"#include "lwip/tcpip.h"#include "lwip/memp.h"#include "lwip/ip.h"#include "lwip/raw.h"#include "lwip/udp.h"#include "lwip/tcp.h"#include <string.h>/** * Create a new netconn (of a specific type) that has a callback function. * The corresponding pcb is also created. * * @param t the type of 'connection' to create (@see enum netconn_type) * @param proto the IP protocol for RAW IP pcbs * @param callback a function to call on status changes (RX available, TX'ed) * @return a newly allocated struct netconn or *         NULL on memory error */struct netconn*netconn_new_with_proto_and_callback(enum netconn_type t, u8_t proto, netconn_callback callback){  struct netconn *conn;  struct api_msg msg;  conn = netconn_alloc(t, callback);  if (conn != NULL ) {    msg.function = do_newconn;    msg.msg.msg.n.proto = proto;    msg.msg.conn = conn;    TCPIP_APIMSG(&msg);    if (conn->err != ERR_OK) {      LWIP_ASSERT("freeing conn without freeing pcb", conn->pcb.tcp == NULL);      LWIP_ASSERT("conn has no op_completed", conn->op_completed != SYS_SEM_NULL);      LWIP_ASSERT("conn has no recvmbox", conn->recvmbox != SYS_MBOX_NULL);      LWIP_ASSERT("conn->acceptmbox shouldn't exist", conn->acceptmbox == SYS_MBOX_NULL);      sys_sem_free(conn->op_completed);      sys_mbox_free(conn->recvmbox);      memp_free(MEMP_NETCONN, conn);      return NULL;    }  }  return conn;}/** * Close a netconn 'connection' and free its resources. * UDP and RAW connection are completely closed, TCP pcbs might still be in a waitstate * after this returns. * * @param conn the netconn to delete * @return ERR_OK if the connection was deleted */err_tnetconn_delete(struct netconn *conn){  struct api_msg msg;  /* No ASSERT here because possible to get a (conn == NULL) if we got an accept error */  if (conn == NULL) {    return ERR_OK;  }  msg.function = do_delconn;  msg.msg.conn = conn;  tcpip_apimsg(&msg);  conn->pcb.tcp = NULL;  netconn_free(conn);  return ERR_OK;}/** * Get the type of a netconn (as enum netconn_type). * * @param conn the netconn of which to get the type * @return the netconn_type of conn */enum netconn_typenetconn_type(struct netconn *conn){  LWIP_ERROR("netconn_type: invalid conn", (conn != NULL), return NETCONN_INVALID;);  return conn->type;}/** * Get the local or remote IP address and port of a netconn. * For RAW netconns, this returns the protocol instead of a port! * * @param conn the netconn to query * @param addr a pointer to which to save the IP address * @param port a pointer to which to save the port (or protocol for RAW) * @param local 1 to get the local IP address, 0 to get the remote one * @return ERR_CONN for invalid connections *         ERR_OK if the information was retrieved */err_tnetconn_getaddr(struct netconn *conn, struct ip_addr *addr, u16_t *port, u8_t local){  struct api_msg msg;  LWIP_ERROR("netconn_getaddr: invalid conn", (conn != NULL), return ERR_ARG;);  LWIP_ERROR("netconn_getaddr: invalid addr", (addr != NULL), return ERR_ARG;);  LWIP_ERROR("netconn_getaddr: invalid port", (port != NULL), return ERR_ARG;);  msg.function = do_getaddr;  msg.msg.conn = conn;  msg.msg.msg.ad.ipaddr = addr;  msg.msg.msg.ad.port = port;  msg.msg.msg.ad.local = local;  TCPIP_APIMSG(&msg);  return conn->err;}/** * Bind a netconn to a specific local IP address and port. * Binding one netconn twice might not always be checked correctly! * * @param conn the netconn to bind * @param addr the local IP address to bind the netconn to (use IP_ADDR_ANY *             to bind to all addresses) * @param port the local port to bind the netconn to (not used for RAW) * @return ERR_OK if bound, any other err_t on failure */err_tnetconn_bind(struct netconn *conn, struct ip_addr *addr, u16_t port){  struct api_msg msg;  LWIP_ERROR("netconn_bind: invalid conn", (conn != NULL), return ERR_ARG;);  msg.function = do_bind;  msg.msg.conn = conn;  msg.msg.msg.bc.ipaddr = addr;  msg.msg.msg.bc.port = port;  TCPIP_APIMSG(&msg);  return conn->err;}/** * Connect a netconn to a specific remote IP address and port. * * @param conn the netconn to connect * @param addr the remote IP address to connect to * @param port the remote port to connect to (no used for RAW) * @return ERR_OK if connected, return value of tcp_/udp_/raw_connect otherwise */err_tnetconn_connect(struct netconn *conn, struct ip_addr *addr, u16_t port){  struct api_msg msg;  LWIP_ERROR("netconn_connect: invalid conn", (conn != NULL), return ERR_ARG;);  msg.function = do_connect;  msg.msg.conn = conn;  msg.msg.msg.bc.ipaddr = addr;  msg.msg.msg.bc.port = port;  /* This is the only function which need to not block tcpip_thread */  tcpip_apimsg(&msg);  return conn->err;}/** * Disconnect a netconn from its current peer (only valid for UDP netconns). * * @param conn the netconn to disconnect * @return TODO: return value is not set here... */err_tnetconn_disconnect(struct netconn *conn){  struct api_msg msg;  LWIP_ERROR("netconn_disconnect: invalid conn", (conn != NULL), return ERR_ARG;);  msg.function = do_disconnect;  msg.msg.conn = conn;  TCPIP_APIMSG(&msg);  return conn->err;}/** * Set a TCP netconn into listen mode * * @param conn the tcp netconn to set to listen mode * @param backlog the listen backlog, only used if TCP_LISTEN_BACKLOG==1 * @return ERR_OK if the netconn was set to listen (UDP and RAW netconns *         don't return any error (yet?)) */err_tnetconn_listen_with_backlog(struct netconn *conn, u8_t backlog){  struct api_msg msg;  /* This does no harm. If TCP_LISTEN_BACKLOG is off, backlog is unused. */  LWIP_UNUSED_ARG(backlog);  LWIP_ERROR("netconn_listen: invalid conn", (conn != NULL), return ERR_ARG;);  msg.function = do_listen;  msg.msg.conn = conn;#if TCP_LISTEN_BACKLOG  msg.msg.msg.lb.backlog = backlog;#endif /* TCP_LISTEN_BACKLOG */  TCPIP_APIMSG(&msg);  return conn->err;}/** * Accept a new connection on a TCP listening netconn. * * @param conn the TCP listen netconn * @return the newly accepted netconn or NULL on timeout */struct netconn *netconn_accept(struct netconn *conn){  struct netconn *newconn;  LWIP_ERROR("netconn_accept: invalid conn",       (conn != NULL),                      return NULL;);  LWIP_ERROR("netconn_accept: invalid acceptmbox", (conn->acceptmbox != SYS_MBOX_NULL), return NULL;);#if LWIP_SO_RCVTIMEO  if (sys_arch_mbox_fetch(conn->acceptmbox, (void *)&newconn, conn->recv_timeout) == SYS_ARCH_TIMEOUT) {    newconn = NULL;  } else#else  sys_arch_mbox_fetch(conn->acceptmbox, (void *)&newconn, 0);#endif /* LWIP_SO_RCVTIMEO*/  {    /* Register event with callback */    API_EVENT(conn, NETCONN_EVT_RCVMINUS, 0);#if TCP_LISTEN_BACKLOG    if (newconn != NULL) {