static void signal_alarm (int signo) { extern enum STATE state; extern char dev_if_name[]; switch (state) { case ONLINE: keep_alive(); alarm(30); break; case STARTED: fprintf(stderr, "\n&&Error: Packet sent but no reply. Please check network link to %s.\n", dev_if_name); pcap_breakloop (handle); break; case STATUS_ERROR: if (exit_counter) { exit_counter--; fprintf(stdout, "Please wait until session ends ... %2d\r", exit_counter); fflush (stdout); alarm(1); } else { fprintf(stdout, "\n&&Info: Program Exit. \n"); pcap_breakloop (handle); } break; default: break; } }
void action_eapol_failre(const struct eap_header *eap_head, const struct pcap_pkthdr *packetinfo, const uint8_t *packet) { extern int background; extern int exit_flag; extern pthread_t exit_waiter_id; state = READY; fprintf(stdout, ">>Protocol: EAP_FAILURE\n"); if(state == ONLINE){ fprintf(stdout, "&&Info: SERVER Forced Logoff\n"); } if (state == STARTED){ fprintf(stdout, "&&Info: Invalid Username or Client info mismatch.\n"); } if (state == ID_AUTHED){ fprintf(stdout, "&&Info: Invalid Password.\n"); } print_server_info (packet, packetinfo->caplen, EAP_FAILURE); if (exit_flag) { fprintf(stdout, "&&Info: Session Ended.\n"); pcap_breakloop (handle); } else{ exit_flag = 1; if (pthread_create (&exit_waiter_id, NULL, thread_wait_exit, NULL) != 0) { fprintf(stderr, "@@Fatal ERROR: Thread failure.\n"); exit (EXIT_FAILURE); } } }
void ewpcap_error(EWPCAP_STATE *ep, char *msg) { int rv = 0; if (ep->p == NULL) return; /* {ewpcap_error, Ref, Error} */ rv = enif_send( NULL, &ep->pid, ep->env, enif_make_tuple3(ep->env, atom_ewpcap_error, enif_make_copy(ep->env, ep->ref), enif_make_string(ep->env, msg, ERL_NIF_LATIN1) ) ); if (!rv) pcap_breakloop(ep->p); enif_clear_env(ep->env); }
static void PcapCallbackLoop(char *user, struct pcap_pkthdr *h, u_char *pkt) { SCEnter(); PcapThreadVars *ptv = (PcapThreadVars *)user; Packet *p = PacketGetFromQueueOrAlloc(); struct timeval current_time; if (unlikely(p == NULL)) { SCReturn; } PKT_SET_SRC(p, PKT_SRC_WIRE); p->ts.tv_sec = h->ts.tv_sec; p->ts.tv_usec = h->ts.tv_usec; SCLogDebug("p->ts.tv_sec %"PRIuMAX"", (uintmax_t)p->ts.tv_sec); p->datalink = ptv->datalink; ptv->pkts++; ptv->bytes += h->caplen; (void) SC_ATOMIC_ADD(ptv->livedev->pkts, 1); p->livedev = ptv->livedev; if (unlikely(PacketCopyData(p, pkt, h->caplen))) { TmqhOutputPacketpool(ptv->tv, p); SCReturn; } switch (ptv->checksum_mode) { case CHECKSUM_VALIDATION_AUTO: if (ptv->livedev->ignore_checksum) { p->flags |= PKT_IGNORE_CHECKSUM; } else if (ChecksumAutoModeCheck(ptv->pkts, SC_ATOMIC_GET(ptv->livedev->pkts), SC_ATOMIC_GET(ptv->livedev->invalid_checksums))) { ptv->livedev->ignore_checksum = 1; p->flags |= PKT_IGNORE_CHECKSUM; } break; case CHECKSUM_VALIDATION_DISABLE: p->flags |= PKT_IGNORE_CHECKSUM; break; default: break; } if (TmThreadsSlotProcessPkt(ptv->tv, ptv->slot, p) != TM_ECODE_OK) { pcap_breakloop(ptv->pcap_handle); ptv->cb_result = TM_ECODE_FAILED; } /* Trigger one dump of stats every second */ TimeGet(¤t_time); if (current_time.tv_sec != ptv->last_stats_dump) { PcapDumpCounters(ptv); ptv->last_stats_dump = current_time.tv_sec; } SCReturn; }
/** * ByteBuffer dispatcher that allocates a new java.nio.ByteBuffer and dispatches * it to java listener. */ void cb_byte_buffer_dispatch(u_char *user, const pcap_pkthdr *pkt_header, const u_char *pkt_data) { cb_byte_buffer_t *data = (cb_byte_buffer_t *)user; JNIEnv *env = data->env; setJMemoryPhysical(env, data->header, toLong((void*)pkt_header)); jobject buffer = env->NewDirectByteBuffer((void *)pkt_data, pkt_header->caplen); if (buffer == NULL) { return; } env->CallVoidMethod( data->obj, data->mid, (jobject) data->header, (jobject) buffer, (jobject) data->user); env->DeleteLocalRef(buffer); if (env->ExceptionCheck() == JNI_TRUE) { data->exception = env->ExceptionOccurred(); pcap_breakloop(data->p); } }
void TrainDialog::timerFired() { progressBar->setValue(progressBar->value() + 1); std::cout << "Ticking: " << progressBar->value(); if (progressBar->value() == TRAIN_TIME_S) { pcap_breakloop(PacketSniffer::instance()->handle); } }
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__); }
void shutdown_all(int sig) { fprintf(stdout,"Leaving...\n"); if (0 != talker) { send_process('L'); /** send leave */ } send_process('M'); /** mrp disconnect */ close(control_socket); if (NULL != handle) { pcap_breakloop(handle); pcap_close(handle); } #ifdef LIBSND if (NULL != snd_file) { sf_write_sync(snd_file); sf_close(snd_file); } #endif if (NULL != client) { fprintf(stdout, "jack\n"); jack_client_close(client); jack_ringbuffer_free(ringbuffer); } exit(0); }
void CommsThread::setNetworkInterface(int value) { if (value != interfaceNumber && scheduledNewInterface == false) { //qDebug() << "got signal from UI"; scheduledNewInterface = true; interfaceNumber = value; if (fp != NULL) { pcap_breakloop(fp); pcap_close(fp); } streamManager.removeAll(); if (interfaceTimeout == NULL) { interfaceTimeout = new QTimer(this); interfaceTimeout->setInterval(NETWORK_INTERFACE_OFF_DELAY); interfaceTimeout->setSingleShot(true); connect(interfaceTimeout, SIGNAL(timeout()), SLOT(timerDone())); } if (interfaceTimeout->isActive()) { interfaceTimeout->setInterval(NETWORK_INTERFACE_OFF_DELAY); qDebug() << interfaceTimeout; } else { interfaceTimeout->start(); } // TODO still not correct: "left over" data in table //QTimer::singleShot(NETWORK_INTERFACE_OFF_DELAY, this, SLOT(timerDone())); // allow time for network interface to stop } }
/* Function handlet for SIGALRM */ void CatchAlarm(int signum) { printf("\n\t\tTIMEOUT :-(\n"); pcap_breakloop(descr); pcap_close(descr); }
void capture_close() { capture_info_t *capinfo; // Nothing to close if (vector_count(capture_cfg.sources) == 0) return; // Stop all captures vector_iter_t it = vector_iterator(capture_cfg.sources); while ((capinfo = vector_iterator_next(&it))) { //Close PCAP file if (capinfo->handle) { pcap_breakloop(capinfo->handle); pthread_join(capinfo->capture_t, NULL); pcap_close(capinfo->handle); } } // Close dump file if (capture_cfg.pd) { dump_close(capture_cfg.pd); } }
static PyObject * p_breakloop (PyObject *self, PyObject *args) { pcap_t * ppcap; if (!PyArg_ParseTuple(args, "l", (long int*)&ppcap)) return NULL; pcap_breakloop(ppcap); Py_RETURN_NONE; }
static int unload_module(void) { unsigned int i = 0; LNOTICE("unloaded module %s", module_name); for (i = 0; i < profile_size; i++) { if(sniffer_proto[i]) { pcap_breakloop(sniffer_proto[i]); pthread_join(call_thread[i],NULL); } if (reasm[i] != NULL) { reasm_ip_free(reasm[i]); reasm[i] = NULL; } if (tcpreasm[i] != NULL) { tcpreasm_ip_free(tcpreasm[i]); tcpreasm[i] = NULL; } free_profile(i); } /* Close socket */ //pcap_close(sniffer_proto); return 0; }
void PcapFileCallbackLoop(char *user, struct pcap_pkthdr *h, u_char *pkt) { SCEnter(); PcapFileThreadVars *ptv = (PcapFileThreadVars *)user; Packet *p = PacketGetFromQueueOrAlloc(); if (unlikely(p == NULL)) { SCReturn; } PACKET_PROFILING_TMM_START(p, TMM_RECEIVEPCAPFILE); p->ts.tv_sec = h->ts.tv_sec; p->ts.tv_usec = h->ts.tv_usec; SCLogDebug("p->ts.tv_sec %"PRIuMAX"", (uintmax_t)p->ts.tv_sec); p->datalink = pcap_g.datalink; p->pcap_cnt = ++pcap_g.cnt; ptv->pkts++; ptv->bytes += h->caplen; if (unlikely(PacketCopyData(p, pkt, h->caplen))) { TmqhOutputPacketpool(ptv->tv, p); PACKET_PROFILING_TMM_END(p, TMM_RECEIVEPCAPFILE); SCReturn; } PACKET_PROFILING_TMM_END(p, TMM_RECEIVEPCAPFILE); if (TmThreadsSlotProcessPkt(ptv->tv, ptv->slot, p) != TM_ECODE_OK) { pcap_breakloop(pcap_g.pcap_handle); ptv->cb_result = TM_ECODE_FAILED; } SCReturn; }
void sigint_handler(int signum) { fprintf(stdout,"Leaving...\n"); if (0 != talker) send_leave(); if (2 > control_socket) { close(control_socket); mrp_disconnect(); } #ifdef PCAP if (NULL != handle) { pcap_breakloop(handle); pcap_close(handle); } #endif #ifdef LIBSND sf_write_sync(snd_file); sf_close(snd_file); #endif }
void terminate() { if (handle != 0) { pcap_breakloop(handle); printf("terminate!\n"); } pcap_close(handle); }
void ctrl_c(){ printf("Exiting\n"); fprintf(file,"r_sum:%d,s_sum:%d\n",r_sum,s_sum); pcap_breakloop(handle); pcap_close(handle); exit(0); }
static void tcp_kill_cb(u_char *user, const struct pcap_pkthdr *pcap, const u_char *pkt) { struct libnet_ipv4_hdr *ip; struct libnet_tcp_hdr *tcp; char ctext[64]; u_int32_t seq, win; int i, len; libnet_t *l; l = (libnet_t *)user; pkt += pcap_off; len = pcap->caplen - pcap_off; ip = (struct libnet_ipv4_hdr *)pkt; if (ip->ip_p != IPPROTO_TCP) return; tcp = (struct libnet_tcp_hdr *)(pkt + (ip->ip_hl << 2)); if (tcp->th_flags & (TH_SYN|TH_FIN|TH_RST)) return; seq = ntohl(tcp->th_ack); win = ntohs(tcp->th_win); snprintf(ctext, sizeof(ctext), "%s:%d > %s:%d:", libnet_addr2name4(ip->ip_src.s_addr, LIBNET_DONT_RESOLVE), ntohs(tcp->th_sport), libnet_addr2name4(ip->ip_dst.s_addr, LIBNET_DONT_RESOLVE), ntohs(tcp->th_dport)); for (i = 0; i < Opt_severity; i++) { seq += (i * win); libnet_clear_packet(l); libnet_build_tcp(ntohs(tcp->th_dport), ntohs(tcp->th_sport), seq, 0, TH_RST, 0, 0, 0, LIBNET_TCP_H, NULL, 0, l, 0); libnet_build_ipv4(LIBNET_IPV4_H + LIBNET_TCP_H, 0, libnet_get_prand(LIBNET_PRu16), 0, 64, IPPROTO_TCP, 0, ip->ip_dst.s_addr, ip->ip_src.s_addr, NULL, 0, l, 0); if (libnet_write(l) < 0) warn("write"); fprintf(stderr, "%s R %lu:%lu(0) win 0\n", ctext, (unsigned long) seq, (unsigned long) seq); } ++kill_counter; if (Opt_max_kill && kill_counter >= Opt_max_kill) { pcap_breakloop(pd); } }
/* gracefully handle a Control C */ void ctrl_c ( ) { printf ("Exiting\n"); pcap_breakloop (handle); /* tell pcap_loop or pcap_dispatch to stop capturing */ pcap_close(handle); return; }
static void stop_fun() { pthread_kill(cappid, SIGUSR1); if (pd != NULL) { pcap_breakloop(pd); pd = NULL; } }
void reader_libpcap_stop() { int i; for (i = 0; i < MAX_INTERFACES && config.interface[i]; i++) { if (pcaps[i]) pcap_breakloop(pcaps[i]); } }
void sig_handler(int sig) { if(handle != NULL) { pcap_breakloop(handle); } fflush(stdout); fflush(stderr); exit(EXIT_FAILURE); }
/** * JPacket dispatcher that dispatches decoded java packets */ void cb_pcap_packet_dispatch(u_char *user, const pcap_pkthdr *pkt_header, const u_char *pkt_data) { cb_packet_t *data = (cb_packet_t *)user; JNIEnv *env = data->env; jmemoryPeer(env, data->header, pkt_header, sizeof(pcap_pkthdr), data->pcap); jmemoryPeer(env, data->packet, pkt_data, pkt_header->caplen, data->pcap); if (Java_org_jnetpcap_packet_JScanner_scan( env, data->scanner, data->packet, data->state, data->id, pkt_header->len) < 0) { return; } jobject pcap_packet = transferToNewBuffer(env, pkt_header, pkt_data, data->state); if (pcap_packet == NULL) { if (data->pcap != NULL) { pcap_breakloop(data->p); } else { data->flags |= DEBUG_INJECT_PACKET_BREAK_LOOP; } return; } env->CallVoidMethod( data->obj, data->mid, // data->packet, pcap_packet, data->user); env->DeleteLocalRef(pcap_packet); if (env->ExceptionCheck() == JNI_TRUE) { data->exception = env->ExceptionOccurred(); pcap_breakloop(data->p); } }
void PcapInterface::shutdown() { if(running) { void *res; NetworkInterface::shutdown(); if(pcap_handle) pcap_breakloop(pcap_handle); pthread_join(pollLoop, &res); } }
void CPacket::TerminateSniffing(int nSignum) { fflush(stdin); char ch; scanf("%c", &ch); printf("\n"); pcap_breakloop(m_pHandle); pcap_close(m_pHandle); }
/* * sig_reload() */ void sig_reload(int signal_arg) { if (handle) { pcap_breakloop(handle); } fprintf(info, "got signal %d, printing out stats and configuration\n", signal_arg); flocap_stats_output(info); config_print(info, &config); }
void ewpcap_send(u_char *user, const struct pcap_pkthdr *h, const u_char *bytes) { EWPCAP_STATE *ep = (EWPCAP_STATE *)user; ErlNifBinary buf = {0}; int rv = 0; /* XXX no way to indicate an error? */ if (ep->p == NULL) return; if (!enif_alloc_binary(h->caplen, &buf)) { pcap_breakloop(ep->p); return; } (void)memcpy(buf.data, bytes, buf.size); /* {ewpcap, Ref, DatalinkType, Time, ActualLength, Packet} */ rv = enif_send( NULL, &ep->pid, ep->env, enif_make_tuple6(ep->env, atom_ewpcap, enif_make_copy(ep->env, ep->ref), enif_make_int(ep->env, ep->datalink), enif_make_tuple3(ep->env, enif_make_ulong(ep->env, abs(h->ts.tv_sec / 1000000)), enif_make_ulong(ep->env, h->ts.tv_sec % 1000000), enif_make_ulong(ep->env, h->ts.tv_usec) ), enif_make_ulong(ep->env, h->len), enif_make_binary(ep->env, &buf) ) ); if (!rv) pcap_breakloop(ep->p); enif_clear_env(ep->env); }
void process_packet (u_char *arg, const struct pcap_pkthdr* pkthdr, const u_char* packet) { packet_probe *pkt; data_test *data = (data_test *)arg; settings *conf_settings = data->conf_settings; received_probe *recv_probe = &(data->probe[0]); resume *result = data->result; timeval32 tm32_now; int jitter = 0; pcap_t* handle = (pcap_t*)data->handle; if (pkthdr->len >= (sizeof(packet_probe) + OVERHEAD_SIZE)) { #ifdef CONECT_4G pkt = (packet_probe *)&packet[OVERHEAD_SIZE+2]; #else pkt = (packet_probe *)&packet[OVERHEAD_SIZE]; #endif tm32_now.tv_sec = pkthdr->ts.tv_sec; tm32_now.tv_usec = pkthdr->ts.tv_usec; if (pkt->packet_id != PACKET_END_TEST) { if (recv_probe->received_total == 0) { recv_probe->received_total = pkthdr->len; recv_probe->received_packets = 1; recv_probe->start = tm32_now; recv_probe->end = recv_probe->report_time = tm32_now; recv_probe->report_time.tv_usec += ((conf_settings->test.cont.report_interval) % 1000) * 1000; recv_probe->report_time.tv_sec += (conf_settings->test.cont.report_interval) / 1000; if (recv_probe->report_time.tv_usec >= 1000000) { recv_probe->report_time.tv_usec -= 1000000; recv_probe->report_time.tv_sec += 1; } } else { /* calcular jitter medio, min e max */ jitter = difftimeval2us (&(recv_probe->end), &tm32_now); if (jitter > result->jitter_max) result->jitter_max = jitter; if (jitter < result->jitter_min) result->jitter_min = jitter; result->jitter_med += jitter; recv_probe->received_total += pkthdr->len; recv_probe->received_packets++; recv_probe->end = tm32_now; } } if ((pkt->packet_id == PACKET_END_TEST) || (compare_time (&(recv_probe->report_time), &(tm32_now)))) { recv_probe->stop_recv = 1; if (handle != NULL) { pcap_breakloop (handle); } } } return; }
void got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet) { time_t dsec; suseconds_t dmsec; u_char *p; int i,j; uint64_t host_id=0; char mac[0x20]; if( header->caplen < 100) return; // skip some unknown very small pkts memcpy(&host_id, packet+48, 6); for(i=0; i<nhosts; i++) { // host already responded if(hosts[i] == host_id) return; } hosts[nhosts++] = host_id; sprintf(mac, "%02x:%02x:%02x:%02x:%02x:%02x", packet[6], packet[7], packet[8], packet[9], packet[10], packet[11] ); if( mac_to_find ) { if( 0 == strcasecmp(mac, mac_to_find) ) { nhosts = 1; do_stop = 1; mac_found = 1; pcap_breakloop( pcap_handle ); } else return; } printf("%3d bytes from %s (%-15s): time=%3d ms name=\"%s\"", header->caplen, mac, lltd_extract_ip(packet+46), tv_diff2msec(&header->ts), unicode ? lltd_extract_unicode_name(packet+46) : lltd_extract_name(packet+46) ); if(verbose == 1) { puts(""); lltd_dump(packet+46); } else if(verbose == 2) { printf("\n\t"); for(i=46,j=0; i<header->caplen; i++) { printf("%02x ",packet[i]); j++; if(j == 16) { printf("\n\t"); j=0; } } } puts(""); }
static void _kqtime_handlePacket(KQTimePCapWorker* worker, const struct pcap_pkthdr *hdr, const u_char *bytes) { // ETH2 header is 64 bytes? // IP header is 20 bytes min + possible ? bytes for options // TCP header is 20 bytes min + possible 80 bytes for options /* check if it is long enough to have data in it */ if (hdr->caplen < (KQTIME_TAG_OFFSET+KQTIME_TAG_LENGTH)) { return; } KQTimeCommand* command = g_async_queue_try_pop(worker->commands); if(command) { KQTimeCommandType type = command->type; g_free(command); switch(type) { case KQTIME_CMD_EXIT: { pcap_breakloop(worker->pcapHandle); return; } case KQTIME_CMD_READY: { /* if we are inbound, the searcher is ready, send it a tag */ if(worker->isInbound) { KQTimeTagCommand* tagCommand = g_new0(KQTimeTagCommand, 1); tagCommand->base.type = KQTIME_CMD_TAG; tagCommand->tagTime = hdr->ts; memcpy(tagCommand->tag, &bytes[KQTIME_TAG_OFFSET], KQTIME_TAG_LENGTH); g_async_queue_push(worker->searchWorkerCommands, tagCommand); return; } /* outbound workers ignore ready commands */ break; } default: break; } } /* only outbound thread sends data to searcher */ if(!worker->isInbound) { KQTimeDataCommand* dataCommand = g_new0(KQTimeDataCommand, 1); dataCommand->base.type = KQTIME_CMD_DATA; dataCommand->dataLength = (gint)hdr->caplen; dataCommand->dataTime = hdr->ts; dataCommand->data = g_malloc((gsize)dataCommand->dataLength); memcpy(dataCommand->data, bytes, (gsize) dataCommand->dataLength); g_async_queue_push(worker->searchWorkerCommands, dataCommand); } }