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;
}

// 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;
}