From 758ceb58e84db5fa8628e5189ee7e44a6dbf265f Mon Sep 17 00:00:00 2001 From: Anders Broman Date: Mon, 3 Oct 2005 18:34:21 +0000 Subject: From Jeff Snyder: 04-stream.diff A simplified packet reassembly API built on top of fragment_add_seq_next for reassembling fragments that are delivered in-order, where fragments are identified by a framenum and an offset into that frame. Streams are attached to a conversation or a circuit and are unidirectional. svn path=/trunk/; revision=16082 --- epan/stream.h | 138 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 138 insertions(+) create mode 100644 epan/stream.h (limited to 'epan/stream.h') diff --git a/epan/stream.h b/epan/stream.h new file mode 100644 index 0000000000..ee868e1e37 --- /dev/null +++ b/epan/stream.h @@ -0,0 +1,138 @@ +/* stream.h + * + * Definititions for handling circuit-switched protocols + * which are handled as streams, and don't have lengths + * and IDs such as are required for reassemble.h + * + * $Id$ + * + * Ethereal - Network traffic analyzer + * By Gerald Combs + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef STREAM_H +#define STREAM_H + +#include + +extern struct _fragment_items; + +/* A stream represents the concept of an arbitrary stream of data, + divided up into frames for transmission, where the frames have + little or no correspondence to the PDUs of the protocol being + streamed, and those PDUs are just delineated by a magic number. + + For example, we stream H.223 over IAX2. IAX2 has no concept of + H.223 PDUs and just divides the H.223 stream into 160-byte + frames. H.223 PDUs are delineated by two-byte magic numbers (which + may, of course, straddle an IAX2 frame boundary). + + Essentially we act as a wrapper to reassemble.h, by making up + PDU ids and keeping some additional data on fragments to allow the + PDUs to be defragmented again. +*/ + + +/* A stream_t represents a stream. There might be one or two streams + in a circuit, depending on whether that circuit is mono- or bi-directional. +*/ +typedef struct stream stream_t; + +/* Fragments in a PDU are represented using a stream_pdu_fragment_t, + and placed in a linked-list with other fragments in the PDU. + + (They're also placed in a hash so we can find them again later) +*/ +typedef struct stream_pdu_fragment stream_pdu_fragment_t; + + + +struct circuit; +struct conversation; + +/* initialise a new stream. Call this when you first identify a distinct + * stream. The circit pointer is just used as a key to look up the stream. */ +extern stream_t *stream_new_circ ( const struct circuit *circuit, int p2p_dir ); +extern stream_t *stream_new_conv ( const struct conversation *conv, int p2p_dir ); + +/* retrieve a previously-created stream. + * + * Returns null if no matching stream was found. + */ +extern stream_t *find_stream_circ ( const struct circuit *circuit, int p2p_dir ); +extern stream_t *find_stream_conv ( const struct conversation *conv, int p2p_dir ); + + + +/* see if we've seen this fragment before. + + The framenum and offset are just hash keys, so can be any values unique + to this frame, but the idea is that you use the number of the frame being + disassembled, and the byte-offset within that frame. +*/ +extern stream_pdu_fragment_t *stream_find_frag( stream_t *stream, guint32 framenum, guint32 offset ); + +/* add a new fragment to the fragment tables for the stream. The framenum and + * offset are keys allowing future access with stream_find_frag(), tvb is the + * fragment to be added, and pinfo is the information for the frame containing + * this fragment. more_frags should be set if this is the final fragment in the + * PDU. + * + * * the fragment must be later in the stream than any previous fragment + * (ie, framenum.offset must be greater than those passed on the previous + * call) + * + * This essentially means that you can only add fragments on the first pass + * through the stream. + */ +extern stream_pdu_fragment_t *stream_add_frag( stream_t *stream, guint32 framenum, guint32 offset, + tvbuff_t *tvb, packet_info *pinfo, gboolean more_frags ); + +/* Get the length of a fragment previously found by stream_find_frag(). + */ +extern guint32 stream_get_frag_length( const stream_pdu_fragment_t *frag); + +/* Get a handle on the top of the chain of fragment_datas underlying this PDU + * frag can be any fragment within a PDU, and it will always return the head of + * the chain + * + * Returns NULL until the last fragment is added. + */ +extern struct _fragment_data *stream_get_frag_data( const stream_pdu_fragment_t *frag); + +/* + * Process reassembled data; if this is the last fragment, put the fragment + * information into the protocol tree, and construct a tvbuff with the + * reassembled data, otherwise just put a "reassembled in" item into the + * protocol tree. + */ +extern tvbuff_t *stream_process_reassembled( + tvbuff_t *tvb, int offset, packet_info *pinfo, + char *name, const stream_pdu_fragment_t *frag, + const struct _fragment_items *fit, + gboolean *update_col_infop, proto_tree *tree); + +/* Get the PDU number. PDUs are numbered from zero within a stream. + * frag can be any fragment within a PDU. + */ +extern guint32 stream_get_pdu_no( const stream_pdu_fragment_t *frag); + +/* initialise the stream routines */ +void stream_init( void ); + +#endif /* STREAM_H */ -- cgit v1.2.3