File: dns_flood_detector.c

package info (click to toggle)
dns-flood-detector 1.20-1~bpo70+1
  • links: PTS, VCS
  • area: main
  • in suites: wheezy-backports
  • size: 212 kB
  • sloc: ansic: 737; perl: 102; sh: 75; makefile: 54
file content (1032 lines) | stat: -rw-r--r-- 31,971 bytes parent folder | download | duplicates (6)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
/********************************************************************************

	Program: dns_flood_detector.c
	 Author: Dennis Opacki <dopacki@adotout.com>
	   Date: Tue Mar 18 16:46:53 EST 2003 
	Purpose: Monitor DNS servers for abusive usage levels
		 and alarm to syslog

	compile with:
	gcc -o dns_flood_detector -lpcap -lpthread -lm dns_flood_detector.c 
	
	command-line options:
	
	-i ifname	specify interface to listen on (default lets pcap pick)	
	-t n		alarm when more than n queries per second are observed
			(default 40)
	-a n		wait for n seconds before alarming again on same source
			(default 90)
	-w n		calculate statistics every n seconds 
			(default 10)
	-x n		use n buckets 
			(default 50)
	-m n		mark overall query rate every n seconds
			(default disabled)
	-A addr		filter for specific address
	-M mask		netmask for filter (in conjunction with -A)
	-Q		monitor any addresses (default is to filter only for
			primary addresses on chosen interface)
	-b		run in foreground in "bindsnap" mode
	-d		run in background in "daemon" mode
	-D		dump dns packets (implies -b)
	-v		detailed information (use twice for more detail)
        -s              send source IP stats to collector as JSON
        -z N.N.N.N      address to send stats to (default 226.1.1.2)
        -p N            UDP port to send stats to (default 2000)

	-h		usage info

    Copyright (C) 2003  Dennis Opacki

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    --- new in v1.05 ---
    8/18/2003 - FreeBSD target - Jim Westfall <jwestfall@surrealistic.net> 
    8/18/2003 - Moved to getopt(3) for compatibility <dopacki@adotout.com>
    8/19/2003 - Added OSX/BSDI make targets - <dopacki@adotout.com>
                Added ability to specify inteface - <dopacki@adotout.com>

    --- new in v1.06 ---
    8/20/2003 - Added Solaris9 make target - <dopacki@adotout.com>
    8/26/2003 - Fixed tcp qdcount bug - <dopacki@adotout.com>

    --- new in v1.07 ---
    8/27/2003 - Fixed alarm reset bug - <dopacki@adotout.com>
    8/28/2003 - Added malloc_fail function - <dopacki@adotout.com>
    8/28/2003 - Added mutex thread locking - <dopacki@adotout.com>
    8/30/2003 - Fixed wierd qtype segfault - <jwestfall@surrealistic.net>
					     <dopacki@adotout.com>

    --- new in v1.08 ---
    9/02/2003 - Added -v -v output in daemon mode - <dopacki@adotout.com>

    --- new in v1.09 ---
    10/19/2003 - Added stdout flushing to bindsnap mode - <dopacki@adotout.com>
    10/19/2003 - Changed logging priority to LOG_NOTICE - <dopacki@adotout.com>
    10/19/2003 - Fixed low traffic verbose logging bugs - <dopacki@adotout.com>

    --- new in v1.10 ---
    10/22/2003 - Added 'mark status' option via '-m' - <dopacki@adotout.com>
    10/23/2003 - Code cleanup in verbose syslogging - <dopacki@adotout.com>

    --- new in v1.11 ---
    06/14/2005 - added A6, AAAA, ANY qtypes - <jwestfall@surrealistic.net>
                 examine all packets with >= 1 qdcount - <jwestfall@surrealistic.net>
                 stop processing packet if invalid dns char - <jwestfall@surrealistic.net>
                 fix tcp parsing - <jwestfall@surrealistic.net>
                 add option_D to dump packets - <jwestfall@surrealistic.net>

    --- new in v1.12 ---
    03/03/2006 - added address filtering options - <erikm@buh.org>
                 fix segfault using argv[0] after getopt - <erikm@buh.org>
                 fix rounding from float/int conversions, use unsigned more consistently - <erikm@buh.org>
                 clean up to work with -Wall - <erikm@buh.org>
                 show fractional qps rates for totals - <erikm@buh.org> 
                 store addresses raw, instead of as text (speedup/reduce memory usage) - <erikm@buh.org>
                 fix crash on long syslog messages - <jwestfall@surrealistic.net>

    --- new in v1.2 ---
    05/10/2012 - added sending of source-IP telemetry to a network collector - <dopacki@adotout.com>

********************************************************************************/

