change all file offsets from long to gint64 so we can - theoretically - handle files...
[obnox/wireshark/wip.git] / dumpcap.c
1 /* dumpcap.c
2  *
3  * $Id$
4  *
5  * Wireshark - Network traffic analyzer
6  * By Gerald Combs <gerald@wireshark.org>
7  * Copyright 1998 Gerald Combs
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2
12  * of the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  */
23
24 #ifdef HAVE_CONFIG_H
25 # include "config.h"
26 #endif
27
28 #include <stdlib.h> /* for exit() */
29 #include <glib.h>
30
31 #include <string.h>
32 #include <ctype.h>
33
34 #ifdef HAVE_UNISTD_H
35 #include <unistd.h>
36 #endif
37
38 #ifdef NEED_GETOPT_H
39 #include "getopt.h"
40 #endif
41
42 #ifdef HAVE_NETDB_H
43 #include <netdb.h>
44 #endif
45
46 #include "ringbuffer.h"
47 #include "clopts_common.h"
48 #include "cmdarg_err.h"
49 #include "version_info.h"
50
51 #include <pcap.h>
52 #include "capture-pcap-util.h"
53
54 #ifdef _WIN32
55 #include "capture-wpcap.h"
56 #endif
57
58 #include "sync_pipe.h"
59
60 #include "capture.h"
61 #include "capture_loop.h"
62 #include "capture_sync.h"
63
64 #include "simple_dialog.h"
65 #include "util.h"
66 #include "log.h"
67 #include "file_util.h"
68
69
70 /*#define DEBUG_DUMPCAP*/
71
72 gboolean capture_child = FALSE; /* FALSE: standalone call, TRUE: this is an Wireshark capture child */
73
74 static void
75 console_log_handler(const char *log_domain, GLogLevelFlags log_level,
76                     const char *message, gpointer user_data _U_);
77
78 /* capture related options */
79 capture_options global_capture_opts;
80 capture_options *capture_opts = &global_capture_opts;
81
82 #if __GNUC__ >= 2
83 void exit_main(int err) __attribute__ ((noreturn));
84 #else
85 void exit_main(int err);
86 #endif
87
88
89 static void
90 print_usage(gboolean print_ver) {
91
92   FILE *output;
93
94
95   if (print_ver) {
96     output = stdout;
97     fprintf(output,
98         "Dumpcap " VERSION "%s\n"
99         "Capture network packets and dump them into a libpcap file.\n"
100         "See http://www.wireshark.org for more information.\n",
101         svnversion);
102   } else {
103     output = stderr;
104   }
105   fprintf(output, "\nUsage: dumpcap [options] ...\n");
106   fprintf(output, "\n");
107   fprintf(output, "Capture interface:\n");
108   fprintf(output, "  -i <interface>           name or idx of interface (def: first none loopback)\n");
109   fprintf(output, "  -f <capture filter>      packet filter in libpcap filter syntax\n");
110   fprintf(output, "  -s <snaplen>             packet snapshot length (def: 65535)\n");
111   fprintf(output, "  -p                       don't capture in promiscuous mode\n");
112 #ifdef _WIN32
113   fprintf(output, "  -B <buffer size>         size of kernel buffer (def: 1MB)\n");
114 #endif
115   fprintf(output, "  -y <link type>           link layer type (def: first appropriate)\n");
116   fprintf(output, "  -D                       print list of interfaces and exit\n");
117   fprintf(output, "  -L                       print list of link-layer types of iface and exit\n");
118   fprintf(output, "\n");
119   fprintf(output, "Stop conditions:\n");
120   fprintf(output, "  -c <packet count>        stop after n packets (def: infinite)\n");
121   fprintf(output, "  -a <autostop cond.> ...  duration:NUM - stop after NUM seconds\n");
122   fprintf(output, "                           filesize:NUM - stop this file after NUM KB\n");
123   fprintf(output, "                              files:NUM - stop after NUM files\n");
124   /*fprintf(output, "\n");*/
125   fprintf(output, "Output (files):\n");
126   fprintf(output, "  -w <filename>            name of file to save (def: tempfile)\n");
127   fprintf(output, "  -b <ringbuffer opt.> ... duration:NUM - switch to next file after NUM secs\n");
128   fprintf(output, "                           filesize:NUM - switch to next file after NUM KB\n");
129   fprintf(output, "                              files:NUM - ringbuffer: replace after NUM files\n");
130   /*fprintf(output, "\n");*/
131   fprintf(output, "Miscellaneous:\n");
132   fprintf(output, "  -v                       print version information and exit\n");
133   fprintf(output, "  -h                       display this help and exit\n");
134   fprintf(output, "\n");
135   fprintf(output, "Example: dumpcap -i eth0 -a duration:60 -w output.pcap\n");
136   fprintf(output, "\"Capture network packets from interface eth0 until 60s passed into output.pcap\"\n");
137   fprintf(output, "\n");
138   fprintf(output, "Use Ctrl-C to stop capturing at any time.\n");
139 }
140
141 static void
142 show_version(GString *comp_info_str, GString *runtime_info_str)
143 {
144
145   printf(
146         "Dumpcap " VERSION "%s\n"
147         "\n"
148         "%s\n"
149         "%s\n"
150         "%s\n"
151         "See http://www.wireshark.org for more information.\n",
152         svnversion, get_copyright_info() ,comp_info_str->str, runtime_info_str->str);
153 }
154
155 /*
156  * Report an error in command-line arguments.
157  */
158 void
159 cmdarg_err(const char *fmt, ...)
160 {
161   va_list ap;
162
163   if(capture_child) {
164     /* XXX - convert to g_log */
165   } else {
166     va_start(ap, fmt);
167     fprintf(stderr, "dumpcap: ");
168     vfprintf(stderr, fmt, ap);
169     fprintf(stderr, "\n");
170     va_end(ap);
171   }
172 }
173
174 /*
175  * Report additional information for an error in command-line arguments.
176  */
177 void
178 cmdarg_err_cont(const char *fmt, ...)
179 {
180   va_list ap;
181
182   if(capture_child) {
183     /* XXX - convert to g_log */
184   } else {
185     va_start(ap, fmt);
186     vfprintf(stderr, fmt, ap);
187     fprintf(stderr, "\n");
188     va_end(ap);
189   }
190 }
191
192
193 #ifdef _WIN32
194 BOOL WINAPI ConsoleCtrlHandlerRoutine(DWORD dwCtrlType)
195 {
196     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
197         "Console: Control signal");
198     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
199         "Console: Control signal, CtrlType: %u", dwCtrlType);
200
201     /* Keep capture running if we're a service and a user logs off */
202     if (capture_child || (dwCtrlType != CTRL_LOGOFF_EVENT)) {
203         capture_loop_stop();
204         return TRUE;
205     } else {
206         return FALSE;
207     }
208 }
209 #endif
210
211 void exit_main(int status)
212 {
213 #ifdef _WIN32
214   /* Shutdown windows sockets */
215   WSACleanup();
216
217   /* can be helpful for debugging */
218 #ifdef DEBUG_DUMPCAP
219   printf("Press any key\n");
220   _getch();
221 #endif
222
223 #endif /* _WIN32 */
224
225   exit(status);
226 }
227
228
229 /* And now our feature presentation... [ fade to music ] */
230 int
231 main(int argc, char *argv[])
232 {
233   int                  opt;
234   extern char         *optarg;
235   gboolean             arg_error = FALSE;
236
237 #ifdef _WIN32
238   WSADATA              wsaData;
239 #endif  /* _WIN32 */
240
241   gboolean             start_capture = TRUE;
242   gboolean             stats_known;
243   struct pcap_stat     stats;
244   GLogLevelFlags       log_flags;
245   gboolean             list_link_layer_types = FALSE;
246   int                  status;
247
248 #define OPTSTRING_INIT "a:b:c:Df:hi:Lps:vw:y:Z"
249
250 #ifdef _WIN32
251 #define OPTSTRING_WIN32 "B:"
252 #else
253 #define OPTSTRING_WIN32 ""
254 #endif  /* _WIN32 */
255
256   char optstring[sizeof(OPTSTRING_INIT) + sizeof(OPTSTRING_WIN32) - 1] =
257     OPTSTRING_INIT OPTSTRING_WIN32;
258
259 #ifdef _WIN32
260   /* Load wpcap if possible. Do this before collecting the run-time version information */
261   load_wpcap();
262
263   /* ... and also load the packet.dll from wpcap */
264   /* XXX - currently not required, may change later. */
265   /*wpcap_packet_load();*/
266
267   /* Start windows sockets */
268   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
269
270   /* Set handler for Ctrl+C key */
271   SetConsoleCtrlHandler(&ConsoleCtrlHandlerRoutine, TRUE);
272 #endif  /* _WIN32 */
273
274
275   /* the default_log_handler will use stdout, which makes trouble in */
276   /* capture child mode, as it uses stdout for it's sync_pipe */
277   /* so do the filtering in the console_log_handler and not here */
278   log_flags = 
279                     G_LOG_LEVEL_ERROR|
280                     G_LOG_LEVEL_CRITICAL|
281                     G_LOG_LEVEL_WARNING|
282                     G_LOG_LEVEL_MESSAGE|
283                     G_LOG_LEVEL_INFO|
284                     G_LOG_LEVEL_DEBUG|
285                     G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
286
287   g_log_set_handler(NULL,
288                     log_flags,
289                     console_log_handler, NULL /* user_data */);
290   g_log_set_handler(LOG_DOMAIN_MAIN,
291                     log_flags,
292                     console_log_handler, NULL /* user_data */);
293   g_log_set_handler(LOG_DOMAIN_CAPTURE,
294                     log_flags,
295             console_log_handler, NULL /* user_data */);
296   g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
297                     log_flags,
298             console_log_handler, NULL /* user_data */);
299
300   /* Set the initial values in the capture_opts. This might be overwritten 
301      by the command line parameters. */
302   capture_opts_init(capture_opts, NULL);
303
304   /* Default to capturing the entire packet. */
305   capture_opts->snaplen             = WTAP_MAX_PACKET_SIZE;
306
307   /* We always save to a file - if no file was specified, we save to a
308      temporary file. */
309   capture_opts->saving_to_file      = TRUE;
310   capture_opts->has_ring_num_files  = TRUE;
311
312   /* Now get our args */
313   while ((opt = getopt(argc, argv, optstring)) != -1) {
314     switch (opt) {
315       case 'h':        /* Print help and exit */
316         print_usage(TRUE);
317         exit_main(0);
318         break;
319       case 'v':        /* Show version and exit */
320       {
321         GString             *comp_info_str;
322         GString             *runtime_info_str;
323         /* Assemble the compile-time version information string */
324         comp_info_str = g_string_new("Compiled with ");
325         get_compiled_version_info(comp_info_str, NULL);
326
327         /* Assemble the run-time version information string */
328         runtime_info_str = g_string_new("Running ");
329         get_runtime_version_info(runtime_info_str, NULL);               
330         show_version(comp_info_str, runtime_info_str);
331         g_string_free(comp_info_str, TRUE);
332         g_string_free(runtime_info_str, TRUE);
333         exit_main(0);
334         break;
335       }
336       /*** capture option specific ***/
337       case 'a':        /* autostop criteria */
338       case 'b':        /* Ringbuffer option */
339       case 'c':        /* Capture x packets */
340       case 'f':        /* capture filter */
341       case 'i':        /* Use interface x */
342       case 'p':        /* Don't capture in promiscuous mode */
343       case 's':        /* Set the snapshot (capture) length */
344       case 'w':        /* Write to capture file x */
345       case 'y':        /* Set the pcap data link type */
346 #ifdef _WIN32
347       case 'B':        /* Buffer size */
348 #endif /* _WIN32 */
349         status = capture_opts_add_opt(capture_opts, opt, optarg, &start_capture);
350         if(status != 0) {
351             exit_main(status);
352         }
353         break;
354       /*** hidden option: Wireshark child mode (using binary output messages) ***/
355       case 'Z':
356           capture_child = TRUE;
357 #ifdef _WIN32
358           /* set output pipe to binary mode, to avoid ugly text conversions */
359                   _setmode(1, O_BINARY);
360 #endif
361           break;
362
363       /*** all non capture option specific ***/
364       case 'D':        /* Print a list of capture devices and exit */
365         status = capture_opts_list_interfaces();
366         exit_main(status);
367         break;
368       case 'L':        /* Print list of link-layer types and exit */
369         list_link_layer_types = TRUE;
370         break;
371       default:
372       case '?':        /* Bad flag - print usage message */
373         cmdarg_err("Invalid Option: %s", argv[optind-1]);
374         arg_error = TRUE;
375         break;
376     }
377   }
378   argc -= optind;
379   argv += optind;
380   if (argc >= 1) {
381       /* user specified file name as regular command-line argument */
382       /* XXX - use it as the capture file name (or something else)? */
383     argc--;
384     argv++;
385   }
386
387   if (argc != 0) {
388     /*
389      * Extra command line arguments were specified; complain.
390      * XXX - interpret as capture filter, as tcpdump and tshark do?
391      */
392     cmdarg_err("Invalid argument: %s", argv[0]);
393     arg_error = TRUE;
394   }
395
396   if (arg_error) {
397     print_usage(FALSE);
398     exit_main(1);
399   }
400
401   if (list_link_layer_types) {
402     /* We're supposed to list the link-layer types for an interface;
403        did the user also specify a capture file to be read? */
404     /* No - did they specify a ring buffer option? */
405     if (capture_opts->multi_files_on) {
406       cmdarg_err("Ring buffer requested, but a capture isn't being done.");
407       exit_main(1);
408     }
409   } else {
410     /* No - was the ring buffer option specified and, if so, does it make
411        sense? */
412     if (capture_opts->multi_files_on) {
413       /* Ring buffer works only under certain conditions:
414          a) ring buffer does not work with temporary files;
415          b) it makes no sense to enable the ring buffer if the maximum
416             file size is set to "infinite". */
417       if (capture_opts->save_file == NULL) {
418         cmdarg_err("Ring buffer requested, but capture isn't being saved to a permanent file.");
419         capture_opts->multi_files_on = FALSE;
420       }
421       if (!capture_opts->has_autostop_filesize && !capture_opts->has_file_duration) {
422         cmdarg_err("Ring buffer requested, but no maximum capture file size or duration were specified.");
423 /* XXX - this must be redesigned as the conditions changed */
424 /*      capture_opts->multi_files_on = FALSE;*/
425       }
426     }
427   }
428
429   if (capture_opts_trim_iface(capture_opts, NULL) == FALSE) {
430         cmdarg_err("No capture interfaces available (maybe lack of privileges?).");
431     exit_main(1);
432   }
433
434   /* Let the user know what interface was chosen. */
435   /* get_interface_descriptive_name() is not available! */
436   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "Interface: %s\n", capture_opts->iface);
437
438   if (list_link_layer_types) {
439     status = capture_opts_list_link_layer_types(capture_opts);
440     exit_main(status);
441   }
442
443   capture_opts_trim_snaplen(capture_opts, MIN_PACKET_SIZE);
444   capture_opts_trim_ring_num_files(capture_opts);
445
446   /* Now start the capture. */
447
448   if(capture_loop_start(capture_opts, &stats_known, &stats) == TRUE) {
449       /* capture ok */
450       exit_main(0);
451   } else {
452       /* capture failed */
453       exit_main(1);
454   }
455 }
456
457
458 static void
459 console_log_handler(const char *log_domain, GLogLevelFlags log_level,
460                     const char *message, gpointer user_data _U_)
461 {
462   time_t curr;
463   struct tm *today;
464   const char *level;
465
466
467   /* ignore log message, if log_level isn't interesting */
468   if( !(log_level & G_LOG_LEVEL_MASK & ~(G_LOG_LEVEL_DEBUG|G_LOG_LEVEL_INFO))) {
469 #ifndef DEBUG_DUMPCAP
470     return;
471 #endif
472   }
473
474   /* create a "timestamp" */
475   time(&curr);
476   today = localtime(&curr);    
477
478   switch(log_level & G_LOG_LEVEL_MASK) {
479   case G_LOG_LEVEL_ERROR:
480     level = "Err ";
481     break;
482   case G_LOG_LEVEL_CRITICAL:
483     level = "Crit";
484     break;
485   case G_LOG_LEVEL_WARNING:
486     level = "Warn";
487     break;
488   case G_LOG_LEVEL_MESSAGE:
489     level = "Msg ";
490     break;
491   case G_LOG_LEVEL_INFO:
492     level = "Info";
493     break;
494   case G_LOG_LEVEL_DEBUG:
495     level = "Dbg ";
496     break;
497   default:
498     fprintf(stderr, "unknown log_level %u\n", log_level);
499     level = NULL;
500     g_assert_not_reached();
501   }
502
503   /* don't use printf (stdout), in child mode we're using stdout for the sync_pipe */
504   if(log_level & G_LOG_LEVEL_MESSAGE) {
505     /* normal user messages without additional infos */
506     fprintf(stderr, "%s\n", message);
507     fflush(stderr);
508   } else {
509     /* info/debug messages with additional infos */
510     fprintf(stderr, "%02u:%02u:%02u %8s %s %s\n",
511             today->tm_hour, today->tm_min, today->tm_sec,
512             log_domain != NULL ? log_domain : "",
513             level, message);
514     fflush(stderr);
515   }
516 }
517
518
519 /****************************************************************************************************************/
520 /* indication report routines */
521
522
523 void
524 report_packet_count(int packet_count)
525 {
526     char tmp[SP_DECISIZE+1+1];
527     static int count = 0;
528
529
530     if(capture_child) {
531         g_snprintf(tmp, sizeof(tmp), "%d", packet_count);
532         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "Packets: %s", tmp);
533         pipe_write_block(1, SP_PACKET_COUNT, tmp);
534     } else {
535         count += packet_count;
536         fprintf(stderr, "\rPackets: %u ", count);
537         /* stderr could be line buffered */
538         fflush(stderr);
539     }
540 }
541
542 void
543 report_new_capture_file(const char *filename)
544 {
545
546     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "File: %s", filename);
547
548     if(capture_child) {
549         pipe_write_block(1, SP_FILE, filename);
550     }
551 }
552
553 void
554 report_cfilter_error(const char *cfilter _U_, const char *errmsg)
555 {
556
557     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "Capture filter error: %s", errmsg);
558
559     if (capture_child) {
560         pipe_write_block(1, SP_BAD_FILTER, errmsg);
561     }
562 }
563
564 void
565 report_capture_error(const char *error_msg, const char *secondary_error_msg)
566 {
567
568     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, 
569         "Primary Error: %s", error_msg);
570     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, 
571         "Secondary Error: %s", secondary_error_msg);
572
573     if(capture_child) {
574         sync_pipe_errmsg_to_parent(error_msg, secondary_error_msg);
575     }
576 }
577
578 void
579 report_packet_drops(int drops)
580 {
581     char tmp[SP_DECISIZE+1+1];
582
583
584     g_snprintf(tmp, sizeof(tmp), "%d", drops);
585     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "Packets dropped: %s", tmp);
586
587     if(capture_child) {
588         pipe_write_block(1, SP_DROPS, tmp);
589     }
590 }
591
592
593 /****************************************************************************************************************/
594 /* signal_pipe handling */
595
596
597 #ifdef _WIN32
598 gboolean
599 signal_pipe_check_running(void)
600 {
601     /* any news from our parent (stdin)? -> just stop the capture */
602     HANDLE handle;
603     DWORD avail = 0;
604     gboolean result;
605
606
607     /* if we are running standalone, no check required */
608     if(!capture_child) {
609         return TRUE;
610     }
611
612     handle = (HANDLE) GetStdHandle(STD_INPUT_HANDLE);
613     result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
614
615     if(!result || avail > 0) {
616         /* peek failed or some bytes really available */
617         /* (if not piping from stdin this would fail) */
618         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
619             "Signal pipe: Stop capture");
620         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
621             "Signal pipe: handle: %x result: %u avail: %u", handle, result, avail);
622         return FALSE;
623     } else {
624         /* pipe ok and no bytes available */
625         return TRUE;
626     }
627 }
628 #endif
629
630
631 /****************************************************************************************************************/
632 /* Stub functions */
633
634
635 const char *netsnmp_get_version(void) { return ""; }
636