If we have pcap_open, call it instead of pcap_open_live, otherwise we might
[obnox/wireshark/wip.git] / tshark.c
1 /* tshark.c
2  *
3  * $Id$
4  *
5  * Wireshark - Network traffic analyzer
6  * By Gerald Combs <gerald@wireshark.org>
7  * Copyright 1998 Gerald Combs
8  *
9  * Text-mode variant, by Gilbert Ramirez <gram@alumni.rice.edu>
10  * and Guy Harris <guy@alum.mit.edu>.
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License
14  * as published by the Free Software Foundation; either version 2
15  * of the License, or (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
25  */
26
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <ctype.h>
35 #include <locale.h>
36 #include <limits.h>
37
38 #ifdef HAVE_UNISTD_H
39 #include <unistd.h>
40 #endif
41
42 #include <errno.h>
43
44 #ifdef HAVE_FCNTL_H
45 #include <fcntl.h>
46 #endif
47
48 #include <signal.h>
49
50 #ifdef HAVE_SYS_STAT_H
51 # include <sys/stat.h>
52 #endif
53
54 #ifdef NEED_STRERROR_H
55 #include "strerror.h"
56 #endif
57
58 #ifdef NEED_GETOPT_H
59 #include "getopt.h"
60 #endif
61
62 #include <glib.h>
63 #include <epan/epan.h>
64 #include <epan/filesystem.h>
65 #include <epan/privileges.h>
66 #include <wiretap/file_util.h>
67
68 #include "globals.h"
69 #include <epan/timestamp.h>
70 #include <epan/packet.h>
71 #include "file.h"
72 #include "disabled_protos.h"
73 #include <epan/prefs.h>
74 #include <epan/column.h>
75 #include "print.h"
76 #include <epan/addr_resolv.h>
77 #include "util.h"
78 #include "clopts_common.h"
79 #include "cmdarg_err.h"
80 #include "version_info.h"
81 #include <epan/conversation.h>
82 #include <epan/plugins.h>
83 #include "register.h"
84 #include <epan/epan_dissect.h>
85 #include <epan/tap.h>
86 #include <epan/stat_cmd_args.h>
87 #include <epan/timestamp.h>
88 #include <epan/ex-opt.h>
89
90 #ifdef HAVE_LIBPCAP
91 #include "capture_ui_utils.h"
92 #include <pcap.h>
93 #include "capture-pcap-util.h"
94 #ifdef _WIN32
95 #include "capture-wpcap.h"
96 #include "capture_errs.h"
97 #endif /* _WIN32 */
98 #include "capture_sync.h"
99 #endif /* HAVE_LIBPCAP */
100 #include "epan/emem.h"
101 #include "log.h"
102 #include <epan/funnel.h>
103
104
105 /*
106  * This is the template for the decode as option; it is shared between the
107  * various functions that output the usage for this parameter.
108  */
109 static const gchar decode_as_arg_template[] = "<layer_type>==<selector>,<decode_as_protocol>";
110
111 static nstime_t first_ts;
112 static nstime_t prev_dis_ts;
113 static nstime_t prev_cap_ts;
114 static GString *comp_info_str, *runtime_info_str;
115
116 static gboolean print_packet_info;      /* TRUE if we're to print packet information */
117 /*
118  * The way the packet decode is to be written.
119  */
120 typedef enum {
121         WRITE_TEXT,     /* summary or detail text */
122         WRITE_XML,      /* PDML or PSML */
123         WRITE_FIELDS    /* User defined list of fields */
124         /* Add CSV and the like here */
125 } output_action_e;
126 static output_action_e output_action;
127 static gboolean do_dissection;  /* TRUE if we have to dissect each packet */
128 static gboolean verbose;
129 static gboolean print_hex;
130 static gboolean line_buffered;
131 static guint32 cum_bytes = 0;
132 static print_format_e print_format = PR_FMT_TEXT;
133 static print_stream_t *print_stream;
134
135 static output_fields_t* output_fields  = NULL;
136
137 /*
138  * Standard secondary message for unexpected errors.
139  */
140 static const char please_report[] =
141     "Please report this to the Wireshark developers";
142
143 #ifdef HAVE_LIBPCAP
144 /*
145  * TRUE if we're to print packet counts to keep track of captured packets.
146  */
147 static gboolean print_packet_counts;
148
149
150 static capture_options capture_opts;
151
152 #ifdef SIGINFO
153 static gboolean infodelay;      /* if TRUE, don't print capture info in SIGINFO handler */
154 static gboolean infoprint;      /* if TRUE, print capture info after clearing infodelay */
155 #endif /* SIGINFO */
156
157 static int capture(void);
158 static void report_counts(void);
159 #ifdef _WIN32
160 static BOOL WINAPI capture_cleanup(DWORD);
161 #else /* _WIN32 */
162 static void capture_cleanup(int);
163 #ifdef SIGINFO
164 static void report_counts_siginfo(int);
165 #endif /* SIGINFO */
166 #endif /* _WIN32 */
167 #endif /* HAVE_LIBPCAP */
168
169 static int load_cap_file(capture_file *, char *, int, int, gint64);
170 static gboolean process_packet(capture_file *cf, gint64 offset,
171     const struct wtap_pkthdr *whdr, union wtap_pseudo_header *pseudo_header,
172     const guchar *pd);
173 static void show_capture_file_io_error(const char *, int, gboolean);
174 static void show_print_file_io_error(int err);
175 static gboolean write_preamble(capture_file *cf);
176 static gboolean print_packet(capture_file *cf, epan_dissect_t *edt);
177 static gboolean write_finale(void);
178 static const char *cf_open_error_message(int err, gchar *err_info,
179     gboolean for_writing, int file_type);
180
181 static void open_failure_message(const char *filename, int err,
182     gboolean for_writing);
183 static void failure_message(const char *msg_format, va_list ap);
184 static void read_failure_message(const char *filename, int err);
185
186 capture_file cfile;
187
188 /*
189  * Mark a particular frame.
190  * Copied from file.c
191  */
192 void
193 cf_mark_frame(capture_file *cf, frame_data *frame)
194 {
195   if (! frame->flags.marked) {
196     frame->flags.marked = TRUE;
197     if (cf->count > cf->marked_count)
198       cf->marked_count++;
199   }
200 }
201
202 /*
203  * Unmark a particular frame.
204  * Copied from file.c
205  */
206 void
207 cf_unmark_frame(capture_file *cf, frame_data *frame)
208 {
209   if (frame->flags.marked) {
210     frame->flags.marked = FALSE;
211     if (cf->marked_count > 0)
212       cf->marked_count--;
213   }
214 }
215
216
217 static void list_capture_types(void) {
218     int i;
219
220     fprintf(stderr, "editcap: The available capture file types for \"F\":\n");
221     for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
222       if (wtap_dump_can_open(i))
223         fprintf(stderr, "    %s - %s\n",
224           wtap_file_type_short_string(i), wtap_file_type_string(i));
225     }
226 }
227
228 static void
229 print_usage(gboolean print_ver)
230 {
231   FILE *output;
232
233   if (print_ver) {
234     output = stdout;
235     fprintf(output,
236         "TShark " VERSION "%s\n"
237         "Dump and analyze network traffic.\n"
238         "See http://www.wireshark.org for more information.\n"
239         "\n"
240         "%s",
241         wireshark_svnversion, get_copyright_info());
242   } else {
243     output = stderr;
244   }
245   fprintf(output, "\n");
246   fprintf(output, "Usage: tshark [options] ...\n");
247   fprintf(output, "\n");
248
249 #ifdef HAVE_LIBPCAP
250   fprintf(output, "Capture interface:\n");
251   fprintf(output, "  -i <interface>           name or idx of interface (def: first non-loopback)\n");
252   fprintf(output, "  -f <capture filter>      packet filter in libpcap filter syntax\n");
253   fprintf(output, "  -s <snaplen>             packet snapshot length (def: 65535)\n");
254   fprintf(output, "  -p                       don't capture in promiscuous mode\n");
255 #ifdef _WIN32
256   fprintf(output, "  -B <buffer size>         size of kernel buffer (def: 1MB)\n");
257 #endif
258   fprintf(output, "  -y <link type>           link layer type (def: first appropriate)\n");
259   fprintf(output, "  -D                       print list of interfaces and exit\n");
260   fprintf(output, "  -L                       print list of link-layer types of iface and exit\n");
261   fprintf(output, "\n");
262   fprintf(output, "Capture stop conditions:\n");
263   fprintf(output, "  -c <packet count>        stop after n packets (def: infinite)\n");
264   fprintf(output, "  -a <autostop cond.> ...  duration:NUM - stop after NUM seconds\n");
265   fprintf(output, "                           filesize:NUM - stop this file after NUM KB\n");
266   fprintf(output, "                              files:NUM - stop after NUM files\n");
267   /*fprintf(output, "\n");*/
268   fprintf(output, "Capture output:\n");
269   fprintf(output, "  -b <ringbuffer opt.> ... duration:NUM - switch to next file after NUM secs\n");
270   fprintf(output, "                           filesize:NUM - switch to next file after NUM KB\n");
271   fprintf(output, "                              files:NUM - ringbuffer: replace after NUM files\n");
272 #endif  /* HAVE_LIBPCAP */
273
274   /*fprintf(output, "\n");*/
275   fprintf(output, "Input file:\n");
276   fprintf(output, "  -r <infile>              set the filename to read from (no pipes or stdin!)\n");
277
278   fprintf(output, "\n");
279   fprintf(output, "Processing:\n");
280   fprintf(output, "  -R <read filter>         packet filter in Wireshark display filter syntax\n");
281   fprintf(output, "  -n                       disable all name resolutions (def: all enabled)\n");
282   fprintf(output, "  -N <name resolve flags>  enable specific name resolution(s): \"mntC\"\n");
283   fprintf(output, "  -d %s ...\n", decode_as_arg_template);
284   fprintf(output, "                           \"Decode As\", see the man page for details\n");
285   fprintf(output, "                           Example: tcp.port==8888,http\n");
286
287   /*fprintf(output, "\n");*/
288   fprintf(output, "Output:\n");
289   fprintf(output, "  -w <outfile|->           set the output filename (or '-' for stdout)\n");
290   fprintf(output, "  -C <config profile>      start with specified configuration profile\n");
291   fprintf(output, "  -F <output file type>    set the output file type, default is libpcap\n");
292   fprintf(output, "                           an empty \"-F\" option will list the file types\n");
293   fprintf(output, "  -V                       add output of packet tree        (Packet Details)\n");
294   fprintf(output, "  -S                       display packets even when writing to a file\n");
295   fprintf(output, "  -x                       add output of hex and ASCII dump (Packet Bytes)\n");
296   fprintf(output, "  -T pdml|ps|psml|text|fields\n");
297   fprintf(output, "                           format of text output (def: text)\n");
298   fprintf(output, "  -e <field>               field to print if -Tfields selected (e.g. tcp.port);\n");
299   fprintf(output, "                           this option can be repeated to print multiple fields\n");
300   fprintf(output, "  -E<fieldsoption>=<value> set options for output when -Tfields selected:\n");
301   fprintf(output, "     header=y|n            switch headers on and off\n");
302   fprintf(output, "     separator=/t|/s|<char> select tab, space, printable character as separator\n");
303   fprintf(output, "     quote=d|s|n           select double, single, no quotes for values\n");
304   fprintf(output, "  -t ad|a|r|d|dd|e         output format of time stamps (def: r: rel. to first)\n");
305   fprintf(output, "  -l                       flush standard output after each packet\n");
306   fprintf(output, "  -q                       be more quiet on stdout (e.g. when using statistics)\n");
307   fprintf(output, "  -X <key>:<value>         eXtension options, see the man page for details\n");
308   fprintf(output, "  -z <statistics>          various statistics, see the man page for details\n");
309
310   fprintf(output, "\n");
311   fprintf(output, "Miscellaneous:\n");
312   fprintf(output, "  -h                       display this help and exit\n");
313   fprintf(output, "  -v                       display version info and exit\n");
314   fprintf(output, "  -o <name>:<value> ...    override preference setting\n");
315 }
316
317 /*
318  * For a dissector table, print on the stream described by output,
319  * its short name (which is what's used in the "-d" option) and its
320  * descriptive name.
321  */
322 static void
323 display_dissector_table_names(const char *table_name, const char *ui_name,
324                               gpointer output)
325 {
326   fprintf((FILE *)output, "\t%s (%s)\n", table_name, ui_name);
327 }
328
329 /*
330  * For a dissector handle, print on the stream described by output,
331  * the filter name (which is what's used in the "-d" option) and the full
332  * name for the protocol that corresponds to this handle.
333  */
334 static void
335 display_dissector_names(const gchar *table _U_, gpointer handle, gpointer output)
336 {
337   int                proto_id;
338   const gchar*       proto_filter_name;
339   const gchar*       proto_ui_name;
340
341   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
342
343   if (proto_id != -1) {
344     proto_filter_name = proto_get_protocol_filter_name(proto_id);
345     proto_ui_name =  proto_get_protocol_name(proto_id);
346     g_assert(proto_filter_name != NULL);
347     g_assert(proto_ui_name != NULL);
348
349     fprintf((FILE *)output, "\t%s (%s)\n",
350             proto_filter_name,
351             proto_ui_name);
352   }
353 }
354
355 /*
356  * The protocol_name_search structure is used by find_protocol_name_func()
357  * to pass parameters and store results
358  */
359 struct protocol_name_search{
360   gchar              *searched_name;  /* Protocol filter name we are looking for */
361   dissector_handle_t  matched_handle; /* Handle for a dissector whose protocol has the specified filter name */
362   guint               nb_match;       /* How many dissectors matched searched_name */
363 };
364 typedef struct protocol_name_search *protocol_name_search_t;
365
366 /*
367  * This function parses all dissectors associated with a table to find the
368  * one whose protocol has the specified filter name.  It is called
369  * as a reference function in a call to dissector_table_foreach_handle.
370  * The name we are looking for, as well as the results, are stored in the
371  * protocol_name_search struct pointed to by user_data.
372  * If called using dissector_table_foreach_handle, we actually parse the
373  * whole list of dissectors.
374  */
375 static void
376 find_protocol_name_func(const gchar *table _U_, gpointer handle, gpointer user_data)
377
378 {
379   int                         proto_id;
380   const gchar                *protocol_filter_name;
381   protocol_name_search_t      search_info;
382
383   g_assert(handle);
384
385   search_info = (protocol_name_search_t)user_data;
386
387   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
388   if (proto_id != -1) {
389     protocol_filter_name = proto_get_protocol_filter_name(proto_id);
390     g_assert(protocol_filter_name != NULL);
391     if (strcmp(protocol_filter_name, search_info->searched_name) == 0) {
392       /* Found a match */
393       if (search_info->nb_match == 0) {
394         /* Record this handle only if this is the first match */
395         search_info->matched_handle = (dissector_handle_t)handle; /* Record the handle for this matching dissector */
396       }
397       search_info->nb_match++;
398     }
399   }
400 }
401
402 /*
403  * Print all layer type names supported.
404  * We send the output to the stream described by the handle output.
405  */
406
407 static void
408 fprint_all_layer_types(FILE *output)
409
410 {
411   dissector_all_tables_foreach_table(display_dissector_table_names, (gpointer)output);
412 }
413
414 /*
415  * Print all protocol names supported for a specific layer type.
416  * table_name contains the layer type name in which the search is performed.
417  * We send the output to the stream described by the handle output.
418  */
419
420 static void
421 fprint_all_protocols_for_layer_types(FILE *output, gchar *table_name)
422
423 {
424   dissector_table_foreach_handle(table_name,
425                                  display_dissector_names,
426                                  (gpointer)output);
427 }
428
429 /*
430  * The function below parses the command-line parameters for the decode as
431  * feature (a string pointer by cl_param).
432  * It checks the format of the command-line, searches for a matching table
433  * and dissector.  If a table/dissector match is not found, we display a
434  * summary of the available tables/dissectors (on stderr) and return FALSE.
435  * If everything is fine, we get the "Decode as" preference activated,
436  * then we return TRUE.
437  */
438 static gboolean
439 add_decode_as(const gchar *cl_param)
440 {
441   gchar                        *table_name;
442   guint32                       selector;
443   gchar                        *decoded_param;
444   gchar                        *remaining_param;
445   gchar                        *selector_str;
446   gchar                        *dissector_str;
447   dissector_handle_t            dissector_matching;
448   dissector_table_t             table_matching;
449   ftenum_t                      dissector_table_selector_type;
450   struct protocol_name_search   user_protocol_name;
451
452   /* The following code will allocate and copy the command-line options in a string pointed by decoded_param */
453
454   g_assert(cl_param);
455   decoded_param = g_strdup(cl_param);
456   g_assert(decoded_param);
457
458
459   /* The lines below will parse this string (modifying it) to extract all
460     necessary information.  Note that decoded_param is still needed since
461     strings are not copied - we just save pointers. */
462
463   /* This section extracts a layer type (table_name) from decoded_param */
464   table_name = decoded_param; /* Layer type string starts from beginning */
465
466   remaining_param = strchr(table_name, '=');
467   if (remaining_param == NULL) {
468     cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
469     /* If the argument does not follow the template, carry on anyway to check
470        if the table name is at least correct.  If remaining_param is NULL,
471        we'll exit anyway further down */
472   }
473   else {
474     *remaining_param = '\0'; /* Terminate the layer type string (table_name) where '=' was detected */
475   }
476
477   /* Remove leading and trailing spaces from the table name */
478   while ( table_name[0] == ' ' )
479     table_name++;
480   while ( table_name[strlen(table_name) - 1] == ' ' )
481     table_name[strlen(table_name) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
482
483 /* The following part searches a table matching with the layer type specified */
484   table_matching = NULL;
485
486 /* Look for the requested table */
487   if ( !(*(table_name)) ) { /* Is the table name empty, if so, don't even search for anything, display a message */
488     cmdarg_err("No layer type specified"); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
489   }
490   else {
491     table_matching = find_dissector_table(table_name);
492     if (!table_matching) {
493       cmdarg_err("Unknown layer type -- %s", table_name); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
494     }
495   }
496
497   if (!table_matching) {
498     /* Display a list of supported layer types to help the user, if the
499        specified layer type was not found */
500     cmdarg_err("Valid layer types are:");
501     fprint_all_layer_types(stderr);
502   }
503   if (remaining_param == NULL || !table_matching) {
504     /* Exit if the layer type was not found, or if no '=' separator was found
505        (see above) */
506     g_free(decoded_param);
507     return FALSE;
508   }
509
510   if (*(remaining_param + 1) != '=') { /* Check for "==" and not only '=' */
511     cmdarg_err("WARNING: -d requires \"==\" instead of \"=\". Option will be treated as \"%s==%s\"", table_name, remaining_param + 1);
512   }
513   else {
514     remaining_param++; /* Move to the second '=' */
515     *remaining_param = '\0'; /* Remove the second '=' */
516   }
517   remaining_param++; /* Position after the layer type string */
518
519   /* This section extracts a selector value (selector_str) from decoded_param */
520
521   selector_str = remaining_param; /* Next part starts with the selector number */
522
523   remaining_param = strchr(selector_str, ',');
524   if (remaining_param == NULL) {
525     cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
526     /* If the argument does not follow the template, carry on anyway to check
527        if the selector value is at least correct.  If remaining_param is NULL,
528        we'll exit anyway further down */
529   }
530   else {
531     *remaining_param = '\0'; /* Terminate the selector number string (selector_str) where ',' was detected */
532   }
533
534   dissector_table_selector_type = get_dissector_table_selector_type(table_name);
535
536   switch (dissector_table_selector_type) {
537
538   case FT_UINT8:
539   case FT_UINT16:
540   case FT_UINT24:
541   case FT_UINT32:
542     /* The selector for this table is an unsigned number.  Parse it as such.
543        There's no need to remove leading and trailing spaces from the
544        selector number string, because sscanf will do that for us. */
545     if ( sscanf(selector_str, "%u", &selector) != 1 ) {
546       cmdarg_err("Invalid selector number \"%s\"", selector_str);
547       g_free(decoded_param);
548       return FALSE;
549     }
550     break;
551
552   case FT_STRING:
553   case FT_STRINGZ:
554   case FT_EBCDIC:
555     /* The selector for this table is a string. */
556     break;
557
558   default:
559     /* There are currently no dissector tables with any types other
560        than the ones listed above. */
561     g_assert_not_reached();
562   }
563
564   if (remaining_param == NULL) {
565     /* Exit if no ',' separator was found (see above) */
566     cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
567     fprint_all_protocols_for_layer_types(stderr, table_name);
568     g_free(decoded_param);
569     return FALSE;
570   }
571
572   remaining_param++; /* Position after the selector number string */
573
574   /* This section extracts a protocol filter name (dissector_str) from decoded_param */
575
576   dissector_str = remaining_param; /* All the rest of the string is the dissector (decode as protocol) name */
577
578   /* Remove leading and trailing spaces from the dissector name */
579   while ( dissector_str[0] == ' ' )
580     dissector_str++;
581   while ( dissector_str[strlen(dissector_str) - 1] == ' ' )
582     dissector_str[strlen(dissector_str) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
583
584   dissector_matching = NULL;
585
586   /* We now have a pointer to the handle for the requested table inside the variable table_matching */
587   if ( ! (*dissector_str) ) { /* Is the dissector name empty, if so, don't even search for a matching dissector and display all dissectors found for the selected table */
588     cmdarg_err("No protocol name specified"); /* Note, we don't exit here, but dissector_matching will remain NULL, so we exit below */
589   }
590   else {
591     user_protocol_name.nb_match = 0;
592     user_protocol_name.searched_name = dissector_str;
593     user_protocol_name.matched_handle = NULL;
594
595     dissector_table_foreach_handle(table_name, find_protocol_name_func, &user_protocol_name); /* Go and perform the search for this dissector in the this table's dissectors' names and shortnames */
596
597     if (user_protocol_name.nb_match != 0) {
598       dissector_matching = user_protocol_name.matched_handle;
599       if (user_protocol_name.nb_match > 1) {
600         cmdarg_err("WARNING: Protocol \"%s\" matched %u dissectors, first one will be used", dissector_str, user_protocol_name.nb_match);
601       }
602     }
603     else {
604       /* OK, check whether the problem is that there isn't any such
605          protocol, or that there is but it's not specified as a protocol
606          that's valid for that dissector table.
607          Note, we don't exit here, but dissector_matching will remain NULL,
608          so we exit below */
609       if (proto_get_id_by_filter_name(dissector_str) == -1) {
610         /* No such protocol */
611         cmdarg_err("Unknown protocol -- \"%s\"", dissector_str);
612       } else {
613         cmdarg_err("Protocol \"%s\" isn't valid for layer type \"%s\"",
614                 dissector_str, table_name);
615       }
616     }
617   }
618
619   if (!dissector_matching) {
620     cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
621     fprint_all_protocols_for_layer_types(stderr, table_name);
622     g_free(decoded_param);
623     return FALSE;
624   }
625
626 /* This is the end of the code that parses the command-line options.
627    All information is now stored in the variables:
628    table_name
629    selector
630    dissector_matching
631    The above variables that are strings are still pointing to areas within
632    decoded_parm.  decoded_parm thus still needs to be kept allocated in
633    until we stop needing these variables
634    decoded_param will be deallocated at each exit point of this function */
635
636
637   /* We now have a pointer to the handle for the requested dissector
638      (requested protocol) inside the variable dissector_matching */
639   switch (dissector_table_selector_type) {
640
641   case FT_UINT8:
642   case FT_UINT16:
643   case FT_UINT24:
644   case FT_UINT32:
645     /* The selector for this table is an unsigned number. */
646     dissector_change(table_name, selector, dissector_matching);
647     break;
648
649   case FT_STRING:
650   case FT_STRINGZ:
651   case FT_EBCDIC:
652     /* The selector for this table is a string. */
653     dissector_change_string(table_name, selector_str, dissector_matching);
654     break;
655
656   default:
657     /* There are currently no dissector tables with any types other
658        than the ones listed above. */
659     g_assert_not_reached();
660   }
661   g_free(decoded_param); /* "Decode As" rule has been succesfully added */
662   return TRUE;
663 }
664
665 static void
666 log_func_ignore (const gchar *log_domain _U_, GLogLevelFlags log_level _U_,
667     const gchar *message _U_, gpointer user_data _U_)
668 {
669 }
670
671 static char *
672 output_file_description(const char *fname)
673 {
674   char *save_file_string;
675
676   /* Get a string that describes what we're writing to */
677   if (strcmp(fname, "-") == 0) {
678     /* We're writing to the standard output */
679     save_file_string = g_strdup("standard output");
680   } else {
681     /* We're writing to a file with the name in save_file */
682     save_file_string = g_strdup_printf("file \"%s\"", fname);
683   }
684   return save_file_string;
685 }
686
687 static void
688 print_current_user(void) {
689   gchar *cur_user, *cur_group;
690   if (started_with_special_privs()) {
691     cur_user = get_cur_username();
692     cur_group = get_cur_groupname();
693     fprintf(stderr, "Running as user \"%s\" and group \"%s\".",
694       cur_user, cur_group);
695     g_free(cur_user);
696     g_free(cur_group);
697     if (running_with_special_privs()) {
698       fprintf(stderr, " This could be dangerous.");
699     }
700     fprintf(stderr, "\n");
701   }
702 }
703
704 static void
705 check_capture_privs(void) {
706 #ifdef _WIN32
707   load_wpcap();
708   /* Warn the user if npf.sys isn't loaded. */
709   if (!npf_sys_is_running() && get_os_major_version() >= 6) {
710     fprintf(stderr, "The NPF driver isn't running.  You may have trouble "
711       "capturing or\nlisting interfaces.\n");
712   }
713 #endif
714 }
715
716
717
718 int
719 main(int argc, char *argv[])
720 {
721   char                *init_progfile_dir_error;
722   int                  opt, i;
723   extern char         *optarg;
724   gboolean             arg_error = FALSE;
725
726 #ifdef _WIN32
727   WSADATA               wsaData;
728 #endif  /* _WIN32 */
729
730   char                *gpf_path, *pf_path;
731   char                *gdp_path, *dp_path;
732   int                  gpf_open_errno, gpf_read_errno;
733   int                  pf_open_errno, pf_read_errno;
734   int                  gdp_open_errno, gdp_read_errno;
735   int                  dp_open_errno, dp_read_errno;
736   int                  err;
737 #ifdef HAVE_LIBPCAP
738   gboolean             list_link_layer_types = FALSE;
739   gboolean             start_capture = FALSE;
740   int                  status;
741 #else
742   gboolean             capture_option_specified = FALSE;
743 #endif
744   gboolean             quiet = FALSE;
745   int                  out_file_type = WTAP_FILE_PCAP;
746   gchar               *cf_name = NULL, *rfilter = NULL;
747 #ifdef HAVE_PCAP_OPEN_DEAD
748   struct bpf_program   fcode;
749 #endif
750   dfilter_t           *rfcode = NULL;
751   e_prefs             *prefs;
752   char                 badopt;
753   GLogLevelFlags       log_flags;
754   int                  optind_initial;
755
756 #define OPTSTRING_INIT "a:b:c:C:d:De:E:f:F:G:hi:lLnN:o:pqr:R:s:St:T:vVw:xX:y:z:"
757 #ifdef HAVE_LIBPCAP
758 #ifdef _WIN32
759 #define OPTSTRING_WIN32 "B:"
760 #else
761 #define OPTSTRING_WIN32 ""
762 #endif  /* _WIN32 */
763 #else
764 #define OPTSTRING_WIN32 ""
765 #endif  /* HAVE_LIBPCAP */
766
767   static const char    optstring[] = OPTSTRING_INIT OPTSTRING_WIN32;
768
769   /*
770    * Get credential information for later use.
771    */
772   get_credential_info();
773
774   /*
775    * Attempt to get the pathname of the executable file.
776    */
777   init_progfile_dir_error = init_progfile_dir(argv[0]);
778   if (init_progfile_dir_error != NULL) {
779     fprintf(stderr, "tshark: Can't get pathname of tshark program: %s.\n",
780             init_progfile_dir_error);
781   }
782
783   /*
784    * In order to have the -X opts assigned before the wslua machine starts
785    * we need to call getopts before epan_init() gets called.
786    */
787   opterr = 0;
788   optind_initial = optind;
789
790   while ((opt = getopt(argc, argv, optstring)) != -1) {
791           switch (opt) {
792                   case 'C':        /* Configuration Profile */
793                           if (profile_exists (optarg)) {
794                                   set_profile_name (optarg);
795                           } else {
796                                   cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
797                                   exit(1);
798                           }
799                           break;
800                   case 'X':
801                           ex_opt_add(optarg);
802                           break;
803                   default:
804                           break;
805           }
806   }
807
808   optind = optind_initial;
809   opterr = 1;
810
811   /* nothing more than the standard GLib handler, but without a warning */
812   log_flags =
813                     G_LOG_LEVEL_WARNING|
814                     G_LOG_LEVEL_MESSAGE|
815                     G_LOG_LEVEL_INFO|
816                     G_LOG_LEVEL_DEBUG;
817
818   g_log_set_handler(NULL,
819                     log_flags,
820                     log_func_ignore, NULL /* user_data */);
821   g_log_set_handler(LOG_DOMAIN_CAPTURE,
822                     log_flags,
823                     log_func_ignore, NULL /* user_data */);
824
825   initialize_funnel_ops();
826
827 #ifdef HAVE_LIBPCAP
828   capture_opts_init(&capture_opts, NULL /* cfile */);
829 #endif
830
831   timestamp_set_type(TS_RELATIVE);
832   timestamp_set_precision(TS_PREC_AUTO);
833
834   /* Register all dissectors; we must do this before checking for the
835      "-G" flag, as the "-G" flag dumps information registered by the
836      dissectors, and we must do it before we read the preferences, in
837      case any dissectors register preferences. */
838   epan_init(register_all_protocols, register_all_protocol_handoffs, NULL, NULL,
839             failure_message, open_failure_message, read_failure_message);
840
841   /* Register all tap listeners; we do this before we parse the arguments,
842      as the "-z" argument can specify a registered tap. */
843
844   /* we register the plugin taps before the other taps because
845      stats_tree taps plugins will be registered as tap listeners
846      by stats_tree_stat.c and need to registered before that */
847 #ifdef HAVE_PLUGINS
848   register_all_plugin_tap_listeners();
849 #endif
850   register_all_tap_listeners();
851
852   /* Now register the preferences for any non-dissector modules.
853      We must do that before we read the preferences as well. */
854   prefs_register_modules();
855
856   /* If invoked with the "-G" flag, we dump out information based on
857      the argument to the "-G" flag; if no argument is specified,
858      for backwards compatibility we dump out a glossary of display
859      filter symbols.
860
861      XXX - we do this here, for now, to support "-G" with no arguments.
862      If none of our build or other processes uses "-G" with no arguments,
863      we can just process it with the other arguments. */
864   if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
865           proto_initialize_all_prefixes();
866           
867     if (argc == 2)
868       proto_registrar_dump_fields(1);
869     else {
870       if (strcmp(argv[2], "fields") == 0)
871         proto_registrar_dump_fields(1);
872       else if (strcmp(argv[2], "fields2") == 0)
873         proto_registrar_dump_fields(2);
874       else if (strcmp(argv[2], "fields3") == 0)
875         proto_registrar_dump_fields(3);
876       else if (strcmp(argv[2], "protocols") == 0)
877         proto_registrar_dump_protocols();
878       else if (strcmp(argv[2], "values") == 0)
879         proto_registrar_dump_values();
880       else if (strcmp(argv[2], "decodes") == 0)
881         dissector_dump_decodes();
882       else if (strcmp(argv[2], "defaultprefs") == 0)
883         write_prefs(NULL);
884       else if (strcmp(argv[2], "currentprefs") == 0) {
885         read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
886             &pf_open_errno, &pf_read_errno, &pf_path);
887         write_prefs(NULL);
888       } else {
889         cmdarg_err("Invalid \"%s\" option for -G flag", argv[2]);
890         exit(1);
891       }
892     }
893     exit(0);
894   }
895
896   /* Set the C-language locale to the native environment. */
897   setlocale(LC_ALL, "");
898
899   prefs = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
900                      &pf_open_errno, &pf_read_errno, &pf_path);
901   if (gpf_path != NULL) {
902     if (gpf_open_errno != 0) {
903       cmdarg_err("Can't open global preferences file \"%s\": %s.",
904               pf_path, strerror(gpf_open_errno));
905     }
906     if (gpf_read_errno != 0) {
907       cmdarg_err("I/O error reading global preferences file \"%s\": %s.",
908               pf_path, strerror(gpf_read_errno));
909     }
910   }
911   if (pf_path != NULL) {
912     if (pf_open_errno != 0) {
913       cmdarg_err("Can't open your preferences file \"%s\": %s.", pf_path,
914               strerror(pf_open_errno));
915     }
916     if (pf_read_errno != 0) {
917       cmdarg_err("I/O error reading your preferences file \"%s\": %s.",
918               pf_path, strerror(pf_read_errno));
919     }
920     g_free(pf_path);
921     pf_path = NULL;
922   }
923
924   /* Set the name resolution code's flags from the preferences. */
925   g_resolv_flags = prefs->name_resolve;
926
927   /* Read the disabled protocols file. */
928   read_disabled_protos_list(&gdp_path, &gdp_open_errno, &gdp_read_errno,
929                             &dp_path, &dp_open_errno, &dp_read_errno);
930   if (gdp_path != NULL) {
931     if (gdp_open_errno != 0) {
932       cmdarg_err("Could not open global disabled protocols file\n\"%s\": %s.",
933                  gdp_path, strerror(gdp_open_errno));
934     }
935     if (gdp_read_errno != 0) {
936       cmdarg_err("I/O error reading global disabled protocols file\n\"%s\": %s.",
937                  gdp_path, strerror(gdp_read_errno));
938     }
939     g_free(gdp_path);
940   }
941   if (dp_path != NULL) {
942     if (dp_open_errno != 0) {
943       cmdarg_err(
944         "Could not open your disabled protocols file\n\"%s\": %s.", dp_path,
945         strerror(dp_open_errno));
946     }
947     if (dp_read_errno != 0) {
948       cmdarg_err(
949         "I/O error reading your disabled protocols file\n\"%s\": %s.", dp_path,
950         strerror(dp_read_errno));
951     }
952     g_free(dp_path);
953   }
954
955   check_capture_privs();
956
957   init_cap_file(&cfile);
958
959   /* Assemble the compile-time version information string */
960   comp_info_str = g_string_new("Compiled ");
961   get_compiled_version_info(comp_info_str, get_epan_compiled_version_info);
962
963   /* Assemble the run-time version information string */
964   runtime_info_str = g_string_new("Running ");
965   get_runtime_version_info(runtime_info_str, NULL);
966
967   /* Print format defaults to this. */
968   print_format = PR_FMT_TEXT;
969
970   output_fields = output_fields_new();
971
972   /* Now get our args */
973   while ((opt = getopt(argc, argv, optstring)) != -1) {
974     switch (opt) {
975       case 'a':        /* autostop criteria */
976       case 'b':        /* Ringbuffer option */
977       case 'c':        /* Capture x packets */
978       case 'f':        /* capture filter */
979       case 'i':        /* Use interface x */
980       case 'p':        /* Don't capture in promiscuous mode */
981       case 's':        /* Set the snapshot (capture) length */
982       case 'w':        /* Write to capture file x */
983       case 'y':        /* Set the pcap data link type */
984 #ifdef _WIN32
985       case 'B':        /* Buffer size */
986 #endif /* _WIN32 */
987 #ifdef HAVE_LIBPCAP
988         status = capture_opts_add_opt(&capture_opts, opt, optarg, &start_capture);
989         if(status != 0) {
990             exit(status);
991         }
992 #else
993         capture_option_specified = TRUE;
994         arg_error = TRUE;
995 #endif
996         break;
997       case 'C':
998         /* Configuration profile settings were already processed just ignore them this time*/
999         break;
1000       case 'd':        /* Decode as rule */
1001         if (!add_decode_as(optarg))
1002           exit(1);
1003         break;
1004       case 'D':        /* Print a list of capture devices and exit */
1005 #ifdef HAVE_LIBPCAP
1006         status = capture_opts_list_interfaces(FALSE);
1007         exit(status);
1008 #else
1009         capture_option_specified = TRUE;
1010         arg_error = TRUE;
1011 #endif
1012         break;
1013       case 'e':
1014         /* Field entry */
1015         output_fields_add(output_fields, optarg);
1016         break;
1017       case 'E':
1018         /* Field option */
1019         if(!output_fields_set_option(output_fields, optarg)) {
1020           cmdarg_err("\"%s\" is not a valid field output option=value pair.", optarg);
1021           output_fields_list_options(stderr);
1022           exit(1);
1023         }
1024         break;
1025       case 'F':
1026         out_file_type = wtap_short_string_to_file_type(optarg);
1027         if (out_file_type < 0) {
1028           cmdarg_err("\"%s\" isn't a valid capture file type", optarg);
1029           list_capture_types();
1030           exit(1);
1031         }
1032         break;
1033       case 'h':        /* Print help and exit */
1034         print_usage(TRUE);
1035         exit(0);
1036         break;
1037       case 'l':        /* "Line-buffer" standard output */
1038         /* This isn't line-buffering, strictly speaking, it's just
1039            flushing the standard output after the information for
1040            each packet is printed; however, that should be good
1041            enough for all the purposes to which "-l" is put (and
1042            is probably actually better for "-V", as it does fewer
1043            writes).
1044
1045            See the comment in "process_packet()" for an explanation of
1046            why we do that, and why we don't just use "setvbuf()" to
1047            make the standard output line-buffered (short version: in
1048            Windows, "line-buffered" is the same as "fully-buffered",
1049            and the output buffer is only flushed when it fills up). */
1050         line_buffered = TRUE;
1051         break;
1052       case 'L':        /* Print list of link-layer types and exit */
1053 #ifdef HAVE_LIBPCAP
1054         list_link_layer_types = TRUE;
1055 #else
1056         capture_option_specified = TRUE;
1057         arg_error = TRUE;
1058 #endif
1059         break;
1060       case 'n':        /* No name resolution */
1061         g_resolv_flags = RESOLV_NONE;
1062         break;
1063       case 'N':        /* Select what types of addresses/port #s to resolve */
1064         if (g_resolv_flags == RESOLV_ALL)
1065           g_resolv_flags = RESOLV_NONE;
1066         badopt = string_to_name_resolve(optarg, &g_resolv_flags);
1067         if (badopt != '\0') {
1068           cmdarg_err("-N specifies unknown resolving option '%c';",
1069                      badopt);
1070           cmdarg_err_cont( "           Valid options are 'm', 'n', 't', and 'C'");
1071           exit(1);
1072         }
1073         break;
1074       case 'o':        /* Override preference from command line */
1075         switch (prefs_set_pref(optarg)) {
1076
1077         case PREFS_SET_OK:
1078           break;
1079
1080         case PREFS_SET_SYNTAX_ERR:
1081           cmdarg_err("Invalid -o flag \"%s\"", optarg);
1082           exit(1);
1083           break;
1084
1085         case PREFS_SET_NO_SUCH_PREF:
1086         case PREFS_SET_OBSOLETE:
1087           cmdarg_err("-o flag \"%s\" specifies unknown preference", optarg);
1088           exit(1);
1089           break;
1090         }
1091         break;
1092       case 'q':        /* Quiet */
1093         quiet = TRUE;
1094         break;
1095       case 'r':        /* Read capture file x */
1096         cf_name = g_strdup(optarg);
1097         break;
1098       case 'R':        /* Read file filter */
1099         rfilter = optarg;
1100         break;
1101       case 'S':        /* show packets in real time */
1102         print_packet_info = TRUE;
1103         break;
1104       case 't':        /* Time stamp type */
1105         if (strcmp(optarg, "r") == 0)
1106           timestamp_set_type(TS_RELATIVE);
1107         else if (strcmp(optarg, "a") == 0)
1108           timestamp_set_type(TS_ABSOLUTE);
1109         else if (strcmp(optarg, "ad") == 0)
1110           timestamp_set_type(TS_ABSOLUTE_WITH_DATE);
1111         else if (strcmp(optarg, "d") == 0)
1112           timestamp_set_type(TS_DELTA);
1113         else if (strcmp(optarg, "dd") == 0)
1114           timestamp_set_type(TS_DELTA_DIS);
1115         else if (strcmp(optarg, "e") == 0)
1116           timestamp_set_type(TS_EPOCH);
1117         else {
1118           cmdarg_err("Invalid time stamp type \"%s\"",
1119             optarg);
1120           cmdarg_err_cont("It must be \"r\" for relative, \"a\" for absolute,");
1121           cmdarg_err_cont("\"ad\" for absolute with date, or \"d\" for delta.");
1122           exit(1);
1123         }
1124         break;
1125       case 'T':        /* printing Type */
1126         if (strcmp(optarg, "text") == 0) {
1127           output_action = WRITE_TEXT;
1128           print_format = PR_FMT_TEXT;
1129         } else if (strcmp(optarg, "ps") == 0) {
1130           output_action = WRITE_TEXT;
1131           print_format = PR_FMT_PS;
1132         } else if (strcmp(optarg, "pdml") == 0) {
1133           output_action = WRITE_XML;
1134           verbose = TRUE;
1135         } else if (strcmp(optarg, "psml") == 0) {
1136           output_action = WRITE_XML;
1137           verbose = FALSE;
1138         } else if(strcmp(optarg, "fields") == 0) {
1139           output_action = WRITE_FIELDS;
1140           verbose = TRUE; /* Need full tree info */
1141         } else {
1142           cmdarg_err("Invalid -T parameter.");
1143           cmdarg_err_cont("It must be \"ps\", \"text\", \"pdml\", \"psml\" or \"fields\".");
1144           exit(1);
1145         }
1146         break;
1147       case 'v':        /* Show version and exit */
1148         printf("TShark " VERSION "%s\n"
1149                "\n"
1150                "%s"
1151                "\n"
1152                "%s"
1153                "\n"
1154                "%s",
1155                wireshark_svnversion, get_copyright_info(), comp_info_str->str,
1156                runtime_info_str->str);
1157         exit(0);
1158         break;
1159       case 'V':        /* Verbose */
1160         verbose = TRUE;
1161         break;
1162       case 'x':        /* Print packet data in hex (and ASCII) */
1163           print_hex = TRUE;
1164           break;
1165       case 'X':
1166           break;
1167       case 'z':
1168         /* We won't call the init function for the stat this soon
1169            as it would disallow MATE's fields (which are registered
1170            by the preferences set callback) from being used as
1171            part of a tap filter.  Instead, we just add the argument
1172            to a list of stat arguments. */
1173         if (!process_stat_cmd_arg(optarg)) {
1174           cmdarg_err("invalid -z argument.");
1175           cmdarg_err_cont("  -z argument must be one of :");
1176           list_stat_cmd_args();
1177           exit(1);
1178         }
1179         break;
1180       default:
1181       case '?':        /* Bad flag - print usage message */
1182         switch(optopt) {
1183         case 'F':
1184           list_capture_types();
1185           break;
1186         default:
1187           print_usage(TRUE);
1188         }
1189         exit(1);
1190         break;
1191     }
1192   }
1193
1194   /* If we specified output fields, but not the output field type... */
1195   if(WRITE_FIELDS != output_action && 0 != output_fields_num_fields(output_fields)) {
1196         cmdarg_err("Output fields were specified with \"-e\", "
1197             "but \"-Tfields\" was not specified.");
1198         exit(1);
1199   } else if(WRITE_FIELDS == output_action && 0 == output_fields_num_fields(output_fields)) {
1200         cmdarg_err("\"-Tfields\" was specified, but no fields were "
1201                     "specified with \"-e\".");
1202
1203         exit(1);
1204   }
1205
1206   /* If no capture filter or read filter has been specified, and there are
1207      still command-line arguments, treat them as the tokens of a capture
1208      filter (if no "-r" flag was specified) or a read filter (if a "-r"
1209      flag was specified. */
1210   if (optind < argc) {
1211     if (cf_name != NULL) {
1212       if (rfilter != NULL) {
1213         cmdarg_err("Read filters were specified both with \"-R\" "
1214             "and with additional command-line arguments");
1215         exit(1);
1216       }
1217       rfilter = get_args_as_string(argc, argv, optind);
1218     } else {
1219 #ifdef HAVE_LIBPCAP
1220       if (capture_opts.has_cfilter) {
1221         cmdarg_err("Capture filters were specified both with \"-f\""
1222             " and with additional command-line arguments");
1223         exit(1);
1224       }
1225       capture_opts.has_cfilter = TRUE;
1226       capture_opts.cfilter = get_args_as_string(argc, argv, optind);
1227 #else
1228       capture_option_specified = TRUE;
1229 #endif
1230     }
1231   }
1232
1233 #ifdef HAVE_LIBPCAP
1234   if (!capture_opts.saving_to_file) {
1235     /* We're not saving the capture to a file; if "-q" wasn't specified,
1236        we should print packet information */
1237     if (!quiet)
1238       print_packet_info = TRUE;
1239   } else {
1240     /* We're saving to a file; if we're writing to the standard output.
1241        and we'll also be writing dissected packets to the standard
1242        output, reject the request.  At best, we could redirect that
1243        to the standard error; we *can't* write both to the standard
1244        output and have either of them be useful. */
1245     if (strcmp(capture_opts.save_file, "-") == 0 && print_packet_info) {
1246       cmdarg_err("You can't write both raw packet data and dissected packets"
1247           " to the standard output.");
1248       exit(1);
1249     }
1250   }
1251 #else
1252   /* We're not saving the capture to a file; if "-q" wasn't specified,
1253      we should print packet information */
1254   if (!quiet)
1255     print_packet_info = TRUE;
1256 #endif
1257
1258 #ifndef HAVE_LIBPCAP
1259   if (capture_option_specified)
1260     cmdarg_err("This version of TShark was not built with support for capturing packets.");
1261 #endif
1262   if (arg_error) {
1263     print_usage(FALSE);
1264     exit(1);
1265   }
1266
1267   /* We don't support capture filters when reading from a capture file
1268      (the BPF compiler doesn't support all link-layer types that we
1269      support in capture files we read). */
1270 #ifdef HAVE_LIBPCAP
1271   if (cf_name != NULL) {
1272     if (capture_opts.has_cfilter) {
1273       cmdarg_err("Only read filters, not capture filters, "
1274           "can be specified when reading a capture file.");
1275       exit(1);
1276     }
1277   }
1278 #endif
1279
1280   if (print_hex) {
1281     if (output_action != WRITE_TEXT) {
1282       cmdarg_err("Raw packet hex data can only be printed as text or PostScript");
1283       exit(1);
1284     }
1285   }
1286
1287 #ifdef HAVE_LIBPCAP
1288   if (list_link_layer_types) {
1289     /* We're supposed to list the link-layer types for an interface;
1290        did the user also specify a capture file to be read? */
1291     if (cf_name) {
1292       /* Yes - that's bogus. */
1293       cmdarg_err("You can't specify -L and a capture file to be read.");
1294       exit(1);
1295     }
1296     /* No - did they specify a ring buffer option? */
1297     if (capture_opts.multi_files_on) {
1298       cmdarg_err("Ring buffer requested, but a capture isn't being done.");
1299       exit(1);
1300     }
1301   } else {
1302     if (cf_name) {
1303       /*
1304        * "-r" was specified, so we're reading a capture file.
1305        * Capture options don't apply here.
1306        */
1307       if (capture_opts.multi_files_on) {
1308         cmdarg_err("Multiple capture files requested, but "
1309                    "a capture isn't being done.");
1310         exit(1);
1311       }
1312       if (capture_opts.has_file_duration) {
1313         cmdarg_err("Switching capture files after a time interval was specified, but "
1314                    "a capture isn't being done.");
1315         exit(1);
1316       }
1317       if (capture_opts.has_ring_num_files) {
1318         cmdarg_err("A ring buffer of capture files was specified, but "
1319           "a capture isn't being done.");
1320         exit(1);
1321       }
1322       if (capture_opts.has_autostop_files) {
1323         cmdarg_err("A maximum number of capture files was specified, but "
1324           "a capture isn't being done.");
1325         exit(1);
1326       }
1327
1328       /* Note: TShark now allows the restriction of a _read_ file by packet count
1329        * and byte count as well as a write file. Other autostop options remain valid
1330        * only for a write file.
1331        */
1332       if (capture_opts.has_autostop_duration) {
1333         cmdarg_err("A maximum capture time was specified, but "
1334           "a capture isn't being done.");
1335         exit(1);
1336       }
1337     } else {
1338       /*
1339        * "-r" wasn't specified, so we're doing a live capture.
1340        */
1341       if (capture_opts.saving_to_file) {
1342         /* They specified a "-w" flag, so we'll be saving to a capture file. */
1343
1344         /* When capturing, we only support writing libpcap format. */
1345         if (out_file_type != WTAP_FILE_PCAP) {
1346           cmdarg_err("Live captures can only be saved in libpcap format.");
1347           exit(1);
1348         }
1349         if (capture_opts.multi_files_on) {
1350           /* Multiple-file mode doesn't work under certain conditions:
1351              a) it doesn't work if you're writing to the standard output;
1352              b) it doesn't work if you're writing to a pipe;
1353           */
1354           if (strcmp(capture_opts.save_file, "-") == 0) {
1355             cmdarg_err("Multiple capture files requested, but "
1356               "the capture is being written to the standard output.");
1357             exit(1);
1358           }
1359           if (capture_opts.output_to_pipe) {
1360             cmdarg_err("Multiple capture files requested, but "
1361               "the capture file is a pipe.");
1362             exit(1);
1363           }
1364           if (!capture_opts.has_autostop_filesize &&
1365               !capture_opts.has_file_duration) {
1366             cmdarg_err("Multiple capture files requested, but "
1367               "no maximum capture file size or duration was specified.");
1368             exit(1);
1369           }
1370         }
1371       } else {
1372         /* They didn't specify a "-w" flag, so we won't be saving to a
1373            capture file.  Check for options that only make sense if
1374            we're saving to a file. */
1375         if (capture_opts.has_autostop_filesize) {
1376           cmdarg_err("Maximum capture file size specified, but "
1377            "capture isn't being saved to a file.");
1378           exit(1);
1379         }
1380         if (capture_opts.multi_files_on) {
1381           cmdarg_err("Multiple capture files requested, but "
1382             "the capture isn't being saved to a file.");
1383           exit(1);
1384         }
1385       }
1386     }
1387   }
1388 #endif
1389
1390 #ifdef _WIN32
1391   /* Start windows sockets */
1392   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
1393 #endif /* _WIN32 */
1394
1395   /* Notify all registered modules that have had any of their preferences
1396      changed either from one of the preferences file or from the command
1397      line that their preferences have changed. */
1398   prefs_apply_all();
1399
1400   /* At this point MATE will have registered its field array so we can
1401      have a tap filter with one of MATE's late-registered fields as part
1402      of the filter.  We can now process all the "-z" arguments. */
1403   start_requested_stats();
1404
1405   /* disabled protocols as per configuration file */
1406   if (gdp_path == NULL && dp_path == NULL) {
1407     set_disabled_protos_list();
1408   }
1409
1410   /* Build the column format array */
1411   col_setup(&cfile.cinfo, prefs->num_cols);
1412   for (i = 0; i < cfile.cinfo.num_cols; i++) {
1413     cfile.cinfo.col_fmt[i] = get_column_format(i);
1414     cfile.cinfo.col_title[i] = g_strdup(get_column_title(i));
1415     if (cfile.cinfo.col_fmt[i] == COL_CUSTOM) {
1416       cfile.cinfo.col_custom_field[i] = g_strdup(get_column_custom_field(i));
1417     } else {
1418       cfile.cinfo.col_custom_field[i] = NULL;
1419     }
1420     cfile.cinfo.fmt_matx[i] = (gboolean *) g_malloc0(sizeof(gboolean) *
1421       NUM_COL_FMTS);
1422     get_column_format_matches(cfile.cinfo.fmt_matx[i], cfile.cinfo.col_fmt[i]);
1423     cfile.cinfo.col_data[i] = NULL;
1424     if (cfile.cinfo.col_fmt[i] == COL_INFO)
1425       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_INFO_LEN);
1426     else
1427       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
1428     cfile.cinfo.col_fence[i] = 0;
1429     cfile.cinfo.col_expr.col_expr[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
1430     cfile.cinfo.col_expr.col_expr_val[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
1431   }
1432
1433   for (i = 0; i < cfile.cinfo.num_cols; i++) {
1434       int j;
1435
1436       for (j = 0; j < NUM_COL_FMTS; j++) {
1437          if (!cfile.cinfo.fmt_matx[i][j])
1438              continue;
1439
1440          if (cfile.cinfo.col_first[j] == -1)
1441              cfile.cinfo.col_first[j] = i;
1442          cfile.cinfo.col_last[j] = i;
1443       }
1444   }
1445
1446 #ifdef HAVE_LIBPCAP
1447   capture_opts_trim_snaplen(&capture_opts, MIN_PACKET_SIZE);
1448   capture_opts_trim_ring_num_files(&capture_opts);
1449 #endif
1450
1451   if (rfilter != NULL) {
1452     if (!dfilter_compile(rfilter, &rfcode)) {
1453       cmdarg_err("%s", dfilter_error_msg);
1454       epan_cleanup();
1455 #ifdef HAVE_PCAP_OPEN_DEAD
1456       {
1457         pcap_t *pc;
1458
1459         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1460         if (pc != NULL) {
1461           if (pcap_compile(pc, &fcode, rfilter, 0, 0) != -1) {
1462             cmdarg_err_cont(
1463               "  Note: That display filter code looks like a valid capture filter;");
1464             cmdarg_err_cont(
1465               "        maybe you mixed them up?");
1466           }
1467           pcap_close(pc);
1468         }
1469       }
1470 #endif
1471       exit(2);
1472     }
1473   }
1474   cfile.rfcode = rfcode;
1475
1476   if (print_packet_info) {
1477     /* If we're printing as text or PostScript, we have
1478        to create a print stream. */
1479     if (output_action == WRITE_TEXT) {
1480       switch (print_format) {
1481
1482       case PR_FMT_TEXT:
1483         print_stream = print_stream_text_stdio_new(stdout);
1484         break;
1485
1486       case PR_FMT_PS:
1487         print_stream = print_stream_ps_stdio_new(stdout);
1488         break;
1489
1490       default:
1491         g_assert_not_reached();
1492       }
1493     }
1494   }
1495
1496   /* We have to dissect each packet if:
1497
1498         we're printing information about each packet;
1499
1500         we're using a read filter on the packets;
1501
1502         we're using any taps. */
1503   do_dissection = print_packet_info || rfcode || have_tap_listeners();
1504
1505   if (cf_name) {
1506     /*
1507      * We're reading a capture file.
1508      */
1509
1510     /*
1511      * Immediately relinquish any special privileges we have; we must not
1512      * be allowed to read any capture files the user running TShark
1513      * can't open.
1514      */
1515     relinquish_special_privs_perm();
1516     print_current_user();
1517
1518     if (cf_open(&cfile, cf_name, FALSE, &err) != CF_OK) {
1519       epan_cleanup();
1520       exit(2);
1521     }
1522
1523     /* Set timestamp precision; there should arguably be a command-line
1524        option to let the user set this. */
1525     switch(wtap_file_tsprecision(cfile.wth)) {
1526     case(WTAP_FILE_TSPREC_SEC):
1527       timestamp_set_precision(TS_PREC_AUTO_SEC);
1528       break;
1529     case(WTAP_FILE_TSPREC_DSEC):
1530       timestamp_set_precision(TS_PREC_AUTO_DSEC);
1531       break;
1532     case(WTAP_FILE_TSPREC_CSEC):
1533       timestamp_set_precision(TS_PREC_AUTO_CSEC);
1534       break;
1535     case(WTAP_FILE_TSPREC_MSEC):
1536       timestamp_set_precision(TS_PREC_AUTO_MSEC);
1537       break;
1538     case(WTAP_FILE_TSPREC_USEC):
1539       timestamp_set_precision(TS_PREC_AUTO_USEC);
1540       break;
1541     case(WTAP_FILE_TSPREC_NSEC):
1542       timestamp_set_precision(TS_PREC_AUTO_NSEC);
1543       break;
1544     default:
1545       g_assert_not_reached();
1546     }
1547
1548     /* Process the packets in the file */
1549 #ifdef HAVE_LIBPCAP
1550     err = load_cap_file(&cfile, capture_opts.save_file, out_file_type,
1551         capture_opts.has_autostop_packets ? capture_opts.autostop_packets : 0,
1552         capture_opts.has_autostop_filesize ? capture_opts.autostop_filesize : 0);
1553 #else
1554     err = load_cap_file(&cfile, NULL, out_file_type, 0, 0);
1555 #endif
1556     if (err != 0) {
1557       epan_cleanup();
1558       exit(2);
1559     }
1560     cf_name[0] = '\0';
1561   } else {
1562     /* No capture file specified, so we're supposed to do a live capture
1563        (or get a list of link-layer types for a live capture device);
1564        do we have support for live captures? */
1565 #ifdef HAVE_LIBPCAP
1566
1567 #ifdef _WIN32
1568     if (!has_wpcap) {
1569       char *detailed_err;
1570
1571       cmdarg_err("WinPcap couldn't be found.");
1572       detailed_err = cant_load_winpcap_err("TShark");
1573       cmdarg_err_cont("%s", detailed_err);
1574       g_free(detailed_err);
1575       exit(2);
1576     }
1577 #endif
1578
1579     /* trim the interface name and exit if that failed */
1580     if (!capture_opts_trim_iface(&capture_opts,
1581         (prefs->capture_device) ? get_if_name(prefs->capture_device) : NULL)) {
1582         exit(2);
1583     }
1584
1585     /* if requested, list the link layer types and exit */
1586     if (list_link_layer_types) {
1587         status = capture_opts_list_link_layer_types(&capture_opts, FALSE);
1588         exit(status);
1589     }
1590
1591     if (print_packet_info) {
1592       if (!write_preamble(NULL)) {
1593         err = errno;
1594         show_print_file_io_error(err);
1595         return err;
1596       }
1597     } else if (!quiet) {
1598       /*
1599        * We're not printing information for each packet, and the user
1600        * didn't ask us not to print a count of packets as they arrive,
1601        * so print that count so the user knows that packets are arriving.
1602        *
1603        * XXX - what if the user wants to do a live capture, doesn't want
1604        * to save it to a file, doesn't want information printed for each
1605        * packet, does want some "-z" statistic, and wants packet counts
1606        * so they know whether they're seeing any packets?
1607        */
1608       print_packet_counts = TRUE;
1609     }
1610
1611     /* For now, assume libpcap gives microsecond precision. */
1612     timestamp_set_precision(TS_PREC_AUTO_USEC);
1613
1614     capture();
1615
1616     if (print_packet_info) {
1617       if (!write_finale()) {
1618         err = errno;
1619         show_print_file_io_error(err);
1620       }
1621     }
1622 #else
1623     /* No - complain. */
1624     cmdarg_err("This version of TShark was not built with support for capturing packets.");
1625     exit(2);
1626 #endif
1627   }
1628
1629   draw_tap_listeners(TRUE);
1630   funnel_dump_all_text_windows();
1631   epan_cleanup();
1632
1633   output_fields_free(output_fields);
1634   output_fields = NULL;
1635
1636   return 0;
1637 }
1638
1639 /*#define USE_BROKEN_G_MAIN_LOOP*/
1640
1641 #ifdef USE_BROKEN_G_MAIN_LOOP
1642   GMainLoop *loop;
1643 #else
1644   gboolean loop_running = FALSE;
1645 #endif
1646   guint32 packet_count = 0;
1647
1648
1649 /* XXX - move to the right position / file */
1650 /* read from a pipe (callback) */
1651 typedef gboolean (*pipe_input_cb_t) (gint source, gpointer user_data);
1652
1653 typedef struct pipe_input_tag {
1654     gint                source;
1655     gpointer            user_data;
1656     int                 *child_process;
1657     pipe_input_cb_t     input_cb;
1658     guint               pipe_input_id;
1659 #ifdef _WIN32
1660     GStaticMutex                callback_running;
1661 #endif
1662 } pipe_input_t;
1663
1664 static pipe_input_t pipe_input;
1665
1666 #ifdef _WIN32
1667 /* The timer has expired, see if there's stuff to read from the pipe,
1668    if so, do the callback */
1669 static gint
1670 pipe_timer_cb(gpointer data)
1671 {
1672   HANDLE handle;
1673   DWORD avail = 0;
1674   gboolean result, result1;
1675   DWORD childstatus;
1676   pipe_input_t *pipe_input = data;
1677   gint iterations = 0;
1678
1679
1680   g_static_mutex_lock (&pipe_input->callback_running);
1681
1682   /* try to read data from the pipe only 5 times, to avoid blocking */
1683   while(iterations < 5) {
1684           /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: new iteration");*/
1685
1686           /* Oddly enough although Named pipes don't work on win9x,
1687                  PeekNamedPipe does !!! */
1688           handle = (HANDLE) _get_osfhandle (pipe_input->source);
1689           result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
1690
1691           /* Get the child process exit status */
1692           result1 = GetExitCodeProcess((HANDLE)*(pipe_input->child_process),
1693                                                                    &childstatus);
1694
1695           /* If the Peek returned an error, or there are bytes to be read
1696                  or the childwatcher thread has terminated then call the normal
1697                  callback */
1698           if (!result || avail > 0 || childstatus != STILL_ACTIVE) {
1699
1700                 /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: data avail");*/
1701
1702                 /* And call the real handler */
1703                 if (!pipe_input->input_cb(pipe_input->source, pipe_input->user_data)) {
1704                         g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: input pipe closed, iterations: %u", iterations);
1705                         /* pipe closed, return false so that the timer is stopped */
1706                         g_static_mutex_unlock (&pipe_input->callback_running);
1707                         return FALSE;
1708                 }
1709           }
1710           else {
1711                 /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: no data avail");*/
1712                 /* No data, stop now */
1713                 break;
1714           }
1715
1716           iterations++;
1717   }
1718
1719         /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: finished with iterations: %u, new timer", iterations);*/
1720
1721         g_static_mutex_unlock (&pipe_input->callback_running);
1722
1723         /* we didn't stopped the timer, so let it run */
1724         return TRUE;
1725 }
1726 #endif
1727
1728
1729 void
1730 pipe_input_set_handler(gint source, gpointer user_data, int *child_process, pipe_input_cb_t input_cb)
1731 {
1732
1733     pipe_input.source                   = source;
1734     pipe_input.child_process            = child_process;
1735     pipe_input.user_data                = user_data;
1736     pipe_input.input_cb                 = input_cb;
1737
1738 #ifdef _WIN32
1739     g_static_mutex_init(&pipe_input.callback_running);
1740     /* Tricky to use pipes in win9x, as no concept of wait.  NT can
1741        do this but that doesn't cover all win32 platforms.  GTK can do
1742        this but doesn't seem to work over processes.  Attempt to do
1743        something similar here, start a timer and check for data on every
1744        timeout. */
1745         /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_input_set_handler: new");*/
1746     pipe_input.pipe_input_id = g_timeout_add(200, pipe_timer_cb, &pipe_input);
1747 #endif
1748 }
1749
1750
1751 #ifdef HAVE_LIBPCAP
1752 static int
1753 capture(void)
1754 {
1755   gboolean ret;
1756 #ifdef USE_TSHARK_SELECT
1757   fd_set readfds;
1758 #endif
1759 #ifndef _WIN32
1760   struct sigaction action, oldaction;
1761 #endif
1762
1763   /*
1764    * XXX - dropping privileges is still required, until code cleanup is done
1765    *
1766    * remove all dependencies to pcap specific code and using only dumpcap is almost done.
1767    * when it's done, we don't need special privileges to run tshark at all,
1768    * therefore we don't need to drop these privileges
1769    * The only thing we might want to keep is a warning if tshark is run as root,
1770    * as it's no longer necessary and potentially dangerous.
1771    *
1772    * THE FOLLOWING IS THE FORMER COMMENT WHICH IS NO LONGER REALLY VALID:
1773    * We've opened the capture device, so we shouldn't need any special
1774    * privileges any more; relinquish those privileges.
1775    *
1776    * XXX - if we have saved set-user-ID support, we should give up those
1777    * privileges immediately, and then reclaim them long enough to get
1778    * a list of network interfaces and to open one, and then give them
1779    * up again, so that stuff we do while processing the argument list,
1780    * reading the user's preferences, loading and starting plugins
1781    * (especially *user* plugins), etc. is done with the user's privileges,
1782    * not special privileges.
1783    */
1784   relinquish_special_privs_perm();
1785   print_current_user();
1786
1787   /* Initialize all data structures used for dissection. */
1788   init_dissection();
1789
1790 #ifdef _WIN32
1791   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
1792   SetConsoleCtrlHandler(capture_cleanup, TRUE);
1793 #else /* _WIN32 */
1794   /* Catch SIGINT and SIGTERM and, if we get either of them, clean up
1795      and exit. */
1796   action.sa_handler = capture_cleanup;
1797   action.sa_flags = 0;
1798   sigemptyset(&action.sa_mask);
1799   sigaction(SIGTERM, &action, NULL);
1800   sigaction(SIGINT, &action, NULL);
1801   sigaction(SIGHUP, NULL, &oldaction);
1802   if (oldaction.sa_handler == SIG_DFL)
1803     sigaction(SIGHUP, &action, NULL);
1804
1805 #ifdef SIGINFO
1806   /* Catch SIGINFO and, if we get it and we're capturing to a file in
1807      quiet mode, report the number of packets we've captured. */
1808   action.sa_handler = report_counts_siginfo;
1809   action.sa_flags = 0;
1810   sigemptyset(&action.sa_mask);
1811   sigaction(SIGINFO, &action, NULL);
1812 #endif /* SIGINFO */
1813 #endif /* _WIN32 */
1814
1815   capture_opts.state = CAPTURE_PREPARING;
1816
1817   /* Let the user know what interface was chosen. */
1818   capture_opts.iface_descr = get_interface_descriptive_name(capture_opts.iface);
1819   fprintf(stderr, "Capturing on %s\n", capture_opts.iface_descr);
1820
1821   ret = sync_pipe_start(&capture_opts);
1822
1823   if (!ret)
1824     return FALSE;
1825
1826     /* the actual capture loop
1827      *
1828      * XXX - glib doesn't seem to provide any event based loop handling.
1829      *
1830      * XXX - for whatever reason,
1831      * calling g_main_loop_new() ends up in 100% cpu load.
1832      *
1833      * But that doesn't matter: in UNIX we can use select() to find an input
1834      * source with something to do.
1835      *
1836      * But that doesn't matter because we're in a CLI (that doesn't need to
1837      * update a GUI or something at the same time) so it's OK if we block
1838      * trying to read from the pipe.
1839      *
1840      * So all the stuff in USE_TSHARK_SELECT could be removed unless I'm
1841      * wrong (but I leave it there in case I am...).
1842      */
1843
1844 #ifdef USE_TSHARK_SELECT
1845   FD_ZERO(&readfds);
1846   FD_SET(pipe_input.source, &readfds);
1847 #endif
1848
1849   loop_running = TRUE;
1850
1851   while (loop_running)
1852   {
1853 #ifdef USE_TSHARK_SELECT
1854     ret = select(pipe_input.source+1, &readfds, NULL, NULL, NULL);
1855
1856     if (ret == -1)
1857     {
1858       perror("select()");
1859       return TRUE;
1860     } else if (ret == 1) {
1861 #endif
1862       /* Call the real handler */
1863       if (!pipe_input.input_cb(pipe_input.source, pipe_input.user_data)) {
1864         g_log(NULL, G_LOG_LEVEL_DEBUG, "input pipe closed");
1865         return FALSE;
1866       }
1867 #ifdef USE_TSHARK_SELECT
1868     }
1869 #endif
1870   }
1871
1872   return TRUE;
1873 }
1874
1875
1876 /* XXX - move the call to main_window_update() out of capture_sync.c */
1877 /* dummy for capture_sync.c to make linker happy */
1878 void main_window_update(void)
1879 {
1880 }
1881
1882 /* capture child detected an error */
1883 void
1884 capture_input_error_message(capture_options *capture_opts _U_, char *error_msg, char *secondary_error_msg)
1885 {
1886         cmdarg_err("%s", error_msg);
1887         cmdarg_err_cont("%s", secondary_error_msg);
1888 }
1889
1890
1891 /* capture child detected an capture filter related error */
1892 void
1893 capture_input_cfilter_error_message(capture_options *capture_opts, char *error_message)
1894 {
1895     dfilter_t   *rfcode = NULL;
1896
1897
1898     if (dfilter_compile(capture_opts->cfilter, &rfcode) && rfcode != NULL) {
1899       cmdarg_err(
1900         "Invalid capture filter: \"%s\"!\n"
1901         "\n"
1902         "That string looks like a valid display filter; however, it isn't a valid\n"
1903         "capture filter (%s).\n"
1904         "\n"
1905         "Note that display filters and capture filters don't have the same syntax,\n"
1906         "so you can't use most display filter expressions as capture filters.\n"
1907         "\n"
1908         "See the User's Guide for a description of the capture filter syntax.",
1909         capture_opts->cfilter, error_message);
1910       dfilter_free(rfcode);
1911     } else {
1912       cmdarg_err(
1913         "Invalid capture filter: \"%s\"!\n"
1914         "\n"
1915         "That string isn't a valid capture filter (%s).\n"
1916         "See the User's Guide for a description of the capture filter syntax.",
1917         capture_opts->cfilter, error_message);
1918     }
1919 }
1920
1921
1922 /* capture child tells us we have a new (or the first) capture file */
1923 gboolean
1924 capture_input_new_file(capture_options *capture_opts, gchar *new_file)
1925 {
1926   gboolean is_tempfile;
1927   int  err;
1928
1929
1930   if(capture_opts->state == CAPTURE_PREPARING) {
1931     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started!");
1932   }
1933   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
1934
1935   g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING);
1936
1937   capture_opts->cf = &cfile;
1938
1939   /* free the old filename */
1940   if(capture_opts->save_file != NULL) {
1941     /* we start a new capture file, close the old one (if we had one before) */
1942     if( ((capture_file *) capture_opts->cf)->state != FILE_CLOSED) {
1943                 if(capture_opts->cf != NULL && ((capture_file *) capture_opts->cf)->wth != NULL) {
1944                         wtap_close(((capture_file *) capture_opts->cf)->wth);
1945                 }
1946     }
1947     g_free(capture_opts->save_file);
1948     is_tempfile = FALSE;
1949   } else {
1950     /* we didn't had a save_file before, must be a tempfile */
1951     is_tempfile = TRUE;
1952   }
1953
1954   /* save the new filename */
1955   capture_opts->save_file = g_strdup(new_file);
1956
1957   /* if we are in real-time mode, open the new file now */
1958   if(do_dissection) {
1959     /* Attempt to open the capture file and set up to read from it. */
1960     switch(cf_open(capture_opts->cf, capture_opts->save_file, is_tempfile, &err)) {
1961     case CF_OK:
1962       break;
1963     case CF_ERROR:
1964       /* Don't unlink (delete) the save file - leave it around,
1965          for debugging purposes. */
1966       g_free(capture_opts->save_file);
1967       capture_opts->save_file = NULL;
1968       return FALSE;
1969     }
1970   }
1971
1972   capture_opts->state = CAPTURE_RUNNING;
1973
1974   return TRUE;
1975 }
1976
1977
1978 /* capture child tells us we have new packets to read */
1979 void
1980 capture_input_new_packets(capture_options *capture_opts, int to_read)
1981 {
1982   gboolean     ret;
1983   int          err;
1984   gchar        *err_info;
1985   gint64       data_offset;
1986   capture_file *cf = capture_opts->cf;
1987
1988
1989 #ifdef SIGINFO
1990   /*
1991    * Prevent a SIGINFO handler from writing to stdout while we're
1992    * doing so; instead, have it just set a flag telling us to print
1993    * that information when we're done.
1994    */
1995   infodelay = TRUE;
1996 #endif /* SIGINFO */
1997
1998   if(do_dissection) {
1999     while (to_read-- && cf->wth) {
2000       ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
2001       if(ret == FALSE) {
2002         /* read from file failed, tell the capture child to stop */
2003         sync_pipe_stop(capture_opts);
2004         wtap_close(cf->wth);
2005         cf->wth = NULL;
2006       } else {
2007         ret = process_packet(cf, data_offset, wtap_phdr(cf->wth),
2008                              wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth));
2009       }
2010       if (ret != FALSE) {
2011         /* packet sucessfully read and gone through the "Read Filter" */
2012         packet_count++;
2013       }
2014     }
2015   } else {
2016     /*
2017      * Dumpcap's doing all the work; we're not doing any dissection.
2018      * Count all the packets it wrote.
2019      */
2020     packet_count += to_read;
2021   }
2022
2023   if (print_packet_counts) {
2024       /* We're printing packet counts. */
2025       if (packet_count != 0) {
2026         fprintf(stderr, "\r%u ", packet_count);
2027         /* stderr could be line buffered */
2028         fflush(stderr);
2029       }
2030   }
2031
2032 #ifdef SIGINFO
2033   /*
2034    * Allow SIGINFO handlers to write.
2035    */
2036   infodelay = FALSE;
2037
2038   /*
2039    * If a SIGINFO handler asked us to write out capture counts, do so.
2040    */
2041   if (infoprint)
2042     report_counts();
2043 #endif /* SIGINFO */
2044 }
2045
2046 static void
2047 report_counts(void)
2048 {
2049   if (!print_packet_counts) {
2050     /* Report the count only if we aren't printing a packet count
2051        as packets arrive. */
2052     fprintf(stderr, "%u packet%s captured\n", packet_count,
2053             plurality(packet_count, "", "s"));
2054   }
2055 #ifdef SIGINFO
2056   infoprint = FALSE; /* we just reported it */
2057 #endif /* SIGINFO */
2058 }
2059
2060 #ifdef SIGINFO
2061 static void
2062 report_counts_siginfo(int signum _U_)
2063 {
2064   int sav_errno = errno;
2065   /* If we've been told to delay printing, just set a flag asking
2066      that we print counts (if we're supposed to), otherwise print
2067      the count of packets captured (if we're supposed to). */
2068   if (infodelay)
2069     infoprint = TRUE;
2070   else
2071     report_counts();
2072   errno = sav_errno;
2073 }
2074 #endif /* SIGINFO */
2075
2076
2077 /* capture child detected any packet drops? */
2078 void
2079 capture_input_drops(capture_options *capture_opts _U_, int dropped)
2080 {
2081         if (print_packet_counts) {
2082         /* We're printing packet counts to stderr.
2083            Send a newline so that we move to the line after the packet count. */
2084           fprintf(stderr, "\n");
2085         }
2086
2087         if(dropped != 0) {
2088                 /* We're printing packet counts to stderr.
2089                    Send a newline so that we move to the line after the packet count. */
2090                   fprintf(stderr, "%u packet%s dropped\n", dropped, plurality(dropped, "", "s"));
2091         }
2092 }
2093
2094
2095 /* capture child closed its side of the pipe, do the required cleanup */
2096 void
2097 capture_input_closed(capture_options *capture_opts)
2098 {
2099   report_counts();
2100
2101   if(capture_opts->cf != NULL && ((capture_file *) capture_opts->cf)->wth != NULL) {
2102     wtap_close(((capture_file *) capture_opts->cf)->wth);
2103   }
2104 #ifdef USE_BROKEN_G_MAIN_LOOP
2105   /*g_main_loop_quit(loop);*/
2106   g_main_quit(loop);
2107 #else
2108   loop_running = FALSE;
2109 #endif
2110 }
2111
2112
2113
2114
2115 #ifdef _WIN32
2116 static BOOL WINAPI
2117 capture_cleanup(DWORD ctrltype _U_)
2118 {
2119   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
2120      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
2121      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
2122      like SIGTERM at least when the machine's shutting down.
2123
2124      For now, we handle them all as indications that we should clean up
2125      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
2126      way on UNIX.
2127
2128      However, as handlers run in a new thread, we can't just longjmp
2129      out; we have to set "ld.go" to FALSE, and must return TRUE so that
2130      no other handler - such as one that would terminate the process -
2131      gets called.
2132
2133      XXX - for some reason, typing ^C to TShark, if you run this in
2134      a Cygwin console window in at least some versions of Cygwin,
2135      causes TShark to terminate immediately; this routine gets
2136      called, but the main loop doesn't get a chance to run and
2137      exit cleanly, at least if this is compiled with Microsoft Visual
2138      C++ (i.e., it's a property of the Cygwin console window or Bash;
2139      it happens if TShark is not built with Cygwin - for all I know,
2140      building it with Cygwin may make the problem go away). */
2141
2142   /* tell the capture child to stop */
2143   sync_pipe_stop(&capture_opts);
2144
2145   /* don't stop our own loop already here, otherwise status messages and
2146    * cleanup wouldn't be done properly. The child will indicate the stop of
2147    * everything by calling capture_input_closed() later */
2148
2149   return TRUE;
2150 }
2151 #else
2152 static void
2153 capture_cleanup(int signum _U_)
2154 {
2155   /* tell the capture child to stop */
2156   sync_pipe_stop(&capture_opts);
2157 }
2158 #endif /* _WIN32 */
2159 #endif /* HAVE_LIBPCAP */
2160
2161 static int
2162 load_cap_file(capture_file *cf, char *save_file, int out_file_type,
2163     int max_packet_count, gint64 max_byte_count)
2164 {
2165   gint         linktype;
2166   int          snapshot_length;
2167   wtap_dumper *pdh;
2168   int          err;
2169   gchar        *err_info;
2170   gint64       data_offset;
2171   char         *save_file_string = NULL;
2172
2173   linktype = wtap_file_encap(cf->wth);
2174   if (save_file != NULL) {
2175     /* Get a string that describes what we're writing to */
2176     save_file_string = output_file_description(save_file);
2177
2178     /* Set up to write to the capture file. */
2179     snapshot_length = wtap_snapshot_length(cf->wth);
2180     if (snapshot_length == 0) {
2181       /* Snapshot length of input file not known. */
2182       snapshot_length = WTAP_MAX_PACKET_SIZE;
2183     }
2184     pdh = wtap_dump_open(save_file, out_file_type, linktype, snapshot_length,
2185                          FALSE /* compressed */, &err);
2186
2187     if (pdh == NULL) {
2188       /* We couldn't set up to write to the capture file. */
2189       switch (err) {
2190
2191       case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
2192         cmdarg_err("Capture files can't be written in that format.");
2193         break;
2194
2195       case WTAP_ERR_UNSUPPORTED_ENCAP:
2196       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
2197         cmdarg_err("The capture file being read can't be written in "
2198           "that format.");
2199         break;
2200
2201       case WTAP_ERR_CANT_OPEN:
2202         cmdarg_err("The %s couldn't be created for some "
2203           "unknown reason.", save_file_string);
2204         break;
2205
2206       case WTAP_ERR_SHORT_WRITE:
2207         cmdarg_err("A full header couldn't be written to the %s.",
2208                    save_file_string);
2209         break;
2210
2211       default:
2212         cmdarg_err("The %s could not be created: %s.", save_file_string,
2213                    wtap_strerror(err));
2214         break;
2215       }
2216       goto out;
2217     }
2218   } else {
2219     if (print_packet_info) {
2220       if (!write_preamble(cf)) {
2221         err = errno;
2222         show_print_file_io_error(err);
2223         goto out;
2224       }
2225     }
2226     pdh = NULL;
2227   }
2228   while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
2229     if (process_packet(cf, data_offset, wtap_phdr(cf->wth),
2230                        wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth))) {
2231       /* Either there's no read filtering or this packet passed the
2232          filter, so, if we're writing to a capture file, write
2233          this packet out. */
2234       if (pdh != NULL) {
2235         if (!wtap_dump(pdh, wtap_phdr(cf->wth),
2236                        wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth),
2237                        &err)) {
2238           /* Error writing to a capture file */
2239           show_capture_file_io_error(save_file, err, FALSE);
2240           wtap_dump_close(pdh, &err);
2241           exit(2);
2242         }
2243       }
2244       /* Stop reading if we have the maximum number of packets;
2245        * When the -c option has not been used, max_packet_count
2246        * starts at 0, which practically means, never stop reading.
2247        * (unless we roll over max_packet_count ?)
2248        */
2249       if( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
2250         err = 0; /* This is not an error */
2251         break;
2252       }
2253     }
2254   }
2255   if (err != 0) {
2256     /* Print a message noting that the read failed somewhere along the line. */
2257     switch (err) {
2258
2259     case WTAP_ERR_UNSUPPORTED_ENCAP:
2260       cmdarg_err("\"%s\" has a packet with a network type that TShark doesn't support.\n(%s)",
2261                  cf->filename, err_info);
2262       break;
2263
2264     case WTAP_ERR_CANT_READ:
2265       cmdarg_err("An attempt to read from \"%s\" failed for some unknown reason.",
2266                  cf->filename);
2267       break;
2268
2269     case WTAP_ERR_SHORT_READ:
2270       cmdarg_err("\"%s\" appears to have been cut short in the middle of a packet.",
2271                  cf->filename);
2272       break;
2273
2274     case WTAP_ERR_BAD_RECORD:
2275       cmdarg_err("\"%s\" appears to be damaged or corrupt.\n(%s)",
2276                  cf->filename, err_info);
2277       break;
2278
2279     default:
2280       cmdarg_err("An error occurred while reading \"%s\": %s.",
2281                  cf->filename, wtap_strerror(err));
2282       break;
2283     }
2284     if (save_file != NULL) {
2285       /* Now close the capture file. */
2286       if (!wtap_dump_close(pdh, &err))
2287         show_capture_file_io_error(save_file, err, TRUE);
2288     }
2289   } else {
2290     if (save_file != NULL) {
2291       /* Now close the capture file. */
2292       if (!wtap_dump_close(pdh, &err))
2293         show_capture_file_io_error(save_file, err, TRUE);
2294     } else {
2295       if (print_packet_info) {
2296         if (!write_finale()) {
2297           err = errno;
2298           show_print_file_io_error(err);
2299         }
2300       }
2301     }
2302   }
2303
2304 out:
2305   wtap_close(cf->wth);
2306   cf->wth = NULL;
2307
2308   if (save_file_string != NULL)
2309     g_free(save_file_string);
2310
2311   return err;
2312 }
2313
2314 static void
2315 fill_in_fdata(frame_data *fdata, capture_file *cf,
2316               const struct wtap_pkthdr *phdr, gint64 offset)
2317 {
2318   fdata->next = NULL;
2319   fdata->prev = NULL;
2320   fdata->pfd = NULL;
2321   fdata->num = cf->count;
2322   fdata->pkt_len = phdr->len;
2323   cum_bytes += phdr->len;
2324   fdata->cum_bytes  = cum_bytes;
2325   fdata->cap_len = phdr->caplen;
2326   fdata->file_off = offset;
2327   fdata->lnk_t = phdr->pkt_encap;
2328   fdata->abs_ts.secs = phdr->ts.secs;
2329   fdata->abs_ts.nsecs = phdr->ts.nsecs;
2330   fdata->flags.passed_dfilter = 0;
2331   fdata->flags.encoding = CHAR_ASCII;
2332   fdata->flags.visited = 0;
2333   fdata->flags.marked = 0;
2334   fdata->flags.ref_time = 0;
2335   fdata->color_filter = NULL;
2336
2337   /* If we don't have the time stamp of the first packet in the
2338      capture, it's because this is the first packet.  Save the time
2339      stamp of this packet as the time stamp of the first packet. */
2340   if (nstime_is_unset(&first_ts)) {
2341     first_ts = fdata->abs_ts;
2342   }
2343
2344   /* If we don't have the time stamp of the previous captured packet,
2345      it's because this is the first packet.  Save the time
2346      stamp of this packet as the time stamp of the previous captured
2347      packet. */
2348   if (nstime_is_unset(&prev_cap_ts)) {
2349     prev_cap_ts = fdata->abs_ts;
2350   }
2351
2352   /* Get the time elapsed between the first packet and this packet. */
2353   nstime_delta(&fdata->rel_ts, &fdata->abs_ts, &first_ts);
2354
2355   /* If it's greater than the current elapsed time, set the elapsed time
2356      to it (we check for "greater than" so as not to be confused by
2357      time moving backwards). */
2358   if ((gint32)cf->elapsed_time.secs < fdata->rel_ts.secs
2359         || ((gint32)cf->elapsed_time.secs == fdata->rel_ts.secs && (gint32)cf->elapsed_time.nsecs < fdata->rel_ts.nsecs)) {
2360     cf->elapsed_time = fdata->rel_ts;
2361   }
2362
2363   /* If we don't have the time stamp of the previous displayed packet,
2364      it's because this is the first packet that's being displayed.  Save the time
2365      stamp of this packet as the time stamp of the previous displayed
2366      packet. */
2367   if (nstime_is_unset(&prev_dis_ts))
2368     prev_dis_ts = fdata->abs_ts;
2369
2370   /* Get the time elapsed between the previous displayed packet and
2371      this packet. */
2372   nstime_delta(&fdata->del_dis_ts, &fdata->abs_ts, &prev_dis_ts);
2373
2374   /* Get the time elapsed between the previous captured packet and
2375      this packet. */
2376   nstime_delta(&fdata->del_cap_ts, &fdata->abs_ts, &prev_cap_ts);
2377   prev_cap_ts = fdata->abs_ts;
2378 }
2379
2380 /* Free up all data attached to a "frame_data" structure. */
2381 static void
2382 clear_fdata(frame_data *fdata)
2383 {
2384   if (fdata->pfd)
2385     g_slist_free(fdata->pfd);
2386 }
2387
2388 static gboolean
2389 process_packet(capture_file *cf, gint64 offset, const struct wtap_pkthdr *whdr,
2390                union wtap_pseudo_header *pseudo_header, const guchar *pd)
2391 {
2392   frame_data fdata;
2393   gboolean create_proto_tree;
2394   epan_dissect_t *edt;
2395   gboolean passed;
2396
2397   /* Count this packet. */
2398   cf->count++;
2399
2400   /* If we're going to print packet information, or we're going to
2401      run a read filter, or we're going to process taps, set up to
2402      do a dissection and do so. */
2403   if (do_dissection) {
2404     fill_in_fdata(&fdata, cf, whdr, offset);
2405
2406     if (print_packet_info) {
2407       /* Grab any resolved addresses */
2408
2409       if (g_resolv_flags) {
2410         host_name_lookup_process(NULL);
2411       }
2412     }
2413
2414     passed = TRUE;
2415     if (cf->rfcode || verbose || num_tap_filters!=0 || have_custom_cols(&cf->cinfo))
2416       create_proto_tree = TRUE;
2417     else
2418       create_proto_tree = FALSE;
2419     /* The protocol tree will be "visible", i.e., printed, only if we're
2420        printing packet details, which is true if we're printing stuff
2421        ("print_packet_info" is true) and we're in verbose mode ("verbose"
2422        is true). */
2423     edt = epan_dissect_new(create_proto_tree, print_packet_info && verbose);
2424
2425     /* If we're running a read filter, prime the epan_dissect_t with that
2426        filter. */
2427     if (cf->rfcode)
2428       epan_dissect_prime_dfilter(edt, cf->rfcode);
2429
2430     col_custom_prime_edt(edt, &cf->cinfo);
2431
2432     tap_queue_init(edt);
2433
2434     /* We only need the columns if we're printing packet info but we're
2435        *not* verbose; in verbose mode, we print the protocol tree, not
2436        the protocol summary. */
2437     epan_dissect_run(edt, pseudo_header, pd, &fdata,
2438                      (print_packet_info && !verbose) ? &cf->cinfo : NULL);
2439
2440     tap_push_tapped_queue(edt);
2441
2442     /* Run the read filter if we have one. */
2443     if (cf->rfcode)
2444       passed = dfilter_apply_edt(cf->rfcode, edt);
2445     else
2446       passed = TRUE;
2447   } else {
2448     /* We're not running a display filter and we're not printing any
2449        packet information, so we don't need to do a dissection, and all
2450        packets are processed. */
2451     edt = NULL;
2452     passed = TRUE;
2453   }
2454
2455   if (passed) {
2456     /* Keep the time of the current packet if the packet passed
2457        the read filter so that the delta time since last displayed
2458        packet can be calculated */
2459     prev_dis_ts = fdata.abs_ts;
2460
2461     /* Process this packet. */
2462     if (print_packet_info) {
2463       /* We're printing packet information; print the information for
2464          this packet. */
2465       print_packet(cf, edt);
2466
2467       /* The ANSI C standard does not appear to *require* that a line-buffered
2468          stream be flushed to the host environment whenever a newline is
2469          written, it just says that, on such a stream, characters "are
2470          intended to be transmitted to or from the host environment as a
2471          block when a new-line character is encountered".
2472
2473          The Visual C++ 6.0 C implementation doesn't do what is intended;
2474          even if you set a stream to be line-buffered, it still doesn't
2475          flush the buffer at the end of every line.
2476
2477          So, if the "-l" flag was specified, we flush the standard output
2478          at the end of a packet.  This will do the right thing if we're
2479          printing packet summary lines, and, as we print the entire protocol
2480          tree for a single packet without waiting for anything to happen,
2481          it should be as good as line-buffered mode if we're printing
2482          protocol trees.  (The whole reason for the "-l" flag in either
2483          tcpdump or TShark is to allow the output of a live capture to
2484          be piped to a program or script and to have that script see the
2485          information for the packet as soon as it's printed, rather than
2486          having to wait until a standard I/O buffer fills up. */
2487       if (line_buffered)
2488         fflush(stdout);
2489
2490       if (ferror(stdout)) {
2491         show_print_file_io_error(errno);
2492         exit(2);
2493       }
2494     }
2495   }
2496
2497   if (do_dissection) {
2498     epan_dissect_free(edt);
2499     clear_fdata(&fdata);
2500   }
2501   return passed;
2502 }
2503
2504 static void
2505 show_capture_file_io_error(const char *fname, int err, gboolean is_close)
2506 {
2507   char *save_file_string;
2508
2509   save_file_string = output_file_description(fname);
2510
2511   switch (err) {
2512
2513   case ENOSPC:
2514     cmdarg_err("Not all the packets could be written to the %s because there is "
2515                "no space left on the file system.",
2516                save_file_string);
2517     break;
2518
2519 #ifdef EDQUOT
2520   case EDQUOT:
2521     cmdarg_err("Not all the packets could be written to the %s because you are "
2522                "too close to, or over your disk quota.",
2523                save_file_string);
2524   break;
2525 #endif
2526
2527   case WTAP_ERR_CANT_CLOSE:
2528     cmdarg_err("The %s couldn't be closed for some unknown reason.",
2529                save_file_string);
2530     break;
2531
2532   case WTAP_ERR_SHORT_WRITE:
2533     cmdarg_err("Not all the packets could be written to the %s.",
2534                save_file_string);
2535     break;
2536
2537   default:
2538     if (is_close) {
2539       cmdarg_err("The %s could not be closed: %s.", save_file_string,
2540                  wtap_strerror(err));
2541     } else {
2542       cmdarg_err("An error occurred while writing to the %s: %s.",
2543                  save_file_string, wtap_strerror(err));
2544     }
2545     break;
2546   }
2547   g_free(save_file_string);
2548 }
2549
2550 static gboolean
2551 write_preamble(capture_file *cf)
2552 {
2553   switch (output_action) {
2554
2555   case WRITE_TEXT:
2556     return print_preamble(print_stream, cf ? cf->filename : NULL);
2557
2558   case WRITE_XML:
2559     if (verbose)
2560       write_pdml_preamble(stdout);
2561     else
2562       write_psml_preamble(stdout);
2563     return !ferror(stdout);
2564
2565   case WRITE_FIELDS:
2566     write_fields_preamble(output_fields, stdout);
2567     return !ferror(stdout);
2568
2569   default:
2570     g_assert_not_reached();
2571     return FALSE;
2572   }
2573 }
2574
2575 static char *
2576 get_line_buf(size_t len)
2577 {
2578   static char *line_bufp = NULL;
2579   static size_t line_buf_len = 256;
2580   size_t new_line_buf_len;
2581
2582   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
2583        new_line_buf_len *= 2)
2584     ;
2585   if (line_bufp == NULL) {
2586     line_buf_len = new_line_buf_len;
2587     line_bufp = g_malloc(line_buf_len + 1);
2588   } else {
2589     if (new_line_buf_len > line_buf_len) {
2590       line_buf_len = new_line_buf_len;
2591       line_bufp = g_realloc(line_bufp, line_buf_len + 1);
2592     }
2593   }
2594   return line_bufp;
2595 }
2596
2597 static gboolean
2598 print_columns(capture_file *cf)
2599 {
2600   char *line_bufp;
2601   int i;
2602   size_t buf_offset;
2603   size_t column_len;
2604
2605   line_bufp = get_line_buf(256);
2606   buf_offset = 0;
2607   *line_bufp = '\0';
2608   for (i = 0; i < cf->cinfo.num_cols; i++) {
2609     switch (cf->cinfo.col_fmt[i]) {
2610     case COL_NUMBER:
2611 #ifdef HAVE_LIBPCAP
2612       /*
2613        * Don't print this if we're doing a live capture from a network
2614        * interface - if we're doing a live capture, you won't be
2615        * able to look at the capture in the future (it's not being
2616        * saved anywhere), so the frame numbers are unlikely to be
2617        * useful.
2618        *
2619        * (XXX - it might be nice to be able to save and print at
2620        * the same time, sort of like an "Update list of packets
2621        * in real time" capture in Wireshark.)
2622        */
2623       if (capture_opts.iface != NULL)
2624         continue;
2625 #endif
2626       column_len = strlen(cf->cinfo.col_data[i]);
2627       if (column_len < 3)
2628         column_len = 3;
2629       line_bufp = get_line_buf(buf_offset + column_len);
2630       sprintf(line_bufp + buf_offset, "%3s", cf->cinfo.col_data[i]);
2631       break;
2632
2633     case COL_CLS_TIME:
2634     case COL_REL_TIME:
2635     case COL_ABS_TIME:
2636     case COL_ABS_DATE_TIME: /* XXX - wider */
2637       column_len = strlen(cf->cinfo.col_data[i]);
2638       if (column_len < 10)
2639         column_len = 10;
2640       line_bufp = get_line_buf(buf_offset + column_len);
2641       sprintf(line_bufp + buf_offset, "%10s", cf->cinfo.col_data[i]);
2642       break;
2643
2644     case COL_DEF_SRC:
2645     case COL_RES_SRC:
2646     case COL_UNRES_SRC:
2647     case COL_DEF_DL_SRC:
2648     case COL_RES_DL_SRC:
2649     case COL_UNRES_DL_SRC:
2650     case COL_DEF_NET_SRC:
2651     case COL_RES_NET_SRC:
2652     case COL_UNRES_NET_SRC:
2653       column_len = strlen(cf->cinfo.col_data[i]);
2654       if (column_len < 12)
2655         column_len = 12;
2656       line_bufp = get_line_buf(buf_offset + column_len);
2657       sprintf(line_bufp + buf_offset, "%12s", cf->cinfo.col_data[i]);
2658       break;
2659
2660     case COL_DEF_DST:
2661     case COL_RES_DST:
2662     case COL_UNRES_DST:
2663     case COL_DEF_DL_DST:
2664     case COL_RES_DL_DST:
2665     case COL_UNRES_DL_DST:
2666     case COL_DEF_NET_DST:
2667     case COL_RES_NET_DST:
2668     case COL_UNRES_NET_DST:
2669       column_len = strlen(cf->cinfo.col_data[i]);
2670       if (column_len < 12)
2671         column_len = 12;
2672       line_bufp = get_line_buf(buf_offset + column_len);
2673       sprintf(line_bufp + buf_offset, "%-12s", cf->cinfo.col_data[i]);
2674       break;
2675
2676     default:
2677       column_len = strlen(cf->cinfo.col_data[i]);
2678       line_bufp = get_line_buf(buf_offset + column_len);
2679       strcat(line_bufp + buf_offset, cf->cinfo.col_data[i]);
2680       break;
2681     }
2682     buf_offset += column_len;
2683     if (i != cf->cinfo.num_cols - 1) {
2684       /*
2685        * This isn't the last column, so we need to print a
2686        * separator between this column and the next.
2687        *
2688        * If we printed a network source and are printing a
2689        * network destination of the same type next, separate
2690        * them with "->"; if we printed a network destination
2691        * and are printing a network source of the same type
2692        * next, separate them with "<-"; otherwise separate them
2693        * with a space.
2694        *
2695        * We add enough space to the buffer for " <- " or " -> ",
2696        * even if we're only adding " ".
2697        */
2698       line_bufp = get_line_buf(buf_offset + 4);
2699       switch (cf->cinfo.col_fmt[i]) {
2700
2701       case COL_DEF_SRC:
2702       case COL_RES_SRC:
2703       case COL_UNRES_SRC:
2704         switch (cf->cinfo.col_fmt[i + 1]) {
2705
2706         case COL_DEF_DST:
2707         case COL_RES_DST:
2708         case COL_UNRES_DST:
2709           strcat(line_bufp + buf_offset, " -> ");
2710           buf_offset += 4;
2711           break;
2712
2713         default:
2714           strcat(line_bufp + buf_offset, " ");
2715           buf_offset += 1;
2716           break;
2717         }
2718         break;
2719
2720       case COL_DEF_DL_SRC:
2721       case COL_RES_DL_SRC:
2722       case COL_UNRES_DL_SRC:
2723         switch (cf->cinfo.col_fmt[i + 1]) {
2724
2725         case COL_DEF_DL_DST:
2726         case COL_RES_DL_DST:
2727         case COL_UNRES_DL_DST:
2728           strcat(line_bufp + buf_offset, " -> ");
2729           buf_offset += 4;
2730           break;
2731
2732         default:
2733           strcat(line_bufp + buf_offset, " ");
2734           buf_offset += 1;
2735           break;
2736         }
2737         break;
2738
2739       case COL_DEF_NET_SRC:
2740       case COL_RES_NET_SRC:
2741       case COL_UNRES_NET_SRC:
2742         switch (cf->cinfo.col_fmt[i + 1]) {
2743
2744         case COL_DEF_NET_DST:
2745         case COL_RES_NET_DST:
2746         case COL_UNRES_NET_DST:
2747           strcat(line_bufp + buf_offset, " -> ");
2748           buf_offset += 4;
2749           break;
2750
2751         default:
2752           strcat(line_bufp + buf_offset, " ");
2753           buf_offset += 1;
2754           break;
2755         }
2756         break;
2757
2758       case COL_DEF_DST:
2759       case COL_RES_DST:
2760       case COL_UNRES_DST:
2761         switch (cf->cinfo.col_fmt[i + 1]) {
2762
2763         case COL_DEF_SRC:
2764         case COL_RES_SRC:
2765         case COL_UNRES_SRC:
2766           strcat(line_bufp + buf_offset, " <- ");
2767           buf_offset += 4;
2768           break;
2769
2770         default:
2771           strcat(line_bufp + buf_offset, " ");
2772           buf_offset += 1;
2773           break;
2774         }
2775         break;
2776
2777       case COL_DEF_DL_DST:
2778       case COL_RES_DL_DST:
2779       case COL_UNRES_DL_DST:
2780         switch (cf->cinfo.col_fmt[i + 1]) {
2781
2782         case COL_DEF_DL_SRC:
2783         case COL_RES_DL_SRC:
2784         case COL_UNRES_DL_SRC:
2785           strcat(line_bufp + buf_offset, " <- ");
2786           buf_offset += 4;
2787           break;
2788
2789         default:
2790           strcat(line_bufp + buf_offset, " ");
2791           buf_offset += 1;
2792           break;
2793         }
2794         break;
2795
2796       case COL_DEF_NET_DST:
2797       case COL_RES_NET_DST:
2798       case COL_UNRES_NET_DST:
2799         switch (cf->cinfo.col_fmt[i + 1]) {
2800
2801         case COL_DEF_NET_SRC:
2802         case COL_RES_NET_SRC:
2803         case COL_UNRES_NET_SRC:
2804           strcat(line_bufp + buf_offset, " <- ");
2805           buf_offset += 4;
2806           break;
2807
2808         default:
2809           strcat(line_bufp + buf_offset, " ");
2810           buf_offset += 1;
2811           break;
2812         }
2813         break;
2814
2815       default:
2816         strcat(line_bufp + buf_offset, " ");
2817         buf_offset += 1;
2818         break;
2819       }
2820     }
2821   }
2822   return print_line(print_stream, 0, line_bufp);
2823 }
2824
2825 static gboolean
2826 print_packet(capture_file *cf, epan_dissect_t *edt)
2827 {
2828   print_args_t  print_args;
2829
2830   if (verbose) {
2831     /* Print the information in the protocol tree. */
2832     switch (output_action) {
2833
2834     case WRITE_TEXT:
2835       print_args.to_file = TRUE;
2836       print_args.format = print_format;
2837       print_args.print_summary = !verbose;
2838       print_args.print_hex = verbose && print_hex;
2839       print_args.print_formfeed = FALSE;
2840       print_args.print_dissections = verbose ? print_dissections_expanded : print_dissections_none;
2841
2842       /* init the packet range */
2843       packet_range_init(&print_args.range);
2844
2845       if (!proto_tree_print(&print_args, edt, print_stream))
2846         return FALSE;
2847       if (!print_hex) {
2848         /* "print_hex_data()" will put out a leading blank line, as well
2849          as a trailing one; print one here, to separate the packets,
2850          only if "print_hex_data()" won't be called. */
2851         if (!print_line(print_stream, 0, ""))
2852           return FALSE;
2853       }
2854       break;
2855
2856     case WRITE_XML:
2857       proto_tree_write_pdml(edt, stdout);
2858       printf("\n");
2859       return !ferror(stdout);
2860     case WRITE_FIELDS:
2861       proto_tree_write_fields(output_fields, edt, stdout);
2862       printf("\n");
2863       return !ferror(stdout);
2864     }
2865   } else {
2866     /* Just fill in the columns. */
2867     epan_dissect_fill_in_columns(edt);
2868
2869     /* Now print them. */
2870     switch (output_action) {
2871
2872     case WRITE_TEXT:
2873         if (!print_columns(cf))
2874           return FALSE;
2875         break;
2876
2877     case WRITE_XML:
2878         proto_tree_write_psml(edt, stdout);
2879         return !ferror(stdout);
2880     case WRITE_FIELDS: /*No non-verbose "fields" format */
2881         g_assert_not_reached();
2882         break;
2883     }
2884   }
2885   if (print_hex) {
2886     if (!print_hex_data(print_stream, edt))
2887       return FALSE;
2888     if (!print_line(print_stream, 0, ""))
2889       return FALSE;
2890   }
2891   return TRUE;
2892 }
2893
2894 static gboolean
2895 write_finale(void)
2896 {
2897   switch (output_action) {
2898
2899   case WRITE_TEXT:
2900     return print_finale(print_stream);
2901
2902   case WRITE_XML:
2903     if (verbose)
2904       write_pdml_finale(stdout);
2905     else
2906       write_psml_finale(stdout);
2907     return !ferror(stdout);
2908
2909   case WRITE_FIELDS:
2910     write_fields_finale(output_fields, stdout);
2911     return !ferror(stdout);
2912
2913   default:
2914     g_assert_not_reached();
2915     return FALSE;
2916   }
2917 }
2918
2919 static void
2920 show_print_file_io_error(int err)
2921 {
2922   switch (err) {
2923
2924   case ENOSPC:
2925     cmdarg_err("Not all the packets could be printed because there is "
2926 "no space left on the file system.");
2927     break;
2928
2929 #ifdef EDQUOT
2930   case EDQUOT:
2931     cmdarg_err("Not all the packets could be printed because you are "
2932 "too close to, or over your disk quota.");
2933   break;
2934 #endif
2935
2936   default:
2937     cmdarg_err("An error occurred while printing packets: %s.",
2938       strerror(err));
2939     break;
2940   }
2941 }
2942
2943 static const char *
2944 cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
2945                       int file_type)
2946 {
2947   const char *errmsg;
2948   static char errmsg_errno[1024+1];
2949
2950   if (err < 0) {
2951     /* Wiretap error. */
2952     switch (err) {
2953
2954     case WTAP_ERR_NOT_REGULAR_FILE:
2955       errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
2956       break;
2957
2958     case WTAP_ERR_FILE_UNKNOWN_FORMAT:
2959       /* Seen only when opening a capture file for reading. */
2960       errmsg = "The file \"%s\" isn't a capture file in a format TShark understands.";
2961       break;
2962
2963     case WTAP_ERR_UNSUPPORTED:
2964       /* Seen only when opening a capture file for reading. */
2965       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2966                "The file \"%%s\" isn't a capture file in a format TShark understands.\n"
2967                "(%s)", err_info);
2968       g_free(err_info);
2969       errmsg = errmsg_errno;
2970       break;
2971
2972     case WTAP_ERR_CANT_WRITE_TO_PIPE:
2973       /* Seen only when opening a capture file for writing. */
2974       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2975                  "The file \"%%s\" is a pipe, and %s capture files can't be "
2976                  "written to a pipe.", wtap_file_type_string(file_type));
2977       errmsg = errmsg_errno;
2978       break;
2979
2980     case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
2981       /* Seen only when opening a capture file for writing. */
2982       errmsg = "TShark doesn't support writing capture files in that format.";
2983       break;
2984
2985     case WTAP_ERR_UNSUPPORTED_ENCAP:
2986       if (for_writing)
2987         errmsg = "TShark can't save this capture in that format.";
2988       else {
2989         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2990                  "The file \"%%s\" is a capture for a network type that TShark doesn't support.\n"
2991                  "(%s)", err_info);
2992         g_free(err_info);
2993         errmsg = errmsg_errno;
2994       }
2995       break;
2996
2997     case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
2998       if (for_writing)
2999         errmsg = "TShark can't save this capture in that format.";
3000       else
3001         errmsg = "The file \"%s\" is a capture for a network type that TShark doesn't support.";
3002       break;
3003
3004     case WTAP_ERR_BAD_RECORD:
3005       /* Seen only when opening a capture file for reading. */
3006       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3007                "The file \"%%s\" appears to be damaged or corrupt.\n"
3008                "(%s)", err_info);
3009       g_free(err_info);
3010       errmsg = errmsg_errno;
3011       break;
3012
3013     case WTAP_ERR_CANT_OPEN:
3014       if (for_writing)
3015         errmsg = "The file \"%s\" could not be created for some unknown reason.";
3016       else
3017         errmsg = "The file \"%s\" could not be opened for some unknown reason.";
3018       break;
3019
3020     case WTAP_ERR_SHORT_READ:
3021       errmsg = "The file \"%s\" appears to have been cut short"
3022                " in the middle of a packet or other data.";
3023       break;
3024
3025     case WTAP_ERR_SHORT_WRITE:
3026       errmsg = "A full header couldn't be written to the file \"%s\".";
3027       break;
3028
3029     default:
3030       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3031                  "The file \"%%s\" could not be %s: %s.",
3032                  for_writing ? "created" : "opened",
3033                  wtap_strerror(err));
3034       errmsg = errmsg_errno;
3035       break;
3036     }
3037   } else
3038     errmsg = file_open_error_message(err, for_writing);
3039   return errmsg;
3040 }
3041
3042 /*
3043  * Open/create errors are reported with an console message in TShark.
3044  */
3045 static void
3046 open_failure_message(const char *filename, int err, gboolean for_writing)
3047 {
3048   fprintf(stderr, "tshark: ");
3049   fprintf(stderr, file_open_error_message(err, for_writing), filename);
3050   fprintf(stderr, "\n");
3051 }
3052
3053 cf_status_t
3054 cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
3055 {
3056   wtap       *wth;
3057   gchar       *err_info;
3058   char        err_msg[2048+1];
3059
3060   wth = wtap_open_offline(fname, err, &err_info, FALSE);
3061   if (wth == NULL)
3062     goto fail;
3063
3064   /* The open succeeded.  Fill in the information for this file. */
3065
3066   /* Initialize all data structures used for dissection. */
3067   init_dissection();
3068
3069   cf->wth = wth;
3070   cf->f_datalen = 0; /* not used, but set it anyway */
3071
3072   /* Set the file name because we need it to set the follow stream filter.
3073      XXX - is that still true?  We need it for other reasons, though,
3074      in any case. */
3075   cf->filename = g_strdup(fname);
3076
3077   /* Indicate whether it's a permanent or temporary file. */
3078   cf->is_tempfile = is_tempfile;
3079
3080   /* If it's a temporary capture buffer file, mark it as not saved. */
3081   cf->user_saved = !is_tempfile;
3082
3083   cf->cd_t      = wtap_file_type(cf->wth);
3084   cf->count     = 0;
3085   cf->drops_known = FALSE;
3086   cf->drops     = 0;
3087   cf->snap      = wtap_snapshot_length(cf->wth);
3088   if (cf->snap == 0) {
3089     /* Snapshot length not known. */
3090     cf->has_snap = FALSE;
3091     cf->snap = WTAP_MAX_PACKET_SIZE;
3092   } else
3093     cf->has_snap = TRUE;
3094   nstime_set_zero(&cf->elapsed_time);
3095   nstime_set_unset(&first_ts);
3096   nstime_set_unset(&prev_dis_ts);
3097   nstime_set_unset(&prev_cap_ts);
3098
3099   return CF_OK;
3100
3101 fail:
3102   g_snprintf(err_msg, sizeof err_msg,
3103              cf_open_error_message(*err, err_info, FALSE, cf->cd_t), fname);
3104   cmdarg_err("%s", err_msg);
3105   return CF_ERROR;
3106 }
3107
3108
3109 /*
3110  * General errors are reported with an console message in TShark.
3111  */
3112 static void
3113 failure_message(const char *msg_format, va_list ap)
3114 {
3115   fprintf(stderr, "tshark: ");
3116   vfprintf(stderr, msg_format, ap);
3117   fprintf(stderr, "\n");
3118 }
3119
3120 /*
3121  * Read errors are reported with an console message in TShark.
3122  */
3123 static void
3124 read_failure_message(const char *filename, int err)
3125 {
3126   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
3127           filename, strerror(err));
3128 }
3129
3130 /*
3131  * Report an error in command-line arguments.
3132  */
3133 void
3134 cmdarg_err(const char *fmt, ...)
3135 {
3136   va_list ap;
3137
3138   va_start(ap, fmt);
3139   failure_message(fmt, ap);
3140   va_end(ap);
3141 }
3142
3143 /*
3144  * Report additional information for an error in command-line arguments.
3145  */
3146 void
3147 cmdarg_err_cont(const char *fmt, ...)
3148 {
3149   va_list ap;
3150
3151   va_start(ap, fmt);
3152   vfprintf(stderr, fmt, ap);
3153   fprintf(stderr, "\n");
3154   va_end(ap);
3155 }