#include <pcap.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in_systm.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <netinet/udp.h>
#include <arpa/inet.h>
#ifdef __bsdi__
#include <net/if_ethernet.h>
#else
#ifdef __sun__
#include <sys/ethernet.h>
#else
#include <net/ethernet.h>
#endif
#endif
#include <pthread.h>
#include <unistd.h>
#include <time.h>
#include <math.h>
#include <signal.h>
#include <syslog.h>
#include <string.h>
#include <sys/stat.h>
#include "dns_flood_detector.h"
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/select.h>

// global variables and their defaults
pthread_mutex_t stats_lock;
struct bucket **bb;
int option_t = 60;
int option_a = 90;
int option_w = 20;
int option_x = 10000;
int option_m = 0;
int option_b = 0;
int option_d = 0;
int option_D = 0;
int option_v = 0;
int option_h = 0;
int option_Q = 0;
int option_A = 0;
int option_M = 0;
int option_s = 0;
int totals = 0;

static char *target_ip = NULL;
int target_port = DEFAULT_PORT;
int mcast_ttl = 10;
char hostname[HOST_NAME_MAX];

char VERSION[] = "1.2";

// 255.255.255.255 is invalid as a src IP address; we'll use it to mark empty buckets
#define BCAST 0xffFFffFF

// this is our statistics thread
void *run_stats () {
  // prepare multicast socket
  struct sockaddr_in addr;
  int sock;
  sock = socket(AF_INET, SOCK_DGRAM,0);

  if  (sock<0) {
    perror("can't set up socket");
    exit(1);
  }

  // is it harmful to set this on non-multicast sockets?
  setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL, (char *)&mcast_ttl, sizeof(mcast_ttl));

  bzero((char*)&addr, sizeof(addr));
  addr.sin_family = AF_INET;
  addr.sin_addr.s_addr = inet_addr(target_ip);
  addr.sin_port = htons(target_port);

  // get our hostname
  gethostname(hostname, HOST_NAME_MAX-1);

  while (1) {

    // check statistical stuff
    pthread_mutex_lock(&stats_lock);
    calculate_averages();
    saddr_stats(sock,addr,hostname);
    pthread_mutex_unlock(&stats_lock);
    sleep (option_w);
  }
}

// report saddr stats
int saddr_stats(int sock, struct sockaddr_in addr, char *hostname) {
  u_int i;
  int addrlen;
  char buff[MAXMESSAGE];
  int buffhead = 0;
  char st_time[10];
  time_t now = time(0);
  struct tm *raw_time = localtime(&now);
  addrlen = sizeof(addr);
  snprintf(st_time, 9, "%02d:%02d:%02d",raw_time->tm_hour,raw_time->tm_min,raw_time->tm_sec);

  // prepare jason structure for multicast datagrams
  char head[MAXHEAD];
  char *tail = "}}";
  snprintf(head,MAXHEAD,"{\"hostname\":\"%s\",\"type\":\"source\",\"data\":{",hostname);
  int netsize = MAXMESSAGE - strlen(head) - strlen(tail);
  if (netsize<=0) exit(EXIT_FAILURE); // this should never ever happen

  int avail = netsize;
  int dlen = 0;
  char datalet[MAXDATALET];

  // copy the initial json header into the buffer
  bzero(buff,sizeof(buff));
  memcpy(buff,head,strlen(head));
  buffhead = buffhead + strlen(head);

  // report all source address stats, cleaning up afterward
  for (i=0; ( (i < option_x) && ( bb[i]->ip_addr.s_addr != 0 ) ); i++) {

    if ( bb[i]->ip_addr.s_addr != BCAST ) {

      // prepare a datalet
      snprintf(datalet,MAXDATALET,"\"%s\":%d,",inet_ntoa(bb[i]->ip_addr),bb[i]->udp_count+bb[i]->tcp_count);
      dlen = strlen(datalet);

      // see if the current datagram has room for the datalet
      if ( avail > dlen ) {

        // append this datalet to the current datagram (minus null terminator)
        avail = avail - dlen;
        memcpy(buff+buffhead,datalet,dlen);
        buffhead = buffhead + dlen;
      }
      // no room in current dgram
      else {

        // remove trailing comma from the buffer so we can close it out
        buffhead = buffhead - 1;

        // add the tail
        strncpy(buff+buffhead,tail, strlen(tail));

        // send the transmission if option_s is set
        if (option_s > 0 ) {
          sendto(sock,buff,strlen(buff)+1,0,(struct sockaddr *) &addr, addrlen);
          microsleep(10);
        }

        // init next datagram
        bzero(buff,sizeof(buff));
        memcpy(buff,head,strlen(head));
        buffhead = strlen(head);
        avail = netsize;

        // append this datalet to the current datagram (minus null terminatin)
        avail = avail - dlen;
        memcpy(buff+buffhead,datalet,dlen);
        buffhead = buffhead + dlen;
      }
    }

    scour_bucket(i);    
  }

  // transmit final buffer contents if needed
  if ( ( option_b == 0) && (buffhead>strlen(head)) ) {

    // remove trailing comma
    buffhead = buffhead - 1;

    // add the tail
    strncpy(buff+buffhead,tail,strlen(tail));

    // send the multicast transmission
    sendto(sock,buff,strlen(buff)+1,0,(struct sockaddr *) &addr, addrlen);
    microsleep(10);

    bzero(buff,sizeof(buff));
  }
  return 1;
}


