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

/* 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;}

/* * 函数名：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);}

/** * 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_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;	}}

void client_init(void){    struct udp_pcb *upcb;    struct pbuf *p;    SET_IP4_ADDR(&ip_udp_server,UDP_SERVER_IP);    /* Create a new UDP control block  */    upcb = udp_new();    p = pbuf_alloc(PBUF_TRANSPORT, sizeof(Sent), PBUF_RAM);    p->payload = (void*)Sent;    upcb->local_port = 5;    udp_connect(upcb, &ip_udp_server, UDP_SERVER_PORT);    udp_send(upcb, p);    /* Reset the upcb */    udp_disconnect(upcb);    /* Bind the upcb to any IP address and the UDP_PORT port*/    udp_bind(upcb, IP_ADDR_ANY, 5);    udp_recv(upcb, udp_client_callback, NULL);    /* Free the p buffer */    pbuf_free(p);}

static voiddo_disconnect(struct api_msg_msg *msg){  switch (msg->conn->type) {#if LWIP_RAW  case NETCONN_RAW:    /* Do nothing as connecting is only a helper for upper lwip layers */    break;#endif#if LWIP_UDP  case NETCONN_UDPLITE:    /* FALLTHROUGH */  case NETCONN_UDPNOCHKSUM:    /* FALLTHROUGH */  case NETCONN_UDP:    udp_disconnect(msg->conn->pcb.udp);    break;#endif   case NETCONN_TCP:    break;  default:    LWIP_ASSERT( "do_newconn: msg->conn->type unknown/n", 0 );  }  sys_mbox_post(msg->conn->mbox, NULL);}

/** * 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);}

/** * 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);}

void trans_Control(void* buf, size_t len) {	struct pbuf *p;	p = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_POOL);	if (p != NULL) {		pbuf_take(p, buf, len);    /* send udp data */		udp_connect(upcb_c, &BagAddr.BagIPaddr, BagAddr.port_c);    udp_send(upcb_c, p);  		udp_disconnect(upcb_c);    /* free pbuf */    pbuf_free(p);  }	return;}

