From Harald Welte:
[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     if (running_with_special_privs()) {
760       fprintf(stderr, "Running as user \"%s\" and group \"%s\". This could be dangerous.\n",
761          cur_user, cur_group);
762     }
763     else {
764       fprintf(stdout, "Running as user \"%s\" and group \"%s\".",
765          cur_user, cur_group);
766     }
767     g_free(cur_user);
768     g_free(cur_group);
769   }
770 }
771
772 static void
773 check_capture_privs(void) {
774 #ifdef _WIN32
775   load_wpcap();
776   /* Warn the user if npf.sys isn't loaded. */
777   if (!npf_sys_is_running() && get_os_major_version() >= 6) {
778     fprintf(stderr, "The NPF driver isn't running.  You may have trouble "
779       "capturing or\nlisting interfaces.\n");
780   }
781 #endif
782 }
783
784 static void
785 show_version(GString *comp_info_str, GString *runtime_info_str)
786 {
787   printf("TShark " VERSION "%s\n"
788          "\n"
789          "%s"
790          "\n"
791          "%s"
792          "\n"
793          "%s",
794          wireshark_svnversion, get_copyright_info(), comp_info_str->str,
795          runtime_info_str->str);
796 }
797
798 int
799 main(int argc, char *argv[])
800 {
801   char                *init_progfile_dir_error;
802   int                  opt;
803   gboolean             arg_error = FALSE;
804
805 #ifdef _WIN32
806   WSADATA              wsaData;
807 #endif  /* _WIN32 */
808
809   char                *gpf_path, *pf_path;
810   char                *gdp_path, *dp_path;
811   int                  gpf_open_errno, gpf_read_errno;
812   int                  pf_open_errno, pf_read_errno;
813   int                  gdp_open_errno, gdp_read_errno;
814   int                  dp_open_errno, dp_read_errno;
815   int                  err;
816   volatile int         exit_status = 0;
817 #ifdef HAVE_LIBPCAP
818   gboolean             list_link_layer_types = FALSE;
819   gboolean             start_capture = FALSE;
820   int                  status;
821   GList               *if_list;
822   gchar               *err_str;
823   guint                i;
824   interface_options    interface_opts;
825 #else
826   gboolean             capture_option_specified = FALSE;
827 #endif
828   gboolean             quiet = FALSE;
829 #ifdef PCAP_NG_DEFAULT
830   volatile int         out_file_type = WTAP_FILE_PCAPNG;
831 #else
832   volatile int         out_file_type = WTAP_FILE_PCAP;
833 #endif
834   volatile gboolean    out_file_name_res = FALSE;
835   gchar               *volatile cf_name = NULL;
836   gchar               *rfilter = NULL;
837 #ifdef HAVE_PCAP_OPEN_DEAD
838   struct bpf_program   fcode;
839 #endif
840   dfilter_t           *rfcode = NULL;
841   e_prefs             *prefs_p;
842   char                 badopt;
843   GLogLevelFlags       log_flags;
844   int                  optind_initial;
845   gchar               *output_only = NULL;
846
847 #ifdef HAVE_LIBPCAP
848 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
849 #define OPTSTRING_B "B:"
850 #else
851 #define OPTSTRING_B ""
852 #endif  /* _WIN32 or HAVE_PCAP_CREATE */
853 #else /* HAVE_LIBPCAP */
854 #define OPTSTRING_B ""
855 #endif  /* HAVE_LIBPCAP */
856
857 #ifdef HAVE_PCAP_CREATE
858 #define OPTSTRING_I "I"
859 #else
860 #define OPTSTRING_I ""
861 #endif
862
863 #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:"
864
865   static const char    optstring[] = OPTSTRING;
866
867 #ifdef _WIN32
868   arg_list_utf_16to8(argc, argv);
869 #if !GLIB_CHECK_VERSION(2,31,0)
870   g_thread_init(NULL);
871 #endif
872 #endif /* _WIN32 */
873
874   /*
875    * Get credential information for later use.
876    */
877   init_process_policies();
878
879   /*
880    * Attempt to get the pathname of the executable file.
881    */
882   init_progfile_dir_error = init_progfile_dir(argv[0], main);
883   if (init_progfile_dir_error != NULL) {
884     fprintf(stderr, "tshark: Can't get pathname of tshark program: %s.\n",
885             init_progfile_dir_error);
886   }
887
888   /*
889    * In order to have the -X opts assigned before the wslua machine starts
890    * we need to call getopts before epan_init() gets called.
891    */
892   opterr = 0;
893   optind_initial = optind;
894
895   while ((opt = getopt(argc, argv, optstring)) != -1) {
896     switch (opt) {
897     case 'C':        /* Configuration Profile */
898       if (profile_exists (optarg, FALSE)) {
899         set_profile_name (optarg);
900       } else {
901         cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
902         return 1;
903       }
904       break;
905     case 'X':
906       ex_opt_add(optarg);
907       break;
908     default:
909       break;
910     }
911   }
912
913   optind = optind_initial;
914   opterr = 1;
915
916
917
918 /** Send All g_log messages to our own handler **/
919
920   log_flags =
921                     G_LOG_LEVEL_ERROR|
922                     G_LOG_LEVEL_CRITICAL|
923                     G_LOG_LEVEL_WARNING|
924                     G_LOG_LEVEL_MESSAGE|
925                     G_LOG_LEVEL_INFO|
926                     G_LOG_LEVEL_DEBUG|
927                     G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
928
929   g_log_set_handler(NULL,
930                     log_flags,
931                     tshark_log_handler, NULL /* user_data */);
932   g_log_set_handler(LOG_DOMAIN_MAIN,
933                     log_flags,
934                     tshark_log_handler, NULL /* user_data */);
935
936 #ifdef HAVE_LIBPCAP
937   g_log_set_handler(LOG_DOMAIN_CAPTURE,
938                     log_flags,
939                     tshark_log_handler, NULL /* user_data */);
940   g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
941                     log_flags,
942                     tshark_log_handler, NULL /* user_data */);
943 #endif
944
945   initialize_funnel_ops();
946
947 #ifdef HAVE_LIBPCAP
948   capture_opts_init(&global_capture_opts, &cfile);
949 #endif
950
951   timestamp_set_type(TS_RELATIVE);
952   timestamp_set_precision(TS_PREC_AUTO);
953   timestamp_set_seconds_type(TS_SECONDS_DEFAULT);
954
955   /* Register all dissectors; we must do this before checking for the
956      "-G" flag, as the "-G" flag dumps information registered by the
957      dissectors, and we must do it before we read the preferences, in
958      case any dissectors register preferences. */
959   epan_init(register_all_protocols, register_all_protocol_handoffs, NULL, NULL,
960             failure_message, open_failure_message, read_failure_message,
961             write_failure_message);
962
963   /* Register all tap listeners; we do this before we parse the arguments,
964      as the "-z" argument can specify a registered tap. */
965
966   /* we register the plugin taps before the other taps because
967      stats_tree taps plugins will be registered as tap listeners
968      by stats_tree_stat.c and need to registered before that */
969 #ifdef HAVE_PLUGINS
970   register_all_plugin_tap_listeners();
971 #endif
972   register_all_tap_listeners();
973
974   /* Now register the preferences for any non-dissector modules.
975      We must do that before we read the preferences as well. */
976   prefs_register_modules();
977
978   /* If invoked with the "-G" flag, we dump out information based on
979      the argument to the "-G" flag; if no argument is specified,
980      for backwards compatibility we dump out a glossary of display
981      filter symbols.
982
983      XXX - we do this here, for now, to support "-G" with no arguments.
984      If none of our build or other processes uses "-G" with no arguments,
985      we can just process it with the other arguments. */
986   if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
987     proto_initialize_all_prefixes();
988
989     if (argc == 2)
990       proto_registrar_dump_fields(1);
991     else {
992       if (strcmp(argv[2], "fields") == 0)
993         proto_registrar_dump_fields(1);
994       else if (strcmp(argv[2], "fields2") == 0)
995         proto_registrar_dump_fields(2);
996       else if (strcmp(argv[2], "fields3") == 0)
997         proto_registrar_dump_fields(3);
998       else if (strcmp(argv[2], "protocols") == 0)
999         proto_registrar_dump_protocols();
1000       else if (strcmp(argv[2], "values") == 0)
1001         proto_registrar_dump_values();
1002       else if (strcmp(argv[2], "ftypes") == 0)
1003         proto_registrar_dump_ftypes();
1004       else if (strcmp(argv[2], "decodes") == 0)
1005         dissector_dump_decodes();
1006       else if (strcmp(argv[2], "heuristic-decodes") == 0)
1007         dissector_dump_heur_decodes();
1008       else if (strcmp(argv[2], "defaultprefs") == 0)
1009         write_prefs(NULL);
1010       else if (strcmp(argv[2], "plugins") == 0)
1011         plugins_dump_all();
1012       else if (strcmp(argv[2], "?") == 0)
1013         glossary_option_help();
1014       else if (strcmp(argv[2], "-?") == 0)
1015         glossary_option_help();
1016       else if (strcmp(argv[2], "currentprefs") == 0) {
1017         read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
1018             &pf_open_errno, &pf_read_errno, &pf_path);
1019         write_prefs(NULL);
1020       } else {
1021         cmdarg_err("Invalid \"%s\" option for -G flag, enter -G ? for more help.", argv[2]);
1022         return 1;
1023       }
1024     }
1025     return 0;
1026   }
1027
1028   /* Set the C-language locale to the native environment. */
1029   setlocale(LC_ALL, "");
1030
1031   prefs_p = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
1032                      &pf_open_errno, &pf_read_errno, &pf_path);
1033   if (gpf_path != NULL) {
1034     if (gpf_open_errno != 0) {
1035       cmdarg_err("Can't open global preferences file \"%s\": %s.",
1036               pf_path, g_strerror(gpf_open_errno));
1037     }
1038     if (gpf_read_errno != 0) {
1039       cmdarg_err("I/O error reading global preferences file \"%s\": %s.",
1040               pf_path, g_strerror(gpf_read_errno));
1041     }
1042   }
1043   if (pf_path != NULL) {
1044     if (pf_open_errno != 0) {
1045       cmdarg_err("Can't open your preferences file \"%s\": %s.", pf_path,
1046               g_strerror(pf_open_errno));
1047     }
1048     if (pf_read_errno != 0) {
1049       cmdarg_err("I/O error reading your preferences file \"%s\": %s.",
1050               pf_path, g_strerror(pf_read_errno));
1051     }
1052     g_free(pf_path);
1053     pf_path = NULL;
1054   }
1055
1056   /* Set the name resolution code's flags from the preferences. */
1057   gbl_resolv_flags = prefs_p->name_resolve;
1058
1059   /* Read the disabled protocols file. */
1060   read_disabled_protos_list(&gdp_path, &gdp_open_errno, &gdp_read_errno,
1061                             &dp_path, &dp_open_errno, &dp_read_errno);
1062   if (gdp_path != NULL) {
1063     if (gdp_open_errno != 0) {
1064       cmdarg_err("Could not open global disabled protocols file\n\"%s\": %s.",
1065                  gdp_path, g_strerror(gdp_open_errno));
1066     }
1067     if (gdp_read_errno != 0) {
1068       cmdarg_err("I/O error reading global disabled protocols file\n\"%s\": %s.",
1069                  gdp_path, g_strerror(gdp_read_errno));
1070     }
1071     g_free(gdp_path);
1072   }
1073   if (dp_path != NULL) {
1074     if (dp_open_errno != 0) {
1075       cmdarg_err(
1076         "Could not open your disabled protocols file\n\"%s\": %s.", dp_path,
1077         g_strerror(dp_open_errno));
1078     }
1079     if (dp_read_errno != 0) {
1080       cmdarg_err(
1081         "I/O error reading your disabled protocols file\n\"%s\": %s.", dp_path,
1082         g_strerror(dp_read_errno));
1083     }
1084     g_free(dp_path);
1085   }
1086
1087   check_capture_privs();
1088
1089   cap_file_init(&cfile);
1090
1091   /* Print format defaults to this. */
1092   print_format = PR_FMT_TEXT;
1093
1094   output_fields = output_fields_new();
1095
1096   /* Now get our args */
1097   while ((opt = getopt(argc, argv, optstring)) != -1) {
1098     switch (opt) {
1099     case '2':        /* Perform two pass analysis */
1100       perform_two_pass_analysis = TRUE;
1101       break;
1102     case 'a':        /* autostop criteria */
1103     case 'b':        /* Ringbuffer option */
1104     case 'c':        /* Capture x packets */
1105     case 'f':        /* capture filter */
1106     case 'i':        /* Use interface x */
1107     case 'p':        /* Don't capture in promiscuous mode */
1108 #ifdef HAVE_PCAP_CREATE
1109     case 'I':        /* Capture in monitor mode, if available */
1110 #endif
1111     case 's':        /* Set the snapshot (capture) length */
1112     case 'w':        /* Write to capture file x */
1113     case 'y':        /* Set the pcap data link type */
1114 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
1115     case 'B':        /* Buffer size */
1116 #endif /* _WIN32 or HAVE_PCAP_CREATE */
1117 #ifdef HAVE_LIBPCAP
1118       status = capture_opts_add_opt(&global_capture_opts, opt, optarg, &start_capture);
1119       if(status != 0) {
1120         return status;
1121       }
1122 #else
1123       capture_option_specified = TRUE;
1124       arg_error = TRUE;
1125 #endif
1126       break;
1127     case 'C':
1128       /* Configuration profile settings were already processed just ignore them this time*/
1129       break;
1130     case 'd':        /* Decode as rule */
1131       if (!add_decode_as(optarg))
1132         return 1;
1133       break;
1134 #if defined(HAVE_HEIMDAL_KERBEROS) || defined(HAVE_MIT_KERBEROS)
1135     case 'K':        /* Kerberos keytab file */
1136       read_keytab_file(optarg);
1137       break;
1138 #endif
1139     case 'D':        /* Print a list of capture devices and exit */
1140 #ifdef HAVE_LIBPCAP
1141       if_list = capture_interface_list(&err, &err_str);
1142       if (if_list == NULL) {
1143         switch (err) {
1144         case CANT_GET_INTERFACE_LIST:
1145         case DONT_HAVE_PCAP:
1146           cmdarg_err("%s", err_str);
1147           g_free(err_str);
1148           break;
1149
1150         case NO_INTERFACES_FOUND:
1151           cmdarg_err("There are no interfaces on which a capture can be done");
1152           break;
1153         }
1154         return 2;
1155       }
1156       capture_opts_print_interfaces(if_list);
1157       free_interface_list(if_list);
1158       return 0;
1159 #else
1160       capture_option_specified = TRUE;
1161       arg_error = TRUE;
1162 #endif
1163       break;
1164     case 'e':
1165       /* Field entry */
1166       output_fields_add(output_fields, optarg);
1167       break;
1168     case 'E':
1169       /* Field option */
1170       if(!output_fields_set_option(output_fields, optarg)) {
1171         cmdarg_err("\"%s\" is not a valid field output option=value pair.", optarg);
1172         output_fields_list_options(stderr);
1173         return 1;
1174       }
1175       break;
1176     case 'F':
1177       out_file_type = wtap_short_string_to_file_type(optarg);
1178       if (out_file_type < 0) {
1179         cmdarg_err("\"%s\" isn't a valid capture file type", optarg);
1180         list_capture_types();
1181         return 1;
1182       }
1183       break;
1184     case 'W':        /* Select extra information to save in our capture file */
1185       /* This is patterned after the -N flag which may not be the best idea. */
1186       if (strchr(optarg, 'n'))
1187         out_file_name_res = TRUE;
1188       break;
1189     case 'H':        /* Read address to name mappings from a hosts file */
1190       if (! read_hosts_file(optarg))
1191       {
1192         cmdarg_err("Can't read host entries from \"%s\"", optarg);
1193         return 1;
1194       }
1195       out_file_name_res = TRUE;
1196       break;
1197
1198     case 'h':        /* Print help and exit */
1199       print_usage(TRUE);
1200       return 0;
1201       break;
1202     case 'l':        /* "Line-buffer" standard output */
1203       /* This isn't line-buffering, strictly speaking, it's just
1204          flushing the standard output after the information for
1205          each packet is printed; however, that should be good
1206          enough for all the purposes to which "-l" is put (and
1207          is probably actually better for "-V", as it does fewer
1208          writes).
1209
1210          See the comment in "process_packet()" for an explanation of
1211          why we do that, and why we don't just use "setvbuf()" to
1212          make the standard output line-buffered (short version: in
1213          Windows, "line-buffered" is the same as "fully-buffered",
1214          and the output buffer is only flushed when it fills up). */
1215       line_buffered = TRUE;
1216       break;
1217     case 'L':        /* Print list of link-layer types and exit */
1218 #ifdef HAVE_LIBPCAP
1219       list_link_layer_types = TRUE;
1220 #else
1221       capture_option_specified = TRUE;
1222       arg_error = TRUE;
1223 #endif
1224       break;
1225     case 'n':        /* No name resolution */
1226       gbl_resolv_flags = RESOLV_NONE;
1227       break;
1228     case 'N':        /* Select what types of addresses/port #s to resolve */
1229       if (gbl_resolv_flags == RESOLV_ALL)
1230         gbl_resolv_flags = RESOLV_NONE;
1231       badopt = string_to_name_resolve(optarg, &gbl_resolv_flags);
1232       if (badopt != '\0') {
1233         cmdarg_err("-N specifies unknown resolving option '%c';",
1234                    badopt);
1235         cmdarg_err_cont( "           Valid options are 'm', 'n', 't', and 'C'");
1236         return 1;
1237       }
1238       break;
1239     case 'o':        /* Override preference from command line */
1240       switch (prefs_set_pref(optarg)) {
1241
1242       case PREFS_SET_OK:
1243         break;
1244
1245       case PREFS_SET_SYNTAX_ERR:
1246         cmdarg_err("Invalid -o flag \"%s\"", optarg);
1247         return 1;
1248         break;
1249
1250       case PREFS_SET_NO_SUCH_PREF:
1251       case PREFS_SET_OBSOLETE:
1252         cmdarg_err("-o flag \"%s\" specifies unknown preference", optarg);
1253         return 1;
1254         break;
1255       }
1256       break;
1257     case 'q':        /* Quiet */
1258       quiet = TRUE;
1259       break;
1260     case 'r':        /* Read capture file x */
1261       cf_name = g_strdup(optarg);
1262       break;
1263     case 'R':        /* Read file filter */
1264       rfilter = optarg;
1265       break;
1266     case 'P':        /* Print packets even when writing to a file */
1267       print_packet_info = TRUE;
1268       break;
1269     case 'S':        /* Set the line Separator to be printed between packets */
1270       separator = strdup(optarg);
1271       break;
1272     case 't':        /* Time stamp type */
1273       if (strcmp(optarg, "r") == 0)
1274         timestamp_set_type(TS_RELATIVE);
1275       else if (strcmp(optarg, "a") == 0)
1276         timestamp_set_type(TS_ABSOLUTE);
1277       else if (strcmp(optarg, "ad") == 0)
1278         timestamp_set_type(TS_ABSOLUTE_WITH_DATE);
1279       else if (strcmp(optarg, "d") == 0)
1280         timestamp_set_type(TS_DELTA);
1281       else if (strcmp(optarg, "dd") == 0)
1282         timestamp_set_type(TS_DELTA_DIS);
1283       else if (strcmp(optarg, "e") == 0)
1284         timestamp_set_type(TS_EPOCH);
1285       else if (strcmp(optarg, "u") == 0)
1286         timestamp_set_type(TS_UTC);
1287       else if (strcmp(optarg, "ud") == 0)
1288         timestamp_set_type(TS_UTC_WITH_DATE);
1289       else {
1290         cmdarg_err("Invalid time stamp type \"%s\"",
1291                    optarg);
1292         cmdarg_err_cont("It must be \"r\" for relative, \"a\" for absolute,");
1293         cmdarg_err_cont("\"ad\" for absolute with date, or \"d\" for delta.");
1294         return 1;
1295       }
1296       break;
1297     case 'T':        /* printing Type */
1298       if (strcmp(optarg, "text") == 0) {
1299         output_action = WRITE_TEXT;
1300         print_format = PR_FMT_TEXT;
1301       } else if (strcmp(optarg, "ps") == 0) {
1302         output_action = WRITE_TEXT;
1303         print_format = PR_FMT_PS;
1304       } else if (strcmp(optarg, "pdml") == 0) {
1305         output_action = WRITE_XML;
1306         verbose = TRUE;
1307       } else if (strcmp(optarg, "psml") == 0) {
1308         output_action = WRITE_XML;
1309         verbose = FALSE;
1310       } else if(strcmp(optarg, "fields") == 0) {
1311         output_action = WRITE_FIELDS;
1312         verbose = TRUE; /* Need full tree info */
1313       } else {
1314         cmdarg_err("Invalid -T parameter.");
1315         cmdarg_err_cont("It must be \"ps\", \"text\", \"pdml\", \"psml\" or \"fields\".");
1316         return 1;
1317       }
1318       break;
1319     case 'u':        /* Seconds type */
1320       if (strcmp(optarg, "s") == 0)
1321         timestamp_set_seconds_type(TS_SECONDS_DEFAULT);
1322       else if (strcmp(optarg, "hms") == 0)
1323         timestamp_set_seconds_type(TS_SECONDS_HOUR_MIN_SEC);
1324       else {
1325         cmdarg_err("Invalid seconds type \"%s\"", optarg);
1326         cmdarg_err_cont("It must be \"s\" for seconds or \"hms\" for hours, minutes and seconds.");
1327         return 1;
1328       }
1329       break;
1330     case 'v':         /* Show version and exit */
1331     {
1332       GString             *comp_info_str;
1333       GString             *runtime_info_str;
1334       /* Assemble the compile-time version information string */
1335       comp_info_str = g_string_new("Compiled ");
1336       get_compiled_version_info(comp_info_str, NULL, epan_get_compiled_version_info);
1337
1338       /* Assemble the run-time version information string */
1339       runtime_info_str = g_string_new("Running ");
1340       get_runtime_version_info(runtime_info_str, NULL);
1341       show_version(comp_info_str, runtime_info_str);
1342       g_string_free(comp_info_str, TRUE);
1343       g_string_free(runtime_info_str, TRUE);
1344       return 0;
1345       break;
1346     }
1347     case 'O':        /* Only output these protocols */
1348       output_only = g_strdup(optarg);
1349       /* FALLTHROUGH */
1350     case 'V':        /* Verbose */
1351       verbose = TRUE;
1352       /*  The user asked for a verbose output, so let's ensure they get it,
1353        *  even if they're writing to a file.
1354        */
1355       print_packet_info = TRUE;
1356       break;
1357     case 'x':        /* Print packet data in hex (and ASCII) */
1358       print_hex = TRUE;
1359       /*  The user asked for hex output, so let's ensure they get it,
1360        *  even if they're writing to a file.
1361        */
1362       print_packet_info = TRUE;
1363       break;
1364     case 'X':
1365       break;
1366     case 'z':
1367       /* We won't call the init function for the stat this soon
1368          as it would disallow MATE's fields (which are registered
1369          by the preferences set callback) from being used as
1370          part of a tap filter.  Instead, we just add the argument
1371          to a list of stat arguments. */
1372       if (!process_stat_cmd_arg(optarg)) {
1373         cmdarg_err("invalid -z argument.");
1374         cmdarg_err_cont("  -z argument must be one of :");
1375         list_stat_cmd_args();
1376         return 1;
1377       }
1378       break;
1379     default:
1380     case '?':        /* Bad flag - print usage message */
1381       switch(optopt) {
1382       case 'F':
1383         list_capture_types();
1384         break;
1385       default:
1386         print_usage(TRUE);
1387       }
1388       return 1;
1389       break;
1390     }
1391   }
1392
1393   /* If we specified output fields, but not the output field type... */
1394   if(WRITE_FIELDS != output_action && 0 != output_fields_num_fields(output_fields)) {
1395         cmdarg_err("Output fields were specified with \"-e\", "
1396             "but \"-Tfields\" was not specified.");
1397         return 1;
1398   } else if(WRITE_FIELDS == output_action && 0 == output_fields_num_fields(output_fields)) {
1399         cmdarg_err("\"-Tfields\" was specified, but no fields were "
1400                     "specified with \"-e\".");
1401
1402         return 1;
1403   }
1404
1405   /* If no capture filter or read filter has been specified, and there are
1406      still command-line arguments, treat them as the tokens of a capture
1407      filter (if no "-r" flag was specified) or a read filter (if a "-r"
1408      flag was specified. */
1409   if (optind < argc) {
1410     if (cf_name != NULL) {
1411       if (rfilter != NULL) {
1412         cmdarg_err("Read filters were specified both with \"-R\" "
1413             "and with additional command-line arguments.");
1414         return 1;
1415       }
1416       rfilter = get_args_as_string(argc, argv, optind);
1417     } else {
1418 #ifdef HAVE_LIBPCAP
1419       if (global_capture_opts.default_options.cfilter) {
1420         cmdarg_err("A default capture filter was specified both with \"-f\""
1421             " and with additional command-line arguments.");
1422         return 1;
1423       }
1424       for (i = 0; i < global_capture_opts.ifaces->len; i++) {
1425         interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
1426         if (interface_opts.cfilter == NULL) {
1427           interface_opts.cfilter = get_args_as_string(argc, argv, optind);
1428           global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
1429           g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
1430         } else {
1431           cmdarg_err("A capture filter was specified both with \"-f\""
1432               " and with additional command-line arguments.");
1433           return 1;
1434         }
1435       }
1436       global_capture_opts.default_options.cfilter = get_args_as_string(argc, argv, optind);
1437 #else
1438       capture_option_specified = TRUE;
1439 #endif
1440     }
1441   }
1442
1443 #ifdef HAVE_LIBPCAP
1444   if (!global_capture_opts.saving_to_file) {
1445     /* We're not saving the capture to a file; if "-q" wasn't specified,
1446        we should print packet information */
1447     if (!quiet)
1448       print_packet_info = TRUE;
1449   } else {
1450     /* We're saving to a file; if we're writing to the standard output.
1451        and we'll also be writing dissected packets to the standard
1452        output, reject the request.  At best, we could redirect that
1453        to the standard error; we *can't* write both to the standard
1454        output and have either of them be useful. */
1455     if (strcmp(global_capture_opts.save_file, "-") == 0 && print_packet_info) {
1456       cmdarg_err("You can't write both raw packet data and dissected packets"
1457           " to the standard output.");
1458       return 1;
1459     }
1460   }
1461 #else
1462   /* We're not saving the capture to a file; if "-q" wasn't specified,
1463      we should print packet information */
1464   if (!quiet)
1465     print_packet_info = TRUE;
1466 #endif
1467
1468 #ifndef HAVE_LIBPCAP
1469   if (capture_option_specified)
1470     cmdarg_err("This version of TShark was not built with support for capturing packets.");
1471 #endif
1472   if (arg_error) {
1473     print_usage(FALSE);
1474     return 1;
1475   }
1476
1477   /* We don't support capture filters when reading from a capture file
1478      (the BPF compiler doesn't support all link-layer types that we
1479      support in capture files we read). */
1480 #ifdef HAVE_LIBPCAP
1481   if (cf_name != NULL) {
1482     if (global_capture_opts.default_options.cfilter) {
1483       cmdarg_err("Only read filters, not capture filters, "
1484           "can be specified when reading a capture file.");
1485       return 1;
1486     }
1487   }
1488 #endif
1489
1490   if (print_hex) {
1491     if (output_action != WRITE_TEXT) {
1492       cmdarg_err("Raw packet hex data can only be printed as text or PostScript");
1493       return 1;
1494     }
1495   }
1496
1497   if (output_only != NULL) {
1498     char *ps;
1499
1500     if (!verbose) {
1501       cmdarg_err("-O requires -V");
1502       return 1;
1503     }
1504
1505     output_only_tables = g_hash_table_new (g_str_hash, g_str_equal);
1506     for (ps = strtok (output_only, ","); ps; ps = strtok (NULL, ",")) {
1507       g_hash_table_insert(output_only_tables, (gpointer)ps, (gpointer)ps);
1508     }
1509   }
1510
1511 #ifdef HAVE_LIBPCAP
1512   if (list_link_layer_types) {
1513     /* We're supposed to list the link-layer types for an interface;
1514        did the user also specify a capture file to be read? */
1515     if (cf_name) {
1516       /* Yes - that's bogus. */
1517       cmdarg_err("You can't specify -L and a capture file to be read.");
1518       return 1;
1519     }
1520     /* No - did they specify a ring buffer option? */
1521     if (global_capture_opts.multi_files_on) {
1522       cmdarg_err("Ring buffer requested, but a capture isn't being done.");
1523       return 1;
1524     }
1525   } else {
1526     if (cf_name) {
1527       /*
1528        * "-r" was specified, so we're reading a capture file.
1529        * Capture options don't apply here.
1530        */
1531       if (global_capture_opts.multi_files_on) {
1532         cmdarg_err("Multiple capture files requested, but "
1533                    "a capture isn't being done.");
1534         return 1;
1535       }
1536       if (global_capture_opts.has_file_duration) {
1537         cmdarg_err("Switching capture files after a time interval was specified, but "
1538                    "a capture isn't being done.");
1539         return 1;
1540       }
1541       if (global_capture_opts.has_ring_num_files) {
1542         cmdarg_err("A ring buffer of capture files was specified, but "
1543           "a capture isn't being done.");
1544         return 1;
1545       }
1546       if (global_capture_opts.has_autostop_files) {
1547         cmdarg_err("A maximum number of capture files was specified, but "
1548           "a capture isn't being done.");
1549         return 1;
1550       }
1551
1552       /* Note: TShark now allows the restriction of a _read_ file by packet count
1553        * and byte count as well as a write file. Other autostop options remain valid
1554        * only for a write file.
1555        */
1556       if (global_capture_opts.has_autostop_duration) {
1557         cmdarg_err("A maximum capture time was specified, but "
1558           "a capture isn't being done.");
1559         return 1;
1560       }
1561     } else {
1562       /*
1563        * "-r" wasn't specified, so we're doing a live capture.
1564        */
1565       if (global_capture_opts.saving_to_file) {
1566         /* They specified a "-w" flag, so we'll be saving to a capture file. */
1567
1568         /* When capturing, we only support writing pcap or pcap-ng format. */
1569         if (out_file_type != WTAP_FILE_PCAP && out_file_type != WTAP_FILE_PCAPNG) {
1570           cmdarg_err("Live captures can only be saved in libpcap format.");
1571           return 1;
1572         }
1573         if (global_capture_opts.multi_files_on) {
1574           /* Multiple-file mode doesn't work under certain conditions:
1575              a) it doesn't work if you're writing to the standard output;
1576              b) it doesn't work if you're writing to a pipe;
1577           */
1578           if (strcmp(global_capture_opts.save_file, "-") == 0) {
1579             cmdarg_err("Multiple capture files requested, but "
1580               "the capture is being written to the standard output.");
1581             return 1;
1582           }
1583           if (global_capture_opts.output_to_pipe) {
1584             cmdarg_err("Multiple capture files requested, but "
1585               "the capture file is a pipe.");
1586             return 1;
1587           }
1588           if (!global_capture_opts.has_autostop_filesize &&
1589               !global_capture_opts.has_file_duration) {
1590             cmdarg_err("Multiple capture files requested, but "
1591               "no maximum capture file size or duration was specified.");
1592             return 1;
1593           }
1594         }
1595         /* Currently, we don't support read filters when capturing
1596            and saving the packets. */
1597         if (rfilter != NULL) {
1598           cmdarg_err("Read filters aren't supported when capturing and saving the captured packets.");
1599           return 1;
1600         }
1601       } else {
1602         /* They didn't specify a "-w" flag, so we won't be saving to a
1603            capture file.  Check for options that only make sense if
1604            we're saving to a file. */
1605         if (global_capture_opts.has_autostop_filesize) {
1606           cmdarg_err("Maximum capture file size specified, but "
1607            "capture isn't being saved to a file.");
1608           return 1;
1609         }
1610         if (global_capture_opts.multi_files_on) {
1611           cmdarg_err("Multiple capture files requested, but "
1612             "the capture isn't being saved to a file.");
1613           return 1;
1614         }
1615       }
1616     }
1617   }
1618 #endif
1619
1620 #ifdef _WIN32
1621   /* Start windows sockets */
1622   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
1623 #endif /* _WIN32 */
1624
1625   /* Notify all registered modules that have had any of their preferences
1626      changed either from one of the preferences file or from the command
1627      line that their preferences have changed. */
1628   prefs_apply_all();
1629
1630   /* At this point MATE will have registered its field array so we can
1631      have a tap filter with one of MATE's late-registered fields as part
1632      of the filter.  We can now process all the "-z" arguments. */
1633   start_requested_stats();
1634
1635 #ifdef HAVE_LIBPCAP
1636   /* We currently don't support taps, or printing dissected packets,
1637      if we're writing to a pipe. */
1638   if (global_capture_opts.saving_to_file &&
1639       global_capture_opts.output_to_pipe) {
1640     if (tap_listeners_require_dissection()) {
1641       cmdarg_err("Taps aren't supported when saving to a pipe.");
1642       return 1;
1643     }
1644     if (print_packet_info) {
1645       cmdarg_err("Printing dissected packets isn't supported when saving to a pipe.");
1646       return 1;
1647     }
1648   }
1649 #endif
1650
1651   /* disabled protocols as per configuration file */
1652   if (gdp_path == NULL && dp_path == NULL) {
1653     set_disabled_protos_list();
1654   }
1655
1656   /* Build the column format array */
1657   build_column_format_array(&cfile.cinfo, prefs_p->num_cols, TRUE);
1658
1659 #ifdef HAVE_LIBPCAP
1660   capture_opts_trim_snaplen(&global_capture_opts, MIN_PACKET_SIZE);
1661   capture_opts_trim_ring_num_files(&global_capture_opts);
1662 #endif
1663
1664   if (rfilter != NULL) {
1665     if (!dfilter_compile(rfilter, &rfcode)) {
1666       cmdarg_err("%s", dfilter_error_msg);
1667       epan_cleanup();
1668 #ifdef HAVE_PCAP_OPEN_DEAD
1669       {
1670         pcap_t *pc;
1671
1672         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1673         if (pc != NULL) {
1674           if (pcap_compile(pc, &fcode, rfilter, 0, 0) != -1) {
1675             cmdarg_err_cont(
1676               "  Note: That display filter code looks like a valid capture filter;");
1677             cmdarg_err_cont(
1678               "        maybe you mixed them up?");
1679           }
1680           pcap_close(pc);
1681         }
1682       }
1683 #endif
1684       return 2;
1685     }
1686   }
1687   cfile.rfcode = rfcode;
1688
1689   if (print_packet_info) {
1690     /* If we're printing as text or PostScript, we have
1691        to create a print stream. */
1692     if (output_action == WRITE_TEXT) {
1693       switch (print_format) {
1694
1695       case PR_FMT_TEXT:
1696         print_stream = print_stream_text_stdio_new(stdout);
1697         break;
1698
1699       case PR_FMT_PS:
1700         print_stream = print_stream_ps_stdio_new(stdout);
1701         break;
1702
1703       default:
1704         g_assert_not_reached();
1705       }
1706     }
1707   }
1708
1709   /* We have to dissect each packet if:
1710
1711         we're printing information about each packet;
1712
1713         we're using a read filter on the packets;
1714
1715         we're using any taps that need dissection. */
1716   do_dissection = print_packet_info || rfcode || tap_listeners_require_dissection();
1717
1718   if (cf_name) {
1719     /*
1720      * We're reading a capture file.
1721      */
1722
1723     /*
1724      * Immediately relinquish any special privileges we have; we must not
1725      * be allowed to read any capture files the user running TShark
1726      * can't open.
1727      */
1728     relinquish_special_privs_perm();
1729     print_current_user();
1730
1731     if (cf_open(&cfile, cf_name, FALSE, &err) != CF_OK) {
1732       epan_cleanup();
1733       return 2;
1734     }
1735
1736     /* Set timestamp precision; there should arguably be a command-line
1737        option to let the user set this. */
1738     switch(wtap_file_tsprecision(cfile.wth)) {
1739     case(WTAP_FILE_TSPREC_SEC):
1740       timestamp_set_precision(TS_PREC_AUTO_SEC);
1741       break;
1742     case(WTAP_FILE_TSPREC_DSEC):
1743       timestamp_set_precision(TS_PREC_AUTO_DSEC);
1744       break;
1745     case(WTAP_FILE_TSPREC_CSEC):
1746       timestamp_set_precision(TS_PREC_AUTO_CSEC);
1747       break;
1748     case(WTAP_FILE_TSPREC_MSEC):
1749       timestamp_set_precision(TS_PREC_AUTO_MSEC);
1750       break;
1751     case(WTAP_FILE_TSPREC_USEC):
1752       timestamp_set_precision(TS_PREC_AUTO_USEC);
1753       break;
1754     case(WTAP_FILE_TSPREC_NSEC):
1755       timestamp_set_precision(TS_PREC_AUTO_NSEC);
1756       break;
1757     default:
1758       g_assert_not_reached();
1759     }
1760
1761     /* Process the packets in the file */
1762     TRY {
1763 #ifdef HAVE_LIBPCAP
1764       err = load_cap_file(&cfile, global_capture_opts.save_file, out_file_type, out_file_name_res,
1765           global_capture_opts.has_autostop_packets ? global_capture_opts.autostop_packets : 0,
1766           global_capture_opts.has_autostop_filesize ? global_capture_opts.autostop_filesize : 0);
1767 #else
1768       err = load_cap_file(&cfile, NULL, out_file_type, out_file_name_res, 0, 0);
1769 #endif
1770     }
1771     CATCH(OutOfMemoryError) {
1772       fprintf(stderr,
1773               "Out Of Memory!\n"
1774               "\n"
1775               "Sorry, but TShark has to terminate now!\n"
1776               "\n"
1777               "Some infos / workarounds can be found at:\n"
1778               "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
1779       err = ENOMEM;
1780     }
1781     ENDTRY;
1782     if (err != 0) {
1783       /* We still dump out the results of taps, etc., as we might have
1784          read some packets; however, we exit with an error status. */
1785       exit_status = 2;
1786     }
1787   } else {
1788     /* No capture file specified, so we're supposed to do a live capture
1789        (or get a list of link-layer types for a live capture device);
1790        do we have support for live captures? */
1791 #ifdef HAVE_LIBPCAP
1792     /* trim the interface name and exit if that failed */
1793     if (!capture_opts_trim_iface(&global_capture_opts,
1794         (prefs_p->capture_device) ? get_if_name(prefs_p->capture_device) : NULL)) {
1795         return 2;
1796     }
1797
1798     /* if requested, list the link layer types and exit */
1799     if (list_link_layer_types) {
1800         guint i;
1801         interface_options interface_opts;
1802
1803         /* Get the list of link-layer types for the capture devices. */
1804         for (i = 0; i < global_capture_opts.ifaces->len; i++) {
1805             if_capabilities_t *caps;
1806
1807             interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
1808             caps = capture_get_if_capabilities(interface_opts.name, interface_opts.monitor_mode, &err_str);
1809             if (caps == NULL) {
1810                 cmdarg_err("%s", err_str);
1811                 g_free(err_str);
1812                 return 2;
1813             }
1814             if (caps->data_link_types == NULL) {
1815                 cmdarg_err("The capture device \"%s\" has no data link types.", interface_opts.name);
1816                 return 2;
1817             }
1818             capture_opts_print_if_capabilities(caps, interface_opts.name, interface_opts.monitor_mode);
1819             free_if_capabilities(caps);
1820         }
1821         return 0;
1822     }
1823
1824     if (print_packet_info) {
1825       if (!write_preamble(NULL)) {
1826         show_print_file_io_error(errno);
1827         return 2;
1828       }
1829     } else if (!quiet) {
1830       /*
1831        * We're not printing information for each packet, and the user
1832        * didn't ask us not to print a count of packets as they arrive,
1833        * so print that count so the user knows that packets are arriving.
1834        *
1835        * XXX - what if the user wants to do a live capture, doesn't want
1836        * to save it to a file, doesn't want information printed for each
1837        * packet, does want some "-z" statistic, and wants packet counts
1838        * so they know whether they're seeing any packets?
1839        */
1840       print_packet_counts = TRUE;
1841     }
1842
1843     /* For now, assume libpcap gives microsecond precision. */
1844     timestamp_set_precision(TS_PREC_AUTO_USEC);
1845
1846     /*
1847      * XXX - this returns FALSE if an error occurred, but it also
1848      * returns FALSE if the capture stops because a time limit
1849      * was reached (and possibly other limits), so we can't assume
1850      * it means an error.
1851      *
1852      * The capture code is a bit twisty, so it doesn't appear to
1853      * be an easy fix.  We just ignore the return value for now.
1854      * Instead, pass on the exit status from the capture child.
1855      */
1856     capture();
1857     exit_status = global_capture_opts.fork_child_status;
1858
1859     if (print_packet_info) {
1860       if (!write_finale()) {
1861         err = errno;
1862         show_print_file_io_error(err);
1863       }
1864     }
1865 #else
1866     /* No - complain. */
1867     cmdarg_err("This version of TShark was not built with support for capturing packets.");
1868     return 2;
1869 #endif
1870   }
1871
1872   g_free(cf_name);
1873
1874   if (cfile.frames != NULL) {
1875     free_frame_data_sequence(cfile.frames);
1876     cfile.frames = NULL;
1877   }
1878
1879   draw_tap_listeners(TRUE);
1880   funnel_dump_all_text_windows();
1881   epan_cleanup();
1882
1883   output_fields_free(output_fields);
1884   output_fields = NULL;
1885
1886   return exit_status;
1887 }
1888
1889 /*#define USE_BROKEN_G_MAIN_LOOP*/
1890
1891 #ifdef USE_BROKEN_G_MAIN_LOOP
1892   GMainLoop *loop;
1893 #else
1894   gboolean loop_running = FALSE;
1895 #endif
1896   guint32 packet_count = 0;
1897
1898
1899 /* XXX - move to the right position / file */
1900 /* read from a pipe (callback) */
1901 typedef gboolean (*pipe_input_cb_t) (gint source, gpointer user_data);
1902
1903 typedef struct pipe_input_tag {
1904   gint                source;
1905   gpointer            user_data;
1906   int                 *child_process;
1907   pipe_input_cb_t     input_cb;
1908   guint               pipe_input_id;
1909 #ifdef _WIN32
1910   GMutex              *callback_running;
1911 #endif
1912 } pipe_input_t;
1913
1914 static pipe_input_t pipe_input;
1915
1916 #ifdef _WIN32
1917 /* The timer has expired, see if there's stuff to read from the pipe,
1918    if so, do the callback */
1919 static gint
1920 pipe_timer_cb(gpointer data)
1921 {
1922   HANDLE handle;
1923   DWORD avail = 0;
1924   gboolean result, result1;
1925   DWORD childstatus;
1926   pipe_input_t *pipe_input_p = data;
1927   gint iterations = 0;
1928
1929   g_mutex_lock (pipe_input_p->callback_running);
1930
1931   /* try to read data from the pipe only 5 times, to avoid blocking */
1932   while(iterations < 5) {
1933     /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: new iteration");*/
1934
1935     /* Oddly enough although Named pipes don't work on win9x,
1936        PeekNamedPipe does !!! */
1937     handle = (HANDLE) _get_osfhandle (pipe_input_p->source);
1938     result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
1939
1940     /* Get the child process exit status */
1941     result1 = GetExitCodeProcess((HANDLE)*(pipe_input_p->child_process),
1942                                  &childstatus);
1943
1944     /* If the Peek returned an error, or there are bytes to be read
1945        or the childwatcher thread has terminated then call the normal
1946        callback */
1947     if (!result || avail > 0 || childstatus != STILL_ACTIVE) {
1948
1949       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: data avail");*/
1950
1951       /* And call the real handler */
1952       if (!pipe_input_p->input_cb(pipe_input_p->source, pipe_input_p->user_data)) {
1953         g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: input pipe closed, iterations: %u", iterations);
1954         /* pipe closed, return false so that the timer is stopped */
1955         g_mutex_unlock (pipe_input_p->callback_running);
1956         return FALSE;
1957       }
1958     }
1959     else {
1960       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: no data avail");*/
1961       /* No data, stop now */
1962       break;
1963     }
1964
1965     iterations++;
1966   }
1967
1968   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: finished with iterations: %u, new timer", iterations);*/
1969
1970   g_mutex_unlock (pipe_input_p->callback_running);
1971
1972   /* we didn't stopped the timer, so let it run */
1973   return TRUE;
1974 }
1975 #endif
1976
1977
1978 void
1979 pipe_input_set_handler(gint source, gpointer user_data, int *child_process, pipe_input_cb_t input_cb)
1980 {
1981
1982   pipe_input.source         = source;
1983   pipe_input.child_process  = child_process;
1984   pipe_input.user_data      = user_data;
1985   pipe_input.input_cb       = input_cb;
1986
1987 #ifdef _WIN32
1988 #if GLIB_CHECK_VERSION(2,31,0)
1989   pipe_input.callback_running = g_malloc(sizeof(GMutex));
1990   g_mutex_init(pipe_input.callback_running);
1991 #else
1992   pipe_input.callback_running = g_mutex_new();
1993 #endif
1994   /* Tricky to use pipes in win9x, as no concept of wait.  NT can
1995      do this but that doesn't cover all win32 platforms.  GTK can do
1996      this but doesn't seem to work over processes.  Attempt to do
1997      something similar here, start a timer and check for data on every
1998      timeout. */
1999   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_input_set_handler: new");*/
2000   pipe_input.pipe_input_id = g_timeout_add(200, pipe_timer_cb, &pipe_input);
2001 #endif
2002 }
2003
2004
2005 #ifdef HAVE_LIBPCAP
2006 static gboolean
2007 capture(void)
2008 {
2009   gboolean ret;
2010   guint i;
2011   GString *str = g_string_new("");
2012 #ifdef USE_TSHARK_SELECT
2013   fd_set readfds;
2014 #endif
2015 #ifndef _WIN32
2016   struct sigaction action, oldaction;
2017 #endif
2018
2019   /*
2020    * XXX - dropping privileges is still required, until code cleanup is done
2021    *
2022    * remove all dependencies to pcap specific code and using only dumpcap is almost done.
2023    * when it's done, we don't need special privileges to run tshark at all,
2024    * therefore we don't need to drop these privileges
2025    * The only thing we might want to keep is a warning if tshark is run as root,
2026    * as it's no longer necessary and potentially dangerous.
2027    *
2028    * THE FOLLOWING IS THE FORMER COMMENT WHICH IS NO LONGER REALLY VALID:
2029    * We've opened the capture device, so we shouldn't need any special
2030    * privileges any more; relinquish those privileges.
2031    *
2032    * XXX - if we have saved set-user-ID support, we should give up those
2033    * privileges immediately, and then reclaim them long enough to get
2034    * a list of network interfaces and to open one, and then give them
2035    * up again, so that stuff we do while processing the argument list,
2036    * reading the user's preferences, loading and starting plugins
2037    * (especially *user* plugins), etc. is done with the user's privileges,
2038    * not special privileges.
2039    */
2040   relinquish_special_privs_perm();
2041   print_current_user();
2042
2043   /* Cleanup all data structures used for dissection. */
2044   cleanup_dissection();
2045   /* Initialize all data structures used for dissection. */
2046   init_dissection();
2047
2048 #ifdef _WIN32
2049   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
2050   SetConsoleCtrlHandler(capture_cleanup, TRUE);
2051 #else /* _WIN32 */
2052   /* Catch SIGINT and SIGTERM and, if we get either of them,
2053      clean up and exit.  If SIGHUP isn't being ignored, catch
2054      it too and, if we get it, clean up and exit.
2055
2056      We restart any read that was in progress, so that it doesn't
2057      disrupt reading from the sync pipe.  The signal handler tells
2058      the capture child to finish; it will report that it finished,
2059      or will exit abnormally, so  we'll stop reading from the sync
2060      pipe, pick up the exit status, and quit. */
2061   action.sa_handler = capture_cleanup;
2062   action.sa_flags = SA_RESTART;
2063   sigemptyset(&action.sa_mask);
2064   sigaction(SIGTERM, &action, NULL);
2065   sigaction(SIGINT, &action, NULL);
2066   sigaction(SIGHUP, NULL, &oldaction);
2067   if (oldaction.sa_handler == SIG_DFL)
2068     sigaction(SIGHUP, &action, NULL);
2069
2070 #ifdef SIGINFO
2071   /* Catch SIGINFO and, if we get it and we're capturing to a file in
2072      quiet mode, report the number of packets we've captured.
2073
2074      Again, restart any read that was in progress, so that it doesn't
2075      disrupt reading from the sync pipe. */
2076   action.sa_handler = report_counts_siginfo;
2077   action.sa_flags = SA_RESTART;
2078   sigemptyset(&action.sa_mask);
2079   sigaction(SIGINFO, &action, NULL);
2080 #endif /* SIGINFO */
2081 #endif /* _WIN32 */
2082
2083   global_capture_opts.state = CAPTURE_PREPARING;
2084
2085   /* Let the user know which interfaces were chosen. */
2086   for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2087     interface_options interface_opts;
2088
2089     interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2090     interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
2091     global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
2092     g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
2093   }
2094 #ifdef _WIN32
2095   if (global_capture_opts.ifaces->len < 2) {
2096 #else
2097   if (global_capture_opts.ifaces->len < 4) {
2098 #endif
2099     for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2100       interface_options interface_opts;
2101
2102       interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2103       if (i > 0) {
2104           if (global_capture_opts.ifaces->len > 2) {
2105               g_string_append_printf(str, ",");
2106           }
2107           g_string_append_printf(str, " ");
2108           if (i == global_capture_opts.ifaces->len - 1) {
2109               g_string_append_printf(str, "and ");
2110           }
2111       }
2112       g_string_append_printf(str, "%s", interface_opts.descr);
2113     }
2114   } else {
2115     g_string_append_printf(str, "%u interfaces", global_capture_opts.ifaces->len);
2116   }
2117   fprintf(stdout, "Capturing on %s\n", str->str);
2118   g_string_free(str, TRUE);
2119
2120   ret = sync_pipe_start(&global_capture_opts);
2121
2122   if (!ret)
2123     return FALSE;
2124
2125   /* the actual capture loop
2126    *
2127    * XXX - glib doesn't seem to provide any event based loop handling.
2128    *
2129    * XXX - for whatever reason,
2130    * calling g_main_loop_new() ends up in 100% cpu load.
2131    *
2132    * But that doesn't matter: in UNIX we can use select() to find an input
2133    * source with something to do.
2134    *
2135    * But that doesn't matter because we're in a CLI (that doesn't need to
2136    * update a GUI or something at the same time) so it's OK if we block
2137    * trying to read from the pipe.
2138    *
2139    * So all the stuff in USE_TSHARK_SELECT could be removed unless I'm
2140    * wrong (but I leave it there in case I am...).
2141    */
2142
2143 #ifdef USE_TSHARK_SELECT
2144   FD_ZERO(&readfds);
2145   FD_SET(pipe_input.source, &readfds);
2146 #endif
2147
2148   loop_running = TRUE;
2149
2150   TRY
2151   {
2152     while (loop_running)
2153     {
2154 #ifdef USE_TSHARK_SELECT
2155       ret = select(pipe_input.source+1, &readfds, NULL, NULL, NULL);
2156
2157       if (ret == -1)
2158       {
2159         perror("select()");
2160         return TRUE;
2161       } else if (ret == 1) {
2162 #endif
2163         /* Call the real handler */
2164         if (!pipe_input.input_cb(pipe_input.source, pipe_input.user_data)) {
2165           g_log(NULL, G_LOG_LEVEL_DEBUG, "input pipe closed");
2166           return FALSE;
2167         }
2168 #ifdef USE_TSHARK_SELECT
2169       }
2170 #endif
2171     }
2172   }
2173   CATCH(OutOfMemoryError) {
2174     fprintf(stderr,
2175             "Out Of Memory!\n"
2176             "\n"
2177             "Sorry, but TShark has to terminate now!\n"
2178             "\n"
2179             "Some infos / workarounds can be found at:\n"
2180             "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2181     exit(1);
2182   }
2183   ENDTRY;
2184   return TRUE;
2185 }
2186
2187
2188 /* XXX - move the call to main_window_update() out of capture_sync.c */
2189 /* dummy for capture_sync.c to make linker happy */
2190 void main_window_update(void)
2191 {
2192 }
2193
2194 /* capture child detected an error */
2195 void
2196 capture_input_error_message(capture_options *capture_opts _U_, char *error_msg, char *secondary_error_msg)
2197 {
2198   cmdarg_err("%s", error_msg);
2199   cmdarg_err_cont("%s", secondary_error_msg);
2200 }
2201
2202
2203 /* capture child detected an capture filter related error */
2204 void
2205 capture_input_cfilter_error_message(capture_options *capture_opts, guint i, char *error_message)
2206 {
2207   dfilter_t   *rfcode = NULL;
2208   interface_options interface_opts;
2209
2210   g_assert(i < capture_opts->ifaces->len);
2211   interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
2212
2213   if (dfilter_compile(interface_opts.cfilter, &rfcode) && rfcode != NULL) {
2214     cmdarg_err(
2215       "Invalid capture filter \"%s\" for interface %s!\n"
2216       "\n"
2217       "That string looks like a valid display filter; however, it isn't a valid\n"
2218       "capture filter (%s).\n"
2219       "\n"
2220       "Note that display filters and capture filters don't have the same syntax,\n"
2221       "so you can't use most display filter expressions as capture filters.\n"
2222       "\n"
2223       "See the User's Guide for a description of the capture filter syntax.",
2224       interface_opts.cfilter, interface_opts.descr, error_message);
2225     dfilter_free(rfcode);
2226   } else {
2227     cmdarg_err(
2228       "Invalid capture filter \"%s\" for interface %s!\n"
2229       "\n"
2230       "That string isn't a valid capture filter (%s).\n"
2231       "See the User's Guide for a description of the capture filter syntax.",
2232       interface_opts.cfilter, interface_opts.descr, error_message);
2233   }
2234 }
2235
2236
2237 /* capture child tells us we have a new (or the first) capture file */
2238 gboolean
2239 capture_input_new_file(capture_options *capture_opts, gchar *new_file)
2240 {
2241   gboolean is_tempfile;
2242   int  err;
2243
2244   if(capture_opts->state == CAPTURE_PREPARING) {
2245     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started!");
2246   }
2247   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
2248
2249   g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING);
2250
2251   /* free the old filename */
2252   if (capture_opts->save_file != NULL) {
2253
2254     /* we start a new capture file, close the old one (if we had one before) */
2255     if( ((capture_file *) capture_opts->cf)->state != FILE_CLOSED) {
2256       if ( ((capture_file *) capture_opts->cf)->wth != NULL) {
2257         wtap_close(((capture_file *) capture_opts->cf)->wth);
2258       }
2259       ((capture_file *) capture_opts->cf)->state = FILE_CLOSED;
2260     }
2261
2262     g_free(capture_opts->save_file);
2263     is_tempfile = FALSE;
2264   } else {
2265     /* we didn't had a save_file before, must be a tempfile */
2266     is_tempfile = TRUE;
2267   }
2268
2269   /* save the new filename */
2270   capture_opts->save_file = g_strdup(new_file);
2271
2272   /* if we are in real-time mode, open the new file now */
2273   if(do_dissection) {
2274     /* Attempt to open the capture file and set up to read from it. */
2275     switch(cf_open(capture_opts->cf, capture_opts->save_file, is_tempfile, &err)) {
2276     case CF_OK:
2277       break;
2278     case CF_ERROR:
2279       /* Don't unlink (delete) the save file - leave it around,
2280          for debugging purposes. */
2281       g_free(capture_opts->save_file);
2282       capture_opts->save_file = NULL;
2283       return FALSE;
2284     }
2285   }
2286
2287   capture_opts->state = CAPTURE_RUNNING;
2288
2289   return TRUE;
2290 }
2291
2292
2293 /* capture child tells us we have new packets to read */
2294 void
2295 capture_input_new_packets(capture_options *capture_opts, int to_read)
2296 {
2297   gboolean     ret;
2298   int          err;
2299   gchar        *err_info;
2300   gint64       data_offset;
2301   capture_file *cf = capture_opts->cf;
2302   gboolean filtering_tap_listeners;
2303   guint tap_flags;
2304
2305 #ifdef SIGINFO
2306   /*
2307    * Prevent a SIGINFO handler from writing to the standard error while
2308    * we're doing so or writing to the standard output; instead, have it
2309    * just set a flag telling us to print that information when we're done.
2310    */
2311   infodelay = TRUE;
2312 #endif /* SIGINFO */
2313
2314   /* Do we have any tap listeners with filters? */
2315   filtering_tap_listeners = have_filtering_tap_listeners();
2316
2317   /* Get the union of the flags for all tap listeners. */
2318   tap_flags = union_of_tap_listener_flags();
2319
2320   if(do_dissection) {
2321     while (to_read-- && cf->wth) {
2322       wtap_cleareof(cf->wth);
2323       ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
2324       if(ret == FALSE) {
2325         /* read from file failed, tell the capture child to stop */
2326         sync_pipe_stop(capture_opts);
2327         wtap_close(cf->wth);
2328         cf->wth = NULL;
2329       } else {
2330         ret = process_packet(cf, data_offset, wtap_phdr(cf->wth),
2331                              wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth),
2332                              filtering_tap_listeners, tap_flags);
2333       }
2334       if (ret != FALSE) {
2335         /* packet successfully read and gone through the "Read Filter" */
2336         packet_count++;
2337       }
2338     }
2339   } else {
2340     /*
2341      * Dumpcap's doing all the work; we're not doing any dissection.
2342      * Count all the packets it wrote.
2343      */
2344     packet_count += to_read;
2345   }
2346
2347   if (print_packet_counts) {
2348       /* We're printing packet counts. */
2349       if (packet_count != 0) {
2350         fprintf(stderr, "\r%u ", packet_count);
2351         /* stderr could be line buffered */
2352         fflush(stderr);
2353       }
2354   }
2355
2356 #ifdef SIGINFO
2357   /*
2358    * Allow SIGINFO handlers to write.
2359    */
2360   infodelay = FALSE;
2361
2362   /*
2363    * If a SIGINFO handler asked us to write out capture counts, do so.
2364    */
2365   if (infoprint)
2366     report_counts();
2367 #endif /* SIGINFO */
2368 }
2369
2370 static void
2371 report_counts(void)
2372 {
2373   if (!print_packet_counts) {
2374     /* Report the count only if we aren't printing a packet count
2375        as packets arrive. */
2376     fprintf(stdout, "%u packet%s captured\n", packet_count,
2377             plurality(packet_count, "", "s"));
2378   }
2379 #ifdef SIGINFO
2380   infoprint = FALSE; /* we just reported it */
2381 #endif /* SIGINFO */
2382 }
2383
2384 #ifdef SIGINFO
2385 static void
2386 report_counts_siginfo(int signum _U_)
2387 {
2388   int sav_errno = errno;
2389   /* If we've been told to delay printing, just set a flag asking
2390      that we print counts (if we're supposed to), otherwise print
2391      the count of packets captured (if we're supposed to). */
2392   if (infodelay)
2393     infoprint = TRUE;
2394   else
2395     report_counts();
2396   errno = sav_errno;
2397 }
2398 #endif /* SIGINFO */
2399
2400
2401 /* capture child detected any packet drops? */
2402 void
2403 capture_input_drops(capture_options *capture_opts _U_, guint32 dropped)
2404 {
2405   if (print_packet_counts) {
2406     /* We're printing packet counts to stderr.
2407        Send a newline so that we move to the line after the packet count. */
2408     fprintf(stderr, "\n");
2409   }
2410
2411   if (dropped != 0) {
2412     /* We're printing packet counts to stderr.
2413        Send a newline so that we move to the line after the packet count. */
2414     fprintf(stderr, "%u packet%s dropped\n", dropped, plurality(dropped, "", "s"));
2415   }
2416 }
2417
2418
2419 /*
2420  * Capture child closed its side of the pipe, report any error and
2421  * do the required cleanup.
2422  */
2423 void
2424 capture_input_closed(capture_options *capture_opts, gchar *msg)
2425 {
2426   if (msg != NULL)
2427     fprintf(stderr, "tshark: %s\n", msg);
2428
2429   report_counts();
2430
2431   if(capture_opts->cf != NULL && ((capture_file *) capture_opts->cf)->wth != NULL) {
2432     wtap_close(((capture_file *) capture_opts->cf)->wth);
2433     if(((capture_file *) capture_opts->cf)->user_saved == FALSE) {
2434       ws_unlink(((capture_file *) capture_opts->cf)->filename);
2435     }
2436   }
2437 #ifdef USE_BROKEN_G_MAIN_LOOP
2438   /*g_main_loop_quit(loop);*/
2439   g_main_quit(loop);
2440 #else
2441   loop_running = FALSE;
2442 #endif
2443 }
2444
2445
2446
2447
2448 #ifdef _WIN32
2449 static BOOL WINAPI
2450 capture_cleanup(DWORD ctrltype _U_)
2451 {
2452   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
2453      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
2454      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
2455      like SIGTERM at least when the machine's shutting down.
2456
2457      For now, we handle them all as indications that we should clean up
2458      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
2459      way on UNIX.
2460
2461      We must return TRUE so that no other handler - such as one that would
2462      terminate the process - gets called.
2463
2464      XXX - for some reason, typing ^C to TShark, if you run this in
2465      a Cygwin console window in at least some versions of Cygwin,
2466      causes TShark to terminate immediately; this routine gets
2467      called, but the main loop doesn't get a chance to run and
2468      exit cleanly, at least if this is compiled with Microsoft Visual
2469      C++ (i.e., it's a property of the Cygwin console window or Bash;
2470      it happens if TShark is not built with Cygwin - for all I know,
2471      building it with Cygwin may make the problem go away). */
2472
2473   /* tell the capture child to stop */
2474   sync_pipe_stop(&global_capture_opts);
2475
2476   /* don't stop our own loop already here, otherwise status messages and
2477    * cleanup wouldn't be done properly. The child will indicate the stop of
2478    * everything by calling capture_input_closed() later */
2479
2480   return TRUE;
2481 }
2482 #else
2483 static void
2484 capture_cleanup(int signum _U_)
2485 {
2486   /* tell the capture child to stop */
2487   sync_pipe_stop(&global_capture_opts);
2488
2489   /* don't stop our own loop already here, otherwise status messages and
2490    * cleanup wouldn't be done properly. The child will indicate the stop of
2491    * everything by calling capture_input_closed() later */
2492 }
2493 #endif /* _WIN32 */
2494 #endif /* HAVE_LIBPCAP */
2495
2496 static gboolean
2497 process_packet_first_pass(capture_file *cf,
2498                gint64 offset, const struct wtap_pkthdr *whdr,
2499                union wtap_pseudo_header *pseudo_header, const guchar *pd)
2500 {
2501   frame_data fdlocal;
2502   guint32 framenum;
2503   epan_dissect_t edt;
2504   gboolean passed;
2505
2506   /* The frame number of this packet is one more than the count of
2507      frames in this packet. */
2508   framenum = cf->count + 1;
2509
2510   /* If we're not running a display filter and we're not printing any
2511      packet information, we don't need to do a dissection. This means
2512      that all packets can be marked as 'passed'. */
2513   passed = TRUE;
2514
2515   frame_data_init(&fdlocal, framenum, whdr, offset, cum_bytes);
2516
2517   /* If we're going to print packet information, or we're going to
2518      run a read filter, or we're going to process taps, set up to
2519      do a dissection and do so. */
2520   if (do_dissection) {
2521     if (gbl_resolv_flags)
2522       /* Grab any resolved addresses */
2523       host_name_lookup_process(NULL);
2524
2525     /* The protocol tree will be "visible", i.e., printed, only if we're
2526        printing packet details, which is true if we're printing stuff
2527        ("print_packet_info" is true) and we're in verbose mode ("verbose"
2528        is true). */
2529     epan_dissect_init(&edt, FALSE, FALSE);
2530
2531     /* If we're running a read filter, prime the epan_dissect_t with that
2532        filter. */
2533     if (cf->rfcode)
2534       epan_dissect_prime_dfilter(&edt, cf->rfcode);
2535
2536     frame_data_set_before_dissect(&fdlocal, &cf->elapsed_time,
2537                                   &first_ts, &prev_dis_ts, &prev_cap_ts);
2538
2539     epan_dissect_run(&edt, pseudo_header, pd, &fdlocal, NULL);
2540
2541     /* Run the read filter if we have one. */
2542     if (cf->rfcode)
2543       passed = dfilter_apply_edt(cf->rfcode, &edt);
2544   }
2545
2546   if (passed) {
2547     frame_data_set_after_dissect(&fdlocal, &cum_bytes, &prev_dis_ts);
2548     frame_data_sequence_add(cf->frames, &fdlocal);
2549     cf->count++;
2550   }
2551
2552   if (do_dissection)
2553     epan_dissect_cleanup(&edt);
2554
2555   return passed;
2556 }
2557
2558 static gboolean
2559 process_packet_second_pass(capture_file *cf, frame_data *fdata,
2560                union wtap_pseudo_header *pseudo_header, const guchar *pd,
2561                gboolean filtering_tap_listeners, guint tap_flags)
2562 {
2563   gboolean create_proto_tree;
2564   column_info *cinfo;
2565   epan_dissect_t edt;
2566   gboolean passed;
2567
2568   /* If we're not running a display filter and we're not printing any
2569      packet information, we don't need to do a dissection. This means
2570      that all packets can be marked as 'passed'. */
2571   passed = TRUE;
2572
2573   /* If we're going to print packet information, or we're going to
2574      run a read filter, or we're going to process taps, set up to
2575      do a dissection and do so. */
2576   if (do_dissection) {
2577     if (gbl_resolv_flags)
2578       /* Grab any resolved addresses */
2579       host_name_lookup_process(NULL);
2580
2581     if (cf->rfcode || verbose || filtering_tap_listeners ||
2582         (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
2583       create_proto_tree = TRUE;
2584     else
2585       create_proto_tree = FALSE;
2586
2587     /* The protocol tree will be "visible", i.e., printed, only if we're
2588        printing packet details, which is true if we're printing stuff
2589        ("print_packet_info" is true) and we're in verbose mode ("verbose"
2590        is true). */
2591     epan_dissect_init(&edt, create_proto_tree, print_packet_info && verbose);
2592
2593     /* If we're running a read filter, prime the epan_dissect_t with that
2594        filter. */
2595     if (cf->rfcode)
2596       epan_dissect_prime_dfilter(&edt, cf->rfcode);
2597
2598     col_custom_prime_edt(&edt, &cf->cinfo);
2599
2600     tap_queue_init(&edt);
2601
2602     /* We only need the columns if either
2603
2604          1) some tap needs the columns
2605
2606        or
2607
2608          2) we're printing packet info but we're *not* verbose; in verbose
2609             mode, we print the protocol tree, not the protocol summary. */
2610     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && !verbose))
2611       cinfo = &cf->cinfo;
2612     else
2613       cinfo = NULL;
2614
2615     epan_dissect_run(&edt, pseudo_header, pd, fdata, cinfo);
2616
2617     tap_push_tapped_queue(&edt);
2618
2619     /* Run the read filter if we have one. */
2620     if (cf->rfcode)
2621       passed = dfilter_apply_edt(cf->rfcode, &edt);
2622   }
2623
2624   if (passed) {
2625     /* Process this packet. */
2626     if (print_packet_info) {
2627       /* We're printing packet information; print the information for
2628          this packet. */
2629       if (do_dissection)
2630         print_packet(cf, &edt);
2631       else
2632         print_packet(cf, NULL);
2633
2634       /* The ANSI C standard does not appear to *require* that a line-buffered
2635          stream be flushed to the host environment whenever a newline is
2636          written, it just says that, on such a stream, characters "are
2637          intended to be transmitted to or from the host environment as a
2638          block when a new-line character is encountered".
2639
2640          The Visual C++ 6.0 C implementation doesn't do what is intended;
2641          even if you set a stream to be line-buffered, it still doesn't
2642          flush the buffer at the end of every line.
2643
2644          So, if the "-l" flag was specified, we flush the standard output
2645          at the end of a packet.  This will do the right thing if we're
2646          printing packet summary lines, and, as we print the entire protocol
2647          tree for a single packet without waiting for anything to happen,
2648          it should be as good as line-buffered mode if we're printing
2649          protocol trees.  (The whole reason for the "-l" flag in either
2650          tcpdump or TShark is to allow the output of a live capture to
2651          be piped to a program or script and to have that script see the
2652          information for the packet as soon as it's printed, rather than
2653          having to wait until a standard I/O buffer fills up. */
2654       if (line_buffered)
2655         fflush(stdout);
2656
2657       if (ferror(stdout)) {
2658         show_print_file_io_error(errno);
2659         exit(2);
2660       }
2661     }
2662   }
2663
2664   if (do_dissection) {
2665     epan_dissect_cleanup(&edt);
2666   }
2667   return passed;
2668 }
2669
2670 static int
2671 load_cap_file(capture_file *cf, char *save_file, int out_file_type,
2672     gboolean out_file_name_res, int max_packet_count, gint64 max_byte_count)
2673 {
2674   gint         linktype;
2675   int          snapshot_length;
2676   wtap_dumper *pdh;
2677   guint32      framenum;
2678   int          err;
2679   gchar        *err_info = NULL;
2680   gint64       data_offset;
2681   char         *save_file_string = NULL;
2682   gboolean     filtering_tap_listeners;
2683   guint        tap_flags;
2684
2685 #ifdef PCAP_NG_DEFAULT
2686   linktype = WTAP_ENCAP_PER_PACKET;
2687 #else
2688   linktype = wtap_file_encap(cf->wth);
2689 #endif
2690   if (save_file != NULL) {
2691     /* Get a string that describes what we're writing to */
2692     save_file_string = output_file_description(save_file);
2693
2694     /* Set up to write to the capture file. */
2695     snapshot_length = wtap_snapshot_length(cf->wth);
2696     if (snapshot_length == 0) {
2697       /* Snapshot length of input file not known. */
2698       snapshot_length = WTAP_MAX_PACKET_SIZE;
2699     }
2700     pdh = wtap_dump_open(save_file, out_file_type, linktype, snapshot_length,
2701                          FALSE /* compressed */, &err);
2702
2703     if (pdh == NULL) {
2704       /* We couldn't set up to write to the capture file. */
2705       switch (err) {
2706
2707       case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
2708         cmdarg_err("Capture files can't be written in that format.");
2709         break;
2710
2711       case WTAP_ERR_UNSUPPORTED_ENCAP:
2712       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
2713         cmdarg_err("The capture file being read can't be written as a "
2714           "\"%s\" file.", wtap_file_type_short_string(out_file_type));
2715         break;
2716
2717       case WTAP_ERR_CANT_OPEN:
2718         cmdarg_err("The %s couldn't be created for some "
2719           "unknown reason.", save_file_string);
2720         break;
2721
2722       case WTAP_ERR_SHORT_WRITE:
2723         cmdarg_err("A full header couldn't be written to the %s.",
2724                    save_file_string);
2725         break;
2726
2727       default:
2728         cmdarg_err("The %s could not be created: %s.", save_file_string,
2729                    wtap_strerror(err));
2730         break;
2731       }
2732       goto out;
2733     }
2734   } else {
2735     if (print_packet_info) {
2736       if (!write_preamble(cf)) {
2737         err = errno;
2738         show_print_file_io_error(err);
2739         goto out;
2740       }
2741     }
2742     pdh = NULL;
2743   }
2744
2745   if (pdh && out_file_name_res) {
2746     if (!wtap_dump_set_addrinfo_list(pdh, get_addrinfo_list())) {
2747       cmdarg_err("The file format \"%s\" doesn't support name resolution information.",
2748                  wtap_file_type_short_string(out_file_type));
2749     }
2750   }
2751
2752   /* Do we have any tap listeners with filters? */
2753   filtering_tap_listeners = have_filtering_tap_listeners();
2754
2755   /* Get the union of the flags for all tap listeners. */
2756   tap_flags = union_of_tap_listener_flags();
2757
2758   if (perform_two_pass_analysis) {
2759     frame_data *fdata;
2760     int old_max_packet_count = max_packet_count;
2761
2762     /* Allocate a frame_data_sequence for all the frames. */
2763     cf->frames = new_frame_data_sequence();
2764
2765     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
2766       if (process_packet_first_pass(cf, data_offset, wtap_phdr(cf->wth),
2767                          wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth))) {
2768         /* Stop reading if we have the maximum number of packets;
2769          * When the -c option has not been used, max_packet_count
2770          * starts at 0, which practically means, never stop reading.
2771          * (unless we roll over max_packet_count ?)
2772          */
2773         if( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
2774           err = 0; /* This is not an error */
2775           break;
2776         }
2777       }
2778     }
2779
2780     /* Close the sequential I/O side, to free up memory it requires. */
2781     wtap_sequential_close(cf->wth);
2782
2783     /* Allow the protocol dissectors to free up memory that they
2784      * don't need after the sequential run-through of the packets. */
2785     postseq_cleanup_all_protocols();
2786
2787     max_packet_count = old_max_packet_count;
2788
2789     for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
2790       fdata = frame_data_sequence_find(cf->frames, framenum);
2791       if (wtap_seek_read(cf->wth, fdata->file_off, &cf->pseudo_header,
2792           cf->pd, fdata->cap_len, &err, &err_info)) {
2793         if (process_packet_second_pass(cf, fdata,
2794                            &cf->pseudo_header, cf->pd,
2795                            filtering_tap_listeners, tap_flags)) {
2796           /* Either there's no read filtering or this packet passed the
2797              filter, so, if we're writing to a capture file, write
2798              this packet out. */
2799           if (pdh != NULL) {
2800             if (!wtap_dump(pdh, wtap_phdr(cf->wth),
2801                            wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth),
2802                            &err)) {
2803               /* Error writing to a capture file */
2804               switch (err) {
2805
2806               case WTAP_ERR_UNSUPPORTED_ENCAP:
2807                 /*
2808                  * This is a problem with the particular frame we're writing;
2809                  * note that, and give the frame number.
2810                  *
2811                  * XXX - framenum is not necessarily the frame number in
2812                  * the input file if there was a read filter.
2813                  */
2814                 fprintf(stderr,
2815                         "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
2816                         framenum, cf->filename,
2817                         wtap_file_type_short_string(out_file_type));
2818                 break;
2819
2820               default:
2821                 show_capture_file_io_error(save_file, err, FALSE);
2822                 break;
2823               }
2824               wtap_dump_close(pdh, &err);
2825               exit(2);
2826             }
2827           }
2828           /* Stop reading if we have the maximum number of packets;
2829            * When the -c option has not been used, max_packet_count
2830            * starts at 0, which practically means, never stop reading.
2831            * (unless we roll over max_packet_count ?)
2832            */
2833           if( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
2834             err = 0; /* This is not an error */
2835             break;
2836           }
2837         }
2838       }
2839     }
2840   }
2841   else {
2842     framenum = 0;
2843     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
2844       framenum++;
2845
2846       if (process_packet(cf, data_offset, wtap_phdr(cf->wth),
2847                          wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth),
2848                          filtering_tap_listeners, tap_flags)) {
2849         /* Either there's no read filtering or this packet passed the
2850            filter, so, if we're writing to a capture file, write
2851            this packet out. */
2852         if (pdh != NULL) {
2853           if (!wtap_dump(pdh, wtap_phdr(cf->wth),
2854                          wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth),
2855                          &err)) {
2856             /* Error writing to a capture file */
2857             switch (err) {
2858
2859             case WTAP_ERR_UNSUPPORTED_ENCAP:
2860               /*
2861                * This is a problem with the particular frame we're writing;
2862                * note that, and give the frame number.
2863                */
2864               fprintf(stderr,
2865                       "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
2866                       framenum, cf->filename,
2867                       wtap_file_type_short_string(out_file_type));
2868               break;
2869
2870             default:
2871               show_capture_file_io_error(save_file, err, FALSE);
2872               break;
2873             }
2874             wtap_dump_close(pdh, &err);
2875             exit(2);
2876           }
2877         }
2878         /* Stop reading if we have the maximum number of packets;
2879          * When the -c option has not been used, max_packet_count
2880          * starts at 0, which practically means, never stop reading.
2881          * (unless we roll over max_packet_count ?)
2882          */
2883         if( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
2884           err = 0; /* This is not an error */
2885           break;
2886         }
2887       }
2888     }
2889   }
2890
2891   if (err != 0) {
2892     /*
2893      * Print a message noting that the read failed somewhere along the line.
2894      *
2895      * If we're printing packet data, and the standard output and error are
2896      * going to the same place, flush the standard output, so everything
2897      * buffered up is written, and then print a newline to the standard error
2898      * before printing the error message, to separate it from the packet
2899      * data.  (Alas, that only works on UN*X; st_dev is meaningless, and
2900      * the _fstat() documentation at Microsoft doesn't indicate whether
2901      * st_ino is even supported.)
2902      */
2903 #ifndef _WIN32
2904     if (print_packet_info) {
2905       struct stat stat_stdout, stat_stderr;
2906
2907       if (fstat(1, &stat_stdout) == 0 && fstat(2, &stat_stderr) == 0) {
2908         if (stat_stdout.st_dev == stat_stderr.st_dev &&
2909             stat_stdout.st_ino == stat_stderr.st_ino) {
2910           fflush(stdout);
2911           fprintf(stderr, "\n");
2912         }
2913       }
2914     }
2915 #endif
2916     switch (err) {
2917
2918     case WTAP_ERR_UNSUPPORTED_ENCAP:
2919       cmdarg_err("The file \"%s\" has a packet with a network type that TShark doesn't support.\n(%s)",
2920                  cf->filename, err_info);
2921       g_free(err_info);
2922       break;
2923
2924     case WTAP_ERR_CANT_READ:
2925       cmdarg_err("An attempt to read from the file \"%s\" failed for some unknown reason.",
2926                  cf->filename);
2927       break;
2928
2929     case WTAP_ERR_SHORT_READ:
2930       cmdarg_err("The file \"%s\" appears to have been cut short in the middle of a packet.",
2931                  cf->filename);
2932       break;
2933
2934     case WTAP_ERR_BAD_FILE:
2935       cmdarg_err("The file \"%s\" appears to be damaged or corrupt.\n(%s)",
2936                  cf->filename, err_info);
2937       g_free(err_info);
2938       break;
2939
2940     case WTAP_ERR_DECOMPRESS:
2941       cmdarg_err("The compressed file \"%s\" appears to be damaged or corrupt.\n"
2942                  "(%s)", cf->filename, err_info);
2943       break;
2944
2945     default:
2946       cmdarg_err("An error occurred while reading the file \"%s\": %s.",
2947                  cf->filename, wtap_strerror(err));
2948       break;
2949     }
2950     if (save_file != NULL) {
2951       /* Now close the capture file. */
2952       if (!wtap_dump_close(pdh, &err))
2953         show_capture_file_io_error(save_file, err, TRUE);
2954     }
2955   } else {
2956     if (save_file != NULL) {
2957       /* Now close the capture file. */
2958       if (!wtap_dump_close(pdh, &err))
2959         show_capture_file_io_error(save_file, err, TRUE);
2960     } else {
2961       if (print_packet_info) {
2962         if (!write_finale()) {
2963           err = errno;
2964           show_print_file_io_error(err);
2965         }
2966       }
2967     }
2968   }
2969
2970 out:
2971   wtap_close(cf->wth);
2972   cf->wth = NULL;
2973
2974   g_free(save_file_string);
2975
2976   return err;
2977 }
2978
2979 static gboolean
2980 process_packet(capture_file *cf, gint64 offset, const struct wtap_pkthdr *whdr,
2981                union wtap_pseudo_header *pseudo_header, const guchar *pd,
2982                gboolean filtering_tap_listeners, guint tap_flags)
2983 {
2984   frame_data fdata;
2985   gboolean create_proto_tree;
2986   column_info *cinfo;
2987   epan_dissect_t edt;
2988   gboolean passed;
2989
2990   /* Count this packet. */
2991   cf->count++;
2992
2993   /* If we're not running a display filter and we're not printing any
2994      packet information, we don't need to do a dissection. This means
2995      that all packets can be marked as 'passed'. */
2996   passed = TRUE;
2997
2998   frame_data_init(&fdata, cf->count, whdr, offset, cum_bytes);
2999
3000   /* If we're going to print packet information, or we're going to
3001      run a read filter, or we're going to process taps, set up to
3002      do a dissection and do so. */
3003   if (do_dissection) {
3004     if (print_packet_info && gbl_resolv_flags)
3005       /* Grab any resolved addresses */
3006       host_name_lookup_process(NULL);
3007
3008     if (cf->rfcode || verbose || filtering_tap_listeners ||
3009         (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
3010       create_proto_tree = TRUE;
3011     else
3012       create_proto_tree = FALSE;
3013
3014     /* The protocol tree will be "visible", i.e., printed, only if we're
3015        printing packet details, which is true if we're printing stuff
3016        ("print_packet_info" is true) and we're in verbose mode ("verbose"
3017        is true). */
3018     epan_dissect_init(&edt, create_proto_tree, print_packet_info && verbose);
3019
3020     /* If we're running a read filter, prime the epan_dissect_t with that
3021        filter. */
3022     if (cf->rfcode)
3023       epan_dissect_prime_dfilter(&edt, cf->rfcode);
3024
3025     col_custom_prime_edt(&edt, &cf->cinfo);
3026
3027     tap_queue_init(&edt);
3028
3029     /* We only need the columns if either
3030
3031          1) some tap needs the columns
3032
3033        or
3034
3035          2) we're printing packet info but we're *not* verbose; in verbose
3036             mode, we print the protocol tree, not the protocol summary. */
3037     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && !verbose))
3038       cinfo = &cf->cinfo;
3039     else
3040       cinfo = NULL;
3041
3042     frame_data_set_before_dissect(&fdata, &cf->elapsed_time,
3043                                   &first_ts, &prev_dis_ts, &prev_cap_ts);
3044
3045     epan_dissect_run(&edt, pseudo_header, pd, &fdata, cinfo);
3046
3047     tap_push_tapped_queue(&edt);
3048
3049     /* Run the read filter if we have one. */
3050     if (cf->rfcode)
3051       passed = dfilter_apply_edt(cf->rfcode, &edt);
3052   }
3053
3054   if (passed) {
3055     frame_data_set_after_dissect(&fdata, &cum_bytes, &prev_dis_ts);
3056
3057     /* Process this packet. */
3058     if (print_packet_info) {
3059       /* We're printing packet information; print the information for
3060          this packet. */
3061       if (do_dissection)
3062         print_packet(cf, &edt);
3063       else
3064         print_packet(cf, NULL);
3065
3066       /* The ANSI C standard does not appear to *require* that a line-buffered
3067          stream be flushed to the host environment whenever a newline is
3068          written, it just says that, on such a stream, characters "are
3069          intended to be transmitted to or from the host environment as a
3070          block when a new-line character is encountered".
3071
3072          The Visual C++ 6.0 C implementation doesn't do what is intended;
3073          even if you set a stream to be line-buffered, it still doesn't
3074          flush the buffer at the end of every line.
3075
3076          So, if the "-l" flag was specified, we flush the standard output
3077          at the end of a packet.  This will do the right thing if we're
3078          printing packet summary lines, and, as we print the entire protocol
3079          tree for a single packet without waiting for anything to happen,
3080          it should be as good as line-buffered mode if we're printing
3081          protocol trees.  (The whole reason for the "-l" flag in either
3082          tcpdump or TShark is to allow the output of a live capture to
3083          be piped to a program or script and to have that script see the
3084          information for the packet as soon as it's printed, rather than
3085          having to wait until a standard I/O buffer fills up. */
3086       if (line_buffered)
3087         fflush(stdout);
3088
3089       if (ferror(stdout)) {
3090         show_print_file_io_error(errno);
3091         exit(2);
3092       }
3093     }
3094   }
3095
3096   if (do_dissection) {
3097     epan_dissect_cleanup(&edt);
3098     frame_data_cleanup(&fdata);
3099   }
3100   return passed;
3101 }
3102
3103 static gboolean
3104 write_preamble(capture_file *cf)
3105 {
3106   switch (output_action) {
3107
3108   case WRITE_TEXT:
3109     return print_preamble(print_stream, cf ? cf->filename : NULL);
3110
3111   case WRITE_XML:
3112     if (verbose)
3113       write_pdml_preamble(stdout, cf ? cf->filename : NULL);
3114     else
3115       write_psml_preamble(stdout);
3116     return !ferror(stdout);
3117
3118   case WRITE_FIELDS:
3119     write_fields_preamble(output_fields, stdout);
3120     return !ferror(stdout);
3121
3122   default:
3123     g_assert_not_reached();
3124     return FALSE;
3125   }
3126 }
3127
3128 static char *
3129 get_line_buf(size_t len)
3130 {
3131   static char *line_bufp = NULL;
3132   static size_t line_buf_len = 256;
3133   size_t new_line_buf_len;
3134
3135   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
3136        new_line_buf_len *= 2)
3137     ;
3138   if (line_bufp == NULL) {
3139     line_buf_len = new_line_buf_len;
3140     line_bufp = g_malloc(line_buf_len + 1);
3141   } else {
3142     if (new_line_buf_len > line_buf_len) {
3143       line_buf_len = new_line_buf_len;
3144       line_bufp = g_realloc(line_bufp, line_buf_len + 1);
3145     }
3146   }
3147   return line_bufp;
3148 }
3149
3150 static gboolean
3151 print_columns(capture_file *cf)
3152 {
3153   char *line_bufp;
3154   int i;
3155   size_t buf_offset;
3156   size_t column_len;
3157
3158   line_bufp = get_line_buf(256);
3159   buf_offset = 0;
3160   *line_bufp = '\0';
3161   for (i = 0; i < cf->cinfo.num_cols; i++) {
3162     /* Skip columns not marked as visible. */
3163     if (!get_column_visible(i))
3164       continue;
3165     switch (cf->cinfo.col_fmt[i]) {
3166     case COL_NUMBER:
3167 #ifdef HAVE_LIBPCAP
3168       /*
3169        * Don't print this if we're doing a live capture from a network
3170        * interface - if we're doing a live capture, you won't be
3171        * able to look at the capture in the future (it's not being
3172        * saved anywhere), so the frame numbers are unlikely to be
3173        * useful.
3174        *
3175        * (XXX - it might be nice to be able to save and print at
3176        * the same time, sort of like an "Update list of packets
3177        * in real time" capture in Wireshark.)
3178        */
3179       if (global_capture_opts.ifaces->len > 0)
3180         continue;
3181 #endif
3182       column_len = strlen(cf->cinfo.col_data[i]);
3183       if (column_len < 3)
3184         column_len = 3;
3185       line_bufp = get_line_buf(buf_offset + column_len);
3186       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%3s", cf->cinfo.col_data[i]);
3187       break;
3188
3189     case COL_CLS_TIME:
3190     case COL_REL_TIME:
3191     case COL_ABS_TIME:
3192     case COL_ABS_DATE_TIME:
3193     case COL_UTC_TIME:
3194     case COL_UTC_DATE_TIME: /* XXX - wider */
3195       column_len = strlen(cf->cinfo.col_data[i]);
3196       if (column_len < 10)
3197         column_len = 10;
3198       line_bufp = get_line_buf(buf_offset + column_len);
3199       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%10s", cf->cinfo.col_data[i]);
3200       break;
3201
3202     case COL_DEF_SRC:
3203     case COL_RES_SRC:
3204     case COL_UNRES_SRC:
3205     case COL_DEF_DL_SRC:
3206     case COL_RES_DL_SRC:
3207     case COL_UNRES_DL_SRC:
3208     case COL_DEF_NET_SRC:
3209     case COL_RES_NET_SRC:
3210     case COL_UNRES_NET_SRC:
3211       column_len = strlen(cf->cinfo.col_data[i]);
3212       if (column_len < 12)
3213         column_len = 12;
3214       line_bufp = get_line_buf(buf_offset + column_len);
3215       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%12s", cf->cinfo.col_data[i]);
3216       break;
3217
3218     case COL_DEF_DST:
3219     case COL_RES_DST:
3220     case COL_UNRES_DST:
3221     case COL_DEF_DL_DST:
3222     case COL_RES_DL_DST:
3223     case COL_UNRES_DL_DST:
3224     case COL_DEF_NET_DST:
3225     case COL_RES_NET_DST:
3226     case COL_UNRES_NET_DST:
3227       column_len = strlen(cf->cinfo.col_data[i]);
3228       if (column_len < 12)
3229         column_len = 12;
3230       line_bufp = get_line_buf(buf_offset + column_len);
3231       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%-12s", cf->cinfo.col_data[i]);
3232       break;
3233
3234     default:
3235       column_len = strlen(cf->cinfo.col_data[i]);
3236       line_bufp = get_line_buf(buf_offset + column_len);
3237       g_strlcat(line_bufp + buf_offset, cf->cinfo.col_data[i], column_len + 1);
3238       break;
3239     }
3240     buf_offset += column_len;
3241     if (i != cf->cinfo.num_cols - 1) {
3242       /*
3243        * This isn't the last column, so we need to print a
3244        * separator between this column and the next.
3245        *
3246        * If we printed a network source and are printing a
3247        * network destination of the same type next, separate
3248        * them with " -> "; if we printed a network destination
3249        * and are printing a network source of the same type
3250        * next, separate them with " <- "; otherwise separate them
3251        * with a space.
3252        *
3253        * We add enough space to the buffer for " <- " or " -> ",
3254        * even if we're only adding " ".
3255        */
3256       line_bufp = get_line_buf(buf_offset + 4);
3257       switch (cf->cinfo.col_fmt[i]) {
3258
3259       case COL_DEF_SRC:
3260       case COL_RES_SRC:
3261       case COL_UNRES_SRC:
3262         switch (cf->cinfo.col_fmt[i + 1]) {
3263
3264         case COL_DEF_DST:
3265         case COL_RES_DST:
3266         case COL_UNRES_DST:
3267           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3268           buf_offset += 4;
3269           break;
3270
3271         default:
3272           g_strlcat(line_bufp + buf_offset, " ", 5);
3273           buf_offset += 1;
3274           break;
3275         }
3276         break;
3277
3278       case COL_DEF_DL_SRC:
3279       case COL_RES_DL_SRC:
3280       case COL_UNRES_DL_SRC:
3281         switch (cf->cinfo.col_fmt[i + 1]) {
3282
3283         case COL_DEF_DL_DST:
3284         case COL_RES_DL_DST:
3285         case COL_UNRES_DL_DST:
3286           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3287           buf_offset += 4;
3288           break;
3289
3290         default:
3291           g_strlcat(line_bufp + buf_offset, " ", 5);
3292           buf_offset += 1;
3293           break;
3294         }
3295         break;
3296
3297       case COL_DEF_NET_SRC:
3298       case COL_RES_NET_SRC:
3299       case COL_UNRES_NET_SRC:
3300         switch (cf->cinfo.col_fmt[i + 1]) {
3301
3302         case COL_DEF_NET_DST:
3303         case COL_RES_NET_DST:
3304         case COL_UNRES_NET_DST:
3305           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3306           buf_offset += 4;
3307           break;
3308
3309         default:
3310           g_strlcat(line_bufp + buf_offset, " ", 5);
3311           buf_offset += 1;
3312           break;
3313         }
3314         break;
3315
3316       case COL_DEF_DST:
3317       case COL_RES_DST:
3318       case COL_UNRES_DST:
3319         switch (cf->cinfo.col_fmt[i + 1]) {
3320
3321         case COL_DEF_SRC:
3322         case COL_RES_SRC:
3323         case COL_UNRES_SRC:
3324           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3325           buf_offset += 4;
3326           break;
3327
3328         default:
3329           g_strlcat(line_bufp + buf_offset, " ", 5);
3330           buf_offset += 1;
3331           break;
3332         }
3333         break;
3334
3335       case COL_DEF_DL_DST:
3336       case COL_RES_DL_DST:
3337       case COL_UNRES_DL_DST:
3338         switch (cf->cinfo.col_fmt[i + 1]) {
3339
3340         case COL_DEF_DL_SRC:
3341         case COL_RES_DL_SRC:
3342         case COL_UNRES_DL_SRC:
3343           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3344           buf_offset += 4;
3345           break;
3346
3347         default:
3348           g_strlcat(line_bufp + buf_offset, " ", 5);
3349           buf_offset += 1;
3350           break;
3351         }
3352         break;
3353
3354       case COL_DEF_NET_DST:
3355       case COL_RES_NET_DST:
3356       case COL_UNRES_NET_DST:
3357         switch (cf->cinfo.col_fmt[i + 1]) {
3358
3359         case COL_DEF_NET_SRC:
3360         case COL_RES_NET_SRC:
3361         case COL_UNRES_NET_SRC:
3362           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3363           buf_offset += 4;
3364           break;
3365
3366         default:
3367           g_strlcat(line_bufp + buf_offset, " ", 5);
3368           buf_offset += 1;
3369           break;
3370         }
3371         break;
3372
3373       default:
3374         g_strlcat(line_bufp + buf_offset, " ", 5);
3375         buf_offset += 1;
3376         break;
3377       }
3378     }
3379   }
3380   return print_line(print_stream, 0, line_bufp);
3381 }
3382
3383 static gboolean
3384 print_packet(capture_file *cf, epan_dissect_t *edt)
3385 {
3386   print_args_t  print_args;
3387
3388   if (verbose) {
3389     /* Print the information in the protocol tree. */
3390     switch (output_action) {
3391
3392     case WRITE_TEXT:
3393       print_args.to_file = TRUE;
3394       print_args.format = print_format;
3395       print_args.print_summary = !verbose;
3396       print_args.print_hex = verbose && print_hex;
3397       print_args.print_formfeed = FALSE;
3398       print_args.print_dissections = verbose ? print_dissections_expanded : print_dissections_none;
3399
3400       /* init the packet range */
3401       packet_range_init(&print_args.range);
3402
3403       if (!proto_tree_print(&print_args, edt, print_stream))
3404         return FALSE;
3405       if (!print_hex) {
3406         /* "print_hex_data()" will put out a leading blank line, as well
3407          as a trailing one; print one here, to separate the packets,
3408          only if "print_hex_data()" won't be called. */
3409         if (!print_line(print_stream, 0, separator))
3410           return FALSE;
3411       }
3412       break;
3413
3414     case WRITE_XML:
3415       proto_tree_write_pdml(edt, stdout);
3416       printf("\n");
3417       return !ferror(stdout);
3418     case WRITE_FIELDS:
3419       proto_tree_write_fields(output_fields, edt, stdout);
3420       printf("\n");
3421       return !ferror(stdout);
3422     }
3423   } else {
3424     /* Just fill in the columns. */
3425     epan_dissect_fill_in_columns(edt, FALSE, TRUE);
3426
3427     /* Now print them. */
3428     switch (output_action) {
3429
3430     case WRITE_TEXT:
3431         if (!print_columns(cf))
3432           return FALSE;
3433         break;
3434
3435     case WRITE_XML:
3436         proto_tree_write_psml(edt, stdout);
3437         return !ferror(stdout);
3438     case WRITE_FIELDS: /*No non-verbose "fields" format */
3439         g_assert_not_reached();
3440         break;
3441     }
3442   }
3443   if (print_hex) {
3444     if (!print_hex_data(print_stream, edt))
3445       return FALSE;
3446     if (!print_line(print_stream, 0, ""))
3447       return FALSE;
3448   }
3449   return TRUE;
3450 }
3451
3452 static gboolean
3453 write_finale(void)
3454 {
3455   switch (output_action) {
3456
3457   case WRITE_TEXT:
3458     return print_finale(print_stream);
3459
3460   case WRITE_XML:
3461     if (verbose)
3462       write_pdml_finale(stdout);
3463     else
3464       write_psml_finale(stdout);
3465     return !ferror(stdout);
3466
3467   case WRITE_FIELDS:
3468     write_fields_finale(output_fields, stdout);
3469     return !ferror(stdout);
3470
3471   default:
3472     g_assert_not_reached();
3473     return FALSE;
3474   }
3475 }
3476
3477 cf_status_t
3478 cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
3479 {
3480   wtap       *wth;
3481   gchar       *err_info;
3482   char        err_msg[2048+1];
3483
3484   wth = wtap_open_offline(fname, err, &err_info, perform_two_pass_analysis);
3485   if (wth == NULL)
3486     goto fail;
3487
3488   /* The open succeeded.  Fill in the information for this file. */
3489
3490   /* Cleanup all data structures used for dissection. */
3491   cleanup_dissection();
3492   /* Initialize all data structures used for dissection. */
3493   init_dissection();
3494
3495   cf->wth = wth;
3496   cf->f_datalen = 0; /* not used, but set it anyway */
3497
3498   /* Set the file name because we need it to set the follow stream filter.
3499      XXX - is that still true?  We need it for other reasons, though,
3500      in any case. */
3501   cf->filename = g_strdup(fname);
3502
3503   /* Indicate whether it's a permanent or temporary file. */
3504   cf->is_tempfile = is_tempfile;
3505
3506   /* If it's a temporary capture buffer file, mark it as not saved. */
3507   cf->user_saved = !is_tempfile;
3508
3509   cf->cd_t      = wtap_file_type(cf->wth);
3510   cf->count     = 0;
3511   cf->drops_known = FALSE;
3512   cf->drops     = 0;
3513   cf->snap      = wtap_snapshot_length(cf->wth);
3514   if (cf->snap == 0) {
3515     /* Snapshot length not known. */
3516     cf->has_snap = FALSE;
3517     cf->snap = WTAP_MAX_PACKET_SIZE;
3518   } else
3519     cf->has_snap = TRUE;
3520   nstime_set_zero(&cf->elapsed_time);
3521   nstime_set_unset(&first_ts);
3522   nstime_set_unset(&prev_dis_ts);
3523   nstime_set_unset(&prev_cap_ts);
3524
3525   cf->state = FILE_READ_IN_PROGRESS;
3526
3527   wtap_set_cb_new_ipv4(cf->wth, add_ipv4_name);
3528   wtap_set_cb_new_ipv6(cf->wth, (wtap_new_ipv6_callback_t) add_ipv6_name);
3529
3530   return CF_OK;
3531
3532 fail:
3533   g_snprintf(err_msg, sizeof err_msg,
3534              cf_open_error_message(*err, err_info, FALSE, cf->cd_t), fname);
3535   cmdarg_err("%s", err_msg);
3536   return CF_ERROR;
3537 }
3538
3539 static void
3540 show_capture_file_io_error(const char *fname, int err, gboolean is_close)
3541 {
3542   char *save_file_string;
3543
3544   save_file_string = output_file_description(fname);
3545
3546   switch (err) {
3547
3548   case ENOSPC:
3549     cmdarg_err("Not all the packets could be written to the %s because there is "
3550                "no space left on the file system.",
3551                save_file_string);
3552     break;
3553
3554 #ifdef EDQUOT
3555   case EDQUOT:
3556     cmdarg_err("Not all the packets could be written to the %s because you are "
3557                "too close to, or over your disk quota.",
3558                save_file_string);
3559   break;
3560 #endif
3561
3562   case WTAP_ERR_CANT_CLOSE:
3563     cmdarg_err("The %s couldn't be closed for some unknown reason.",
3564                save_file_string);
3565     break;
3566
3567   case WTAP_ERR_SHORT_WRITE:
3568     cmdarg_err("Not all the packets could be written to the %s.",
3569                save_file_string);
3570     break;
3571
3572   default:
3573     if (is_close) {
3574       cmdarg_err("The %s could not be closed: %s.", save_file_string,
3575                  wtap_strerror(err));
3576     } else {
3577       cmdarg_err("An error occurred while writing to the %s: %s.",
3578                  save_file_string, wtap_strerror(err));
3579     }
3580     break;
3581   }
3582   g_free(save_file_string);
3583 }
3584
3585 static void
3586 show_print_file_io_error(int err)
3587 {