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

/* Shut down  the UDP and network stuff */bool netShutdown(NetPath *netPath){	struct ip_addr multicastAaddr;	DBG("netShutdown/n");	/* leave multicast group */	multicastAaddr.addr = netPath->multicastAddr;	igmp_leavegroup(IP_ADDR_ANY, &multicastAaddr);	/* Disconnect and close the Event UDP interface */	if (netPath->eventPcb)	{		udp_disconnect(netPath->eventPcb);		udp_remove(netPath->eventPcb);		netPath->eventPcb = NULL;	}	/* Disconnect and close the General UDP interface */	if (netPath->generalPcb)	{		udp_disconnect(netPath->generalPcb);		udp_remove(netPath->generalPcb);		netPath->generalPcb = NULL;	}	/* Clear the network addresses. */	netPath->multicastAddr = 0;	netPath->unicastAddr = 0;	/* Return a success code. */	return TRUE;}

/* shut down the UDP stuff */Boolean netShutdown(NetPath *netPath){    /* Disconnect and close the Event UDP interface */    if(netPath->eventPcb) {        udp_disconnect(netPath->eventPcb);        udp_remove(netPath->eventPcb);    }    /* Disconnect and close the General UDP interface */    if(netPath->generalPcb) {        udp_disconnect(netPath->generalPcb);        udp_remove(netPath->generalPcb);    }    /* Free up the Event and General Tx PBUFs. */    if(netPath->eventTxBuf) {        pbuf_free(netPath->eventTxBuf);    }    if(netPath->generalTxBuf) {        pbuf_free(netPath->generalTxBuf);    }    /* Clear the network addresses. */    netPath->multicastAddr = 0;    netPath->unicastAddr = 0;    /* Return a success code. */    return TRUE;}

