epan/packet.h

   1 /* packet.h
   2  * Definitions for packet disassembly structures and routines
   3  *
   4  * $Id$
   5  *
   6  * Ethereal - Network traffic analyzer
   7  * By Gerald Combs <gerald@ethereal.com>
   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 #ifndef __PACKET_H__
  26 #define __PACKET_H__
  27
  28 /*
  29  * If <inttypes.h> defines formats to be used to print 64-bit integers,
  30  * include it.
  31  */
  32 #ifdef INTTYPES_H_DEFINES_FORMATS
  33 #include <inttypes.h>
  34 #endif
  35
  36 #include "wiretap/wtap.h"
  37 #include "proto.h"
  38 #include "tvbuff.h"
  39 #include "pint.h"
  40 #include "to_str.h"
  41 #include "value_string.h"
  42 #include "column_info.h"
  43 #include "frame_data.h"
  44 #include "packet_info.h"
  45 #include "column-utils.h"
  46 #include "epan.h"
  47
  48 #define hi_nibble(b) (((b) & 0xf0) >> 4)
  49 #define lo_nibble(b) ((b) & 0x0f)
  50
  51 /* Useful when you have an array whose size you can tell at compile-time */
  52 #define array_length(x) (sizeof x / sizeof x[0])
  53
  54 /* Check whether the "len" bytes of data starting at "offset" is
  55  * entirely inside the captured data for this packet. */
  56 #define BYTES_ARE_IN_FRAME(offset, captured_len, len) \
  57         ((guint)(offset) + (guint)(len) > (guint)(offset) && \
  58          (guint)(offset) + (guint)(len) <= (guint)(captured_len))
  59
  60 /* To pass one of two strings, singular or plural */
  61 #define plurality(d,s,p) ((d) == 1 ? (s) : (p))
  62
  63 typedef struct _packet_counts {
  64   gint           sctp;
  65   gint           tcp;
  66   gint           udp;
  67   gint           icmp;
  68   gint           ospf;
  69   gint           gre;
  70   gint           netbios;
  71   gint           ipx;
  72   gint           vines;
  73   gint           other;
  74   gint           total;
  75   gint           arp;
  76 } packet_counts;
  77
  78 /* Types of character encodings */
  79 typedef enum {
  80         CHAR_ASCII       = 0,   /* ASCII */
  81         CHAR_EBCDIC      = 1    /* EBCDIC */
  82 } char_enc;
  83
  84 /* Struct for boolean enumerations */
  85 typedef struct true_false_string {
  86         char    *true_string;
  87         char    *false_string;
  88 } true_false_string;
  89
  90 extern const true_false_string flags_set_truth;
  91
  92 extern void packet_init(void);
  93 extern void packet_cleanup(void);
  94
  95 /* Handle for dissectors you call directly or register with "dissector_add()".
  96    This handle is opaque outside of "packet.c". */
  97 struct dissector_handle;
  98 typedef struct dissector_handle *dissector_handle_t;
  99
 100 /* Hash table for matching port numbers and dissectors; this is opaque
 101    outside of "packet.c". */
 102 struct dissector_table;
 103 typedef struct dissector_table *dissector_table_t;
 104
 105 /*
 106  * Dissector that returns nothing.
 107  */
 108 typedef void (*dissector_t)(tvbuff_t *, packet_info *, proto_tree *);
 109
 110 /*
 111  * Dissector that returns:
 112  *
 113  *      the amount of data in the protocol's PDU, if it was able to
 114  *      dissect all the data;
 115  *
 116  *      0, if the tvbuff doesn't contain a PDU for that protocol;
 117  *
 118  *      the negative of the amount of additional data needed, if
 119  *      we need more data (e.g., from subsequent TCP segments) to
 120  *      dissect the entire PDU.
 121  */
 122 typedef int (*new_dissector_t)(tvbuff_t *, packet_info *, proto_tree *);
 123
 124 typedef void (*DATFunc) (gchar *table_name, ftenum_t selector_type,
 125     gpointer key, gpointer value, gpointer user_data);
 126 typedef void (*DATFunc_handle) (gchar *table_name, gpointer value,
 127     gpointer user_data);
 128 typedef void (*DATFunc_table) (gchar *table_name, gchar *ui_name,
 129     gpointer user_data);
 130
 131 /* Opaque structure - provides type checking but no access to components */
 132 typedef struct dtbl_entry dtbl_entry_t;
 133
 134 extern dissector_handle_t dtbl_entry_get_handle (dtbl_entry_t *dtbl_entry);
 135 extern dissector_handle_t dtbl_entry_get_initial_handle (dtbl_entry_t * entry);
 136 extern void dissector_table_foreach_changed (char *name, DATFunc func,
 137     gpointer user_data);
 138 extern void dissector_table_foreach (char *name, DATFunc func,
 139     gpointer user_data);
 140 extern void dissector_all_tables_foreach_changed (DATFunc func,
 141     gpointer user_data);
 142 extern void dissector_table_foreach_handle(char *name, DATFunc_handle func,
 143     gpointer user_data);
 144 extern void dissector_all_tables_foreach_table (DATFunc_table func,
 145     gpointer user_data);
 146
 147 /* a protocol uses the function to register a sub-dissector table */
 148 extern dissector_table_t register_dissector_table(const char *name,
 149     char *ui_name, ftenum_t type, int base);
 150
 151 /* Find a dissector table by table name. */
 152 extern dissector_table_t find_dissector_table(const char *name);
 153
 154 /* Get the UI name for a sub-dissector table, given its internal name */
 155 extern char *get_dissector_table_ui_name(const char *name);
 156
 157 /* Get the field type for values of the selector for a dissector table,
 158    given the table's internal name */
 159 extern ftenum_t get_dissector_table_selector_type(const char *name);
 160
 161 /* Get the base to use when displaying values of the selector for a
 162    sub-dissector table, given the table's internal name */
 163 extern int get_dissector_table_base(const char *name);
 164
 165 /* Add an entry to a uint dissector table. */
 166 extern void dissector_add(const char *abbrev, guint32 pattern,
 167     dissector_handle_t handle);
 168
 169 /* Delete the entry for a dissector in a uint dissector table
 170    with a particular pattern. */
 171 extern void dissector_delete(const char *name, guint32 pattern,
 172     dissector_handle_t handle);
 173
 174 /* Change the entry for a dissector in a uint dissector table
 175    with a particular pattern to use a new dissector handle. */
 176 extern void dissector_change(const char *abbrev, guint32 pattern,
 177     dissector_handle_t handle);
 178
 179 /* Reset an entry in a uint dissector table to its initial value. */
 180 extern void dissector_reset(const char *name, guint32 pattern);
 181
 182 /* Look for a given value in a given uint dissector table and, if found,
 183    call the dissector with the arguments supplied, and return TRUE,
 184    otherwise return FALSE. */
 185 extern gboolean dissector_try_port(dissector_table_t sub_dissectors,
 186     guint32 port, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 187
 188 /* Look for a given value in a given uint dissector table and, if found,
 189    return the dissector handle for that value. */
 190 extern dissector_handle_t dissector_get_port_handle(
 191     dissector_table_t sub_dissectors, guint32 port);
 192
 193 /* Add an entry to a string dissector table. */
 194 extern void dissector_add_string(const char *name, gchar *pattern,
 195     dissector_handle_t handle);
 196
 197 /* Delete the entry for a dissector in a string dissector table
 198    with a particular pattern. */
 199 extern void dissector_delete_string(const char *name, const gchar *pattern,
 200         dissector_handle_t handle);
 201
 202 /* Change the entry for a dissector in a string dissector table
 203    with a particular pattern to use a new dissector handle. */
 204 extern void dissector_change_string(const char *name, gchar *pattern,
 205     dissector_handle_t handle);
 206
 207 /* Reset an entry in a string sub-dissector table to its initial value. */
 208 extern void dissector_reset_string(const char *name, const gchar *pattern);
 209
 210 /* Look for a given string in a given dissector table and, if found, call
 211    the dissector with the arguments supplied, and return TRUE, otherwise
 212    return FALSE. */
 213 extern gboolean dissector_try_string(dissector_table_t sub_dissectors,
 214     const gchar *string, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 215
 216 /* Look for a given value in a given string dissector table and, if found,
 217    return the dissector handle for that value. */
 218 extern dissector_handle_t dissector_get_string_handle(
 219     dissector_table_t sub_dissectors, const gchar *string);
 220
 221 /* Add a handle to the list of handles that *could* be used with this
 222    table.  That list is used by code in the UI. */
 223 extern void dissector_add_handle(const char *name, dissector_handle_t handle);
 224
 225 /* List of "heuristic" dissectors (which get handed a packet, look at it,
 226    and either recognize it as being for their protocol, dissect it, and
 227    return TRUE, or don't recognize it and return FALSE) to be called
 228    by another dissector. */
 229 typedef GSList *heur_dissector_list_t;
 230
 231 /** A protocol uses this function to register a heuristic sub-dissector list.
 232  *  Call this in the parent dissectors proto_register function.
 233  *
 234  * @param name the name of this protocol
 235  * @param list the list of heuristic sub-dissectors to be registered
 236  */
 237 extern void register_heur_dissector_list(const char *name,
 238     heur_dissector_list_t *list);
 239
 240 /** Try all the dissectors in a given heuristic dissector list. This is done,
 241  *  until we find one that recognizes the protocol.
 242  *  Call this while the parent dissector running.
 243  *
 244  * @param sub_dissectors the sub-dissector list
 245  * @param tvb the tv_buff with the (remaining) packet data
 246  * @param pinfo the packet info of this packet (additional info)
 247  * @param tree the protocol tree to be build or NULL
 248  * @return TRUE if the packet was recognized by the sub-dissector (stop dissection here)
 249  */
 250 extern gboolean dissector_try_heuristic(heur_dissector_list_t sub_dissectors,
 251     tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 252
 253 /** Type of a heuristic dissector, used in heur_dissector_add().
 254  *
 255  * @param tvb the tv_buff with the (remaining) packet data
 256  * @param pinfo the packet info of this packet (additional info)
 257  * @param tree the protocol tree to be build or NULL
 258  * @return TRUE if the packet was recognized by the sub-dissector (stop dissection here)
 259  */
 260 typedef gboolean (*heur_dissector_t)(tvbuff_t *tvb, packet_info *pinfo,
 261         proto_tree *tree);
 262
 263 /** Add a sub-dissector to a heuristic dissector list.
 264  *  Call this in the proto_handoff function of the sub-dissector.
 265  *
 266  * @param name the name of the "parent" protocol, e.g. "tcp"
 267  * @param dissector the sub-dissector to be registered
 268  * @param proto the protocol id of the sub-dissector
 269  */
 270 extern void heur_dissector_add(const char *name, heur_dissector_t dissector,
 271     int proto);
 272
 273 /* Register a dissector. */
 274 extern void register_dissector(const char *name, dissector_t dissector,
 275     int proto);
 276 extern void new_register_dissector(const char *name, new_dissector_t dissector,
 277     int proto);
 278
 279 /* Get the short name of the protocol for a dissector handle. */
 280 extern char *dissector_handle_get_short_name(dissector_handle_t handle);
 281
 282 /* Get the index of the protocol for a dissector handle. */
 283 extern int dissector_handle_get_protocol_index(dissector_handle_t handle);
 284
 285 /* Find a dissector by name. */
 286 extern dissector_handle_t find_dissector(const char *name);
 287
 288 /* Create an anonymous handle for a dissector. */
 289 extern dissector_handle_t create_dissector_handle(dissector_t dissector,
 290     int proto);
 291 extern dissector_handle_t new_create_dissector_handle(new_dissector_t dissector,
 292     int proto);
 293
 294 /* Call a dissector through a handle. */
 295 extern int call_dissector(dissector_handle_t handle, tvbuff_t *tvb,
 296     packet_info *pinfo, proto_tree *tree);
 297
 298 /* Do all one-time initialization. */
 299 extern void dissect_init(void);
 300
 301 extern void dissect_cleanup(void);
 302
 303 /*
 304  * Given a tvbuff, and a length from a packet header, adjust the length
 305  * of the tvbuff to reflect the specified length.
 306  */
 307 extern void set_actual_length(tvbuff_t *tvb, guint specified_len);
 308
 309 /* Allow protocols to register "init" routines, which are called before
 310    we make a pass through a capture file and dissect all its packets
 311    (e.g., when we read in a new capture file, or run a "filter packets"
 312    or "colorize packets" pass over the current capture file). */
 313 extern void register_init_routine(void (*func)(void));
 314
 315 /* Initialize all data structures used for dissection. */
 316 extern void init_dissection(void);
 317
 318 /* Allow protocols to register a "cleanup" routine to be
 319  * run after the initial sequential run through the packets.
 320  * Note that the file can still be open after this; this is not
 321  * the final cleanup. */
 322 extern void register_postseq_cleanup_routine(void (*func)(void));
 323
 324 /* Call all the registered "postseq_cleanup" routines. */
 325 extern void postseq_cleanup_all_protocols(void);
 326
 327 /* Allow dissectors to register a "final_registration" routine
 328  * that is run like the proto_register_XXX() routine, but the end
 329  * end of the epan_init() function; that is, *after* all other
 330  * subsystems, liked dfilters, have finished initializing. This is
 331  * useful for dissector registration routines which need to compile
 332  * display filters. dfilters can't initialize itself until all protocols
 333  * have registereed themselvs. */
 334 extern void
 335 register_final_registration_routine(void (*func)(void));
 336
 337 /* Call all the registered "final_registration" routines. */
 338 extern void
 339 final_registration_all_protocols(void);
 340
 341 /*
 342  * Add a new data source to the list of data sources for a frame, given
 343  * the tvbuff for the data source and its name.
 344  */
 345 extern void add_new_data_source(packet_info *pinfo, tvbuff_t *tvb,
 346     char *name);
 347
 348 /*
 349  * Free up a frame's list of data sources.
 350  */
 351 extern void free_data_sources(packet_info *pinfo);
 352
 353 /*
 354  * Dissectors should never modify the packet data.
 355  */
 356 extern void dissect_packet(epan_dissect_t *edt,
 357     union wtap_pseudo_header *pseudo_header, const guchar *pd,
 358     frame_data *fd, column_info *cinfo);
 359
 360 /* These functions are in packet-ethertype.c */
 361 extern void capture_ethertype(guint16 etype, const guchar *pd, int offset,
 362                 int len, packet_counts *ld);
 363 extern void ethertype(guint16 etype, tvbuff_t *tvb, int offset_after_ethertype,
 364                 packet_info *pinfo, proto_tree *tree, proto_tree *fh_tree,
 365                 int etype_id, int trailer_id, int fcs_len);
 366
 367 #endif /* packet.h */