/**
* @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);
}
