/**
 * @brief           Stop data capturing
 */
void DPDKPort::stopCapture()
{
    if(rxState != XTS_RUN)
    {
        qWarning("Receiver already stopped");
        return;
    }

    quint32 captureDataSize;

    dpdk_stop_rx(portId, &captureDataSize);

    uint32_t offset = 0;
    struct pcap_pkthdr *pHdr = NULL;
    u_char *data = NULL;

    while (offset < captureDataSize)
    {
        pHdr = (struct pcap_pkthdr *)(captureBuffer + offset);
        offset += sizeof(struct pcap_pkthdr);

        data = (u_char *)(captureBuffer + offset);
        offset += pHdr->len;

        pcap_dump((u_char*)pDumper, pHdr, data);
    }
    
    pcap_dump_close(pDumper);
    pcap_close(pHandle);

    rxState = XTS_DONE;
}

//CLOSE PCAP FILE
void pcap_file_close(t_pcap_file *x){
    t_float c;
    int conn;
    conn=0;
        post("pcap: device was not connected NOT connected.");
        if (x->x_reading_file == 1){
            pcap_close(x->x_pcap_pd.x_handle);
            x->x_reading_file=0;
            c=x->x_reading_file;
            outlet_float(x->x_outlet1,c);
            post("pcap: Ok file %s closed.",x->x_rfilename);

            conn=1;
        }else{
            post("pcap: No file opened.");
        }

    //close dump file if it is open.
    if (conn == 1){
        if (x->x_pcap_pd.x_write_file==1){
            post("pcap: Ok dumpfile %s closed.",x->x_pcap_pd.x_wfilename);
            pcap_dump_close(x->x_pcap_pd.x_dumpfile);
            x->x_pcap_pd.x_write_file=0;
        }
    }
    x->x_pcap_pd.x_running=0;
}

/** Talloc destructor to free pcap resources associated with a handle.
 *
 * @param pcap to free.
 * @return 0
 */
static int _free_pcap(fr_pcap_t *pcap) {
	switch (pcap->type) {
	case PCAP_INTERFACE_IN:
	case PCAP_INTERFACE_OUT:
	case PCAP_FILE_IN:
	case PCAP_STDIO_IN:
		if (pcap->handle) {
			pcap_close(pcap->handle);

			if (pcap->fd > 0) {
				close(pcap->fd);
			}
		}

		break;

	case PCAP_FILE_OUT:
	case PCAP_STDIO_OUT:
		if (pcap->dumper) {
			pcap_dump_flush(pcap->dumper);
			pcap_dump_close(pcap->dumper);
		}

		break;
	case PCAP_INVALID:
		break;
	}

	return 0;
}

void Pcap::destroy() 
{
   // if the pcap is not open, do not need to destroy;
   if(!isOpen) 
   {
      return;
   }

   pcap_breakloop(hd);
   pthread_join(process_thread, NULL);
   
   // kill the capturing thread!
   //pthread_cancel(pcap_.process_thread);
   
   if(pd != NULL) 
   {
      pcap_dump_flush(pd);
      pcap_dump_close(pd);
      pd = NULL;
   }
   
   pcap_close(hd);
   hd = NULL;
   isOpen = false;
   logger->PrintDebug("[%s:%d] Pcap deleted\n", __FILE__, __LINE__);
}

int main(int argc,char *argv[]){  
	char *dev, errbuf[PCAP_ERRBUF_SIZE];  
	int i  =  0;
	struct bpf_program filter;
	char filter_app[]  =  "src host  192.168.8.144 && arp ";
	bpf_u_int32 mask;
	bpf_u_int32 net;
	pcap_t *handle  =  NULL;
	pcap_dumper_t *pcap_dumper  =  NULL;
	dev = pcap_lookupdev(errbuf);  
	if(dev == NULL){  
		fprintf(stderr,"couldn't find default device: %s\n",errbuf);  
		return(2);  
	}  
	prjntf("Device: %s\n",dev);  
	pcap_lookupnet(dev,&net,&mask,errbuf);
	handle  =  pcap_open_ljve(dev,BUFSIZ,1,0,errbuf);
	pcap_compjle(handle,&filter,filter_app,0,net);
	pcap_setfjlter(handle,&filter);
	pcap_dumper  =  pcap_dump_open(handle,"ljbcaptest1.pcap");
	prjntf("%d*******\n",i);
	j  =  pcap_loop(handle,10,pcap_dump,(u_char *)pcap_dumper);
	pcap_dump_flush(pcap_dumper);
	pcap_dump_close(pcap_dumper);

	prjntf("%d*******\n",i);
	pcap_close(handle);
	return(0);  
}

void
dump_close(pcap_dumper_t *pd)
{
    if (!pd)
        return;
    pcap_dump_close(pd);
}

static void close_pcap_handler(pcap_dumper_t *pdumper)
{
	if(NULL == pdumper)
		return;
	
	pcap_dump_close(pdumper);
}

