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