epan/packet.h

   1 /* packet.h
   2  * Definitions for packet disassembly structures and routines
   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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  23  */
  24
  25 #ifndef __PACKET_H__
  26 #define __PACKET_H__
  27
  28 #include "wiretap/wtap.h"
  29 #include "proto.h"
  30 #include "tvbuff.h"
  31 #include "wsutil/pint.h"
  32 #include "to_str.h"
  33 #include "value_string.h"
  34 #include "column_info.h"
  35 #include "frame_data.h"
  36 #include "packet_info.h"
  37 #include "column-utils.h"
  38 #include "epan.h"
  39 #include "tfs.h"
  40 #include "ws_symbol_export.h"
  41 #include "range.h"
  42
  43 #ifdef __cplusplus
  44 extern "C" {
  45 #endif /* __cplusplus */
  46
  47 /** @defgroup packet General Packet Dissection
  48  *
  49  * @{
  50  */
  51
  52 #define hi_nibble(b) (((b) & 0xf0) >> 4)
  53 #define lo_nibble(b) ((b) & 0x0f)
  54
  55 /* Useful when you have an array whose size you can tell at compile-time */
  56 #define array_length(x) (sizeof x / sizeof x[0])
  57
  58 /* Check whether the "len" bytes of data starting at "offset" is
  59  * entirely inside the captured data for this packet. */
  60 #define BYTES_ARE_IN_FRAME(offset, captured_len, len) \
  61         ((guint)(offset) + (guint)(len) > (guint)(offset) && \
  62          (guint)(offset) + (guint)(len) <= (guint)(captured_len))
  63
  64 /* To pass one of two strings, singular or plural */
  65 #define plurality(d,s,p) ((d) == 1 ? (s) : (p))
  66
  67 typedef struct _packet_counts {
  68   gint           sctp;
  69   gint           tcp;
  70   gint           udp;
  71   gint           icmp;
  72   gint           ospf;
  73   gint           gre;
  74   gint           netbios;
  75   gint           ipx;
  76   gint           vines;
  77   gint           other;
  78   gint           total;
  79   gint           arp;
  80   gint           i2c_event;
  81   gint           i2c_data;
  82 } packet_counts;
  83
  84 /** Number of packet counts. */
  85 #define PACKET_COUNTS_SIZE sizeof(packet_counts) / sizeof (gint)
  86
  87 extern void packet_init(void);
  88 extern void packet_cache_proto_handles(void);
  89 extern void packet_cleanup(void);
  90
  91 /* Handle for dissectors you call directly or register with "dissector_add_uint()".
  92    This handle is opaque outside of "packet.c". */
  93 struct dissector_handle;
  94 typedef struct dissector_handle *dissector_handle_t;
  95
  96 /* Hash table for matching unsigned integers, or strings, and dissectors;
  97    this is opaque outside of "packet.c". */
  98 struct dissector_table;
  99 typedef struct dissector_table *dissector_table_t;
 100
 101 /*
 102  * Dissector that returns nothing.
 103  */
 104 typedef void (*dissector_t)(tvbuff_t *, packet_info *, proto_tree *);
 105
 106 /*
 107  * Dissector that returns:
 108  *
 109  *      The amount of data in the protocol's PDU, if it was able to
 110  *      dissect all the data;
 111  *
 112  *      0, if the tvbuff doesn't contain a PDU for that protocol;
 113  *
 114  *      The negative of the amount of additional data needed, if
 115  *      we need more data (e.g., from subsequent TCP segments) to
 116  *      dissect the entire PDU.
 117  */
 118 typedef int (*new_dissector_t)(tvbuff_t *, packet_info *, proto_tree *, void *);
 119
 120 /** Type of a heuristic dissector, used in heur_dissector_add().
 121  *
 122  * @param tvb the tvbuff with the (remaining) packet data
 123  * @param pinfo the packet info of this packet (additional info)
 124  * @param tree the protocol tree to be build or NULL
 125  * @return TRUE if the packet was recognized by the sub-dissector (stop dissection here)
 126  */
 127 typedef gboolean (*heur_dissector_t)(tvbuff_t *tvb, packet_info *pinfo,
 128         proto_tree *tree, void *);
 129
 130 typedef void (*DATFunc) (const gchar *table_name, ftenum_t selector_type,
 131     gpointer key, gpointer value, gpointer user_data);
 132 typedef void (*DATFunc_handle) (const gchar *table_name, gpointer value,
 133     gpointer user_data);
 134 typedef void (*DATFunc_table) (const gchar *table_name, const gchar *ui_name,
 135     gpointer user_data);
 136
 137 typedef void (*DATFunc_heur_table) (const gchar *table_name,gpointer table,
 138     gpointer user_data);
 139
 140 /* Opaque structure - provides type checking but no access to components */
 141 typedef struct dtbl_entry dtbl_entry_t;
 142
 143 WS_DLL_PUBLIC dissector_handle_t dtbl_entry_get_handle (dtbl_entry_t *dtbl_entry);
 144 WS_DLL_PUBLIC dissector_handle_t dtbl_entry_get_initial_handle (dtbl_entry_t * entry);
 145 void dissector_table_foreach_changed (const char *name, DATFunc func,
 146     gpointer user_data);
 147 WS_DLL_PUBLIC void dissector_table_foreach (const char *name, DATFunc func,
 148     gpointer user_data);
 149 WS_DLL_PUBLIC void dissector_all_tables_foreach_changed (DATFunc func,
 150     gpointer user_data);
 151 WS_DLL_PUBLIC void dissector_table_foreach_handle(const char *name, DATFunc_handle func,
 152     gpointer user_data);
 153 WS_DLL_PUBLIC void dissector_all_tables_foreach_table (DATFunc_table func,
 154     gpointer user_data, GCompareFunc compare_key_func);
 155
 156 /* a protocol uses the function to register a sub-dissector table */
 157 WS_DLL_PUBLIC dissector_table_t register_dissector_table(const char *name,
 158     const char *ui_name, const ftenum_t type, const int base);
 159
 160 /* Find a dissector table by table name. */
 161 WS_DLL_PUBLIC dissector_table_t find_dissector_table(const char *name);
 162
 163 /* Get the UI name for a sub-dissector table, given its internal name */
 164 WS_DLL_PUBLIC const char *get_dissector_table_ui_name(const char *name);
 165
 166 /* Get the field type for values of the selector for a dissector table,
 167    given the table's internal name */
 168 WS_DLL_PUBLIC ftenum_t get_dissector_table_selector_type(const char *name);
 169
 170 /* Get the base to use when displaying values of the selector for a
 171    sub-dissector table, given the table's internal name */
 172 WS_DLL_PUBLIC int get_dissector_table_base(const char *name);
 173
 174 /* Add an entry to a uint dissector table. */
 175 WS_DLL_PUBLIC void dissector_add_uint(const char *abbrev, const guint32 pattern,
 176     dissector_handle_t handle);
 177
 178 /* Add an range of entries to a uint dissector table. */
 179 WS_DLL_PUBLIC void dissector_add_uint_range(const char *abbrev, range_t *range,
 180     dissector_handle_t handle);
 181
 182 /* Delete the entry for a dissector in a uint dissector table
 183    with a particular pattern. */
 184 WS_DLL_PUBLIC void dissector_delete_uint(const char *name, const guint32 pattern,
 185     dissector_handle_t handle);
 186
 187 /* Delete an range of entries from a uint dissector table. */
 188 WS_DLL_PUBLIC void dissector_delete_uint_range(const char *abbrev, range_t *range,
 189     dissector_handle_t handle);
 190
 191 /* Delete all entries from a dissector table. */
 192 WS_DLL_PUBLIC void dissector_delete_all(const char *name, dissector_handle_t handle);
 193
 194 /* Change the entry for a dissector in a uint dissector table
 195    with a particular pattern to use a new dissector handle. */
 196 WS_DLL_PUBLIC void dissector_change_uint(const char *abbrev, const guint32 pattern,
 197     dissector_handle_t handle);
 198
 199 /* Reset an entry in a uint dissector table to its initial value. */
 200 WS_DLL_PUBLIC void dissector_reset_uint(const char *name, const guint32 pattern);
 201
 202 /* Look for a given value in a given uint dissector table and, if found,
 203    call the dissector with the arguments supplied, and return TRUE,
 204    otherwise return FALSE. */
 205 WS_DLL_PUBLIC gboolean dissector_try_uint(dissector_table_t sub_dissectors,
 206     const guint32 uint_val, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 207
 208 /* Look for a given value in a given uint dissector table and, if found,
 209    call the dissector with the arguments supplied, and return TRUE,
 210    otherwise return FALSE. */
 211 gboolean dissector_try_uint_new(dissector_table_t sub_dissectors,
 212         const guint32 uint_val, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const gboolean add_proto_name, void *data);
 213
 214 /* Look for a given value in a given uint dissector table and, if found,
 215    return the dissector handle for that value. */
 216 WS_DLL_PUBLIC dissector_handle_t dissector_get_uint_handle(
 217     dissector_table_t const sub_dissectors, const guint32 uint_val);
 218
 219 /* Add an entry to a string dissector table. */
 220 WS_DLL_PUBLIC void dissector_add_string(const char *name, const gchar *pattern,
 221     dissector_handle_t handle);
 222
 223 /* Delete the entry for a dissector in a string dissector table
 224    with a particular pattern. */
 225 WS_DLL_PUBLIC void dissector_delete_string(const char *name, const gchar *pattern,
 226         dissector_handle_t handle);
 227
 228 /* Change the entry for a dissector in a string dissector table
 229    with a particular pattern to use a new dissector handle. */
 230 WS_DLL_PUBLIC void dissector_change_string(const char *name, const gchar *pattern,
 231     dissector_handle_t handle);
 232
 233 /* Reset an entry in a string sub-dissector table to its initial value. */
 234 WS_DLL_PUBLIC void dissector_reset_string(const char *name, const gchar *pattern);
 235
 236 /* Look for a given string in a given dissector table and, if found, call
 237    the dissector with the arguments supplied, and return TRUE, otherwise
 238    return FALSE. */
 239 WS_DLL_PUBLIC gboolean dissector_try_string(dissector_table_t sub_dissectors,
 240     const gchar *string, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 241
 242 /* Look for a given value in a given string dissector table and, if found,
 243    return the dissector handle for that value. */
 244 WS_DLL_PUBLIC dissector_handle_t dissector_get_string_handle(
 245     dissector_table_t sub_dissectors, const gchar *string);
 246
 247 /* Add a handle to the list of handles that *could* be used with this
 248    table.  That list is used by code in the UI. */
 249 WS_DLL_PUBLIC void dissector_add_handle(const char *name, dissector_handle_t handle);
 250
 251 /* List of "heuristic" dissectors (which get handed a packet, look at it,
 252    and either recognize it as being for their protocol, dissect it, and
 253    return TRUE, or don't recognize it and return FALSE) to be called
 254    by another dissector. */
 255 typedef GSList *heur_dissector_list_t;
 256
 257
 258 typedef struct {
 259         heur_dissector_t dissector;
 260         protocol_t *protocol;
 261         gboolean enabled;
 262 } heur_dtbl_entry_t;
 263
 264 /** A protocol uses this function to register a heuristic sub-dissector list.
 265  *  Call this in the parent dissectors proto_register function.
 266  *
 267  * @param name the name of this protocol
 268  * @param list the list of heuristic sub-dissectors to be registered
 269  */
 270 WS_DLL_PUBLIC void register_heur_dissector_list(const char *name,
 271     heur_dissector_list_t *list);
 272
 273 WS_DLL_PUBLIC void dissector_all_heur_tables_foreach_table (DATFunc_heur_table func,
 274     gpointer user_data);
 275
 276 /** Try all the dissectors in a given heuristic dissector list. This is done,
 277  *  until we find one that recognizes the protocol.
 278  *  Call this while the parent dissector running.
 279  *
 280  * @param sub_dissectors the sub-dissector list
 281  * @param tvb the tvbuff with the (remaining) packet data
 282  * @param pinfo the packet info of this packet (additional info)
 283  * @param tree the protocol tree to be build or NULL
 284  * @param data parameter to pass to subdissector
 285  * @return TRUE if the packet was recognized by the sub-dissector (stop dissection here)
 286  */
 287 WS_DLL_PUBLIC gboolean dissector_try_heuristic(heur_dissector_list_t sub_dissectors,
 288     tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data);
 289
 290 /** Add a sub-dissector to a heuristic dissector list.
 291  *  Call this in the proto_handoff function of the sub-dissector.
 292  *
 293  * @param name the name of the "parent" protocol, e.g. "tcp"
 294  * @param dissector the sub-dissector to be registered
 295  * @param proto the protocol id of the sub-dissector
 296  */
 297 WS_DLL_PUBLIC void heur_dissector_add(const char *name, heur_dissector_t dissector,
 298     const int proto);
 299
 300 /** Remove a sub-dissector from a heuristic dissector list.
 301  *  Call this in the prefs_reinit function of the sub-dissector.
 302  *
 303  * @param name the name of the "parent" protocol, e.g. "tcp"
 304  * @param dissector the sub-dissector to be unregistered
 305  * @param proto the protocol id of the sub-dissector
 306  */
 307 WS_DLL_PUBLIC void heur_dissector_delete(const char *name, heur_dissector_t dissector, const int proto);
 308
 309 /** Enable/Disable a sub-dissector in a heuristic dissector list
 310  *  Call this in the prefs_reinit function of the sub-dissector.
 311  *
 312  * @param name the name of the "parent" protocol, e.g. "tcp"
 313  * @param dissector the sub-dissector to be disabled/enabled
 314  * @param proto the protocol id of the sub-dissector
 315  * @param enabled TRUE/FALSE to enable/disable the sub-dissector
 316  */
 317 extern void heur_dissector_set_enabled(const char *name, heur_dissector_t dissector, const int proto, const gboolean enabled);
 318
 319 /* Register a dissector. */
 320 WS_DLL_PUBLIC dissector_handle_t register_dissector(const char *name, dissector_t dissector,
 321     const int proto);
 322 WS_DLL_PUBLIC dissector_handle_t new_register_dissector(const char *name, new_dissector_t dissector,
 323     const int proto);
 324
 325 /* Get the long name of the protocol for a dissector handle. */
 326 extern const char *dissector_handle_get_long_name(const dissector_handle_t handle);
 327
 328 /* Get the short name of the protocol for a dissector handle. */
 329 WS_DLL_PUBLIC const char *dissector_handle_get_short_name(const dissector_handle_t handle);
 330
 331 /* Get the index of the protocol for a dissector handle. */
 332 WS_DLL_PUBLIC int dissector_handle_get_protocol_index(const dissector_handle_t handle);
 333
 334 /* Find a dissector by name. */
 335 WS_DLL_PUBLIC dissector_handle_t find_dissector(const char *name);
 336
 337 /* Get a dissector name from handle. */
 338 WS_DLL_PUBLIC const char *dissector_handle_get_dissector_name(const dissector_handle_t handle);
 339
 340 /* Create an anonymous handle for a dissector. */
 341 WS_DLL_PUBLIC dissector_handle_t create_dissector_handle(dissector_t dissector,
 342     const int proto);
 343 WS_DLL_PUBLIC dissector_handle_t new_create_dissector_handle(new_dissector_t dissector,
 344     const int proto);
 345
 346 /* Call a dissector through a handle and if no dissector was found
 347  * pass it over to the "data" dissector instead.
 348  *
 349  *   @param handle The dissector to call.
 350  *   @param  tvb The buffer to dissect.
 351  *   @param  pinfo Packet Info.
 352  *   @param  tree The protocol tree.
 353  *   @param  data parameter to pass to dissector
 354  *   @return  If the protocol for that handle isn't enabled call the data
 355  *   dissector. Otherwise, if the handle refers to a new-style
 356  *   dissector, call the dissector and return its return value, otherwise call
 357  *   it and return the length of the tvbuff pointed to by the argument.
 358  */
 359 WS_DLL_PUBLIC int call_dissector_with_data(dissector_handle_t handle, tvbuff_t *tvb,
 360     packet_info *pinfo, proto_tree *tree, void *data);
 361 WS_DLL_PUBLIC int call_dissector(dissector_handle_t handle, tvbuff_t *tvb,
 362     packet_info *pinfo, proto_tree *tree);
 363
 364 /* Call a dissector through a handle but if no dissector was found
 365  * just return 0 and do not call the "data" dissector instead.
 366  *
 367  *   @param handle The dissector to call.
 368  *   @param  tvb The buffer to dissect.
 369  *   @param  pinfo Packet Info.
 370  *   @param  tree The protocol tree.
 371  *   @param  data parameter to pass to dissector
 372  *   @return  If the protocol for that handle isn't enabled, return 0 without
 373  *   calling the dissector. Otherwise, if the handle refers to a new-style
 374  *   dissector, call the dissector and return its return value, otherwise call
 375  *   it and return the length of the tvbuff pointed to by the argument.
 376  */
 377 WS_DLL_PUBLIC int call_dissector_only(dissector_handle_t handle, tvbuff_t *tvb,
 378     packet_info *pinfo, proto_tree *tree, void *data);
 379
 380 /* Do all one-time initialization. */
 381 extern void dissect_init(void);
 382
 383 extern void dissect_cleanup(void);
 384
 385 /*
 386  * Given a tvbuff, and a length from a packet header, adjust the length
 387  * of the tvbuff to reflect the specified length.
 388  */
 389 WS_DLL_PUBLIC void set_actual_length(tvbuff_t *tvb, const guint specified_len);
 390
 391 /* Allow protocols to register "init" routines, which are called before
 392    we make a pass through a capture file and dissect all its packets
 393    (e.g., when we read in a new capture file, or run a "filter packets"
 394    or "colorize packets" pass over the current capture file). */
 395 WS_DLL_PUBLIC void register_init_routine(void (*func)(void));
 396
 397 /* Initialize all data structures used for dissection. */
 398 void init_dissection(void);
 399
 400 /* Free data structures allocated for dissection. */
 401 void cleanup_dissection(void);
 402
 403 /* Allow protocols to register a "cleanup" routine to be
 404  * run after the initial sequential run through the packets.
 405  * Note that the file can still be open after this; this is not
 406  * the final cleanup. */
 407 WS_DLL_PUBLIC void register_postseq_cleanup_routine(void (*func)(void));
 408
 409 /* Call all the registered "postseq_cleanup" routines. */
 410 WS_DLL_PUBLIC void postseq_cleanup_all_protocols(void);
 411
 412 /* Allow dissectors to register a "final_registration" routine
 413  * that is run like the proto_register_XXX() routine, but the end
 414  * end of the epan_init() function; that is, *after* all other
 415  * subsystems, liked dfilters, have finished initializing. This is
 416  * useful for dissector registration routines which need to compile
 417  * display filters. dfilters can't initialize itself until all protocols
 418  * have registereed themselvs. */
 419 WS_DLL_PUBLIC void
 420 register_final_registration_routine(void (*func)(void));
 421
 422 /* Call all the registered "final_registration" routines. */
 423 extern void
 424 final_registration_all_protocols(void);
 425
 426 /*
 427  * Add a new data source to the list of data sources for a frame, given
 428  * the tvbuff for the data source and its name.
 429  */
 430 WS_DLL_PUBLIC void add_new_data_source(packet_info *pinfo, tvbuff_t *tvb,
 431     const char *name);
 432
 433
 434 /*
 435  * Return the data source name, tvb.
 436  */
 437 struct data_source;
 438 WS_DLL_PUBLIC const char *get_data_source_name(const struct data_source *src);
 439 WS_DLL_PUBLIC tvbuff_t *get_data_source_tvb(const struct data_source *src);
 440
 441 /*
 442  * Free up a frame's list of data sources.
 443  */
 444 extern void free_data_sources(packet_info *pinfo);
 445
 446 /* Mark another frame as depended upon by the current frame.
 447  *
 448  * This information is used to ensure that the dependend-upon frame is saved
 449  * if the user does a File->Save-As of only the Displayed packets and the
 450  * current frame passed the display filter.
 451  */
 452 WS_DLL_PUBLIC void mark_frame_as_depended_upon(packet_info *pinfo, guint32 frame_num);
 453
 454 /*
 455  * Dissectors should never modify the packet data.
 456  */
 457 extern void dissect_packet(epan_dissect_t *edt,
 458     struct wtap_pkthdr *phdr, tvbuff_t *tvb,
 459     frame_data *fd, column_info *cinfo);
 460
 461 /* These functions are in packet-ethertype.c */
 462 extern void capture_ethertype(guint16 etype, const guchar *pd, int offset,
 463                 int len, packet_counts *ld);
 464 WS_DLL_PUBLIC void ethertype(guint16 etype, tvbuff_t *tvb, int offset_after_ethertype,
 465                 packet_info *pinfo, proto_tree *tree, proto_tree *fh_tree,
 466                 int etype_id, int trailer_id, int fcs_len);
 467
 468 /*
 469  * Dump layer/selector/dissector records in a fashion similar to the
 470  * proto_registrar_dump_* routines.
 471  */
 472 WS_DLL_PUBLIC void dissector_dump_decodes(void);
 473
 474 /*
 475  * For each heuristic dissector table, dump list of dissectors (filter_names) for that table
 476  */
 477 WS_DLL_PUBLIC void dissector_dump_heur_decodes(void);
 478
 479 /*
 480  * post dissectors are to be called by packet-frame.c after every other
 481  * dissector has been called.
 482  */
 483 WS_DLL_PUBLIC void register_postdissector(dissector_handle_t);
 484 extern gboolean have_postdissector(void);
 485 extern void call_all_postdissectors(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 486
 487 /** @} */
 488
 489 #ifdef __cplusplus
 490 }
 491 #endif /* __cplusplus */
 492
 493 #endif /* packet.h */