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