/*---------------------------------------------------------------------------*/
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 void
tcpip_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 void
tcpip_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
}
}
void
bootp_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 void
sms77_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 void
tcpip_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 void
tcpip_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--;
}
}
}
void
ntp_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;
}
}
}
void
uipudp_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 void
tcpip_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 void
tcpip_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 void
dc3840_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 void
tcpip_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 void
tcpip_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();
}
void
zbus_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_t
raven_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);
if(len > 0) {
send_packet(&server_addr, SERVER_PORT, udp_data, len);
}
etimer_reset(&periodic_timer);
send_frame(TEMP_REQUEST, 0, 0);
}
break;
case PROCESS_EVENT_POLL:
/* Check for command from serial port, execute it. */
if (cmd.done) {
/* Execute the waiting command */
switch (cmd.cmd) {
case CMD_PING:
/* Send ping request over the air */
seqno = cmd.frame[0];
raven_ping6(&server_addr, 0);
break;
case CMD_TEMP:
/* Copy sensor data until white space or end of
string. The ATMega3290 sends temperature with both
value and type (25 C) */
copy_value(cmd.frame, last_temp, sizeof(last_temp));
PRINTF("[APP] New temp value %s\n", last_temp);
break;
default:
break;
}
/* Reset command done flag. */
cmd.done = 0;
}
break;
default:
break;
}
}
return 0;
}
/*---------------------------------------------------------------------------*/
static
PT_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;
}
}
}
