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