/** * @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 close_pcap_dump() { if (pcap_writer) { pcap_dump_flush(pcap_writer); pcap_dump_close(pcap_writer); pcap_writer = NULL; } }
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 pcap_ng_dump_close(pcap_dumper_t *p) { /* * XXX we could add an interface statistics block at the end * of the file. */ return pcap_dump_close(p); }
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); }
int dump_file_close() { if ( dump_handle != NULL ) { pcap_dump_flush(dump_handle); pcap_dump_close(dump_handle); dump_handle = NULL; } return SUCCESS; }
void zizzania_finalize(struct zizzania *z) { if (z->dumper) { pcap_dump_close(z->dumper); } pcap_close(z->handler); close(z->comm[0]); close(z->comm[1]); g_hash_table_destroy(z->targets); g_hash_table_destroy(z->kill_list); }
void write_pcap_deinit(struct wlantest *wt) { if (wt->write_pcap_dumper) { pcap_dump_close(wt->write_pcap_dumper); wt->write_pcap_dumper = NULL; } if (wt->write_pcap) { pcap_close(wt->write_pcap); wt->write_pcap = NULL; } }
/* * Automated Garbage Collection for Pcap Class */ static void rbpcap_free(rbpcap_t *rbp) { if (rbp->pd) pcap_close(rbp->pd); if (rbp->pdt) pcap_dump_close(rbp->pdt); rbp->pd = NULL; rbp->pdt = NULL; free(rbp); }
void capture_close(void) { pcap_close(GBL_PCAP->pcap); if (GBL_OPTIONS->write) pcap_dump_close(GBL_PCAP->dump); if (GBL_SNIFF->type == SM_BRIDGED) pcap_close(GBL_PCAP->pcap_bridge); DEBUG_MSG("ATEXIT: capture_closed"); }
bool GPcapFileWriter::doClose() { if (pcap_dumper_ != nullptr) { pcap_dump_close(pcap_dumper_); pcap_dumper_ = nullptr; } if (pcap_ != nullptr) { pcap_close(pcap_); pcap_ = nullptr; } return true; }
/*- -- dumper:close() Manually close a dumper object, freeing it's resources (this will happen on garbage collection if not done explicitly). */ static int lpcap_dump_close (lua_State *L) { pcap_dumper_t** dumper = luaL_checkudata(L, 1, L_PCAP_DUMPER_REGID); if(*dumper) pcap_dump_close(*dumper); *dumper = NULL; return 0; }
/* * Class: org_jnetpcap_PcapDumper * Method: close * Signature: ()V */ EXTERN void JNICALL Java_org_jnetpcap_PcapDumper_close (JNIEnv *env, jobject obj) { pcap_dumper_t *d = getPcapDumper(env, obj); if (d == NULL) { return; // Exception already thrown } pcap_dump_close(d); setPcapDumper(env, obj, NULL); }