// calculate the running average within each bucket
int calculate_averages() {
  u_int i,j,delta,cursize,qps;
  int newsize;
  float qpsf;
  char st_time[10];
  time_t now = time(0);
  u_int types[] = {1,2,5,6,12,15,28,38,252,255,0};
  char *target;
  char *names[] = {"A","NS","CNAME","SOA","PTR","MX","AAAA","A6","AXFR","ANY",""};
  struct tm *raw_time = localtime(&now);
  snprintf(st_time, 9, "%02d:%02d:%02d",raw_time->tm_hour,raw_time->tm_min,raw_time->tm_sec);

  for (i=0; i<option_x; i++) {

    // only process valid buckets
    if ( bb[i]->ip_addr.s_addr != BCAST) {
      delta = now - bb[i]->first_packet;

      // let's try to avoid a divide-by-zero, shall we?
      if (delta > 1 ) {

        // round our average and save it in the bucket
        bb[i]->qps = (u_int)ceil( (bb[i]->tcp_count + bb[i]->udp_count) / (float)delta);

        // handle threshold crossing
        if ( bb[i]->qps > option_t ) {

          // display detail to either syslog or stdout
          if ( option_b ) {
            if ( ! option_v ) {
              printf("[%s] source [%s] - %u qps\n",st_time,inet_ntoa(bb[i]->ip_addr),bb[i]->qps);
              fflush(stdout);
            }
            else {
              printf("[%s] source [%s] - %u qps tcp : %u qps udp ",st_time,inet_ntoa(bb[i]->ip_addr),
              (u_int)ceil( ((float)bb[i]->tcp_count/delta)),
              (u_int)ceil( ((float)bb[i]->udp_count/delta)));

              if ( option_v >1 ) {
                for (j=0;types[j];j++) {
                  qps = (u_int)ceil((float)bb[i]->qstats[types[j]]/delta);
                  if (qps){
                    printf("[%u qps %s] ",qps,names[j]);
                  }
                }
              }
              printf("\n");
              fflush(stdout);
            }
          }
          else {
            // if running in background, use alarm reset timer
            if ((now-bb[i]->alarm_set)>option_a) {

              // display appropriate level of detail via syslog
              if ( ! option_v ) {
                syslog(LOG_NOTICE,"source [%s] - %u qps\n",inet_ntoa(bb[i]->ip_addr),bb[i]->qps);
              }
              else if (option_v > 1) {
                target = (char *)malloc(sizeof(char)*MAXSYSLOG);
                newsize = MAXSYSLOG;
                cursize = snprintf(target,newsize,"source [%s] - %u tcp qps : %u udp qps ",inet_ntoa(bb[i]->ip_addr),
                (u_int)ceil( ((float)bb[i]->tcp_count/delta)),				
                (u_int)ceil( ((float)bb[i]->udp_count/delta)));
                newsize-=cursize;
	
                for (j=0;types[j];j++ ) {
                  qps = (u_int)ceil(((float)bb[i]->qstats[types[j]]/delta));
                  if ( ( qps > 0)  && ( newsize > 1 ) ) {
                    cursize = snprintf(target+(MAXSYSLOG-newsize),newsize,"[%u qps %s] ",qps,names[j]);
                    newsize-=cursize;
                  }
                }
                if (newsize <= 0 ) {
                  target[MAXSYSLOG-1]='\0';
                }
                syslog(LOG_NOTICE,"%s",target);
                free(target);
              }
              else {
                syslog(LOG_NOTICE,"source [%s] - %u tcp qps - %u udp qps\n",inet_ntoa(bb[i]->ip_addr),
                (u_int)ceil( ((float)bb[i]->tcp_count/delta)),
                (u_int)ceil( ((float)bb[i]->udp_count/delta)));
              }

              // reset alarm
              bb[i]->alarm_set = now;
            }
          }
        }
      }
    }		
  }
	
  // 'mark stats' if required and it is time
  delta = (u_int)(now - bb[totals]->first_packet);
  if ( (option_m > 0)&&(delta > 1)&&(delta >= option_m) ) {

    // handle bindsnap mode 
    if (option_b) {
      printf("[%s] totals - %3.2f qps tcp : %3.2f qps udp ",st_time, ((float)bb[totals]->tcp_count/delta),((float)bb[totals]->udp_count/delta));
      if (option_v) {
        for (j=0;types[j];j++) {
          qpsf = ((float)bb[totals]->qstats[types[j]]/delta);
          if (qpsf > 0){
            printf("[%3.2f qps %s] ",qpsf,names[j]);
          }
        }
      }
      printf("\n");
      fflush(stdout);
    }
    else {
      // agonizing high verbosity code
      if (option_v) {
        target = (char *)malloc(sizeof(char)*MAXSYSLOG);
        newsize = MAXSYSLOG;
        cursize = snprintf(target,newsize,"[totals] - %3.2f tcp qps : %3.2f udp qps ",
        ((float)bb[totals]->tcp_count/delta),				
        ((float)bb[totals]->udp_count/delta));
        newsize-=cursize;
	
        for (j=0;types[j];j++ ) {
          qpsf = ((float)bb[totals]->qstats[types[j]]/delta);
          if ( ( qpsf > 0)  && ( newsize > 1 ) ) {
            cursize = snprintf(target+(MAXSYSLOG-newsize),newsize,"[%3.2f qps %s] ",qpsf,names[j]);
            newsize-=cursize;
          }
        }
        if (newsize <= 0 ) {
          target[MAXSYSLOG-1]='\0';
        }
        syslog(LOG_NOTICE,"%s",target);
        free(target);
      }
      else {
        syslog(LOG_NOTICE,"[totals] - %3.2f tcp qps : %3.2f udp qps\n",
        ((float)bb[totals]->tcp_count/delta),
        ((float)bb[totals]->udp_count/delta));
      }
    }	
    scour_bucket(totals);
  }
  return 1;
}