/** * New proxied UDP conversation created. * Global callback for udp_proxy_accept(). */static voidpxudp_pcb_accept(void *arg, struct udp_pcb *newpcb, struct pbuf *p,                 ip_addr_t *addr, u16_t port){    struct pxudp *pxudp;    ipX_addr_t dst_addr;    int mapping;    int sdom;    SOCKET sock;    LWIP_ASSERT1(newpcb != NULL);    LWIP_ASSERT1(p != NULL);    LWIP_UNUSED_ARG(arg);    pxudp = pxudp_allocate();    if (pxudp == NULL) {        DPRINTF(("pxudp_allocate: failed/n"));        udp_remove(newpcb);        pbuf_free(p);        return;    }    sdom = PCB_ISIPV6(newpcb) ? PF_INET6 : PF_INET;    mapping = pxremap_outbound_ipX(PCB_ISIPV6(newpcb), &dst_addr, &newpcb->local_ip);#if 0 /* XXX: DNS IPv6->IPv4 remapping hack */    if (mapping == PXREMAP_MAPPED        && newpcb->local_port == 53        && PCB_ISIPV6(newpcb))    {        /*         * "Remap" DNS over IPv6 to IPv4 since Ubuntu dnsmasq does not         * listen on IPv6.         */        sdom = PF_INET;        ipX_addr_set_loopback(0, &dst_addr);    }#endif  /* DNS IPv6->IPv4 remapping hack */    sock = proxy_connected_socket(sdom, SOCK_DGRAM,                                  &dst_addr, newpcb->local_port);    if (sock == INVALID_SOCKET) {        udp_remove(newpcb);        pbuf_free(p);        return;    }    pxudp->sock = sock;    pxudp->pcb = newpcb;    udp_recv(newpcb, pxudp_pcb_recv, pxudp);    pxudp->pmhdl.callback = pxudp_pmgr_pump;    pxudp_chan_send(POLLMGR_CHAN_PXUDP_ADD, pxudp);    /* dispatch directly instead of calling pxudp_pcb_recv() */    pxudp_pcb_forward_outbound(pxudp, p, addr, port);}

err_t mdns_responder_init(const struct mdns_service *services,                          int num_services,                          const char *txt_records[]){    err_t ret;    memset(&mdns_state, 0, sizeof(mdns_state));    mdns_state.netif = &gs_net_if;    setup_hostnames(&mdns_state, &gs_net_if);    setup_txt_records(&mdns_state, txt_records);    mdns_state.services = services;    mdns_state.num_services = num_services;    struct ip_addr ipgroup;    IP4_ADDR(&ipgroup, 224, 0, 0, 251);    mdns_state.sendpcb = udp_new();    if (mdns_state.sendpcb == NULL)        return ERR_MEM;    struct udp_pcb *pcb = udp_new();    if (pcb == NULL) {        udp_remove(mdns_state.sendpcb);        return ERR_MEM;    }    if ((ret = igmp_joingroup(IP_ADDR_ANY, &ipgroup)) != ERR_OK)        return ret;    ip_set_option(pcb, SOF_REUSEADDR);    ip_set_option(mdns_state.sendpcb, SOF_REUSEADDR);    if ((ret = udp_bind(pcb, IP_ADDR_ANY, MDNS_PORT)) != ERR_OK)        goto error_exit;    udp_recv(pcb, recv, &mdns_state);    if ((ret = udp_bind(mdns_state.sendpcb, 0, MDNS_PORT)) != ERR_OK)        goto error_exit;    if ((ret = udp_connect(mdns_state.sendpcb, &ipgroup, MDNS_PORT)) != ERR_OK)        goto error_exit;    return ERR_OK;error_exit:    udp_remove(pcb);    udp_remove(mdns_state.sendpcb);    return ret;}

void ESP8266NetBIOS::end(){    if(_pcb != NULL) {        udp_remove(_pcb);        _pcb = NULL;    }}

/****************************************************************************** * FunctionName : udp_test_port_init * Returns      : none*******************************************************************************/void ICACHE_FLASH_ATTR udp_test_port_init(uint16 portn){	  struct udp_pcb *pcb;#if DEBUGSOO > 0	   os_printf("/nUDP Test port %d init... ", portn);#endif	   pcb = udp_new();	   if(pcb != NULL) {		   err_t err = udp_bind(pcb, IP_ADDR_ANY, portn);		   if(err != ERR_OK) {#if DEBUGSOO > 0			   os_printf("Error bind/n");#endif			   udp_remove(pcb);			   return;		   };		   udp_recv(pcb, udp_test_port_recv, pcb);	   }	   else {#if DEBUGSOO > 0	   os_printf("Error mem/n");#endif	   }#if DEBUGSOO > 0	   os_printf("Ok/n");#endif}

/**  * @brief  Initialize the server application.  * @param  None  * @retval None  */void udp_echoserver_init(void){   struct udp_pcb *upcb;   err_t err;      /* Create a new UDP control block  */   upcb = udp_new();      if (upcb)   {     /* Bind the upcb to the UDP_PORT port */     /* Using IP_ADDR_ANY allow the upcb to be used by any local interface */      err = udp_bind(upcb, IP_ADDR_ANY, UDP_SERVER_PORT);            if(err == ERR_OK)      {        /* Set a receive callback for the upcb */        udp_recv(upcb, udp_echoserver_receive_callback, NULL);      }      else      {        udp_remove(upcb);      }   }}

intinit_transport(struct ip_addr server){    struct pbuf *pbuf;    udp_cnx = udp_new();    udp_recv(udp_cnx, time_recv, (void*) L4_Myself().raw);    udp_bind(udp_cnx, IP_ADDR_ANY, NFS_LOCAL_PORT);    udp_connect(udp_cnx, &server, 37 /* Time port */);    do {	pbuf = pbuf_alloc(PBUF_TRANSPORT, UDP_PAYLOAD, PBUF_RAM);	udp_send(udp_cnx, pbuf);	sos_usleep(100);	pbuf_free(pbuf);    } while (time_of_day == 0);    udp_remove(udp_cnx);    cur_xid = time_of_day * 10000; /* Generate a randomish xid */    udp_cnx = udp_new();    udp_recv(udp_cnx, my_recv, NULL);    udp_connect(udp_cnx, &server, 0);    udp_bind(udp_cnx, IP_ADDR_ANY, NFS_LOCAL_PORT);    return 0;}

void mg_if_destroy_conn(struct mg_connection *nc) {  int i;  if (nc->sock != INVALID_SOCKET) {    struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;    if (!(nc->flags & MG_F_UDP)) {      struct tcp_pcb *tpcb = cs->pcb.tcp;      if (tpcb != NULL) {        tcp_arg(tpcb, NULL);        DBG(("%p tcp_close %p", nc, tpcb));        tcp_arg(tpcb, NULL);        tcp_close(tpcb);      }      while (cs->rx_chain != NULL) {        struct pbuf *seg = cs->rx_chain;        cs->rx_chain = pbuf_dechain(cs->rx_chain);        pbuf_free(seg);      }    } else {      struct udp_pcb *upcb = cs->pcb.udp;      if (upcb != NULL) {        DBG(("%p udp_remove %p", nc, upcb));        udp_remove(upcb);      }    }    memset(cs, 0, sizeof(*cs));    free(cs);    nc->sock = INVALID_SOCKET;  }  /* Walk the queue and null-out further signals for this conn. */  for (i = 0; i < MG_TASK_QUEUE_LEN; i++) {    if ((struct mg_connection *) s_mg_task_queue[i].par == nc) {      s_mg_task_queue[i].sig = MG_SIG_TOMBSTONE;    }  }}

// Lua: client/server/socket:close()int net_close( lua_State *L ) {  lnet_userdata *ud = net_get_udata(L);  if (!ud) return luaL_error(L, "invalid user data");  if (ud->pcb) {    switch (ud->type) {      case TYPE_TCP_CLIENT:        if (ERR_OK != tcp_close(ud->tcp_pcb)) {          tcp_arg(ud->tcp_pcb, NULL);          tcp_abort(ud->tcp_pcb);        }        ud->tcp_pcb = NULL;        break;      case TYPE_TCP_SERVER:        tcp_close(ud->tcp_pcb);        ud->tcp_pcb = NULL;        break;      case TYPE_UDP_SOCKET:        udp_remove(ud->udp_pcb);        ud->udp_pcb = NULL;        break;    }  } else {    return luaL_error(L, "not connected");  }  if (ud->type == TYPE_TCP_SERVER ||     (ud->pcb == NULL && ud->client.wait_dns == 0)) {    lua_gc(L, LUA_GCSTOP, 0);    luaL_unref(L, LUA_REGISTRYINDEX, ud->self_ref);    ud->self_ref = LUA_NOREF;    lua_gc(L, LUA_GCRESTART, 0);  }  return 0;}

/** * Clean up and free the ttcp structure */static void ard_tcp_destroy(struct ttcp* ttcp) {	err_t err = ERR_OK;	DUMP_TCP_STATE(ttcp);	if (getSock(ttcp)==-1)		WARN("ttcp already deallocated!/n");	if (ttcp->tpcb) {		tcp_arg(ttcp->tpcb, NULL);		tcp_sent(ttcp->tpcb, NULL);		tcp_recv(ttcp->tpcb, NULL);		tcp_err(ttcp->tpcb, NULL);		//TEMPORAQARY		//err = tcp_close(ttcp->tpcb);		INFO_TCP("Closing tpcb: state:0x%x err:%d/n", ttcp->tpcb->state, err);	}	if (ttcp->lpcb) {		tcp_arg(ttcp->lpcb, NULL);		tcp_accept(ttcp->lpcb, NULL);		err = tcp_close(ttcp->lpcb);		INFO_TCP("Closing lpcb: state:0x%x err:%d/n", ttcp->lpcb->state, err);	}	if (ttcp->upcb) {		udp_disconnect(ttcp->upcb);		udp_remove(ttcp->upcb);	}	if (ttcp->payload)		free(ttcp->payload);	free(ttcp);}

err_t simple_discovery_init(struct netif *netif){    err_t ret;    struct udp_pcb *pcb = udp_new();    if (pcb == NULL)        return ERR_MEM;#if LWIP_IGMP    struct ip_addr ipgroup;    IP4_ADDR(&ipgroup, 224, 0, 0, 178);    if ((ret = igmp_joingroup(IP_ADDR_ANY, &ipgroup)) != ERR_OK)        goto error_exit;#endif    if ((ret = udp_bind(pcb, IP_ADDR_ANY, SIMPLE_DISCOVERY_PORT)) != ERR_OK)        goto error_exit;    udp_recv(pcb, recv, netif);    return ERR_OK;error_exit:    udp_remove(pcb);    return ret;}

/** @ingroup tftp * Deinitialize ("turn off") TFTP client/server. */void tftp_cleanup(void){  LWIP_ASSERT("Cleanup called on non-initialized TFTP", tftp_state.upcb != NULL);  udp_remove(tftp_state.upcb);  close_handle();  memset(&tftp_state, 0, sizeof(tftp_state));}

/** * Initialize TFTP client/server. * @param mode TFTP mode (client/server) * @param ctx TFTP callback struct */err_ttftp_init_common(u8_t mode, const struct tftp_context *ctx){  err_t ret;  /* LWIP_ASSERT_CORE_LOCKED(); is checked by udp_new() */  struct udp_pcb *pcb = udp_new_ip_type(IPADDR_TYPE_ANY);  if (pcb == NULL) {    return ERR_MEM;  }  ret = udp_bind(pcb, IP_ANY_TYPE, TFTP_PORT);  if (ret != ERR_OK) {    udp_remove(pcb);    return ret;  }  tftp_state.handle    = NULL;  tftp_state.port      = 0;  tftp_state.ctx       = ctx;  tftp_state.timer     = 0;  tftp_state.last_data = NULL;  tftp_state.upcb      = pcb;  tftp_state.tftp_mode = mode;  udp_recv(pcb, recv, NULL);  return ERR_OK;}

err_t tftp_init(const struct tftp_context *ctx){    err_t ret;    struct udp_pcb *pcb = udp_new();    if (pcb == NULL)        return ERR_MEM;    if ((ret = udp_bind(pcb, IP_ADDR_ANY, TFTP_PORT)) != ERR_OK)        goto error_exit;    tftp_state.handle = NULL;    tftp_state.port = 0;    tftp_state.ctx = ctx;    tftp_state.timer = 0;    tftp_state.last_data = NULL;    udp_recv(pcb, recv, &tftp_state);    return ERR_OK;error_exit:    udp_remove(pcb);    return ret;}

/** * Clean up and free the ttcp structure */static void ard_tcp_abort(struct ttcp* ttcp) {	INFO_TCP("Abort ttcb:%p tpcb:%p lpcb:%p/n", ttcp, ttcp->tpcb, ttcp->lpcb);	if (ttcp->tpcb) {		tcp_arg(ttcp->tpcb, NULL);		tcp_sent(ttcp->tpcb, NULL);		tcp_recv(ttcp->tpcb, NULL);		tcp_err(ttcp->tpcb, NULL);		tcp_abort(ttcp->tpcb);	}	if (ttcp->lpcb) {		tcp_arg(ttcp->lpcb, NULL);		tcp_accept(ttcp->lpcb, NULL);		tcp_abort(ttcp->lpcb);	}	if (ttcp->upcb) {		udp_disconnect(ttcp->upcb);		udp_remove(ttcp->upcb);	}	if (ttcp->payload)		free(ttcp->payload);	free(ttcp);}

/** @ingroup tftp * Initialize TFTP server. * @param ctx TFTP callback struct */err_t tftp_init(const struct tftp_context *ctx){  err_t ret;  struct udp_pcb *pcb = udp_new_ip_type(IPADDR_TYPE_ANY);  if (pcb == NULL) {    return ERR_MEM;  }  ret = udp_bind(pcb, IP_ANY_TYPE, TFTP_PORT);  if (ret != ERR_OK) {    udp_remove(pcb);    return ret;  }  tftp_state.handle    = NULL;  tftp_state.port      = 0;  tftp_state.ctx       = ctx;  tftp_state.timer     = 0;  tftp_state.last_data = NULL;  tftp_state.upcb      = pcb;  udp_recv(pcb, recv, NULL);  return ERR_OK;}

STATIC mp_obj_t lwip_socket_close(mp_obj_t self_in) {    lwip_socket_obj_t *socket = self_in;    bool socket_is_listener = false;    if (socket->pcb.tcp == NULL) {        return mp_const_none;    }    switch (socket->type) {        case MOD_NETWORK_SOCK_STREAM: {            if (socket->pcb.tcp->state == LISTEN) {                socket_is_listener = true;            }            if (tcp_close(socket->pcb.tcp) != ERR_OK) {                tcp_abort(socket->pcb.tcp);            }            break;        }        case MOD_NETWORK_SOCK_DGRAM: udp_remove(socket->pcb.udp); break;        //case MOD_NETWORK_SOCK_RAW: raw_remove(socket->pcb.raw); break;    }    socket->pcb.tcp = NULL;    socket->state = _ERR_BADF;    if (socket->incoming.pbuf != NULL) {        if (!socket_is_listener) {            pbuf_free(socket->incoming.pbuf);        } else {            tcp_abort(socket->incoming.connection);        }        socket->incoming.pbuf = NULL;    }    return mp_const_none;}

int udp_echo_server_init(void){    int r;    uint16_t bind_port = 7; //don't use htons() (don't know why...)    //create a new UDP PCB    struct udp_pcb *pcb = udp_new(); //UDP connection data    if (pcb == NULL) {        return ERR_MEM;    }    //bind it to every IP of every interface and define a specific port to    //bind to    r = udp_bind(pcb, IP_ADDR_ANY, bind_port);    if(r != ERR_OK) {        udp_remove(pcb);        return(r);    }    printf("udp_echo_server_init(): bound./n");    //install a callback for received datagrams    udp_recv(pcb, echo_recv_handler, 0 /*client data, arg in callback*/);    printf("installed receive callback./n");    struct pbuf * test_pbuf = pbuf_alloc(PBUF_RAW, 256, PBUF_RAM);    memcpy(test_pbuf->payload, "DDDDDDDDDUUUUUUUUU", 16);    netif_default->linkoutput(netif_default, test_pbuf);    return (0);}

/** * Clean up and free the ttcp structure */static voidttcp_destroy(struct ttcp* ttcp){        if (ttcp->tpcb) {                tcp_arg(ttcp->tpcb, NULL);                tcp_sent(ttcp->tpcb, NULL);                tcp_recv(ttcp->tpcb, NULL);                tcp_err(ttcp->tpcb, NULL);                tcp_close(ttcp->tpcb);        }        if (ttcp->lpcb) {                tcp_arg(ttcp->lpcb, NULL);                tcp_accept(ttcp->lpcb, NULL);                tcp_close(ttcp->lpcb);        }        if (ttcp->upcb) {                udp_disconnect(ttcp->upcb);                udp_remove(ttcp->upcb);        }        if (ttcp->payload)                free(ttcp->payload);        timer_cancel_timeout(ttcp->tid);        free(ttcp);}

void ICACHE_FLASH_ATTR dhcps_start(struct ip_info *info){	struct netif * apnetif = (struct netif *)eagle_lwip_getif(0x01);	if(apnetif->dhcps_pcb != NULL) {        udp_remove(apnetif->dhcps_pcb);    }	pcb_dhcps = udp_new();	if (pcb_dhcps == NULL || info ==NULL) {		os_printf("dhcps_start(): could not obtain pcb/n");	}	apnetif->dhcps_pcb = pcb_dhcps;	IP4_ADDR(&broadcast_dhcps, 255, 255, 255, 255);	server_address = info->ip;	wifi_softap_init_dhcps_lease(server_address.addr);	client_address_plus.addr = dhcps_lease.start_ip.addr;	udp_bind(pcb_dhcps, IP_ADDR_ANY, DHCPS_SERVER_PORT);	udp_recv(pcb_dhcps, handle_dhcp, NULL);#if DHCPS_DEBUG	os_printf("dhcps:dhcps_start->udp_recv function Set a receive callback handle_dhcp for UDP_PCB pcb_dhcps/n");#endif}

STATIC mp_obj_t lwip_socket_close(mp_obj_t self_in) {    lwip_socket_obj_t *socket = self_in;    bool socket_is_listener = false;    if (socket->pcb == NULL) {        return mp_const_none;    }    switch (socket->type) {        case MOD_NETWORK_SOCK_STREAM: {            if (((struct tcp_pcb*)socket->pcb)->state == LISTEN) {                socket_is_listener = true;            }            if (tcp_close((struct tcp_pcb*)socket->pcb) != ERR_OK) {                tcp_abort((struct tcp_pcb*)socket->pcb);            }            break;        }        case MOD_NETWORK_SOCK_DGRAM: udp_remove((struct udp_pcb*)socket->pcb); break;        //case MOD_NETWORK_SOCK_RAW: raw_remove((struct raw_pcb*)socket->pcb); break;    }    socket->pcb = NULL;    socket->connected = -16; // EBADF    if (socket->incoming != NULL) {        if (!socket_is_listener) {            pbuf_free((struct pbuf*)socket->incoming);        } else {            tcp_abort((struct tcp_pcb*)socket->incoming);        }        socket->incoming = NULL;    }    return mp_const_none;}

void ICACHE_FLASH_ATTR dhcps_stop(void){	struct netif * apnetif = (struct netif *)eagle_lwip_getif(0x01);	udp_disconnect(pcb_dhcps);	dhcps_lease_flag = true;    if(apnetif->dhcps_pcb != NULL) {        udp_remove(apnetif->dhcps_pcb);        apnetif->dhcps_pcb = NULL;    }	//udp_remove(pcb_dhcps);	list_node *pnode = NULL;	list_node *pback_node = NULL;	pnode = plist;	while (pnode != NULL) {		pback_node = pnode;		pnode = pback_node->pnext;		node_remove_from_list(&plist, pback_node);		os_free(pback_node->pnode);		pback_node->pnode = NULL;		os_free(pback_node);		pback_node = NULL;	}}

/****************************************************************************** * FunctionName : espconn_udp_server * Description  : Initialize the server: set up a PCB and bind it to the port * Parameters   : pespconn -- the espconn used to build server * Returns      : none*******************************************************************************/sint8 ICACHE_FLASH_ATTRespconn_udp_server(struct espconn *pespconn){    struct udp_pcb *upcb = NULL;    espconn_msg *pserver = NULL;    upcb = udp_new();    if (upcb == NULL) {        return ESPCONN_MEM;    } else {        pserver = (espconn_msg *)os_zalloc(sizeof(espconn_msg));        if (pserver == NULL) {            udp_remove(upcb);            return ESPCONN_MEM;        }        pserver->pcommon.pcb = upcb;        pserver->pespconn = pespconn;        espconn_list_creat(&plink_active, pserver);        udp_bind(upcb, IP_ADDR_ANY, pserver->pespconn->proto.udp->local_port);        udp_recv(upcb, espconn_udp_recv, (void *)pserver);        return ESPCONN_OK;    }}

/**@brief Creates port as requested in p_port. * * @details Creates port as requested in p_port. * * @param[in]   index    Index to the m_port_table where entry of the port created is to be made. * @param[in]   p_port   Port information to be created. * * @retval NRF_SUCCESS   Indicates if port was created successfully, else an an  error code *                       indicating reason for failure. */static uint32_t port_create(uint32_t index, coap_port_t  * p_port){    err_t           err = NRF_ERROR_NO_MEM;    ip6_addr_t      any_addr;    struct udp_pcb * p_socket = m_port_table[index].p_socket;    ip6_addr_set_any(&any_addr);    //Request new socket creation.    p_socket = udp_new();    if (NULL != p_socket)    {        // Bind the socket to the local port.        err = udp_bind(p_socket, &any_addr, p_port->port_number);        if (err == ERR_OK)        {            //Register data receive callback.            udp_recv(p_socket, udp_recv_data_handler, &m_port_table[index]);            //All procedure with respect to port creation succeeded, make entry in the table.            m_port_table[index].port_number = p_port->port_number;            m_port_table[index].p_socket    = p_socket;        }        else        {            //Not all procedures succeeded with allocated socket, hence free it.            err = NRF_ERROR_INVALID_PARAM;            udp_remove(p_socket);        }    }    return err;}

/*  * FIXME: currently we associate a connection with a thread (and an * upcall thread), which is restrictive. */net_connection_t net_create_udp_connection(spdid_t spdid, long evt_id){	struct udp_pcb *up;	struct intern_connection *ic;	net_connection_t ret;	up = udp_new();		if (NULL == up) {		prints("Could not allocate udp connection");		ret = -ENOMEM;		goto err;	}	ic = net_conn_alloc(UDP, cos_get_thd_id(), evt_id);	if (NULL == ic) {		prints("Could not allocate internal connection");		ret = -ENOMEM;		goto udp_err;	}	ic->spdid = spdid;	ic->conn.up = up;	udp_recv(up, cos_net_lwip_udp_recv, (void*)ic);	return net_conn_get_opaque(ic);udp_err:	udp_remove(up);err:	return ret;}

/* * 函数名：updd_Send * 描述  ：发送udp数据包 * 输入  ：无 * 输出  : 无 * 调用  ：外部调用 */void udpd_Send(void){	struct udp_pcb *UdpPcb;   struct ip_addr ipaddr;   struct pbuf *p;	err_t err = ERR_Mine;	//测试用		p = pbuf_alloc(PBUF_RAW,sizeof(UDPData),PBUF_RAM);   p->payload=(void *)UDPData;    	UdpPcb = udp_new(); 	udp_bind(UdpPcb,IP_ADDR_ANY,6000);       /* 绑定本地IP 地址 */   IP4_ADDR(&ipaddr,192,168,1,122);     err = udp_connect(UdpPcb,&ipaddr,6001);   /* 连接远程主机 */ 		if(err == ERR_OK)	{		err = ERR_Mine;	//测试用		err = udp_send(UdpPcb, p);	}		udp_disconnect(UdpPcb);	pbuf_free(p);	udp_remove(UdpPcb);}

/** * Delete the pcb inside a netconn. * Called from netconn_delete. * * @param msg the api_msg_msg pointing to the connection */voidlwip_netconn_do_delconn(struct api_msg_msg *msg){  /* @todo TCP: abort running write/connect? */ if ((msg->conn->state != NETCONN_NONE) &&     (msg->conn->state != NETCONN_LISTEN) &&     (msg->conn->state != NETCONN_CONNECT)) {    /* this only happens for TCP netconns */    LWIP_ASSERT("NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP",                NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP);    msg->err = ERR_INPROGRESS;  } else {    LWIP_ASSERT("blocking connect in progress",      (msg->conn->state != NETCONN_CONNECT) || IN_NONBLOCKING_CONNECT(msg->conn));    /* Drain and delete mboxes */    netconn_drain(msg->conn);    if (msg->conn->pcb.tcp != NULL) {      switch (NETCONNTYPE_GROUP(msg->conn->type)) {#if LWIP_RAW      case NETCONN_RAW:        raw_remove(msg->conn->pcb.raw);        break;#endif /* LWIP_RAW */#if LWIP_UDP      case NETCONN_UDP:        msg->conn->pcb.udp->recv_arg = NULL;        udp_remove(msg->conn->pcb.udp);        break;#endif /* LWIP_UDP */#if LWIP_TCP      case NETCONN_TCP:        LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL &&          msg->conn->write_offset == 0);        msg->conn->state = NETCONN_CLOSE;        msg->msg.sd.shut = NETCONN_SHUT_RDWR;        msg->conn->current_msg = msg;        lwip_netconn_do_close_internal(msg->conn);        /* API_EVENT is called inside lwip_netconn_do_close_internal, before releasing           the application thread, so we can return at this point! */        return;#endif /* LWIP_TCP */      default:        break;      }      msg->conn->pcb.tcp = NULL;    }    /* tcp netconns don't come here! */    /* @todo: this lets select make the socket readable and writable,       which is wrong! errfd instead? */    API_EVENT(msg->conn, NETCONN_EVT_RCVPLUS, 0);    API_EVENT(msg->conn, NETCONN_EVT_SENDPLUS, 0);  }  if (sys_sem_valid(&msg->conn->op_completed)) {    sys_sem_signal(&msg->conn->op_completed);  }}

/** * Stop this module. */voidsntp_stop(void){  if (sntp_pcb != NULL) {    sys_untimeout(sntp_request, NULL);    udp_remove(sntp_pcb);    sntp_pcb = NULL;  }}

static void udp_close_cb(void *ctx_p){    struct socket_t *socket_p = ctx_p;    udp_recv(socket_p->pcb_p, NULL, NULL);    udp_remove(socket_p->pcb_p);    resume_thrd(socket_p->input.cb.thrd_p, 0);}