file.h

   1 /* file.h
   2  * Definitions for file structures and routines
   3  *
   4  * Wireshark - Network traffic analyzer
   5  * By Gerald Combs <gerald@wireshark.org>
   6  * Copyright 1998 Gerald Combs
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #ifndef __FILE_H__
  24 #define __FILE_H__
  25
  26 #include "wiretap/wtap.h"
  27 #include <errno.h>
  28 #include <epan/epan.h>
  29
  30 #include <epan/print.h>
  31 #include <epan/packet-range.h>
  32
  33 #ifdef __cplusplus
  34 extern "C" {
  35 #endif /* __cplusplus */
  36
  37 /** Return values from functions that only can succeed or fail. */
  38 typedef enum {
  39     CF_OK,      /**< operation succeeded */
  40     CF_ERROR    /**< operation got an error (function may provide err with details) */
  41 } cf_status_t;
  42
  43 /** Return values from functions that read capture files. */
  44 typedef enum {
  45     CF_READ_OK,      /**< operation succeeded */
  46     CF_READ_ERROR,   /**< operation got an error (function may provide err with details) */
  47     CF_READ_ABORTED  /**< operation aborted by user */
  48 } cf_read_status_t;
  49
  50 /** Return values from functions that write out packets. */
  51 typedef enum {
  52     CF_WRITE_OK,      /**< operation succeeded */
  53     CF_WRITE_ERROR,   /**< operation got an error (function may provide err with details) */
  54     CF_WRITE_ABORTED  /**< operation aborted by user */
  55 } cf_write_status_t;
  56
  57 /** Return values from functions that print sets of packets. */
  58 typedef enum {
  59     CF_PRINT_OK,            /**< print operation succeeded */
  60     CF_PRINT_OPEN_ERROR,    /**< print operation failed while opening printer */
  61     CF_PRINT_WRITE_ERROR    /**< print operation failed while writing to the printer */
  62 } cf_print_status_t;
  63
  64 typedef enum {
  65     cf_cb_file_opened,
  66     cf_cb_file_closing,
  67     cf_cb_file_closed,
  68     cf_cb_file_read_started,
  69     cf_cb_file_read_finished,
  70     cf_cb_file_reload_started,
  71     cf_cb_file_reload_finished,
  72     cf_cb_file_rescan_started,
  73     cf_cb_file_rescan_finished,
  74     cf_cb_file_retap_started,
  75     cf_cb_file_retap_finished,
  76     cf_cb_file_fast_save_finished,
  77     cf_cb_packet_selected,
  78     cf_cb_packet_unselected,
  79     cf_cb_field_unselected,
  80     cf_cb_file_save_started,
  81     cf_cb_file_save_finished,
  82     cf_cb_file_save_failed,
  83     cf_cb_file_save_stopped,
  84     cf_cb_file_export_specified_packets_started,
  85     cf_cb_file_export_specified_packets_finished,
  86     cf_cb_file_export_specified_packets_failed,
  87     cf_cb_file_export_specified_packets_stopped
  88 } cf_cbs;
  89
  90 typedef void (*cf_callback_t) (gint event, gpointer data, gpointer user_data);
  91
  92 typedef struct {
  93     const char    *string;
  94     size_t         string_len;
  95     capture_file  *cf;
  96     gboolean       frame_matched;
  97     field_info    *finfo;
  98 } match_data;
  99
 100 /**
 101  * Add a capture file event callback.
 102  *
 103  * @param func The function to be called for each event.
 104  *             The function will be passed three parameters: The event type (event),
 105  *             event-dependent data (data), and user-supplied data (user_data).
 106  *             Event-dependent data may be a capture_file pointer, character pointer,
 107  *             or NULL.
 108  * @param user_data User-supplied data to pass to the callback. May be NULL.
 109  */
 110
 111 extern void
 112 cf_callback_add(cf_callback_t func, gpointer user_data);
 113
 114 /**
 115  * Remove a capture file event callback.
 116  *
 117  * @param func The function to be removed.
 118  * @param user_data User-supplied data. Must be the same value supplied to cf_callback_add.
 119  */
 120
 121 extern void
 122 cf_callback_remove(cf_callback_t func, gpointer user_data);
 123
 124 /**
 125  * Open a capture file.
 126  *
 127  * @param cf the capture file to be opened
 128  * @param fname the filename to be opened
 129  * @param type WTAP_TYPE_AUTO for automatic or index to direct open routine
 130  * @param is_tempfile is this a temporary file?
 131  * @param err error code
 132  * @return one of cf_status_t
 133  */
 134 cf_status_t cf_open(capture_file *cf, const char *fname, unsigned int type, gboolean is_tempfile, int *err);
 135
 136 /**
 137  * Close a capture file.
 138  *
 139  * @param cf the capture file to be closed
 140  */
 141 void cf_close(capture_file *cf);
 142
 143 /**
 144  * Reload a capture file.
 145  *
 146  * @param cf the capture file to be reloaded
 147  */
 148 void cf_reload(capture_file *cf);
 149
 150 /**
 151  * Read all packets of a capture file into the internal structures.
 152  *
 153  * @param cf the capture file to be read
 154  * @param from_save reread asked from cf_save_records
 155  * @return one of cf_read_status_t
 156  */
 157 cf_read_status_t cf_read(capture_file *cf, gboolean from_save);
 158
 159 /**
 160  * Read the metadata and raw data for a record.  It will pop
 161  * up an alert box if there's an error.
 162  *
 163  * @param cf the capture file from which to read the record
 164  * @param fdata the frame_data structure for the record in question
 165  * @param phdr pointer to a wtap_pkthdr structure to contain the
 166  * record's metadata
 167  * @param buf a Buffer into which to read the record's raw data
 168  * @return TRUE if the read succeeded, FALSE if there was an error
 169  */
 170 gboolean cf_read_record_r(capture_file *cf, const frame_data *fdata,
 171                           struct wtap_pkthdr *phdr, Buffer *buf);
 172
 173 /**
 174  * Read the metadata and raw data for a record into a
 175  * capture_file structure's phdr and buf members.
 176  * It will pop up an alert box if there's an error.
 177  *
 178  * @param cf the capture file from which to read the record
 179  * @param fdata the frame_data structure for the record in question
 180  * @return TRUE if the read succeeded, FALSE if there was an error
 181  */
 182 gboolean cf_read_record(capture_file *cf, frame_data *fdata);
 183
 184 /**
 185  * Read packets from the "end" of a capture file.
 186  *
 187  * @param cf the capture file to be read from
 188  * @param to_read the number of packets to read
 189  * @param err the error code, if an error had occurred
 190  * @return one of cf_read_status_t
 191  */
 192 cf_read_status_t cf_continue_tail(capture_file *cf, volatile int to_read, int *err);
 193
 194 /**
 195  * Fake reading packets from the "end" of a capture file.
 196  *
 197  * @param cf the capture file to be read from
 198  */
 199 void cf_fake_continue_tail(capture_file *cf);
 200
 201 /**
 202  * Finish reading from "end" of a capture file.
 203  *
 204  * @param cf the capture file to be read from
 205  * @param err the error code, if an error had occurred
 206  * @return one of cf_read_status_t
 207  */
 208 cf_read_status_t cf_finish_tail(capture_file *cf, int *err);
 209
 210 /**
 211  * Determine whether this capture file (or a range of it) can be written
 212  * in any format using Wiretap rather than by copying the raw data.
 213  *
 214  * @param cf the capture file to check
 215  * @return TRUE if it can be written, FALSE if it can't
 216  */
 217 gboolean cf_can_write_with_wiretap(capture_file *cf);
 218
 219 /**
 220  * Determine whether this capture file can be saved with a "save" operation;
 221  * if there's nothing unsaved, it can't.
 222  *
 223  * @param cf the capture file to check
 224  * @return TRUE if it can be saved, FALSE if it can't
 225  */
 226 gboolean cf_can_save(capture_file *cf);
 227
 228 /**
 229  * Determine whether this capture file can be saved with a "save as" operation.
 230  *
 231  * @param cf the capture file to check
 232  * @return TRUE if it can be saved, FALSE if it can't
 233  */
 234 gboolean cf_can_save_as(capture_file *cf);
 235
 236 /**
 237  * Determine whether this capture file has unsaved data.
 238  *
 239  * @param cf the capture file to check
 240  * @return TRUE if it has unsaved data, FALSE if it doesn't
 241  */
 242 gboolean cf_has_unsaved_data(capture_file *cf);
 243
 244 /**
 245  * Save all packets in a capture file to a new file, and, if that succeeds,
 246  * make that file the current capture file.  If there's already a file with
 247  * that name, do a "safe save", writing to a temporary file in the same
 248  * directory and, if the write succeeds, renaming the new file on top of the
 249  * old file, so that if the write fails, the old file is still intact.
 250  *
 251  * @param cf the capture file to save to
 252  * @param fname the filename to save to
 253  * @param save_format the format of the file to save (libpcap, ...)
 254  * @param compressed whether to gzip compress the file
 255  * @param discard_comments TRUE if we should discard comments if the save
 256  * succeeds (because we saved in a format that doesn't support
 257  * comments)
 258  * @param dont_reopen TRUE if it shouldn't reopen and make that file the
 259  * current capture file
 260  * @return one of cf_write_status_t
 261  */
 262 cf_write_status_t cf_save_records(capture_file * cf, const char *fname,
 263                                   guint save_format, gboolean compressed,
 264                                   gboolean discard_comments,
 265                                   gboolean dont_reopen);
 266
 267 /**
 268  * Export some or all packets from a capture file to a new file.  If there's
 269  * already a file with that name, do a "safe save", writing to a temporary
 270  * file in the same directory and, if the write succeeds, renaming the new
 271  * file on top of the old file, so that if the write fails, the old file is
 272  * still intact.
 273  *
 274  * @param cf the capture file to write to
 275  * @param fname the filename to write to
 276  * @param range the range of packets to write
 277  * @param save_format the format of the file to write (libpcap, ...)
 278  * @param compressed whether to gzip compress the file
 279  * @return one of cf_write_status_t
 280  */
 281 cf_write_status_t cf_export_specified_packets(capture_file *cf,
 282                                               const char *fname,
 283                                               packet_range_t *range,
 284                                               guint save_format,
 285                                               gboolean compressed);
 286
 287 /**
 288  * Get a displayable name of the capture file.
 289  *
 290  * @param cf the capture file
 291  * @return the displayable name (must be g_free'd)
 292  */
 293 gchar *cf_get_display_name(capture_file *cf);
 294
 295 /**
 296  * Set the source of the capture data for temporary files, e.g.
 297  * "Interface eth0" or "Pipe from Pong"
 298  *
 299  * @param cf the capture file
 300  * @param source the source description. this will be copied internally.
 301  */
 302 void cf_set_tempfile_source(capture_file *cf, gchar *source);
 303
 304 /**
 305  * Get the source of the capture data for temporary files. Guaranteed to
 306  * return a non-null value. The returned value should not be freed.
 307  *
 308  * @param cf the capture file
 309  */
 310 const gchar *cf_get_tempfile_source(capture_file *cf);
 311
 312 /**
 313  * Get the number of packets in the capture file.
 314  *
 315  * @param cf the capture file
 316  * @return the number of packets in the capture file
 317  */
 318 int cf_get_packet_count(capture_file *cf);
 319
 320 /**
 321  * Is this capture file a temporary file?
 322  *
 323  * @param cf the capture file
 324  * @return TRUE if it's a temporary file, FALSE otherwise
 325  */
 326 gboolean cf_is_tempfile(capture_file *cf);
 327
 328 /**
 329  * Set flag, that this file is a tempfile.
 330  */
 331 void cf_set_tempfile(capture_file *cf, gboolean is_tempfile);
 332
 333 /**
 334  * Set flag, if the number of packet drops while capturing are known or not.
 335  *
 336  * @param cf the capture file
 337  * @param drops_known TRUE if the number of packet drops are known, FALSE otherwise
 338  */
 339 void cf_set_drops_known(capture_file *cf, gboolean drops_known);
 340
 341 /**
 342  * Set the number of packet drops while capturing.
 343  *
 344  * @param cf the capture file
 345  * @param drops the number of packet drops occurred while capturing
 346  */
 347 void cf_set_drops(capture_file *cf, guint32 drops);
 348
 349 /**
 350  * Get flag state, if the number of packet drops while capturing are known or not.
 351  *
 352  * @param cf the capture file
 353  * @return TRUE if the number of packet drops are known, FALSE otherwise
 354  */
 355 gboolean cf_get_drops_known(capture_file *cf);
 356
 357 /**
 358  * Get the number of packet drops while capturing.
 359  *
 360  * @param cf the capture file
 361  * @return the number of packet drops occurred while capturing
 362  */
 363 guint32 cf_get_drops(capture_file *cf);
 364
 365 /**
 366  * Set the read filter.
 367  * @todo this shouldn't be required, remove it somehow
 368  *
 369  * @param cf the capture file
 370  * @param rfcode the readfilter
 371  */
 372 void cf_set_rfcode(capture_file *cf, dfilter_t *rfcode);
 373
 374 /**
 375  * "Display Filter" packets in the capture file.
 376  *
 377  * @param cf the capture file
 378  * @param dfilter the display filter
 379  * @param force TRUE if do in any case, FALSE only if dfilter changed
 380  * @return one of cf_status_t
 381  */
 382 cf_status_t cf_filter_packets(capture_file *cf, gchar *dfilter, gboolean force);
 383
 384 /**
 385  * At least one "Refence Time" flag has changed, rescan all packets.
 386  *
 387  * @param cf the capture file
 388  */
 389 void cf_reftime_packets(capture_file *cf);
 390
 391 /**
 392  * Return the time it took to load the file
 393  */
 394 gulong cf_get_computed_elapsed(capture_file *cf);
 395
 396 /**
 397  * "Something" has changed, rescan all packets.
 398  *
 399  * @param cf the capture file
 400  */
 401 void cf_redissect_packets(capture_file *cf);
 402
 403 /**
 404  * Rescan all packets and just run taps - don't reconstruct the display.
 405  *
 406  * @param cf the capture file
 407  * @return one of cf_read_status_t
 408  */
 409 cf_read_status_t cf_retap_packets(capture_file *cf);
 410
 411 /**
 412  * Adjust timestamp precision if auto is selected.
 413  *
 414  * @param cf the capture file
 415  */
 416 void cf_timestamp_auto_precision(capture_file *cf);
 417
 418 /**
 419  * Print the capture file.
 420  *
 421  * @param cf the capture file
 422  * @param print_args the arguments what and how to print
 423  * @return one of cf_print_status_t
 424  */
 425 cf_print_status_t cf_print_packets(capture_file *cf, print_args_t *print_args);
 426
 427 /**
 428  * Print (export) the capture file into PDML format.
 429  *
 430  * @param cf the capture file
 431  * @param print_args the arguments what and how to export
 432  * @return one of cf_print_status_t
 433  */
 434 cf_print_status_t cf_write_pdml_packets(capture_file *cf, print_args_t *print_args);
 435
 436 /**
 437  * Print (export) the capture file into PSML format.
 438  *
 439  * @param cf the capture file
 440  * @param print_args the arguments what and how to export
 441  * @return one of cf_print_status_t
 442  */
 443 cf_print_status_t cf_write_psml_packets(capture_file *cf, print_args_t *print_args);
 444
 445 /**
 446  * Print (export) the capture file into CSV format.
 447  *
 448  * @param cf the capture file
 449  * @param print_args the arguments what and how to export
 450  * @return one of cf_print_status_t
 451  */
 452 cf_print_status_t cf_write_csv_packets(capture_file *cf, print_args_t *print_args);
 453
 454 /**
 455  * Print (export) the capture file into C Arrays format.
 456  *
 457  * @param cf the capture file
 458  * @param print_args the arguments what and how to export
 459  * @return one of cf_print_status_t
 460  */
 461 cf_print_status_t cf_write_carrays_packets(capture_file *cf, print_args_t *print_args);
 462
 463 /**
 464  * Find packet with a protocol tree item that contains a specified text string.
 465  *
 466  * @param cf the capture file
 467  * @param string the string to find
 468  * @param dir direction in which to search
 469  * @return TRUE if a packet was found, FALSE otherwise
 470  */
 471 gboolean cf_find_packet_protocol_tree(capture_file *cf, const char *string,
 472                                       search_direction dir);
 473
 474 /**
 475  * Find field with a label that contains text string cfile->sfilter.
 476  *
 477  * @param cf the capture file
 478  * @param tree the protocol tree
 479  * @param mdata the first field (mdata->finfo) that matched the string
 480  * @return TRUE if a packet was found, FALSE otherwise
 481  */
 482 extern gboolean cf_find_string_protocol_tree(capture_file *cf, proto_tree *tree,
 483                                              match_data *mdata);
 484
 485 /**
 486  * Find packet whose summary line contains a specified text string.
 487  *
 488  * @param cf the capture file
 489  * @param string the string to find
 490  * @param dir direction in which to search
 491  * @return TRUE if a packet was found, FALSE otherwise
 492  */
 493 gboolean cf_find_packet_summary_line(capture_file *cf, const char *string,
 494                                      search_direction dir);
 495
 496 /**
 497  * Find packet whose data contains a specified byte string.
 498  *
 499  * @param cf the capture file
 500  * @param string the string to find
 501  * @param string_size the size of the string to find
 502  * @param dir direction in which to search
 503  * @return TRUE if a packet was found, FALSE otherwise
 504  */
 505 gboolean cf_find_packet_data(capture_file *cf, const guint8 *string,
 506                              size_t string_size, search_direction dir);
 507
 508 /**
 509  * Find packet that matches a compiled display filter.
 510  *
 511  * @param cf the capture file
 512  * @param sfcode the display filter to match
 513  * @param dir direction in which to search
 514  * @return TRUE if a packet was found, FALSE otherwise
 515  */
 516 gboolean cf_find_packet_dfilter(capture_file *cf, dfilter_t *sfcode,
 517                                 search_direction dir);
 518
 519 /**
 520  * Find packet that matches a display filter given as a text string.
 521  *
 522  * @param cf the capture file
 523  * @param filter the display filter to match
 524  * @param dir direction in which to search
 525  * @return TRUE if a packet was found, FALSE otherwise
 526  */
 527 gboolean
 528 cf_find_packet_dfilter_string(capture_file *cf, const char *filter,
 529                               search_direction dir);
 530
 531 /**
 532  * Find marked packet.
 533  *
 534  * @param cf the capture file
 535  * @param dir direction in which to search
 536  * @return TRUE if a packet was found, FALSE otherwise
 537  */
 538 gboolean cf_find_packet_marked(capture_file *cf, search_direction dir);
 539
 540 /**
 541  * Find time-reference packet.
 542  *
 543  * @param cf the capture file
 544  * @param dir direction in which to search
 545  * @return TRUE if a packet was found, FALSE otherwise
 546  */
 547 gboolean cf_find_packet_time_reference(capture_file *cf, search_direction dir);
 548
 549 /**
 550  * GoTo Packet in first row.
 551  *
 552  * @return TRUE if the first row exists, FALSE otherwise
 553  */
 554 gboolean cf_goto_top_frame(void);
 555
 556 /**
 557  * GoTo Packet in last row.
 558  *
 559  * @return TRUE if last row exists, FALSE otherwise
 560  */
 561 gboolean cf_goto_bottom_frame(void);
 562
 563 /**
 564  * GoTo Packet with the given row.
 565  *
 566  * @param cf the capture file
 567  * @param row the row to go to
 568  * @return TRUE if this row exists, FALSE otherwise
 569  */
 570 gboolean cf_goto_frame(capture_file *cf, guint row);
 571
 572 /**
 573  * Go to frame specified by currently selected protocol tree field.
 574  * (Go To Corresponding Packet)
 575  * @todo this is ugly and should be improved!
 576  *
 577  * @param cf the capture file
 578  * @return TRUE if this packet exists, FALSE otherwise
 579  */
 580 gboolean cf_goto_framenum(capture_file *cf);
 581
 582 /**
 583  * Select the packet in the given row.
 584  *
 585  * @param cf the capture file
 586  * @param row the row to select
 587  */
 588 void cf_select_packet(capture_file *cf, int row);
 589
 590 /**
 591  * Unselect all packets, if any.
 592  *
 593  * @param cf the capture file
 594  */
 595 void cf_unselect_packet(capture_file *cf);
 596
 597 /**
 598  * Unselect all protocol tree fields, if any.
 599  *
 600  * @param cf the capture file
 601  */
 602 void cf_unselect_field(capture_file *cf);
 603
 604 /**
 605  * Mark a particular frame in a particular capture.
 606  *
 607  * @param cf the capture file
 608  * @param frame the frame to be marked
 609  */
 610 void cf_mark_frame(capture_file *cf, frame_data *frame);
 611
 612 /**
 613  * Unmark a particular frame in a particular capture.
 614  *
 615  * @param cf the capture file
 616  * @param frame the frame to be unmarked
 617  */
 618 void cf_unmark_frame(capture_file *cf, frame_data *frame);
 619
 620 /**
 621  * Ignore a particular frame in a particular capture.
 622  *
 623  * @param cf the capture file
 624  * @param frame the frame to be ignored
 625  */
 626 void cf_ignore_frame(capture_file *cf, frame_data *frame);
 627
 628 /**
 629  * Unignore a particular frame in a particular capture.
 630  *
 631  * @param cf the capture file
 632  * @param frame the frame to be unignored
 633  */
 634 void cf_unignore_frame(capture_file *cf, frame_data *frame);
 635
 636 /**
 637  * Merge two (or more) capture files into one.
 638  * @todo is this the right place for this function? It doesn't have to do a lot with capture_file.
 639  *
 640  * @param out_filename pointer to output filename; if output filename is
 641  * NULL, a temporary file name is generated and *out_filename is set
 642  * to point to the generated file name
 643  * @param in_file_count the number of input files to merge
 644  * @param in_filenames array of input filenames
 645  * @param file_type the output filetype
 646  * @param do_append FALSE to merge chronologically, TRUE simply append
 647  * @return one of cf_status_t
 648  */
 649 cf_status_t
 650 cf_merge_files(char **out_filename, int in_file_count,
 651                char *const *in_filenames, int file_type, gboolean do_append);
 652
 653
 654 /**
 655  * Get the comment on a capture from the SHB data block
 656  *
 657  * @param cf the capture file
 658  */
 659 const gchar* cf_read_shb_comment(capture_file *cf);
 660
 661 /**
 662  * Update(replace) the comment on a capture from the SHB data block
 663  *
 664  * @param cf the capture file
 665  * @param comment the string replacing the old comment
 666  */
 667 void cf_update_capture_comment(capture_file *cf, gchar *comment);
 668
 669 char *cf_get_comment(capture_file *cf, const frame_data *fd);
 670
 671 /**
 672  * Update(replace) the comment on a capture from a frame
 673  *
 674  * @param cf the capture file
 675  * @param fd the frame_data structure for the frame
 676  * @param new_comment the string replacing the old comment
 677  */
 678 gboolean cf_set_user_packet_comment(capture_file *cf, frame_data *fd, const gchar *new_comment);
 679
 680 /**
 681  * What types of comments does this file have?
 682  *
 683  * @param cf the capture file
 684  * @return bitset of WTAP_COMMENT_ values
 685  */
 686 guint32 cf_comment_types(capture_file *cf);
 687
 688 #ifdef WANT_PACKET_EDITOR
 689 /**
 690  * Give a frame new, edited data.
 691  *
 692  * @param cf the capture file
 693  * @param fd frame_data structure for the frame
 694  * @param phdr the struct wtap_pkthdr for the frame
 695  * @param pd the raw packet data for the frame
 696  */
 697 void cf_set_frame_edited(capture_file *cf, frame_data *fd, struct wtap_pkthdr *phdr, guint8 *pd);
 698 #endif
 699
 700 #ifdef __cplusplus
 701 }
 702 #endif /* __cplusplus */
 703
 704 #endif /* file.h */
 705
 706 /*
 707  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
 708  *
 709  * Local variables:
 710  * c-basic-offset: 4
 711  * tab-width: 8
 712  * indent-tabs-mode: nil
 713  * End:
 714  *
 715  * vi: set shiftwidth=4 tabstop=8 expandtab:
 716  * :indentSize=4:tabSize=8:noTabs=true:
 717  */