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