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

/*---------------------------------------------------------------------------*/static void tcpip_handler(void) {  memset(buf, 0, MAX_PAYLOAD_LEN);  if(uip_newdata()) {    leds_on(LEDS_RED);    len = uip_datalen();    memcpy(buf, uip_appdata, len);    PRINTF("%u bytes from [", len);    PRINT6ADDR(&UIP_IP_BUF->srcipaddr);    PRINTF("]:%u/n", UIP_HTONS(UIP_UDP_BUF->srcport));    uip_ipaddr_copy(&server_conn->ripaddr, &UIP_IP_BUF->srcipaddr);    server_conn->rport = UIP_UDP_BUF->srcport;    uip_udp_packet_send(server_conn, buf, len);    /* Restore server connection to allow data from any node */    uip_create_unspecified(&server_conn->ripaddr);    server_conn->rport = 0;  }  leds_off(LEDS_RED);  return;}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  char *appdata;  if(uip_newdata()) {    appdata = (char *)uip_appdata;    appdata[uip_datalen()] = 0;    PRINTF("DATA recv '%s' from ", appdata);    PRINTF("%d",           UIP_IP_BUF->srcipaddr.u8[sizeof(UIP_IP_BUF->srcipaddr.u8) - 1]);    PRINTF("/n");#if SERVER_REPLY    PRINTF("DATA sending reply/n");    uip_ipaddr_copy(&server_conn->ripaddr, &UIP_IP_BUF->srcipaddr);    uip_udp_packet_send(server_conn, "Reply", sizeof("Reply"));    uip_create_unspecified(&server_conn->ripaddr);#endif  }}

/*--------------------------------------------------------------*/static voidtcpip_handler(void){  char *appdata;    PRINTF("  uip_flags = %i/n", uip_flags);   if(uip_newdata()) {    appdata = (char *)uip_appdata;    appdata[uip_datalen()] = 0;    PRINTF("DATA recv '%s' from ", appdata);    PRINTF("%d", UIP_IP_BUF->srcipaddr.u8[15]);    PRINTF("/n");#if SERVER_REPLY    uip_ipaddr_copy(&client_conn->ripaddr, &UIP_IP_BUF->srcipaddr);    uip_udp_packet_send(client_conn, "Reply", sizeof("Reply"));    uip_create_unspecified(&client_conn->ripaddr);#endif  } }

voidbootp_net_main(void){    if(uip_newdata()) {	bootp_handle_reply();        return;    }    if(! uip_udp_conn->appstate.bootp.retry_timer) {	bootp_send_request();	if(uip_udp_conn->appstate.bootp.retry_counter < 5)	    uip_udp_conn->appstate.bootp.retry_timer =		2 << (++ uip_udp_conn->appstate.bootp.retry_counter);	else	    uip_udp_conn->appstate.bootp.retry_timer = 64 + (rand() & 63);    }    else	uip_udp_conn->appstate.bootp.retry_timer --;}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(tcpEcho_process, ev, data){  PROCESS_BEGIN();  /* Listen for a connection on local port */  tcp_listen(UIP_HTONS(local_port));  while (1)  {    PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);    /* If there is new uIP data, display it */    if(uip_newdata()) {      /* Add the end of string. */      ((char *)uip_appdata)[uip_datalen()] = 0;      printf("New uIP data: '%s'/n", uip_appdata);    }  }  PROCESS_END();}

static voidsms77_net_main(void){		    if (uip_aborted() || uip_timedout()) {	SMSDEBUG ("connection aborted/n");        if (sms77_tmp_buf) {          free(sms77_tmp_buf);          sms77_tmp_buf = NULL;        }        return;    }    if (uip_closed()) {	SMSDEBUG ("connection closed/n");        if (sms77_tmp_buf) {          free(sms77_tmp_buf);          sms77_tmp_buf = NULL;        }        return;    }    if (uip_connected() || uip_rexmit()) {	SMSDEBUG ("new connection or rexmit, sending message/n");        char *p = uip_appdata;        p += sprintf(p,  "GET /?u=%s&p=%s&to=%s&type=%s&text=", sms77_user, sms77_pass, sms77_recv, sms77_type);        p += urlencode(sms77_tmp_buf, strlen(sms77_tmp_buf), p);        p += sprintf_P(p, sms77_secheader);        uip_udp_send(p - (char *)uip_appdata);        SMSDEBUG("send %d bytes/n", p - (char *)uip_appdata);    }    if (uip_acked()) {      uip_close();    }        if (uip_newdata())    	SMSDEBUG("data: %s/n", uip_appdata);}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(server_process, ev, data){  PROCESS_BEGIN();  uip_ipaddr_t serveraddr;  uip_ipaddr(&serveraddr, 172,16,2,0);  serverport = 2222;  localport = 3333;  udpconn = udp_new(&serveraddr, uip_htons(serverport), NULL);  udp_bind(udpconn, uip_htons(localport));  while(1) {    PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);    if (uip_newdata()) {      newdata(uip_appdata, uip_datalen());    }  }  PROCESS_END();}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  uint8_t *appdata;  rimeaddr_t sender;  uint8_t seqno;  uint8_t hops;  if(uip_newdata()) {	appdata = (uint8_t *)uip_appdata;	sender.u8[0] = UIP_IP_BUF->srcipaddr.u8[15];	sender.u8[1] = UIP_IP_BUF->srcipaddr.u8[14];	seqno = *appdata;	hops = uip_ds6_if.cur_hop_limit - UIP_IP_BUF->ttl + 1;	printf("sender:%u.%u ",sender.u8[0] ,sender.u8[1]);	printf("last_rssi=%d/n",cc2420_last_rssi-45);	collect_common_recv(&sender, seqno, hops,						appdata + 2, uip_datalen() - 2);    /* Ignore incoming data */  }}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void) {    seq_id_server_expected++;    if (uip_newdata()) {        ((char *) uip_appdata)[uip_datalen()] = 0;        app_data = (data_struct *) & uip_appdata[0];        printf("cb(%u.%u)cf", app_data->seq_id_client, app_data->seq_id_server);        PRINT6ADDR(&UIP_IP_BUF->srcipaddr);        if (seq_id_server < app_data->seq_id_server) {            packets_received++;            seq_id_server = app_data->seq_id_server;            if (seq_id_server_expected < app_data->seq_id_server) {                seq_id_server_expected = app_data->seq_id_server;            }            printf("ci%ucj%uck%u/n", packets_sent, packets_received, packetqueue_len(&tx_queue));        } else {            printf("cm/n");            seq_id_server_expected--;        }    }}

