int main(int argc, char *argv[]) { (void)argc, (void)argv; unsigned char packet[MAX_PACKET_SIZE]; struct interface_data iface_data; unsigned char dest_mac[ETH_ALEN] = {0x90, 0x2b, 0x34, 0x1a, 0x5f, 0x04}; struct sockaddr_ll dest_address; const int packet_size = 64; unsigned char payload[4] = {0xde, 0xad, 0xbe, 0xef}; int sockfd = socket(AF_PACKET, SOCK_RAW, IPPROTO_RAW); assert(sockfd > 2); get_src_mac(&iface_data, sockfd); fill_packet(packet, dest_mac, iface_data.if_mac.ifr_hwaddr.sa_data, packet_size, payload); dest_address.sll_ifindex = iface_data.index; dest_address.sll_halen = ETH_ALEN; memcpy(dest_address.sll_addr, dest_mac, ETH_ALEN); int result = sendto(sockfd, packet, packet_size, 0, (struct sockaddr*)&dest_address, sizeof(struct sockaddr_ll)); assert(result == packet_size); return 0; }
void ntp_sendpacket() { if(eth_debug) { DC('n'); DC('s'); ntp_func(0); } if(ntp_conn == 0) return; uip_udp_conn = ntp_conn; fill_packet((ntp_packet_t*)uip_appdata); uip_send(uip_appdata, sizeof(ntp_packet_t)); uip_process(UIP_UDP_SEND_CONN); uip_arp_out(); network_send(); }
__dead static void worker(void *arg) { ifnet_t *ifp = ifunit(IFNAME_INT); unsigned int i = (uintptr_t)arg; struct mbuf *m = fill_packet(i); uint64_t n = 0; while (!run) /* spin-wait */; while (!done) { int error; error = npf_packet_handler(NULL, &m, ifp, PFIL_OUT); KASSERT(error == 0); n++; } npackets[i] = n; kthread_exit(0); }
static int test_bpf_code(void *code, size_t size) { ifnet_t *dummy_ifp = npf_test_addif(IFNAME_TEST, false, false); npf_cache_t npc = { .npc_info = 0 }; bpf_args_t bc_args; struct mbuf *m; nbuf_t nbuf; int ret, jret; void *jcode; /* Layer 3 (IP + TCP). */ m = fill_packet(IPPROTO_TCP); nbuf_init(&nbuf, m, dummy_ifp); npf_cache_all(&npc, &nbuf); memset(&bc_args, 0, sizeof(bpf_args_t)); bc_args.pkt = m; bc_args.wirelen = m_length(m); bc_args.arg = &npc; ret = npf_bpf_filter(&bc_args, code, NULL); /* JIT-compiled code. */ jcode = npf_bpf_compile(code, size); if (jcode) { jret = npf_bpf_filter(&bc_args, NULL, jcode); assert(ret == jret); bpf_jit_freecode(jcode); } else if (lverbose) { printf("JIT-compilation failed\n"); } m_freem(m); return ret; } static uint32_t npf_bpfcop_run(u_int reg) { struct bpf_insn insns_npf_bpfcop[] = { BPF_STMT(BPF_MISC+BPF_COP, NPF_COP_L3), BPF_STMT(BPF_LD+BPF_W+BPF_MEM, reg), BPF_STMT(BPF_RET+BPF_A, 0), }; return test_bpf_code(&insns_npf_bpfcop, sizeof(insns_npf_bpfcop)); } static bool npf_bpfcop_test(void) { bool fail = false; /* A <- IP version (4 or 6) */ struct bpf_insn insns_ipver[] = { BPF_STMT(BPF_MISC+BPF_COP, NPF_COP_L3), BPF_STMT(BPF_RET+BPF_A, 0), }; fail |= (test_bpf_code(&insns_ipver, sizeof(insns_ipver)) != IPVERSION); /* BPF_MW_IPVERI <- IP version */ fail |= (npf_bpfcop_run(BPF_MW_IPVER) != IPVERSION); /* BPF_MW_L4OFF <- L4 header offset */ fail |= (npf_bpfcop_run(BPF_MW_L4OFF) != sizeof(struct ip)); /* BPF_MW_L4PROTO <- L4 protocol */ fail |= (npf_bpfcop_run(BPF_MW_L4PROTO) != IPPROTO_TCP); return fail; }
int do_serial_comms(const char *ttyfile, const char *baudrate, struct record *root) { int fd; int len; speed_t speed; uint8_t *ptr; struct record *rec; const uint8_t BACKSPACE[] = {0x08}; const uint8_t ERASE_ALL[] = {0x00}; const uint8_t ACK = 0x06; ptr = io_buffer; if (baudrate_to_speed_t(baudrate, &speed)) { fprintf(stderr, "unsupported baudrate, %s\n", baudrate); return -1; } fd = serial_open(ttyfile, speed); if (fd < 0) { fprintf(stderr, "error opening serial port\n"); return -1; } fprintf(stdout, "Putting card into download mode.\n"); //Set PROG and reset set_dtr(fd, true); set_rts(fd, true); sleep(1); fprintf(stdout, "Trying to synchronize with ADuC70xx: "); fflush(stdout); while (serial_read_fully(fd, ptr, 1, 100)); set_rts(fd, false); do { len = serial_write_fully(fd, BACKSPACE, sizeof(BACKSPACE), 1000); len = serial_read_fully(fd, ptr, 24, 100); } while (!((len > 6) && (memcmp(ptr, "ADuC70", 6) == 0))); //Disable PROG set_dtr(fd, false); while (serial_read_fully(fd, ptr, 1, 100)); if ((len > 6) && (memcmp(ptr, "ADuC70", 6) == 0)) { int product_len = (memchr(ptr, ' ', 24) - (void *)ptr); fprintf(stdout, "Found %.*s\n", product_len, ptr); fprintf(stdout, "Erasing: "); fflush(stdout); len = fill_packet(ptr, 'E', 0x00000000, ERASE_ALL, sizeof(ERASE_ALL)); len = serial_write_fully(fd, ptr, len, 1000); len = serial_read_fully(fd, ptr, 1, 10000); if ((len <= 0) || (ptr[0] != ACK)) { fprintf(stdout, "FAILED\n"); goto error; } fprintf(stdout, "OK\n"); rec = root; while (rec != NULL) { int count = 0; uint32_t address = rec->address; uint8_t *data = data_buffer; struct record *drec; for (drec = rec; ((drec != NULL) && ((address + count) == drec->address) && ((count + drec->count) < DATA_BUFFER_SIZE)); drec = drec->next) { memcpy(data, drec->data, drec->count); data += drec->count; count += drec->count; } rec = drec; fprintf(stdout, "Writting (%#x): ", address); fflush(stdout); len = fill_packet(ptr, 'W', address, data_buffer, count); len = serial_write_fully(fd, ptr, len, 1000); len = serial_read_fully(fd, ptr, 1, 10000); if ((len <= 0) || (ptr[0] != ACK)) { fprintf(stdout, "FAILED\n"); goto error; } fprintf(stdout, "OK\n"); } if (reset) { fprintf(stdout, "Resetting: "); fflush(stdout); len = fill_packet(ptr, 'R', 0x00000001, NULL, 0); len = serial_write_fully(fd, ptr, len, 1000); len = serial_read_fully(fd, ptr, 1, 10000); if ((len <= 0) || (ptr[0] != ACK)) { fprintf(stdout, "FAILED\n"); goto error; } fprintf(stdout, "OK\n"); } } else { fprintf(stdout, "FAILED\n"); goto error; } if (follow) { int count = 600; while (count--) { len = serial_read(fd, ptr, 16, 1000); if (len > 0) { dump_text(stdout, ptr, len); } } } error: if (serial_close(fd) < 0) { fprintf(stderr, "error closing serial port\n"); return -1; } return 0; }
void main(void) { volatile packet_t *p; char c; uint16_t r=30; /* start reception 100us before ack should arrive */ uint16_t end=180; /* 750 us receive window*/ /* trim the reference osc. to 24MHz */ trim_xtal(); uart_init(UART1, 115200); vreg_init(); maca_init(); set_channel(0); /* channel 11 */ // set_power(0x0f); /* 0xf = -1dbm, see 3-22 */ // set_power(0x11); /* 0x11 = 3dbm, see 3-22 */ set_power(0x12); /* 0x12 is the highest, not documented */ /* sets up tx_on, should be a board specific item */ GPIO->FUNC_SEL_44 = 1; GPIO->PAD_DIR_SET_44 = 1; GPIO->FUNC_SEL_45 = 2; GPIO->PAD_DIR_SET_45 = 1; *MACA_RXACKDELAY = r; printf("rx warmup: %d\n\r", (int)(*MACA_WARMUP & 0xfff)); *MACA_RXEND = end; printf("rx end: %d\n\r", (int)(*MACA_RXEND & 0xfff)); set_prm_mode(AUTOACK); print_welcome("rftest-tx"); while(1) { /* call check_maca() periodically --- this works around */ /* a few lockup conditions */ check_maca(); while((p = rx_packet())) { if(p) { printf("RX: "); print_packet(p); free_packet(p); } } if(uart1_can_get()) { c = uart1_getc(); switch(c) { case 'z': r++; if(r > 4095) { r = 0; } *MACA_RXACKDELAY = r; printf("rx ack delay: %d\n\r", r); break; case 'x': if(r == 0) { r = 4095; } else { r--; } *MACA_RXACKDELAY = r; printf("rx ack delay: %d\n\r", r); break; case 'q': end++; if(r > 4095) { r = 0; } *MACA_RXEND = end; printf("rx end: %d\n\r", end); break; case 'w': end--; if(r == 0) { r = 4095; } else { r--; } *MACA_RXEND = end; printf("rx end: %d\n\r", end); break; default: p = get_free_packet(); if(p) { fill_packet(p); printf("autoack-tx --- "); print_packet(p); tx_packet(p); } break; } } } }
void main(void) { volatile packet_t *p; #ifdef CARRIER_SENSE volatile uint32_t i; #endif uint16_t r=30; /* start reception 100us before ack should arrive */ uint16_t end=180; /* 750 us receive window*/ /* trim the reference osc. to 24MHz */ trim_xtal(); uart_init(INC, MOD, SAMP); vreg_init(); maca_init(); ///* Setup the timer */ *TMR_ENBL = 0; /* tmrs reset to enabled */ *TMR0_SCTRL = 0; *TMR0_LOAD = 0; /* reload to zero */ *TMR0_COMP_UP = 18750; /* trigger a reload at the end */ *TMR0_CMPLD1 = 18750; /* compare 1 triggered reload level, 10HZ maybe? */ *TMR0_CNTR = 0; /* reset count register */ *TMR0_CTRL = (COUNT_MODE<<13) | (PRIME_SRC<<9) | (SEC_SRC<<7) | (ONCE<<6) | (LEN<<5) | (DIR<<4) | (CO_INIT<<3) | (OUT_MODE); *TMR_ENBL = 0xf; /* enable all the timers --- why not? */ set_channel(CHANNEL); /* channel 11 */ set_power(0x12); /* 0x12 is the highest, not documented */ /* sets up tx_on, should be a board specific item */ GPIO->FUNC_SEL_44 = 1; GPIO->PAD_DIR_SET_44 = 1; GPIO->FUNC_SEL_45 = 2; GPIO->PAD_DIR_SET_45 = 1; *MACA_RXACKDELAY = r; *MACA_RXEND = end; set_prm_mode(AUTOACK); while(1) { if((*TMR0_SCTRL >> 15) != 0) tick(); /* call check_maca() periodically --- this works around */ /* a few lockup conditions */ check_maca(); while((p = rx_packet())) { if(p) free_packet(p); } p = get_free_packet(); if(p) { fill_packet(p); #ifdef CARRIER_SENSE for(i=0; i<POWER_DELAY; i++) {continue;} while(get_power()>74) {} #endif #ifdef BLOCKING_TX blocking_tx_packet(p); #else tx_packet(p); #endif current_pkts++; #if defined(RANDOM_WAIT_TIME) || defined(FIXED_WAIT) random_wait(); #endif } } }
static void pg_inject(void) { u32 saddr; struct net_device *odev; struct sk_buff *skb; struct timeval start, stop; u32 total, idle; int pc, lcount; odev = pg_setup_inject(&saddr); if (!odev) return; skb = fill_packet(odev, saddr); if (skb == NULL) goto out_reldev; forced_stop = 0; idle_acc_hi = 0; idle_acc_lo = 0; pc = 0; lcount = pg_count; do_gettimeofday(&start); for(;;) { spin_lock_bh(&odev->xmit_lock); atomic_inc(&skb->users); if (!netif_queue_stopped(odev)) { if (odev->hard_start_xmit(skb, odev)) { kfree_skb(skb); if (net_ratelimit()) printk(KERN_INFO "Hard xmit error\n"); } pc++; } else { kfree_skb(skb); } spin_unlock_bh(&odev->xmit_lock); if (pg_ipg) nanospin(pg_ipg); if (forced_stop) goto out_intr; if (signal_pending(current)) goto out_intr; if (--lcount == 0) { if (atomic_read(&skb->users) != 1) { u32 idle_start, idle; idle_start = get_cycles(); while (atomic_read(&skb->users) != 1) { if (signal_pending(current)) goto out_intr; schedule(); } idle = get_cycles() - idle_start; idle_acc_lo += idle; if (idle_acc_lo < idle) idle_acc_hi++; } break; } if (netif_queue_stopped(odev) || current->need_resched) { u32 idle_start, idle; idle_start = get_cycles(); do { if (signal_pending(current)) goto out_intr; if (!netif_running(odev)) goto out_intr; if (current->need_resched) schedule(); else do_softirq(); } while (netif_queue_stopped(odev)); idle = get_cycles() - idle_start; idle_acc_lo += idle; if (idle_acc_lo < idle) idle_acc_hi++; } } do_gettimeofday(&stop); total = (stop.tv_sec - start.tv_sec)*1000000 + stop.tv_usec - start.tv_usec; idle = (((idle_acc_hi<<20)/pg_cpu_speed)<<12)+idle_acc_lo/pg_cpu_speed; if (1) { char *p = pg_result; p += sprintf(p, "OK: %u(c%u+d%u) usec, %u (%dbyte,%dfrags) %upps %uMB/sec", total, total-idle, idle, pc, skb->len, skb_shinfo(skb)->nr_frags, ((pc*1000)/(total/1000)), (((pc*1000)/(total/1000))*pkt_size)/1024/1024 ); } out_relskb: kfree_skb(skb); out_reldev: dev_put(odev); return; out_intr: sprintf(pg_result, "Interrupted"); goto out_relskb; }
PacketCenter::PacketCenter (string input, PacketType inputType) { /* By default the encryption key is set to null, for obvious reasons. */ _key = 0; /* Initialize the vectors. */ packets[ENCRYPTED].resize(1); packets[DECRYPTED].resize(1); processed[0] = false; processed[1] = false; HungryVector<Packet*>* packet_vector =0; /* If we're being handed a plaintext string */ if (inputType == DECRYPTED) { /* Alias the packet vector we're currently work with */ packet_vector = &packets[DECRYPTED]; unsigned int input_len = input.length(); /* Pad the input to have a length evenly divisible by eight. */ while (input_len % Packet::SIZE != 0) { input.append(" "); input_len++; } /* Determine the number of paackets that will be generated * from the input. */ unsigned int num_packets = input_len/Packet::SIZE; /*Split the input into chunks and place them into packets, * all of which go into the DECRYPTED packets vector. */ for (unsigned int p = 0; p < num_packets; p++) { int start = p*Packet::SIZE; string substring = input.substr(start, Packet::SIZE); Packet* pkt = new Packet(substring); packet_vector->add(pkt); } /* Get rid of extra slots from the double function. */ packet_vector->trim(); /* Make sure that we don't have the option to process this again. */ processed[DECRYPTED] = true; } else { /* Grab the correct vector. */ packet_vector = &packets[ENCRYPTED]; /* Get rid of the extra space that should be at the end of the string, * taking any other accidental extra spaces with it. */ TurnLeft::Utils::trimchar(input); /* There will be one space between each set, therefore, there is one * more set than spaces. */ int num_chars = count(input.begin(), input.end(), ' ')+1; /* This should be a number divisble by nine already, because * Blowfish null terminates packets. * If this assertion fails, it's because somebody * was tampering with the data... */ assert(num_chars % (Packet::SIZE+1) == 0); int num_packets = num_chars/(Packet::SIZE+1); /* This variable will be modified by the fill_packet method */ int start = 0; for (int p = 0; p < num_packets; p++) { /* Extracts the next eight char sets from the string, * converts the sets into an unsigned char, and assigns * that char to a spot in the CharArray that will * be given to the packet. */ Packet* pkt = fill_packet(input, start); packet_vector->add(pkt); } /* Trim any extra slots generated by the double method. */ packet_vector->trim(); /* Make sure we are not able to process encrypted data again. */ processed[ENCRYPTED] = true; } }
/* Test that fill_header generate right header * Test header and packet are right size header=8 packet=1024 * Test fill_packet generate right packet * Test read_header return right header data structure * Test read_packet reads correct amount of payload*/ int main(int argc, char *argv[]) { init_test(argc,argv); assert(sizeof(header_t)==8); assert(sizeof(packet_t)==1024); packet_t test_packet; header_t test_header; /* Test write and read header */ /* fill_header fills buf with header */ fill_header(100,200,333,ACK,&test_packet); /* We have empty test_header, read data in buf and assign it to test_heaer */ read_header(&test_header,&test_packet); assert(test_header.seq==100); assert(test_header.ack==200); assert(test_header.offset==333); assert(test_header.flag==ACK); /* Test write and read payload */ /* Initial send buffer */ u_char sender_buf[2048],recv_buf[2048]; memset(recv_buf,0,2048); u_char * psend=sender_buf; u_char * precv=recv_buf; int i; for (i=0;i<1016;i++) { sender_buf[i]=5; } for (i=1016;i<2032;i++) { sender_buf[i]=6; } for (i=2032;i<2048;i++) { sender_buf[i]=7; } /* Send 1016 bytes payload packet */ fill_packet(psend,&test_packet,PAYLOAD_SIZE); /* Suppose we send test_packet...... */ /* OK, Now we receive new data, cast it into test_packet */ read_packet(precv,&test_packet,PAYLOAD_SIZE); for (i=0;i<1016;i++) { assert(recv_buf[i]==5); } psend+=PAYLOAD_SIZE; precv+=PAYLOAD_SIZE; fill_packet(psend,&test_packet,PAYLOAD_SIZE); read_packet(precv,&test_packet,PAYLOAD_SIZE); for (i=1016;i<2032;i++) { assert(recv_buf[i]==6); } psend+=PAYLOAD_SIZE; precv+=PAYLOAD_SIZE; fill_packet(psend,&test_packet,16); read_packet(precv,&test_packet,16); for (i=2032;i<2048;i++) { assert(recv_buf[i]==7); } return 0; }