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