Ringbuffer rework.
[obnox/wireshark/wip.git] / tethereal.c
1 /* tethereal.c
2  *
3  * $Id: tethereal.c,v 1.188 2003/06/22 16:06:03 deniel Exp $
4  *
5  * Ethereal - Network traffic analyzer
6  * By Gerald Combs <gerald@ethereal.com>
7  * Copyright 1998 Gerald Combs
8  *
9  * Text-mode variant, by Gilbert Ramirez <gram@alumni.rice.edu>
10  * and Guy Harris <guy@alum.mit.edu>.
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_LIBPCAP
51 #include <pcap.h>
52 #include <setjmp.h>
53 #endif
54
55 #ifdef HAVE_SYS_STAT_H
56 # include <sys/stat.h>
57 #endif
58
59 #ifdef NEED_SNPRINTF_H
60 # include "snprintf.h"
61 #endif
62
63 #ifdef NEED_STRERROR_H
64 #include "strerror.h"
65 #endif
66
67 #ifdef NEED_GETOPT_H
68 #include "getopt.h"
69 #endif
70
71 #include <glib.h>
72 #include <epan/epan.h>
73 #include <epan/filesystem.h>
74
75 #include "globals.h"
76 #include <epan/timestamp.h>
77 #include <epan/packet.h>
78 #include "file.h"
79 #include "prefs.h"
80 #include "column.h"
81 #include "print.h"
82 #include <epan/resolv.h>
83 #include "util.h"
84 #ifdef HAVE_LIBPCAP
85 #include "pcap-util.h"
86 #endif
87 #include <epan/conversation.h>
88 #include <epan/plugins.h>
89 #include "register.h"
90 #include "conditions.h"
91 #include "capture_stop_conditions.h"
92 #include "ringbuffer.h"
93 #include <epan/epan_dissect.h>
94 #include "tap.h"
95
96 #ifdef HAVE_LIBPCAP
97 #include <wiretap/wtap-capture.h>
98 #include <wiretap/libpcap.h>
99 #endif
100
101 #ifdef _WIN32
102 #include "capture-wpcap.h"
103 #endif
104
105 /*
106  * This is the template for the decode as option; it is shared between the
107  * various functions that output the usage for this parameter.
108  */
109 static const gchar decode_as_arg_template[] = "<layer_type>==<selector>,<decode_as_protocol>";
110 static guint32 firstsec, firstusec;
111 static guint32 prevsec, prevusec;
112 static GString *comp_info_str, *runtime_info_str;
113 static gboolean quiet;
114 static gboolean decode;
115 static gboolean verbose;
116 static gboolean print_hex;
117 static gboolean line_buffered;
118
119 #ifdef HAVE_LIBPCAP
120 typedef struct _loop_data {
121   gboolean       go;           /* TRUE as long as we're supposed to keep capturing */
122   gint           linktype;
123   gboolean       from_pipe;    /* TRUE if we are capturing data from a pipe */
124   pcap_t        *pch;
125   wtap_dumper   *pdh;
126   jmp_buf        stopenv;
127   gboolean       output_to_pipe;
128   int            packet_count;
129 #ifndef _WIN32
130   gboolean       modified;     /* TRUE if data in the pipe uses modified pcap headers */
131   gboolean       byte_swapped; /* TRUE if data in the pipe is byte swapped */
132   unsigned int   bytes_to_read, bytes_read; /* Used by pipe_dispatch */
133   enum {
134          STATE_EXPECT_REC_HDR, STATE_READ_REC_HDR,
135          STATE_EXPECT_DATA,     STATE_READ_DATA
136        } pipe_state;
137
138   enum { PIPOK, PIPEOF, PIPERR, PIPNEXIST } pipe_err;
139 #endif
140 } loop_data;
141
142 static loop_data ld;
143
144 static int capture(int);
145 static void capture_pcap_cb(guchar *, const struct pcap_pkthdr *,
146   const guchar *);
147 static void report_counts(void);
148 #ifdef _WIN32
149 static BOOL WINAPI capture_cleanup(DWORD);
150 #else /* _WIN32 */
151 static void capture_cleanup(int);
152 #ifdef SIGINFO
153 static void report_counts_siginfo(int);
154 #endif /* SIGINFO */
155 #endif /* _WIN32 */
156 #endif /* HAVE_LIBPCAP */
157
158 typedef struct {
159   capture_file *cf;
160   wtap_dumper *pdh;
161 } cb_args_t;
162
163 static int load_cap_file(capture_file *, int);
164 static void wtap_dispatch_cb_write(guchar *, const struct wtap_pkthdr *, long,
165     union wtap_pseudo_header *, const guchar *);
166 static void show_capture_file_io_error(const char *, int, gboolean);
167 static void wtap_dispatch_cb_print(guchar *, const struct wtap_pkthdr *, long,
168     union wtap_pseudo_header *, const guchar *);
169 #ifdef HAVE_LIBPCAP
170 #ifndef _WIN32
171 static void adjust_header(loop_data *, struct pcap_hdr *, struct pcaprec_hdr *);
172 static int pipe_open_live(char *, struct pcap_hdr *, loop_data *, char *, int);
173 static int pipe_dispatch(int, loop_data *, struct pcap_hdr *, \
174                 struct pcaprec_modified_hdr *, guchar *, char *, int);
175 #endif /* _WIN32 */
176 #endif
177
178 capture_file cfile;
179 ts_type timestamp_type = RELATIVE;
180 #ifdef HAVE_LIBPCAP
181 typedef struct {
182         int snaplen;                    /* Maximum captured packet length */
183         int promisc_mode;               /* Capture in promiscuous mode */
184         int autostop_count;             /* Maximum packet count */
185         gboolean has_autostop_duration; /* TRUE if maximum capture duration
186                                            is specified */
187         gint32 autostop_duration;       /* Maximum capture duration */
188         gboolean has_autostop_filesize; /* TRUE if maximum capture file size
189                                            is specified */
190         gint32 autostop_filesize;       /* Maximum capture file size */
191         gboolean ringbuffer_on;         /* TRUE if ring buffer in use */
192         guint32 ringbuffer_num_files;   /* Number of ring buffer files */
193         gboolean has_ring_duration;     /* TRUE if ring duration specified */
194         gint32 ringbuffer_duration;     /* Switch file after n seconds */
195 } capture_options;
196
197 static capture_options capture_opts = {
198         WTAP_MAX_PACKET_SIZE,           /* snapshot length - default is
199                                            infinite, in effect */
200         TRUE,                           /* promiscuous mode is the default */
201         0,                              /* max packet count - default is 0,
202                                            meaning infinite */
203         FALSE,                          /* maximum capture duration not
204                                            specified by default */
205         0,                              /* maximum capture duration */
206         FALSE,                          /* maximum capture file size not
207                                            specified by default */
208         0,                              /* maximum capture file size */
209         FALSE,                          /* ring buffer off by default */
210         RINGBUFFER_MIN_NUM_FILES,       /* default number of ring buffer
211                                            files */
212         FALSE,                          /* Switch ring file after some */
213         0                               /* specified time is off by default */
214 };
215
216 #ifdef SIGINFO
217 static gboolean infodelay;      /* if TRUE, don't print capture info in SIGINFO handler */
218 static gboolean infoprint;      /* if TRUE, print capture info after clearing infodelay */
219 #endif /* SIGINFO */
220 #endif /* HAVE_LIBPCAP */
221
222 static void
223 print_usage(gboolean print_ver)
224 {
225   int i;
226
227   if (print_ver) {
228     fprintf(stderr, "This is GNU t%s %s\n%s\n%s\n", PACKAGE, VERSION,
229         comp_info_str->str, runtime_info_str->str);
230   }
231 #ifdef HAVE_LIBPCAP
232   fprintf(stderr, "\nt%s [ -vh ] [ -DlnpqSVx ] [ -a <capture autostop condition> ] ...\n",
233           PACKAGE);
234   fprintf(stderr, "\t[ -b <number of ring buffer files>[:<duration>] ] [ -c <count> ]\n");
235   fprintf(stderr, "\t[ -d %s ] ...\n", decode_as_arg_template);
236   fprintf(stderr, "\t[ -f <capture filter> ] [ -F <output file type> ] [ -i <interface> ]\n");
237   fprintf(stderr, "\t[ -N <resolving> ] [ -o <preference setting> ] ... [ -r <infile> ]\n");
238   fprintf(stderr, "\t[ -R <read filter> ] [ -s <snaplen> ] [ -t <time stamp format> ]\n");
239   fprintf(stderr, "\t[ -w <savefile> ] [ -Z <statistics string> ]\n");
240 #else
241   fprintf(stderr, "\nt%s [ -vh ] [ -lnVx ]\n", PACKAGE);
242   fprintf(stderr, "\t[ -d %s ] ...\n", decode_as_arg_template);
243   fprintf(stderr, "\t[ -F <output file type> ] [ -N <resolving> ]\n");
244   fprintf(stderr, "\t[ -o <preference setting> ] ... [ -r <infile> ] [ -R <read filter> ]\n");
245   fprintf(stderr, "\t[ -t <time stamp format> ] [ -w <savefile> ] [ -Z <statistics string> ]\n");
246 #endif
247   fprintf(stderr, "Valid file type arguments to the \"-F\" flag:\n");
248   for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
249     if (wtap_dump_can_open(i))
250       fprintf(stderr, "\t%s - %s\n",
251         wtap_file_type_short_string(i), wtap_file_type_string(i));
252   }
253   fprintf(stderr, "\tdefault is libpcap\n");
254 }
255
256 #ifdef HAVE_LIBPCAP
257 static int
258 get_natural_int(const char *string, const char *name)
259 {
260   long number;
261   char *p;
262
263   number = strtol(string, &p, 10);
264   if (p == string || *p != '\0') {
265     fprintf(stderr, "tethereal: The specified %s \"%s\" is not a decimal number\n",
266             name, string);
267     exit(1);
268   }
269   if (number < 0) {
270     fprintf(stderr, "tethereal: The specified %s is a negative number\n",
271             name);
272     exit(1);
273   }
274   if (number > INT_MAX) {
275     fprintf(stderr, "tethereal: The specified %s is too large (greater than %d)\n",
276             name, INT_MAX);
277     exit(1);
278   }
279   return number;
280 }
281
282 static int
283 get_positive_int(const char *string, const char *name)
284 {
285   long number;
286
287   number = get_natural_int(string, name);
288
289   if (number == 0) {
290     fprintf(stderr, "tethereal: The specified %s is zero\n",
291             name);
292     exit(1);
293   }
294
295   return number;
296 }
297
298 /*
299  * Given a string of the form "<autostop criterion>:<value>", as might appear
300  * as an argument to a "-a" option, parse it and set the criterion in
301  * question.  Return an indication of whether it succeeded or failed
302  * in some fashion.
303  */
304 static gboolean
305 set_autostop_criterion(const char *autostoparg)
306 {
307   guchar *p, *colonp;
308
309   colonp = strchr(autostoparg, ':');
310   if (colonp == NULL)
311     return FALSE;
312
313   p = colonp;
314   *p++ = '\0';
315
316   /*
317    * Skip over any white space (there probably won't be any, but
318    * as we allow it in the preferences file, we might as well
319    * allow it here).
320    */
321   while (isspace(*p))
322     p++;
323   if (*p == '\0') {
324     /*
325      * Put the colon back, so if our caller uses, in an
326      * error message, the string they passed us, the message
327      * looks correct.
328      */
329     *colonp = ':';
330     return FALSE;
331   }
332   if (strcmp(autostoparg,"duration") == 0) {
333     capture_opts.has_autostop_duration = TRUE;
334     capture_opts.autostop_duration = get_positive_int(p,"autostop duration");
335   } else if (strcmp(autostoparg,"filesize") == 0) {
336     capture_opts.has_autostop_filesize = TRUE;
337     capture_opts.autostop_filesize = get_positive_int(p,"autostop filesize");
338   } else {
339     return FALSE;
340   }
341   *colonp = ':';        /* put the colon back */
342   return TRUE;
343 }
344
345 /*
346  * Given a string of the form "<ring buffer file>:<duration>", as might appear
347  * as an argument to a "-b" option, parse it and set the arguments in
348  * question.  Return an indication of whether it succeeded or failed
349  * in some fashion.
350  */
351 static gboolean
352 get_ring_arguments(const char *arg)
353 {
354   guchar *p = NULL, *colonp;
355
356   colonp = strchr(arg, ':');
357
358   if (colonp != NULL) {
359     p = colonp;
360     *p++ = '\0';
361   }
362
363   capture_opts.ringbuffer_num_files = 
364     get_natural_int(arg, "number of ring buffer files");
365
366   if (colonp == NULL)
367     return TRUE;
368
369   /*
370    * Skip over any white space (there probably won't be any, but
371    * as we allow it in the preferences file, we might as well
372    * allow it here).
373    */
374   while (isspace(*p))
375     p++;
376   if (*p == '\0') {
377     /*
378      * Put the colon back, so if our caller uses, in an
379      * error message, the string they passed us, the message
380      * looks correct.
381      */
382     *colonp = ':';
383     return FALSE;
384   }
385
386   capture_opts.has_ring_duration = TRUE;
387   capture_opts.ringbuffer_duration = get_positive_int(p,
388                                                       "ring buffer duration");
389
390   *colonp = ':';        /* put the colon back */
391   return TRUE;
392 }
393 #endif
394
395 /* structure to keep track of what tap listeners have been registered.
396  */
397 typedef struct _ethereal_tap_list {
398         struct _ethereal_tap_list *next;
399         char *cmd;
400         void (*func)(char *arg);
401 } ethereal_tap_list;
402 static ethereal_tap_list *tap_list=NULL;
403
404 void
405 register_ethereal_tap(char *cmd, void (*func)(char *arg))
406 {
407         ethereal_tap_list *newtl;
408
409         newtl=malloc(sizeof(ethereal_tap_list));
410         newtl->next=tap_list;
411         tap_list=newtl;
412         newtl->cmd=cmd;
413         newtl->func=func;
414
415 }
416
417 /*
418  * For a dissector table, display, on the standard error, its short name
419  * (which is what's used in the "-d" option) and its descriptive name.
420  */
421 static void
422 display_dissector_table_names(char *table_name, char *ui_name,
423                               gpointer user_data _U_)
424 {
425   fprintf(stderr, "\t%s (%s)\n", table_name, ui_name);
426 }
427
428 /*
429  * For a dissector handle, display, on the standard error, the filter name
430  * (which is what's used in the "-d" option) and the full name for the
431  * protocol for the handle.
432  */
433 static void
434 display_dissector_names(gchar *table _U_, gpointer handle, gpointer data _U_)
435 {
436   int                proto_id;
437
438   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
439
440   fprintf(stderr, "\t%s (%s)\n", proto_get_protocol_filter_name(proto_id),
441           proto_get_protocol_name(proto_id));
442 }
443
444 /*
445  * The protocol_name_search structure is used by find_name_shortname_func()
446  * to pass parameters and store results
447  */
448 struct protocol_name_search{
449   gchar              *searched_name;  /* Protocol name we are looking for */
450   dissector_handle_t  matched_handle; /* Handle for a dissector whose protocol has the specified filter name */
451   guint               nb_match;       /* How many dissectors matched searched_name */
452 };
453 typedef struct protocol_name_search *protocol_name_search_t;
454
455 /*
456  * This function parses all dissectors associated with a table to find the
457  * one whose protocol has the specified filter name.  It is called
458  * as a reference function in a call to dissector_table_foreach_handle.
459  * The name we are looking for, as well as the results, are stored in the
460  * protocol_name_search struct pointed to by user_data.
461  * If called using dissector_table_foreach_handle, we actually parse the
462  * whole list of dissectors only once here.
463  */
464 static void
465 find_name_func(gchar *table _U_, gpointer handle, gpointer user_data) {
466
467   int                         proto_id;
468   const gchar                *protocol_filter_name;
469   protocol_name_search_t      search_info;
470
471   g_assert(handle);
472
473   search_info = (protocol_name_search_t)user_data;
474
475   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
476   protocol_filter_name = proto_get_protocol_filter_name(proto_id);
477   if (strcmp(protocol_filter_name, search_info->searched_name) == 0) {
478     /* Found a match */
479     if (search_info->nb_match == 0) {
480       /* Record this handle only if this is the first match */
481       search_info->matched_handle = (dissector_handle_t)handle; /* Record the handle for this matching dissector */
482     }
483     search_info->nb_match++;
484   }
485 }
486
487 /*
488  * The function below parses the command-line parameters for the decode as
489  * feature (a string pointer by cl_param).
490  * It checks the format of the command-line, searches for a matching table
491  * and dissector.  If a table/dissector match is not found, we display a
492  * summary of the available tables/dissectors (on stderr) and return FALSE.
493  * If everything is fine, we get the "Decode as" preference activated,
494  * then we return TRUE.
495  */
496 static gboolean
497 add_decode_as(const gchar *cl_param) {
498
499   gchar                        *table_name;
500   guint32                       selector;
501   gchar                        *decoded_param;
502   gchar                        *remaining_param;
503   gchar                        *selector_str;
504   gchar                        *dissector_str;
505   dissector_handle_t            dissector_matching;
506   dissector_table_t             table_matching;
507   struct protocol_name_search   user_protocol_name;
508
509 /* The following code will allocate and copy the command-line options in a string pointed by decoded_param */
510
511   g_assert(cl_param);
512   decoded_param = g_malloc( sizeof(gchar) * strlen(cl_param) + 1 ); /* Allocate enough space to have a working copy of the command-line parameter */
513   g_assert(decoded_param);
514   strcpy(decoded_param, cl_param);
515
516
517   /* The lines below will parse this string (modifying it) to extract all
518     necessary information.  Note that decoded_param is still needed since
519     strings are not copied - we just save pointers. */
520
521   table_name = decoded_param; /* Layer type string starts from beginning */
522
523   remaining_param = strchr(table_name, '=');
524   if (remaining_param == NULL) {
525     fprintf(stderr, "tethereal: Parameter \"%s\" doesn't follow the template \"%s\"\n", cl_param, decode_as_arg_template);
526     g_free(decoded_param);
527     return FALSE;
528   }
529
530   *remaining_param = '\0'; /* Terminate the layer type string (table_name) where '=' was detected */
531   
532   if (*(remaining_param + 1) != '=') { /* Check for "==" and not only '=' */
533     fprintf(stderr, "tethereal: Warning: -d requires \"==\" instead of \"=\". Option will be treated as \"%s==%s\"\n", table_name, remaining_param + 1);
534   }
535   else {
536     remaining_param++; /* Move to the second '=' */
537     *remaining_param = '\0'; /* Remove the second '=' */
538   }
539   remaining_param++; /* Position after the layer type string */
540
541   selector_str = remaining_param; /* Next part starts with the selector number */
542
543   /* Remove leading and trailing spaces from the table name */
544   while ( table_name[0] == ' ' )
545     table_name++; 
546   while ( table_name[strlen(table_name) - 1] == ' ' )
547     table_name[strlen(table_name) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
548
549
550   remaining_param = strchr(selector_str, ',');
551   if (remaining_param == NULL) {
552     fprintf(stderr, "tethereal: Parameter \"%s\" doesn't follow the template \"%s\"\n", cl_param, decode_as_arg_template);
553     g_free(decoded_param);
554     return FALSE;
555   }
556
557   *remaining_param = '\0'; /* Terminate the selector number string (selector_str) where ',' was detected */
558   
559   remaining_param++; /* Position after the selector number string */
560
561
562   dissector_str = remaining_param; /* All the rest of the string is the dissector (decode as protocol) name */
563
564 /* The following part looks for the layer type part of the parameter */
565   table_matching = NULL;
566
567 /* Look for the requested table */
568   if ( !(*(table_name)) ) { /* Is the table name empty, if so, don't even search for anything, display a message */
569     fprintf(stderr, "tethereal: No layer type specified\n"); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
570   }
571   else {
572     table_matching = find_dissector_table(table_name);
573     if (!table_matching) {
574       fprintf(stderr, "tethereal: Unknown layer type -- %s\n", table_name); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
575     }
576   }
577
578   if (!table_matching) {
579     fprintf(stderr, "tethereal: Valid layer types are:\n");
580     dissector_all_tables_foreach_table(display_dissector_table_names, NULL);
581
582     g_free(decoded_param); 
583     return FALSE;
584   }
585
586   switch (get_dissector_table_type(table_name)) {
587
588   case FT_UINT8:
589   case FT_UINT16:
590   case FT_UINT24:
591   case FT_UINT32:
592     /* The selector for this table is an unsigned number.  Parse it as such.
593        There's no need to remove leading and trailing spaces from the
594        selector number string, because sscanf will do that for us. */
595     if ( sscanf(selector_str, "%u", &selector) != 1 ) {
596       fprintf(stderr, "tethereal: Invalid selector number \"%s\"\n", selector_str);
597       g_free(decoded_param);
598       return FALSE;
599     }
600     break;
601
602   default:
603     /* There are currently no dissector tables with any types other
604        than the ones listed above, but we might, for example, have
605        string-based dissector tables at some point. */
606     g_assert_not_reached();
607   }
608
609   /* Remove leading and trailing spaces from the dissector name */
610   while ( dissector_str[0] == ' ' )
611     dissector_str++; 
612   while ( dissector_str[strlen(dissector_str) - 1] == ' ' )
613     dissector_str[strlen(dissector_str) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
614
615
616 #ifdef DEBUG
617   fprintf(stderr, "tethereal: Debug info: table=\"%s\", selector=\"%d\", dissector=\"%s\"\n", table_name, selector, dissector_str); // For debug only!
618 #endif
619
620 /* The is the end of the code that parses the command-line options. All information have now been stored in the structure preference. All strings are still pointing to decoded_parm that needs to be kept in memory as long as preference is needed, and decoded_param needs to be deallocated at each exit point of this function */
621
622
623   dissector_matching = NULL;
624
625 /* We now have a pointer to the handle for the requested table inside the variable table_matching */
626   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 */
627     fprintf(stderr, "tethereal: No protocol name specified\n"); /* Note, we don't exit here, but dissector_matching will remain NULL, so we exit below */
628   }
629   else {
630     user_protocol_name.nb_match = 0;
631     user_protocol_name.searched_name = dissector_str;
632     user_protocol_name.matched_handle = NULL;
633     dissector_table_foreach_handle(table_name, find_name_func, &user_protocol_name); /* Go and perform the search for this dissector in the this table's dissectors' names and shortnames */
634
635     if (user_protocol_name.nb_match != 0) {
636       dissector_matching = user_protocol_name.matched_handle;
637       if (user_protocol_name.nb_match > 1) {
638         fprintf(stderr, "tethereal: Warning: Protocol \"%s\" matched %u dissectors, first one will be used\n", dissector_str, user_protocol_name.nb_match);
639       }
640     }
641     else {
642       /* OK, check whether the problem is that there isn't any such
643          protocol, or that there is but it's not specified as a protocol
644          that's valid for that dissector table.
645          Note, we don't exit here, but dissector_matching will remain NULL,
646          so we exit below */
647       if (proto_get_id_by_filter_name(dissector_str) == -1) {
648         /* No such protocol */
649         fprintf(stderr, "tethereal: Unknown protocol -- \"%s\"\n", dissector_str);
650       } else {
651         fprintf(stderr, "tethereal: Protocol \"%s\" isn't valid for layer type \"%s\"\n",
652                 dissector_str, table_name);
653       }
654     }
655   }
656
657   if (!dissector_matching) {
658     fprintf(stderr, "tethereal: Valid protocols for layer type \"%s\" are:\n", table_name);
659     dissector_table_foreach_handle(table_name, display_dissector_names, NULL);
660     g_free(decoded_param); 
661     return FALSE;
662   }
663
664   /* We now have a pointer to the handle for the requested dissector
665      (requested protocol) inside the variable dissector_matching */
666   dissector_change(table_name, selector, dissector_matching);
667   g_free(decoded_param); /* "Decode As" rule has been succesfully added */
668   return TRUE;
669 }
670
671 int
672 main(int argc, char *argv[])
673 {
674   int                  opt, i;
675   extern char         *optarg;
676   gboolean             arg_error = FALSE;
677
678 #ifdef _WIN32
679   WSADATA               wsaData;
680 #endif  /* _WIN32 */
681
682   char                *gpf_path;
683   char                *pf_path;
684   int                  gpf_open_errno, pf_open_errno;
685   int                  err;
686 #ifdef HAVE_LIBPCAP
687   gboolean             capture_filter_specified = FALSE;
688   GList               *if_list, *if_entry;
689   gchar                err_str[PCAP_ERRBUF_SIZE];
690 #else
691   gboolean             capture_option_specified = FALSE;
692 #endif
693   int                  out_file_type = WTAP_FILE_PCAP;
694   gchar               *cf_name = NULL, *rfilter = NULL;
695 #ifdef HAVE_LIBPCAP
696   gchar               *if_text;
697 #endif
698   dfilter_t           *rfcode = NULL;
699   e_prefs             *prefs;
700   char                 badopt;
701   ethereal_tap_list *tli;
702
703   /* Register all dissectors; we must do this before checking for the
704      "-G" flag, as the "-G" flag dumps information registered by the
705      dissectors, and we must do it before we read the preferences, in
706      case any dissectors register preferences. */
707   epan_init(PLUGIN_DIR,register_all_protocols,register_all_protocol_handoffs);
708
709   /* Register all tap listeners; we do this before we parse the arguments,
710      as the "-z" argument can specify a registered tap. */
711   register_all_tap_listeners();
712
713   /* Now register the preferences for any non-dissector modules.
714      We must do that before we read the preferences as well. */
715   prefs_register_modules();
716
717   /* If invoked with the "-G" flag, we dump out information based on
718      the argument to the "-G" flag; if no argument is specified,
719      for backwards compatibility we dump out a glossary of display
720      filter symbols.
721
722      We do this here to mirror what happens in the GTK+ version, although
723      it's not necessary here. */
724   if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
725     if (argc == 2)
726       proto_registrar_dump_fields();
727     else {
728       if (strcmp(argv[2], "fields") == 0)
729         proto_registrar_dump_fields();
730       else if (strcmp(argv[2], "protocols") == 0)
731         proto_registrar_dump_protocols();
732       else {
733         fprintf(stderr, "tethereal: Invalid \"%s\" option for -G flag\n",
734                 argv[2]);
735         exit(1);
736       }
737     }
738     exit(0);
739   }
740
741   /* Set the C-language locale to the native environment. */
742   setlocale(LC_ALL, "");
743
744   prefs = read_prefs(&gpf_open_errno, &gpf_path, &pf_open_errno, &pf_path);
745   if (gpf_path != NULL) {
746     fprintf(stderr, "Can't open global preferences file \"%s\": %s.\n", pf_path,
747         strerror(gpf_open_errno));
748   }
749   if (pf_path != NULL) {
750     fprintf(stderr, "Can't open your preferences file \"%s\": %s.\n", pf_path,
751         strerror(pf_open_errno));
752     g_free(pf_path);
753     pf_path = NULL;
754   }
755
756   /* Set the name resolution code's flags from the preferences. */
757   g_resolv_flags = prefs->name_resolve;
758
759 #ifdef _WIN32
760   /* Load Wpcap, if possible */
761   load_wpcap();
762 #endif
763
764   init_cap_file(&cfile);
765
766   /* Assemble the compile-time version information string */
767   comp_info_str = g_string_new("Compiled ");
768   get_compiled_version_info(comp_info_str);
769
770   /* Assemble the run-time version information string */
771   runtime_info_str = g_string_new("Running ");
772   get_runtime_version_info(runtime_info_str);
773
774   /* Now get our args */
775   while ((opt = getopt(argc, argv, "a:b:c:d:Df:F:hi:lnN:o:pqr:R:s:St:vw:Vxz:")) != -1) {
776     switch (opt) {
777       case 'a':        /* autostop criteria */
778 #ifdef HAVE_LIBPCAP
779         if (set_autostop_criterion(optarg) == FALSE) {
780           fprintf(stderr, "tethereal: Invalid or unknown -a flag \"%s\"\n", optarg);
781           exit(1);
782         }
783 #else
784         capture_option_specified = TRUE;
785         arg_error = TRUE;
786 #endif
787         break;
788       case 'b':        /* Ringbuffer option */
789 #ifdef HAVE_LIBPCAP
790         capture_opts.ringbuffer_on = TRUE;
791         if (get_ring_arguments(optarg) == FALSE) {
792           fprintf(stderr, "tethereal: Invalid or unknown -b arg \"%s\"\n", optarg);
793           exit(1);
794         }
795 #else
796         capture_option_specified = TRUE;
797         arg_error = TRUE;
798 #endif
799         break;
800       case 'c':        /* Capture xxx packets */
801 #ifdef HAVE_LIBPCAP
802         capture_opts.autostop_count =
803             get_positive_int(optarg, "packet count");
804 #else
805         capture_option_specified = TRUE;
806         arg_error = TRUE;
807 #endif
808         break;
809       case 'd':        /* Decode as rule */
810         if (!add_decode_as(optarg))
811           exit(1);
812         break;
813       case 'D':        /* Print a list of capture devices */
814 #ifdef HAVE_LIBPCAP
815         if_list = get_interface_list(&err, err_str);
816         if (if_list == NULL) {
817             switch (err) {
818
819             case CANT_GET_INTERFACE_LIST:
820                 fprintf(stderr, "tethereal: Can't get list of interfaces: %s\n",
821                         err_str);
822                 break;
823
824             case NO_INTERFACES_FOUND:
825                 fprintf(stderr, "tethereal: There are no interfaces on which a capture can be done\n");
826                 break;
827             }
828             exit(2);
829         }
830         for (if_entry = g_list_first(if_list); if_entry != NULL;
831                 if_entry = g_list_next(if_entry))
832           printf("%s\n", (char *)if_entry->data);
833         free_interface_list(if_list);
834         exit(0);
835 #else
836         capture_option_specified = TRUE;
837         arg_error = TRUE;
838 #endif
839         break;
840       case 'f':
841 #ifdef HAVE_LIBPCAP
842         capture_filter_specified = TRUE;
843         if (cfile.cfilter)
844                 g_free(cfile.cfilter);
845         cfile.cfilter = g_strdup(optarg);
846 #else
847         capture_option_specified = TRUE;
848         arg_error = TRUE;
849 #endif
850         break;
851       case 'F':
852         out_file_type = wtap_short_string_to_file_type(optarg);
853         if (out_file_type < 0) {
854           fprintf(stderr, "tethereal: \"%s\" is not a valid capture file type\n",
855                         optarg);
856           exit(1);
857         }
858         break;
859       case 'h':        /* Print help and exit */
860         print_usage(TRUE);
861         exit(0);
862         break;
863       case 'i':        /* Use interface xxx */
864 #ifdef HAVE_LIBPCAP
865         cfile.iface = g_strdup(optarg);
866 #else
867         capture_option_specified = TRUE;
868         arg_error = TRUE;
869 #endif
870         break;
871       case 'l':        /* "Line-buffer" standard output */
872         /* This isn't line-buffering, strictly speaking, it's just
873            flushing the standard output after the information for
874            each packet is printed; however, that should be good
875            enough for all the purposes to which "-l" is put.
876
877            See the comment in "wtap_dispatch_cb_print()" for an
878            explanation of why we do that, and why we don't just
879            use "setvbuf()" to make the standard output line-buffered
880            (short version: in Windows, "line-buffered" is the same
881            as "fully-buffered", and the output buffer is only flushed
882            when it fills up). */
883         line_buffered = TRUE;
884         break;
885       case 'n':        /* No name resolution */
886         g_resolv_flags = RESOLV_NONE;
887         break;
888       case 'N':        /* Select what types of addresses/port #s to resolve */
889         if (g_resolv_flags == RESOLV_ALL)
890           g_resolv_flags = RESOLV_NONE;
891         badopt = string_to_name_resolve(optarg, &g_resolv_flags);
892         if (badopt != '\0') {
893           fprintf(stderr, "tethereal: -N specifies unknown resolving option '%c'; valid options are 'm', 'n', and 't'\n",
894                         badopt);
895           exit(1);
896         }
897         break;
898       case 'o':        /* Override preference from command line */
899         switch (prefs_set_pref(optarg)) {
900
901         case PREFS_SET_SYNTAX_ERR:
902           fprintf(stderr, "tethereal: Invalid -o flag \"%s\"\n", optarg);
903           exit(1);
904           break;
905
906         case PREFS_SET_NO_SUCH_PREF:
907         case PREFS_SET_OBSOLETE:
908           fprintf(stderr, "tethereal: -o flag \"%s\" specifies unknown preference\n",
909                         optarg);
910           exit(1);
911           break;
912         }
913         break;
914       case 'p':        /* Don't capture in promiscuous mode */
915 #ifdef HAVE_LIBPCAP
916         capture_opts.promisc_mode = FALSE;
917 #else
918         capture_option_specified = TRUE;
919         arg_error = TRUE;
920 #endif
921         break;
922       case 'q':        /* Quiet */
923         quiet = TRUE;
924         break;
925       case 'r':        /* Read capture file xxx */
926         cf_name = g_strdup(optarg);
927         break;
928       case 'R':        /* Read file filter */
929         rfilter = optarg;
930         break;
931       case 's':        /* Set the snapshot (capture) length */
932 #ifdef HAVE_LIBPCAP
933         capture_opts.snaplen = get_positive_int(optarg, "snapshot length");
934 #else
935         capture_option_specified = TRUE;
936         arg_error = TRUE;
937 #endif
938         break;
939       case 'S':        /* show packets in real time */
940         decode = TRUE;
941         break;
942       case 't':        /* Time stamp type */
943         if (strcmp(optarg, "r") == 0)
944           timestamp_type = RELATIVE;
945         else if (strcmp(optarg, "a") == 0)
946           timestamp_type = ABSOLUTE;
947         else if (strcmp(optarg, "ad") == 0)
948           timestamp_type = ABSOLUTE_WITH_DATE;
949         else if (strcmp(optarg, "d") == 0)
950           timestamp_type = DELTA;
951         else {
952           fprintf(stderr, "tethereal: Invalid time stamp type \"%s\"\n",
953             optarg);
954           fprintf(stderr, "It must be \"r\" for relative, \"a\" for absolute,\n");
955           fprintf(stderr, "\"ad\" for absolute with date, or \"d\" for delta.\n");
956           exit(1);
957         }
958         break;
959       case 'v':        /* Show version and exit */
960         printf("t%s %s\n%s\n%s\n", PACKAGE, VERSION, comp_info_str->str,
961                runtime_info_str->str);
962         exit(0);
963         break;
964       case 'w':        /* Write to capture file xxx */
965         cfile.save_file = g_strdup(optarg);
966         break;
967       case 'V':        /* Verbose */
968         verbose = TRUE;
969         break;
970       case 'x':        /* Print packet data in hex (and ASCII) */
971         print_hex = TRUE;
972         break;
973       case 'z':
974         for(tli=tap_list;tli;tli=tli->next){
975           if(!strncmp(tli->cmd,optarg,strlen(tli->cmd))){
976             (*tli->func)(optarg);
977             break;
978           }
979         }
980         if(!tli){
981           fprintf(stderr,"tethereal: invalid -z argument.\n");
982           fprintf(stderr,"  -z argument must be one of :\n");
983           for(tli=tap_list;tli;tli=tli->next){
984             fprintf(stderr,"     %s\n",tli->cmd);
985           }
986           exit(1);
987         }
988         break;
989       default:
990       case '?':        /* Bad flag - print usage message */
991         arg_error = TRUE;
992         break;
993     }
994   }
995
996   /* If no capture filter or read filter has been specified, and there are
997      still command-line arguments, treat them as the tokens of a capture
998      filter (if no "-r" flag was specified) or a read filter (if a "-r"
999      flag was specified. */
1000   if (optind < argc) {
1001     if (cf_name != NULL) {
1002       if (rfilter != NULL) {
1003         fprintf(stderr,
1004 "tethereal: Read filters were specified both with \"-R\" and with additional command-line arguments\n");
1005         exit(2);
1006       }
1007       rfilter = get_args_as_string(argc, argv, optind);
1008     } else {
1009 #ifdef HAVE_LIBPCAP
1010       if (capture_filter_specified) {
1011         fprintf(stderr,
1012 "tethereal: Capture filters were specified both with \"-f\" and with additional command-line arguments\n");
1013         exit(2);
1014       }
1015       cfile.cfilter = get_args_as_string(argc, argv, optind);
1016 #else
1017       capture_option_specified = TRUE;
1018 #endif
1019     }
1020   }
1021
1022   /* See if we're writing a capture file and the file is a pipe */
1023 #ifdef HAVE_LIBPCAP
1024   ld.output_to_pipe = FALSE;
1025 #endif
1026   if (cfile.save_file != NULL) {
1027     if (strcmp(cfile.save_file, "-") == 0) {
1028       /* stdout */
1029       g_free(cfile.save_file);
1030       cfile.save_file = g_strdup("");
1031 #ifdef HAVE_LIBPCAP
1032       ld.output_to_pipe = TRUE;
1033 #endif
1034     }
1035 #ifdef HAVE_LIBPCAP
1036     else {
1037       err = test_for_fifo(cfile.save_file);
1038       switch (err) {
1039
1040       case ENOENT:      /* it doesn't exist, so we'll be creating it,
1041                            and it won't be a FIFO */
1042       case 0:           /* found it, but it's not a FIFO */
1043         break;
1044
1045       case ESPIPE:      /* it is a FIFO */
1046         ld.output_to_pipe = TRUE;
1047         break;
1048
1049       default:          /* couldn't stat it */
1050         fprintf(stderr,
1051                 "tethereal: Error testing whether capture file is a pipe: %s\n",
1052                 strerror(errno));
1053         exit(2);
1054       }
1055     }
1056 #endif
1057   }
1058
1059 #ifdef HAVE_LIBPCAP
1060   /* If they didn't specify a "-w" flag, but specified a maximum capture
1061      file size, tell them that this doesn't work, and exit. */
1062   if (capture_opts.has_autostop_filesize && cfile.save_file == NULL) {
1063     fprintf(stderr, "tethereal: Maximum capture file size specified, but "
1064       "capture isn't being saved to a file.\n");
1065     exit(2);
1066   }
1067
1068   if (capture_opts.ringbuffer_on) {
1069     /* Ring buffer works only under certain conditions:
1070        a) ring buffer does not work if you're not saving the capture to
1071           a file;
1072        b) ring buffer only works if you're saving in libpcap format;
1073        c) it makes no sense to enable the ring buffer if the maximum
1074           file size is set to "infinite";
1075        d) file must not be a pipe. */
1076     if (cfile.save_file == NULL) {
1077       fprintf(stderr, "tethereal: Ring buffer requested, but "
1078         "capture isn't being saved to a file.\n");
1079       exit(2);
1080     }
1081     if (out_file_type != WTAP_FILE_PCAP) {
1082       fprintf(stderr, "tethereal: Ring buffer requested, but "
1083         "capture isn't being saved in libpcap format.\n");
1084       exit(2);
1085     }
1086     if (!capture_opts.has_autostop_filesize) {
1087       fprintf(stderr, "tethereal: Ring buffer requested, but "
1088         "no maximum capture file size was specified.\n");
1089       exit(2);
1090     }
1091     if (ld.output_to_pipe) {
1092       fprintf(stderr, "tethereal: Ring buffer requested, but "
1093         "capture file is a pipe.\n");
1094       exit(2);
1095     }
1096   }
1097 #endif
1098
1099 #ifdef _WIN32
1100   /* Start windows sockets */
1101   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
1102 #endif  /* _WIN32 */
1103
1104   /* Notify all registered modules that have had any of their preferences
1105      changed either from one of the preferences file or from the command
1106      line that their preferences have changed. */
1107   prefs_apply_all();
1108
1109 #ifndef HAVE_LIBPCAP
1110   if (capture_option_specified)
1111     fprintf(stderr, "This version of Tethereal was not built with support for capturing packets.\n");
1112 #endif
1113   if (arg_error) {
1114     print_usage(FALSE);
1115     exit(1);
1116   }
1117
1118   /* Build the column format array */
1119   col_setup(&cfile.cinfo, prefs->num_cols);
1120   for (i = 0; i < cfile.cinfo.num_cols; i++) {
1121     cfile.cinfo.col_fmt[i] = get_column_format(i);
1122     cfile.cinfo.col_title[i] = g_strdup(get_column_title(i));
1123     cfile.cinfo.fmt_matx[i] = (gboolean *) g_malloc0(sizeof(gboolean) *
1124       NUM_COL_FMTS);
1125     get_column_format_matches(cfile.cinfo.fmt_matx[i], cfile.cinfo.col_fmt[i]);
1126     cfile.cinfo.col_data[i] = NULL;
1127     if (cfile.cinfo.col_fmt[i] == COL_INFO)
1128       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_INFO_LEN);
1129     else
1130       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
1131     cfile.cinfo.col_fence[i] = 0;
1132     cfile.cinfo.col_expr[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
1133     cfile.cinfo.col_expr_val[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
1134   }
1135
1136 #ifdef HAVE_LIBPCAP
1137   if (capture_opts.snaplen < 1)
1138     capture_opts.snaplen = WTAP_MAX_PACKET_SIZE;
1139   else if (capture_opts.snaplen < MIN_PACKET_SIZE)
1140     capture_opts.snaplen = MIN_PACKET_SIZE;
1141
1142   /* Check the value range of the ringbuffer_num_files parameter */
1143   if (capture_opts.ringbuffer_num_files < RINGBUFFER_MIN_NUM_FILES)
1144     capture_opts.ringbuffer_num_files = RINGBUFFER_MIN_NUM_FILES;
1145   else if (capture_opts.ringbuffer_num_files > RINGBUFFER_MAX_NUM_FILES)
1146     capture_opts.ringbuffer_num_files = RINGBUFFER_MAX_NUM_FILES;
1147 #endif
1148
1149   if (rfilter != NULL) {
1150     if (!dfilter_compile(rfilter, &rfcode)) {
1151       fprintf(stderr, "tethereal: %s\n", dfilter_error_msg);
1152       epan_cleanup();
1153       exit(2);
1154     }
1155   }
1156   cfile.rfcode = rfcode;
1157   if (cf_name) {
1158     err = open_cap_file(cf_name, FALSE, &cfile);
1159     if (err != 0) {
1160       epan_cleanup();
1161       exit(2);
1162     }
1163     err = load_cap_file(&cfile, out_file_type);
1164     if (err != 0) {
1165       epan_cleanup();
1166       exit(2);
1167     }
1168     cf_name[0] = '\0';
1169   } else {
1170     /* No capture file specified, so we're supposed to do a live capture;
1171        do we have support for live captures? */
1172 #ifdef HAVE_LIBPCAP
1173
1174 #ifdef _WIN32
1175     if (!has_wpcap) {
1176         fprintf(stderr, "tethereal: Could not load wpcap.dll.\n");
1177         exit(2);
1178     }
1179 #endif
1180
1181     /* Yes; did the user specify an interface to use? */
1182     if (cfile.iface == NULL) {
1183         /* No - is a default specified in the preferences file? */
1184         if (prefs->capture_device != NULL) {
1185             /* Yes - use it. */
1186             if_text = strrchr(prefs->capture_device, ' ');
1187             if (if_text == NULL) {
1188                 cfile.iface = g_strdup(prefs->capture_device);
1189             } else {
1190                 cfile.iface = g_strdup(if_text + 1); /* Skip over space */
1191             }
1192         } else {
1193             /* No - pick the first one from the list of interfaces. */
1194             if_list = get_interface_list(&err, err_str);
1195             if (if_list == NULL) {
1196                 switch (err) {
1197
1198                 case CANT_GET_INTERFACE_LIST:
1199                     fprintf(stderr, "tethereal: Can't get list of interfaces: %s\n",
1200                             err_str);
1201                     break;
1202
1203                 case NO_INTERFACES_FOUND:
1204                     fprintf(stderr, "tethereal: There are no interfaces on which a capture can be done\n");
1205                     break;
1206                 }
1207                 exit(2);
1208             }
1209             if_text = strrchr(if_list->data, ' ');      /* first interface */
1210             if (if_text == NULL) {
1211                 cfile.iface = g_strdup(if_list->data);
1212             } else {
1213                 cfile.iface = g_strdup(if_text + 1); /* Skip over space */
1214             }
1215             free_interface_list(if_list);
1216         }
1217     }
1218     capture(out_file_type);
1219
1220     if (capture_opts.ringbuffer_on) {
1221       ringbuf_free();
1222     }
1223 #else
1224     /* No - complain. */
1225     fprintf(stderr, "This version of Tethereal was not built with support for capturing packets.\n");
1226     exit(2);
1227 #endif
1228   }
1229
1230   draw_tap_listeners(TRUE);
1231   epan_cleanup();
1232
1233   return 0;
1234 }
1235
1236 #ifdef HAVE_LIBPCAP
1237 /* Do the low-level work of a capture.
1238    Returns TRUE if it succeeds, FALSE otherwise. */
1239 static int
1240 capture(int out_file_type)
1241 {
1242   int         pcap_encap;
1243   int         file_snaplen;
1244   gchar       open_err_str[PCAP_ERRBUF_SIZE];
1245   gchar       lookup_net_err_str[PCAP_ERRBUF_SIZE];
1246   bpf_u_int32 netnum, netmask;
1247   struct bpf_program fcode;
1248   void        (*oldhandler)(int);
1249   int         err = 0;
1250   int         volatile volatile_err = 0;
1251   int         volatile inpkts = 0;
1252   int         pcap_cnt;
1253   char        errmsg[1024+1];
1254   condition  *volatile cnd_stop_capturesize = NULL;
1255   condition  *volatile cnd_stop_timeout = NULL;
1256   condition  *volatile cnd_ring_timeout = NULL;
1257 #ifndef _WIN32
1258   static const char ppamsg[] = "can't find PPA for ";
1259   char       *libpcap_warn;
1260   volatile int pipe_fd = -1;
1261   struct pcap_hdr hdr;
1262   struct pcaprec_modified_hdr rechdr;
1263   guchar pcap_data[WTAP_MAX_PACKET_SIZE];
1264 #endif
1265   struct pcap_stat stats;
1266   gboolean    write_err;
1267   gboolean    dump_ok;
1268
1269   /* Initialize all data structures used for dissection. */
1270   init_dissection();
1271
1272   ld.linktype       = WTAP_ENCAP_UNKNOWN;
1273   ld.pdh            = NULL;
1274
1275   /* Open the network interface to capture from it.
1276      Some versions of libpcap may put warnings into the error buffer
1277      if they succeed; to tell if that's happened, we have to clear
1278      the error buffer, and check if it's still a null string.  */
1279   open_err_str[0] = '\0';
1280   ld.pch = pcap_open_live(cfile.iface, capture_opts.snaplen,
1281                           capture_opts.promisc_mode, 1000, open_err_str);
1282
1283   if (ld.pch == NULL) {
1284     /* We couldn't open "cfile.iface" as a network device. */
1285 #ifdef _WIN32
1286     /* On Windows, we don't support capturing on pipes, so we give up. */
1287
1288     /* On Win32 OSes, the capture devices are probably available to all
1289        users; don't warn about permissions problems.
1290
1291        Do, however, warn that WAN devices aren't supported. */
1292     snprintf(errmsg, sizeof errmsg,
1293         "The capture session could not be initiated (%s).\n"
1294         "Please check that you have the proper interface specified.\n"
1295         "\n"
1296         "Note that the driver Tethereal uses for packet capture on Windows doesn't\n"
1297         "support capturing on PPP/WAN interfaces in Windows NT/2000/XP/.NET Server.\n",
1298         open_err_str);
1299     goto error;
1300 #else
1301     /* try to open cfile.iface as a pipe */
1302     pipe_fd = pipe_open_live(cfile.iface, &hdr, &ld, errmsg, sizeof errmsg);
1303
1304     if (pipe_fd == -1) {
1305
1306       if (ld.pipe_err == PIPNEXIST) {
1307         /* Pipe doesn't exist, so output message for interface */
1308
1309         /* If we got a "can't find PPA for XXX" message, warn the user (who
1310            is running Tethereal on HP-UX) that they don't have a version
1311            of libpcap that properly handles HP-UX (libpcap 0.6.x and later
1312            versions, which properly handle HP-UX, say "can't find /dev/dlpi
1313            PPA for XXX" rather than "can't find PPA for XXX"). */
1314         if (strncmp(open_err_str, ppamsg, sizeof ppamsg - 1) == 0)
1315           libpcap_warn =
1316             "\n\n"
1317             "You are running Tethereal with a version of the libpcap library\n"
1318             "that doesn't handle HP-UX network devices well; this means that\n"
1319             "Tethereal may not be able to capture packets.\n"
1320             "\n"
1321             "To fix this, you should install libpcap 0.6.2, or a later version\n"
1322             "of libpcap, rather than libpcap 0.4 or 0.5.x.  It is available in\n"
1323             "packaged binary form from the Software Porting And Archive Centre\n"
1324             "for HP-UX; the Centre is at http://hpux.connect.org.uk/ - the page\n"
1325             "at the URL lists a number of mirror sites.";
1326         else
1327           libpcap_warn = "";
1328         snprintf(errmsg, sizeof errmsg,
1329           "The capture session could not be initiated (%s).\n"
1330           "Please check to make sure you have sufficient permissions, and that\n"
1331           "you have the proper interface or pipe specified.%s", open_err_str,
1332           libpcap_warn);
1333       }
1334       /*
1335        * Else pipe (or file) does exist and pipe_open_live() has
1336        * filled in errmsg
1337        */
1338       goto error;
1339     } else
1340       /* pipe_open_live() succeeded; don't want
1341          error message from pcap_open_live() */
1342       open_err_str[0] = '\0';
1343 #endif
1344   }
1345
1346   if (cfile.cfilter && !ld.from_pipe) {
1347     /* A capture filter was specified; set it up. */
1348     if (pcap_lookupnet(cfile.iface, &netnum, &netmask, lookup_net_err_str) < 0) {
1349       /*
1350        * Well, we can't get the netmask for this interface; it's used
1351        * only for filters that check for broadcast IP addresses, so
1352        * we just warn the user, and punt and use 0.
1353        */
1354       fprintf(stderr,
1355         "Warning:  Couldn't obtain netmask info (%s).\n", lookup_net_err_str);
1356       netmask = 0;
1357     }
1358     if (pcap_compile(ld.pch, &fcode, cfile.cfilter, 1, netmask) < 0) {
1359       snprintf(errmsg, sizeof errmsg, "Unable to parse filter string (%s).",
1360         pcap_geterr(ld.pch));
1361       goto error;
1362     }
1363     if (pcap_setfilter(ld.pch, &fcode) < 0) {
1364       snprintf(errmsg, sizeof errmsg, "Can't install filter (%s).",
1365         pcap_geterr(ld.pch));
1366       goto error;
1367     }
1368   }
1369
1370   /* Set up to write to the capture file. */
1371 #ifndef _WIN32
1372   if (ld.from_pipe) {
1373     pcap_encap = hdr.network;
1374     file_snaplen = hdr.snaplen;
1375   } else
1376 #endif
1377   {
1378     pcap_encap = get_pcap_linktype(ld.pch, cfile.iface);
1379     file_snaplen = pcap_snapshot(ld.pch);
1380   }
1381   ld.linktype = wtap_pcap_encap_to_wtap_encap(pcap_encap);
1382   if (cfile.save_file != NULL) {
1383     /* Set up to write to the capture file. */
1384     if (ld.linktype == WTAP_ENCAP_UNKNOWN) {
1385       strcpy(errmsg, "The network you're capturing from is of a type"
1386                " that Tethereal doesn't support.");
1387       goto error;
1388     }
1389     if (capture_opts.ringbuffer_on) {
1390       cfile.save_file_fd = ringbuf_init(cfile.save_file,
1391         capture_opts.ringbuffer_num_files);
1392       if (cfile.save_file_fd != -1) {
1393         ld.pdh = ringbuf_init_wtap_dump_fdopen(out_file_type, ld.linktype,
1394           pcap_snapshot(ld.pch), &err);
1395       } else {
1396         err = errno;    /* "ringbuf_init()" failed */
1397         ld.pdh = NULL;
1398       }
1399     } else {
1400       ld.pdh = wtap_dump_open(cfile.save_file, out_file_type,
1401                  ld.linktype, pcap_snapshot(ld.pch), &err);
1402     }
1403
1404     if (ld.pdh == NULL) {
1405       snprintf(errmsg, sizeof errmsg,
1406                file_open_error_message(err, TRUE, out_file_type),
1407                *cfile.save_file == '\0' ? "stdout" : cfile.save_file);
1408       goto error;
1409     }
1410   }
1411
1412   /* Does "open_err_str" contain a non-empty string?  If so, "pcap_open_live()"
1413      returned a warning; print it, but keep capturing. */
1414   if (open_err_str[0] != '\0')
1415     fprintf(stderr, "tethereal: WARNING: %s.\n", open_err_str);
1416
1417 #ifdef _WIN32
1418   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
1419   SetConsoleCtrlHandler(capture_cleanup, TRUE);
1420 #else /* _WIN32 */
1421   /* Catch SIGINT and SIGTERM and, if we get either of them, clean up
1422      and exit.
1423      XXX - deal with signal semantics on various UNIX platforms.  Or just
1424      use "sigaction()" and be done with it? */
1425   signal(SIGTERM, capture_cleanup);
1426   signal(SIGINT, capture_cleanup);
1427   if ((oldhandler = signal(SIGHUP, capture_cleanup)) != SIG_DFL)
1428     signal(SIGHUP, oldhandler);
1429
1430 #ifdef SIGINFO
1431   /* Catch SIGINFO and, if we get it and we're capturing to a file in
1432      quiet mode, report the number of packets we've captured. */
1433   signal(SIGINFO, report_counts_siginfo);
1434 #endif /* SIGINFO */
1435 #endif /* _WIN32 */
1436
1437   /* Let the user know what interface was chosen. */
1438   fprintf(stderr, "Capturing on %s\n", cfile.iface);
1439
1440   /* initialize capture stop conditions */
1441   init_capture_stop_conditions();
1442   /* create stop conditions */
1443   if (capture_opts.has_autostop_filesize)
1444     cnd_stop_capturesize = cnd_new((const char*)CND_CLASS_CAPTURESIZE,
1445                                    (long)capture_opts.autostop_filesize * 1000);
1446   if (capture_opts.has_autostop_duration)
1447     cnd_stop_timeout = cnd_new((const char*)CND_CLASS_TIMEOUT,
1448                                (gint32)capture_opts.autostop_duration);
1449
1450   if (capture_opts.ringbuffer_on && capture_opts.has_ring_duration)
1451     cnd_ring_timeout = cnd_new(CND_CLASS_TIMEOUT, 
1452                                capture_opts.ringbuffer_duration);
1453
1454   if (!setjmp(ld.stopenv)) {
1455     ld.go = TRUE;
1456     ld.packet_count = 0;
1457   } else
1458     ld.go = FALSE;
1459   while (ld.go) {
1460     /* We need to be careful with automatic variables defined in the
1461        outer scope which are changed inside the loop.  Most compilers
1462        don't try to roll them back to their original values after the
1463        longjmp which causes the loop to finish, but all that the
1464        standards say is that their values are indeterminate.  If we
1465        don't want them to be rolled back, we should define them with the
1466        volatile attribute (paraphrasing W. Richard Stevens, Advanced
1467        Programming in the UNIX Environment, p. 178).
1468
1469        The "err" variable causes a particular problem.  If we give it
1470        the volatile attribute, then when we pass a reference to it (as
1471        in "&err") to a function, GCC warns: "passing arg <n> of
1472        <function> discards qualifiers from pointer target type".
1473        Therefore within the loop and just beyond we don't use "err".
1474        Within the loop we define "loop_err", and assign its value to
1475        "volatile_err", which is in the outer scope and is checked when
1476        the loop finishes.
1477
1478        We also define "packet_count_prev" here to keep things tidy,
1479        since it's used only inside the loop.  If it were defined in the
1480        outer scope, GCC would give a warning (unnecessary in this case)
1481        that it might be clobbered, and we'd need to give it the volatile
1482        attribute to suppress the warning. */
1483
1484     int loop_err = 0;
1485     int packet_count_prev = 0;
1486
1487     if (cnd_stop_capturesize == NULL && cnd_stop_timeout == NULL) {
1488       /* We're not stopping at a particular capture file size, and we're
1489          not stopping after some particular amount of time has expired,
1490          so either we have no stop condition or the only stop condition
1491          is a maximum packet count.
1492
1493          If there's no maximum packet count, pass it -1, meaning "until
1494          you run out of packets in the bufferful you read".  Otherwise,
1495          pass it the number of packets we have left to capture.
1496
1497          We don't call "pcap_loop()" as, if we're saving to a file that's
1498          a FIFO, we want to flush the FIFO after we're done processing
1499          this libpcap bufferful of packets, so that the program
1500          reading the FIFO sees the packets immediately and doesn't get
1501          any partial packet, forcing it to block in the middle of reading
1502          that packet. */
1503       if (capture_opts.autostop_count == 0)
1504         pcap_cnt = -1;
1505       else {
1506         if (ld.packet_count >= capture_opts.autostop_count) {
1507           /* XXX do we need this test here? */
1508           /* It appears there's nothing more to capture. */
1509           break;
1510         }
1511         pcap_cnt = capture_opts.autostop_count - ld.packet_count;
1512       }
1513     } else {
1514       /* We need to check the capture file size or the timeout after
1515          each packet. */
1516       pcap_cnt = 1;
1517     }
1518 #ifndef _WIN32
1519     if (ld.from_pipe) {
1520       inpkts = pipe_dispatch(pipe_fd, &ld, &hdr, &rechdr, pcap_data,
1521         errmsg, sizeof errmsg);
1522     } else
1523 #endif
1524       inpkts = pcap_dispatch(ld.pch, pcap_cnt, capture_pcap_cb, (guchar *) &ld);
1525     if (inpkts < 0) {
1526       /* Error from "pcap_dispatch()", or error or "no more packets" from
1527          "pipe_dispatch(). */
1528       ld.go = FALSE;
1529     } else if (cnd_stop_timeout != NULL && cnd_eval(cnd_stop_timeout)) {
1530       /* The specified capture time has elapsed; stop the capture. */
1531       ld.go = FALSE;
1532     } else if (cnd_ring_timeout != NULL && cnd_eval(cnd_ring_timeout)) {
1533       /* time elasped for this ring file, swith to the next */
1534       if (ringbuf_switch_file(&cfile, &ld.pdh, &loop_err)) {
1535         /* File switch succeeded: reset the condition */
1536         cnd_reset(cnd_ring_timeout);
1537       } else {
1538         /* File switch failed: stop here */
1539         ld.go = FALSE;
1540       }
1541     } else if (inpkts > 0) {
1542       if (capture_opts.autostop_count != 0 &&
1543                  ld.packet_count >= capture_opts.autostop_count) {
1544         /* The specified number of packets have been captured and have
1545            passed both any capture filter in effect and any read filter
1546            in effect. */
1547         ld.go = FALSE;
1548       } else if (cnd_stop_capturesize != NULL &&
1549                     cnd_eval(cnd_stop_capturesize,
1550                               (guint32)wtap_get_bytes_dumped(ld.pdh))) {
1551         /* We're saving the capture to a file, and the capture file reached
1552            its maximum size. */
1553         if (capture_opts.ringbuffer_on) {
1554           /* Switch to the next ringbuffer file */
1555           if (ringbuf_switch_file(&cfile, &ld.pdh, &loop_err)) {
1556             /* File switch succeeded: reset the condition */
1557             cnd_reset(cnd_stop_capturesize);
1558             if (cnd_ring_timeout) {
1559               cnd_reset(cnd_ring_timeout);
1560             }
1561           } else {
1562             /* File switch failed: stop here */
1563             volatile_err = loop_err;
1564             ld.go = FALSE;
1565           }
1566         } else {
1567           /* No ringbuffer - just stop. */
1568           ld.go = FALSE;
1569         }
1570       }
1571       if (ld.output_to_pipe) {
1572         if (ld.packet_count > packet_count_prev) {
1573           if (fflush(wtap_dump_file(ld.pdh))) {
1574             volatile_err = errno;
1575             ld.go = FALSE;
1576           }
1577           packet_count_prev = ld.packet_count;
1578         }
1579       }
1580     } /* inpkts > 0 */
1581   } /* while (ld.go) */
1582
1583   /* delete stop conditions */
1584   if (cnd_stop_capturesize != NULL)
1585     cnd_delete(cnd_stop_capturesize);
1586   if (cnd_stop_timeout != NULL)
1587     cnd_delete(cnd_stop_timeout);
1588   if (cnd_ring_timeout != NULL)
1589     cnd_delete(cnd_ring_timeout);
1590
1591   if ((cfile.save_file != NULL) && !quiet) {
1592     /* We're saving to a file, which means we're printing packet counts
1593        to stderr if we are not running silent and deep.
1594        Send a newline so that we move to the line after the packet count. */
1595     fprintf(stderr, "\n");
1596   }
1597
1598   /* If we got an error while capturing, report it. */
1599   if (inpkts < 0) {
1600 #ifndef _WIN32
1601     if (ld.from_pipe) {
1602       if (ld.pipe_err == PIPERR) {
1603         fprintf(stderr, "tethereal: Error while capturing packets: %s\n",
1604           errmsg);
1605       }
1606     } else
1607 #endif
1608     {
1609       fprintf(stderr, "tethereal: Error while capturing packets: %s\n",
1610           pcap_geterr(ld.pch));
1611     }
1612   }
1613
1614   if (volatile_err == 0)
1615     write_err = FALSE;
1616   else {
1617     show_capture_file_io_error(cfile.save_file, volatile_err, FALSE);
1618     write_err = TRUE;
1619   }
1620
1621   if (cfile.save_file != NULL) {
1622     /* We're saving to a file or files; close all files. */
1623     if (capture_opts.ringbuffer_on) {
1624       dump_ok = ringbuf_wtap_dump_close(&cfile, &err);
1625     } else {
1626       dump_ok = wtap_dump_close(ld.pdh, &err);
1627     }
1628     /* If we've displayed a message about a write error, there's no point
1629        in displaying another message about an error on close. */
1630     if (!dump_ok && !write_err)
1631       show_capture_file_io_error(cfile.save_file, err, TRUE);
1632   }
1633
1634 #ifndef _WIN32
1635   if (ld.from_pipe && pipe_fd >= 0)
1636     close(pipe_fd);
1637   else
1638 #endif
1639   {
1640     /* Get the capture statistics, and, if any packets were dropped, report
1641        that. */
1642     if (pcap_stats(ld.pch, &stats) >= 0) {
1643       if (stats.ps_drop != 0) {
1644         fprintf(stderr, "%u packets dropped\n", stats.ps_drop);
1645       }
1646     } else {
1647       fprintf(stderr, "tethereal: Can't get packet-drop statistics: %s\n",
1648           pcap_geterr(ld.pch));
1649     }
1650     pcap_close(ld.pch);
1651   }
1652
1653   /* Report the number of captured packets if not reported during capture
1654      and we are saving to a file. */
1655   report_counts();
1656
1657   return TRUE;
1658
1659 error:
1660   if (capture_opts.ringbuffer_on) {
1661     ringbuf_error_cleanup();
1662   }
1663   g_free(cfile.save_file);
1664   cfile.save_file = NULL;
1665   fprintf(stderr, "tethereal: %s\n", errmsg);
1666 #ifndef _WIN32
1667   if (ld.from_pipe) {
1668     if (pipe_fd >= 0)
1669       close(pipe_fd);
1670   } else
1671 #endif
1672   {
1673   if (ld.pch != NULL)
1674     pcap_close(ld.pch);
1675   }
1676
1677   return FALSE;
1678 }
1679
1680 static void
1681 capture_pcap_cb(guchar *user, const struct pcap_pkthdr *phdr,
1682   const guchar *pd)
1683 {
1684   struct wtap_pkthdr whdr;
1685   union wtap_pseudo_header pseudo_header;
1686   loop_data *ld = (loop_data *) user;
1687   cb_args_t args;
1688   int err;
1689
1690   /* Convert from libpcap to Wiretap format.
1691      If that fails, ignore the packet (wtap_process_pcap_packet has
1692      written an error message). */
1693   pd = wtap_process_pcap_packet(ld->linktype, phdr, pd, &pseudo_header,
1694                                 &whdr, &err);
1695   if (pd == NULL) {
1696     return;
1697   }
1698
1699   args.cf = &cfile;
1700   args.pdh = ld->pdh;
1701   if (ld->pdh) {
1702     wtap_dispatch_cb_write((guchar *)&args, &whdr, 0, &pseudo_header, pd);
1703     /* Report packet capture count if not quiet */
1704     if (!quiet) {
1705       if (!decode) {
1706          if (ld->packet_count != 0) {
1707            fprintf(stderr, "\r%u ", ld->packet_count);
1708            /* stderr could be line buffered */
1709            fflush(stderr);
1710          }
1711       } else {
1712            wtap_dispatch_cb_print((guchar *)&args, &whdr, 0,
1713                                   &pseudo_header, pd);
1714       }
1715     }
1716   } else {
1717     wtap_dispatch_cb_print((guchar *)&args, &whdr, 0, &pseudo_header, pd);
1718   }
1719 }
1720
1721 #ifdef _WIN32
1722 static BOOL WINAPI
1723 capture_cleanup(DWORD ctrltype _U_)
1724 {
1725   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
1726      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
1727      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
1728      like SIGTERM at least when the machine's shutting down.
1729
1730      For now, we handle them all as indications that we should clean up
1731      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
1732      way on UNIX.
1733
1734      However, as handlers run in a new thread, we can't just longjmp
1735      out; we have to set "ld.go" to FALSE, and must return TRUE so that
1736      no other handler - such as one that would terminate the process -
1737      gets called.
1738
1739      XXX - for some reason, typing ^C to Tethereal, if you run this in
1740      a Cygwin console window in at least some versions of Cygwin,
1741      causes Tethereal to terminate immediately; this routine gets
1742      called, but the main loop doesn't get a chance to run and
1743      exit cleanly, at least if this is compiled with Microsoft Visual
1744      C++ (i.e., it's a property of the Cygwin console window or Bash;
1745      it happens if Tethereal is not built with Cygwin - for all I know,
1746      building it with Cygwin may make the problem go away). */
1747   ld.go = FALSE;
1748   return TRUE;
1749 }
1750 #else
1751 static void
1752 capture_cleanup(int signum _U_)
1753 {
1754   /* Longjmp back to the starting point; "pcap_dispatch()", on many
1755      UNIX platforms, just keeps looping if it gets EINTR, so if we set
1756      "ld.go" to FALSE and return, we won't break out of it and quit
1757      capturing. */
1758   longjmp(ld.stopenv, 1);
1759 }
1760 #endif /* _WIN32 */
1761
1762 static void
1763 report_counts(void)
1764 {
1765 #ifdef SIGINFO
1766   /* XXX - if we use sigaction, this doesn't have to be done.
1767      (Yes, this isn't necessary on BSD, but just in case a system
1768      where "signal()" has AT&T semantics adopts SIGINFO....) */
1769   signal(SIGINFO, report_counts_siginfo);
1770 #endif /* SIGINFO */
1771
1772   if (cfile.save_file != NULL && quiet) {
1773     /* Report the count only if we're capturing to a file (rather
1774        than printing captured packet information out) and aren't
1775        updating a count as packets arrive. */
1776     fprintf(stderr, "%u packets captured\n", ld.packet_count);
1777   }
1778 #ifdef SIGINFO
1779   infoprint = FALSE;    /* we just reported it */
1780 #endif /* SIGINFO */
1781 }
1782
1783 #ifdef SIGINFO
1784 static void
1785 report_counts_siginfo(int signum _U_)
1786 {
1787   int sav_errno = errno;
1788   /* If we've been told to delay printing, just set a flag asking
1789      that we print counts (if we're supposed to), otherwise print
1790      the count of packets captured (if we're supposed to). */
1791   if (infodelay)
1792     infoprint = TRUE;
1793   else
1794     report_counts();
1795   errno = sav_errno;
1796 }
1797 #endif /* SIGINFO */
1798 #endif /* HAVE_LIBPCAP */
1799
1800 static int
1801 load_cap_file(capture_file *cf, int out_file_type)
1802 {
1803   gint         linktype;
1804   int          snapshot_length;
1805   wtap_dumper *pdh;
1806   int          err;
1807   int          success;
1808   cb_args_t    args;
1809
1810   linktype = wtap_file_encap(cf->wth);
1811   if (cf->save_file != NULL) {
1812     /* Set up to write to the capture file. */
1813     snapshot_length = wtap_snapshot_length(cf->wth);
1814     if (snapshot_length == 0) {
1815       /* Snapshot length of input file not known. */
1816       snapshot_length = WTAP_MAX_PACKET_SIZE;
1817     }
1818     pdh = wtap_dump_open(cf->save_file, out_file_type,
1819                 linktype, snapshot_length, &err);
1820
1821     if (pdh == NULL) {
1822       /* We couldn't set up to write to the capture file. */
1823       switch (err) {
1824
1825       case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
1826         fprintf(stderr,
1827                 "tethereal: Capture files can't be written in that format.\n");
1828         break;
1829
1830       case WTAP_ERR_UNSUPPORTED_ENCAP:
1831       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
1832         fprintf(stderr,
1833           "tethereal: The capture file being read cannot be written in "
1834           "that format.\n");
1835         break;
1836
1837       case WTAP_ERR_CANT_OPEN:
1838         fprintf(stderr,
1839           "tethereal: The file \"%s\" couldn't be created for some "
1840           "unknown reason.\n",
1841             *cf->save_file == '\0' ? "stdout" : cf->save_file);
1842         break;
1843
1844       case WTAP_ERR_SHORT_WRITE:
1845         fprintf(stderr,
1846           "tethereal: A full header couldn't be written to the file \"%s\".\n",
1847                 *cf->save_file == '\0' ? "stdout" : cf->save_file);
1848         break;
1849
1850       default:
1851         fprintf(stderr,
1852           "tethereal: The file \"%s\" could not be created: %s\n.",
1853                 *cf->save_file == '\0' ? "stdout" : cf->save_file,
1854                 wtap_strerror(err));
1855         break;
1856       }
1857       goto out;
1858     }
1859     args.cf = cf;
1860     args.pdh = pdh;
1861     success = wtap_loop(cf->wth, 0, wtap_dispatch_cb_write, (guchar *) &args,
1862                         &err);
1863
1864     /* Now close the capture file. */
1865     if (!wtap_dump_close(pdh, &err))
1866       show_capture_file_io_error(cfile.save_file, err, TRUE);
1867   } else {
1868     args.cf = cf;
1869     args.pdh = NULL;
1870     success = wtap_loop(cf->wth, 0, wtap_dispatch_cb_print, (guchar *) &args,
1871                         &err);
1872   }
1873   if (!success) {
1874     /* Print up a message box noting that the read failed somewhere along
1875        the line. */
1876     switch (err) {
1877
1878     case WTAP_ERR_UNSUPPORTED_ENCAP:
1879       fprintf(stderr,
1880 "tethereal: \"%s\" is a capture file is for a network type that Tethereal doesn't support.\n",
1881         cf->filename);
1882       break;
1883
1884     case WTAP_ERR_CANT_READ:
1885       fprintf(stderr,
1886 "tethereal: An attempt to read from \"%s\" failed for some unknown reason.\n",
1887         cf->filename);
1888       break;
1889
1890     case WTAP_ERR_SHORT_READ:
1891       fprintf(stderr,
1892 "tethereal: \"%s\" appears to have been cut short in the middle of a packet.\n",
1893         cf->filename);
1894       break;
1895
1896     case WTAP_ERR_BAD_RECORD:
1897       fprintf(stderr,
1898 "tethereal: \"%s\" appears to be damaged or corrupt.\n",
1899         cf->filename);
1900       break;
1901
1902     default:
1903       fprintf(stderr,
1904 "tethereal: An error occurred while reading \"%s\": %s.\n",
1905         cf->filename, wtap_strerror(err));
1906       break;
1907     }
1908   }
1909
1910 out:
1911   wtap_close(cf->wth);
1912   cf->wth = NULL;
1913
1914   return err;
1915 }
1916
1917 static void
1918 fill_in_fdata(frame_data *fdata, capture_file *cf,
1919         const struct wtap_pkthdr *phdr, long offset)
1920 {
1921   fdata->next = NULL;
1922   fdata->prev = NULL;
1923   fdata->pfd = NULL;
1924   fdata->num = cf->count;
1925   fdata->pkt_len = phdr->len;
1926   fdata->cap_len = phdr->caplen;
1927   fdata->file_off = offset;
1928   fdata->lnk_t = phdr->pkt_encap;
1929   fdata->abs_secs  = phdr->ts.tv_sec;
1930   fdata->abs_usecs = phdr->ts.tv_usec;
1931   fdata->flags.passed_dfilter = 0;
1932   fdata->flags.encoding = CHAR_ASCII;
1933   fdata->flags.visited = 0;
1934   fdata->flags.marked = 0;
1935
1936   /* If we don't have the time stamp of the first packet in the
1937      capture, it's because this is the first packet.  Save the time
1938      stamp of this packet as the time stamp of the first packet. */
1939   if (!firstsec && !firstusec) {
1940     firstsec  = fdata->abs_secs;
1941     firstusec = fdata->abs_usecs;
1942   }
1943
1944   /* If we don't have the time stamp of the previous displayed packet,
1945      it's because this is the first displayed packet.  Save the time
1946      stamp of this packet as the time stamp of the previous displayed
1947      packet. */
1948   if (!prevsec && !prevusec) {
1949     prevsec  = fdata->abs_secs;
1950     prevusec = fdata->abs_usecs;
1951   }
1952
1953   /* Get the time elapsed between the first packet and this packet. */
1954   compute_timestamp_diff(&fdata->rel_secs, &fdata->rel_usecs,
1955                 fdata->abs_secs, fdata->abs_usecs, firstsec, firstusec);
1956
1957   /* If it's greater than the current elapsed time, set the elapsed time
1958      to it (we check for "greater than" so as not to be confused by
1959      time moving backwards). */
1960   if ((gint32)cf->esec < fdata->rel_secs
1961         || ((gint32)cf->esec == fdata->rel_secs && (gint32)cf->eusec < fdata->rel_usecs)) {
1962     cf->esec = fdata->rel_secs;
1963     cf->eusec = fdata->rel_usecs;
1964   }
1965
1966   /* Get the time elapsed between the previous displayed packet and
1967      this packet. */
1968   compute_timestamp_diff(&fdata->del_secs, &fdata->del_usecs,
1969                 fdata->abs_secs, fdata->abs_usecs, prevsec, prevusec);
1970   prevsec = fdata->abs_secs;
1971   prevusec = fdata->abs_usecs;
1972 }
1973
1974 /* Free up all data attached to a "frame_data" structure. */
1975 static void
1976 clear_fdata(frame_data *fdata)
1977 {
1978   if (fdata->pfd)
1979     g_slist_free(fdata->pfd);
1980 }
1981
1982 static void
1983 wtap_dispatch_cb_write(guchar *user, const struct wtap_pkthdr *phdr,
1984   long offset, union wtap_pseudo_header *pseudo_header, const guchar *buf)
1985 {
1986   cb_args_t    *args = (cb_args_t *) user;
1987   capture_file *cf = args->cf;
1988   wtap_dumper  *pdh = args->pdh;
1989   frame_data    fdata;
1990   int           err;
1991   gboolean      passed;
1992   epan_dissect_t *edt;
1993
1994 #ifdef HAVE_LIBPCAP
1995 #ifdef SIGINFO
1996   /*
1997    * Prevent a SIGINFO handler from writing to stdout while we're
1998    * doing so; instead, have it just set a flag telling us to print
1999    * that information when we're done.
2000    */
2001   infodelay = TRUE;
2002 #endif /* SIGINFO */
2003 #endif /* HAVE_LIBPCAP */
2004
2005   cf->count++;
2006   if (cf->rfcode) {
2007     fill_in_fdata(&fdata, cf, phdr, offset);
2008     edt = epan_dissect_new(TRUE, FALSE);
2009     epan_dissect_prime_dfilter(edt, cf->rfcode);
2010     epan_dissect_run(edt, pseudo_header, buf, &fdata, NULL);
2011     passed = dfilter_apply_edt(cf->rfcode, edt);
2012   } else {
2013     passed = TRUE;
2014     edt = NULL;
2015   }
2016   if (passed) {
2017     /* The packet passed the read filter. */
2018 #ifdef HAVE_LIBPCAP
2019     ld.packet_count++;
2020 #endif
2021     if (!wtap_dump(pdh, phdr, pseudo_header, buf, &err)) {
2022 #ifdef HAVE_LIBPCAP
2023       if (ld.pch != NULL && !quiet) {
2024         /* We're capturing packets, so (if -q not specified) we're printing
2025            a count of packets captured; move to the line after the count. */
2026         fprintf(stderr, "\n");
2027       }
2028 #endif
2029       show_capture_file_io_error(cf->save_file, err, FALSE);
2030 #ifdef HAVE_LIBPCAP
2031       if (ld.pch != NULL)
2032         pcap_close(ld.pch);
2033 #endif
2034       wtap_dump_close(pdh, &err);
2035       exit(2);
2036     }
2037   }
2038   if (edt != NULL)
2039     epan_dissect_free(edt);
2040   if (cf->rfcode)
2041     clear_fdata(&fdata);
2042
2043 #ifdef HAVE_LIBPCAP
2044 #ifdef SIGINFO
2045   /*
2046    * Allow SIGINFO handlers to write.
2047    */
2048   infodelay = FALSE;
2049
2050   /*
2051    * If a SIGINFO handler asked us to write out capture counts, do so.
2052    */
2053   if (infoprint)
2054     report_counts();
2055 #endif /* SIGINFO */
2056 #endif /* HAVE_LIBPCAP */
2057 }
2058
2059 static void
2060 show_capture_file_io_error(const char *fname, int err, gboolean is_close)
2061 {
2062   if (*fname == '\0')
2063     fname = "stdout";
2064
2065   switch (err) {
2066
2067   case ENOSPC:
2068     fprintf(stderr,
2069 "tethereal: Not all the packets could be written to \"%s\" because there is "
2070 "no space left on the file system.\n",
2071         fname);
2072     break;
2073
2074 #ifdef EDQUOT
2075   case EDQUOT:
2076     fprintf(stderr,
2077 "tethereal: Not all the packets could be written to \"%s\" because you are "
2078 "too close to, or over your disk quota.\n",
2079         fname);
2080   break;
2081 #endif
2082
2083   case WTAP_ERR_CANT_CLOSE:
2084     fprintf(stderr,
2085 "tethereal: \"%s\" couldn't be closed for some unknown reason.\n",
2086         fname);
2087     break;
2088
2089   case WTAP_ERR_SHORT_WRITE:
2090     fprintf(stderr,
2091 "tethereal: Not all the packets could be written to \"%s\".\n",
2092         fname);
2093     break;
2094
2095   default:
2096     if (is_close) {
2097       fprintf(stderr,
2098 "tethereal: \"%s\" could not be closed: %s.\n",
2099         fname, wtap_strerror(err));
2100     } else {
2101       fprintf(stderr,
2102 "tethereal: An error occurred while writing to \"%s\": %s.\n",
2103         fname, wtap_strerror(err));
2104     }
2105     break;
2106   }
2107 }
2108
2109 static void
2110 wtap_dispatch_cb_print(guchar *user, const struct wtap_pkthdr *phdr,
2111   long offset, union wtap_pseudo_header *pseudo_header, const guchar *buf)
2112 {
2113   cb_args_t    *args = (cb_args_t *) user;
2114   capture_file *cf = args->cf;
2115   frame_data    fdata;
2116   gboolean      passed;
2117   print_args_t  print_args;
2118   epan_dissect_t *edt;
2119   gboolean      create_proto_tree;
2120   int           i;
2121
2122   cf->count++;
2123
2124   fill_in_fdata(&fdata, cf, phdr, offset);
2125
2126   /* Grab any resolved addresses */
2127   if (g_resolv_flags) {
2128     host_name_lookup_process(NULL);
2129   }
2130
2131   passed = TRUE;
2132   if (cf->rfcode || verbose || num_tap_filters!=0)
2133     create_proto_tree = TRUE;
2134   else
2135     create_proto_tree = FALSE;
2136   /* The protocol tree will be "visible", i.e., printed, only if we're
2137      not printing a summary.
2138
2139      We only need the columns if we're *not* verbose; in verbose mode,
2140      we print the protocol tree, not the protocol summary. */
2141
2142   edt = epan_dissect_new(create_proto_tree, verbose);
2143   if (cf->rfcode) {
2144     epan_dissect_prime_dfilter(edt, cf->rfcode);
2145   }
2146
2147   tap_queue_init(edt);
2148   epan_dissect_run(edt, pseudo_header, buf, &fdata, verbose ? NULL : &cf->cinfo);
2149   tap_push_tapped_queue(edt);
2150
2151   if (cf->rfcode) {
2152     passed = dfilter_apply_edt(cf->rfcode, edt);
2153   }
2154   if (passed) {
2155     /* The packet passed the read filter. */
2156 #ifdef HAVE_LIBPCAP
2157     ld.packet_count++;
2158 #endif
2159     if (verbose) {
2160       /* Print the information in the protocol tree. */
2161       print_args.to_file = TRUE;
2162       print_args.format = PR_FMT_TEXT;
2163       print_args.print_summary = FALSE;
2164       print_args.print_hex = print_hex;
2165       print_args.expand_all = TRUE;
2166       print_args.suppress_unmarked = FALSE;
2167       proto_tree_print(&print_args, edt, stdout);
2168       if (!print_hex) {
2169         /* "print_hex_data()" will put out a leading blank line, as well
2170            as a trailing one; print one here, to separate the packets,
2171            only if "print_hex_data()" won't be called. */
2172         printf("\n");
2173       }
2174     } else {
2175       /* Just fill in the columns. */
2176       epan_dissect_fill_in_columns(edt);
2177
2178       /* Now print them. */
2179       for (i = 0; i < cf->cinfo.num_cols; i++) {
2180         switch (cf->cinfo.col_fmt[i]) {
2181         case COL_NUMBER:
2182           /*
2183            * Don't print this if we're doing a live capture from a network
2184            * interface - if we're doing a live capture, you won't be
2185            * able to look at the capture in the future (it's not being
2186            * saved anywhere), so the frame numbers are unlikely to be
2187            * useful.
2188            *
2189            * (XXX - it might be nice to be able to save and print at
2190            * the same time, sort of like an "Update list of packets
2191            * in real time" capture in Ethereal.)
2192            */
2193           if (cf->iface != NULL)
2194             continue;
2195           printf("%3s", cf->cinfo.col_data[i]);
2196           break;
2197
2198         case COL_CLS_TIME:
2199         case COL_REL_TIME:
2200         case COL_ABS_TIME:
2201         case COL_ABS_DATE_TIME: /* XXX - wider */
2202           printf("%10s", cf->cinfo.col_data[i]);
2203           break;
2204
2205         case COL_DEF_SRC:
2206         case COL_RES_SRC:
2207         case COL_UNRES_SRC:
2208         case COL_DEF_DL_SRC:
2209         case COL_RES_DL_SRC:
2210         case COL_UNRES_DL_SRC:
2211         case COL_DEF_NET_SRC:
2212         case COL_RES_NET_SRC:
2213         case COL_UNRES_NET_SRC:
2214           printf("%12s", cf->cinfo.col_data[i]);
2215           break;
2216
2217         case COL_DEF_DST:
2218         case COL_RES_DST:
2219         case COL_UNRES_DST:
2220         case COL_DEF_DL_DST:
2221         case COL_RES_DL_DST:
2222         case COL_UNRES_DL_DST:
2223         case COL_DEF_NET_DST:
2224         case COL_RES_NET_DST:
2225         case COL_UNRES_NET_DST:
2226           printf("%-12s", cf->cinfo.col_data[i]);
2227           break;
2228
2229         default:
2230           printf("%s", cf->cinfo.col_data[i]);
2231           break;
2232         }
2233         if (i != cf->cinfo.num_cols - 1) {
2234           /*
2235            * This isn't the last column, so we need to print a
2236            * separator between this column and the next.
2237            *
2238            * If we printed a network source and are printing a
2239            * network destination of the same type next, separate
2240            * them with "->"; if we printed a network destination
2241            * and are printing a network source of the same type
2242            * next, separate them with "<-"; otherwise separate them
2243            * with a space.
2244            */
2245           switch (cf->cinfo.col_fmt[i]) {
2246
2247           case COL_DEF_SRC:
2248           case COL_RES_SRC:
2249           case COL_UNRES_SRC:
2250             switch (cf->cinfo.col_fmt[i + 1]) {
2251
2252             case COL_DEF_DST:
2253             case COL_RES_DST:
2254             case COL_UNRES_DST:
2255               printf(" -> ");
2256               break;
2257
2258             default:
2259               putchar(' ');
2260               break;
2261             }
2262             break;
2263
2264           case COL_DEF_DL_SRC:
2265           case COL_RES_DL_SRC:
2266           case COL_UNRES_DL_SRC:
2267             switch (cf->cinfo.col_fmt[i + 1]) {
2268
2269             case COL_DEF_DL_DST:
2270             case COL_RES_DL_DST:
2271             case COL_UNRES_DL_DST:
2272               printf(" -> ");
2273               break;
2274
2275             default:
2276               putchar(' ');
2277               break;
2278             }
2279             break;
2280
2281           case COL_DEF_NET_SRC:
2282           case COL_RES_NET_SRC:
2283           case COL_UNRES_NET_SRC:
2284             switch (cf->cinfo.col_fmt[i + 1]) {
2285
2286             case COL_DEF_NET_DST:
2287             case COL_RES_NET_DST:
2288             case COL_UNRES_NET_DST:
2289               printf(" -> ");
2290               break;
2291
2292             default:
2293               putchar(' ');
2294               break;
2295             }
2296             break;
2297
2298           case COL_DEF_DST:
2299           case COL_RES_DST:
2300           case COL_UNRES_DST:
2301             switch (cf->cinfo.col_fmt[i + 1]) {
2302
2303             case COL_DEF_SRC:
2304             case COL_RES_SRC:
2305             case COL_UNRES_SRC:
2306               printf(" <- ");
2307               break;
2308
2309             default:
2310               putchar(' ');
2311               break;
2312             }
2313             break;
2314
2315           case COL_DEF_DL_DST:
2316           case COL_RES_DL_DST:
2317           case COL_UNRES_DL_DST:
2318             switch (cf->cinfo.col_fmt[i + 1]) {
2319
2320             case COL_DEF_DL_SRC:
2321             case COL_RES_DL_SRC:
2322             case COL_UNRES_DL_SRC:
2323               printf(" <- ");
2324               break;
2325
2326             default:
2327               putchar(' ');
2328               break;
2329             }
2330             break;
2331
2332           case COL_DEF_NET_DST:
2333           case COL_RES_NET_DST:
2334           case COL_UNRES_NET_DST:
2335             switch (cf->cinfo.col_fmt[i + 1]) {
2336
2337             case COL_DEF_NET_SRC:
2338             case COL_RES_NET_SRC:
2339             case COL_UNRES_NET_SRC:
2340               printf(" <- ");
2341               break;
2342
2343             default:
2344               putchar(' ');
2345               break;
2346             }
2347             break;
2348
2349           default:
2350             putchar(' ');
2351             break;
2352           }
2353         }
2354       }
2355       putchar('\n');
2356     }
2357     if (print_hex) {
2358       print_hex_data(stdout, print_args.format, edt);
2359       putchar('\n');
2360     }
2361   }
2362
2363   /* The ANSI C standard does not appear to *require* that a line-buffered
2364      stream be flushed to the host environment whenever a newline is
2365      written, it just says that, on such a stream, characters "are
2366      intended to be transmitted to or from the host environment as a
2367      block when a new-line character is encountered".
2368
2369      The Visual C++ 6.0 C implementation doesn't do what is intended;
2370      even if you set a stream to be line-buffered, it still doesn't
2371      flush the buffer at the end of every line.
2372
2373      So, if the "-l" flag was specified, we flush the standard output
2374      at the end of a packet.  This will do the right thing if we're
2375      printing packet summary lines, and, as we print the entire protocol
2376      tree for a single packet without waiting for anything to happen,
2377      it should be as good as line-buffered mode if we're printing
2378      protocol trees.  (The whole reason for the "-l" flag in either
2379      tcpdump or Tethereal is to allow the output of a live capture to
2380      be piped to a program or script and to have that script see the
2381      information for the packet as soon as it's printed, rather than
2382      having to wait until a standard I/O buffer fills up. */
2383   if (line_buffered)
2384     fflush(stdout);
2385
2386   epan_dissect_free(edt);
2387
2388   clear_fdata(&fdata);
2389 }
2390
2391 char *
2392 file_open_error_message(int err, gboolean for_writing, int file_type)
2393 {
2394   char *errmsg;
2395   static char errmsg_errno[1024+1];
2396
2397   switch (err) {
2398
2399   case WTAP_ERR_NOT_REGULAR_FILE:
2400     errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
2401     break;
2402
2403   case WTAP_ERR_FILE_UNKNOWN_FORMAT:
2404   case WTAP_ERR_UNSUPPORTED:
2405     /* Seen only when opening a capture file for reading. */
2406     errmsg = "The file \"%s\" is not a capture file in a format Tethereal understands.";
2407     break;
2408
2409   case WTAP_ERR_CANT_WRITE_TO_PIPE:
2410     /* Seen only when opening a capture file for writing. */
2411     snprintf(errmsg_errno, sizeof(errmsg_errno),
2412              "The file \"%%s\" is a pipe, and %s capture files cannot be "
2413              "written to a pipe.", wtap_file_type_string(file_type));
2414     errmsg = errmsg_errno;
2415     break;
2416
2417   case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
2418     /* Seen only when opening a capture file for writing. */
2419     errmsg = "Tethereal does not support writing capture files in that format.";
2420     break;
2421
2422   case WTAP_ERR_UNSUPPORTED_ENCAP:
2423   case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
2424     if (for_writing)
2425       errmsg = "Tethereal cannot save this capture in that format.";
2426     else
2427       errmsg = "The file \"%s\" is a capture for a network type that Tethereal doesn't support.";
2428     break;
2429
2430   case WTAP_ERR_BAD_RECORD:
2431     errmsg = "The file \"%s\" appears to be damaged or corrupt.";
2432     break;
2433
2434   case WTAP_ERR_CANT_OPEN:
2435     if (for_writing)
2436       errmsg = "The file \"%s\" could not be created for some unknown reason.";
2437     else
2438       errmsg = "The file \"%s\" could not be opened for some unknown reason.";
2439     break;
2440
2441   case WTAP_ERR_SHORT_READ:
2442     errmsg = "The file \"%s\" appears to have been cut short"
2443              " in the middle of a packet or other data.";
2444     break;
2445
2446   case WTAP_ERR_SHORT_WRITE:
2447     errmsg = "A full header couldn't be written to the file \"%s\".";
2448     break;
2449
2450   case ENOENT:
2451     if (for_writing)
2452       errmsg = "The path to the file \"%s\" does not exist.";
2453     else
2454       errmsg = "The file \"%s\" does not exist.";
2455     break;
2456
2457   case EACCES:
2458     if (for_writing)
2459       errmsg = "You do not have permission to create or write to the file \"%s\".";
2460     else
2461       errmsg = "You do not have permission to read the file \"%s\".";
2462     break;
2463
2464   case EISDIR:
2465     errmsg = "\"%s\" is a directory (folder), not a file.";
2466     break;
2467
2468   default:
2469     snprintf(errmsg_errno, sizeof(errmsg_errno),
2470              "The file \"%%s\" could not be %s: %s.",
2471              for_writing ? "created" : "opened",
2472              wtap_strerror(err));
2473     errmsg = errmsg_errno;
2474     break;
2475   }
2476   return errmsg;
2477 }
2478
2479 int
2480 open_cap_file(char *fname, gboolean is_tempfile, capture_file *cf)
2481 {
2482   wtap       *wth;
2483   int         err;
2484   char        err_msg[2048+1];
2485
2486   wth = wtap_open_offline(fname, &err, FALSE);
2487   if (wth == NULL)
2488     goto fail;
2489
2490   /* The open succeeded.  Fill in the information for this file. */
2491
2492   /* Initialize all data structures used for dissection. */
2493   init_dissection();
2494
2495   cf->wth = wth;
2496   cf->filed = -1;       /* not used, but set it anyway */
2497   cf->f_len = 0;        /* not used, but set it anyway */
2498
2499   /* Set the file name because we need it to set the follow stream filter.
2500      XXX - is that still true?  We need it for other reasons, though,
2501      in any case. */
2502   cf->filename = g_strdup(fname);
2503
2504   /* Indicate whether it's a permanent or temporary file. */
2505   cf->is_tempfile = is_tempfile;
2506
2507   /* If it's a temporary capture buffer file, mark it as not saved. */
2508   cf->user_saved = !is_tempfile;
2509
2510   cf->cd_t      = wtap_file_type(cf->wth);
2511   cf->count     = 0;
2512   cf->drops_known = FALSE;
2513   cf->drops     = 0;
2514   cf->esec      = 0;
2515   cf->eusec     = 0;
2516   cf->snap      = wtap_snapshot_length(cf->wth);
2517   if (cf->snap == 0) {
2518     /* Snapshot length not known. */
2519     cf->has_snap = FALSE;
2520     cf->snap = WTAP_MAX_PACKET_SIZE;
2521   } else
2522     cf->has_snap = TRUE;
2523   cf->progbar_quantum = 0;
2524   cf->progbar_nextstep = 0;
2525   firstsec = 0, firstusec = 0;
2526   prevsec = 0, prevusec = 0;
2527
2528   return (0);
2529
2530 fail:
2531   snprintf(err_msg, sizeof err_msg, file_open_error_message(err, FALSE, 0),
2532            fname);
2533   fprintf(stderr, "tethereal: %s\n", err_msg);
2534   return (err);
2535 }
2536
2537 #ifdef HAVE_LIBPCAP
2538 #ifndef _WIN32
2539 /* Take care of byte order in the libpcap headers read from pipes.
2540  * (function taken from wiretap/libpcap.c) */
2541 static void
2542 adjust_header(loop_data *ld, struct pcap_hdr *hdr, struct pcaprec_hdr *rechdr)
2543 {
2544   if (ld->byte_swapped) {
2545     /* Byte-swap the record header fields. */
2546     rechdr->ts_sec = BSWAP32(rechdr->ts_sec);
2547     rechdr->ts_usec = BSWAP32(rechdr->ts_usec);
2548     rechdr->incl_len = BSWAP32(rechdr->incl_len);
2549     rechdr->orig_len = BSWAP32(rechdr->orig_len);
2550   }
2551
2552   /* In file format version 2.3, the "incl_len" and "orig_len" fields were
2553      swapped, in order to match the BPF header layout.
2554
2555      Unfortunately, some files were, according to a comment in the "libpcap"
2556      source, written with version 2.3 in their headers but without the
2557      interchanged fields, so if "incl_len" is greater than "orig_len" - which
2558      would make no sense - we assume that we need to swap them.  */
2559   if (hdr->version_major == 2 &&
2560       (hdr->version_minor < 3 ||
2561        (hdr->version_minor == 3 && rechdr->incl_len > rechdr->orig_len))) {
2562     guint32 temp;
2563
2564     temp = rechdr->orig_len;
2565     rechdr->orig_len = rechdr->incl_len;
2566     rechdr->incl_len = temp;
2567   }
2568 }
2569
2570 /* Mimic pcap_open_live() for pipe captures
2571  * We check if "pipename" is "-" (stdin) or a FIFO, open it, and read the
2572  * header.
2573  * N.B. : we can't read the libpcap formats used in RedHat 6.1 or SuSE 6.3
2574  * because we can't seek on pipes (see wiretap/libpcap.c for details) */
2575 static int
2576 pipe_open_live(char *pipename, struct pcap_hdr *hdr, loop_data *ld,
2577                  char *errmsg, int errmsgl)
2578 {
2579   struct stat pipe_stat;
2580   int         fd;
2581   guint32     magic;
2582   int         b;
2583   unsigned int bytes_read;
2584
2585   /*
2586    * XXX Tethereal blocks until we return
2587    */
2588   if (strcmp(pipename, "-") == 0)
2589     fd = 0; /* read from stdin */
2590   else {
2591     if (stat(pipename, &pipe_stat) < 0) {
2592       if (errno == ENOENT || errno == ENOTDIR)
2593         ld->pipe_err = PIPNEXIST;
2594       else {
2595         snprintf(errmsg, errmsgl,
2596           "The capture session could not be initiated "
2597           "due to error on pipe: %s", strerror(errno));
2598         ld->pipe_err = PIPERR;
2599       }
2600       return -1;
2601     }
2602     if (! S_ISFIFO(pipe_stat.st_mode)) {
2603       if (S_ISCHR(pipe_stat.st_mode)) {
2604         /*
2605          * Assume the user specified an interface on a system where
2606          * interfaces are in /dev.  Pretend we haven't seen it.
2607          */
2608          ld->pipe_err = PIPNEXIST;
2609       } else {
2610         snprintf(errmsg, errmsgl,
2611             "The capture session could not be initiated because\n"
2612             "\"%s\" is neither an interface nor a pipe", pipename);
2613         ld->pipe_err = PIPERR;
2614       }
2615       return -1;
2616     }
2617     fd = open(pipename, O_RDONLY);
2618     if (fd == -1) {
2619       snprintf(errmsg, errmsgl,
2620           "The capture session could not be initiated "
2621           "due to error on pipe open: %s", strerror(errno));
2622       ld->pipe_err = PIPERR;
2623       return -1;
2624     }
2625   }
2626
2627   ld->from_pipe = TRUE;
2628
2629   /* read the pcap header */
2630   bytes_read = 0;
2631   while (bytes_read < sizeof magic) {
2632     b = read(fd, ((char *)&magic)+bytes_read, sizeof magic-bytes_read);
2633     if (b <= 0) {
2634       if (b == 0)
2635         snprintf(errmsg, errmsgl, "End of file on pipe during open");
2636       else
2637         snprintf(errmsg, errmsgl, "Error on pipe during open: %s",
2638           strerror(errno));
2639       goto error;
2640     }
2641     bytes_read += b;
2642   }
2643
2644   switch (magic) {
2645   case PCAP_MAGIC:
2646     /* Host that wrote it has our byte order, and was running
2647        a program using either standard or ss990417 libpcap. */
2648     ld->byte_swapped = FALSE;
2649     ld->modified = FALSE;
2650     break;
2651   case PCAP_MODIFIED_MAGIC:
2652     /* Host that wrote it has our byte order, but was running
2653        a program using either ss990915 or ss991029 libpcap. */
2654     ld->byte_swapped = FALSE;
2655     ld->modified = TRUE;
2656     break;
2657   case PCAP_SWAPPED_MAGIC:
2658     /* Host that wrote it has a byte order opposite to ours,
2659        and was running a program using either standard or
2660        ss990417 libpcap. */
2661     ld->byte_swapped = TRUE;
2662     ld->modified = FALSE;
2663     break;
2664   case PCAP_SWAPPED_MODIFIED_MAGIC:
2665     /* Host that wrote it out has a byte order opposite to
2666        ours, and was running a program using either ss990915
2667        or ss991029 libpcap. */
2668     ld->byte_swapped = TRUE;
2669     ld->modified = TRUE;
2670     break;
2671   default:
2672     /* Not a "libpcap" type we know about. */
2673     snprintf(errmsg, errmsgl, "Unrecognized libpcap format");
2674     goto error;
2675   }
2676
2677   /* Read the rest of the header */
2678   bytes_read = 0;
2679   while (bytes_read < sizeof(struct pcap_hdr)) {
2680     b = read(fd, ((char *)hdr)+bytes_read,
2681           sizeof(struct pcap_hdr) - bytes_read);
2682     if (b <= 0) {
2683       if (b == 0)
2684         snprintf(errmsg, errmsgl, "End of file on pipe during open");
2685       else
2686         snprintf(errmsg, errmsgl, "Error on pipe during open: %s",
2687           strerror(errno));
2688       goto error;
2689     }
2690     bytes_read += b;
2691   }
2692
2693   if (ld->byte_swapped) {
2694     /* Byte-swap the header fields about which we care. */
2695     hdr->version_major = BSWAP16(hdr->version_major);
2696     hdr->version_minor = BSWAP16(hdr->version_minor);
2697     hdr->snaplen = BSWAP32(hdr->snaplen);
2698     hdr->network = BSWAP32(hdr->network);
2699   }
2700
2701   if (hdr->version_major < 2) {
2702     snprintf(errmsg, errmsgl, "Unable to read old libpcap format");
2703     goto error;
2704   }
2705
2706   ld->pipe_state = STATE_EXPECT_REC_HDR;
2707   ld->pipe_err = PIPOK;
2708   return fd;
2709
2710 error:
2711   ld->pipe_err = PIPERR;
2712   close(fd);
2713   return -1;
2714
2715 }
2716 /* We read one record from the pipe, take care of byte order in the record
2717  * header, write the record in the capture file, and update capture statistics. */
2718
2719 static int
2720 pipe_dispatch(int fd, loop_data *ld, struct pcap_hdr *hdr,
2721                 struct pcaprec_modified_hdr *rechdr, guchar *data,
2722                 char *errmsg, int errmsgl)
2723 {
2724   struct pcap_pkthdr phdr;
2725   int b;
2726   enum { PD_REC_HDR_READ, PD_DATA_READ, PD_PIPE_EOF, PD_PIPE_ERR,
2727           PD_ERR } result;
2728
2729   switch (ld->pipe_state) {
2730
2731   case STATE_EXPECT_REC_HDR:
2732     ld->bytes_to_read = ld->modified ?
2733       sizeof(struct pcaprec_modified_hdr) : sizeof(struct pcaprec_hdr);
2734     ld->bytes_read = 0;
2735     ld->pipe_state = STATE_READ_REC_HDR;
2736     /* Fall through */
2737
2738   case STATE_READ_REC_HDR:
2739     b = read(fd, ((char *)rechdr)+ld->bytes_read,
2740       ld->bytes_to_read - ld->bytes_read);
2741     if (b <= 0) {
2742       if (b == 0)
2743         result = PD_PIPE_EOF;
2744       else
2745         result = PD_PIPE_ERR;
2746       break;
2747     }
2748     if ((ld->bytes_read += b) < ld->bytes_to_read)
2749         return 0;
2750     result = PD_REC_HDR_READ;
2751     break;
2752
2753   case STATE_EXPECT_DATA:
2754     ld->bytes_read = 0;
2755     ld->pipe_state = STATE_READ_DATA;
2756     /* Fall through */
2757
2758   case STATE_READ_DATA:
2759     b = read(fd, data+ld->bytes_read, rechdr->hdr.incl_len - ld->bytes_read);
2760     if (b <= 0) {
2761       if (b == 0)
2762         result = PD_PIPE_EOF;
2763       else
2764         result = PD_PIPE_ERR;
2765       break;
2766     }
2767     if ((ld->bytes_read += b) < rechdr->hdr.incl_len)
2768       return 0;
2769     result = PD_DATA_READ;
2770     break;
2771
2772   default:
2773     snprintf(errmsg, errmsgl, "pipe_dispatch: invalid state");
2774     result = PD_ERR;
2775
2776   } /* switch (ld->pipe_state) */
2777
2778   /*
2779    * We've now read as much data as we were expecting, so process it.
2780    */
2781   switch (result) {
2782
2783   case PD_REC_HDR_READ:
2784     /* We've read the header. Take care of byte order. */
2785     adjust_header(ld, hdr, &rechdr->hdr);
2786     if (rechdr->hdr.incl_len > WTAP_MAX_PACKET_SIZE) {
2787       snprintf(errmsg, errmsgl, "Frame %u too long (%d bytes)",
2788         ld->packet_count+1, rechdr->hdr.incl_len);
2789       break;
2790     }
2791     ld->pipe_state = STATE_EXPECT_DATA;
2792     return 0;
2793
2794   case PD_DATA_READ:
2795     /* Fill in a "struct pcap_pkthdr", and process the packet. */
2796     phdr.ts.tv_sec = rechdr->hdr.ts_sec;
2797     phdr.ts.tv_usec = rechdr->hdr.ts_usec;
2798     phdr.caplen = rechdr->hdr.incl_len;
2799     phdr.len = rechdr->hdr.orig_len;
2800
2801     capture_pcap_cb((guchar *)ld, &phdr, data);
2802
2803     ld->pipe_state = STATE_EXPECT_REC_HDR;
2804     return 1;
2805
2806   case PD_PIPE_EOF:
2807     ld->pipe_err = PIPEOF;
2808     return -1;
2809
2810   case PD_PIPE_ERR:
2811     snprintf(errmsg, errmsgl, "Error reading from pipe: %s",
2812       strerror(errno));
2813     /* Fall through */
2814   case PD_ERR:
2815     break;
2816   }
2817
2818   ld->pipe_err = PIPERR;
2819   /* Return here rather than inside the switch to prevent GCC warning */
2820   return -1;
2821 }
2822 #endif /* _WIN32 */
2823 #endif /* HAVE_LIBPCAP */