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