int valid_dns_char(char c) {

  if((c >= '0' && c <= '9') 
  || (c >= 'a' && c <= 'z')
  || (c >= 'A' && c <= 'Z')
  || (c == '-') 
  || (c == '_')) // is valid for SRV records. 
    return 1;

  return 0; 
}

// purge and initialize all buckets
void init_buckets() {
	u_int i;

  // create bucket brigade (final bucket is for totals)
  pthread_mutex_lock(&stats_lock);
  if ( ( bb = malloc( sizeof(struct bucket *) * (option_x+1)) ) == NULL ) malloc_fail("bb", sizeof(struct bucket *) * (option_x+1));
  for (i=0; i <=option_x; i++ ) {
    if ( ( bb[i] = (struct bucket *)malloc( sizeof(struct bucket) ) ) == NULL) malloc_fail("bb[i]", sizeof(struct bucket) );
    scour_bucket(i);
  }
  pthread_mutex_unlock(&stats_lock);
}

// clean out a bucket while avoiding obvious memory leak
int scour_bucket( int i ) {
  int j;

  bb[i]->ip_addr.s_addr=BCAST;
  bb[i]->tcp_count=0;
  bb[i]->udp_count=0;
  bb[i]->qps=0;
  bb[i]->first_packet=time(0);
  bb[i]->last_packet=(time_t)0;
  bb[i]->alarm_set=(time_t)0;
	
  for (j=0;j<256;j++) {
    bb[i]->qstats[j]=0;
  }

  return 1;
}

// add a packet to a bucket
int add_to_bucket ( struct in_addr *ip_src, int ip_proto, int num_queries, u_int8_t qtype) {
  int bucket = 0;

  // get the bucket to put packet in	
  pthread_mutex_lock(&stats_lock);
  bucket = find_bucket(ip_src);

  // set bucket fields
  bb[bucket]->last_packet = time(0);
  if (ip_proto == 6 ) {
    bb[bucket]->tcp_count+=num_queries;
    bb[totals]->tcp_count+=num_queries;
  }
  else {
    bb[bucket]->udp_count+=num_queries;
    bb[totals]->udp_count+=num_queries;
  }

  bb[bucket]->qstats[qtype]+=num_queries;
  bb[totals]->qstats[qtype]+=num_queries;
  pthread_mutex_unlock(&stats_lock);

  return 1;
}

