自学教程：C++ sys_mbox_free函数代码示例

/** * Delete rcvmbox and acceptmbox of a netconn and free the left-over data in * these mboxes * * @param conn the netconn to free * @bytes_drained bytes drained from recvmbox * @accepts_drained pending connections drained from acceptmbox */static voidnetconn_drain(struct netconn *conn){    void *mem;#if LWIP_TCP    struct pbuf *p;#endif /* LWIP_TCP */    /* This runs in tcpip_thread, so we don't need to lock against rx packets */    /* Delete and drain the recvmbox. */    if (sys_mbox_valid(&conn->recvmbox)) {        while (sys_mbox_tryfetch(&conn->recvmbox, &mem) != SYS_MBOX_EMPTY) {#if LWIP_TCP            if (conn->type == NETCONN_TCP) {                if(mem != NULL) {                    p = (struct pbuf*)mem;                    /* pcb might be set to NULL already by err_tcp() */                    if (conn->pcb.tcp != NULL) {                        tcp_recved(conn->pcb.tcp, p->tot_len);                    }                    pbuf_free(p);                }            } else#endif /* LWIP_TCP */            {                netbuf_delete((struct netbuf *)mem);            }        }        sys_mbox_free(&conn->recvmbox);        sys_mbox_set_invalid(&conn->recvmbox);    }    /* Delete and drain the acceptmbox. */#if LWIP_TCP    if (sys_mbox_valid(&conn->acceptmbox)) {        while (sys_mbox_tryfetch(&conn->acceptmbox, &mem) != SYS_MBOX_EMPTY) {            struct netconn *newconn = (struct netconn *)mem;            /* Only tcp pcbs have an acceptmbox, so no need to check conn->type */            /* pcb might be set to NULL already by err_tcp() */            if (conn->pcb.tcp != NULL) {                tcp_accepted(conn->pcb.tcp);            }            /* drain recvmbox */            netconn_drain(newconn);            if (newconn->pcb.tcp != NULL) {                tcp_abort(newconn->pcb.tcp);                newconn->pcb.tcp = NULL;            }            netconn_free(newconn);        }        sys_mbox_free(&conn->acceptmbox);        sys_mbox_set_invalid(&conn->acceptmbox);    }#endif /* LWIP_TCP */}

static err_taccept_function(void *arg, struct tcp_pcb *newpcb, err_t err){  sys_mbox_t mbox;  struct netconn *newconn;  struct netconn *conn;  #if API_MSG_DEBUG#if TCP_DEBUG  tcp_debug_print_state(newpcb->state);#endif /* TCP_DEBUG */#endif /* API_MSG_DEBUG */  conn = (struct netconn *)arg;  mbox = conn->acceptmbox;  newconn = memp_malloc(MEMP_NETCONN);  if (newconn == NULL) {    return ERR_MEM;  }  newconn->recvmbox = sys_mbox_new();  if (newconn->recvmbox == SYS_MBOX_NULL) {    memp_free(MEMP_NETCONN, newconn);    return ERR_MEM;  }  newconn->mbox = sys_mbox_new();  if (newconn->mbox == SYS_MBOX_NULL) {    sys_mbox_free(newconn->recvmbox);    memp_free(MEMP_NETCONN, newconn);    return ERR_MEM;  }  newconn->sem = sys_sem_new(0);  if (newconn->sem == SYS_SEM_NULL) {    sys_mbox_free(newconn->recvmbox);    sys_mbox_free(newconn->mbox);    memp_free(MEMP_NETCONN, newconn);    return ERR_MEM;  }  /* Allocations were OK, setup the PCB etc */  newconn->type = NETCONN_TCP;  newconn->pcb.tcp = newpcb;  setup_tcp(newconn);  newconn->acceptmbox = SYS_MBOX_NULL;  newconn->err = err;  /* Register event with callback */  if (conn->callback)  {    (*conn->callback)(conn, NETCONN_EVT_RCVPLUS, 0);  }  /* We have to set the callback here even though   * the new socket is unknown. Mark the socket as -1. */  newconn->callback = conn->callback;  newconn->socket = -1;  newconn->recv_avail = 0;    sys_mbox_post(mbox, newconn);  return ERR_OK;}

err_tnetconn_delete(struct netconn *conn){  struct api_msg *msg;  void *mem;    if (conn == NULL) {    return ERR_OK;  }    if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {    return ERR_MEM;  }    msg->type = API_MSG_DELCONN;  msg->msg.conn = conn;  api_msg_post(msg);    sys_mbox_fetch(conn->mbox, NULL);  memp_free(MEMP_API_MSG, msg);  /* Drain the recvmbox. */  if (conn->recvmbox != SYS_MBOX_NULL) {    while (sys_arch_mbox_fetch(conn->recvmbox, &mem, 1) != SYS_ARCH_TIMEOUT) {      if (conn->type == NETCONN_TCP) {        if(mem != NULL)          pbuf_free((struct pbuf *)mem);      } else {        netbuf_delete((struct netbuf *)mem);      }    }    sys_mbox_free(conn->recvmbox);    conn->recvmbox = SYS_MBOX_NULL;  }   /* Drain the acceptmbox. */  if (conn->acceptmbox != SYS_MBOX_NULL) {    while (sys_arch_mbox_fetch(conn->acceptmbox, &mem, 1) != SYS_ARCH_TIMEOUT) {      netconn_delete((struct netconn *)mem);    }        sys_mbox_free(conn->acceptmbox);    conn->acceptmbox = SYS_MBOX_NULL;  }  sys_mbox_free(conn->mbox);  conn->mbox = SYS_MBOX_NULL;  if (conn->sem != SYS_SEM_NULL) {    sys_sem_free(conn->sem);  }  /*  conn->sem = SYS_SEM_NULL;*/  memp_free(MEMP_NETCONN, conn);  return ERR_OK;}

err_tnetconn_delete(struct netconn *conn){  struct api_msg msg;  void *mem;	//fprintf(stderr, "netconn_delete %p/n",conn);    if (conn == NULL) {    return ERR_OK;  }    msg.type = API_MSG_DELCONN;  msg.msg.conn = conn;    api_msg_post(conn->stack, &msg);      sys_mbox_fetch(conn->mbox, NULL);  /* Drain the recvmbox. */  if (conn->recvmbox != SYS_MBOX_NULL) {    while (sys_arch_mbox_fetch(conn->recvmbox, &mem, 1) != SYS_ARCH_TIMEOUT) {      if (conn->type == NETCONN_TCP) {				if (mem != NULL)					pbuf_free((struct pbuf *)mem);      } else {				netbuf_delete((struct netbuf *)mem);      }    }    sys_mbox_free(conn->recvmbox);    conn->recvmbox = SYS_MBOX_NULL;  }  /* Drain the acceptmbox. */  if (conn->acceptmbox != SYS_MBOX_NULL) {    while (sys_arch_mbox_fetch(conn->acceptmbox, &mem, 1) != SYS_ARCH_TIMEOUT) {      netconn_delete((struct netconn *)mem);    }        sys_mbox_free(conn->acceptmbox);    conn->acceptmbox = SYS_MBOX_NULL;  }  sys_mbox_free(conn->mbox);  conn->mbox = SYS_MBOX_NULL;  if (conn->sem != SYS_SEM_NULL) {    sys_sem_free(conn->sem);  }    conn->sem = SYS_SEM_NULL; /* this should not be commented out!*/  memp_free(MEMP_NETCONN, conn);  return ERR_OK;}

/** * Set a TCP pcb contained in a netconn into listen mode * Called from netconn_listen. * * @param msg the api_msg_msg pointing to the connection */voidlwip_netconn_do_listen(struct api_msg_msg *msg){  if (ERR_IS_FATAL(msg->conn->last_err)) {    msg->err = msg->conn->last_err;  } else {    msg->err = ERR_CONN;    if (msg->conn->pcb.tcp != NULL) {      if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) {        if (msg->conn->state == NETCONN_NONE) {          struct tcp_pcb* lpcb;#if LWIP_IPV6          if ((msg->conn->flags & NETCONN_FLAG_IPV6_V6ONLY) == 0) {#if TCP_LISTEN_BACKLOG            lpcb = tcp_listen_dual_with_backlog(msg->conn->pcb.tcp, msg->msg.lb.backlog);#else  /* TCP_LISTEN_BACKLOG */            lpcb = tcp_listen_dual(msg->conn->pcb.tcp);#endif /* TCP_LISTEN_BACKLOG */          } else#endif /* LWIP_IPV6 */          {#if TCP_LISTEN_BACKLOG            lpcb = tcp_listen_with_backlog(msg->conn->pcb.tcp, msg->msg.lb.backlog);#else  /* TCP_LISTEN_BACKLOG */            lpcb = tcp_listen(msg->conn->pcb.tcp);#endif /* TCP_LISTEN_BACKLOG */          }          if (lpcb == NULL) {            /* in this case, the old pcb is still allocated */            msg->err = ERR_MEM;          } else {            /* delete the recvmbox and allocate the acceptmbox */            if (sys_mbox_valid(&msg->conn->recvmbox)) {              /** @todo: should we drain the recvmbox here? */              sys_mbox_free(&msg->conn->recvmbox);              sys_mbox_set_invalid(&msg->conn->recvmbox);            }            msg->err = ERR_OK;            if (!sys_mbox_valid(&msg->conn->acceptmbox)) {              msg->err = sys_mbox_new(&msg->conn->acceptmbox, DEFAULT_ACCEPTMBOX_SIZE);            }            if (msg->err == ERR_OK) {              msg->conn->state = NETCONN_LISTEN;              msg->conn->pcb.tcp = lpcb;              tcp_arg(msg->conn->pcb.tcp, msg->conn);              tcp_accept(msg->conn->pcb.tcp, accept_function);            } else {              /* since the old pcb is already deallocated, free lpcb now */              tcp_close(lpcb);              msg->conn->pcb.tcp = NULL;            }          }        }      } else {        msg->err = ERR_ARG;      }    }  }  TCPIP_APIMSG_ACK(msg);}

/** * 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;    if (TCPIP_APIMSG(&msg) != ERR_OK) {      LWIP_ASSERT("freeing conn without freeing pcb", conn->pcb.tcp == NULL);      LWIP_ASSERT("conn has no op_completed", sys_sem_valid(&conn->op_completed));      LWIP_ASSERT("conn has no recvmbox", sys_mbox_valid(&conn->recvmbox));#if LWIP_TCP      LWIP_ASSERT("conn->acceptmbox shouldn't exist", !sys_mbox_valid(&conn->acceptmbox));#endif /* LWIP_TCP */      sys_sem_free(&conn->op_completed);      sys_mbox_free(&conn->recvmbox);      memp_free(MEMP_NETCONN, conn);      return NULL;    }  }  return conn;}

/** * 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;  API_MSG_VAR_DECLARE(msg);  conn = netconn_alloc(t, callback);  if (conn != NULL) {    err_t err;    API_MSG_VAR_ALLOC_DONTFAIL(msg);    API_MSG_VAR_REF(msg).msg.msg.n.proto = proto;    API_MSG_VAR_REF(msg).msg.conn = conn;    TCPIP_APIMSG(&API_MSG_VAR_REF(msg), lwip_netconn_do_newconn, err);    API_MSG_VAR_FREE(msg);    if (err != ERR_OK) {      LWIP_ASSERT("freeing conn without freeing pcb", conn->pcb.tcp == NULL);      LWIP_ASSERT("conn has no recvmbox", sys_mbox_valid(&conn->recvmbox));#if LWIP_TCP      LWIP_ASSERT("conn->acceptmbox shouldn't exist", !sys_mbox_valid(&conn->acceptmbox));#endif /* LWIP_TCP */#if !LWIP_NETCONN_SEM_PER_THREAD      LWIP_ASSERT("conn has no op_completed", sys_sem_valid(&conn->op_completed));      sys_sem_free(&conn->op_completed);#endif /* !LWIP_NETCONN_SEM_PER_THREAD */      sys_mbox_free(&conn->recvmbox);      memp_free(MEMP_NETCONN, conn);      return NULL;    }  }  return conn;}

struct fwtcp *fwtcp_create(struct fwspec *fwspec){    struct fwtcp *fwtcp;    SOCKET lsock;    int status;    err_t error;    lsock = proxy_bound_socket(fwspec->sdom, fwspec->stype, &fwspec->src.sa);    if (lsock == INVALID_SOCKET) {        perror("socket");        return NULL;    }    fwtcp = (struct fwtcp *)malloc(sizeof(*fwtcp));    if (fwtcp == NULL) {        closesocket(lsock);        return NULL;    }    fwtcp->pmhdl.callback = fwtcp_pmgr_listen;    fwtcp->pmhdl.data = (void *)fwtcp;    fwtcp->pmhdl.slot = -1;    fwtcp->sock = lsock;    fwtcp->fwspec = *fwspec;    /* struct copy */    error = sys_mbox_new(&fwtcp->connmbox, 16);    if (error != ERR_OK) {        closesocket(lsock);        free(fwtcp);        return (NULL);    }#define CALLBACK_MSG(MSG, FUNC)                         /    do {                                                /        fwtcp->MSG.type = TCPIP_MSG_CALLBACK_STATIC;    /        fwtcp->MSG.sem = NULL;                          /        fwtcp->MSG.msg.cb.function = FUNC;              /        fwtcp->MSG.msg.cb.ctx = (void *)fwtcp;          /    } while (0)    CALLBACK_MSG(msg_connect, fwtcp_pcb_connect);    CALLBACK_MSG(msg_delete,  fwtcp_pcb_delete);#undef CALLBACK_MSG    status = pollmgr_add(&fwtcp->pmhdl, fwtcp->sock, POLLIN);    if (status < 0) {        sys_mbox_free(&fwtcp->connmbox);        closesocket(lsock);        free(fwtcp);        return NULL;    }    fwtcp->next = fwtcp_list;    fwtcp_list = fwtcp;    return fwtcp;}

voidvMBPortEventClose( void ){    if( xMailBox != SYS_MBOX_NULL )    {        sys_mbox_free( xMailBox );    }}

static voidfwtcp_pcb_delete(void *arg){    struct fwtcp *fwtcp = (struct fwtcp *)arg;    void *data;    u32_t timo;    timo = sys_mbox_tryfetch(&fwtcp->connmbox, &data);    LWIP_ASSERT1(timo == SYS_MBOX_EMPTY);    LWIP_UNUSED_ARG(timo);      /* only in assert */    sys_mbox_free(&fwtcp->connmbox);    free(fwtcp);}

static voidpxudp_drain_inmbox(struct pxudp *pxudp){    void *ptr;    if (!sys_mbox_valid(&pxudp->inmbox)) {        return;    }    while (sys_mbox_tryfetch(&pxudp->inmbox, &ptr) != SYS_MBOX_EMPTY) {        struct pbuf *p = (struct pbuf *)ptr;        pbuf_free(p);    }    sys_mbox_free(&pxudp->inmbox);    sys_mbox_set_invalid(&pxudp->inmbox);}

/** * Call the lower part of a netconn_* function * This function is then running in the thread context * of tcpip_thread and has exclusive access to lwIP core code. * * @param apimsg a struct containing the function to call and its parameters * @return ERR_OK if the function was called, another err_t if not */static err_ttcpip_apimsg(struct api_msg *apimsg){#ifdef LWIP_DEBUG  /* catch functions that don't set err */  apimsg->msg.err = ERR_VAL;#endif#if LWIP_NETCONN_SEM_PER_THREAD  apimsg->msg.op_completed_sem = LWIP_NETCONN_THREAD_SEM_GET();  LWIP_ASSERT("netconn semaphore not initialized",  sys_sem_valid(apimsg->msg.op_completed_sem));#endif#ifdef LWIP_ESP8266    //#if 0    sys_sem_t *op_sem_tmp = NULL;    if(apimsg->function == lwip_netconn_do_write)        op_sem_tmp = LWIP_API_MSG_SND_SEM(&apimsg->msg);    else        op_sem_tmp = LWIP_API_MSG_SEM(&apimsg->msg);    if (tcpip_send_api_msg(apimsg->function, &apimsg->msg, op_sem_tmp) == ERR_OK) {#else    if (tcpip_send_api_msg(apimsg->function, &apimsg->msg, LWIP_API_MSG_SEM(&apimsg->msg)) == ERR_OK) {#endif        return apimsg->msg.err;    }      return ERR_VAL;}#endif /* !LWIP_TCPIP_CORE_LOCKING *//** * 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;  API_MSG_VAR_DECLARE(msg);  conn = netconn_alloc(t, callback);  if (conn != NULL) {    err_t err;    API_MSG_VAR_ALLOC_DONTFAIL(msg);    API_MSG_VAR_REF(msg).msg.msg.n.proto = proto;    API_MSG_VAR_REF(msg).msg.conn = conn;    TCPIP_APIMSG(&API_MSG_VAR_REF(msg), lwip_netconn_do_newconn, err);    API_MSG_VAR_FREE(msg);    if (err != ERR_OK) {      LWIP_ASSERT("freeing conn without freeing pcb", conn->pcb.tcp == NULL);      LWIP_ASSERT("conn has no recvmbox", sys_mbox_valid(&conn->recvmbox));#if LWIP_TCP      LWIP_ASSERT("conn->acceptmbox shouldn't exist", !sys_mbox_valid(&conn->acceptmbox));#endif /* LWIP_TCP */#if !LWIP_NETCONN_SEM_PER_THREAD      LWIP_ASSERT("conn has no op_completed", sys_sem_valid(&conn->op_completed));      sys_sem_free(&conn->op_completed);#ifdef LWIP_ESP8266        sys_sem_free(&conn->snd_op_completed);#endif#endif /* !LWIP_NETCONN_SEM_PER_THREAD */      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){  err_t err;  API_MSG_VAR_DECLARE(msg);//.........这里部分代码省略.........

//.........这里部分代码省略.........    LWIP_DEBUGF(API_MSG_DEBUG, ("accept_function: newpcb->tate: %s/n", tcp_debug_state_str(newpcb->state)));    if (!sys_mbox_valid(&conn->acceptmbox)) {        LWIP_DEBUGF(API_MSG_DEBUG, ("accept_function: acceptmbox already deleted/n"));        return ERR_VAL;    }    /* We have to set the callback here even though     * the new socket is unknown. conn->socket is marked as -1. */    newconn = netconn_alloc(conn->type, conn->callback);    if (newconn == NULL) {        return ERR_MEM;    }    newconn->pcb.tcp = newpcb;    setup_tcp(newconn);    /* no protection: when creating the pcb, the netconn is not yet known       to the application thread */    newconn->last_err = err;    if (sys_mbox_trypost(&conn->acceptmbox, newconn) != ERR_OK) {        /* When returning != ERR_OK, the pcb is aborted in tcp_process(),           so do nothing here! */        /* remove all references to this netconn from the pcb */        struct tcp_pcb* pcb = newconn->pcb.tcp;        tcp_arg(pcb, NULL);        tcp_recv(pcb, NULL);        tcp_sent(pcb, NULL);        tcp_poll(pcb, NULL, 4);        tcp_err(pcb, NULL);        /* remove reference from to the pcb from this netconn */        newconn->pcb.tcp = NULL;        /* no need to drain since we know the recvmbox is empty. */        sys_mbox_free(&newconn->recvmbox);        sys_mbox_set_invalid(&newconn->recvmbox);        netconn_free(newconn);        return ERR_MEM;    } else {        /* Register event with callback */        API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0);    }    return ERR_OK;}#endif /* LWIP_TCP *//** * Create a new pcb of a specific type. * Called from do_newconn(). * * @param msg the api_msg_msg describing the connection type * @return msg->conn->err, but the return value is currently ignored */static voidpcb_new(struct api_msg_msg *msg){    LWIP_ASSERT("pcb_new: pcb already allocated", msg->conn->pcb.tcp == NULL);    /* Allocate a PCB for this connection */    switch(NETCONNTYPE_GROUP(msg->conn->type)) {#if LWIP_RAW    case NETCONN_RAW:        msg->conn->pcb.raw = raw_new(msg->msg.n.proto);        if(msg->conn->pcb.raw == NULL) {            msg->err = ERR_MEM;            break;

int mbox_free(int id){	return sys_mbox_free(id);}

/** * Create a new netconn (of a specific type) that has a callback function. * The corresponding pcb is NOT 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_alloc(enum netconn_type t, netconn_callback callback){  struct netconn *conn;  int size;  conn = (struct netconn *)memp_malloc(MEMP_NETCONN);  if (conn == NULL) {    return NULL;  }  conn->last_err = ERR_OK;  conn->type = t;  conn->pcb.tcp = NULL;  /* If all sizes are the same, every compiler should optimize this switch to nothing */  switch(NETCONNTYPE_GROUP(t)) {#if LWIP_RAW  case NETCONN_RAW:    size = DEFAULT_RAW_RECVMBOX_SIZE;    break;#endif /* LWIP_RAW */#if LWIP_UDP  case NETCONN_UDP:    size = DEFAULT_UDP_RECVMBOX_SIZE;    break;#endif /* LWIP_UDP */#if LWIP_TCP  case NETCONN_TCP:    size = DEFAULT_TCP_RECVMBOX_SIZE;    break;#endif /* LWIP_TCP */  default:    LWIP_ASSERT("netconn_alloc: undefined netconn_type", 0);    goto free_and_return;  }  if (sys_mbox_new(&conn->recvmbox, size) != ERR_OK) {    goto free_and_return;  }#if !LWIP_NETCONN_SEM_PER_THREAD  if (sys_sem_new(&conn->op_completed, 0) != ERR_OK) {    sys_mbox_free(&conn->recvmbox);    goto free_and_return;  }#endif#if LWIP_TCP  sys_mbox_set_invalid(&conn->acceptmbox);#endif  conn->state        = NETCONN_NONE;#if LWIP_SOCKET  /* initialize socket to -1 since 0 is a valid socket */  conn->socket       = -1;#endif /* LWIP_SOCKET */  conn->callback     = callback;#if LWIP_TCP  conn->current_msg  = NULL;  conn->write_offset = 0;#endif /* LWIP_TCP */#if LWIP_SO_SNDTIMEO  conn->send_timeout = 0;#endif /* LWIP_SO_SNDTIMEO */#if LWIP_SO_RCVTIMEO  conn->recv_timeout = 0;#endif /* LWIP_SO_RCVTIMEO */#if LWIP_SO_RCVBUF  conn->recv_bufsize = RECV_BUFSIZE_DEFAULT;  conn->recv_avail   = 0;#endif /* LWIP_SO_RCVBUF */  conn->flags = 0;  return conn;free_and_return:  memp_free(MEMP_NETCONN, conn);  return NULL;}

struct netbuf *netconn_recv(struct netconn *conn){  struct api_msg *msg;  struct netbuf *buf;  struct pbuf *p;  u16_t len;      if (conn == NULL) {    return NULL;  }    if (conn->recvmbox == SYS_MBOX_NULL) {    conn->err = ERR_CONN;    return NULL;  }  if (conn->err != ERR_OK) {    return NULL;  }  if (conn->type == NETCONN_TCP) {    if (conn->pcb.tcp->state == LISTEN) {      conn->err = ERR_CONN;      return NULL;    }    buf = memp_malloc(MEMP_NETBUF);    if (buf == NULL) {      conn->err = ERR_MEM;      return NULL;    }        sys_mbox_fetch(conn->recvmbox, (void **)&p);    if (p != NULL)    {        len = p->tot_len;        conn->recv_avail -= len;    }    else        len = 0;        /* Register event with callback */      if (conn->callback)        (*conn->callback)(conn, NETCONN_EVT_RCVMINUS, len);    /* If we are closed, we indicate that we no longer wish to receive       data by setting conn->recvmbox to SYS_MBOX_NULL. */    if (p == NULL) {      memp_free(MEMP_NETBUF, buf);      sys_mbox_free(conn->recvmbox);      conn->recvmbox = SYS_MBOX_NULL;      return NULL;    }    buf->p = p;    buf->ptr = p;    buf->fromport = 0;    buf->fromaddr = NULL;    /* Let the stack know that we have taken the data. */    if ((msg = memp_malloc(MEMP_API_MSG)) == NULL) {      conn->err = ERR_MEM;      return buf;    }    msg->type = API_MSG_RECV;    msg->msg.conn = conn;    if (buf != NULL) {      msg->msg.msg.len = buf->p->tot_len;    } else {      msg->msg.msg.len = 1;    }    api_msg_post(msg);    sys_mbox_fetch(conn->mbox, NULL);    memp_free(MEMP_API_MSG, msg);  } else {    sys_mbox_fetch(conn->recvmbox, (void **)&buf);  conn->recv_avail -= buf->p->tot_len;    /* Register event with callback */    if (conn->callback)        (*conn->callback)(conn, NETCONN_EVT_RCVMINUS, buf->p->tot_len);  }        LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_recv: received %p (err %d)/n", (void *)buf, conn->err));  return buf;}