Add a few more menu items.
[obnox/wireshark/wip.git] / capture.c
1 /* capture.c
2  * Routines for packet capture
3  *
4  * $Id$
5  *
6  * Wireshark - Network traffic analyzer
7  * By Gerald Combs <gerald@wireshark.org>
8  * Copyright 1998 Gerald Combs
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  */
24
25 #ifdef HAVE_CONFIG_H
26 # include "config.h"
27 #endif
28
29 #ifdef HAVE_LIBPCAP
30
31 #ifdef HAVE_UNISTD_H
32 #include <unistd.h>
33 #endif
34
35 #include <stdio.h>
36 #include <string.h>
37
38 #include <glib.h>
39
40 #include <epan/packet.h>
41 #include <epan/dfilter/dfilter.h>
42 #include "file.h"
43 #include "capture.h"
44 #include "capture_ifinfo.h"
45 #include "capture_sync.h"
46 #include "capture_info.h"
47 #include "capture_ui_utils.h"
48 #include "util.h"
49 #include "capture-pcap-util.h"
50 #include "simple_dialog.h"
51 #include <epan/prefs.h>
52
53 #ifdef _WIN32
54 #include "capture-wpcap.h"
55 #endif
56 #include "ui_util.h"
57 #include "wsutil/file_util.h"
58 #include "log.h"
59
60 typedef struct if_stat_cache_item_s {
61     char *name;
62     struct pcap_stat ps;
63 } if_stat_cache_item_t;
64
65 struct if_stat_cache_s {
66     int stat_fd;
67     int fork_child;
68     GList *cache_list;  /* List of if_stat_chache_entry_t */
69 };
70
71 /* this callback mechanism should possibly be replaced by the g_signal_...() stuff (if I only would know how :-) */
72 typedef struct {
73     capture_callback_t cb_fct;
74     gpointer user_data;
75 } capture_callback_data_t;
76
77 static GList *capture_callbacks = NULL;
78
79 static void
80 capture_callback_invoke(int event, capture_options *capture_opts)
81 {
82     capture_callback_data_t *cb;
83     GList *cb_item = capture_callbacks;
84
85     /* there should be at least one interested */
86     g_assert(cb_item != NULL);
87
88     while(cb_item != NULL) {
89         cb = cb_item->data;
90         cb->cb_fct(event, capture_opts, cb->user_data);
91         cb_item = g_list_next(cb_item);
92     }
93 }
94
95
96 void
97 capture_callback_add(capture_callback_t func, gpointer user_data)
98 {
99     capture_callback_data_t *cb;
100
101     cb = g_malloc(sizeof(capture_callback_data_t));
102     cb->cb_fct = func;
103     cb->user_data = user_data;
104
105     capture_callbacks = g_list_append(capture_callbacks, cb);
106 }
107
108 void
109 capture_callback_remove(capture_callback_t func)
110 {
111     capture_callback_data_t *cb;
112     GList *cb_item = capture_callbacks;
113
114     while(cb_item != NULL) {
115         cb = cb_item->data;
116         if(cb->cb_fct == func) {
117             capture_callbacks = g_list_remove(capture_callbacks, cb);
118             g_free(cb);
119             return;
120         }
121         cb_item = g_list_next(cb_item);
122     }
123
124     g_assert_not_reached();
125 }
126
127 /**
128  * Start a capture.
129  *
130  * @return TRUE if the capture starts successfully, FALSE otherwise.
131  */
132 gboolean
133 capture_start(capture_options *capture_opts)
134 {
135   gboolean ret;
136   guint i;
137   GString *source = g_string_new("");
138
139   if (capture_opts->state != CAPTURE_STOPPED)
140     return FALSE;
141   capture_opts->state = CAPTURE_PREPARING;
142
143   /* close the currently loaded capture file */
144   cf_close(capture_opts->cf);
145
146   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Start ...");
147
148 #ifdef _WIN32
149   if (capture_opts->ifaces->len < 2) {
150 #else
151   if (capture_opts->ifaces->len < 4) {
152 #endif
153     for (i = 0; i < capture_opts->ifaces->len; i++) {
154       interface_options interface_opts;
155
156       interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
157       if (i > 0) {
158           if (capture_opts->ifaces->len > 2) {
159               g_string_append_printf(source, ",");
160           }
161           g_string_append_printf(source, " ");
162           if (i == capture_opts->ifaces->len - 1) {
163               g_string_append_printf(source, "and ");
164           }
165       }
166       g_string_append_printf(source, "%s", get_iface_description_for_interface(capture_opts, i));
167       if ((interface_opts.cfilter != NULL) &&
168           (strlen(interface_opts.cfilter) > 0)) {
169         g_string_append_printf(source, " (%s)", interface_opts.cfilter);
170       }
171     }
172   } else {
173     g_string_append_printf(source, "%u interfaces", capture_opts->ifaces->len);
174   }
175   cf_set_tempfile_source(capture_opts->cf, source->str);
176   g_string_free(source, TRUE);
177
178   /* try to start the capture child process */
179   ret = sync_pipe_start(capture_opts);
180   if(!ret) {
181       if(capture_opts->save_file != NULL) {
182           g_free(capture_opts->save_file);
183           capture_opts->save_file = NULL;
184       }
185
186       g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Start failed!");
187       capture_opts->state = CAPTURE_STOPPED;
188   } else {
189       /* the capture child might not respond shortly after bringing it up */
190       /* (for example: it will block if no input arrives from an input capture pipe (e.g. mkfifo)) */
191
192       /* to prevent problems, bring the main GUI into "capture mode" right after a successful */
193       /* spawn/exec of the capture child, without waiting for any response from it */
194       capture_callback_invoke(capture_cb_capture_prepared, capture_opts);
195
196       if(capture_opts->show_info)
197         capture_info_open(capture_opts);
198   }
199
200   return ret;
201 }
202
203
204 void
205 capture_stop(capture_options *capture_opts)
206 {
207   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Stop ...");
208
209   capture_callback_invoke(capture_cb_capture_stopping, capture_opts);
210
211   /* stop the capture child gracefully */
212   sync_pipe_stop(capture_opts);
213 }
214
215
216 void
217 capture_restart(capture_options *capture_opts)
218 {
219     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Restart");
220
221     capture_opts->restart = TRUE;
222     capture_stop(capture_opts);
223 }
224
225
226 void
227 capture_kill_child(capture_options *capture_opts)
228 {
229   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_INFO, "Capture Kill");
230
231   /* kill the capture child */
232   sync_pipe_kill(capture_opts->fork_child);
233 }
234
235
236
237 /* We've succeeded in doing a (non real-time) capture; try to read it into a new capture file */
238 static gboolean
239 capture_input_read_all(capture_options *capture_opts, gboolean is_tempfile, gboolean drops_known,
240 guint32 drops)
241 {
242   int err;
243
244   /* Capture succeeded; attempt to open the capture file. */
245   if (cf_open(capture_opts->cf, capture_opts->save_file, is_tempfile, &err) != CF_OK) {
246     /* We're not doing a capture any more, so we don't have a save file. */
247     return FALSE;
248   }
249   
250   /* Set the read filter to NULL. */
251   /* XXX - this is odd here; try to put it somewhere where it fits better */
252   cf_set_rfcode(capture_opts->cf, NULL);
253
254   /* Get the packet-drop statistics.
255
256      XXX - there are currently no packet-drop statistics stored
257      in libpcap captures, and that's what we're reading.
258
259      At some point, we will add support in Wiretap to return
260      packet-drop statistics for capture file formats that store it,
261      and will make "cf_read()" get those statistics from Wiretap.
262      We clear the statistics (marking them as "not known") in
263      "cf_open()", and "cf_read()" will only fetch them and mark
264      them as known if Wiretap supplies them, so if we get the
265      statistics now, after calling "cf_open()" but before calling
266      "cf_read()", the values we store will be used by "cf_read()".
267
268      If a future libpcap capture file format stores the statistics,
269      we'll put them into the capture file that we write, and will
270      thus not have to set them here - "cf_read()" will get them from
271      the file and use them. */
272   if (drops_known) {
273     cf_set_drops_known(capture_opts->cf, TRUE);
274
275     /* XXX - on some systems, libpcap doesn't bother filling in
276        "ps_ifdrop" - it doesn't even set it to zero - so we don't
277        bother looking at it.
278
279        Ideally, libpcap would have an interface that gave us
280        several statistics - perhaps including various interface
281        error statistics - and would tell us which of them it
282        supplies, allowing us to display only the ones it does. */
283     cf_set_drops(capture_opts->cf, drops);
284   }
285
286   /* read in the packet data */
287   switch (cf_read(capture_opts->cf, FALSE)) {
288
289   case CF_READ_OK:
290   case CF_READ_ERROR:
291     /* Just because we got an error, that doesn't mean we were unable
292        to read any of the file; we handle what we could get from the
293        file. */
294     break;
295
296   case CF_READ_ABORTED:
297     /* User wants to quit program. Exit by leaving the main loop,
298        so that any quit functions we registered get called. */
299     main_window_nested_quit();
300     return FALSE;
301   }
302
303   /* if we didn't capture even a single packet, close the file again */
304   if(cf_get_packet_count(capture_opts->cf) == 0 && !capture_opts->restart) {
305     simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
306 "%sNo packets captured!%s\n"
307 "\n"
308 "As no data was captured, closing the %scapture file!\n"
309 "\n"
310 "\n"
311 "Help about capturing can be found at:\n"
312 "\n"
313 "       http://wiki.wireshark.org/CaptureSetup"
314 #ifdef _WIN32
315 "\n\n"
316 "Wireless (Wi-Fi/WLAN):\n"
317 "Try to switch off promiscuous mode in the Capture Options!"
318 #endif
319 "",
320     simple_dialog_primary_start(), simple_dialog_primary_end(),
321     (cf_is_tempfile(capture_opts->cf)) ? "temporary " : "");
322     cf_close(capture_opts->cf);
323   }
324   return TRUE;
325 }
326
327
328 /* capture child tells us we have a new (or the first) capture file */
329 gboolean
330 capture_input_new_file(capture_options *capture_opts, gchar *new_file)
331 {
332   gboolean is_tempfile;
333   int  err;
334
335   if(capture_opts->state == CAPTURE_PREPARING) {
336     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started!");
337   }
338   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
339
340   g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING);
341
342   /* free the old filename */
343   if(capture_opts->save_file != NULL) {
344     /* we start a new capture file, close the old one (if we had one before). */
345     /* (we can only have an open capture file in real_time_mode!) */
346     if( ((capture_file *) capture_opts->cf)->state != FILE_CLOSED) {
347         capture_callback_invoke(capture_cb_capture_update_finished, capture_opts);
348         cf_finish_tail(capture_opts->cf, &err);
349         cf_close(capture_opts->cf);
350     }
351     g_free(capture_opts->save_file);
352     is_tempfile = FALSE;
353     cf_set_tempfile(capture_opts->cf, FALSE);
354   } else {
355     /* we didn't have a save_file before; must be a tempfile */
356     is_tempfile = TRUE;
357     cf_set_tempfile(capture_opts->cf, TRUE);
358   }
359
360   /* save the new filename */
361   capture_opts->save_file = g_strdup(new_file);
362
363   /* if we are in real-time mode, open the new file now */
364   if(capture_opts->real_time_mode) {
365     /* Attempt to open the capture file and set up to read from it. */
366     switch(cf_start_tail(capture_opts->cf, capture_opts->save_file, is_tempfile, &err)) {
367     case CF_OK:
368       break;
369     case CF_ERROR:
370       /* Don't unlink (delete) the save file - leave it around,
371          for debugging purposes. */
372       g_free(capture_opts->save_file);
373       capture_opts->save_file = NULL;
374       return FALSE;
375     }
376   }
377
378   if(capture_opts->show_info) {
379     if (!capture_info_new_file(new_file))
380       return FALSE;
381   }
382
383   if(capture_opts->real_time_mode) {
384     capture_callback_invoke(capture_cb_capture_update_started, capture_opts);
385   } else {
386     capture_callback_invoke(capture_cb_capture_fixed_started, capture_opts);
387   }
388   capture_opts->state = CAPTURE_RUNNING;
389
390   return TRUE;
391 }
392
393
394 /* capture child tells us we have new packets to read */
395 void
396 capture_input_new_packets(capture_options *capture_opts, int to_read)
397 {
398   int  err;
399
400
401   g_assert(capture_opts->save_file);
402
403   if(capture_opts->real_time_mode) {
404     /* Read from the capture file the number of records the child told us it added. */
405     switch (cf_continue_tail(capture_opts->cf, to_read, &err)) {
406
407     case CF_READ_OK:
408     case CF_READ_ERROR:
409       /* Just because we got an error, that doesn't mean we were unable
410          to read any of the file; we handle what we could get from the
411          file.
412
413          XXX - abort on a read error? */
414          capture_callback_invoke(capture_cb_capture_update_continue, capture_opts);
415       break;
416
417     case CF_READ_ABORTED:
418       /* Kill the child capture process; the user wants to exit, and we
419          shouldn't just leave it running. */
420       capture_kill_child(capture_opts);
421       break;
422     }
423   } else {
424     /* increase the capture file packet counter by the number of incoming packets */
425     cf_set_packet_count(capture_opts->cf,
426         cf_get_packet_count(capture_opts->cf) + to_read);
427     cf_fake_continue_tail(capture_opts->cf);
428
429     capture_callback_invoke(capture_cb_capture_fixed_continue, capture_opts);
430   }
431
432   /* update the main window so we get events (e.g. from the stop toolbar button) */
433   main_window_update();
434
435   if(capture_opts->show_info)
436     capture_info_new_packets(to_read);
437 }
438
439
440 /* Capture child told us how many dropped packets it counted.
441  */
442 void
443 capture_input_drops(capture_options *capture_opts, guint32 dropped)
444 {
445   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_INFO, "%u packet%s dropped", dropped, plurality(dropped, "", "s"));
446
447   g_assert(capture_opts->state == CAPTURE_RUNNING);
448
449   cf_set_drops_known(capture_opts->cf, TRUE);
450   cf_set_drops(capture_opts->cf, dropped);
451 }
452
453
454 /* Capture child told us that an error has occurred while starting/running
455    the capture.
456    The buffer we're handed has *two* null-terminated strings in it - a
457    primary message and a secondary message, one right after the other.
458    The secondary message might be a null string.
459  */
460 void
461 capture_input_error_message(capture_options *capture_opts, char *error_msg, char *secondary_error_msg)
462 {
463   gchar *safe_error_msg;
464   gchar *safe_secondary_error_msg;
465
466   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Error message from child: \"%s\", \"%s\"",
467         error_msg, secondary_error_msg);
468
469   g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING);
470
471   safe_error_msg = simple_dialog_format_message(error_msg);
472   if (*secondary_error_msg != '\0') {
473     /* We have both primary and secondary messages. */
474     safe_secondary_error_msg = simple_dialog_format_message(secondary_error_msg);
475     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s%s%s\n\n%s",
476                   simple_dialog_primary_start(), safe_error_msg,
477                   simple_dialog_primary_end(), safe_secondary_error_msg);
478     g_free(safe_secondary_error_msg);
479   } else {
480     /* We have only a primary message. */
481     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s%s%s",
482                   simple_dialog_primary_start(), safe_error_msg,
483                   simple_dialog_primary_end());
484   }
485   g_free(safe_error_msg);
486
487   /* the capture child will close the sync_pipe if required, nothing to do for now */
488 }
489
490
491
492 /* Capture child told us that an error has occurred while parsing a
493    capture filter when starting/running the capture.
494  */
495 void
496 capture_input_cfilter_error_message(capture_options *capture_opts, guint i, char *error_message)
497 {
498   dfilter_t *rfcode = NULL;
499   gchar *safe_cfilter;
500   gchar *safe_descr;
501   gchar *safe_cfilter_error_msg;
502   interface_options interface_opts;
503
504   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture filter error message from child: \"%s\"", error_message);
505
506   g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING);
507   g_assert(i < capture_opts->ifaces->len);
508
509   interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
510   safe_cfilter = simple_dialog_format_message(interface_opts.cfilter);
511   safe_descr = simple_dialog_format_message(interface_opts.descr);
512   safe_cfilter_error_msg = simple_dialog_format_message(error_message);
513   /* Did the user try a display filter? */
514   if (dfilter_compile(interface_opts.cfilter, &rfcode) && rfcode != NULL) {
515     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
516       "%sInvalid capture filter \"%s\" for interface %s!%s\n"
517       "\n"
518       "That string looks like a valid display filter; however, it isn't a valid\n"
519       "capture filter (%s).\n"
520       "\n"
521       "Note that display filters and capture filters don't have the same syntax,\n"
522       "so you can't use most display filter expressions as capture filters.\n"
523       "\n"
524       "See the User's Guide for a description of the capture filter syntax.",
525       simple_dialog_primary_start(), safe_cfilter, safe_descr,
526       simple_dialog_primary_end(), safe_cfilter_error_msg);
527       dfilter_free(rfcode);
528   } else {
529     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
530       "%sInvalid capture filter \"%s\" for interface %s!%s\n"
531       "\n"
532       "That string isn't a valid capture filter (%s).\n"
533       "See the User's Guide for a description of the capture filter syntax.",
534       simple_dialog_primary_start(), safe_cfilter, safe_descr,
535       simple_dialog_primary_end(), safe_cfilter_error_msg);
536   }
537   g_free(safe_cfilter_error_msg);
538   g_free(safe_descr);
539   g_free(safe_cfilter);
540
541   /* the capture child will close the sync_pipe if required, nothing to do for now */
542 }
543
544
545 /* capture child closed its side of the pipe, do the required cleanup */
546 void
547 capture_input_closed(capture_options *capture_opts, gchar *msg)
548 {
549     int  err;
550     int  packet_count_save;
551
552     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture stopped!");
553     g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING);
554
555     if (msg != NULL)
556         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", msg);
557
558     /* if we didn't start the capture, do a fake start. */
559     /* (happens if we got an error message - we won't get a filename then). */
560     if(capture_opts->state == CAPTURE_PREPARING) {
561         if(capture_opts->real_time_mode) {
562             capture_callback_invoke(capture_cb_capture_update_started, capture_opts);
563         } else {
564             capture_callback_invoke(capture_cb_capture_fixed_started, capture_opts);
565         }
566     }
567
568     if(capture_opts->real_time_mode) {
569         cf_read_status_t status;
570
571         /* Read what remains of the capture file. */
572         status = cf_finish_tail(capture_opts->cf, &err);
573
574         /* XXX: If -Q (quit-after-cap) then cf->count clr'd below so save it first */
575         packet_count_save = cf_get_packet_count(capture_opts->cf);
576         /* Tell the GUI we are not doing a capture any more.
577            Must be done after the cf_finish_tail(), so file lengths are 
578            correctly displayed */
579         capture_callback_invoke(capture_cb_capture_update_finished, capture_opts);
580
581         /* Finish the capture. */
582         switch (status) {
583
584         case CF_READ_OK:
585             if ((packet_count_save == 0) && !capture_opts->restart) {
586                 simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
587 "%sNo packets captured!%s\n"
588 "\n"
589 "As no data was captured, closing the %scapture file!\n"
590 "\n"
591 "\n"
592 "Help about capturing can be found at:\n"
593 "\n"
594 "       http://wiki.wireshark.org/CaptureSetup"
595 #ifdef _WIN32
596 "\n\n"
597 "Wireless (Wi-Fi/WLAN):\n"
598 "Try to switch off promiscuous mode in the Capture Options!"
599 #endif
600 "",
601               simple_dialog_primary_start(), simple_dialog_primary_end(),
602               cf_is_tempfile(capture_opts->cf) ? "temporary " : "");
603               cf_close(capture_opts->cf);
604             }
605             break;
606         case CF_READ_ERROR:
607           /* Just because we got an error, that doesn't mean we were unable
608              to read any of the file; we handle what we could get from the
609              file. */
610           break;
611
612         case CF_READ_ABORTED:
613           /* Exit by leaving the main loop, so that any quit functions
614              we registered get called. */
615           main_window_quit();
616           break;
617         }
618
619     } else {
620         /* first of all, we are not doing a capture any more */
621         capture_callback_invoke(capture_cb_capture_fixed_finished, capture_opts);
622
623         /* this is a normal mode capture and if no error happened, read in the capture file data */
624         if(capture_opts->save_file != NULL) {
625             capture_input_read_all(capture_opts, cf_is_tempfile(capture_opts->cf),
626                 cf_get_drops_known(capture_opts->cf), cf_get_drops(capture_opts->cf));
627         }
628     }
629
630     if(capture_opts->show_info)
631       capture_info_close();
632
633     capture_opts->state = CAPTURE_STOPPED;
634
635     /* if we couldn't open a capture file, there's nothing more for us to do */
636     if(capture_opts->save_file == NULL) {
637         cf_close(capture_opts->cf);
638         return;
639     }
640
641     /* does the user wants to restart the current capture? */
642     if(capture_opts->restart) {
643         capture_opts->restart = FALSE;
644
645         ws_unlink(capture_opts->save_file);
646
647         /* if it was a tempfile, throw away the old filename (so it will become a tempfile again) */
648         if(cf_is_tempfile(capture_opts->cf)) {
649             g_free(capture_opts->save_file);
650             capture_opts->save_file = NULL;
651         }
652
653         /* ... and start the capture again */
654         capture_start(capture_opts);
655     } else {
656         /* We're not doing a capture any more, so we don't have a save file. */
657         g_free(capture_opts->save_file);
658         capture_opts->save_file = NULL;
659     }
660 }
661
662 if_stat_cache_t *
663 capture_stat_start(GList *if_list) {
664     int stat_fd, fork_child;
665     gchar *msg;
666     if_stat_cache_t *sc = NULL;
667     GList *if_entry;
668     if_info_t *if_info;
669     if_stat_cache_item_t *sc_item;
670
671     /* Fire up dumpcap. */
672     /*
673      * XXX - on systems with BPF, the number of BPF devices limits the
674      * number of devices on which you can capture simultaneously.
675      *
676      * This means that
677      *
678      *    1) this might fail if you run out of BPF devices
679      *
680      * and
681      *
682      *    2) opening every interface could leave too few BPF devices
683      *       for *other* programs.
684      *
685      * It also means the system could end up getting a lot of traffic
686      * that it has to pass through the networking stack and capture
687      * mechanism, so opening all the devices and presenting packet
688      * counts might not always be a good idea.
689      */
690      if (sync_interface_stats_open(&stat_fd, &fork_child, &msg) == 0) {
691         sc = g_malloc(sizeof(if_stat_cache_t));
692         sc->stat_fd = stat_fd;
693         sc->fork_child = fork_child;
694         sc->cache_list = NULL;
695
696         /* Initialize the cache */
697         for (if_entry = if_list; if_entry != NULL; if_entry = g_list_next(if_entry)) {
698             if_info = if_entry->data;
699             if (if_info) {
700                 sc_item = g_malloc0(sizeof(if_stat_cache_item_t));
701                 sc_item->name = g_strdup(if_info->name);
702                 sc->cache_list = g_list_append(sc->cache_list, sc_item);
703             }
704         }
705     }
706     return sc;
707 }
708
709 #define MAX_STAT_LINE_LEN 500
710
711 static void
712 capture_stat_cache_update(if_stat_cache_t *sc) {
713     gchar stat_line[MAX_STAT_LINE_LEN];
714     gchar **stat_parts;
715     GList *sc_entry;
716     if_stat_cache_item_t *sc_item;
717
718     if (!sc)
719         return;
720
721     while (sync_pipe_gets_nonblock(sc->stat_fd, stat_line, MAX_STAT_LINE_LEN) > 0) {
722         g_strstrip(stat_line);
723         stat_parts = g_strsplit(stat_line, "\t", 3);
724         if (stat_parts[0] == NULL || stat_parts[1] == NULL ||
725             stat_parts[2] == NULL) {
726             g_strfreev(stat_parts);
727             continue;
728         }
729         for (sc_entry = sc->cache_list; sc_entry != NULL; sc_entry = g_list_next(sc_entry)) {
730             sc_item = sc_entry->data;
731             if (strcmp(sc_item->name, stat_parts[0]) == 0) {
732                 sc_item->ps.ps_recv = (u_int) strtoul(stat_parts[1], NULL, 10);
733                 sc_item->ps.ps_drop = (u_int) strtoul(stat_parts[2], NULL, 10);
734             }
735         }
736         g_strfreev(stat_parts);
737     }
738 }
739
740 gboolean
741 capture_stats(if_stat_cache_t *sc, char *ifname, struct pcap_stat *ps) {
742     GList *sc_entry;
743     if_stat_cache_item_t *sc_item;
744
745     if (!sc || !ifname || !ps) {
746         return FALSE;
747     }
748
749     capture_stat_cache_update(sc);
750     for (sc_entry = sc->cache_list; sc_entry != NULL; sc_entry = g_list_next(sc_entry)) {
751         sc_item = sc_entry->data;
752         if (strcmp(sc_item->name, ifname) == 0) {
753             memcpy(ps, &sc_item->ps, sizeof(struct pcap_stat));
754             return TRUE;
755         }
756     }
757     return FALSE;
758 }
759
760 void
761 capture_stat_stop(if_stat_cache_t *sc) {
762     GList *sc_entry;
763     if_stat_cache_item_t *sc_item;
764     int ret;
765     gchar *msg;
766
767     if (!sc)
768         return;
769
770     ret = sync_interface_stats_close(&sc->stat_fd, &sc->fork_child, &msg);
771     if (ret == -1) {
772         /* XXX - report failure? */
773         g_free(msg);
774     }
775
776     for (sc_entry = sc->cache_list; sc_entry != NULL; sc_entry = g_list_next(sc_entry)) {
777         sc_item = sc_entry->data;
778         g_free(sc_item->name);
779         g_free(sc_item);
780     }
781     g_free(sc);
782 }
783
784 #endif /* HAVE_LIBPCAP */