// figure out where to put this packet
int find_bucket(struct in_addr *ip_src) {
  int i, bucket=0;
  time_t oldest=0;

  // look for an existing bucket for this IP
  for (i=0; i< option_x; i++ ){
    // ip field of bucket seems to match the ip we are checking
    if (bb[i]->ip_addr.s_addr == ip_src->s_addr) {
      return i;
    }
  }

  // look for unused buckets
  for (i=0; i< option_x; i++ ) {

    // found an unused one - clean it, init it, and return it
    if ( bb[i]->ip_addr.s_addr == BCAST ) {
      scour_bucket(i);
      bb[i]->ip_addr.s_addr = ip_src->s_addr;
      return i;
    }

    // find the most stagnant bucket in case we need it
    // avoids another loop through the buckets
    // TODO - should we autoflush buckets after some idle time,
    //        or after alarming?  fixes the case where
    //        alarms are unlikely to reappear even if a client
    //        resumes flooding if there isn't bucket contention
    //        churning them out and resetting the timer for the rate
    //        calculation...

    if ( ( bb[i]->last_packet != 0 ) && ((oldest==0)||( bb[i]->last_packet < oldest))) {
      oldest = bb[i]->last_packet;
      bucket = i;			
    }
  }

  // use the most stagnant bucket since all are in use
  // clean it, init it, and return it
  scour_bucket(bucket);
  bb[i]->ip_addr.s_addr = ip_src->s_addr;

  return bucket;
}

// handle all packets we throw at it 
void handle_IP(u_char *args, const struct pcap_pkthdr* pkthdr,const u_char* packet){
  const struct ip* ip;
  const struct my_dns *dns;
  const struct tcphdr *tcp;
  const struct udphdr *udp;
  u_int length = pkthdr->len;
  u_int caplen = pkthdr->caplen;
  u_int hlen,off,version;
  unsigned char dname[NS_MAXDNAME]="";
  struct in_addr ip_src;
  unsigned char *data;
  u_int len,dpos;
  u_int8_t qtype,tlen;

  // skip the ethernet header
  length -= sizeof(struct ether_header); 

  // make sure packet is a valid length
  if (length < sizeof(struct ip)) {
    return;
  }

  // snap off the ip portion
  ip = (struct ip*)(packet + sizeof(struct ether_header));

  // get utility params for sanity checking
  len     = ntohs(ip->ip_len);
  hlen    = ip->ip_hl;
  version = ip->ip_v;

  // let's not do ipv6 just yet
  if(version != 4) {
    return;
  }

  // make sure we have a sane header length
  if(hlen < 5 ) {
    return;
  }

  // do we have the everything we are supposed to?
  if(length < len) {
    return;
  }

  // make sure we are only processing the first fragment
  off = ntohs(ip->ip_off);
  if((off & 0x1fff) == 0 ) {

    // get the source ip
    ip_src.s_addr = ip->ip_src.s_addr;

    // process udp packets
    if ( ip->ip_p == 17 ) {
      udp = (struct udphdr *) ( (char *) packet + sizeof(struct ether_header)+ sizeof (struct ip) );

      // try to make sure it is safe to cast packet into dns structure
      if ( (sizeof(struct my_dns)+sizeof(struct ether_header)+sizeof(struct ip)+sizeof(struct udphdr)) >= caplen ) {
        return;
      }
      else {
        // populate dns header
        dns = (struct my_dns *) ( (char *) packet + sizeof(struct ether_header) + sizeof (struct ip) + sizeof (struct udphdr) );
        data = (unsigned char *) packet +sizeof(struct ether_header) + sizeof (struct ip) + sizeof (struct udphdr) + sizeof(struct my_dns);
      }
    }

    // process tcp packets
    else if ( ip->ip_p == 6 ) {
      tcp = (struct tcphdr *) ( (char *) packet + sizeof(struct ether_header)+ sizeof (struct ip) );

      // ignore packets without push flag set
      if (! (tcp->th_flags & TH_PUSH)) return;
	
      // try to make sure it is safe to cast packet into dns structure
      if ( (sizeof(struct my_dns)+sizeof(struct ether_header)+sizeof(struct ip)+(tcp->th_off * sizeof(u_int32_t)) + sizeof(u_int16_t)) >= caplen ) {
        return;
      }
      else {
        // populate dns header
        // tcp dns lookups also include a 16bit length field = dns header + data.
        dns = (struct my_dns *) ( (char *) packet + sizeof(struct ether_header)+ sizeof (struct ip) + (tcp->th_off * sizeof(u_int32_t) + sizeof(u_int16_t)));
        data = (unsigned char *) packet + sizeof(struct ether_header) + sizeof (struct ip) + (tcp->th_off * sizeof(u_int32_t)) + sizeof(struct my_dns) + sizeof(u_int16_t);
      }
    }

    // hmm.. not tcp, not udp.. move on.
    else {
      return;
    }

    // we only want queries, not responses
    if (  dns->dns_flags1 & 0x80 ) {
      return;
    }

    // ignore packets with no questions
    if (ntohs(dns->dns_qdcount) == 0) {
      return;
    }
		
    // get the domain name and query type
    tlen=dpos=0;
    for (;(*data)&&((void *)data<((void *)packet+caplen-1)); data++) {
      if (!tlen) tlen=*data;
      for (;(tlen&&((void *)data<((void *)packet+caplen-1)));tlen--){
        data++;
        // bail on an invalid dns char
        if(!valid_dns_char(*data)) {
          return;
        }
        if (dpos<NS_MAXDNAME) dname[dpos++] = *data;
      }
      if (dpos<NS_MAXDNAME) dname[dpos++] = '.';
    }
    dname[dpos]='\0';

    // be careful not to walk past the end of the captured data
    if ( (void *)data < ((void *)packet+caplen-3) ) {
      data+=2;
      qtype = *data;
    }
    else {
      return;
    }

    if( option_D ) {
      printf("src: %-15s  proto: %s  qtype: 0x%02x  domain: %s\n", (inet_ntoa(ip_src)), 
      (ip->ip_p == 17 ? "udp" : "tcp"), qtype, dname);
    }

    // add packet to bucket array
    if (ntohs(dns->dns_qdcount)&&qtype) {
      add_to_bucket( &ip_src, ip->ip_p, 1, qtype );
    }
  }
  return;
}