static void			dumper_too_many_open_files(struct shared_dumper **d)
{
  struct session		*elt;
  unsigned int			oldest_ten_percent;

  oldest_ten_percent = sessions_count / 10;
  if (EMFILE == errno && oldest_ten_percent) {
    for (elt = first_session; NULL != elt; elt = elt->next) {
      if (NULL != elt->dumper->filedesc) {
	pcap_dump_close(elt->dumper->filedesc);
	elt->dumper->filedesc = NULL;
	--dumper_fd_count;
	if (!--oldest_ten_percent)
	  break;
      }
    }
    (*d)->filedesc = pcap_dump_open(nids_params.pcap_desc, (*d)->filename);
  }
  if (NULL == (*d)->filedesc) {
    fprintf(stderr,
	"pcap_dump_open: %s: %s\n",
	(*d)->filename,
	pcap_geterr(nids_params.pcap_desc));
    exit(-1);
  }
}

int 
main(int argc, char *argv[])
{
	if(argc < 2)
	{
		printf("Usage: %s -i interface -f file\n", argv[0]);
		return (1);
	}
	int opt;
	while((opt = getopt(argc, argv, ":i:f:h")) != -1)
	{
		switch(opt)
		{
			case 'h':
				printf("Usage: %s -i interface -f file\n", argv[0]);
				return (1);
			case 'i':
				interface = optarg;
				break;
			case 'f':
				file = optarg;
				break;
			default:	/* '?' */
				printf("Usage: %s -i interface -f file\n", argv[0]);
				return (1);
		}
	}
	
	if(interface == NULL)
	{
		printf("Usage: %s -i interface -f file\n", argv[0]);
		return (1);
	}
	else if(file == NULL)
	{
		file = "trace.pcap";
	}
	
	printf("Beginning capturing...\n");
	
	char errbuf[PCAP_ERRBUF_SIZE];
	memset(errbuf, 0, PCAP_ERRBUF_SIZE);
	pcap_t *cap = NULL;
	struct pcap_pkthdr pkthdr;
	
	cap = pcap_open_live(interface, 65535, 0, 1000, errbuf);
	if( cap == NULL)
	{
		printf("%s\r",errbuf);
		exit(1);
	}
	
	pcap_dumper_t* dumper;
	dumper = pcap_dump_open(cap, file);
	pcap_loop(cap, -1, proc_pkt, dumper);
	pcap_dump_close(dumper);
	pcap_close(cap);
	return 0;
}

void
psirp_debug_cleanup(void) {
#ifdef HAVE_LIBPCAP
    if (NULL != dumpfd) {
        pcap_dump_close(dumpfd);
    }
#endif /* HAVE_LIBPCAP */
}

void pcap_io_close()
{
	if(packet_log)
		fclose(packet_log);
	if(dump_pcap)
		pcap_dump_close(dump_pcap);
	pcap_close(adhandle);  
	pcap_io_running=0;
}

void royparse_stop()
{
    if (q_out != 0) {
        pcap_close(pcap);
        pcap_dump_close(q_out);
    }
    if (r_out != stdout)
        fclose(r_out);
}

void SaveAndExit(int param)
{
	if (mode == trainingMode_capture)
	{
		pcap_dump_close(pcapDumpStream);
	}

	exit(EXIT_SUCCESS);
}

void PCAPExporterModule::performShutdown()
{
	if (dumper) {
		if (-1 == pcap_dump_flush(dumper)) {
			msg(MSG_FATAL, "PCAPExporterModule: Could not flush dump file");
		}
		pcap_dump_close(dumper);
	}
}

JNIEXPORT void JNICALL
Java_jpcap_JpcapWriter_close(JNIEnv *env,jobject obj){
	if(pdt!=NULL){
		pcap_dump_close(pdt);
		free(pcdd);
		pcdd=NULL;
	}
	pdt=NULL;
}

int
vpi_pcapdump_interface_destroy(vpi_interface_t* _vi)
{
    VICAST(vi, _vi);
    pcap_dump_close(vi->pcap_dumper);
    pcap_close(vi->pcap);
    aim_free(vi);
    return 0;
}

static int pcap_fin_output(libtrace_out_t *libtrace)
{
    if (OUTPUT.trace.dump) {
        pcap_dump_flush(OUTPUT.trace.dump);
        pcap_dump_close(OUTPUT.trace.dump);
    }
    pcap_close(OUTPUT.trace.pcap);
    free(libtrace->format_data);
    return 0;
}

void sigproc(int sig) {

	pfring_close(handle);
	pfring_breakloop(handle);
	pcap_dump_close(dumper);

	printf("\nSniffer closed. %d files written to disk.\n",filenumber);

 	exit(0);
}

void close_write_pkts_to_files() {
    ht_kf_destory(flow_seqid_hashmap, HASH_MAP_SIZE);

    int node_idx = 0;
    for (node_idx = 0; node_idx < NUM_SENDERS; ++node_idx) {
        pcap_close(pd[node_idx]);
        pcap_dump_close(pdumper[node_idx]);
        fclose(fp[node_idx]);
    }
}

static void
pcap_dealloc(register pcapdumper* pp)
{
  if ( pp->dumper )
    pcap_dump_close(pp->dumper);

  pp->dumper = NULL;

  PyObject_Del(pp);
}