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

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  char *str;  if(uip_newdata()) {    str = uip_appdata;    str[uip_datalen()] = '/0';    printf("Response from the server: '%s'/n", str);  }}

/*----------------------------------------------------------------------------*/static	void _demo_udp_callback(c_event_t c_event, p_data_t p_data) {	char *pc_str;	if(c_event == EVENT_TYPE_TCPIP) {		if(uip_newdata()) {			pc_str = uip_appdata;			pc_str[uip_datalen()] = '/0';			LOG_INFO("Packet from a client: '%s'/n/r", pc_str);			_demo_udp_sendMsg(_demo_extractSeq(pc_str) + 1);		}	}}

/*---------------------------------------------------------------------------*/static voiddtls_handle_read(dtls_context_t *ctx) {  session_t session;  if(uip_newdata()) {    dtls_session_init(&session);    uip_ipaddr_copy(&session.addr, &UIP_IP_BUF->srcipaddr);    session.port = UIP_UDP_BUF->srcport;    dtls_handle_message(ctx, &session, uip_appdata, uip_datalen());  }}

void handle_tcp_srv_app1(void){    static struct timer user_timer; //create a timer;    static bool app_init = FALSE;    if (uip_newdata()) {        printf_high("Server RX [%d] bytes/n", uip_datalen());        iot_uart_output(uip_appdata, uip_datalen());    }    if (uip_poll()) {        /* below codes shows how to send data to client  */        if ((app_init == FALSE) || timer_expired(&user_timer)) {            printf_high("TCP SERVER APP1 uip_poll_timer_expired/n");            uip_send("hello,this is tcp srv...", 24);            timer_set(&user_timer, 5*CLOCK_SECOND);            app_init = TRUE;        }    }}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  char *str;  if(uip_newdata()) {    str = uip_appdata;    str[uip_datalen()] = '/0';    printf("DATA recv '%s'/n", str);  }}

/*---------------------------------------------------------------------------*/static void man_udp_handler(void) {	if(uip_newdata()) {/*		((char *)uip_appdata)[uip_datalen()] = 0;		printf("New uIP data: '%s'/n", uip_appdata);		PRINT6ADDR(&man_conf->mnaddr);		printf("port = %u/n", man_conf->mnrport);*/		char rst;		rst = man_processing((uint8_t*)uip_appdata, uip_datalen(), &man_conf, client_conn);		PRINTF("ManUDP handler return with %d/n", rst);	}}

static u8_t parse_msg (void){  dhcpMsg_t *m = (dhcpMsg_t *) uip_appdata;  if ((m->op == DHCP_REPLY) && !memcmp (m->xid, xid, sizeof (xid)) && !memcmp (m->chaddr, dhcpcState->mac_addr, dhcpcState->mac_len))  {    memcpy (dhcpcState->ipaddr, m->yiaddr, 4);    return parse_options (&m->options [4], uip_datalen ());  }  return 0;}

/*---------------------------------------------------------------------------*/static u8_t parse_msg(void){  struct dhcp_msg *m = (struct dhcp_msg *)uip_appdata;  if(m->op == DHCP_REPLY &&     memcmp(m->xid, xid, sizeof(xid)) == 0 &&     memcmp(m->chaddr, s.mac_addr, s.mac_len) == 0) {    memcpy(s.ipaddr, m->yiaddr, 4);    return parse_options(&m->options[4], uip_datalen());  }  return 0;}

static uint8_tparse_msg(void){  struct dhcp_msg *m = (struct dhcp_msg *)uip_appdata;  if(m->op == DHCP_BOOTREPLY &&     memcmp(m->xid, &xid, sizeof(xid)) == 0 &&     memcmp(m->chaddr, dhcpc_state.mac_addr, dhcpc_state.mac_len) == 0) {    memcpy(dhcpc_state.ipaddr.u16, m->yiaddr, 4);    return parse_options(&m->options[4], uip_datalen());  }  return 0;}

/*---------------------------------------------------------------------------*/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",           UDP_IP_BUF->srcipaddr.u8[sizeof(UDP_IP_BUF->srcipaddr.u8) - 1]);    PRINTF("/n");#if SERVER_REPLY    PRINTF("DATA sending reply/n");    //uip_ipaddr_copy(&server_conn->ripaddr, &UDP_IP_BUF->srcipaddr);    //server_conn->rport = UDP_IP_BUF->srcport;    //uip_udp_packet_send(server_conn, appdata,uip_datalen() );    uip_udp_packet_sendto(server_conn, appdata,uip_datalen(),&UDP_IP_BUF->srcipaddr, UDP_IP_BUF->srcport);    //uip_create_unspecified(&server_conn->ripaddr);#endif  }}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  char *ptr;  char *str;  if(uip_newdata()) {    leds_on(LEDS_BLUE);    str = uip_appdata;    str[uip_datalen()] = '/0';    printf("DATA recv %s/n", str);  }  }

/*---------------------------------------------------------------------------*/PROCESS_THREAD(tcp_server, ev, data){	PROCESS_BEGIN();	tcp_listen(UIP_HTONS(8080));	while(1) {		PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);		printf("TCP server: receive TCP event/n");		if(uip_closed() || uip_aborted() || uip_timedout()) {			printf("TCP server: connection closed/n");		} else if(uip_connected()) {			printf("TCP server: connected/n");		}		if(uip_newdata()) {			printf("TCP server: receive new data/n");			uint16_t len = uip_datalen();			uint8_t *ptr = uip_appdata;			while(len--){				printf("%c", *ptr++);			}			printf("/n");			printf("TCP server: send echo message/n");			uip_send(uip_appdata, uip_datalen());		}		if(uip_rexmit() ||				uip_newdata() ||				uip_acked() ||				uip_connected() ||				uip_poll()) {			//senddata();		}	}    PROCESS_END();}

/*---------------------------------------------------------------------------*/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 uint8_tparse_msg(void){  struct dhcp_msg *m = (struct dhcp_msg *)uip_appdata;    if(m->op == DHCP_REPLY &&     memcmp(m->xid, xid, sizeof(xid)) == 0 &&     memcmp(m->chaddr, uip_ethaddr.addr, sizeof(struct uip_eth_addr)) == 0) {    memcpy(uip_udp_conn->appstate.dhcp.ipaddr, m->yiaddr, 4);    return parse_options(&m->options[4], uip_datalen());  }  return 0;}

/*----------------------------------------------------------------------------*/static	void _demo_udp_callback(c_event_t c_event, p_data_t p_data) {	char *pc_str;	if (etimer_expired(&st_et)) {		_demo_udp_sendMsg(l_lastSeqId);		etimer_restart(&st_et);	} else if (c_event == EVENT_TYPE_TCPIP) {		if (uip_newdata()) {			pc_str = uip_appdata;			pc_str[uip_datalen()] = '/0';			LOG_INFO("Packet from a server: '%s'/n/r", pc_str);			l_lastSeqId = _demo_extractSeq(pc_str);		}	}}

/*---------------------------------------------------------------------------*/static voidnet_input(void){  if(uip_newdata()) {    memset(buffer, 0, MAX_MSG_SIZE);    msg_len = MIN(uip_datalen(), MAX_MSG_SIZE - 1);    /* Copy data */    memcpy(buffer, uip_appdata, msg_len);    printf("%s", (char *)buffer);  }  return;}

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

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  char *appdata;  unsigned char i;  blink_event = process_alloc_event();  if(uip_newdata()) {    appdata = (char *)uip_appdata;    appdata[uip_datalen()] = 0;    for(i = 0; i < 4; i++){      dht11data[i] = *(appdata + i);    }    PRINTF("DATA recv '%s' from ", appdata);    PRINTF("%d",           UIP_IP_BUF->srcipaddr.u8[sizeof(UIP_IP_BUF->srcipaddr.u8) - 1]);    PRINTF("/n");    PRINTF("wendu is %c%c, shidu is %c%c /n", *appdata,*(appdata+1),*(appdata+2),*(appdata+3));    //    PRINTF("DATA sending reply/n");//    uip_ipaddr_copy(&server_conn->ripaddr, &UIP_IP_BUF->srcipaddr);    /*    if(strncmp(appdata, "RED", 3) == 0) {      leds_on(LEDS_RED);      leds_off(LEDS_GREEN);      sta = 0;      }    if(strncmp(appdata, "GREEN", 5) == 0) {      leds_on(LEDS_GREEN);      leds_off(LEDS_RED);      sta = 0;      }    if(strncmp(appdata,"BLINK",5) == 0) {      process_post(&udp_server_process, blink_event, NULL);      sta = 1;    }    if(strncmp(appdata,"OFF",3) == 0) {      leds_off(LEDS_RED | LEDS_GREEN);      sta = 0;    }#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 uint8_tparse_msg(struct ntp_time *time){  struct ntp_msg *m = (struct ntp_msg *)uip_appdata;  // check correct time len  if(uip_datalen() != sizeof(struct ntp_msg))    return 0;  // adjust endianess  time->seconds = ntp_read_u32(m->transmit_timestamp[0]);  time->fraction = ntp_read_u32(m->transmit_timestamp[1]) >> 16;  return 1;}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  leds_on(LEDS_GREEN);  if(uip_newdata()) {    putstring("0x");    puthex(uip_datalen());    putstring(" bytes response=0x");    puthex((*(uint16_t *) uip_appdata) >> 8);    puthex((*(uint16_t *) uip_appdata) & 0xFF);    putchar('/n');  }  leds_off(LEDS_GREEN);  return;}

/*--------------------------------------------------------------------------------------------*/ void tcpip_handler(struct udp_tx *udp_tx_info){	 if(uip_newdata()){		 ((char *)uip_appdata)[uip_datalen()] = 0;		 		PRINTF("Server received: '%s' from [", (char *)uip_appdata);		 		PRINT6ADDR(&UIP_IP_BUF->srcipaddr);		 		PRINTF("]:%u",UIP_HTONS(UIP_UDP_BUF->srcport));		 		PRINTF("/n");		 		uip_ipaddr_copy(&server_conn->ripaddr, &UIP_IP_BUF->srcipaddr);		 		server_conn->rport=uip_htons(3007);		 		PRINTF("Responding with message: ");		 		udp_data_handler(uip_appdata,udp_tx_info);	 } }

uint64_t _demo_extractSeq(char * str){	char temp[20];	uint8_t i = 0;	//uint8_t j = 0;	for (i=uip_datalen();i>0;i--) {		if (str[i] == '|' ) {			i--;			memcpy(temp,str,i);			temp[i] = '/0';			break;		}	}	return atol(temp);}

void uecmd_net_main() {	if (!uip_newdata ())		return;	char *p = (char *)uip_appdata;	/* Add /0 to the data and remove /n from the data */	do {		if (*p == '/r' || *p == '/n') {			break;		}	} while ( ++p <= ((char *)uip_appdata + uip_datalen()));	/* Parse the Data */	*p = 0;	char cmd[p - (char *)uip_appdata];	strncpy(cmd, uip_appdata, p - (char *)uip_appdata + 1);	uip_slen = 0;	while (uip_slen < UIP_BUFSIZE - UIP_IPUDPH_LEN) {		int16_t len = ecmd_parse_command(cmd, ((char *)uip_appdata) + uip_slen,						 (UIP_BUFSIZE - UIP_IPUDPH_LEN) - uip_slen);		uint8_t real_len = len;		if (!is_ECMD_FINAL(len)) { /* what about the errors ? */			/* convert ECMD_AGAIN back to ECMD_FINAL */			real_len = (uint8_t) ECMD_AGAIN(len);		}		uip_slen += real_len + 1;		((char *)uip_appdata)[uip_slen - 1] = '/n';		if (real_len == len || len == 0)			break;	}	/* Sent data out */	uip_udp_conn_t echo_conn;	uip_ipaddr_copy(echo_conn.ripaddr, BUF->srcipaddr);	echo_conn.rport = BUF->srcport;	echo_conn.lport = HTONS(ECMD_UDP_PORT);	uip_udp_conn = &echo_conn;	uip_process(UIP_UDP_SEND_CONN);	router_output();	uip_slen = 0;}

static unsigned char parse_msg(void){  int result = 0;  int bytes_available = uip_datalen();  unsigned char* pData = uip_appdata;  result = 1;  lo_message message = lo_message_deserialise(pData, bytes_available, &result);  if (result == 0) {    //char* path = lo_url_get_path(lo_address_get_url(lo_message_get_source(message)));    lo_arg** argv = lo_message_get_argv(message);    //if (!strcmp(path,'/set/rgb')) {      lo_arg* red = argv[0];      lo_arg* green = argv[1];      lo_arg* blue = argv[2];      float fRed = red->f;      float fGreen = green->f;      float fBlue = blue->f;      analogWrite(redPin, (unsigned char)(fRed * 0xFF));      analogWrite(greenPin, (unsigned char)(fGreen * 0xFF));      analogWrite(bluePin, (unsigned char)(fBlue * 0xFF));    /*}    else if (!strcmp(path, '/set/hsi')) {      lo_arg* H = argv[0];      lo_arg* S = argv[1];      lo_arg* I = argv[2];      unsigned char rgb[3];      hsi2rgb(H, S, I, rgb);      analogWrite(redPin, rgb[0]);      analogWrite(greenPin, rgb[1]);      analogWrite(bluePin, rgb[2]);    }*/  }  lo_message_free(message);  s.state = STATE_QUIT;  return 1;}

/*---------------------------------------------------------------------*/PROCESS_THREAD(test_uaodv_process, ev, data){  static uip_ipaddr_t addr;  PROCESS_BEGIN();  printf("uIP uAODV test process started/n");  uip_ipaddr(&addr, 0,0,0,0);  in_conn = udp_new(&addr, UIP_HTONS(0), NULL);  uip_udp_bind(in_conn, UIP_HTONS(COOJA_PORT));  uip_ipaddr(&addr, 10,10,10,4);  out_conn = udp_new(&addr, UIP_HTONS(COOJA_PORT), NULL);  button_sensor.configure(SENSORS_ACTIVE, 1);  while(1) {    PROCESS_WAIT_EVENT();    if(ev == sensors_event && data == &button_sensor) {      struct uaodv_rt_entry *route;      uip_ipaddr(&addr, 10,10,10,4);      route = uaodv_rt_lookup_any(&addr);      if (route == NULL || route->is_bad) {        printf("%d.%d.%d.%d: lookup %d.%d.%d.%d/n", uip_ipaddr_to_quad(&uip_hostaddr), uip_ipaddr_to_quad(&addr));        uaodv_request_route_to(&addr);      } else {        printf("%d.%d.%d.%d: send to %d.%d.%d.%d/n", uip_ipaddr_to_quad(&uip_hostaddr), uip_ipaddr_to_quad(&addr));        tcpip_poll_udp(out_conn);        PROCESS_WAIT_UNTIL(ev == tcpip_event && uip_poll());        uip_send("cooyah COOJA", 12);      }    }    if(ev == tcpip_event && uip_newdata()) {      ((char*) uip_appdata)[uip_datalen()] = 0;      printf("data received from %d.%d.%d.%d: %s/n",          uip_ipaddr_to_quad(&((struct uip_udpip_hdr *)&uip_buf[UIP_LLH_LEN])->srcipaddr),          (char *)uip_appdata);      leds_toggle(LEDS_ALL);    }  }  PROCESS_END();}

static voidnewdata(void){	u16_t len;	len = uip_datalen();	if (s.state == WEBCLIENT_STATE_STATUSLINE)		len = parse_statusline(len);	if (s.state == WEBCLIENT_STATE_HEADERS && len > 0)		len = parse_headers(len);	if (len > 0 && s.state == WEBCLIENT_STATE_DATA &&	    s.httpflag != HTTPFLAG_MOVED)		webclient_datahandler((char *)uip_appdata, len);}

void process1_app(void){  u16_t len;  /*if(uip_connected() && uip_conn->lport == HTONS(55555)) {      ser_print("1.  Accepted connection on port 55555/n");  }*/  if(uip_newdata()) {      len = uip_datalen();      memcpy(incoming, uip_appdata, len);      incoming[len] = '/0';     }  if(sendData != 0 && uip_conn->lport == HTONS(55555)){        //ser_print("Sending status.../n");        sprintf(temp, "%d", doorStatus);        uip_send(temp, 1);        sendData = 0;  }}

/* * In socketapp.h we have defined the UIP_APPCALL macro to * socket_app_appcall so that this function is uIP's application * function. This function is called whenever an uIP event occurs * (e.g. when a new connection is established, new data arrives, sent * data is acknowledged, data needs to be retransmitted, etc.). */void socket_app_appcall( void ){    /*     * The uip_conn structure has a field called "appstate" that holds     * the application state of the connection. We make a pointer to     * this to access it easier.     */    struct socket_app_state *s = &(uip_conn->appstate);    /*     * If a new connection was just established, we should initialize     * the protosocket in our applications' state structure.     */    if ( uip_connected() )    {        s->no = counter++;        memset( buffer, 0, sizeof(buffer));        WiFi_connected( s->no );    }    /**     * Neue Daten anstehend     */    else if ( uip_newdata() )    {        memset( buffer, 0, sizeof(buffer) );        int length = uip_datalen();        int i = 0;        while ( i < length && i < sizeof(buffer) )        {            if	( ((char *) uip_appdata)[i] == '/r' )                continue;            if	( ((char *) uip_appdata)[i] == '/n' )                break;            buffer[i] = ((char *) uip_appdata)[i];            i++;        }        WiFi_newData( s->no, buffer, length );    }    /**     * Verbindung wird geschlossen     */    else if	( uip_aborted() || uip_closed() )    {        WiFi_closed( s->no );    }}

/*---------------------------------------------------------------------------*/static voidtcpip_handler(void){  uint8_t *appdata;  linkaddr_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;    collect_common_recv(&sender, seqno, hops,                        appdata + 2, uip_datalen() - 2);  }}

/*-----------------------------------------------------------------------------------*/voidtelnet_app(void *ts){  struct telnet_state *s = (struct telnet_state *)ts;      if(uip_connected()) {    s->flags = 0;    telnet_connected(s);    senddata(s);    return;  }    if(uip_closed()) {    telnet_closed(s);  }    if(uip_aborted()) {    telnet_aborted(s);  }  if(uip_timedout()) {    telnet_timedout(s);  }  if(s->flags & FLAG_CLOSE) {    uip_close();    return;  }  if(s->flags & FLAG_ABORT) {    uip_abort();    return;  }  if(uip_acked()) {    acked(s);  }  if(uip_newdata()) {    telnet_newdata(s, (char *)uip_appdata, uip_datalen());  }  if(uip_rexmit() ||     uip_newdata() ||     uip_acked()) {    senddata(s);  } else if(uip_poll()) {    senddata(s);  }}