2 * Definitions for packet disassembly structures and routines
6 * Wireshark - Network traffic analyzer
7 * By Gerald Combs <gerald@wireshark.org>
8 * Copyright 1998 Gerald Combs
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.
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.
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.
29 * If <inttypes.h> defines formats to be used to print 64-bit integers,
32 #ifdef INTTYPES_H_DEFINES_FORMATS
36 #include "wiretap/wtap.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"
51 #endif /* __cplusplus */
53 #define hi_nibble(b) (((b) & 0xf0) >> 4)
54 #define lo_nibble(b) ((b) & 0x0f)
56 /* Useful when you have an array whose size you can tell at compile-time */
57 #define array_length(x) (sizeof x / sizeof x[0])
59 /* Check whether the "len" bytes of data starting at "offset" is
60 * entirely inside the captured data for this packet. */
61 #define BYTES_ARE_IN_FRAME(offset, captured_len, len) \
62 ((guint)(offset) + (guint)(len) > (guint)(offset) && \
63 (guint)(offset) + (guint)(len) <= (guint)(captured_len))
65 /* To pass one of two strings, singular or plural */
66 #define plurality(d,s,p) ((d) == 1 ? (s) : (p))
68 typedef struct _packet_counts {
83 /** Number of packet counts. */
84 #define PACKET_COUNTS_SIZE sizeof(packet_counts) / sizeof (gint)
86 /* Types of character encodings */
88 CHAR_ASCII = 0, /* ASCII */
89 CHAR_EBCDIC = 1 /* EBCDIC */
92 extern void packet_init(void);
93 extern void packet_cleanup(void);
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;
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;
106 * Dissector that returns nothing.
108 typedef void (*dissector_t)(tvbuff_t *, packet_info *, proto_tree *);
111 * Dissector that returns:
113 * The amount of data in the protocol's PDU, if it was able to
114 * dissect all the data;
116 * 0, if the tvbuff doesn't contain a PDU for that protocol;
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.
122 typedef int (*new_dissector_t)(tvbuff_t *, packet_info *, proto_tree *);
124 /** Type of a heuristic dissector, used in heur_dissector_add().
126 * @param tvb the tv_buff with the (remaining) packet data
127 * @param pinfo the packet info of this packet (additional info)
128 * @param tree the protocol tree to be build or NULL
129 * @return TRUE if the packet was recognized by the sub-dissector (stop dissection here)
131 typedef gboolean (*heur_dissector_t)(tvbuff_t *tvb, packet_info *pinfo,
134 typedef void (*DATFunc) (gchar *table_name, ftenum_t selector_type,
135 gpointer key, gpointer value, gpointer user_data);
136 typedef void (*DATFunc_handle) (const gchar *table_name, gpointer value,
138 typedef void (*DATFunc_table) (gchar *table_name, const gchar *ui_name,
141 /* Opaque structure - provides type checking but no access to components */
142 typedef struct dtbl_entry dtbl_entry_t;
144 extern dissector_handle_t dtbl_entry_get_handle (dtbl_entry_t *dtbl_entry);
145 extern dissector_handle_t dtbl_entry_get_initial_handle (dtbl_entry_t * entry);
146 extern void dissector_table_foreach_changed (char *name, DATFunc func,
148 extern void dissector_table_foreach (char *name, DATFunc func,
150 extern void dissector_all_tables_foreach_changed (DATFunc func,
152 extern void dissector_table_foreach_handle(const char *name, DATFunc_handle func,
154 extern void dissector_all_tables_foreach_table (DATFunc_table func,
157 /* a protocol uses the function to register a sub-dissector table */
158 extern dissector_table_t register_dissector_table(const char *name,
159 const char *ui_name, ftenum_t type, int base);
161 /* Find a dissector table by table name. */
162 extern dissector_table_t find_dissector_table(const char *name);
164 /* Get the UI name for a sub-dissector table, given its internal name */
165 extern const char *get_dissector_table_ui_name(const char *name);
167 /* Get the field type for values of the selector for a dissector table,
168 given the table's internal name */
169 extern ftenum_t get_dissector_table_selector_type(const char *name);
171 /* Get the base to use when displaying values of the selector for a
172 sub-dissector table, given the table's internal name */
173 extern int get_dissector_table_base(const char *name);
175 /* Add an entry to a uint dissector table. */
176 extern void dissector_add(const char *abbrev, guint32 pattern,
177 dissector_handle_t handle);
179 /* Delete the entry for a dissector in a uint dissector table
180 with a particular pattern. */
181 extern void dissector_delete(const char *name, guint32 pattern,
182 dissector_handle_t handle);
184 /* Change the entry for a dissector in a uint dissector table
185 with a particular pattern to use a new dissector handle. */
186 extern void dissector_change(const char *abbrev, guint32 pattern,
187 dissector_handle_t handle);
189 /* Reset an entry in a uint dissector table to its initial value. */
190 extern void dissector_reset(const char *name, guint32 pattern);
192 /* Look for a given value in a given uint dissector table and, if found,
193 call the dissector with the arguments supplied, and return TRUE,
194 otherwise return FALSE. */
195 extern gboolean dissector_try_port(dissector_table_t sub_dissectors,
196 guint32 port, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
198 /* Look for a given value in a given uint dissector table and, if found,
199 return the dissector handle for that value. */
200 extern dissector_handle_t dissector_get_port_handle(
201 dissector_table_t sub_dissectors, guint32 port);
203 /* Add an entry to a string dissector table. */
204 extern void dissector_add_string(const char *name, const gchar *pattern,
205 dissector_handle_t handle);
207 /* Delete the entry for a dissector in a string dissector table
208 with a particular pattern. */
209 extern void dissector_delete_string(const char *name, const gchar *pattern,
210 dissector_handle_t handle);
212 /* Change the entry for a dissector in a string dissector table
213 with a particular pattern to use a new dissector handle. */
214 extern void dissector_change_string(const char *name, gchar *pattern,
215 dissector_handle_t handle);
217 /* Reset an entry in a string sub-dissector table to its initial value. */
218 extern void dissector_reset_string(const char *name, const gchar *pattern);
220 /* Look for a given string in a given dissector table and, if found, call
221 the dissector with the arguments supplied, and return TRUE, otherwise
223 extern gboolean dissector_try_string(dissector_table_t sub_dissectors,
224 const gchar *string, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
226 /* Look for a given value in a given string dissector table and, if found,
227 return the dissector handle for that value. */
228 extern dissector_handle_t dissector_get_string_handle(
229 dissector_table_t sub_dissectors, const gchar *string);
231 /* Add a handle to the list of handles that *could* be used with this
232 table. That list is used by code in the UI. */
233 extern void dissector_add_handle(const char *name, dissector_handle_t handle);
235 /* List of "heuristic" dissectors (which get handed a packet, look at it,
236 and either recognize it as being for their protocol, dissect it, and
237 return TRUE, or don't recognize it and return FALSE) to be called
238 by another dissector. */
239 typedef GSList *heur_dissector_list_t;
241 /** A protocol uses this function to register a heuristic sub-dissector list.
242 * Call this in the parent dissectors proto_register function.
244 * @param name the name of this protocol
245 * @param list the list of heuristic sub-dissectors to be registered
247 extern void register_heur_dissector_list(const char *name,
248 heur_dissector_list_t *list);
250 /** Try all the dissectors in a given heuristic dissector list. This is done,
251 * until we find one that recognizes the protocol.
252 * Call this while the parent dissector running.
254 * @param sub_dissectors the sub-dissector list
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)
260 extern gboolean dissector_try_heuristic(heur_dissector_list_t sub_dissectors,
261 tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
263 /** Add a sub-dissector to a heuristic dissector list.
264 * Call this in the proto_handoff function of the sub-dissector.
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
270 extern void heur_dissector_add(const char *name, heur_dissector_t dissector,
273 /* Register a dissector. */
274 extern void register_dissector(const char *name, dissector_t dissector,
276 extern void new_register_dissector(const char *name, new_dissector_t dissector,
279 /* Get the short name of the protocol for a dissector handle. */
280 extern const char *dissector_handle_get_short_name(dissector_handle_t handle);
282 /* Get the index of the protocol for a dissector handle. */
283 extern int dissector_handle_get_protocol_index(dissector_handle_t handle);
285 /* Find a dissector by name. */
286 extern dissector_handle_t find_dissector(const char *name);
288 /* Create an anonymous handle for a dissector. */
289 extern dissector_handle_t create_dissector_handle(dissector_t dissector,
291 extern dissector_handle_t new_create_dissector_handle(new_dissector_t dissector,
294 /* Call a dissector through a handle and if no dissector was found
295 * pass if over to the "data" dissector instead.
297 * @param handle The dissector to call.
298 * @param tvb The buffer to dissect.
299 * @param pinfo Packet Info.
300 * @param tree The protocol tree.
301 * @return If the protocol for that handle isn't enabled call the data
302 * dissector. Otherwise, if the handle refers to a new-style
303 * dissector, call the dissector and return its return value, otherwise call
304 * it and return the length of the tvbuff pointed to by the argument.
306 extern int call_dissector(dissector_handle_t handle, tvbuff_t *tvb,
307 packet_info *pinfo, proto_tree *tree);
309 /* Call a dissector through a handle but if no dissector was found
310 * just return 0 and do not call the "data" dissector instead.
312 * @param handle The dissector to call.
313 * @param tvb The buffer to dissect.
314 * @param pinfo Packet Info.
315 * @param tree The protocol tree.
316 * @return If the protocol for that handle isn't enabled, return 0 without
317 * calling the dissector. Otherwise, if the handle refers to a new-style
318 * dissector, call the dissector and return its return value, otherwise call
319 * it and return the length of the tvbuff pointed to by the argument.
321 extern int call_dissector_only(dissector_handle_t handle, tvbuff_t *tvb,
322 packet_info *pinfo, proto_tree *tree);
324 /* Do all one-time initialization. */
325 extern void dissect_init(void);
327 extern void dissect_cleanup(void);
330 * Given a tvbuff, and a length from a packet header, adjust the length
331 * of the tvbuff to reflect the specified length.
333 extern void set_actual_length(tvbuff_t *tvb, guint specified_len);
335 /* Allow protocols to register "init" routines, which are called before
336 we make a pass through a capture file and dissect all its packets
337 (e.g., when we read in a new capture file, or run a "filter packets"
338 or "colorize packets" pass over the current capture file). */
339 extern void register_init_routine(void (*func)(void));
341 /* Initialize all data structures used for dissection. */
342 extern void init_dissection(void);
344 /* Free data structures allocated for dissection. */
345 extern void cleanup_dissection(void);
347 /* Allow protocols to register a "cleanup" routine to be
348 * run after the initial sequential run through the packets.
349 * Note that the file can still be open after this; this is not
350 * the final cleanup. */
351 extern void register_postseq_cleanup_routine(void (*func)(void));
353 /* Call all the registered "postseq_cleanup" routines. */
354 extern void postseq_cleanup_all_protocols(void);
356 /* Allow dissectors to register a "final_registration" routine
357 * that is run like the proto_register_XXX() routine, but the end
358 * end of the epan_init() function; that is, *after* all other
359 * subsystems, liked dfilters, have finished initializing. This is
360 * useful for dissector registration routines which need to compile
361 * display filters. dfilters can't initialize itself until all protocols
362 * have registereed themselvs. */
364 register_final_registration_routine(void (*func)(void));
366 /* Call all the registered "final_registration" routines. */
368 final_registration_all_protocols(void);
371 * Add a new data source to the list of data sources for a frame, given
372 * the tvbuff for the data source and its name.
374 extern void add_new_data_source(packet_info *pinfo, tvbuff_t *tvb,
378 * Free up a frame's list of data sources.
380 extern void free_data_sources(packet_info *pinfo);
383 * Dissectors should never modify the packet data.
385 extern void dissect_packet(epan_dissect_t *edt,
386 union wtap_pseudo_header *pseudo_header, const guchar *pd,
387 frame_data *fd, column_info *cinfo);
389 /* These functions are in packet-ethertype.c */
390 extern void capture_ethertype(guint16 etype, const guchar *pd, int offset,
391 int len, packet_counts *ld);
392 extern void ethertype(guint16 etype, tvbuff_t *tvb, int offset_after_ethertype,
393 packet_info *pinfo, proto_tree *tree, proto_tree *fh_tree,
394 int etype_id, int trailer_id, int fcs_len);
397 * Dump layer/selector/dissector records in a fashion similar to the
398 * proto_registrar_dump_* routines.
400 extern void dissector_dump_decodes(void);
403 * post dissectors are to be called by packet-frame.c after every other
404 * dissector has been called.
406 extern void register_postdissector(dissector_handle_t);
407 extern void call_all_postdissectors(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
411 #endif /* __cplusplus */
413 #endif /* packet.h */