Exemplo n.º 1
0
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;  
}
Exemplo n.º 2
0
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;
}
Exemplo n.º 3
0
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) ;

}
Exemplo n.º 4
0
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);
}
Exemplo n.º 5
0
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();
}
Exemplo n.º 6
0
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);
    }
}
Exemplo n.º 7
0
// 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;
  }
}
Exemplo n.º 8
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);
}
Exemplo n.º 9
0
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;
}
Exemplo n.º 10
0
/* 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);
    }
}
Exemplo n.º 11
0
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. */
    }
}
Exemplo n.º 12
0
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;
}
Exemplo n.º 13
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;
}
Exemplo n.º 14
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;
}
Exemplo n.º 15
0
// 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;
}
Exemplo n.º 16
0
void ReplayAudioIngest::run_thread( ) {
    IOAudioPacket *in;
    for (;;) {
        in = pipe->get( );
        process_packet(in);
        delete in;
    }
}
Exemplo n.º 17
0
void EventLogger::cycle_log()
{
    open_log();

    LoggedEvent event("log-opened", "EventLogger");
    event.add("msg", "Log cycled.");
    process_packet(event.make_datagram(), m_local);
}
Exemplo n.º 18
0
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);
}
Exemplo n.º 19
0
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
}
Exemplo n.º 20
0
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\"}");
    }
Exemplo n.º 21
0
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;
}
Exemplo n.º 22
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;
}
Exemplo n.º 23
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);

  }

}
Exemplo n.º 24
0
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 -- */
Exemplo n.º 25
0
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);
}
Exemplo n.º 26
0
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();
}
Exemplo n.º 27
0
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;
        }
    }
}
Exemplo n.º 28
0
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;
		}
	}	
}
Exemplo n.º 29
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();
}
Exemplo n.º 30
0
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
}