int send_packet( const packet *p, const char *why ) { int ret; mbedtls_net_context *dst = p->dst; /* insert corrupted ApplicationData record? */ if( opt.bad_ad && strcmp( p->type, "ApplicationData" ) == 0 ) { unsigned char buf[MAX_MSG_SIZE]; memcpy( buf, p->buf, p->len ); if( p->len <= 13 ) { mbedtls_printf( " ! can't corrupt empty AD record" ); } else { ++buf[13]; print_packet( p, "corrupted" ); } if( ( ret = dispatch_data( dst, buf, p->len ) ) <= 0 ) { mbedtls_printf( " ! dispatch returned %d\n", ret ); return( ret ); } } print_packet( p, why ); if( ( ret = dispatch_data( dst, p->buf, p->len ) ) <= 0 ) { mbedtls_printf( " ! dispatch returned %d\n", ret ); return( ret ); } /* Don't duplicate Application Data, only handshake covered */ if( opt.duplicate != 0 && strcmp( p->type, "ApplicationData" ) != 0 && rand() % opt.duplicate == 0 ) { print_packet( p, "duplicated" ); if( ( ret = dispatch_data( dst, p->buf, p->len ) ) <= 0 ) { mbedtls_printf( " ! dispatch returned %d\n", ret ); return( ret ); } } return( 0 ); }
int main() { struct packet p; init_packet(&p); print_packet(&p); tag_client_send(&p); print_packet(&p); tag_server_recv(&p); print_packet(&p); tag_server_send(&p); print_packet(&p); tag_client_recv(&p); print_packet(&p); return 0; }
static int client_send (uint8_t *data, uint32_t *count) { memcpy(send_buffer.data, data, *count); send_buffer.len = *count; print_packet(" REQUEST: ", send_buffer.data, send_buffer.len); server_process_message(send_buffer.data, send_buffer.len, recv_buffer.data, &recv_buffer.len); print_packet("RESPONSE: ", recv_buffer.data, recv_buffer.len); return 0; }
int main(int argc, char **argv) { if (argc != 2) { printf("No Argument Specified\n"); return 1; } char *endptr = argv[1]; int number = strtol(argv[1], &endptr, 10); if (endptr == argv[1] || number < 0 ) { printf("Invalid Argument\n"); return 1; } FILE *fp = fopen( CONTROLLER_DEV, "r+b"); if ( fp == NULL ) { printf("Controller Does Not Exist\n"); return 1; } controller control; fwrite( &number, 4, 1, fp ); for (int i = 0; i < number; i++) { fread(&control.place_holder, 4, 1, fp); print_packet(control); } fclose(fp); //free(control); return 0; }
void process_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet) { const struct sniff_ethernet *ether; /* The ethernet header */ const struct sniff_ip *ip; /* The IP header */ const struct sniff_tcp *tcp; /* The TCP header */ const char *payload; /* Packet payload. */ u_int size_ip; /* IP Header length */ u_int size_tcp; /* TCP Header length */ ether = (struct sniff_ethernet*)(packet); ip = (struct sniff_ip*)(packet + SIZE_ETHERNET); size_ip = IP_HL(ip) * 4; if(size_ip < 20) { printf("\t* Invalid IP header length: %u bytes\n", size_ip); return; } tcp = (struct sniff_tcp*)(packet + SIZE_ETHERNET + size_ip); size_tcp = TH_OFF(tcp) * 4; if(size_tcp < 20) { printf("\t*Invalid TCP header length: %u bytes\n", size_tcp); } payload = (u_char*)(packet + SIZE_ETHERNET + size_ip + size_tcp); print_packet(ether,ip,tcp); }
// Parse the ethernet headers, and return the payload position (0 on error). uint32_t eth_parse(struct pcap_pkthdr *header, uint8_t *packet, eth_info * eth, config * conf) { uint32_t pos = 0; if (header->len < 14) { fprintf(stderr, "Truncated Packet(eth)\n"); return 0; } while (pos < 6) { eth->dstmac[pos] = packet[pos]; eth->srcmac[pos] = packet[pos+6]; pos++; } pos = pos + 6; // Skip the extra 2 byte field inserted in "Linux Cooked" captures. if (conf->datalink == DLT_LINUX_SLL) { pos = pos + 2; } // Skip VLAN tagging if (packet[pos] == 0x81 && packet[pos+1] == 0) pos = pos + 4; eth->ethtype = (packet[pos] << 8) + packet[pos+1]; pos = pos + 2; SHOW_RAW( printf("\neth "); print_packet(header->len, packet, 0, pos, 18); )
int open_file(const char *path) { char errbuf[PCAP_ERRBUF_SIZE]; int packet_count = 0; pcap_t *file; struct pcap_pkthdr h; file = pcap_open_offline(path, errbuf); if (!file) { printf("Error: pcap_open_offline(): %s %s %d.\n", errbuf, __FILE__, __LINE__); return ERROR; } u_char *packet; while ((packet = (u_int8_t *) pcap_next(file, &h)) != NULL) { print_packet(&h, packet); packet_count++; } printf("%d paquetes en el archivo %s.\n", packet_count, path); return OK; }
/* send an ack for the given message and message ID */ static void send_ack (int sock, struct allnet_header * hp, unsigned char * message_ack, int send_resend_request, char * contact, keyset kset) { if ((hp->transport & ALLNET_TRANSPORT_ACK_REQ) == 0) { printf ("packet not requesting an ack, no ack sent\n"); return; } int size; struct allnet_header * ackp = create_ack (hp, message_ack, NULL, ADDRESS_BITS, &size); if (ackp == NULL) return; /* also save in the (very likely) event that we receive our own ack */ currently_sent_ack = (currently_sent_ack + 1) % NUM_ACKS; memcpy (recently_sent_acks [currently_sent_ack], message_ack, MESSAGE_ID_SIZE); #ifdef DEBUG_PRINT print_packet ((char *) ackp, size, "sending ack", 1); #endif /* DEBUG_PRINT */ send_pipe_message_free (sock, (char *) ackp, size, ALLNET_PRIORITY_LOCAL); /* after sending the ack, see if we can get any outstanding * messages from the peer */ if (send_resend_request) request_and_resend (sock, contact, kset); }
int main(int argc, char** argv) { if (argc < 2) { std::cerr << "USAGE: parsepgp <file>" << std::endl; return 1; } std::ifstream pgp_file; pgp_file.open(argv[1]); // Flawfinder: ignore (give the user what they want) std::stringstream str_stream; str_stream << pgp_file.rdbuf(); try { std::string file_contents = str_stream.str(); parse4880::parse( parse4880::ustring(file_contents.begin(), file_contents.end()), [](std::shared_ptr<parse4880::PGPPacket> packet) -> bool { print_packet(*packet, 0); return true; }); } catch(const parse4880::parse4880_error& e) { fprintf(stderr, "Parse error:\n\t%s\n", e.what()); return 1; } }
/********************************************************************** * %FUNCTION: handle_frame_from_tunnel * %ARGUMENTS: * ses -- l2tp session * buf -- received PPP frame * len -- length of frame * %RETURNS: * Nothing * %DESCRIPTION: * Shoots the frame to PPP's pty ***********************************************************************/ void l2tp_sync_ppp_handle_frame_from_tunnel(l2tp_session *ses, unsigned char *buf, size_t len) { int n; d_dbg("l2tp_sync_ppp_handle_frame_from_tunnel >>>\n"); //+++ michael_lee: (2012.06.15 11:56:55) // this will cause kernel skb unalign at ppp_synctty.c ppp_sync_input function. remove it. //--- michael_lee #if 0 /* Add framing bytes */ *--buf = 0x03; *--buf = 0xFF; len += 2; #endif #if 0 print_packet(2, buf, len, "l2tp_sync_ppp_handle_from_from_tunnel"); #endif //+++ fix by siyou. 2011/1/6 11:08¤W¤È //marco, add 20 ms sleep here, or in some situation, two packets will combine as one packet //which will affect the state machine and we will not reply chap response //usleep(20000); //--- /* TODO: Add error checking */ if (ses->pty_fd < 0) { d_dbg("Attempt to write %d bytes to non existent fd.", len); } else { n = write(ses->pty_fd, buf, len); } d_dbg("l2tp_sync_ppp_handle_frame_from_tunnel <<<\n"); }
// send WHOHAS to all peers void send_whohas_packet_to_all(struct packet* packets, int packet_count, int socket, struct sockaddr* dst_addr){ int i = 0; for(i=0;i<packet_count;i++){ print_packet(&packets[i]); send_packet(packets[i], socket, dst_addr); } }
/********************************************************************** * %FUNCTION: handle_frame_to_tunnel * %ARGUMENTS: * ses -- l2tp session * %RETURNS: * Nothing * %DESCRIPTION: * Handles readability on PTY; shoots PPP frame over tunnel ***********************************************************************/ void l2tp_sync_ppp_handle_frame_to_tunnel(l2tp_session * ses) { static unsigned char buf[4096+EXTRA_HEADER_ROOM]; unsigned char * payload; int n; int iters = 5; d_dbg("%s >>>\n" , __FUNCTION__); /* It seems to be better to read in a loop than to go * back to select loop. However, don't loop forever, or * we could have a DoS potential */ payload = buf + EXTRA_HEADER_ROOM; while (iters--) { /* EXTRA_HEADER_ROOM bytes extra space for l2tp header */ n = read(ses->pty_fd, payload, sizeof(buf)-EXTRA_HEADER_ROOM); /* TODO: Check this.... */ if (n <= 2) break; if (!ses) continue; /* Chop off framing bytes */ #if 0 print_packet(2, payload, n, "l2tp_sync_ppp_handle_from_to_tunnel"); #endif if (payload[0] == 0xff && payload[1] == 0x03) { payload += 2; n -= 2; } l2tp_dgram_send_ppp_frame(ses, payload, n); } d_dbg("l2tp_sync_ppp_handle_from_to_tunnel <<<\n"); }
void send_packet(apacket *p, atransport *t) { unsigned char *x; unsigned sum; unsigned count; p->msg.magic = p->msg.command ^ 0xffffffff; count = p->msg.data_length; x = (unsigned char *) p->data; sum = 0; while(count-- > 0){ sum += *x++; } p->msg.data_check = sum; print_packet("send", p); if (t == NULL) { D("Transport is null \n"); // Zap errno because print_packet() and other stuff have errno effect. errno = 0; fatal_errno("Transport is null"); } if(write_packet(t->transport_socket, t->serial, &p)){ fatal_errno("cannot enqueue packet on transport socket"); } }
static uint8 cs8900a_output (struct device_desc *dev, uint8 * buf, uint16 packet_len) { struct net_device *net_dev = (struct net_device *) dev->dev; struct net_cs8900a_io *io = (struct net_cs8900a_io *) dev->data; int len; //printf("%s: packet_len:%d\n", __FUNCTION__, packet_len); #if 0 print_packet (buf, packet_len); #endif if ((len = net_dev->net_write (net_dev, buf, packet_len)) == -1) { fprintf (stderr, "write to tapif error in skyeye-ne2k.c\n"); return -1; } io->ctrl_st[CtrlStNum (PP_TxEvent)] |= 0x100; io->ctrl_st[CtrlStNum (PP_BusST)] |= Rdy4TxNOW; if (io->ctrl_st[CtrlStNum (PP_BusCTL)] & EnableRQ) { set_time (io->index, packet_len); io->need_update = 1; net_cs8900a_set_update_intr (dev); } return 0; }
/*---------------------------------------------------------------------------*/ static void plb_send(mac_callback_t sent, void *ptr) { PRINTF("plb_send\n"); if ( packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) == 0 ) //data { PRINTF("plb_send : DATA\n"); send_req = 1; sent_callback = sent; sent_ptr = ptr; //packetbuf_clear_hdr(); temp_len=packetbuf_datalen(); packetbuf_copyto(dataptr_temp); print_packet(dataptr_temp,packetbuf_totlen());//JJH3 } //kdw sync else if ( packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) == 1 ) //sync { sent_callback = sent; sent_ptr = ptr; plb_send_sync_start(); } else // error { mac_call_sent_callback(sent, ptr, MAC_TX_ERR, 1); //error fill this } return; }
void print_packets(std::list<std::shared_ptr<parse4880::PGPPacket>> packets, int level) { for (auto i = packets.begin(); i != packets.end(); i++) { print_packet(**i, level); } }
/* handle an incoming packet, acking it if it is a data packet for us * returns the message length > 0 if this was a valid data message from a peer. * if it gets a valid key, returns -1 (details below) * Otherwise returns 0 and does not fill in any of the following results. * * if it is a data or ack, it is saved in the xchat log * if it is a valid data message from a peer or a broadcaster, * fills in verified and broadcast * fills in contact, message (to point to malloc'd buffers, must be freed) * if not broadcast, fills in desc (also malloc'd), sent (if not null) * and duplicate. * if verified and not broadcast, fills in kset. * the data message (if any) is null-terminated * * if kcontact and ksecret1 are not NULL, assumes we are also looking * for key exchange messages sent to us matching either of ksecret1 or * (if not NULL) ksecret2. If such a key is found, returns -1. * there are two ways of calling this: * - if the user specified the peer's secret, first send initial key, * then call handle_packet with our secret in ksecret1 and our * peer's secret in ksecret2. * - otherwise, put our secret in ksecret1, make ksecret2 and kaddr NULL, * and handle_packet is ready to receive a key. * In either case, if a matching key is received, it is saved and a * response is sent (if a response is a duplicate, it does no harm). * kmax_hops specifies the maximum hop count of incoming acceptable keys, * and the hop count used in sending the key. * * if subscription is not null, listens for a reply containing a key * matching the subscription, returning -2 if a match is found. */ int handle_packet (int sock, char * packet, int psize, char ** contact, keyset * kset, char ** message, char ** desc, int * verified, time_t * sent, int * duplicate, int * broadcast, char * kcontact, char * ksecret1, char * ksecret2, int kmax_hops, char * subscription, unsigned char * addr, int nbits) { if (! is_valid_message (packet, psize)) return 0; struct allnet_header * hp = (struct allnet_header *) packet; int hsize = ALLNET_SIZE (hp->transport); if (psize < hsize) return 0; #ifdef DEBUG_PRINT if (hp->hops > 0) /* not my own packet */ print_packet (packet, psize, "xcommon received", 1); #endif /* DEBUG_PRINT */ if (hp->message_type == ALLNET_TYPE_ACK) { handle_ack (sock, packet, psize, hsize); return 0; } if (hp->message_type == ALLNET_TYPE_CLEAR) { /* a broadcast packet */ if ((subscription != NULL) && (addr != NULL)) { int sub = handle_sub (sock, hp, packet + hsize, psize - hsize, subscription, addr, nbits); #ifdef DEBUG_PRINT printf ("handle_sub (%d, %p, %p, %d, %s, %p, %d) ==> %d\n", sock, hp, packet + hsize, psize - hsize, subscription, addr, nbits, sub); #endif /* DEBUG_PRINT */ if (sub > 0) /* received a key in response to our subscription */ return sub; } #ifdef DEBUG_PRINT else printf ("subscription %p, addr %p, did not call handle_sub\n", subscription, addr); #endif /* DEBUG_PRINT */ return handle_clear (hp, packet + hsize, psize - hsize, contact, message, verified, broadcast); } if (hp->message_type == ALLNET_TYPE_DATA) /* an encrypted data packet */ return handle_data (sock, hp, packet + hsize, psize - hsize, contact, kset, message, desc, verified, sent, duplicate, broadcast); if (hp->message_type == ALLNET_TYPE_KEY_XCHG) return handle_key (sock, hp, packet + hsize, psize - hsize, kcontact, ksecret1, ksecret2, kmax_hops); return 0; }
void main(void) { volatile packet_t *p; volatile uint8_t t=20; uint8_t chan; char c; gpio_data(0); gpio_pad_dir_set( 1ULL << LED ); /* read from the data register instead of the pad */ /* this is needed because the led clamps the voltage low */ gpio_data_sel( 1ULL << LED); /* trim the reference osc. to 24MHz */ trim_xtal(); uart_init(UART1, 115200); vreg_init(); maca_init(); /* sets up tx_on, should be a board specific item */ *GPIO_FUNC_SEL2 = (0x01 << ((44-16*2)*2)); gpio_pad_dir_set( 1ULL << 44 ); set_power(0x0f); /* 0dbm */ chan = 0; set_channel(chan); /* channel 11 */ *MACA_MACPANID = 0xaaaa; *MACA_MAC16ADDR = 0x1111; *MACA_TXACKDELAY = 68; /* 68 puts the tx ack at about the correct spot */ set_prm_mode(AUTOACK); print_welcome("rftest-rx"); while(1) { /* call check_maca() periodically --- this works around */ /* a few lockup conditions */ check_maca(); if((p = rx_packet())) { /* print and free the packet */ printf("autoack-rx --- "); print_packet(p); maca_free_packet(p); } if(uart1_can_get()) { c = uart1_getc(); if(c == 'z') t++; if(c == 'x') t--; *MACA_TXACKDELAY = t; printf("tx ack delay: %d\n\r", t); } } }
static bool server_send_packet(Client *c, Packet *pkt) { print_packet("server-send:", pkt); if (send_packet(c->socket, pkt)) return true; debug("FAILED\n"); c->state = STATE_DISCONNECTED; return false; }
void read_from_file (FILE *fp) { uint8_t cmdbuf[MAXCMD]; uint8_t sz = 0; uint8_t response[MAXCMD]; char line[MAXLINECMD]; char *p; while (fgets (line, MAXLINECMD, fp)) { p = line; sz = 0; while (*p && sz < MAXCMD) { if (*p == ' ') { p++; continue; } if (*p == '\n' || *p == '\r') { break; } if (isxdigit(*p) && isxdigit(p[1])) { sscanf(p, "%02x", (unsigned int *)&cmdbuf[sz]); sz++; p += 2; } else { break; } } if (sz > 0) { if (optsendpackets && cmdbuf[0] == 0x09) { print_packet(cmdbuf, sz); send_raw_packet(watch, sz, cmdbuf, response); print_packet(response, response[1] + 2); } else { // we're not going to send anything to the watch, just print it print_packet(cmdbuf, sz); } } } }
static bool server_write_pty(Packet *pkt) { print_packet("server-write-pty:", pkt); size_t size = pkt->len; if (write_all(server.pty, pkt->u.msg, size) == size) return true; debug("FAILED\n"); server.running = false; return false; }
static bool server_recv_packet(Client *c, Packet *pkt) { if (recv_packet(c->socket, pkt)) { print_packet("server-recv:", pkt); return true; } debug("server-recv: FAILED\n"); c->state = STATE_DISCONNECTED; return false; }
/** Remove extended attributes */ int do_removexattr (const char * path, const char *name){ char buffer[BUFFERSIZE]; memset(buffer, 0, BUFFERSIZE); corefs_packet* packet = (corefs_packet*)buffer; int ret; unsigned int packet_size; server_data *sd=NULL; char r_path_[MAXPATH]; char s_addr[MAXADDR]; char *r_path = &r_path_[0]; remove_addr(path, &r_path, s_addr); if (r_path[0]=='\0') { //there was no path other than the first '/' //ie this is for the root directory return do_removexattr_local(path, name); } ret = check_setup(s_addr, &sd); if (ret == -EHOSTUNREACH) return -EHOSTUNREACH; if (ret < 0) return -EIO; #ifdef DEBUG dprintf(stderr, "REMOVEXATTR: path[%s] name[%s]\n", path, name); #endif /* Get user info from the upper layer */ if(my_ops.up_get_user_info) my_ops.up_get_user_info(&(packet->payload.request.user_ids), path, NULL); /* Build the request packet */ packet_size = build_xattr(packet, COREFS_XATTR_REMOVEXATTR, name, r_path, 0, 0); /* encapsulate in network order */ char request_buf[packet_size]; memset(request_buf, 0, packet_size); ret = encap_corefs_header(request_buf, packet); encap_corefs_request(request_buf + ret, packet); #ifdef DEBUG_NETWORK fprintf(stderr, "printing removexattr request\n"); print_packet(*packet); #endif if (send_packet(sd->ctx, request_buf, packet_size) <=0) { dprintf(stderr, "error sending packet.\n"); return -EIO; } memset(buffer, 0, BUFFERSIZE); if ((ret = client_receive_specified(sd->ctx, buffer, COREFS_RESPONSE_STATUS)) < 0) { dprintf(stderr, "GETXATTR: error receiving removexattr status.\n"); return ret; } return 0; }
/* Receive a Topfield protocol packet. * Returns a negative number if the packet read failed for some reason. */ ssize_t get_tf_packet(int fd, struct tf_packet * packet) { __u8 *buf = (__u8 *) packet; int r; trace(3, fprintf(stderr, "get_tf_packet\n")); r = usb_bulk_read(fd, 0x82, buf, MAXIMUM_PACKET_SIZE, TF_PROTOCOL_TIMEOUT); if(r < 0) { fprintf(stderr, "USB read error: %s\n", strerror(errno)); return -1; } if(r < PACKET_HEAD_SIZE) { fprintf(stderr, "Short read. %d bytes\n", r); return -1; } /* Send SUCCESS as soon as we see a data transfer packet */ if(DATA_HDD_FILE_DATA == get_u32_raw(&packet->cmd)) { send_success(fd); } swap_in_packet(packet); { __u16 crc; __u16 calc_crc; __u16 len = get_u16(&packet->length); if(len < PACKET_HEAD_SIZE) { fprintf(stderr, "Invalid packet length %04x\n", len); return -1; } crc = get_u16(&packet->crc); calc_crc = get_crc(packet); /* Complain about CRC mismatch */ if(crc != calc_crc) { fprintf(stderr, "WARNING: Packet CRC %04x, expected %04x\n", crc, calc_crc); } } print_packet(packet, " IN<"); return r; }
int client_receive_specified(COMMCTX* ctx, char* buffer, unsigned int type) { int ret; corefs_packet * packet =(corefs_packet*)buffer; char resp_buf[BUFFERSIZE]; memset(resp_buf, 0, BUFFERSIZE); ret=receive_packet(ctx, resp_buf); if (ret < header_size) { dprintf(stderr, "error receiving packet.\n"); return -EIO; } /* Copy the header */ corefs_packet * reply =(corefs_packet*)resp_buf; packet->header.magic = reply->header.magic; packet->header.type = reply->header.type; packet->header.sequence = reply->header.sequence; packet->header.payload_size = reply->header.payload_size; /* decap the received message */ if(packet->header.type == COREFS_RESPONSE) decap_corefs_response(resp_buf + header_size, packet); else{ dprintf(stderr, "client_receive_specified: Received wrong packet type [%u], packet sequence[%u]\n", packet->header.type, packet->header.sequence); return -EPROTO; } #ifdef DEBUG_NETWORK dprintf(stderr, "client_receive_specified: printing response\n"); print_packet(*packet); #endif if(packet->payload.response.type == COREFS_RESPONSE_ERROR){ return -packet->payload.response.rop.status.bits; } else if((packet->payload.response.type != type) && !((type == COREFS_RESPONSE_DATA) && (packet->payload.request.type == COREFS_RESPONSE_MOREDATA))) { dprintf(stderr, "client_receive_specified: Error - expecting packet type %i, received %i.\n", type, packet->payload.response.type); return -EPROTO; } else if (packet->payload.response.type == COREFS_RESPONSE_STATUS){ ret = packet->payload.response.rop.status.bits; } else { ret= packet->header.payload_size; } return ret; }
static bool server_read_pty(Packet *pkt) { pkt->type = MSG_CONTENT; ssize_t len = read(server.pty, pkt->u.msg, sizeof(pkt->u.msg)); if (len > 0) pkt->len = len; else if (len == 0) server.running = false; else if (len == -1 && errno != EAGAIN && errno != EINTR && errno != EWOULDBLOCK) server.running = false; print_packet("server-read-pty:", pkt); return len > 0; }
/* Given a Topfield protocol packet, this function will calculate the required * CRC and send the packet out over a bulk pipe. */ ssize_t send_tf_packet(int fd, struct tf_packet *packet) { unsigned int pl = get_u16(&packet->length); ssize_t byte_count = (pl + 1) & ~1; trace(3, fprintf(stderr, "%s\n", __func__)); put_u16(&packet->crc, get_crc(packet)); print_packet(packet, "OUT>"); swap_out_packet(packet); return usb_bulk_write(fd, 0x01, (__u8 *) packet, byte_count, TF_PROTOCOL_TIMEOUT); }
int main(int argc, char **argv) { int c; char *input_file, *output_file = NULL; program_name = argv[0]; input_file= dev_file; while((c = getopt(argc, argv, "i:o:")) != -1) { switch (c) { case 'i': strcpy(buf_i, optarg); input_file = buf_i; break; case 'o': strcpy(buf_o, optarg); output_file = buf_o; break; default: usage(); } } int fdin, err; FILE * fout; fdin = open(input_file, O_RDONLY); if(output_file == NULL){ fout = stdout; } else{ fout = fopen(output_file, "w+"); } while(1){ int len; len = read(fdin, buffer, 2000); if(len > 0){ print_packet(fout, buffer, len); } else{ break; } } close(fdin); fclose(fout); return 0; }
int main(int argc, const char *argv[]) { int len, size, tcphdrlen; u8 *pdata, *http; u8 dstmac[ETH_ALEN] = {0}; char recvbuf[BUFSIZE]; struct sockaddr_ll sa; struct ethhdr *ethhdr; struct iphdr *iphdr; struct tcphdr *tcphdr; char *ifname = "wfm"; SOCK: if ((sock_fd = open_socket(ifname)) < 0) { perror("open_socket"); exit(EXIT_FAILURE); } if ((ifindex = interface_index(ifname)) < 0) { perror("interface_index"); exit(EXIT_FAILURE); } if (interface_addr(ifname, dstmac) < 0) { perror("interface_addr"); exit(EXIT_FAILURE); } memset(&sa, 0, sizeof(sa)); sa.sll_family = AF_PACKET; sa.sll_protocol = htons(ETH_P_ALL); sa.sll_ifindex = ifindex; if (bind(sock_fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) exit(EXIT_FAILURE); for ( ; ; ) { len = recvfrom(sock_fd, recvbuf, BUFSIZE, 0, NULL, NULL); if (len < 0) { close(sock_fd); sleep(3); goto SOCK; } /* process packet ... */ print_packet(recvbuf, len); /* process packet ... */ } return 0; }
/*---------------------------------------------------------------------------*/ static char plb_send_strobe(rimeaddr_t *dst, int *acked, uint8_t type) { PRINTF("plb_send_strobe [dst: %u.%u] [type: %x]\n",dst->u8[0],dst->u8[1],type); uint8_t strobe[MAX_STROBE_SIZE]; int strobe_len = 0; rtimer_clock_t wt; // Make PLB header packetbuf_clear(); if( (strobe_len = plb_create_header(dst,type)) < 0 ){ return -1; } // Make packet -> strobe strobe_len = strobe_len +1; // assign space for packet type if( strobe_len > (int)sizeof(strobe)) { /* Failed to send */ PRINTF("plb: send failed, too large header\n"); return -1; } memcpy(strobe, packetbuf_hdrptr(), strobe_len); /* Send beacon and wait ack : STROBE_NUM_MAX times */ int strobe_num = 0; radio_on(); while((strobe_num < STROBE_NUM_MAX) && ((*acked) == 0)){ PRINTF("plb_send_strobe : strobe %d\n",strobe_num); #if DEBUG_PACKET print_packet(strobe, strobe_len); #endif if(NETSTACK_RADIO.send(strobe, strobe_len) != RADIO_TX_OK){ return -1; } strobe_num ++; (*acked) = plb_wait_ack(type); if(*acked){ PRINTF("ack! return: %d\n", *acked); } } radio_off(); return 0; }