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