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