/** * Connect a pcb contained inside a netconn * Only used for UDP netconns. * Called from netconn_disconnect. * * @param msg the api_msg_msg pointing to the connection to disconnect */voiddo_disconnect(struct api_msg_msg *msg){#if LWIP_UDP    if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) {        udp_disconnect(msg->conn->pcb.udp);        msg->err = ERR_OK;    } else#endif /* LWIP_UDP */    {        msg->err = ERR_VAL;    }    TCPIP_APIMSG_ACK(msg);}

void 	udp_echoserver_receive_callback(void *arg, struct udp_pcb *upcb, struct pbuf *p, struct ip_addr *addr, u16_t port) {		char c[64];		union {int i;char c[4];} ipaddr;		ipaddr.i=(int)netif_default->ip_addr.addr;		pbuf_free(p);  		sprintf(c,"LwIP %d.%d.%d.%d",ipaddr.c[0],ipaddr.c[1],ipaddr.c[2],ipaddr.c[3]);		p = pbuf_alloc(PBUF_TRANSPORT, strlen(c) , PBUF_POOL);		pbuf_take(p,c,strlen(c));		udp_connect(upcb, addr, port);		udp_send(upcb, p);		udp_disconnect(upcb);		pbuf_free(p);  }

/**  * @brief This function is called when an UDP datagrm has been received on the port UDP_PORT.  * @param arg user supplied argument (udp_pcb.recv_arg)  * @param pcb the udp_pcb which received data  * @param p the packet buffer that was received  * @param addr the remote IP address from which the packet was received  * @param port the remote port from which the packet was received  * @retval None  */void udp_echoserver_receive_callback(void *arg, struct udp_pcb *upcb, struct pbuf *p, struct ip_addr *addr, u16_t port){  /* Connect to the remote client */  udp_connect(upcb, addr, UDP_CLIENT_PORT);      /* Tell the client that we have accepted it */  udp_send(upcb, p);  /* free the UDP connection, so we can accept new clients */  udp_disconnect(upcb);	  /* Free the p buffer */  pbuf_free(p);   }

/**  * @brief Cleanup after end of TFTP read operation  * @param upcb: pointer on udp pcb  * @param  args: pointer on a structure of type tftp_connection_args  * @retval None  */void tftp_cleanup_rd(struct udp_pcb *upcb, tftp_connection_args *args){  /* close the filesystem */  f_close(&file_SD);  f_mount(NULL, NULL, 0);  /* Free the tftp_connection_args structure reserverd for */  mem_free(args);  /* Disconnect the udp_pcb*/    udp_disconnect(upcb);  /* close the connection */  udp_remove(upcb);  udp_recv(UDPpcb, recv_callback_tftp, NULL);}

static socket_error_t lwipv4_socket_close(struct socket *sock){    err_t err = ERR_OK;    if (sock == NULL || sock->impl == NULL)        return SOCKET_ERROR_NULL_PTR;    switch (sock->family) {    case SOCKET_DGRAM:        udp_disconnect((struct udp_pcb *)sock->impl);        break;    case SOCKET_STREAM:        err = tcp_close((struct tcp_pcb *)sock->impl);        break;    default:        return SOCKET_ERROR_BAD_FAMILY;    }    return lwipv4_socket_error_remap(err);}

/* close the file writen, disconnect and close the connection */void tftp_cleanup_wr(struct udp_pcb *upcb, tftp_connection_args *args){  /* close the filesystem */  file_fclose(&file_CR);  fs_umount(&efs2.myFs);  /* Free the tftp_connection_args structure reserverd for */  mem_free(args);  /* Disconnect the udp_pcb*/  udp_disconnect(upcb);  /* close the connection */  udp_remove(upcb);  /* reset the callback function */  udp_recv(UDPpcb, recv_callback_tftp, NULL);}

/****************************************************************************** * FunctionName : espconn_udp_disconnect * Description  : A new incoming connection has been disconnected. * Parameters   : espconn -- the espconn used to disconnect with host * Returns      : none*******************************************************************************/void ICACHE_FLASH_ATTR espconn_udp_disconnect(espconn_msg *pdiscon){    if (pdiscon == NULL) {        return;    }    struct udp_pcb *upcb = pdiscon->pcommon.pcb;    udp_disconnect(upcb);    udp_remove(upcb);    espconn_list_delete(&plink_active, pdiscon);    os_free(pdiscon);    pdiscon = NULL;}

void trans_Data(short* buf_ch1, short* buf_ch2, unsigned short num) {	int i = 0;	struct pbuf *p;	for(; i < num; i++) {		memcpy(&packData.sampl[4 * i], &buf_ch1[2 * i], 2 * sizeof(short));		memcpy(&packData.sampl[4 * i + 2], &buf_ch2[2 * i], 2 * sizeof(short));	}	p = pbuf_alloc(PBUF_TRANSPORT, sizeof(packData), PBUF_POOL);	if (p != NULL) {		pbuf_take(p, &packData, sizeof(packData));    /* send udp data */		udp_connect(upcb_d, &BagAddr.BagIPaddr, BagAddr.port_d);    udp_send(upcb_d, p);  		udp_disconnect(upcb_d);    /* free pbuf */    pbuf_free(p);  }}

static voiddo_disconnect(struct api_msg_msg *msg){  switch (msg->conn->type) {#if LWIP_UDP  case NETCONN_UDPLITE:    /* FALLTHROUGH */  case NETCONN_UDPNOCHKSUM:    /* FALLTHROUGH */  case NETCONN_UDP:    udp_disconnect(msg->conn->pcb.udp);    break;#endif   case NETCONN_TCP:    break;  }  sys_mbox_post(msg->conn->mbox, NULL);}

/**  * close - the function will close the file  *                      * @param fd the file handle  *  * @return the result  */int _close(int fd){    struct socket *socket = (struct socket *)fd;    int ret = -1;       if (SOCK_STREAM == socket->type)    {        ret = tcp_close(socket->pcb);    }    else if (SOCK_PACKET == socket->type)    {        udp_disconnect(socket->pcb);        ret = 0;    }        free(socket);      return ret;}

void ICACHE_FLASH_ATTR dhcps_stop(void){//	struct netif * nif = eagle_lwip_getif(1);	udp_disconnect(pcb_dhcps);	udp_remove(pcb_dhcps);//	nif->dhcp = NULL;	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;	}	dhcps_lease_flag = true;}

/** * Sends an generic or enterprise specific trap message. * * @param generic_trap is the trap code * @param eoid points to enterprise object identifier * @param specific_trap used for enterprise traps when generic_trap == 6 * @return ERR_OK when success, ERR_MEM if we're out of memory * * @note the caller is responsible for filling in outvb in the trap_msg * @note the use of the enterpise identifier field * is per RFC1215. * Use .iso.org.dod.internet.mgmt.mib-2.snmp for generic traps * and .iso.org.dod.internet.private.enterprises.yourenterprise * (sysObjectID) for specific traps. */err_tsnmp_send_trap(s8_t generic_trap, struct snmp_obj_id *eoid, s32_t specific_trap){  struct snmp_trap_dst *td;  struct netif *dst_if;  struct ip_addr dst_ip;  struct pbuf *p;  u16_t i,tot_len;  for (i=0, td = &trap_dst[0]; i<SNMP_TRAP_DESTINATIONS; i++, td++)  {    if ((td->enable != 0) && (td->dip.addr != 0))    {      /* network order trap destination */      trap_msg.dip.addr = td->dip.addr;      /* lookup current source address for this dst */      dst_if = ip_route(&td->dip);      dst_ip.addr = ntohl(dst_if->ip_addr.addr);      trap_msg.sip_raw[0] = dst_ip.addr >> 24;      trap_msg.sip_raw[1] = dst_ip.addr >> 16;      trap_msg.sip_raw[2] = dst_ip.addr >> 8;      trap_msg.sip_raw[3] = dst_ip.addr;      trap_msg.gen_trap = generic_trap;      trap_msg.spc_trap = specific_trap;      if (generic_trap == SNMP_GENTRAP_ENTERPRISESPC)      {        /* enterprise-Specific trap */        trap_msg.enterprise = eoid;      }      else      {        /* generic (MIB-II) trap */        snmp_get_snmpgrpid_ptr(&trap_msg.enterprise);      }      snmp_get_sysuptime(&trap_msg.ts);      /* pass 0, calculate length fields */      tot_len = snmp_varbind_list_sum(&trap_msg.outvb);      tot_len = snmp_trap_header_sum(&trap_msg, tot_len);      /* allocate pbuf(s) */      p = pbuf_alloc(PBUF_TRANSPORT, tot_len, PBUF_POOL);      if (p != NULL)      {        u16_t ofs;        /* pass 1, encode packet ino the pbuf(s) */        ofs = snmp_trap_header_enc(&trap_msg, p);        snmp_varbind_list_enc(&trap_msg.outvb, p, ofs);        snmp_inc_snmpouttraps();        snmp_inc_snmpoutpkts();        /** connect to the TRAP destination */        udp_connect(trap_msg.pcb, &trap_msg.dip, SNMP_TRAP_PORT);        udp_send(trap_msg.pcb, p);        /** disassociate remote address and port with this pcb */        udp_disconnect(trap_msg.pcb);        pbuf_free(p);      }      else      {        return ERR_MEM;      }    }  }

/** * Sends a 'getresponse' message to the request originator. * * @param m_stat points to the current message request state source * @return ERR_OK when success, ERR_MEM if we're out of memory * * @note the caller is responsible for filling in outvb in the m_stat * and provide error-status and index (except for tooBig errors) ... */err_tsnmp_send_response(struct snmp_msg_pstat *m_stat){  struct snmp_varbind_root emptyvb = {NULL, NULL, 0, 0, 0};  struct pbuf *p;  u16_t tot_len;  err_t err;  /* pass 0, calculate length fields */  tot_len = snmp_varbind_list_sum(&m_stat->outvb);  tot_len = snmp_resp_header_sum(m_stat, tot_len);  /* try allocating pbuf(s) for complete response */  p = pbuf_alloc(PBUF_TRANSPORT, tot_len, PBUF_POOL);  if (p == NULL)  {    LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_snd_response() tooBig/n"));    /* can't construct reply, return error-status tooBig */    m_stat->error_status = SNMP_ES_TOOBIG;    m_stat->error_index = 0;    /* pass 0, recalculate lengths, for empty varbind-list */    tot_len = snmp_varbind_list_sum(&emptyvb);    tot_len = snmp_resp_header_sum(m_stat, tot_len);    /* retry allocation once for header and empty varbind-list */    p = pbuf_alloc(PBUF_TRANSPORT, tot_len, PBUF_POOL);  }  if (p != NULL)  {    /* first pbuf alloc try or retry alloc success */    u16_t ofs;    LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_snd_response() p != NULL/n"));    /* pass 1, size error, encode packet ino the pbuf(s) */    ofs = snmp_resp_header_enc(m_stat, p);    if (m_stat->error_status == SNMP_ES_TOOBIG)    {      snmp_varbind_list_enc(&emptyvb, p, ofs);    }    else    {      snmp_varbind_list_enc(&m_stat->outvb, p, ofs);    }    switch (m_stat->error_status)    {      case SNMP_ES_TOOBIG:        snmp_inc_snmpouttoobigs();        break;      case SNMP_ES_NOSUCHNAME:        snmp_inc_snmpoutnosuchnames();        break;      case SNMP_ES_BADVALUE:        snmp_inc_snmpoutbadvalues();        break;      case SNMP_ES_GENERROR:        snmp_inc_snmpoutgenerrs();        break;    }    snmp_inc_snmpoutgetresponses();    snmp_inc_snmpoutpkts();    /** @todo do we need separate rx and tx pcbs for threaded case? */    /** connect to the originating source */    udp_connect(m_stat->pcb, &m_stat->sip, m_stat->sp);    err = udp_send(m_stat->pcb, p);    if (err == ERR_MEM)    {      /** @todo release some memory, retry and return tooBig? tooMuchHassle? */      err = ERR_MEM;    }    else    {      err = ERR_OK;    }    /** disassociate remote address and port with this pcb */    udp_disconnect(m_stat->pcb);    pbuf_free(p);    LWIP_DEBUGF(SNMP_MSG_DEBUG, ("snmp_snd_response() done/n"));    return err;  }  else  {    /* first pbuf alloc try or retry alloc failed       very low on memory, couldn't return tooBig */    return ERR_MEM;  }}

Boolean netInit(NetPath *netPath, RunTimeOpts *rtOpts, PtpClock *ptpClock){    int i;    struct in_addr netAddr;    char addrStr[NET_ADDRESS_LENGTH];    DBG("netInit/n");    /* Allocate tx buffer for the event port. */    netPath->eventTxBuf = pbuf_alloc(PBUF_TRANSPORT, PACKET_SIZE, PBUF_RAM);    if(netPath->eventTxBuf == NULL) {        PERROR("Failed to allocate Event Tx Buffer/n");        return FALSE;    }    /* Allocate tx buffer for the general port. */    netPath->generalTxBuf = pbuf_alloc(PBUF_TRANSPORT, PACKET_SIZE, PBUF_RAM);    if(netPath->generalTxBuf == NULL) {        PERROR("Failed to allocate Event Tx Buffer/n");        pbuf_free(netPath->eventTxBuf);        return FALSE;    }    /* Open lwIP raw udp interfaces for the event port. */    netPath->eventPcb = udp_new();    if(netPath->eventPcb == NULL) {        PERROR("Failed to open Event UDP PCB/n");        pbuf_free(netPath->eventTxBuf);        pbuf_free(netPath->generalTxBuf);        return FALSE;    }    /* Open lwIP raw udp interfaces for the general port. */    netPath->generalPcb = udp_new();    if(netPath->generalPcb == NULL) {        PERROR("Failed to open General UDP PCB/n");        udp_remove(netPath->eventPcb);        pbuf_free(netPath->eventTxBuf);        pbuf_free(netPath->generalTxBuf);        return FALSE;    }    /* Initialize the buffer queues. */    netQInit(&netPath->eventQ);    netQInit(&netPath->generalQ);    /* Configure network (broadcast/unicast) addresses. */    netPath->unicastAddr = 0;    if(!lookupSubdomainAddress(rtOpts->subdomainName, addrStr)) {        udp_disconnect(netPath->eventPcb);        udp_disconnect(netPath->generalPcb);        udp_remove(netPath->eventPcb);        udp_remove(netPath->generalPcb);        pbuf_free(netPath->eventTxBuf);        pbuf_free(netPath->generalTxBuf);        return FALSE;    }    if(!inet_aton(addrStr, &netAddr)) {        ERROR("failed to encode multi-cast address: %s/n", addrStr);        udp_disconnect(netPath->eventPcb);        udp_disconnect(netPath->generalPcb);        udp_remove(netPath->eventPcb);        udp_remove(netPath->generalPcb);        pbuf_free(netPath->eventTxBuf);        pbuf_free(netPath->generalTxBuf);        return FALSE;    }    netPath->multicastAddr = netAddr.s_addr;    /* Setup subdomain address string. */    for(i = 0; i < SUBDOMAIN_ADDRESS_LENGTH; ++i) {        ptpClock->subdomain_address[i] = (netAddr.s_addr >> (i * 8)) & 0xff;    }    /* Establish the appropriate UDP bindings/connections for events. */    udp_recv(netPath->eventPcb, eventRecv, netPath);    udp_bind(netPath->eventPcb, IP_ADDR_ANY, PTP_EVENT_PORT);//  udp_connect(netPath->eventPcb, IP_ADDR_ANY, PTP_EVENT_PORT);    *(Integer16*)ptpClock->event_port_address = PTP_EVENT_PORT;    /* Establish the appropriate UDP bindings/connections for general. */    udp_recv(netPath->generalPcb, generalRecv, netPath);    udp_bind(netPath->generalPcb, IP_ADDR_ANY, PTP_GENERAL_PORT);//  udp_connect(netPath->generalPcb, IP_ADDR_ANY, PTP_GENERAL_PORT);    *(Integer16*)ptpClock->general_port_address = PTP_GENERAL_PORT;    /* Return a success code. */    return TRUE;}

/**  * @brief This function is called when an UDP datagrm has been received on the port UDP_PORT.  * @param arg user supplied argument (udp_pcb.recv_arg)  * @param pcb the udp_pcb which received data  * @param p the packet buffer that was received  * @param addr the remote IP address from which the packet was received  * @param port the remote port from which the packet was received  * @retval None  */void udp_server_callback(void *arg, struct udp_pcb *upcb, struct pbuf *p, struct ip_addr *addr, u16_t port){  struct tcp_pcb *pcb;  uint8_t iptab[4];  uint8_t iptxt[20];    /* We have received the UDP Echo from a client */  /* read its IP address */  iptab[0] = (uint8_t)((uint32_t)(addr->addr) >> 24);  iptab[1] = (uint8_t)((uint32_t)(addr->addr) >> 16);  iptab[2] = (uint8_t)((uint32_t)(addr->addr) >> 8);  iptab[3] = (uint8_t)((uint32_t)(addr->addr));  sprintf((char*)iptxt, "is: %d.%d.%d.%d     ", iptab[3], iptab[2], iptab[1], iptab[0]);    printf( "is: %d.%d.%d.%d     ", iptab[3], iptab[2], iptab[1], iptab[0]);	                           	                                /* Connect to the remote client */  udp_connect(upcb, addr, UDP_CLIENT_PORT);      /* Tell the client that we have accepted it */	udp_send(upcb,p);  /* free the UDP connection, so we can accept new clients */  udp_disconnect(upcb);	  /* Bind the upcb to IP_ADDR_ANY address and the UDP_PORT port*/  /* Be ready to get a new request from another client */    udp_bind(upcb, IP_ADDR_ANY, UDP_SERVER_PORT);	  /* Set a receive callback for the upcb */  udp_recv(upcb, udp_server_callback, NULL);    		  /* Create a new TCP control block  */  pcb = tcp_new();	  if(pcb !=NULL)  {    err_t err;	  	          /* Assign to the new pcb a local IP address and a port number */    err = tcp_bind(pcb, addr, TCP_SERVER_PORT);	  	if(err != ERR_USE)	{	  /* Set the connection to the LISTEN state */      pcb = tcp_listen(pcb);          /* Specify the function to be called when a connection is established */      tcp_accept(pcb, tcp_server_accept);	}	else	{	  /* We enter here if a conection to the addr IP address already exists */	  /* so we don't need to establish a new one */	  tcp_close(pcb);	}              }  /* Free the p buffer */  pbuf_free(p);   }