voidntp_newdata(void){  if (!uip_newdata ()) return;  uint32_t ntp_timestamp;  struct ntp_packet *pkt = uip_appdata;  /* We must save an unix timestamp */  ntp_timestamp = NTOHL(pkt->rec.seconds) - 2208988800;#ifdef DEBUG_NTP    debug_printf("NTP: Set new time: %lu/n",ntp_timestamp);#endif  clock_set_time(ntp_timestamp);  set_dcf_count(0);  set_ntp_count(1);#ifdef NTPD_SUPPORT  ntp_setstratum(pkt->stratum);#endif}

void handle_my_tcp_srv(void){    static struct timer user_timer; //create a timer;    static bool app_init = FALSE;	char mydata[100];    if (uip_newdata()) {        //printf_high("Server RX [%d] bytes/n", uip_datalen());		strncpy(mydata,uip_appdata,strlen(uip_appdata));		proces_data(mydata, uip_datalen());    }    if (uip_poll()) {        /* below codes shows how to send data to client  */        if ((app_init == FALSE) || timer_expired(&user_timer)) {            //printf_high("Poll/n");            timer_set(&user_timer, 5*CLOCK_SECOND);            app_init = TRUE;        }    }}

voiduipudp_appcall(void) {  if (uip_udp_userdata_t *data = (uip_udp_userdata_t *)(uip_udp_conn->appstate))    {      if (uip_newdata())        {          if (data->packet_next == NOBLOCK)            {              uip_udp_conn->rport = UDPBUF->srcport;              uip_ipaddr_copy(uip_udp_conn->ripaddr,UDPBUF->srcipaddr);              data->packet_next = Enc28J60Network::allocBlock(ntohs(UDPBUF->udplen)-UIP_UDPH_LEN);                  //if we are unable to allocate memory the packet is dropped. udp doesn't guarantee packet delivery              if (data->packet_next != NOBLOCK)                {                  //discard Linklevel and IP and udp-header and any trailing bytes:                  Enc28J60Network::copyPacket(data->packet_next,0,UIPEthernetClass::in_packet,UIP_UDP_PHYH_LEN,Enc28J60Network::blockSize(data->packet_next));    #ifdef UIPETHERNET_DEBUG_UDP                  Serial.print(F("udp, uip_newdata received packet: "));                  Serial.print(data->packet_next);                  Serial.print(F(", size: "));                  Serial.println(Enc28J60Network::blockSize(data->packet_next));    #endif                }            }        }      if (uip_poll() && data->send)        {          //set uip_slen (uip private) by calling uip_udp_send#ifdef UIPETHERNET_DEBUG_UDP          Serial.print(F("udp, uip_poll preparing packet to send: "));          Serial.print(data->packet_out);          Serial.print(F(", size: "));          Serial.println(Enc28J60Network::blockSize(data->packet_out));#endif          UIPEthernetClass::uip_packet = data->packet_out;          UIPEthernetClass::uip_hdrlen = UIP_UDP_PHYH_LEN;          uip_udp_send(data->out_pos - (UIP_UDP_PHYH_LEN));        }    }}

/*---------------------------------------------------------------------------*/void _udp_sock_callback(c_event_t c_event, p_data_t p_data){    struct udp_socket *c;    if(c_event == EVENT_TYPE_TCPIP) {        /* An appstate pointer is passed to use from the IP stack           through the 'data' pointer. We registered this appstate when           we did the udp_new() call in udp_socket_register() as the           struct udp_socket pointer. So we extract this           pointer and use it when calling the reception callback. */        c = (struct udp_socket *)p_data;        /* Defensive coding: although the appstate *should* be non-null           here, we make sure to avoid the program crashing on us. */        if(c != NULL) {            LOG_INFO("socket ptr from callback = %p:%p", c, c->input_callback);            /* If we were called because of incoming data, we should call               the reception callback. */            if(uip_newdata()) {                /* Copy the data from the uIP data buffer into our own                   buffer to avoid the uIP buffer being messed with by the                   callee. */                memcpy(buf, uip_appdata, uip_datalen());                /* Call the client process. We use the PROCESS_CONTEXT                   mechanism to temporarily switch process context to the                   client process. */                if(c->input_callback != NULL) {                    c->input_callback(c, c->ptr,                                      &(UIP_IP_BUF->srcipaddr),                                      UIP_HTONS(UIP_IP_BUF->srcport),                                      &(UIP_IP_BUF->destipaddr),                                      UIP_HTONS(UIP_IP_BUF->destport),                                      buf, uip_datalen());                }            }        }    }}

/* --------------------------------------------------------------- */static void tcpip_handler(){    // Check that what we have received is a new packet    if (!uip_newdata())        return;    // Clean buffer    memset(command, 0, MAX_COMMAND_LEN);    // Get the data    command_len = uip_datalen();    memcpy(command, uip_appdata, command_len);    // Send the command by a serial line    // "putstring" does not depend of the debug verbosity level    printf("%s/n", command);    // Debug messages    PRINTF("# Recevied %u bytes from [", command_len);    PRINT6ADDR(&UIP_IP_BUF->srcipaddr);    PRINTF("]:%u/n", UIP_HTONS(UIP_UDP_BUF->srcport));}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  static int seq_id;  char buf[MAX_PAYLOAD_LEN];  if(uip_newdata()) {    ((char *)uip_appdata)[uip_datalen()] = 0;    PRINTF("Server received: '%s'", (char *)uip_appdata);    PRINT6ADDR(&UIP_IP_BUF->srcipaddr);    PRINTF("/r/n");    uip_ipaddr_copy(&server_conn->ripaddr, &UIP_IP_BUF->srcipaddr);    PRINTF("Responding with message: ");    sprintf(buf, "Hello from the server! (%d)", ++seq_id);    PRINTF("%s/r/n", buf);    uip_udp_packet_send(server_conn, buf, strlen(buf));    /* Restore server connection to allow data from any node */    memset(&server_conn->ripaddr, 0, sizeof(server_conn->ripaddr));  }}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  static uint32_t number;  static uint16_t loc,i;  if(uip_newdata()) {    switch( ((char*)uip_appdata)[0] ) {    case 'A': // anuncio      memcpy(&number, (char*)uip_appdata+1, sizeof(uint32_t));      //printf("anuncio %lu/n", number);      loc = -1;      for( i = 0 ; loc == -1 && i < HISTORY_SIZE ; ++ i ) {    	  if( history[i].id == number ) {    	    loc = i;    	  }      }      if( loc != -1 ) {    	  if( cur_time-INTERV_END <= history[loc].time && history[loc].time <= cur_time-INTERV_BEG ) {    	    printf("abrir %lu/n", number);    	    history[loc].time = 0;      	} else if( history[loc].time < cur_time-INTERV_END ) {    	    history[loc].time = cur_time;    	  }      } else {    	  loc = 0;    	  for( i = 1 ; i < HISTORY_SIZE ; ++ i ) {		    if( history[i].time < history[loc].time ) {		      loc = i;		    }		  }		  history[loc].id = number;		  history[loc].time = cur_time;      }      break;    default: putchar(((char*)uip_appdata)[0]);    }  }}

PROCESS_THREAD(UDP_echo_process, ev, data){    static uip_ipaddr_t localaddr;    static struct uip_udp_conn *localconn;    PROCESS_BEGIN();    /* Create the local listener */    localconn = udp_new(&uip_all_zeroes_addr, 0, NULL);    udp_bind(localconn,uip_htons(local_port));    while (1)    {        PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);        /* If there is new uIP data, display it */        if(uip_newdata()) {            /* Add the end of string. */            ((char *)uip_appdata)[uip_datalen()] = 0;            printf("New uIP data: '%s'/n", uip_appdata);        }    }    PROCESS_END();}

void netfind_app_call(void){        if(uip_poll()) {                switch(netfind_s.state) {                        case NETFIND_STATE_WAIT:                                if(get_clock() > netfind_s.send_answer_time)                                        netfind_s.state = NETFIND_STATE_SEND_ANSWER;                                break;                        case NETFIND_STATE_SEND_ANSWER:                                netfind_send_answer();                                break;                }        }        if(uip_newdata()) {                switch(netfind_s.state) {                        case NETFIND_STATE_IDLE:                                netfind_handle_request();                                break;                }        }}

static voiddc3840_net_main (void){    if (!uip_newdata ())	return;    uip_udp_conn_t dc3840_conn;    #define BUF ((struct uip_udpip_hdr *) (uip_appdata - UIP_IPUDPH_LEN))    uip_ipaddr_copy(dc3840_conn.ripaddr, BUF->srcipaddr);    dc3840_conn.rport = BUF->srcport;    dc3840_conn.lport = HTONS(DC3840_PORT);    uip_udp_conn = &dc3840_conn;    uint16_t offset = atoi (uip_appdata);    dc3840_get_data (uip_appdata, offset, 512);    uip_slen = 512;    uip_process (UIP_UDP_SEND_CONN);    router_output ();    uip_slen = 0;		/* No reply. */}

bool readUDP(NetworkSocket * networkSocket, uint8_t * buffer, int bufferLength, NetworkAddress ** sourceAddress, int *readLength){    bool result = true;    *readLength = 0;    //if (uip_newdata() && (UIP_IP_BUF->destport == networkSocket->Port) )    if (uip_newdata())    {        Lwm2m_Debug("Packet from: %d %d/n", uip_htons(UIP_IP_BUF->destport), networkSocket->Port);        if (uip_datalen() > bufferLength)            *readLength = bufferLength;        else            *readLength = uip_datalen();    }    if (*readLength > 0)    {        uip_ipaddr_t * address = &UIP_IP_BUF->srcipaddr;        uint16_t port = uip_htons(UIP_IP_BUF->srcport);        bool secure = (networkSocket->SocketType & NetworkSocketType_Secure) == NetworkSocketType_Secure;        memcpy(buffer, uip_appdata, *readLength);        NetworkAddress * networkAddress = getCachedAddress(address, port);        if (networkAddress == NULL)        {            networkAddress = addCachedAddress(address, port, secure);            if (networkAddress)            {                networkAddress->useCount++;         // TODO - ensure addresses are freed? (after t/o or transaction or DTLS session closed)            }        }        if (networkAddress)        {            *sourceAddress = networkAddress;        }    }    return result;}

void _udp_states_process(void) {    if(uip_len>7&&uip_newdata()) { // a minimum packet of udp_states are 8 byte -> smaller are a corrupted packet        uint16_t len = uip_len-5; //header length are 5 byte so the states are uip_len - 5        uint8_t buffer[uip_len]; //get memory for the packet        memcpy(buffer, uip_appdata, uip_len); //get the packet        udp_states_packet_t packet; // place for the header        udp_states_state_t tmp_state; // a state to compare        udp_states_state_t *found_state; //pointer to the found state        packet.node = buffer[1]; //make the packet        packet.type = buffer[2];        packet.part = buffer[3];        packet.prio_byte= buffer[4];        packet.data=&buffer[5];        tmp_state.node=packet.node; //make the compare state        tmp_state.type=packet.type;        tmp_state.part=packet.part;        debug_printf("UDP_STATES %x:%x:%x %x:%x:%x/n%x,%x,%x",tmp_state.node,tmp_state.type,tmp_state.part,udp_states_states[0].node,udp_states_states[0].type,udp_states_states[0].part,buffer[6],buffer[7],buffer[8]);        found_state=(udp_states_state_t*) bsearch((const void*)&tmp_state,(const void*)udp_states_states,udp_states_n_registert_states,sizeof(udp_states_state_t),_udp_states_compare);        udp_states_make_state(found_state,packet,len); //make state from the packet        for(udp_states_state_t *i = found_state; i>=udp_states_states; i--) { //search other states in the packet            if(_udp_states_compare(i,&tmp_state)!=0) //if compare from the state is not null for the state is a other packet needed                break;            else {                udp_states_make_state(i,packet,len); //so make the state            }        }        for(udp_states_state_t *i = found_state; i<=udp_states_states+sizeof(udp_states_state_t); i++) { //search in the other direction            if(_udp_states_compare(i,&tmp_state)!=0) //like the other code                break;            else {                udp_states_make_state(i,packet,len); // like the other code            }        }    }    uip_slen = 0; //all data procecced}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  /* handle the incoming packet */  if(uip_newdata()) {    if( ((query_pkt_t*)uip_appdata)->type == 1){      /* Query Packet */      query_pkt_t *appdata;      appdata = (query_pkt_t*)uip_appdata;        if(!appdata->multicast_flag)          collect_common_send();        else{          if(appdata->query_id > cur_query_id) { /* Do not reply to the duplicate query */            cur_query_id = appdata->query_id;            if(region == SENSOR || region == ANONYMOUS){              collect_common_send();            }            else if (appdata->id < region) { //else drop the query, received from the lower region            /* send multicast query to the lower regions */              appdata->id = region;              uip_ipaddr_t addr;              uip_create_linklocal_allnodes_mcast(&addr);              uip_udp_packet_sendto(server_conn, appdata, sizeof(query_pkt_t),                          &addr, UIP_HTONS(UDP_CLIENT_PORT));            }          }         }    }    else if( ((identity_pkt_t*)uip_appdata)->type == 2){      /* Identity Packet */      if(region > ((identity_pkt_t*)uip_appdata)->id )        add_new_nbr(((identity_pkt_t*)uip_appdata)->id, UIP_IP_BUF->srcipaddr, cc2420_last_rssi);      print_nbr_table();    }  }}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){	uint8_t *appdata;	rimeaddr_t sender;    uint8_t seqno;	uint16_t len;	//uint16_t client_clock;	//uint16_t rank;	uint16_t num_neighbors;	uint8_t hops;	if(uip_newdata()) {	    appdata = (uint8_t *)uip_appdata;	    seqno = *appdata;	    sender.u8[0] = UIP_IP_BUF->srcipaddr.u8[15];	    sender.u8[1] = UIP_IP_BUF->srcipaddr.u8[14];	    hops = uip_ds6_if.cur_hop_limit - UIP_IP_BUF->ttl + 1;	    uint16_t data;	    uint16_t payload_len = uip_datalen() - 2;	    uint8_t* payload = appdata +2;	    int i;	    PRINTF("DATA recv from %d: ",UIP_IP_BUF->srcipaddr.u8[sizeof(UIP_IP_BUF->srcipaddr.u8) - 1]);	    PRINTF(" %u ",seqno);	    for(i = 0; i < payload_len / 2; i++) {	      memcpy(&data, payload, sizeof(data));	      payload += sizeof(data);	      PRINTF("  %u ", data);	    }	    PRINTF(" %d, %u/n",hops,clock_time());	    //print format: node id | seqno,len | client_time | client_rank | client_neighbor_num | hops | current_time	  }}

/*---------------------------------------------------------------------*/PROCESS_THREAD(test_uip_process, ev, data){    PROCESS_BEGIN();    printf("uIP test process started/n");    broadcast_conn = udp_broadcast_new(COOJA_PORT, NULL);    button_sensor.configure(SENSORS_ACTIVE, 1);    while(1) {        PROCESS_WAIT_EVENT();        printf("An event occured: ");        if(ev == PROCESS_EVENT_EXIT) {            printf("shutting down/n");            break;        }        if(ev == sensors_event && data == &button_sensor) {            printf("button clicked, sending packet/n");            tcpip_poll_udp(broadcast_conn);            PROCESS_WAIT_UNTIL(ev == tcpip_event && uip_poll());            uip_send("cooyah COOJA", 12);        } else if(ev == sensors_event) {            printf("unknown sensor event: %s/n", ((struct sensors_sensor *)data)->type);        } else if(ev == tcpip_event && uip_newdata()) {            printf("a packet was received, toggling leds/n");            printf("packet data: '%s'/n", (char*) uip_appdata);            leds_toggle(LEDS_ALL);        } else {            printf("unknown event: %d/n", ev);        }    }    PROCESS_END();}

voidzbus_raw_net_main(void) {  if (uip_newdata ())    {      /* 600ms timeout */      uip_udp_conn->appstate.zbus_raw.timeout = 3;      uip_ipaddr_copy(uip_udp_conn->ripaddr, BUF->srcipaddr);      uip_udp_conn->rport = BUF->srcport;            zbus_send_data(uip_appdata, uip_len);      return;    }  if (! uip_udp_conn->appstate.zbus_raw.timeout)    return;  if (-- uip_udp_conn->appstate.zbus_raw.timeout)    return;			/* timeout not yet over. */  uip_ipaddr_copy(uip_udp_conn->ripaddr, all_ones_addr);  uip_udp_conn->rport = 0;}

void dhcp_app_call(void){        if(uip_newdata()) {                switch(dhcp_s.state) {                        case DHCP_STATE_OFFER:                                dhcp_parse_offer();                                break;                        case DHCP_STATE_ACK:                                dhcp_parse_ack();                                break;                }        }        if(uip_poll()) {                switch(dhcp_s.state) {                        case DHCP_STATE_BOOT_WAIT:                                if(get_clock() > dhcp_s.dhcp_renew_time)                                        dhcp_s.state = DHCP_STATE_DISCOVER;                                break;                        case DHCP_STATE_DISCOVER:                                dhcp_send_discover();                                break;                        case DHCP_STATE_REQUEST:                                dhcp_send_request();                                break;                        case DHCP_STATE_WAIT_RENEW:                                if(get_clock() > dhcp_s.dhcp_renew_time)                                        dhcp_s.state = DHCP_STATE_REQUEST;                                break;                }        }}

/*---------------------------------------------------------------------------*/PROCESS_THREAD(shell_udpsend_process, ev, data){  const char *next, *nextptr;  struct shell_input *input;  uint16_t port, local_port;    PROCESS_BEGIN();  next = strchr(data, ' ');  if(next == NULL) {    shell_output_str(&udpsend_command,		     "udpsend <server> <port> [localport]: server as address", "");    PROCESS_EXIT();  }  if(next - (char *)data > sizeof(server)) {    shell_output_str(&udpsend_command, "Too long input", "");    PROCESS_EXIT();  }  strncpy(server, data, sizeof(server));  /* NULL-terminate the server string. */  server[next - (char *)data] = 0;  ++next;  port = shell_strtolong(next, &nextptr);  uiplib_ipaddrconv(server, &serveraddr);  udpconn = udp_new(&serveraddr, uip_htons(port), NULL);    if(next != nextptr) {    local_port = shell_strtolong(nextptr, &nextptr);    udp_bind(udpconn, uip_htons(local_port));  }  running = 1;  while(running) {    PROCESS_WAIT_EVENT();    if(ev == shell_event_input) {      input = data;      if(input->len1 + input->len2 == 0) {		PROCESS_EXIT();      }	  if(input->len1 == 5) {		  	PROCESS_EXIT();  //YIBO: For exit this process.    	  }      if(input->len1 > 0) {		send_line(input->data1, input->len1);      }    } else if(ev == tcpip_event) {      if(uip_newdata()) {		newdata(uip_appdata, uip_datalen());      }#if 0    } else if(ev == resolv_event_found) {      /* Either found a hostname, or not. */      if((char *)data != NULL &&	 resolv_lookup((char *)data, &ipaddr) == RESOLV_STATUS_CACHED) {	uip_ipaddr_copy(serveraddr, ipaddr);	telnet_connect(&s, server, serveraddr, nick);      } else {	shell_output_str(&udpsend_command, "Host not found.", "");      }#endif /* 0 */    }  }  PROCESS_END();}

/*------------------------------------------------------------------*/static u8_traven_gui_loop(process_event_t ev, process_data_t data){    uint8_t *ptr;    int len = 0;    if(ev == tcpip_event) {        PRINTF("[APP] TCPIP event lport %u rport %u raddress/n",uip_udp_conn->lport, uip_udp_conn->rport);        if(uip_udp_conn == node_conn) {            PRINTF("[APP] UDP packet/n");            if(uip_newdata()) {                ptr = (uint8_t *)uip_appdata;                /* Make sure the data is terminated */                ptr[uip_datalen()] = 0;                /* Command to this node */                switch(*ptr) {                case 'T':                    send_frame(TEMP_REQUEST, 0, 0);                    len = snprintf(udp_data,                                   DATA_LEN, "%c%s/r/n", *ptr, last_temp);                    if(len > 0) {                        reply_packet(udp_data, len);                    }                    break;                case 'A':                    if(ptr[1] > 32) {                        invert_led = ptr[1] == '1';                        send_frame(LED_REQUEST, 1, &invert_led);                    }                    len = sprintf(udp_data, "A%u/r/n", invert_led ? 1 : 0);                    if(len > 0) {                        reply_packet(udp_data, len);                    }                    break;                case 'P':                    PRINTF("[APP] Request for periodic sending of temperatures/n");                    if(sscanf((char *)ptr+1,"%d", &periodic_interval)) {                        PRINTF("[APP] Period %d/n", periodic_interval);                        if(periodic_interval == 0) {                            etimer_stop(&periodic_timer);                        } else {                            etimer_set(&periodic_timer, periodic_interval * CLOCK_SECOND);                        }                        len = snprintf(udp_data,                                       DATA_LEN, "P%d/r/n", periodic_interval);                        if(len > 0) {                            reply_packet(udp_data, len);                        }                    }                    break;                case 'C':                    PRINTF("[APP] Command %c/n",ptr[1]);                    if(sscanf((char *)ptr+2,                              "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x %d",                              &addr[0],&addr[1],&addr[2],&addr[3],&addr[4],                              &addr[5],&addr[6],&addr[7],&len) >= 8) {                        uip_ip6addr(&locaddr, addr[0], addr[1],addr[2],                                    addr[3],addr[4],addr[5],addr[6],addr[7]);                        if(ptr[1] == 'E') {                            PRINTF("[APP] Send ping to");                            PRINT6ADDR(&locaddr);                            PRINTF("len %d/n", len);                            raven_ping6(&locaddr, len);                        } else if (ptr[1] == 'T') {                            PRINTF("[APP] Send temperature to");                            PRINT6ADDR(&locaddr);                            PRINTF("/n");                            len = snprintf(udp_data, DATA_LEN, "%c/r/n", ptr[1]);                            if(len > 0) {                                send_packet(&locaddr, HTONS(0xF0B0), udp_data, len);                            }                        } else {                            PRINTF("[APP] Command unknown/n");                        }                    }                    break;                default:                    break;                }            }        }    } else {        switch (ev) {        case ICMP6_ECHO_REQUEST:            /* We have received a ping request over the air.               Send frame back to 3290 */            send_frame(PING_REQUEST, 0, 0);            break;        case ICMP6_ECHO_REPLY:            /* We have received a ping reply over the air.               Send frame back to 3290 */            send_frame(PING_REPLY, 1, &seqno);            break;        case PROCESS_EVENT_TIMER:            if(data == &periodic_timer) {                PRINTF("[APP] Periodic Timer/n");                /* Send to server if time to send */                len = sprintf(udp_data, "T%s/r/n", last_temp);//.........这里部分代码省略.........

/*---------------------------------------------------------------------------*/staticPT_THREAD(handle_dhcp(void)){  PT_BEGIN(&s.pt);    /* try_again:*/  s.state = STATE_SENDING;  s.ticks = CLOCK_SECOND;  do {    send_discover();    timer_set(&s.timer, s.ticks);    PT_YIELD(&s.pt);    PT_WAIT_UNTIL(&s.pt, uip_newdata() || timer_expired(&s.timer));    if(uip_newdata() && parse_msg() == DHCPOFFER) {      s.state = STATE_OFFER_RECEIVED;      break;    }    if(s.ticks < CLOCK_SECOND * 60) {      s.ticks *= 2;    }  } while(s.state != STATE_OFFER_RECEIVED);    s.ticks = CLOCK_SECOND;  do {    send_request();    timer_set(&s.timer, s.ticks);    PT_YIELD(&s.pt);    PT_WAIT_UNTIL(&s.pt, uip_newdata() || timer_expired(&s.timer));    if(uip_newdata() && parse_msg() == DHCPACK) {      s.state = STATE_CONFIG_RECEIVED;      break;    }    if(s.ticks <= CLOCK_SECOND * 10) {      s.ticks += CLOCK_SECOND;    } else {      PT_RESTART(&s.pt);    }  } while(s.state != STATE_CONFIG_RECEIVED);  #if 0  printf("Got IP address %d.%d.%d.%d/n",	 uip_ipaddr1(s.ipaddr), uip_ipaddr2(s.ipaddr),	 uip_ipaddr3(s.ipaddr), uip_ipaddr4(s.ipaddr));  printf("Got netmask %d.%d.%d.%d/n",	 uip_ipaddr1(s.netmask), uip_ipaddr2(s.netmask),	 uip_ipaddr3(s.netmask), uip_ipaddr4(s.netmask));  printf("Got DNS server %d.%d.%d.%d/n",	 uip_ipaddr1(s.dnsaddr), uip_ipaddr2(s.dnsaddr),	 uip_ipaddr3(s.dnsaddr), uip_ipaddr4(s.dnsaddr));  printf("Got default router %d.%d.%d.%d/n",	 uip_ipaddr1(s.default_router), uip_ipaddr2(s.default_router),	 uip_ipaddr3(s.default_router), uip_ipaddr4(s.default_router));  printf("Lease expires in %ld seconds/n",	 ntohs(s.lease_time[0])*65536ul + ntohs(s.lease_time[1]));#endif  dhcpc_configured(&s);    /*  timer_stop(&s.timer);*/  /*   * PT_END restarts the thread so we do this instead. Eventually we   * should reacquire expired leases here.   */  while(1) {    PT_YIELD(&s.pt);  }  PT_END(&s.pt);}

/** uIP stack application callback for the TELNET server. This function must be called each time the *  TCP/IP stack needs a TCP packet to be processed. */void TELNETServerApp_Callback(void){	uip_tcp_appstate_t* const AppState   = &uip_conn->appstate;	char*               const AppData    = (char*)uip_appdata;	if (uip_connected())	{		/* New connection - initialize connection state values */		AppState->TELNETServer.CurrentState = TELNET_STATE_SendHeader;	}	if (uip_acked())	{		/* Progress to the next state once the current state's data has been ACKed */		AppState->TELNETServer.CurrentState = AppState->TELNETServer.NextState;	}	if (uip_rexmit() || uip_acked() || uip_newdata() || uip_connected() || uip_poll())	{		switch (AppState->TELNETServer.CurrentState)		{			case TELNET_STATE_SendHeader:				/* Copy over and send the TELNET welcome message upon first connection */				strcpy_P(AppData, WelcomeHeader);				uip_send(AppData, strlen(AppData));				AppState->TELNETServer.NextState = TELNET_STATE_SendMenu;				break;			case TELNET_STATE_SendMenu:				/* Copy over and send the TELNET menu to the client */				strcpy_P(AppData, TELNETMenu);				uip_send(AppData, strlen(AppData));				AppState->TELNETServer.NextState = TELNET_STATE_GetCommand;				break;			case TELNET_STATE_GetCommand:				if (!(uip_datalen()))				  break;				/* Save the issued command for later processing */				AppState->TELNETServer.IssuedCommand = AppData[0];				AppState->TELNETServer.CurrentState  = TELNET_STATE_SendResponse;				break;			case TELNET_STATE_SendResponse:				/* Determine which command was issued, perform command processing */				switch (AppState->TELNETServer.IssuedCommand)				{					case 'c':						TELNETServerApp_DisplayTCPConnections();						break;					default:						strcpy_P(AppData, PSTR("Invalid Command./r/n"));						uip_send(AppData, strlen(AppData));						break;				}				AppState->TELNETServer.NextState = TELNET_STATE_SendMenu;				break;		}	}}