// main logic
// some pcap code borrowed from http://www.cet.nau.edu/~mc8/Socket/Tutorials/section1.html
  int main(int argc,char **argv){ 
  char *dev = NULL; 
  pthread_t thread;
  char errbuf[PCAP_ERRBUF_SIZE];
  pcap_t* descr;
  struct bpf_program fp;      /* hold compiled program     */
  bpf_u_int32 maskp=0;          /* subnet mask               */
  bpf_u_int32 netp=0;           /* ip                        */
  char *filter = NULL;
  char *dst_addr = NULL;
  char *dst_mask = NULL;
  struct sigaction sa;
  struct in_addr addr,tmpaddr;
  u_int f_size;
  char *name = NULL;
  u_int c = 0;

  if ( ( name = (char *)strdup(argv[0]) ) == NULL) malloc_fail("name", strlen(argv[0]) );

  // loop through command line options and get options 
  while(1) {
    c = getopt(argc, argv,"i:t:a:w:x:m:A:M:QbdDvsh");
		
    if (c==-1) break;
    switch(c) {
      case 0:
        break;
      case 'i':
        if (optarg) {
          if ( ( dev = (char *)strdup(optarg) ) == NULL) malloc_fail("dev", strlen(optarg) );
        }
        break;
      case 't':
        if (optarg) {
          if ( abs (atoi(optarg)) > 0) {
            option_t = abs( atoi(optarg));
          }
        }
        break;
      case 'a':
        if (optarg) {
          if ( abs (atoi(optarg)) > 10) {
            option_a = abs( atoi(optarg));
          }
        }
        break;
      case 'w':
        if (optarg) {
          if ( abs (atoi(optarg)) > 1) {
            option_w = abs( atoi(optarg));
          }
        }
        break;
      case 'x':
        if (optarg) {
          if ( abs (atoi(optarg)) > 10) {
            option_x = abs( atoi(optarg));
          }
        }
        break;
      case 'm':
        if (optarg) {
          if ( abs (atoi(optarg)) > 0) {
            option_m = abs( atoi(optarg));
          }
        }
        break;
      case 'M':
        if (optarg && (dst_mask == NULL) ) {
          if ( inet_aton(optarg, &tmpaddr) ) {
            if ( ( dst_mask = (char *)strdup(optarg) ) == NULL) malloc_fail("filter mask", strlen(optarg) );
            option_M=1;
          } else {
            fprintf(stderr,"Invalid filter mask \"%s\"\n",optarg);
            option_h = 1;
          }
        }
        break;
      case 'A':
        if (optarg && (dst_addr == NULL) ) {
          if ( inet_aton(optarg, &tmpaddr) ) {
            if ( ( dst_addr = (char *)strdup(optarg) ) == NULL) malloc_fail("dest filter", strlen(optarg) );
            option_A=1;
          } else {
            fprintf(stderr,"Invalid filter address \"%s\"\n",optarg);
            option_h = 1;
          }
        }
        break;
      case 'Q':
        option_Q = 1;
        break;
      case 'b':
        option_b = 1;
        break;
      case 'd':
        option_d = 1;
        break;
      case 'D':
        option_D = 1;
         break;
      case 'v':
        option_v++;
        break;
      case 's':
        option_s = 1;
        break;
      case 'h':
        option_h = 1;
        break;
      case 'z': 
        target_ip = optarg;
        break;
      case 'p':
        target_port = atoi(optarg);
        break;
      default:
        break;
    }
  }

  // display usage info if needed
  if (optind<argc) option_h = 1;

  if (option_h) {
    fprintf(stderr,"dns_flood_detector, version %s\n",VERSION);
    fprintf(stderr,"Usage: %s [OPTION]\n\n",name);
    fprintf(stderr,"-i IFNAME                 specify device name to listen on\n");
    fprintf(stderr,"-t N                      alarm at >N queries per second\n");
    fprintf(stderr,"-a N                      reset alarm after N seconds\n");
    fprintf(stderr,"-w N                      calculate stats every N seconds\n");
    fprintf(stderr,"-x N                      create N buckets\n");
    fprintf(stderr,"-m N                      report overall stats every N seconds\n");
    fprintf(stderr,"-A addr                   filter for specific address\n");
    fprintf(stderr,"-M mask                   netmask for filter (in conjunction with -A)\n");
    fprintf(stderr,"-Q                        don't filter by local interface address\n");
    fprintf(stderr,"-b                        run in foreground in bindsnap mode\n");
    fprintf(stderr,"-d                        run in background in daemon mode\n");
    fprintf(stderr,"-D                        dump dns packets (implies -b)\n");
    fprintf(stderr,"-v                        verbose output - use again for more verbosity\n");
    fprintf(stderr,"-s                        send source-IP data to network collector as JSON\n");
    fprintf(stderr,"-z addr                   address to send stats to (default 226.1.1.2)\n");
    fprintf(stderr,"-p N                      UDP port to send stats to (default 2000)\n");	
    fprintf(stderr,"-h                        display this usage information\n");
    exit(1);
  }

  if ( target_ip == NULL ) {
    target_ip = DEFAULT_IP;
  }

  // if dumping packets, force option_b and disable option_d
  if( option_D ) {
    if( ! option_b )
      option_b = 1;
		
    if( option_d )
      option_d = 0;
  }

  if ( ( option_Q ) && ( option_A ) ) {
    fprintf(stderr,"%s couldn't start\n",name);
    fprintf(stderr,"You can't specify both -A (address filter) and -Q (no filter)\n");
    exit(1);
  }

  if ( ( ! option_d ) && ( ! option_b ) ) {
    fprintf(stderr,"%s couldn't start\n",name);
    fprintf(stderr,"You must specify either -d (daemon) or -b (bindsnap)\n");
    exit(1);
  }
  free(name);

  // set up for daemonized operation unless running in bindsnap mode
  if ( ! option_b ) {
    openlog("dns_flood_detector",LOG_PID|LOG_CONS,LOG_DAEMON);
    syslog(LOG_NOTICE,"dns_flood_detector starting");

    // daemonize unless running in bindsnap mode
    daemonize();

    // set up signal handlers
    sa.sa_handler=exit;
    sa.sa_flags=0;
    if(sigaction(SIGTERM,&sa,NULL)) {
      syslog(LOG_ERR,"Unable to set signal handler: %s.  Exiting.",strerror(errno));
    }
  }

  // find a valid device to open
  if(dev == NULL && ( (dev=pcap_lookupdev(errbuf)) == NULL ) ){
    fprintf(stderr,"unable to bind to valid device\n");
    exit(1);
  }

  /* restrict to queries to primary local address? */
  if (option_Q) {
    f_size = strlen("port 53 ");
    if ( ( filter = (char *) malloc ( f_size+1) ) == NULL ) malloc_fail( "filter", f_size+1 );
    snprintf( filter, f_size, "port 53");
  } else {
    if (! option_A) {
      // get network address and netmask for device
      pcap_lookupnet(dev,&netp,&maskp,errbuf);
		
      // set up filter with local network
      addr.s_addr = (unsigned long int)netp;
      if ( ( dst_addr = (char *)malloc( strlen((char *)inet_ntoa(addr))+1) ) == NULL ) malloc_fail("dest_addr", strlen((char *)inet_ntoa(addr))+1 );
      strncpy(dst_addr,(char*)inet_ntoa(addr),strlen((char *)inet_ntoa(addr)));
      dst_addr[strlen((char *)inet_ntoa(addr))]='\0';
		
      addr.s_addr = (unsigned long int)maskp;

      if (!option_M) {
        if ( ( dst_mask = (char *)malloc( strlen((char *)inet_ntoa(addr))+1) ) == NULL ) malloc_fail("dest_mask", strlen((char *)inet_ntoa(addr))+1 );
        strncpy(dst_mask,(char*)inet_ntoa(addr),strlen((char *)inet_ntoa(addr)));
        dst_mask[strlen((char *)inet_ntoa(addr))]='\0';
      }
    } else {
      // we're using an address from -A
      if (!option_M) {
        // if no mask was specified, then use just a host mask
        if ( ( dst_mask = (char *)malloc(16) ) == NULL ) malloc_fail("dest_mask", 16);
        strncpy(dst_mask,"255.255.255.255",15);
      }
    }
	
    f_size = strlen("port 53 and dst net mask   ")+ strlen(dst_mask)+ strlen(dst_addr);
    if ( ( filter = (char *) malloc ( f_size+1) ) == NULL ) malloc_fail( "filter", f_size+1 );
    snprintf( filter, f_size, "port 53 and dst net %s mask %s", dst_addr, dst_mask);
	
    free (dst_mask);
    free (dst_addr);
  }

  if ( option_b && option_v ) {
    printf("using filter \"%s\" on dev %s\n", filter, dev);
  }

  // open device for reading only local traffic
  descr = pcap_open_live(dev,1500,0,1,errbuf);
  if(descr == NULL) { 
    fprintf(stderr,"unable to open device %s\n",dev);
    exit(1);
  }

  // compile filter
  if(pcap_compile(descr,&fp,filter,0,netp) == -1) { 
    fprintf(stderr,"error compiling filter: %s\n",pcap_geterr(descr));
    exit(1);
  }

  // set filter
  if(pcap_setfilter(descr,&fp) == -1){ 
    fprintf(stderr,"error setting filter: %s\n",pcap_geterr(descr));
    exit(1); 
  }

  // initialize buckets and mark overall stats bucket
  init_buckets();
  totals = option_x;

  // create mutex lock
  if (pthread_mutex_init(&stats_lock, NULL) < 0) {
    exit(1);
  }

  // launch watcher thread
  if (pthread_create (&thread, NULL, run_stats, (void *)0)) {
    exit(1);
  }

  // main pcap loop
  pcap_loop(descr,-1,&handle_IP,NULL);

  // done
  closelog();
  return 0;
}

