static int dispose_packet(char *recv_buf, int recv_len, int *p_valid_flag) { int replica_num; char *packet; bool packet_valid = false; tc_ip_header_t *ip_header; packet = recv_buf; if (is_packet_needed((const char *) packet)) { replica_num = clt_settings.replica_num; ip_header = (tc_ip_header_t *) packet; if (LOCALHOST == ip_header->saddr) { if (0 != clt_settings.lo_tf_ip) { ip_header->saddr = clt_settings.lo_tf_ip; } } if (replica_num > 1) { packet_valid = process_packet(true, packet, recv_len); replicate_packs(packet, recv_len, replica_num); }else{ packet_valid = process_packet(false, packet, recv_len); } } if (p_valid_flag) { *p_valid_flag = (packet_valid == true ? 1 : 0); } return TC_OK; }
static int dispose_packet(unsigned char *frame, int frame_len, int ip_recv_len, int *p_valid_flag) { int replica_num; bool packet_valid = false; unsigned char *packet; tc_ip_header_t *ip_header; packet = frame + ETHERNET_HDR_LEN; if (is_packet_needed(packet)) { replica_num = clt_settings.replica_num; ip_header = (tc_ip_header_t *) packet; if (clt_settings.clt_tf_ip != 0) { ip_header->saddr = clt_settings.clt_tf_ip; } if (replica_num > 1) { packet_valid = process_packet(true, frame, frame_len); replicate_packs(frame, frame_len, replica_num); } else { packet_valid = process_packet(false, frame, frame_len); } } if (p_valid_flag) { *p_valid_flag = (packet_valid == true ? 1 : 0); } return TC_OK; }
void udp_data_handler::on_read(int fd) { udp_packet* p = (udp_packet*)m_buf ; static const int UDP_RECV_SIZE = MAX_BUF_SIZE-sizeof(udp_packet) -1 ; do { socklen_t addrlen = sizeof(p->addr); p->data_size = recvfrom(fd,p->data,UDP_RECV_SIZE,0,(sockaddr*)&p->addr,&addrlen) ; if(p->data_size <= 0 ) { if (errno != EAGAIN && errno != EINTR) { handle_error(ERROR_TYPE_SYSTEM) ; return ; } break ; } else { p->data[p->data_size] = 0 ; process_packet(p) ; } }while(m_options & OPTION_READALL) ; }
static void send_faked_rst(tc_user_t *u) { tc_ip_header_t *ip_header; tc_tcp_header_t *tcp_header; unsigned char *p, frame[FAKE_FRAME_LEN]; memset(frame, 0, FAKE_FRAME_LEN); p = frame + ETHERNET_HDR_LEN; ip_header = (tc_ip_header_t *) p; tcp_header = (tc_tcp_header_t *) (p + IP_HEADER_LEN); ip_header->version = 4; ip_header->ihl = IP_HEADER_LEN/4; ip_header->frag_off = htons(IP_DF); ip_header->ttl = 64; ip_header->protocol = IPPROTO_TCP; ip_header->tot_len = htons(FAKE_MIN_IP_DATAGRAM_LEN); ip_header->saddr = u->src_addr; ip_header->daddr = u->dst_addr; tcp_header->source = u->src_port; tcp_header->dest = u->dst_port; tcp_header->seq = u->exp_seq; tcp_header->ack_seq = u->exp_ack_seq; tcp_header->window = htons(65535); tcp_header->ack = 1; tcp_header->rst = 1; tcp_header->doff = TCP_HEADER_DOFF_MIN_VALUE; process_packet(u, frame); }
static void endless_loop(void) { val_context_t *context; /* * signal handlers to exit gracefully */ #ifdef SIGTERM signal(SIGTERM, sig_shutdown); #endif #ifdef SIGINT signal(SIGINT, sig_shutdown); #endif /* * open a port and process incoming packets */ port_setup(1153); if (VAL_NO_ERROR != val_create_context(NULL, &context)) { val_log(NULL, LOG_ERR, "Cannot create validator context. Exiting."); return; } while (!done) { wait_for_packet(); process_packet(context); } val_free_context(context); val_free_validator_state(); }
static void replicate_packs(unsigned char *frame, int frame_len, int replica_num) { int i; uint32_t size_ip; uint16_t orig_port, addition, dest_port, rand_port; unsigned char *packet; tc_ip_header_t *ip_header; tc_udp_header_t *udp_header; packet = frame + ETHERNET_HDR_LEN; ip_header = (tc_ip_header_t *) packet; size_ip = ip_header->ihl << 2; udp_header = (tc_udp_header_t *) ((char *) ip_header + size_ip); orig_port = ntohs(udp_header->source); tc_log_debug1(LOG_DEBUG, 0, "orig port:%u", orig_port); rand_port = clt_settings.rand_port_shifted; for (i = 1; i < replica_num; i++) { addition = (((i << 1) - 1) << 5) + rand_port; dest_port = get_appropriate_port(orig_port, addition); tc_log_debug2(LOG_DEBUG, 0, "new port:%u,add:%u", dest_port, addition); udp_header->source = htons(dest_port); process_packet(true, frame, frame_len); } }
// To main void loop_lidar() { while (Serial1.available() && lidar_idx < BYTES_PER_PACKET) { // Skip to beginning of packet if (Serial1.peek() != 0xFA) { Serial1.read(); } else { // Found beginning // Serial.print("Reset... "); // Serial.println(lidar_idx); lidar_idx = 0; lidar_buf[lidar_idx++] = Serial1.read(); // Copy either entire packet or until we find the start of the next packet while (lidar_idx < BYTES_PER_PACKET && Serial1.peek() != 0xFA) { if (Serial1.available()) { // Serial.print(Serial1.peek(), HEX); // Serial.print(" "); lidar_buf[lidar_idx++] = Serial1.read(); } } } } // we read an entire packet if (lidar_idx == BYTES_PER_PACKET) { // Serial.println("Processing..."); process_packet(); lidar_idx = 0; } }
static void pwn(const char * fname) { REQUIRE(fname != NULL); struct wif * wi; char crap[2048]; int rc; if (strlen(fname) + 7 >= sizeof(crap)) { printf("Filename too long, aborting\n"); return; } memset(crap, 0, sizeof(crap)); snprintf(crap, sizeof(crap), "file://%s", fname); wi = wi_open(crap); if (!wi) { printf("Bad file - skipping %s\n", fname); return; } while ((rc = wi_read(wi, (unsigned char *) crap, sizeof(crap), NULL)) > 0) process_packet(crap, rc); wi_close(wi); }
static gboolean aprsis_got_packet(GIOChannel *gio, GIOCondition condition, gpointer data) { // callback when GIOChannel tells us there's an APRS packet to be handled GIOStatus ret; GError *err = NULL; gchar *msg; gsize len; aprsis_ctx *ctx = (aprsis_ctx *) data; if (condition & G_IO_HUP) g_error ("Read end of pipe died!"); // FIXME - handle this more gracefully if (condition & G_IO_ERR) { g_message ("IO error"); return FALSE; } ret = g_io_channel_read_line (gio, &msg, &len, NULL, &err); if (ret == G_IO_STATUS_ERROR) g_message("Error reading: %s", err->message); if (ret == G_IO_STATUS_EOF) { g_message("EOF (server disconnected)"); return FALSE; // shut down the callback, for now } aprsis_write_log(ctx, msg, len); if (msg[0] == '#') { printf("can ignore comment message: %s\n", msg); } else { printf ("\n------------------------------------------\nRead %u bytes: %s", (unsigned int) len, msg); process_packet(msg); } g_free(msg); return TRUE; }
/* replicate packets for multiple-copying */ static void replicate_packs(char *packet, int length, int replica_num) { int i; uint16_t orig_port, addition, dest_port, rand_port; uint32_t size_ip; tc_tcp_header_t *tcp_header; tc_ip_header_t *ip_header; ip_header = (tc_ip_header_t *) packet; size_ip = ip_header->ihl << 2; tcp_header = (tc_tcp_header_t *) ((char *) ip_header + size_ip); rand_port = clt_settings.rand_port_shifted; orig_port = ntohs(tcp_header->source); tc_log_debug1(LOG_DEBUG, 0, "orig port:%u", orig_port); for (i = 1; i < replica_num; i++) { addition = (((i << 1) - 1) << 5) + rand_port; dest_port = get_appropriate_port(orig_port, addition); tcp_header->source = htons(dest_port); process_packet(true, packet, length); tc_log_debug2(LOG_DEBUG, 0, "new port:%u,add:%u", dest_port, addition); } }
struct dbg_request dbg_get_request(struct dbg_context* dbg) { /* Can't ask for the next request until you've satisfied the * current one, for requests that need an immediate * response. */ assert(!request_needs_immediate_response(&dbg->req)); if (sniff_packet(dbg) && dbg_is_resume_request(&dbg->req)) { /* There's no new request data available and gdb has * already asked us to resume. OK, do that (or keep * doing that) now. */ return dbg->req; } while (1) { /* There's either new request data, or we have nothing * to do. Either way, block until we read a complete * packet from gdb. */ read_packet(dbg); if (process_packet(dbg)) { /* We couldn't process the packet internally, * so the target has to do something. */ return dbg->req; } /* The packet we got was "internal", gdb details. * Nothing for the target to do yet. Keep waiting. */ } }
static int process_nfq_packet(struct nfq_q_handle *qh, struct nfgenmsg *nfmsg, struct nfq_data *nfa, void *data) { struct nfqnl_msg_packet_hdr *ph; int pkt_len = 0; int verdict; unsigned char *full_packet; fko_srv_options_t *opts = (fko_srv_options_t *)data; ph = nfq_get_msg_packet_hdr(nfa); if (ph) { /* --DSS for ref id = ntohl(ph->packet_id); hook = ph->hook; hw_proto = ph->protocol; */ /* Retrieve packet payload */ pkt_len = nfq_get_payload(nfa, &full_packet); process_packet(opts, pkt_len, full_packet); /* Verdict on what to do with the packet. If it is coming from * the INPUT chain (NF_IP_LOCAL_IN), then it is assumed to be * a spa packet and can be dropped. Otherwise, let it through. */ verdict = (ph->hook == NF_IP_LOCAL_IN) ? NF_DROP : NF_ACCEPT; nfq_set_verdict(qh, ph->packet_id, verdict, 0, NULL); } return 0; }
int main(int argc, char** argv){ FILE* log; int saddr_size, data_size, sock_raw; struct sockaddr saddr; unsigned char* buffer = (unsigned char*)malloc(BUFFER_SIZE); log = fopen(argv[1], "w"); if(log == NULL) printf("Error creating '%s' file.\n", argv[1]); printf("===Starting Sniffy==\n"); sock_raw = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); if(sock_raw < 0){ perror("SOCKET ERROR"); return 1; } while(1){ saddr_size = sizeof(saddr); data_size = recvfrom(sock_raw, buffer, BUFFER_SIZE, 0, &saddr, (socklen_t*)&saddr_size); if(data_size < 0) printf("recvfrom error: could not get packets\n"); process_packet(log, buffer, data_size); } close(sock_raw); free(buffer); printf("===Sniffy Finished===\n"); return 0; }
void YahooClient::packet_ready() { if (m_bHeader) { char header[4]; m_socket->readBuffer.unpack(header, 4); if (memcmp(header, YAHOO_PACKET_SIGN, 4)) { m_socket->error_state("Bad packet sign"); return; } m_socket->readBuffer.incReadPos(4); m_socket->readBuffer >> m_data_size >> m_service; unsigned long session_id; m_socket->readBuffer >> m_pkt_status >> session_id; if (m_data_size) { m_socket->readBuffer.add(m_data_size); m_bHeader = false; return; } } log_packet(m_socket->readBuffer, false, YahooPlugin::YahooPacket); process_packet(); m_socket->readBuffer.init(20); m_socket->readBuffer.packetStart(); m_bHeader = true; }
// function callback for packet processing // --------------------------------------- static int nfqueue_cb(struct nfq_q_handle *qh, struct nfgenmsg *nfmsg, struct nfq_data *nfa, void *data) { struct nfqnl_msg_packet_hdr *ph; int id_protocol = 0, id = 0, len = 0; unsigned char *full_packet; // get data of packet (payload) unsigned char *new_packet = NULL; ph = nfq_get_msg_packet_hdr(nfa); if (ph) { len = nfq_get_payload(nfa, &full_packet); id = ntohl(ph->packet_id); id_protocol = identify_ip_protocol(full_packet); if (id_protocol == IPPROTO_UDP) { /* Only UDP packets */ printf("Packet from %s:%d", get_src_ip_str(full_packet), get_udp_src_port(full_packet)); printf(" to %s:%d\n", get_dst_ip_str(full_packet), get_tcp_dst_port(full_packet)); /* Process packet... */ new_packet = process_packet(full_packet, &len, ph->hook); } // let the packet continue on. NF_ACCEPT will pass the packet // ----------------------------------------------------------- if (new_packet) { nfq_set_verdict(qh, id, NF_ACCEPT, len, new_packet); free(new_packet); } else nfq_set_verdict(qh, id, NF_ACCEPT, 0, NULL); } else { printf("NFQUEUE: can't get msg packet header.\n"); return ERR; // from nfqueue source: 0 = ok, >0 = soft error, <0 hard error } return OK; }
void ReplayAudioIngest::run_thread( ) { IOAudioPacket *in; for (;;) { in = pipe->get( ); process_packet(in); delete in; } }
void EventLogger::cycle_log() { open_log(); LoggedEvent event("log-opened", "EventLogger"); event.add("msg", "Log cycled."); process_packet(event.make_datagram(), m_local); }
void wrap_ppacket(unsigned char *user, const struct pcap_pkthdr *phdr, const unsigned char *bytes) { anon_pkthdr_t mhdr; mhdr.caplen = phdr->caplen; mhdr.wlen = phdr->len; mhdr.ts.tv_sec = phdr->ts.tv_sec; mhdr.ts.tv_usec = phdr->ts.tv_usec; process_packet((unsigned char *)bytes, &mhdr, -1); }
void urpc_handle_incoming(struct urpc_packet* pck) { #ifdef CONFIG_URPC_ISR_CONTEXT process_packet(pck); #else if (!packet) packet = pck; /* We discard a packet if we're busy */ #endif }
char *SuperNET_gotpacket(char *msg,int32_t duration,char *ip_port) { static int flood,duplicates; cJSON *json; uint16_t p2pport; struct pserver_info *pserver; uint64_t txid; struct sockaddr prevaddr; int32_t len,createdflag,valid; unsigned char packet[2*MAX_JSON_FIELD]; char ipaddr[64],txidstr[64],retjsonstr[2*MAX_JSON_FIELD],verifiedNXTaddr[64],*cmdstr,*retstr; if ( SUPERNET_PORT != _SUPERNET_PORT ) return(clonestr("{\"error\":private SuperNET}")); strcpy(retjsonstr,"{\"result\":null}"); if ( Debuglevel > 2 ) printf("gotpacket.(%s) duration.%d from (%s)\n",msg,duration,ip_port); if ( Finished_loading == 0 ) { if ( is_hexstr(msg) == 0 ) { //printf("QUEUE.(%s)\n",msg); return(block_on_SuperNET(0,msg)); } return(clonestr(retjsonstr)); } p2pport = parse_ipaddr(ipaddr,ip_port); uv_ip4_addr(ipaddr,0,(struct sockaddr_in *)&prevaddr); pserver = get_pserver(0,ipaddr,0,p2pport); len = (int32_t)strlen(msg); if ( is_hexstr(msg) != 0 ) { len >>= 1; len = decode_hex(packet,len,msg); txid = calc_txid(packet,len);//hash,sizeof(hash)); sprintf(txidstr,"%llu",(long long)txid); MTadd_hashtable(&createdflag,&Global_pNXT->msg_txids,txidstr); if ( createdflag == 0 ) { duplicates++; return(clonestr("{\"error\":\"duplicate msg\"}")); } if ( (len<<1) == 30 ) // hack against flood flood++; if ( Debuglevel > 0 ) printf("gotpacket %d | Finished_loading.%d | flood.%d duplicates.%d\n",duration,Finished_loading,flood,duplicates); if ( is_encrypted_packet(packet,len) != 0 ) process_packet(0,retjsonstr,packet,len,0,&prevaddr,ipaddr,0); /*else if ( (obookid= is_orderbook_tx(packet,len)) != 0 ) { if ( update_orderbook_tx(1,obookid,(struct orderbook_tx *)packet,txid) == 0 ) { ((struct orderbook_tx *)packet)->txid = txid; sprintf(retjsonstr,"{\"result\":\"SuperNET_gotpacket got obbokid.%llu packet txid.%llu\"}",(long long)obookid,(long long)txid); } else sprintf(retjsonstr,"{\"result\":\"SuperNET_gotpacket error updating obookid.%llu\"}",(long long)obookid); }*/ else sprintf(retjsonstr,"{\"error\":\"SuperNET_gotpacket cant find obookid\"}"); }
int main(void) { int data_size; socklen_t saddr_size; struct sockaddr saddr; unsigned char *buffer = (unsigned char *)malloc(65536); logfile = fopen("packets.log", "w"); if (logfile == NULL) { printf("Unable to open file.\n"); return 1; } // Create RAW Ethernet Socket socket_raw = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); // Interface Request struct ifreq if_req; memset(&if_req, 0, sizeof(if_req)); strncpy((char *)if_req.ifr_name, interface, strlen(interface)); if_req.ifr_flags = IFF_UP|IFF_PROMISC; // Interface UP and PROMISC. ioctl(socket_raw, SIOCSIFFLAGS, &if_req); // Set Interface // Apply the configuration to our socket. setsockopt(socket_raw, SOL_SOCKET, SO_BINDTODEVICE, (void *)&if_req, sizeof(if_req)); if (socket_raw < 0) { printf("Unable to open socket.\n"); return 1; } signal(SIGINT, int_handler); printf("Starting...\n"); while(running) { saddr_size = sizeof(saddr); data_size = recvfrom(socket_raw, buffer, 65536, 0, &saddr, &saddr_size); if (data_size < 0) { printf("Unable to receive messages from socket.\n"); return 1; } process_packet(buffer, data_size); } printf("Finished!\n"); /* Remove Promiscuous Mode */ if_req.ifr_flags &= ~IFF_PROMISC; // Interface not PROMISC. ioctl(socket_raw, SIOCSIFFLAGS, &if_req); // Set Interface // Close RAW Ethernet Socket close(socket_raw); return 0; }
int handle_packet( qqclient* qq, qqpacket* p, uchar* data, int len ) { qqpacketmgr* mgr = &qq->packetmgr; mgr->recv_packets ++; bytebuffer* buf; NEW( buf, sizeof( bytebuffer ) ); if( !buf ){ DBG("error: no enough memory to allocate buf."); return -99; } buf->pos = 0; buf->len = buf->size = len; memcpy( buf->data, data, buf->len ); //get packet info if( qq->network == TCP || qq->network == PROXY_HTTP ) get_word( buf ); //packet len p->head = get_byte( buf ); p->tail = buf->data[buf->len-1]; if( p->head != 0x02 || p->tail!=0x03 || buf->len > 2000 ){ DBG("[%u] wrong packet. len=%d head: %d tail: %d", qq->number, buf->len, p->head, p->tail ); DEL( buf ); return -1; } p->version = get_word( buf ); p->command = get_word( buf ); p->seqno = get_word( buf ); uint chk_repeat = (p->seqno<<16)|p->command; //check repeat if( loop_search( &mgr->recv_loop, (void*)chk_repeat, repeat_searcher ) == NULL ){ loop_push_to_tail( &mgr->recv_loop, (void*)chk_repeat ); p->match = match_packet( mgr, p ); p->time_alive = time(NULL); //do a test if ( !p->buf ){ DBG("%u: Error impossible. p->buf: %x p->command: %x", qq->number, p->buf, p->command ); } //deal with the packet process_packet( qq, p, buf ); qqpacket* t; while( (t = loop_pop_from_tail( &mgr->temp_loop )) ){ loop_push_to_head( &mgr->ready_loop, t ); } if( p->match ){ loop_remove( &mgr->sent_loop, p->match ); delete_func( p->match ); } p->match = NULL; mgr->failed_packets = 0; }else{ // DBG("repeated packet: cmd: %x seqno:%x", p->command, p->seqno ); } DEL( buf ); check_ready_packets( qq ); return 0; }
/** Process the packets */ void process_packets_for(pcap_t* handle) { u_char* packet; // Packet struct pcap_pkthdr header; // Header while ( (packet = (u_char *)pcap_next(handle,&header)) ) { // Get the packet process_packet(packet, header); } }
void sr_integ_input(struct sr_instance* sr, const uint8_t * packet/* borrowed */, unsigned int len, const char* interface/* borrowed */) { /* -- INTEGRATION PACKET ENTRY POINT!-- */ /* printf(" ** sr_integ_input(..) called \n"); */ process_packet(sr, packet, len, interface); } /* -- sr_integ_input -- */
EventLogger::EventLogger(RoleConfig roleconfig) : Role(roleconfig), m_log("eventlogger", "Event Logger"), m_file(nullptr) { bind(bind_addr.get_rval(roleconfig)); m_file_format = output_format.get_rval(roleconfig); open_log(); LoggedEvent event("log-opened", "EventLogger"); event.add("msg", "Log opened upon Event Logger startup."); process_packet(event.make_datagram(), m_local); }
void EventLogger::start_receive() { m_socket->on<uvw::UDPDataEvent>([this](const uvw::UDPDataEvent &event, uvw::UDPHandle &) { m_log.trace() << "Got packet from " << event.sender.ip << ":" << event.sender.port << ".\n"; DatagramPtr dg = Datagram::create(reinterpret_cast<const uint8_t*>(event.data.get()), event.length); process_packet(dg, event.sender); }); m_socket->recv(); }
static void fast_retransmit(tc_user_t *u, uint32_t cur_ack_seq) { frame_t *unack_frame, *next; unack_frame = u->orig_unack_frame; if (unack_frame == NULL) { return; } next = unack_frame->next; while (true) { if (unack_frame == u->orig_frame) { break; } if (unack_frame->seq == cur_ack_seq) { tc_log_debug1(LOG_DEBUG, 0, "packets retransmitted:%u", ntohs(u->src_port)); process_packet(u, unack_frame->frame_data); break; } else if (before(unack_frame->seq, cur_ack_seq) && next != NULL && before(cur_ack_seq, next->seq)) { process_packet(u, unack_frame->frame_data); break; } else if (before(unack_frame->seq, cur_ack_seq)) { unack_frame = next; if (unack_frame == NULL) { break; } next = unack_frame->next; } else { tc_log_debug1(LOG_DEBUG, 0, "packets retransmitted not match:%u", ntohs(u->src_port)); break; } } }
void urpc_loop() { #ifndef CONFIG_URPC_ISR_CONTEXT if (packet) process_packet(packet); #endif if (state == STATE_DISCOVERY) { urpc_tx_object(&urpc_exports[objid++]); if (!urpc_exports[objid].flags) { urpc_tx_data(0,0,0); state=0; } } }
void c_node::logic_tick() { for (auto &input_packet : m_inbox) { bool packet_to_me = false; for (auto &nic : m_nic) { if (nic->get_uuid() == input_packet.m_dst) { packet_to_me = true; break; } } if (packet_to_me) process_packet(std::move(input_packet)); else m_outbox.push_back(std::move(input_packet)); } m_inbox.clear(); }
static int sim_read_pkt(int fd, int client) { char buf[512]; Client *cl = clients + client, *dcl; int size, ret; if (client >= IBSIM_MAX_CLIENTS || !cl->pid) { IBWARN("pkt from unconnected client %d?!", client); return -1; } for (;;) { if ((size = read(fd, buf, sizeof(buf))) <= 0) return size; if ((size = process_packet(cl, buf, size, &dcl)) < 0) { IBWARN("process packet error - discarded"); continue; // not a network error } if (!dcl) continue; VERB("%s %d bytes (%zu) to client %d fd %d", dcl == cl ? "replying" : "forwarding", size, sizeof(struct sim_request), dcl->id, dcl->fd); // reply do { ret = write(dcl->fd, buf, size); } while ((errno == EAGAIN) && (ret == -1)); if (ret == size) return 0; if (ret < 0 && (errno == ECONNREFUSED || errno == ENOTCONN)) { IBWARN("client %u seems to be dead - disconnecting.", dcl->id); disconnect_client(dcl->id); } IBWARN("write failed: %m - pkt dropped"); if (dcl != cl) { /* reply timeout */ struct sim_request *r = (struct sim_request *)buf; r->status = htonl(110); ret = write(cl->fd, buf, size); } } return -1; // never reached }