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