// daemonize the process
int daemonize(void) {
  pid_t pid;
  int fd;   
  int a;

  fd=open("/dev/null",O_RDWR);
  if(fd<0) {
    syslog(LOG_ERR,"Failed to open /dev/null: %s.  Exiting.",strerror(errno));
    exit(1); 
  }
 
  dup2(fd,0);
  dup2(fd,1);
  dup2(fd,2);

  if((pid=fork())<0) {
    syslog(LOG_ERR,"Fork failed: %s.  Exiting.",strerror(errno));
    exit(1);
  } 
  else if (pid!=0) {
    exit(0);
  }
           
  setsid();  
  a = chdir("/");
  umask(0);
  return 0;  
}

int malloc_fail( char * var, int size ) {
  // print error to stderr if running in bindsnap mode
  if (option_b) {
    fprintf(stderr, "our OS wouldn't let me malloc %d bytes for a new %s. giving up", size, var);
  }
  else {
    syslog(LOG_ERR, "our OS wouldn't let me malloc %d bytes for a new %s. giving up", size, var);
  }
  exit(1);
}

int microsleep(unsigned int usec) {
  struct timeval        timeout;
  timeout.tv_sec = usec / 1000000;
  timeout.tv_usec = usec % 1000000;

  while ((select(0, (fd_set *) 0, (fd_set *) 0,(fd_set *) 0, &timeout) < 0) && (errno == EINTR));
  return(0);
}