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

/* *  Entry point of the SNMP server. */PROCESS_THREAD(snmpd_process, ev, data) {	PROCESS_BEGIN();	snmp_packets = 0;        #ifndef CONTIKI_TARGET_AVR_RAVEN        systemStartTime = clock_time();        #endif        #if CHECK_STACK_SIZE        u16t i = 0;        u32t pointer;        u32t* p = &pointer;        for (i = 0; i < 1000; i++) {            *p = 0xAAAAAAAA;            p--;        }        marker = &pointer;        #endif	udpconn = udp_new(NULL, UIP_HTONS(0), NULL);	udp_bind(udpconn, UIP_HTONS(LISTEN_PORT));        /* init MIB */        if (mib_init() != -1) {                        while(1) {                PROCESS_YIELD();                udp_handler(ev, data);            }        } else {            snmp_log("error occurs while initializing the MIB/n");        }	PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(sensortag_process, ev, data){  static struct etimer et;  uip_ipaddr_t ipaddr;  etimer_set(&et, CLOCK_CONF_SECOND*20);  PROCESS_BEGIN();  PROCESS_WAIT_EVENT_UNTIL(ev == PROCESS_EVENT_TIMER);  if(uip_ds6_get_global(ADDR_PREFERRED) == NULL) {    printf("NO IP /n/r");  }  else{    printf("Good /n/r");  }  print_local_addresses();  if(uiplib_ipaddrconv("2001:0db8:0002:0000:0000:0000:0000:0002", &ipaddr)){    printf("Get server IP! /n/r");  }  /* new connection with remote host */  client_conn = udp_new(&ipaddr, UIP_HTONS(10001), NULL);  udp_bind(client_conn, UIP_HTONS(10002));  printf("Connect! /n/r");  init_hdc_reading(NULL);  while(1) {    PROCESS_YIELD();    if(ev == sensors_event && data == &hdc_1000_sensor) {      get_hdc_reading();    }  }  PROCESS_END();}

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

/** * Starts SNMP Agent. * Allocates UDP pcb and binds it to IP_ADDR_ANY port 161. */voidsnmp_init(void){  struct snmp_msg_pstat *msg_ps;  u8_t i;  snmp1_pcb = udp_new();  if (snmp1_pcb != NULL)  {    udp_recv(snmp1_pcb, snmp_recv, (void *)SNMP_IN_PORT);    udp_bind(snmp1_pcb, IP_ADDR_ANY, SNMP_IN_PORT);  }  msg_ps = &msg_input_list[0];  for (i=0; i<SNMP_CONCURRENT_REQUESTS; i++)  {    msg_ps->state = SNMP_MSG_EMPTY;    msg_ps->error_index = 0;    msg_ps->error_status = SNMP_ES_NOERROR;    msg_ps++;  }  trap_msg.pcb = snmp1_pcb;#ifdef SNMP_PRIVATE_MIB_INIT  /* If defined, this must be a function-like define to initialize the   * private MIB after the stack has been initialized.   * The private MIB can also be initialized in tcpip_callback (or after   * the stack is initialized), this define is only for convenience. */  SNMP_PRIVATE_MIB_INIT();#endif /* SNMP_PRIVATE_MIB_INIT */  /* The coldstart trap will only be output     if our outgoing interface is up & configured  */  snmp_coldstart_trap();}

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

int main (void){    zctx_t *ctx = zctx_new ();    udp_t *udp = udp_new (PING_PORT_NUMBER);        byte buffer [PING_MSG_SIZE];    zmq_pollitem_t pollitems [] = {{ NULL, udp_handle (udp), ZMQ_POLLIN, 0 }};        //  Send first ping right away    uint64_t ping_at = zclock_time ();        while (!zctx_interrupted) {        long timeout = (long) (ping_at - zclock_time ());        if (timeout < 0)            timeout = 0;        if (zmq_poll (pollitems, 1, timeout * ZMQ_POLL_MSEC) == -1)            break;              //  Interrupted        //  Someone answered our ping        if (pollitems [0].revents & ZMQ_POLLIN)            udp_recv (udp, buffer, PING_MSG_SIZE);                if (zclock_time () >= ping_at) {            puts ("Pinging peers...");            buffer [0] = '!';            udp_send (udp, buffer, PING_MSG_SIZE);            ping_at = zclock_time () + PING_INTERVAL;        }    }    udp_destroy (&udp);    zctx_destroy (&ctx);    return 0;}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_server_process, ev, data){  PROCESS_BEGIN();  PRINTF("UDP server started/n");#if UIP_CONF_ROUTER  uip_ip6addr(&ipaddr, 0xaaaa, 0, 0, 0, 0, 0, 0, 0);  uip_netif_addr_add(&ipaddr, 64, 0, AUTOCONF);#endif /* UIP_CONF_ROUTER */  print_local_addresses();  server_conn = udp_new(NULL, HTONS(61617), NULL);  udp_bind(server_conn, HTONS(61616));  PRINTF("Created a server connection with remote address ");  PRINT6ADDR(&server_conn->ripaddr);  PRINTF("local/remote port %u/%u/n", HTONS(server_conn->lport),         HTONS(server_conn->rport));  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(servreg_hack_process, ev, data){  static struct etimer periodic;  static struct uip_udp_conn *outconn, *inconn;  PROCESS_BEGIN();  /* Create outbound UDP connection. */  outconn = udp_broadcast_new(UIP_HTONS(UDP_PORT), NULL);  udp_bind(outconn, UIP_HTONS(UDP_PORT));  /* Create inbound UDP connection. */  inconn = udp_new(NULL, UIP_HTONS(UDP_PORT), NULL);  udp_bind(inconn, UIP_HTONS(UDP_PORT));  etimer_set(&periodic, PERIOD_TIME);  etimer_set(&sendtimer, random_rand() % (PERIOD_TIME));  while(1) {    PROCESS_WAIT_EVENT();    if(ev == PROCESS_EVENT_TIMER && data == &periodic) {      etimer_reset(&periodic);      etimer_set(&sendtimer, random_rand() % (PERIOD_TIME));    } else if(ev == PROCESS_EVENT_TIMER && data == &sendtimer) {      send_udp_packet(outconn);    } else if(ev == tcpip_event) {      parse_incoming_packet(uip_appdata, uip_datalen());    }  }  PROCESS_END();}

PROCESS_THREAD(receive_process, ev, data){    PROCESS_BEGIN();        static struct uip_udp_conn* server_conn;    server_conn = udp_new(NULL, UIP_HTONS(UDP_CLIENT_PORT), NULL);    udp_bind(server_conn, UIP_HTONS(UDP_SERVER_PORT));    while(1) {        PROCESS_YIELD();        if(ev == tcpip_event) {            uint8_t* appdata = uip_appdata;            ASSERT((uip_datalen() % sizeof(uint32_t)) == 0);            size_t numberof_values = uip_datalen() / sizeof(uint32_t);            printf("trace: received values: ");            uint32_t value;            size_t i;            for (i=0; i<numberof_values; i++) {                ASSERT(offset < MAX_NUMBEROF_VALUES);                memcpy(&value, &appdata[i * sizeof(uint32_t)], sizeof(uint32_t));                printf("%lu ", value);                values[offset++] = value;            }            printf("/n");        }    }    PROCESS_END();}

/* Glowny program */PROCESS_THREAD(program_UDP, ev, data) {    static struct etimer et;    PROCESS_BEGIN();#if UIP_CONF_IPV6 > 0    uip_ip6addr(&ipaddr, addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7]);#else    uip_ipaddr(&ipaddr, addr[0], addr[1], addr[2], addr[3]);#endif    conn = udp_new(&ipaddr, UIP_HTONS(port), &state);    udp_bind(conn, UIP_HTONS(port + 1));    printf("Binded/n");    etimer_set(&et, CLOCK_CONF_SECOND * 3);    while (1) {        PROCESS_WAIT_EVENT();        if (uip_newdata()) {            str = uip_appdata;            str[uip_datalen()] = '/0';            printf("Received: '%s'/n", str);        }        etimer_reset(&et);    }    PROCESS_END();}

PROCESS_THREAD(udp_plug_process, ev, data){	static struct etimer et;	PROCESS_BEGIN();	  	PRINTF("UDP server started/r/n");	#if DEV_BOARD  	leds_on(LEDS_RED | LEDS_GREEN);	SENSORS_ACTIVATE(button_sensor);#else	leds_on(LEDS_GREEN);	#ifdef HAS_PIR_SENSOR		pir_state = PIR_DISPATCH;		etimer_set(&pir_timer, PIR_INIT_TIME);	#endif#endif#if HAS_TEMP_SENSOR	start_temp_conv();#endif#if HAS_LIGHT_SENSOR	light_sensor_init();#endif	udp_conn = udp_new(NULL, UIP_HTONS(0), NULL);	udp_bind(udp_conn, UIP_HTONS(PLUG_PORT));	PRINTF("listening on udp port %u/r/n",UIP_HTONS(udp_conn->lport));	etimer_set(&et, SEND_INTERVAL);	while(1) {		PROCESS_YIELD();		if(etimer_expired(&et)) {			timeout_handler();			etimer_restart(&et);		}#ifdef HAS_PIR_SENSOR				if((pir_state == PIR_DISPATCH)&&(etimer_expired(&pir_timer))) {			SENSORS_ACTIVATE(button_sensor);			pir_state = PIR_READY;		}#endif				if(ev == tcpip_event) {			PRINTF("Calling tcpip_Handler/r/n");			tcpip_handler();		}				if (ev == sensors_event && data == &button_sensor) {#ifndef DEV_BOARD  			handle_pir_event();#endif			PRINTF("Button Pressed/r/n");		}	}  PROCESS_END();}

/*-----------------------------------------------------------------------*/PROCESS_THREAD(udp_sender_process, ev, data){	static struct etimer period_timer, wait_timer;	PROCESS_BEGIN();		set_global_address();	PRINTF("UDP sender process started/n");	print_local_address();	/* new connection with remote host */	sender_conn = udp_new(NULL, UIP_HTONS(UDP_SINK_PORT), NULL);	udp_bind(sender_conn, UIP_HTONS(UDP_SENDER_PORT));	PRINTF("Created a connection with the sink ");	PRINT6ADDR(&sender_conn->ripaddr);	PRINTF(" local/remote port %u/%u/n",			UIP_HTONS(sender_conn->lport), UIP_HTONS(sender_conn->rport));		etimer_set(&period_timer, CLOCK_SECOND * PERIOD);	while(1) {		PROCESS_WAIT_EVENT();		if(ev == PROCESS_EVENT_TIMER) {			if(data == &period_timer) {				etimer_reset(&period_timer);				etimer_set(&wait_timer,							random_rand() % (CLOCK_SECOND * RANDWAIT));			} else if(data ==&wait_timer) {				/* Time to send a data. */				collect_common_send();			}		}	}	PROCESS_END();}

PROCESS_THREAD(sync_master, ev, data){  static int i=0;  static struct uip_udp_conn *udp;  PROCESS_BEGIN();      udp = udp_new(NULL, UIP_HTONS(10000), NULL);  uip_udp_bind(udp, UIP_HTONS(10000));  uart0_init(1000000);  while(1)  {    PROCESS_YIELD_UNTIL(ev == tcpip_event);    int i;    for (i = 0; i < 16; i++)      uart0_writeb(UDP_HDR->srcipaddr.u8[i]);    for (i = 0; i < uip_datalen(); i++)    {      uart0_writeb(((uint8_t*)uip_appdata)[i]);    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/voidinit_dtls() {  static dtls_handler_t cb = {    .write = send_to_peer,    .read  = read_from_peer,    .event = NULL,#ifdef DTLS_PSK    .get_psk_info = get_psk_info,#endif#ifdef DTLS_ECC    .get_ecdsa_key = NULL,    .verify_ecdsa_key = NULL,#endif  };  server_conn = udp_new(NULL, 0, NULL);  udp_bind(server_conn, UIP_HTONS(DTLS_ECHO_PORT));  dtls_set_log_level(DTLS_LOG_DEBUG);  dtls_context = dtls_new_context(server_conn);  if (dtls_context)    dtls_set_handler(dtls_context, &cb);  printf("DTLS server started/n");}

/** * /brief      Register a UDP connection * /param c    A pointer to a struct simple_udp_connection * /param local_port The local UDP port in host byte order * /param remote_addr The remote IP address * /param remote_port The remote UDP port in host byte order * /param receive_callback A pointer to a function to be called for incoming packets * /retval 0   If no UDP connection could be allocated * /retval 1   If the connection was successfully allocated * *             This function registers a UDP connection and attaches a *             callback function to it. The callback function will be *             called for incoming packets. The local UDP port can be *             set to 0 to indicate that an ephemeral UDP port should *             be allocated. The remote IP address can be NULL, to *             indicate that packets from any IP address should be *             accepted. * */intsimple_udp_register(struct simple_udp_connection *c,                    uint16_t local_port,                    uip_ipaddr_t *remote_addr,                    uint16_t remote_port,                    simple_udp_callback receive_callback){  init_simple_udp();  c->local_port = local_port;  c->remote_port = remote_port;  if(remote_addr != NULL) {    uip_ipaddr_copy(&c->remote_addr, remote_addr);  }  c->receive_callback = receive_callback;  PROCESS_CONTEXT_BEGIN(&simple_udp_process);  c->udp_conn = udp_new(remote_addr, UIP_HTONS(remote_port), c);  if(c->udp_conn != NULL) {    udp_bind(c->udp_conn, UIP_HTONS(local_port));  }  PROCESS_CONTEXT_END();  if(c->udp_conn == NULL) {    return 0;  }  return 1;}

void UdpConnection::initialize(udp_pcb* pcb /* = NULL*/){	if (pcb == NULL)		pcb = udp_new();	udp = pcb;	udp_recv(udp, staticOnReceive, (void*)this);}

TC_RUN_THREAD void server_thread(){    int i=0;    for (i=0; i<sizeof(workers)/sizeof(worker_t); i++) {        workers[i].busy = false;    }    ipconfig(false);    struct uip_udp_conn* conn = udp_new(NULL, 0, NULL);    udp_bind(conn, UDP_SERVER_PORT);    while(1) {        if (! tc_receive(&cond_server)) {            for (i=0; i<sizeof(workers)/sizeof(worker_t); i++) {                worker_t* worker = workers + i;                if (worker->busy == false) {                    worker->busy = true;                    bool success = rpc_unmarshall_call(CALL, MAX_TELL_DEPTH, uip_appdata, uip_datalen());                    ASSERT(success == true);                    worker->peer = UIP_IP_BUF->srcipaddr;                    tc_condition_signal(&worker->cond, NULL);                    break;                }            }            ASSERT(i != sizeof(workers)/sizeof(worker_t));        } else {            worker_t* worker = cond_server.data;            worker->busy = false;            int16_t size = rpc_marshall_response(RESPONSE, uip_appdata, UIP_BUFSIZE);            ASSERT(size != -1);            uip_udp_packet_sendto(conn, uip_appdata, size, &worker->peer, UDP_CLIENT_PORT);        }    }}

int lwip_bind(int s, struct sockaddr *name, socklen_t namelen) {	sockfd_t	* fd;	struct ip_addr	ip;	int		port, rv = 0;	s = sock_for_fd(s);	if (s < 0) {		errno = EBADF;		return -1;	}	fd = fds + s;	// Make sure it's an internet address we understand.	if (namelen != sizeof(struct sockaddr_in)) {		errno = ENAMETOOLONG;		return -1;	}	// Get access	mutex_lock(fd->mutex);	// Copy it over	memcpy(&fd->name, name, namelen);	// Convert this to an lwIP-happy format	ip.addr = ((struct sockaddr_in *)name)->sin_addr.s_addr;	port = ((struct sockaddr_in *)name)->sin_port;	// Are we TCP or UDP?	switch (fd->type) {	case SOCK_STREAM:		fd->tcppcb = tcp_new();		tcp_arg(fd->tcppcb, (void *)s);		tcp_recv(fd->tcppcb, recv_tcp);		tcp_sent(fd->tcppcb, sent_tcp);		tcp_poll(fd->tcppcb, poll_tcp, 4);	// 4 == 4 TCP timer intervals		tcp_err(fd->tcppcb, err_tcp);		if (tcp_bind(fd->tcppcb, &ip, ntohs(port)) != ERR_OK) {			if (tcp_close(fd->tcppcb) != ERR_OK)				tcp_abort(fd->tcppcb);			fd->tcppcb = NULL;			errno = EINVAL;			rv = -1; goto out;		}		break;	case SOCK_DGRAM:		fd->udppcb = udp_new();		udp_recv(fd->udppcb, recv_udp, (void *)s);		udp_bind(fd->udppcb, &ip, ntohs(port));		break;	default:		assert( 0 );		errno = EINVAL;		rv = -1; goto out;	}out:	mutex_unlock(fd->mutex);	return rv;}

PROCESS_THREAD(rs232udp_process, ev, data) {  PROCESS_BEGIN();  _network_rs232udp_server_conn = udp_new(NULL, UIP_HTONS(0), NULL);  udp_bind(_network_rs232udp_server_conn, UIP_HTONS(UDP_PORT));    while (1) {    PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);    if(uip_newdata()) {      uip_ipaddr_copy(&_network_rs232udp_last_ip, &UDP_HDR->srcipaddr);      _network_rs232udp_last_port = UIP_HTONS(UDP_HDR->srcport);            ((char *)uip_appdata)[uip_datalen()] = 0;      printf("rs232udp %d.%d.%d.%d:%d rx: '%s'/n",	     _network_rs232udp_last_ip.u8[0],	     _network_rs232udp_last_ip.u8[1],	     _network_rs232udp_last_ip.u8[2],	     _network_rs232udp_last_ip.u8[3],	     _network_rs232udp_last_port,	     (char *)uip_appdata);      rs232_tx((char *)uip_appdata);    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_server_process, ev, data){  PROCESS_BEGIN();  putstring("Starting UDP server/n");#if BUTTON_SENSOR_ON  putstring("Button 1: Print RIME stats/n");#endif#if SERVER_RPL_ROOT  create_dag();#endif  server_conn = udp_new(NULL, UIP_HTONS(0), NULL);  udp_bind(server_conn, UIP_HTONS(3000));  PRINTF("Listen port: 3000, TTL=%u/n", server_conn->ttl);  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();#if (BUTTON_SENSOR_ON && (DEBUG==DEBUG_PRINT))    } else if(ev == sensors_event && data == &button_sensor) {        print_stats();#endif /* BUTTON_SENSOR_ON */    }  }  PROCESS_END();}

PROCESS_THREAD(rime_udp_process, ev, data){  static uip_ipaddr_t ipaddr;  PROCESS_BEGIN();  broadcast_conn = udp_broadcast_new(HTONS(RIME_UDP_PORT), NULL);  if(broadcast_conn == NULL) {    PRINTF("rime-udp: Failed to allocate a broadcast connection!/n");  }  uip_create_unspecified(&ipaddr);  unicast_conn = udp_new(&ipaddr, HTONS(RIME_UDP_PORT), NULL);  if(unicast_conn == NULL) {    PRINTF("rime-udp: Failed to allocate a unicast connection!/n");  }  udp_bind(unicast_conn, HTONS(RIME_UDP_PORT));  while(1) {    PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);    if(uip_newdata()) {      packetbuf_clear();      memmove(packetbuf_hdrptr(), uip_appdata, uip_datalen());      PRINTF("rime-udp: received %d bytes/n", uip_datalen());      receiver_callback(&rime_udp_driver);    }  }  PROCESS_END();}

/**  * @brief  Initialize the server application.  * @param  None  * @retval None  */void server_init(void){  struct tcp_pcb *tpcb;    	struct udp_pcb *upcb;  	  	/* Create a new TCP control block  */	tpcb = tcp_new();		/* Assign to the new pcb a local IP address and a port number */	/* Using IP_ADDR_ANY allow the pcb to be used by any local interface */	tcp_bind(tpcb, IP_ADDR_ANY, TCP_SERVER_PORT);		/* Set the connection to the LISTEN state */	tpcb = tcp_listen(tpcb);	/* Specify the function to be called when a connection is established */		tcp_accept(tpcb, tcp_server_accept);		  /* Create a new UDP control block  */  upcb = udp_new();    /* Bind the upcb to the UDP_PORT port */  /* Using IP_ADDR_ANY allow the upcb to be used by any local interface */  udp_bind(upcb, IP_ADDR_ANY, UDP_SERVER_PORT);    /* Set a receive callback for the upcb */  udp_recv(upcb, udp_server_callback, NULL);  }

intstart_urxperf_application(){	struct udp_pcb *pcb;	err_t err;	unsigned port = rxperf_port;	/* iperf default port */	/* create new TCP PCB structure */	pcb = udp_new();	if (!pcb) {		xil_printf("Error creating PCB. Out of Memory/r/n");		return -1;	}	/* bind to iperf @port */	err = udp_bind(pcb, IP_ADDR_ANY, port);	if (err != ERR_OK) {		xil_printf("Unable to bind to port %d: err = %d/r/n", port, err);		return -2;	}	udp_recv(pcb, urxperf_recv_callback, NULL);        rxperf_server_running = 1;	return 0;}

/** * Starts SNMP Agent. * Allocates UDP pcb and binds it to IP_ADDR_ANY port 161. */voidsnmp_init(void){  struct snmp_msg_pstat *msg_ps;  u8_t i;  snmp1_pcb = udp_new();  if (snmp1_pcb != NULL)  {    udp_recv(snmp1_pcb, snmp_recv, (void *)SNMP_IN_PORT);    udp_bind(snmp1_pcb, IP_ADDR_ANY, SNMP_IN_PORT);  }  msg_ps = &msg_input_list[0];  for (i=0; i<SNMP_CONCURRENT_REQUESTS; i++)  {    msg_ps->state = SNMP_MSG_EMPTY;    msg_ps->error_index = 0;    msg_ps->error_status = SNMP_ES_NOERROR;    msg_ps++;  }  trap_msg.pcb = snmp1_pcb;  /* The coldstart trap will only be output     if our outgoing interface is up & configured  */  snmp_coldstart_trap();}

/**  * @brief  Creates and initializes a UDP PCB for TFTP receive operation    * @param  None    * @retval None  */void IAP_tftpd_init(void){  err_t err;  unsigned port = 69; /* 69 is the port used for TFTP protocol initial transaction */  /* create a new UDP PCB structure  */  UDPpcb = udp_new();  if (!UDPpcb)  {    /* Error creating PCB. Out of Memory  */#ifdef USE_LCD    LCD_ErrLog("Can not create pcb /n");#endif    return;  }  /* Bind this PCB to port 69  */  err = udp_bind(UDPpcb, IP_ADDR_ANY, port);  if (err == ERR_OK)  {    /* Initialize receive callback function  */    udp_recv(UDPpcb, IAP_tftp_recv_callback, NULL);  }   else  {#ifdef USE_LCD    LCD_ErrLog("Can not create pcb /n");#endif  }}

/**  * @brief  Initializes the udp pcb for TFTP   * @param  None  * @retval None  */void tftpd_init(void){  err_t err;  unsigned port = 69;  /* create a new UDP PCB structure  */  UDPpcb = udp_new();  if (UDPpcb)  {      /* Bind this PCB to port 69  */    err = udp_bind(UDPpcb, IP_ADDR_ANY, port);    if (err == ERR_OK)    {          /* TFTP server start  */      udp_recv(UDPpcb, recv_callback_tftp, NULL);    }    else    {      printf("can not bind pcb");    }  }  else  {    printf("can not create new pcb");  }}

/*  netx_udp_open()    Open a "socket" with a given local port number    The call returns 0 if OK, non-zero if it fails.*/intnetx_udp_open(struct netxsocket_s *rlpsock, localaddr_arg_t localaddr){    struct udp_pcb *netx_pcb;        /* common Protocol Control Block */    if (rlpsock->nativesock) {        acnlog(LOG_WARNING | LOG_NETI, "netx_udp_open : already open");        return -1;    }    netx_pcb = udp_new();    if (!netx_pcb)        return -1;    rlpsock->nativesock = netx_pcb;    /* BIND:sets local_ip and local_port */    if (!udp_bind(netx_pcb, LCLAD_INADDR(LCLAD_UNARG(localaddr)), LCLAD_PORT(LCLAD_UNARG(localaddr))) == ERR_OK)        return -1;    if (LCLAD_PORT(LCLAD_UNARG(localaddr)) == NETI_PORT_EPHEM) {        /* if port was 0, then the stack should have given us a port, so assign it back */        NSK_PORT(*rlpsock) = netx_pcb->local_port;    }  else {        NSK_PORT(*rlpsock) = LCLAD_PORT(LCLAD_UNARG(localaddr));    }#if !CONFIG_LOCALIP_ANY    NSK_INADDR(rlpsock) = LCLAD_INADDR(LCLAD_UNARG(localaddr));#endif    /* UDP Callback */    udp_recv(netx_pcb, netxhandler, rlpsock);    return 0;}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_client_process, ev, data){  static struct etimer periodic;  static struct ctimer backoff_timer;#if WITH_COMPOWER  static int print = 0;#endif  PROCESS_BEGIN();  PROCESS_PAUSE();  set_global_address();    PRINTF("UDP client process started/n");  print_local_addresses();  /* new connection with remote host */  client_conn = udp_new(NULL, UIP_HTONS(UDP_SERVER_PORT), NULL);   if(client_conn == NULL) {    PRINTF("No UDP connection available, exiting the process!/n");    PROCESS_EXIT();  }  udp_bind(client_conn, UIP_HTONS(UDP_CLIENT_PORT));   PRINTF("Created a connection with the server ");  PRINT6ADDR(&client_conn->ripaddr);  PRINTF(" local/remote port %u/%u/n",  UIP_HTONS(client_conn->lport), UIP_HTONS(client_conn->rport));#if WITH_COMPOWER  powertrace_sniff(POWERTRACE_ON);#endif  etimer_set(&periodic, SEND_INTERVAL);  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();    }        if(etimer_expired(&periodic)) {      etimer_reset(&periodic);      ctimer_set(&backoff_timer, SEND_TIME, send_packet, NULL);#if WITH_COMPOWER      if (print == 0) {  powertrace_print("#P");      }      if (++print == 3) {  print = 0;      }#endif    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(udp_client_process, ev, data){  PROCESS_BEGIN();  PROCESS_PAUSE();  set_global_address();  PRINTF("UDP client process started/n");  print_local_addresses();  /* new connection with remote host */  client_conn = udp_new(NULL, UIP_HTONS(UDP_SERVER_PORT), NULL);  udp_bind(client_conn, UIP_HTONS(UDP_CLIENT_PORT));  PRINTF("Created a connection with the server ");  PRINT6ADDR(&client_conn->ripaddr);  PRINTF(" local/remote port %u/%u/n",        UIP_HTONS(client_conn->lport), UIP_HTONS(client_conn->rport));  while(1) {    PROCESS_YIELD();    if(ev == tcpip_event) {      tcpip_handler();    }  }  PROCESS_END();}

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