2 * netsniff-ng - the packet sniffing beast
3 * By Daniel Borkmann <daniel@netsniff-ng.org>
4 * Copyright 2009-2011 Daniel Borkmann.
5 * Copyright 2010 Emmanuel Roullit.
6 * Subject to the GPL, version 2.
8 * The first sniffer that invoked both, the zero-copy RX_RING as well as
9 * the zero-copy TX_RING for high-performance network I/O and scatter/gather
12 * "I knew that danger lay ahead, of course; but I did not expect to
13 * meet it in our own Shire. Can't a hobbit walk from the Water to the
14 * River in peace?" "But it is not your own Shire," said Gildor. "Others
15 * dwelt here before hobbits were; and others will dwell here again when
16 * hobbits are no more. The wide world is all about you: you can fence
17 * yourselves in, but you cannot for ever fence it out."
19 * -- The Lord of the Rings, Gildor to Frodo,
20 * Chapter 'Three is Company'.
27 netsniff-ng - the packet sniffing beast
31 netsniff-ng -i|-d|--dev|--in <dev|pcap> -o|--out <dev|pcap|dir|txf>
32 [-f|--filter <bpf-file>][-t|--type <type>][-F|--interval <uint>]
33 [-s|--silent][-J|--jumbo-support][-n|--num <uint>][-r|--rand]
34 [-M|--no-promisc][-m|--mmap | -c|--clrw][-S|--ring-size <size>]
35 [-k|--kernel-pull <uint>][-b|--bind-cpu <cpu> | -B|--unbind-cpu <cpu>]
36 [-H|--prio-high][-Q|--notouch-irq][-q|--less | -X|--hex | -l|--ascii]
37 [-v|--version][-h|--help]
41 The first sniffer that invoked both, the zero-copy RX_RING as well as
42 the zero-copy TX_RING for high-performance network I/O and scatter/gather
49 =item netsniff-ng --in eth0 --out dump.pcap
51 Capture traffic from interface 'eth0' and save it pcap file 'dump.pcap'
53 =item netsniff-ng --in any --filter http.bpf --payload
55 Capture HTTP traffic from any interface and print its payload on stdout
57 =item netsniff-ng --in wlan0 --bind-cpu 0,1
59 Capture all traffic from wlan0 interface.
60 Schedule process on CPU 0 and 1.
68 =item -i|-d|--dev|--in <dev|pcap>
70 Input source. Can be a network device or pcap file.
72 =item -o|--out <dev|pcap|dir|txf>
74 Output sink. Can be a network device, pcap file, a trafgen txf file or a
75 directory. (There's only pcap to txf translation possible.)
77 =item -f|--filter <bpf-file>
79 Use BPF filter file from bpfc.
81 =item -t|--type <type>
85 =item Only handle packets of defined type:
101 =item -F|--interval <uint>
103 Dump interval in seconds. if -o is a directory, a new pcap will be created at each interval.
104 The older files are left untouched. (default value: 60 seconds)
108 Do not print captured packets to stdout.
110 =item -J|--jumbo-support
112 Support for 64KB Super Jumbo Frames.
114 =item -n|--num <uint>
116 When zerp, capture/replay until SIGINT is received (default).
117 When non-zero, capture/replay the number of packets.
121 Randomize packet forwarding order (replay mode only).
123 =item -M|--no-promisc
125 Do not place the interface in promiscuous mode.
129 Mmap pcap file i.e., for replaying. Default: scatter/gather I/O.
133 Instead of using scatter/gather I/O use slower read(2)/write(2) I/O.
135 =item -S|--ring-size <size>
137 Manually set ring size in KB/MB/GB, e.g. '10MB'.
139 =item -k|--kernel-pull <uint>
141 Kernel pull from user interval in microseconds. Default is 10us. (replay mode only).
143 =item -b|--bind-cpu <cpu>
145 Bind to specific CPU (or CPU-range).
147 =item -B|--unbind-cpu <cpu>
149 Forbid to use specific CPU (or CPU-range).
153 Run the process in high-priority mode.
155 =item -Q|--notouch-irq
157 Do not touch IRQ CPU affinity of NIC.
161 Print less-verbose packet information.
165 Print packet data in hex format.
169 Print human-readable packet data.
177 Print help text and lists all options.
183 Written by Daniel Borkmann <daniel@netsniff-ng.org> and Emmanuel Roullit <emmanuel@netsniff-ng.org>
187 Documentation by Emmanuel Roullit <emmanuel@netsniff-ng.org>
191 Please report bugs to <bugs@netsniff-ng.org>
205 #include <sys/socket.h>
206 #include <sys/types.h>
207 #include <sys/stat.h>
208 #include <sys/time.h>
216 #include "mac80211.h"
218 #include "built_in.h"
224 #include "dissector.h"
228 #define CPU_UNKNOWN -1
229 #define CPU_NOTOUCH -2
230 #define PACKET_ALL -1
231 #define DUMP_INTERVAL 60
243 unsigned int reserve_size
;
247 enum pcap_ops_groups pcap
;
251 unsigned long dump_interval
;
255 unsigned long tx_bytes
;
256 unsigned long tx_packets
;
259 volatile sig_atomic_t sigint
= 0;
262 static unsigned long frame_cnt_max
= 0;
263 static unsigned long interval
= TX_KERNEL_PULL_INT
;
264 static struct itimerval itimer
;
265 static volatile bool next_dump
= false;
267 static const char *short_options
= "d:i:o:rf:MJt:S:k:n:b:B:HQmcsqXlvhF:RgA";
269 static struct option long_options
[] = {
270 {"dev", required_argument
, 0, 'd'},
271 {"in", required_argument
, 0, 'i'},
272 {"out", required_argument
, 0, 'o'},
273 {"rand", no_argument
, 0, 'r'},
274 {"rfraw", no_argument
, 0, 'R'},
275 {"mmap", no_argument
, 0, 'm'},
276 {"sg", no_argument
, 0, 'g'},
277 {"clrw", no_argument
, 0, 'c'},
278 {"jumbo-support", no_argument
, 0, 'J'},
279 {"filter", required_argument
, 0, 'f'},
280 {"no-promisc", no_argument
, 0, 'M'},
281 {"num", required_argument
, 0, 'n'},
282 {"type", required_argument
, 0, 't'},
283 {"interval", required_argument
, 0, 'F'},
284 {"ring-size", required_argument
, 0, 'S'},
285 {"kernel-pull", required_argument
, 0, 'k'},
286 {"bind-cpu", required_argument
, 0, 'b'},
287 {"unbind-cpu", required_argument
, 0, 'B'},
288 {"prio-high", no_argument
, 0, 'H'},
289 {"notouch-irq", no_argument
, 0, 'Q'},
290 {"silent", no_argument
, 0, 's'},
291 {"less", no_argument
, 0, 'q'},
292 {"hex", no_argument
, 0, 'X'},
293 {"ascii", no_argument
, 0, 'l'},
294 {"no-sock-mem", no_argument
, 0, 'A'},
295 {"version", no_argument
, 0, 'v'},
296 {"help", no_argument
, 0, 'h'},
300 static void signal_handler(int number
)
313 static void timer_elapsed(int number
)
315 itimer
.it_interval
.tv_sec
= 0;
316 itimer
.it_interval
.tv_usec
= interval
;
317 itimer
.it_value
.tv_sec
= 0;
318 itimer
.it_value
.tv_usec
= interval
;
320 pull_and_flush_tx_ring(tx_sock
);
321 setitimer(ITIMER_REAL
, &itimer
, NULL
);
324 static void timer_next_dump(int number
)
326 itimer
.it_interval
.tv_sec
= interval
;
327 itimer
.it_interval
.tv_usec
= 0;
328 itimer
.it_value
.tv_sec
= interval
;
329 itimer
.it_value
.tv_usec
= 0;
332 setitimer(ITIMER_REAL
, &itimer
, NULL
);
335 static void enter_mode_pcap_to_tx(struct mode
*mode
)
337 int irq
, ifindex
, fd
= 0, ret
;
338 unsigned int size
, it
= 0;
340 struct frame_map
*hdr
;
341 struct sock_fprog bpf_ops
;
342 struct tx_stats stats
;
344 unsigned long trunced
= 0;
345 struct timeval start
, end
, diff
;
347 if (!device_up_and_running(mode
->device_out
))
348 panic("Device not up and running!\n");
350 tx_sock
= pf_socket();
352 if (!pcap_ops
[mode
->pcap
])
353 panic("pcap group not supported!\n");
354 fd
= open_or_die(mode
->device_in
, O_RDONLY
| O_LARGEFILE
| O_NOATIME
);
355 ret
= pcap_ops
[mode
->pcap
]->pull_file_header(fd
, &mode
->link_type
);
357 panic("error reading pcap header!\n");
358 if (pcap_ops
[mode
->pcap
]->prepare_reading_pcap
) {
359 ret
= pcap_ops
[mode
->pcap
]->prepare_reading_pcap(fd
);
361 panic("error prepare reading pcap!\n");
364 fmemset(&tx_ring
, 0, sizeof(tx_ring
));
365 fmemset(&bpf_ops
, 0, sizeof(bpf_ops
));
366 fmemset(&stats
, 0, sizeof(stats
));
369 mode
->device_trans
= xstrdup(mode
->device_out
);
370 xfree(mode
->device_out
);
372 enter_rfmon_mac80211(mode
->device_trans
, &mode
->device_out
);
373 if (mode
->link_type
!= LINKTYPE_IEEE802_11
)
374 panic("Wrong linktype of pcap!\n");
377 ifindex
= device_ifindex(mode
->device_out
);
378 size
= ring_size(mode
->device_out
, mode
->reserve_size
);
380 bpf_parse_rules(mode
->filter
, &bpf_ops
);
382 set_packet_loss_discard(tx_sock
);
383 set_sockopt_hwtimestamp(tx_sock
, mode
->device_out
);
384 setup_tx_ring_layout(tx_sock
, &tx_ring
, size
, mode
->jumbo_support
);
385 create_tx_ring(tx_sock
, &tx_ring
);
386 mmap_tx_ring(tx_sock
, &tx_ring
);
387 alloc_tx_ring_frames(&tx_ring
);
388 bind_tx_ring(tx_sock
, &tx_ring
, ifindex
);
390 dissector_init_all(mode
->print_mode
);
392 if (mode
->cpu
>= 0 && ifindex
> 0) {
393 irq
= device_irq_number(mode
->device_out
);
394 device_bind_irq_to_cpu(mode
->cpu
, irq
);
395 printf("IRQ: %s:%d > CPU%d\n", mode
->device_out
, irq
,
400 interval
= mode
->kpull
;
402 itimer
.it_interval
.tv_sec
= 0;
403 itimer
.it_interval
.tv_usec
= interval
;
404 itimer
.it_value
.tv_sec
= 0;
405 itimer
.it_value
.tv_usec
= interval
;
406 setitimer(ITIMER_REAL
, &itimer
, NULL
);
409 bpf_dump_all(&bpf_ops
);
410 printf("MD: TX %luus %s ", interval
, pcap_ops
[mode
->pcap
]->name
);
412 printf("802.11 raw via %s ", mode
->device_out
);
413 #ifdef _LARGEFILE64_SOURCE
419 gettimeofday(&start
, NULL
);
421 while (likely(sigint
== 0)) {
422 while (user_may_pull_from_tx(tx_ring
.frames
[it
].iov_base
)) {
423 struct pcap_pkthdr phdr
;
424 hdr
= tx_ring
.frames
[it
].iov_base
;
425 /* Kernel assumes: data = ph.raw + po->tp_hdrlen -
426 * sizeof(struct sockaddr_ll); */
427 out
= ((uint8_t *) hdr
) + TPACKET_HDRLEN
-
428 sizeof(struct sockaddr_ll
);
431 memset(&phdr
, 0, sizeof(phdr
));
432 ret
= pcap_ops
[mode
->pcap
]->read_pcap_pkt(fd
, &phdr
,
433 out
, ring_frame_size(&tx_ring
));
434 if (unlikely(ret
<= 0))
436 if (ring_frame_size(&tx_ring
) < phdr
.len
) {
437 phdr
.len
= ring_frame_size(&tx_ring
);
440 } while (mode
->filter
&& !bpf_run_filter(&bpf_ops
, out
, phdr
.len
));
441 pcap_pkthdr_to_tpacket_hdr(&phdr
, &hdr
->tp_h
);
443 stats
.tx_bytes
+= hdr
->tp_h
.tp_len
;;
446 show_frame_hdr(hdr
, mode
->print_mode
, RING_MODE_EGRESS
);
447 dissector_entry_point(out
, hdr
->tp_h
.tp_snaplen
,
448 mode
->link_type
, mode
->print_mode
);
450 kernel_may_pull_from_tx(&hdr
->tp_h
);
451 next_slot_prewr(&it
, &tx_ring
);
453 if (unlikely(sigint
== 1))
455 if (frame_cnt_max
!= 0 &&
456 stats
.tx_packets
>= frame_cnt_max
) {
463 gettimeofday(&end
, NULL
);
464 diff
= tv_subtract(end
, start
);
468 printf("\r%12lu frames outgoing\n", stats
.tx_packets
);
469 printf("\r%12lu frames truncated (larger than frame)\n", trunced
);
470 printf("\r%12lu bytes outgoing\n", stats
.tx_bytes
);
471 printf("\r%12lu sec, %lu usec in total\n", diff
.tv_sec
, diff
.tv_usec
);
473 bpf_release(&bpf_ops
);
474 dissector_cleanup_all();
475 destroy_tx_ring(tx_sock
, &tx_ring
);
478 leave_rfmon_mac80211(mode
->device_trans
, mode
->device_out
);
481 if (pcap_ops
[mode
->pcap
]->prepare_close_pcap
)
482 pcap_ops
[mode
->pcap
]->prepare_close_pcap(fd
, PCAP_MODE_READ
);
486 static void enter_mode_rx_to_tx(struct mode
*mode
)
488 int rx_sock
, ifindex_in
, ifindex_out
;
489 unsigned int size_in
, size_out
, it_in
= 0, it_out
= 0;
490 unsigned long fcnt
= 0;
493 struct frame_map
*hdr_in
, *hdr_out
;
496 struct pollfd rx_poll
;
497 struct sock_fprog bpf_ops
;
499 if (!strncmp(mode
->device_in
, mode
->device_out
,
500 strlen(mode
->device_in
)))
501 panic("Ingress/egress devices must be different!\n");
502 if (!device_up_and_running(mode
->device_out
))
503 panic("Egress device not up and running!\n");
504 if (!device_up_and_running(mode
->device_in
))
505 panic("Ingress device not up and running!\n");
507 rx_sock
= pf_socket();
508 tx_sock
= pf_socket();
510 fmemset(&tx_ring
, 0, sizeof(tx_ring
));
511 fmemset(&rx_ring
, 0, sizeof(rx_ring
));
512 fmemset(&rx_poll
, 0, sizeof(rx_poll
));
513 fmemset(&bpf_ops
, 0, sizeof(bpf_ops
));
515 ifindex_in
= device_ifindex(mode
->device_in
);
516 size_in
= ring_size(mode
->device_in
, mode
->reserve_size
);
518 ifindex_out
= device_ifindex(mode
->device_out
);
519 size_out
= ring_size(mode
->device_out
, mode
->reserve_size
);
521 enable_kernel_bpf_jit_compiler();
522 bpf_parse_rules(mode
->filter
, &bpf_ops
);
523 bpf_attach_to_sock(rx_sock
, &bpf_ops
);
525 setup_rx_ring_layout(rx_sock
, &rx_ring
, size_in
, mode
->jumbo_support
);
526 create_rx_ring(rx_sock
, &rx_ring
);
527 mmap_rx_ring(rx_sock
, &rx_ring
);
528 alloc_rx_ring_frames(&rx_ring
);
529 bind_rx_ring(rx_sock
, &rx_ring
, ifindex_in
);
530 prepare_polling(rx_sock
, &rx_poll
);
532 set_packet_loss_discard(tx_sock
);
533 setup_tx_ring_layout(tx_sock
, &tx_ring
, size_out
, mode
->jumbo_support
);
534 create_tx_ring(tx_sock
, &tx_ring
);
535 mmap_tx_ring(tx_sock
, &tx_ring
);
536 alloc_tx_ring_frames(&tx_ring
);
537 bind_tx_ring(tx_sock
, &tx_ring
, ifindex_out
);
539 mt_init_by_seed_time();
540 dissector_init_all(mode
->print_mode
);
542 if (mode
->promiscuous
== true) {
543 ifflags
= enter_promiscuous_mode(mode
->device_in
);
548 interval
= mode
->kpull
;
550 itimer
.it_interval
.tv_sec
= 0;
551 itimer
.it_interval
.tv_usec
= interval
;
552 itimer
.it_value
.tv_sec
= 0;
553 itimer
.it_value
.tv_usec
= interval
;
554 setitimer(ITIMER_REAL
, &itimer
, NULL
);
557 bpf_dump_all(&bpf_ops
);
558 printf("MD: RXTX %luus\n\n", interval
);
559 printf("Running! Hang up with ^C!\n\n");
561 while (likely(sigint
== 0)) {
562 while (user_may_pull_from_rx(rx_ring
.frames
[it_in
].iov_base
)) {
563 hdr_in
= rx_ring
.frames
[it_in
].iov_base
;
564 in
= ((uint8_t *) hdr_in
) + hdr_in
->tp_h
.tp_mac
;
566 if (mode
->packet_type
!= PACKET_ALL
)
567 if (mode
->packet_type
!= hdr_in
->s_ll
.sll_pkttype
)
570 hdr_out
= tx_ring
.frames
[it_out
].iov_base
;
571 out
= ((uint8_t *) hdr_out
) + TPACKET_HDRLEN
-
572 sizeof(struct sockaddr_ll
);
574 for (; !user_may_pull_from_tx(tx_ring
.frames
[it_out
].iov_base
) &&
577 next_rnd_slot(&it_out
, &tx_ring
);
579 next_slot(&it_out
, &tx_ring
);
580 hdr_out
= tx_ring
.frames
[it_out
].iov_base
;
581 out
= ((uint8_t *) hdr_out
) + TPACKET_HDRLEN
-
582 sizeof(struct sockaddr_ll
);
585 tpacket_hdr_clone(&hdr_out
->tp_h
, &hdr_in
->tp_h
);
586 fmemcpy(out
, in
, hdr_in
->tp_h
.tp_len
);
588 kernel_may_pull_from_tx(&hdr_out
->tp_h
);
590 next_rnd_slot(&it_out
, &tx_ring
);
592 next_slot(&it_out
, &tx_ring
);
594 show_frame_hdr(hdr_in
, mode
->print_mode
, RING_MODE_INGRESS
);
595 dissector_entry_point(in
, hdr_in
->tp_h
.tp_snaplen
,
596 mode
->link_type
, mode
->print_mode
);
598 if (frame_cnt_max
!= 0 && fcnt
>= frame_cnt_max
) {
603 kernel_may_pull_from_rx(&hdr_in
->tp_h
);
604 next_slot(&it_in
, &rx_ring
);
606 if (unlikely(sigint
== 1))
610 poll(&rx_poll
, 1, -1);
611 poll_error_maybe_die(rx_sock
, &rx_poll
);
614 sock_print_net_stats(rx_sock
, 0);
616 bpf_release(&bpf_ops
);
617 dissector_cleanup_all();
618 destroy_tx_ring(tx_sock
, &tx_ring
);
619 destroy_rx_ring(rx_sock
, &rx_ring
);
621 if (mode
->promiscuous
== true)
622 leave_promiscuous_mode(mode
->device_in
, ifflags
);
628 static void enter_mode_read_pcap(struct mode
*mode
)
630 int ret
, fd
, fdo
= 0;
631 struct pcap_pkthdr phdr
;
632 struct sock_fprog bpf_ops
;
633 struct tx_stats stats
;
637 unsigned long trunced
= 0;
638 struct timeval start
, end
, diff
;
640 if (!pcap_ops
[mode
->pcap
])
641 panic("pcap group not supported!\n");
642 fd
= open_or_die(mode
->device_in
, O_RDONLY
| O_LARGEFILE
| O_NOATIME
);
643 ret
= pcap_ops
[mode
->pcap
]->pull_file_header(fd
, &mode
->link_type
);
645 panic("error reading pcap header!\n");
646 if (pcap_ops
[mode
->pcap
]->prepare_reading_pcap
) {
647 ret
= pcap_ops
[mode
->pcap
]->prepare_reading_pcap(fd
);
649 panic("error prepare reading pcap!\n");
652 fmemset(&fm
, 0, sizeof(fm
));
653 fmemset(&bpf_ops
, 0, sizeof(bpf_ops
));
654 fmemset(&stats
, 0, sizeof(stats
));
656 bpf_parse_rules(mode
->filter
, &bpf_ops
);
657 dissector_init_all(mode
->print_mode
);
660 out
= xmalloc_aligned(out_len
, CO_CACHE_LINE_SIZE
);
663 bpf_dump_all(&bpf_ops
);
664 printf("MD: RD %s ", pcap_ops
[mode
->pcap
]->name
);
665 #ifdef _LARGEFILE64_SOURCE
671 if (mode
->device_out
) {
672 fdo
= open_or_die_m(mode
->device_out
, O_RDWR
| O_CREAT
|
673 O_TRUNC
| O_LARGEFILE
, DEFFILEMODE
);
676 gettimeofday(&start
, NULL
);
678 while (likely(sigint
== 0)) {
680 memset(&phdr
, 0, sizeof(phdr
));
681 ret
= pcap_ops
[mode
->pcap
]->read_pcap_pkt(fd
, &phdr
,
683 if (unlikely(ret
< 0))
685 if (unlikely(phdr
.len
== 0)) {
689 if (unlikely(phdr
.len
> out_len
)) {
693 } while (mode
->filter
&&
694 !bpf_run_filter(&bpf_ops
, out
, phdr
.len
));
696 pcap_pkthdr_to_tpacket_hdr(&phdr
, &fm
.tp_h
);
698 stats
.tx_bytes
+= fm
.tp_h
.tp_len
;
701 show_frame_hdr(&fm
, mode
->print_mode
, RING_MODE_EGRESS
);
702 dissector_entry_point(out
, fm
.tp_h
.tp_snaplen
,
703 mode
->link_type
, mode
->print_mode
);
705 if (mode
->device_out
) {
708 slprintf(bout
, sizeof(bout
), "{\n ");
709 write_or_die(fdo
, bout
, strlen(bout
));
711 while (i
< fm
.tp_h
.tp_snaplen
) {
712 slprintf(bout
, sizeof(bout
), "0x%02x, ", out
[i
]);
713 write_or_die(fdo
, bout
, strlen(bout
));
716 slprintf(bout
, sizeof(bout
), "\n", out
[i
]);
717 write_or_die(fdo
, bout
, strlen(bout
));
718 if (i
< fm
.tp_h
.tp_snaplen
) {
719 slprintf(bout
, sizeof(bout
), " ", out
[i
]);
720 write_or_die(fdo
, bout
, strlen(bout
));
725 slprintf(bout
, sizeof(bout
), "\n");
726 write_or_die(fdo
, bout
, strlen(bout
));
728 slprintf(bout
, sizeof(bout
), "}\n\n");
729 write_or_die(fdo
, bout
, strlen(bout
));
732 if (frame_cnt_max
!= 0 &&
733 stats
.tx_packets
>= frame_cnt_max
) {
739 gettimeofday(&end
, NULL
);
740 diff
= tv_subtract(end
, start
);
744 printf("\r%12lu frames outgoing\n", stats
.tx_packets
);
745 printf("\r%12lu frames truncated (larger than mtu)\n", trunced
);
746 printf("\r%12lu bytes outgoing\n", stats
.tx_bytes
);
747 printf("\r%12lu sec, %lu usec in total\n", diff
.tv_sec
, diff
.tv_usec
);
751 bpf_release(&bpf_ops
);
752 dissector_cleanup_all();
753 if (pcap_ops
[mode
->pcap
]->prepare_close_pcap
)
754 pcap_ops
[mode
->pcap
]->prepare_close_pcap(fd
, PCAP_MODE_READ
);
757 if (mode
->device_out
)
761 static void finish_multi_pcap_file(struct mode
*mode
, int fd
)
763 pcap_ops
[mode
->pcap
]->fsync_pcap(fd
);
764 if (pcap_ops
[mode
->pcap
]->prepare_close_pcap
)
765 pcap_ops
[mode
->pcap
]->prepare_close_pcap(fd
, PCAP_MODE_WRITE
);
768 fmemset(&itimer
, 0, sizeof(itimer
));
769 setitimer(ITIMER_REAL
, &itimer
, NULL
);
772 static int next_multi_pcap_file(struct mode
*mode
, int fd
)
777 pcap_ops
[mode
->pcap
]->fsync_pcap(fd
);
778 if (pcap_ops
[mode
->pcap
]->prepare_close_pcap
)
779 pcap_ops
[mode
->pcap
]->prepare_close_pcap(fd
, PCAP_MODE_WRITE
);
782 slprintf(tmp
, sizeof(tmp
), "%s/%lu.pcap", mode
->device_out
, time(0));
784 fd
= open_or_die_m(tmp
, O_RDWR
| O_CREAT
| O_TRUNC
| O_LARGEFILE
,
786 ret
= pcap_ops
[mode
->pcap
]->push_file_header(fd
, mode
->link_type
);
788 panic("error writing pcap header!\n");
789 if (pcap_ops
[mode
->pcap
]->prepare_writing_pcap
) {
790 ret
= pcap_ops
[mode
->pcap
]->prepare_writing_pcap(fd
);
792 panic("error prepare writing pcap!\n");
798 static int begin_multi_pcap_file(struct mode
*mode
)
803 if (!pcap_ops
[mode
->pcap
])
804 panic("pcap group not supported!\n");
805 if (mode
->device_out
[strlen(mode
->device_out
) - 1] == '/')
806 mode
->device_out
[strlen(mode
->device_out
) - 1] = 0;
808 slprintf(tmp
, sizeof(tmp
), "%s/%lu.pcap", mode
->device_out
, time(0));
810 fd
= open_or_die_m(tmp
, O_RDWR
| O_CREAT
| O_TRUNC
| O_LARGEFILE
,
812 ret
= pcap_ops
[mode
->pcap
]->push_file_header(fd
, mode
->link_type
);
814 panic("error writing pcap header!\n");
815 if (pcap_ops
[mode
->pcap
]->prepare_writing_pcap
) {
816 ret
= pcap_ops
[mode
->pcap
]->prepare_writing_pcap(fd
);
818 panic("error prepare writing pcap!\n");
821 interval
= mode
->dump_interval
;
822 itimer
.it_interval
.tv_sec
= interval
;
823 itimer
.it_interval
.tv_usec
= 0;
824 itimer
.it_value
.tv_sec
= interval
;
825 itimer
.it_value
.tv_usec
= 0;
826 setitimer(ITIMER_REAL
, &itimer
, NULL
);
831 static void finish_single_pcap_file(struct mode
*mode
, int fd
)
833 pcap_ops
[mode
->pcap
]->fsync_pcap(fd
);
834 if (pcap_ops
[mode
->pcap
]->prepare_close_pcap
)
835 pcap_ops
[mode
->pcap
]->prepare_close_pcap(fd
, PCAP_MODE_WRITE
);
839 static int begin_single_pcap_file(struct mode
*mode
)
843 if (!pcap_ops
[mode
->pcap
])
844 panic("pcap group not supported!\n");
845 fd
= open_or_die_m(mode
->device_out
,
846 O_RDWR
| O_CREAT
| O_TRUNC
| O_LARGEFILE
,
848 ret
= pcap_ops
[mode
->pcap
]->push_file_header(fd
, mode
->link_type
);
850 panic("error writing pcap header!\n");
851 if (pcap_ops
[mode
->pcap
]->prepare_writing_pcap
) {
852 ret
= pcap_ops
[mode
->pcap
]->prepare_writing_pcap(fd
);
854 panic("error prepare writing pcap!\n");
860 static void enter_mode_rx_only_or_dump(struct mode
*mode
)
862 int sock
, irq
, ifindex
, fd
= 0, ret
;
863 unsigned int size
, it
= 0;
864 unsigned long fcnt
= 0, skipped
= 0;
868 struct pollfd rx_poll
;
869 struct frame_map
*hdr
;
870 struct sock_fprog bpf_ops
;
871 struct timeval start
, end
, diff
;
873 if (!device_up_and_running(mode
->device_in
))
874 panic("Device not up and running!\n");
879 mode
->device_trans
= xstrdup(mode
->device_in
);
880 xfree(mode
->device_in
);
882 enter_rfmon_mac80211(mode
->device_trans
, &mode
->device_in
);
883 mode
->link_type
= LINKTYPE_IEEE802_11
;
888 fmemset(&tmp
, 0, sizeof(tmp
));
889 ret
= stat(mode
->device_out
, &tmp
);
894 mode
->dump_dir
= !!S_ISDIR(tmp
.st_mode
);
895 if (mode
->dump_dir
) {
896 fd
= begin_multi_pcap_file(mode
);
899 fd
= begin_single_pcap_file(mode
);
903 fmemset(&rx_ring
, 0, sizeof(rx_ring
));
904 fmemset(&rx_poll
, 0, sizeof(rx_poll
));
905 fmemset(&bpf_ops
, 0, sizeof(bpf_ops
));
907 ifindex
= device_ifindex(mode
->device_in
);
908 size
= ring_size(mode
->device_in
, mode
->reserve_size
);
910 enable_kernel_bpf_jit_compiler();
911 bpf_parse_rules(mode
->filter
, &bpf_ops
);
912 bpf_attach_to_sock(sock
, &bpf_ops
);
914 set_sockopt_hwtimestamp(sock
, mode
->device_in
);
915 setup_rx_ring_layout(sock
, &rx_ring
, size
, mode
->jumbo_support
);
916 create_rx_ring(sock
, &rx_ring
);
917 mmap_rx_ring(sock
, &rx_ring
);
918 alloc_rx_ring_frames(&rx_ring
);
919 bind_rx_ring(sock
, &rx_ring
, ifindex
);
921 prepare_polling(sock
, &rx_poll
);
922 dissector_init_all(mode
->print_mode
);
924 if (mode
->cpu
>= 0 && ifindex
> 0) {
925 irq
= device_irq_number(mode
->device_in
);
926 device_bind_irq_to_cpu(mode
->cpu
, irq
);
927 printf("IRQ: %s:%d > CPU%d\n", mode
->device_in
, irq
,
931 if (mode
->promiscuous
== true) {
932 ifflags
= enter_promiscuous_mode(mode
->device_in
);
937 bpf_dump_all(&bpf_ops
);
938 printf("MD: RX %s ", mode
->dump
? pcap_ops
[mode
->pcap
]->name
: "");
940 printf("802.11 raw via %s ", mode
->device_in
);
941 #ifdef _LARGEFILE64_SOURCE
947 gettimeofday(&start
, NULL
);
949 while (likely(sigint
== 0)) {
950 while (user_may_pull_from_rx(rx_ring
.frames
[it
].iov_base
)) {
951 hdr
= rx_ring
.frames
[it
].iov_base
;
952 packet
= ((uint8_t *) hdr
) + hdr
->tp_h
.tp_mac
;
955 if (mode
->packet_type
!= PACKET_ALL
)
956 if (mode
->packet_type
!= hdr
->s_ll
.sll_pkttype
)
958 if (unlikely(ring_frame_size(&rx_ring
) <
959 hdr
->tp_h
.tp_snaplen
)) {
964 struct pcap_pkthdr phdr
;
965 tpacket_hdr_to_pcap_pkthdr(&hdr
->tp_h
, &phdr
);
966 ret
= pcap_ops
[mode
->pcap
]->write_pcap_pkt(fd
, &phdr
,
968 if (unlikely(ret
!= sizeof(phdr
) + phdr
.len
))
969 panic("Write error to pcap!\n");
972 show_frame_hdr(hdr
, mode
->print_mode
, RING_MODE_INGRESS
);
973 dissector_entry_point(packet
, hdr
->tp_h
.tp_snaplen
,
974 mode
->link_type
, mode
->print_mode
);
976 if (frame_cnt_max
!= 0 && fcnt
>= frame_cnt_max
) {
981 kernel_may_pull_from_rx(&hdr
->tp_h
);
982 next_slot_prerd(&it
, &rx_ring
);
984 if (unlikely(sigint
== 1))
986 if (mode
->dump
&& next_dump
) {
987 struct tpacket_stats kstats
;
988 socklen_t slen
= sizeof(kstats
);
989 fmemset(&kstats
, 0, sizeof(kstats
));
990 getsockopt(sock
, SOL_PACKET
, PACKET_STATISTICS
,
992 fd
= next_multi_pcap_file(mode
, fd
);
994 if (mode
->print_mode
== FNTTYPE_PRINT_NONE
) {
995 printf(".(+%lu/-%lu)",
996 1UL * kstats
.tp_packets
-
998 skipped
, 1UL * kstats
.tp_drops
+
1005 poll(&rx_poll
, 1, -1);
1006 poll_error_maybe_die(sock
, &rx_poll
);
1009 gettimeofday(&end
, NULL
);
1010 diff
= tv_subtract(end
, start
);
1012 if (!(mode
->dump_dir
&& mode
->print_mode
== FNTTYPE_PRINT_NONE
)) {
1013 sock_print_net_stats(sock
, skipped
);
1014 printf("\r%12lu sec, %lu usec in total\n", diff
.tv_sec
,
1021 bpf_release(&bpf_ops
);
1022 dissector_cleanup_all();
1023 destroy_rx_ring(sock
, &rx_ring
);
1025 if (mode
->promiscuous
== true)
1026 leave_promiscuous_mode(mode
->device_in
, ifflags
);
1029 leave_rfmon_mac80211(mode
->device_trans
, mode
->device_in
);
1035 finish_multi_pcap_file(mode
, fd
);
1037 finish_single_pcap_file(mode
, fd
);
1041 static void help(void)
1043 printf("\n%s %s, the packet sniffing beast\n", PROGNAME_STRING
,
1045 printf("http://www.netsniff-ng.org\n\n");
1046 printf("Usage: netsniff-ng [options]\n");
1047 printf("Options:\n");
1048 printf(" -i|-d|--dev|--in <dev|pcap> Input source as netdev or pcap\n");
1049 printf(" -o|--out <dev|pcap|dir|txf> Output sink as netdev, pcap, directory, txf file\n");
1050 printf(" -f|--filter <bpf-file> Use BPF filter file from bpfc\n");
1051 printf(" -t|--type <type> Only handle packets of defined type:\n");
1052 printf(" host|broadcast|multicast|others|outgoing\n");
1053 printf(" -F|--interval <uint> Dump interval in sec if -o is a directory where\n");
1054 printf(" pcap files should be stored (default: 60)\n");
1055 printf(" -J|--jumbo-support Support for 64KB Super Jumbo Frames\n");
1056 printf(" Default RX/TX slot: 2048Byte\n");
1057 printf(" -R|--rfraw Capture or inject raw 802.11 frames\n");
1058 printf(" -n|--num <uint> Number of packets until exit\n");
1059 printf(" `-- 0 Loop until interrupted (default)\n");
1060 printf(" `- n Send n packets and done\n");
1061 printf("Options for printing:\n");
1062 printf(" -s|--silent Do not print captured packets\n");
1063 printf(" -q|--less Print less-verbose packet information\n");
1064 printf(" -X|--hex Print packet data in hex format\n");
1065 printf(" -l|--ascii Print human-readable packet data\n");
1066 printf("Options, advanced:\n");
1067 printf(" -r|--rand Randomize packet forwarding order\n");
1068 printf(" -M|--no-promisc No promiscuous mode for netdev\n");
1069 printf(" -A|--no-sock-mem Don't tune core socket memory\n");
1070 printf(" -m|--mmap Mmap pcap file i.e., for replaying\n");
1071 printf(" -g|--sg Scatter/gather pcap file I/O\n");
1072 printf(" -c|--clrw Use slower read(2)/write(2) I/O\n");
1073 printf(" -S|--ring-size <size> Manually set ring size to <size>:\n");
1074 printf(" mmap space in KB/MB/GB, e.g. \'10MB\'\n");
1075 printf(" -k|--kernel-pull <uint> Kernel pull from user interval in us\n");
1076 printf(" Default is 10us where the TX_RING\n");
1077 printf(" is populated with payload from uspace\n");
1078 printf(" -b|--bind-cpu <cpu> Bind to specific CPU (or CPU-range)\n");
1079 printf(" -B|--unbind-cpu <cpu> Forbid to use specific CPU (or CPU-range)\n");
1080 printf(" -H|--prio-high Make this high priority process\n");
1081 printf(" -Q|--notouch-irq Do not touch IRQ CPU affinity of NIC\n");
1082 printf(" -v|--version Show version\n");
1083 printf(" -h|--help Guess what?!\n");
1085 printf("Examples:\n");
1086 printf(" netsniff-ng --in eth0 --out dump.pcap --silent --bind-cpu 0\n");
1087 printf(" netsniff-ng --in wlan0 --rfraw --out dump.pcap --silent --bind-cpu 0\n");
1088 printf(" netsniff-ng --in dump.pcap --mmap --out eth0 --silent --bind-cpu 0\n");
1089 printf(" netsniff-ng --in dump.pcap --out dump.txf --silent --bind-cpu 0\n");
1090 printf(" netsniff-ng --in eth0 --out eth1 --silent --bind-cpu 0 --type host\n");
1091 printf(" netsniff-ng --in eth1 --out /opt/probe1/ -s -m -J --interval 30 -b 0\n");
1092 printf(" netsniff-ng --in any --filter http.bpf --jumbo-support --ascii\n");
1095 printf(" This tool is targeted for network developers! You should\n");
1096 printf(" be aware of what you are doing and what these options above\n");
1097 printf(" mean! Use netsniff-ng's bpfc compiler for generating filter files.\n");
1098 printf(" Further, netsniff-ng automatically enables the kernel BPF JIT\n");
1099 printf(" if present. Txf file output is only possible if the input source\n");
1100 printf(" is a pcap file.\n");
1102 printf("Please report bugs to <bugs@netsniff-ng.org>\n");
1103 printf("Copyright (C) 2009-2012 Daniel Borkmann <daniel@netsniff-ng.org>\n");
1104 printf("Copyright (C) 2009-2012 Emmanuel Roullit <emmanuel@netsniff-ng.org>\n");
1105 printf("License: GNU GPL version 2\n");
1106 printf("This is free software: you are free to change and redistribute it.\n");
1107 printf("There is NO WARRANTY, to the extent permitted by law.\n\n");
1111 static void version(void)
1113 printf("\n%s %s, the packet sniffing beast\n", PROGNAME_STRING
,
1115 printf("http://www.netsniff-ng.org\n\n");
1116 printf("Please report bugs to <bugs@netsniff-ng.org>\n");
1117 printf("Copyright (C) 2009-2012 Daniel Borkmann <daniel@netsniff-ng.org>\n");
1118 printf("Copyright (C) 2009-2012 Emmanuel Roullit <emmanuel@netsniff-ng.org>\n");
1119 printf("License: GNU GPL version 2\n");
1120 printf("This is free software: you are free to change and redistribute it.\n");
1121 printf("There is NO WARRANTY, to the extent permitted by law.\n\n");
1125 static void header(void)
1127 printf("%s%s%s\n", colorize_start(bold
), PROGNAME_STRING
" "
1128 VERSION_STRING
, colorize_end());
1131 int main(int argc
, char **argv
)
1133 int c
, i
, j
, opt_index
, ops_touched
= 0;
1136 bool prio_high
= false;
1137 bool setsockmem
= true;
1139 void (*enter_mode
)(struct mode
*mode
) = NULL
;
1141 check_for_root_maybe_die();
1143 fmemset(&mode
, 0, sizeof(mode
));
1144 mode
.link_type
= LINKTYPE_EN10MB
;
1145 mode
.print_mode
= FNTTYPE_PRINT_NORM
;
1146 mode
.cpu
= CPU_UNKNOWN
;
1147 mode
.packet_type
= PACKET_ALL
;
1148 mode
.promiscuous
= true;
1149 mode
.randomize
= false;
1150 mode
.pcap
= PCAP_OPS_SG
;
1151 mode
.dump_interval
= DUMP_INTERVAL
;
1153 while ((c
= getopt_long(argc
, argv
, short_options
, long_options
,
1154 &opt_index
)) != EOF
) {
1158 mode
.device_in
= xstrdup(optarg
);
1161 mode
.device_out
= xstrdup(optarg
);
1164 mode
.link_type
= LINKTYPE_IEEE802_11
;
1168 mode
.randomize
= true;
1171 mode
.jumbo_support
= 1;
1174 mode
.filter
= xstrdup(optarg
);
1177 mode
.promiscuous
= false;
1183 if (!strncmp(optarg
, "host", strlen("host")))
1184 mode
.packet_type
= PACKET_HOST
;
1185 else if (!strncmp(optarg
, "broadcast", strlen("broadcast")))
1186 mode
.packet_type
= PACKET_BROADCAST
;
1187 else if (!strncmp(optarg
, "multicast", strlen("multicast")))
1188 mode
.packet_type
= PACKET_MULTICAST
;
1189 else if (!strncmp(optarg
, "others", strlen("others")))
1190 mode
.packet_type
= PACKET_OTHERHOST
;
1191 else if (!strncmp(optarg
, "outgoing", strlen("outgoing")))
1192 mode
.packet_type
= PACKET_OUTGOING
;
1194 mode
.packet_type
= PACKET_ALL
;
1198 mode
.reserve_size
= 0;
1200 for (j
= i
= strlen(optarg
); i
> 0; --i
) {
1201 if (!isdigit(optarg
[j
- i
]))
1206 if (!strncmp(ptr
, "KB", strlen("KB")))
1207 mode
.reserve_size
= 1 << 10;
1208 else if (!strncmp(ptr
, "MB", strlen("MB")))
1209 mode
.reserve_size
= 1 << 20;
1210 else if (!strncmp(ptr
, "GB", strlen("GB")))
1211 mode
.reserve_size
= 1 << 30;
1213 panic("Syntax error in ring size param!\n");
1216 mode
.reserve_size
*= atoi(optarg
);
1219 set_cpu_affinity(optarg
, 0);
1220 if (mode
.cpu
!= CPU_NOTOUCH
)
1221 mode
.cpu
= atoi(optarg
);
1224 set_cpu_affinity(optarg
, 1);
1230 mode
.pcap
= PCAP_OPS_RW
;
1234 mode
.pcap
= PCAP_OPS_MMAP
;
1238 mode
.pcap
= PCAP_OPS_SG
;
1242 mode
.cpu
= CPU_NOTOUCH
;
1245 mode
.print_mode
= FNTTYPE_PRINT_NONE
;
1248 mode
.print_mode
= FNTTYPE_PRINT_LESS
;
1251 mode
.print_mode
= (mode
.print_mode
== FNTTYPE_PRINT_ASCII
) ?
1252 FNTTYPE_PRINT_HEX_ASCII
: FNTTYPE_PRINT_HEX
;
1255 mode
.print_mode
= (mode
.print_mode
== FNTTYPE_PRINT_HEX
) ?
1256 FNTTYPE_PRINT_HEX_ASCII
: FNTTYPE_PRINT_ASCII
;
1259 mode
.kpull
= (unsigned long) atol(optarg
);
1262 frame_cnt_max
= (unsigned long) atol(optarg
);
1265 mode
.dump_interval
= (unsigned long) atol(optarg
);
1287 panic("Option -%c requires an argument!\n",
1290 if (isprint(optopt
))
1291 whine("Unknown option character "
1292 "`0x%X\'!\n", optopt
);
1300 if (!mode
.device_in
)
1301 mode
.device_in
= xstrdup("any");
1303 register_signal(SIGINT
, signal_handler
);
1304 register_signal(SIGHUP
, signal_handler
);
1306 init_pcap(mode
.jumbo_support
);
1310 if (prio_high
== true) {
1311 set_proc_prio(get_default_proc_prio());
1312 set_sched_status(get_default_sched_policy(),
1313 get_default_sched_prio());
1316 if (setsockmem
== true) {
1317 if ((vals
[0] = get_system_socket_mem(sock_rmem_max
)) < SMEM_SUG_MAX
)
1318 set_system_socket_mem(sock_rmem_max
, SMEM_SUG_MAX
);
1319 if ((vals
[1] = get_system_socket_mem(sock_rmem_def
)) < SMEM_SUG_DEF
)
1320 set_system_socket_mem(sock_rmem_def
, SMEM_SUG_DEF
);
1321 if ((vals
[2] = get_system_socket_mem(sock_wmem_max
)) < SMEM_SUG_MAX
)
1322 set_system_socket_mem(sock_wmem_max
, SMEM_SUG_MAX
);
1323 if ((vals
[3] = get_system_socket_mem(sock_wmem_def
)) < SMEM_SUG_DEF
)
1324 set_system_socket_mem(sock_wmem_def
, SMEM_SUG_DEF
);
1327 if (mode
.device_in
&& (device_mtu(mode
.device_in
) ||
1328 !strncmp("any", mode
.device_in
, strlen(mode
.device_in
)))) {
1329 if (!mode
.device_out
) {
1331 enter_mode
= enter_mode_rx_only_or_dump
;
1332 } else if (device_mtu(mode
.device_out
)) {
1333 register_signal_f(SIGALRM
, timer_elapsed
, SA_SIGINFO
);
1334 enter_mode
= enter_mode_rx_to_tx
;
1337 register_signal_f(SIGALRM
, timer_next_dump
, SA_SIGINFO
);
1338 enter_mode
= enter_mode_rx_only_or_dump
;
1340 mode
.pcap
= PCAP_OPS_SG
;
1343 if (mode
.device_out
&& device_mtu(mode
.device_out
)) {
1344 register_signal_f(SIGALRM
, timer_elapsed
, SA_SIGINFO
);
1345 enter_mode
= enter_mode_pcap_to_tx
;
1347 mode
.pcap
= PCAP_OPS_MMAP
;
1349 enter_mode
= enter_mode_read_pcap
;
1351 mode
.pcap
= PCAP_OPS_SG
;
1356 panic("Selection not supported!\n");
1362 if (setsockmem
== true) {
1363 set_system_socket_mem(sock_rmem_max
, vals
[0]);
1364 set_system_socket_mem(sock_rmem_def
, vals
[1]);
1365 set_system_socket_mem(sock_wmem_max
, vals
[2]);
1366 set_system_socket_mem(sock_wmem_def
, vals
[3]);
1370 xfree(mode
.device_in
);
1371 if (mode
.device_out
)
1372 xfree(mode
.device_out
);
1373 if (mode
.device_trans
)
1374 xfree(mode
.device_trans
);