static void write_pair(pSlip gd, pSlipObject pair) { pSlipObject car_obj; pSlipObject cdr_obj; car_obj = car(pair); cdr_obj = cdr(pair); slip_write(gd, car_obj); if (cdr_obj->type == eType_PAIR) { printf(" "); write_pair(gd, cdr_obj); } else if (cdr_obj->type == eType_EMPTY_LIST) { return; } else { printf(" . "); slip_write(gd, cdr_obj); } }
/*-----------------------------------------------------------------------------------*/ static void create_hello(void) { hello_packet_t packet; uint8_t state, i; uint8_t buf[HELLO_PACKETSIZE]; /* Construct packet */ packet.type = HELLO_PACKET; packet.operation = SEC_ARP_REQUEST; buf[0] = packet.type; buf[1] = packet.operation; /* Get device-id */ for(i = 0; i < UIP_DS6_ADDR_NB; i++) { state = uip_ds6_if.addr_list[i].state; if(uip_ds6_if.addr_list[i].isused && state == ADDR_PREFERRED) { memcpy(&buf[2], &uip_ds6_if.addr_list[i].ipaddr.u8[0], 16); } } /* Get device MAC */ memcpy(&buf[18], &rimeaddr_node_addr.u8[0], 8); /* Send buf over slip */ slip_write(buf, HELLO_PACKETSIZE); PRINTF("sec-arp: create\n"); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(slip_process, ev, data) { PROCESS_BEGIN(); rxbuf_init(); while(1) { PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL); slip_active = 1; /* Move packet from rxbuf to buffer provided by uIP. */ uip_len = slip_poll_handler(&uip_buf[UIP_LLH_LEN], UIP_BUFSIZE - UIP_LLH_LEN); #if !UIP_CONF_IPV6 if(uip_len == 4 && strncmp((char*)&uip_buf[UIP_LLH_LEN], "?IPA", 4) == 0) { char buf[8]; memcpy(&buf[0], "=IPA", 4); memcpy(&buf[4], &uip_hostaddr, 4); if(input_callback) { input_callback(); } slip_write(buf, 8); } else if(uip_len > 0 && uip_len == (((u16_t)(BUF->len[0]) << 8) + BUF->len[1]) && uip_ipchksum() == 0xffff) { #define IP_DF 0x40 if(BUF->ipid[0] == 0 && BUF->ipid[1] == 0 && BUF->ipoffset[0] & IP_DF) { static u16_t ip_id; u16_t nid = ip_id++; BUF->ipid[0] = nid >> 8; BUF->ipid[1] = nid; nid = uip_htons(nid); nid = ~nid; /* negate */ BUF->ipchksum += nid; /* add */ if(BUF->ipchksum < nid) { /* 1-complement overflow? */ BUF->ipchksum++; } } tcpip_input(); } else { uip_len = 0; SLIP_STATISTICS(slip_ip_drop++); } #else /* UIP_CONF_IPV6 */ if(uip_len > 0) { if(input_callback) { input_callback(); } tcpip_input(); } #endif /* UIP_CONF_IPV6 */ }
char *get_arch_rime_addr(void) { struct timer tm; uart2_set_input(uart_rbyte); while (rimeaddr_cmp(&arch_rime_addr, &rimeaddr_null)) { printf("send rime addr request!\r\n"); slip_write("?M", 2); timer_set(&tm, CLOCK_SECOND*2); while (!timer_expired(&tm)); } return (char *)&arch_rime_addr; }
/** \brief Take an IP packet and format it to be sent on an 802.15.4 * network using 6lowpan. * \param localdest The MAC address of the destination * * The IP packet is initially in uip_buf. Its header is compressed * and if necessary it is fragmented. The resulting * packet/fragments are put in packetbuf and delivered to the 802.15.4 * MAC. */ static uint8_t tip_output(uip_lladdr_t *localdest) { uint8_t buf[RIMEADDR_SIZE+4]; rimeaddr_t dest; /* * The destination address will be tagged to each outbound * packet. If the argument localdest is NULL, we are sending a * broadcast packet. */ if(localdest == NULL) { rimeaddr_copy(&dest, &rimeaddr_null); } else { rimeaddr_copy(&dest, (const rimeaddr_t *)localdest); } if (0 == rimeaddr_cmp(&dest, &laddr)) { // send rime addr buf[0]='!'; buf[1]='R'; rimeaddr_copy((rimeaddr_t *)&buf[2],(const rimeaddr_t *)localdest); slip_write(buf, 2+RIMEADDR_SIZE); rimeaddr_copy(&laddr, (const rimeaddr_t *)localdest); } #if DEBUG { uint16_t i; PRINTF(">>>len(%u) ", uip_len); for (i=0; i<uip_len; i++)PRINTF(":%02X", BUF[i]); PRINTF("\r\n"); } #endif packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &laddr); slip_write(&uip_buf[UIP_LLH_LEN], uip_len); return 1; }
/* Packet from SICSLoWPAN */ void tcpip_input(void) { if(uip_len > 0) { mac_LowpanToEthernet(); if(uip_len > 0) { /* printf("pppp i %u tx %u rx %u\n", UIP_IP_BUF->proto, packetbuf_attr(PACKETBUF_ATTR_TRANSMIT_TIME), packetbuf_attr(PACKETBUF_ATTR_LISTEN_TIME));*/ slip_write(uip_buf, uip_len); leds_invert(LEDS_RED); uip_len = 0; } } }
/*---------------------------------------------------------------------------*/ static void slip_input_callback(void) { unsigned char i; unsigned short chek_summ,chek_summ_recv; if (strncmp(uip_buf, "AdressTarget", 12) == 0){ chek_summ =chksum(chek_summ,(uint8_t*)uip_buf,16); chek_summ_recv = uip_buf[16]; chek_summ_recv |= ((uint16_t)uip_buf[17])<<8; if (chek_summ_recv==chek_summ){ //set new IPv6 addres uip_ipaddr_t ipaddr; uip_lladdr_t lladdr; lladdr.addr[0] = 0x00; lladdr.addr[1] = 0x12; lladdr.addr[2] = 0x4b; lladdr.addr[3] = 0x00; lladdr.addr[4] = uip_buf[12]; lladdr.addr[5] = uip_buf[13]; lladdr.addr[6] = uip_buf[14]; lladdr.addr[7] = uip_buf[15]; for (i=0;i<4;i++){ if (uip_buf[12+i]!= uip_ds6_if.addr_list[0].ipaddr.u8[12+i]) break; } if (i<4){ uip_ds6_addr_rm(&uip_ds6_if.addr_list[0]); uip_ip6addr(&ipaddr, 0x2001, 0x0db8, 0, 0x0212, 0, 0, 0, 0); uip_ds6_set_addr_iid(&ipaddr, &lladdr); uip_ds6_addr_add(&ipaddr, 0, ADDR_AUTOCONF); uip_buf[12] = uip_ds6_if.addr_list[0].ipaddr.u8[12]; uip_buf[13] = uip_ds6_if.addr_list[0].ipaddr.u8[13]; uip_buf[14] = uip_ds6_if.addr_list[0].ipaddr.u8[14]; uip_buf[15] = uip_ds6_if.addr_list[0].ipaddr.u8[15]; slip_write(uip_buf, 16); print_local_addresses(); } } } // PRINTF("SIN: %u\n", uip_len); }
static int slip_transmit(FAR struct slip_driver_s *priv) { uint8_t *src; uint8_t *start; uint8_t esc; int remaining; int len; /* Increment statistics */ ninfo("Sending packet size %d\n", priv->dev.d_len); NETDEV_TXPACKETS(&priv->dev); /* Send an initial END character to flush out any data that may have * accumulated in the receiver due to line noise */ slip_putc(priv, SLIP_END); /* For each byte in the packet, send the appropriate character sequence */ src = priv->dev.d_buf; remaining = priv->dev.d_len; start = src; len = 0; while (remaining-- > 0) { switch (*src) { /* If it's the same code as an END character, we send a special two * character code so as not to make the receiver think we sent an * END */ case SLIP_END: esc = SLIP_ESC_END; goto escape; /* If it's the same code as an ESC character, we send a special two * character code so as not to make the receiver think we sent an * ESC */ case SLIP_ESC: esc = SLIP_ESC_ESC; escape: { /* Flush any unsent data */ if (len > 0) { slip_write(priv, start, len); } /* Reset */ start = src + 1; len = 0; /* Then send the escape sequence */ slip_putc(priv, SLIP_ESC); slip_putc(priv, esc); } break; /* otherwise, just bump up the count */ default: len++; break; } /* Point to the next character in the packet */ src++; } /* We have looked at every character in the packet. Now flush any unsent * data */ if (len > 0) { slip_write(priv, start, len); } /* And send the END token */ slip_putc(priv, SLIP_END); NETDEV_TXDONE(&priv->dev); priv->txnodelay = true; return OK; }
static inline void slip_putc(FAR struct slip_driver_s *priv, int ch) { uint8_t buffer = (uint8_t)ch; slip_write(priv, &buffer, 1); }
int main(int argc, char *argv[]) { pSlip slip; char *buff; int32_t bufflen = 1024; FILE *fp = stdin; if (argc == 2) { fp = fopen(argv[1], "rt"); assert(fp != NULL); fseek(fp, 0x0L, SEEK_END); bufflen = ftell(fp); fseek(fp, 0x0L, SEEK_SET); } buff = malloc(bufflen+16); slip = slip_init(); assert(slip != NULL); printf("\nWelcome to bootstrap slip. Use ctrl-c to exit.\n"); while (slip->running == SLIP_RUNNING) { char *p; pSlipObject obj; printf("> "); fflush(stdout); memset(buff, 0x0, bufflen+1); fflush(stdout); fread(buff, 1, bufflen, fp); // echo if script if (fp != stdin) printf("%s", buff); fflush(stdout); if (buff[0] != 0) { if ( TokeniseBuffer(slip, buff, strlen(buff)) == 0) { while (obj != NULL && slip->running == SLIP_RUNNING) { obj = slip_read(slip); if (slip->running == SLIP_RUNNING && obj != NULL) { obj = slip_evaluate(slip, obj); if (slip->running == SLIP_RUNNING && obj != NULL) slip_write(slip, obj); printf("\n"); } } } else printf("tokenise buffer failed\n"); } else slip->running = SLIP_SHUTDOWN; }; if (slip->running == SLIP_SHUTDOWN) printf("\nThank you.\n"); slip_release(slip); if (fp != stdin) fclose(fp); return 0; }