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

/** * Try to post a callback-message to the tcpip_thread mbox * This is intended to be used to send "static" messages from interrupt context. * * @param msg pointer to the message to post * @return sys_mbox_trypost() return code */err_ttcpip_trycallback(struct tcpip_callback_msg* msg){    if (!sys_mbox_valid(&mbox)) {        return ERR_VAL;    }    return sys_mbox_trypost(&mbox, msg);}

/** * Receive callback function for RAW netconns. * Doesn't 'eat' the packet, only references it and sends it to * conn->recvmbox * * @see raw.h (struct raw_pcb.recv) for parameters and return value */static u8_trecv_raw(void *arg, struct raw_pcb *pcb, struct pbuf *p,         ip_addr_t *addr){    struct pbuf *q;    struct netbuf *buf;    struct netconn *conn;    LWIP_UNUSED_ARG(addr);    conn = (struct netconn *)arg;    if ((conn != NULL) && sys_mbox_valid(&conn->recvmbox)) {#if LWIP_SO_RCVBUF        int recv_avail;        SYS_ARCH_GET(conn->recv_avail, recv_avail);        if ((recv_avail + (int)(p->tot_len)) > conn->recv_bufsize) {            return 0;        }#endif /* LWIP_SO_RCVBUF */        /* copy the whole packet into new pbufs */        q = pbuf_alloc(PBUF_RAW, p->tot_len, PBUF_RAM);        if(q != NULL) {            if (pbuf_copy(q, p) != ERR_OK) {                pbuf_free(q);                q = NULL;            }        }        if (q != NULL) {            u16_t len;            buf = (struct netbuf *)memp_malloc(MEMP_NETBUF);            if (buf == NULL) {                pbuf_free(q);                return 0;            }            buf->p = q;            buf->ptr = q;            ip_addr_copy(buf->addr, *ip_current_src_addr());            buf->port = pcb->protocol;            len = q->tot_len;            if (sys_mbox_trypost(&conn->recvmbox, buf) != ERR_OK) {                netbuf_delete(buf);                return 0;            } else {#if LWIP_SO_RCVBUF                SYS_ARCH_INC(conn->recv_avail, len);#endif /* LWIP_SO_RCVBUF */                /* Register event with callback */                API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);            }        }    }    return 0; /* do not eat the packet */}

/** * Pass a received packet to tcpip_thread for input processing * * @param p the received packet, p->payload pointing to the Ethernet header or *          to an IP header (if netif doesn't got NETIF_FLAG_ETHARP flag) * @param inp the network interface on which the packet was received */err_ttcpip_input(struct pbuf *p, struct netif *inp){  struct tcpip_msg *msg;	//===============	// test by pegasus	//	struct pbuf *q;	//	int i, plen = p->tot_len;	//	char* dat;	//===============   		/*/		// 调试打印接收信息		lwip_printf("/r/n********tcpip_input*************/r/n");		lwip_printf("接收数据长度:%d <--->/r/n",plen);		for (q = p; q!=NULL; q = q->next)		{			dat = (char*)q->payload;			plen= q->len;			for(i=0;i<plen;i++)			{				lwip_printf("%4x ",dat[i]);				if((i%6)==5) lwip_printf("/r/n");			}			lwip_printf("/r/n<*<*<*>*>*>/r/n");		}		lwip_printf("/r/n+++++++++++++++++++++/r/n");		/**/	  if (mbox != SYS_MBOX_NULL) {    msg = memp_malloc(MEMP_TCPIP_MSG_INPKT);    if (msg == NULL) {      return ERR_MEM;    }    msg->type = TCPIP_MSG_INPKT;    msg->msg.inp.p = p;    msg->msg.inp.netif = inp;    if (sys_mbox_trypost(mbox, msg) != ERR_OK) {      memp_free(MEMP_TCPIP_MSG_INPKT, msg);      return ERR_MEM;    }    return ERR_OK;  }  return ERR_VAL;}

/*  Deallocates a mailbox. If there are messages still present in the  mailbox when the mailbox is deallocated, it is an indication of a  programming error in lwIP and the developer should be notified.*/voidsys_mbox_free(sys_mbox_t *mbox){#define MAX_POLL_CNT 100#define PER_POLL_DELAY 20  uint16_t count = 0;  bool post_null = true;  LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free: set alive false/n"));  (*mbox)->alive = false;  while ( count++ < MAX_POLL_CNT ){ //ESP32_WORKAROUND    LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free:try lock=%d/n", count));    if (!sys_mutex_trylock( &(*mbox)->lock )){      LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free:get lock ok %d/n", count));      sys_mutex_unlock( &(*mbox)->lock );      break;    }    if (post_null){      LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free: post null to mbox/n"));      if (sys_mbox_trypost( mbox, NULL) != ERR_OK){        ESP_STATS_DROP_INC(esp.free_mbox_post_fail);        LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free: post null mbox fail/n"));      } else {        post_null = false;        LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free: post null mbox ok/n"));      }    }    if (count == (MAX_POLL_CNT-1)){      ESP_LOGW(TAG, "WARNING: mbox %p had a consumer who never unblocked. Leaking!/n", (*mbox)->os_mbox);    }    sys_delay_ms(PER_POLL_DELAY);  }  LWIP_DEBUGF(ESP_THREAD_SAFE_DEBUG, ("sys_mbox_free:free mbox/n"));  if (uxQueueMessagesWaiting((*mbox)->os_mbox)) {    xQueueReset((*mbox)->os_mbox);    /* Line for breakpoint.  Should never break here! */    __asm__ volatile ("nop");  }

/** * Pass a received packet to tcpip_thread for input processing * * @param p the received packet, p->payload pointing to the Ethernet header or *          to an IP header (if inp doesn't have NETIF_FLAG_ETHARP or *          NETIF_FLAG_ETHERNET flags) * @param inp the network interface on which the packet was received */err_ttcpip_input(struct pbuf *p, struct netif *inp){#if LWIP_TCPIP_CORE_LOCKING_INPUT  err_t ret;  LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_input: PACKET %p/%p/n", (void *)p, (void *)inp));  LOCK_TCPIP_CORE();#if LWIP_ETHERNET  if (inp->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) {    ret = ethernet_input(p, inp);  } else#endif /* LWIP_ETHERNET */  {    ret = ip_input(p, inp);  }  UNLOCK_TCPIP_CORE();  return ret;#else /* LWIP_TCPIP_CORE_LOCKING_INPUT */  struct tcpip_msg *msg;  if (sys_mbox_valid(&mbox)) {    msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_INPKT);    if (msg == NULL) {      return ERR_MEM;    }    msg->type = TCPIP_MSG_INPKT;#ifdef __ADSPBLACKFIN__    msg->flags = 0;#endif    msg->msg.inp.p = p;    msg->msg.inp.netif = inp;    if (sys_mbox_trypost(&mbox, msg) != ERR_OK) {      memp_free(MEMP_TCPIP_MSG_INPKT, msg);      return ERR_MEM;    }    return ERR_OK;  }  return ERR_VAL;#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */}

/** * Pass a received packet to tcpip_thread for input processing * * @param p the received packet, p->payload pointing to the Ethernet header or *          to an IP header (if netif doesn't got NETIF_FLAG_ETHARP flag) * @param inp the network interface on which the packet was received */err_ttcpip_input(struct pbuf *p, struct netif *inp){  struct tcpip_msg *msg;  if (mbox != SYS_MBOX_NULL) {    msg = memp_malloc(MEMP_TCPIP_MSG_INPKT);    if (msg == NULL) {      return ERR_MEM;    }    msg->type = TCPIP_MSG_INPKT;    msg->msg.inp.p = p;    msg->msg.inp.netif = inp;    if (sys_mbox_trypost(mbox, msg) != ERR_OK) {      memp_free(MEMP_TCPIP_MSG_INPKT, msg);      return ERR_MEM;    }    return ERR_OK;  }  return ERR_VAL;}

/** * Pass a received packet to tcpip_thread for input processing * * @param p the received packet * @param inp the network interface on which the packet was received * @param input_fn input function to call */err_ttcpip_signal_netif_event(struct netif *inp, u32_t event, netif_drv_fn drv_fn){  struct tcpip_msg *msg;  LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(mbox));  msg = (struct tcpip_msg *)memp_malloc(MEMP_NETIF_DRV_MSG);  if (msg == NULL) {    return ERR_MEM;  }  msg->type = TCPIP_MSG_DRV;  //msg->msg.inp.p = p;  msg->msg.drv.netif = inp;  msg->msg.drv.event = event;  msg->msg.drv.drv_fn = drv_fn;  if (sys_mbox_trypost(&mbox, msg) != ERR_OK) {    memp_free(MEMP_NETIF_DRV_MSG, msg);    return ERR_MEM;  }  return ERR_OK;}

/** * Receive callback function for UDP netconns. * Posts the packet to conn->recvmbox or deletes it on memory error. * * @see udp.h (struct udp_pcb.recv) for parameters */static voidrecv_udp(void *arg, struct udp_pcb *pcb, struct pbuf *p,         ip_addr_t *addr, u16_t port){    struct netbuf *buf;    struct netconn *conn;    u16_t len;#if LWIP_SO_RCVBUF    int recv_avail;#endif /* LWIP_SO_RCVBUF */    LWIP_UNUSED_ARG(pcb); /* only used for asserts... */    LWIP_ASSERT("recv_udp must have a pcb argument", pcb != NULL);    LWIP_ASSERT("recv_udp must have an argument", arg != NULL);    conn = (struct netconn *)arg;    LWIP_ASSERT("recv_udp: recv for wrong pcb!", conn->pcb.udp == pcb);#if LWIP_SO_RCVBUF    SYS_ARCH_GET(conn->recv_avail, recv_avail);    if ((conn == NULL) || !sys_mbox_valid(&conn->recvmbox) ||            ((recv_avail + (int)(p->tot_len)) > conn->recv_bufsize)) {#else  /* LWIP_SO_RCVBUF */    if ((conn == NULL) || !sys_mbox_valid(&conn->recvmbox)) {#endif /* LWIP_SO_RCVBUF */        pbuf_free(p);        return;    }    buf = (struct netbuf *)memp_malloc(MEMP_NETBUF);    if (buf == NULL) {        pbuf_free(p);        return;    } else {        buf->p = p;        buf->ptr = p;        ip_addr_set(&buf->addr, addr);        buf->port = port;#if LWIP_NETBUF_RECVINFO        {            const struct ip_hdr* iphdr = ip_current_header();            /* get the UDP header - always in the first pbuf, ensured by udp_input */            const struct udp_hdr* udphdr = (void*)(((char*)iphdr) + IPH_LEN(iphdr));#if LWIP_CHECKSUM_ON_COPY            buf->flags = NETBUF_FLAG_DESTADDR;#endif /* LWIP_CHECKSUM_ON_COPY */            ip_addr_set(&buf->toaddr, ip_current_dest_addr());            buf->toport_chksum = udphdr->dest;        }#endif /* LWIP_NETBUF_RECVINFO */    }    len = p->tot_len;    if (sys_mbox_trypost(&conn->recvmbox, buf) != ERR_OK) {        netbuf_delete(buf);        return;    } else {#if LWIP_SO_RCVBUF        SYS_ARCH_INC(conn->recv_avail, len);#endif /* LWIP_SO_RCVBUF */        /* Register event with callback */        API_EVENT(conn, NETCONN_EVT_RCVPLUS, len);    }}#endif /* LWIP_UDP */#if LWIP_TCP/** * Receive callback function for TCP netconns. * Posts the packet to conn->recvmbox, but doesn't delete it on errors. * * @see tcp.h (struct tcp_pcb.recv) for parameters and return value */static err_trecv_tcp(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err){    struct netconn *conn;    u16_t len;    LWIP_UNUSED_ARG(pcb);    LWIP_ASSERT("recv_tcp must have a pcb argument", pcb != NULL);    LWIP_ASSERT("recv_tcp must have an argument", arg != NULL);    conn = (struct netconn *)arg;    LWIP_ASSERT("recv_tcp: recv for wrong pcb!", conn->pcb.tcp == pcb);    if (conn == NULL) {        return ERR_VAL;    }    if (!sys_mbox_valid(&conn->recvmbox)) {        /* recvmbox already deleted */        if (p != NULL) {            tcp_recved(pcb, p->tot_len);            pbuf_free(p);        }        return ERR_OK;//.........这里部分代码省略.........

static intpxudp_pmgr_pump(struct pollmgr_handler *handler, SOCKET fd, int revents){    struct pxudp *pxudp;    struct pbuf *p;    ssize_t nread;    err_t error;    pxudp = (struct pxudp *)handler->data;    LWIP_ASSERT1(handler == &pxudp->pmhdl);    LWIP_ASSERT1(fd == pxudp->sock);    LWIP_UNUSED_ARG(fd);    if (revents & ~(POLLIN|POLLERR)) {        DPRINTF(("%s: unexpected revents 0x%x/n", __func__, revents));        return pxudp_schedule_delete(pxudp);    }    /*     * XXX: AFAICS, there's no way to match the error with the     * outgoing datagram that triggered it, since we do non-blocking     * sends from lwip thread.     */    if (revents & POLLERR) {        int sockerr = -1;        socklen_t optlen = (socklen_t)sizeof(sockerr);        int status;        status = getsockopt(pxudp->sock, SOL_SOCKET,                            SO_ERROR, (char *)&sockerr, &optlen);        if (status < 0) {            DPRINTF(("%s: sock %d: SO_ERROR failed:%R[sockerr]/n",                     __func__, pxudp->sock, SOCKERRNO()));        }        else {            DPRINTF(("%s: sock %d: %R[sockerr]/n",                     __func__, pxudp->sock, sockerr));        }    }    if ((revents & POLLIN) == 0) {        return POLLIN;    }    nread = recv(pxudp->sock, pollmgr_udpbuf, sizeof(pollmgr_udpbuf), 0);    if (nread == SOCKET_ERROR) {        DPRINTF(("%s: %R[sockerr]/n", __func__, SOCKERRNO()));        return POLLIN;    }    p = pbuf_alloc(PBUF_RAW, (u16_t)nread, PBUF_RAM);    if (p == NULL) {        DPRINTF(("%s: pbuf_alloc(%d) failed/n", __func__, (int)nread));        return POLLIN;    }    error = pbuf_take(p, pollmgr_udpbuf, (u16_t)nread);    if (error != ERR_OK) {        DPRINTF(("%s: pbuf_take(%d) failed/n", __func__, (int)nread));        pbuf_free(p);        return POLLIN;    }    error = sys_mbox_trypost(&pxudp->inmbox, p);    if (error != ERR_OK) {        pbuf_free(p);        return POLLIN;    }    proxy_lwip_post(&pxudp->msg_inbound);    return POLLIN;}

intfwtcp_pmgr_listen(struct pollmgr_handler *handler, SOCKET fd, int revents){    struct fwtcp *fwtcp;    struct sockaddr_storage ss;    socklen_t sslen;    void *peer_addr;    uint16_t peer_port;    struct pxtcp *pxtcp;    SOCKET newsock;    int status;    err_t error;    fwtcp = (struct fwtcp *)handler->data;    pxtcp = NULL;    LWIP_ASSERT1(fwtcp != NULL);    LWIP_ASSERT1(fd == fwtcp->sock);    LWIP_ASSERT1(revents == POLLIN);    LWIP_UNUSED_ARG(fd);    LWIP_UNUSED_ARG(revents);    LWIP_ASSERT1(sys_mbox_valid(&fwtcp->connmbox));    sslen = sizeof(ss);    newsock = accept(fwtcp->sock, (struct sockaddr *)&ss, &sslen);    if (newsock == INVALID_SOCKET) {        return POLLIN;    }    if (ss.ss_family == PF_INET) {        struct sockaddr_in *peer4 = (struct sockaddr_in *)&ss;        peer_addr = &peer4->sin_addr;        peer_port = peer4->sin_port;    }    else { /* PF_INET6 */        struct sockaddr_in6 *peer6 = (struct sockaddr_in6 *)&ss;        peer_addr = &peer6->sin6_addr;        peer_port = peer6->sin6_port;    }    peer_port = ntohs(peer_port);#if PLEASE_ABSTAIN_FROM_DPRINFING > 1 /* DPRINTF */ && !defined(RT_OS_WINDOWS)    {        char addrbuf[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"];        const char *addrstr;        addrstr = inet_ntop(ss.ss_family, peer_addr, addrbuf, sizeof(addrbuf));        DPRINTF(("<--- TCP %s%s%s:%d/n",                 ss.ss_family == AF_INET6 ? "[" : "",                 addrstr,                 ss.ss_family == AF_INET6 ? "]" : "",                 peer_port));    }#endif  /* DPRINTF */    pxtcp = pxtcp_create_forwarded(newsock);    if (pxtcp == NULL) {        proxy_reset_socket(newsock);        return POLLIN;    }    status = pxtcp_pmgr_add(pxtcp);    if (status < 0) {        pxtcp_cancel_forwarded(pxtcp);        return POLLIN;    }    error = sys_mbox_trypost(&fwtcp->connmbox, (void *)pxtcp);    if (error != ERR_OK) {        pxtcp_pmgr_del(pxtcp);        pxtcp_cancel_forwarded(pxtcp);        return POLLIN;    }    proxy_lwip_post(&fwtcp->msg_connect);    return POLLIN;}

/*----------------------------------------------------------------------*/void sys_mbox_post(sys_mbox_t mbox, void *msg){  sys_mbox_trypost(mbox, msg); }

/** * Try to post a callback-message to the tcpip_thread mbox * This is intended to be used to send "static" messages from interrupt context. * * @param msg pointer to the message to post * @return sys_mbox_trypost() return code */err_ttcpip_trycallback(struct tcpip_callback_msg* msg){  LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(mbox));  return sys_mbox_trypost(&mbox, msg);}