diff options
Diffstat (limited to 'epan/reassemble.c')
| -rw-r--r-- | epan/reassemble.c | 3554 |
1 files changed, 3554 insertions, 0 deletions
diff --git a/epan/reassemble.c b/epan/reassemble.c new file mode 100644 index 00000000..6f06a8f1 --- /dev/null +++ b/epan/reassemble.c @@ -0,0 +1,3554 @@ +/* reassemble.c + * Routines for {fragment,segment} reassembly + * + * Wireshark - Network traffic analyzer + * By Gerald Combs <gerald@wireshark.org> + * Copyright 1998 Gerald Combs + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ + +#include "config.h" + +#include <string.h> + +#include <epan/packet.h> +#include <epan/exceptions.h> +#include <epan/reassemble.h> +#include <epan/tvbuff-int.h> + +#include <wsutil/str_util.h> +#include <wsutil/ws_assert.h> + +/* + * Functions for reassembly tables where the endpoint addresses, and a + * fragment ID, are used as the key. + */ +typedef struct _fragment_addresses_key { + address src; + address dst; + guint32 id; +} fragment_addresses_key; + +GList* reassembly_table_list = NULL; + +static guint +fragment_addresses_hash(gconstpointer k) +{ + const fragment_addresses_key* key = (const fragment_addresses_key*) k; + guint hash_val; +/* + int i; +*/ + + hash_val = 0; + +/* More than likely: in most captures src and dst addresses are the + same, and would hash the same. + We only use id as the hash as an optimization. + + for (i = 0; i < key->src.len; i++) + hash_val += key->src.data[i]; + for (i = 0; i < key->dst.len; i++) + hash_val += key->dst.data[i]; +*/ + + hash_val += key->id; + + return hash_val; +} + +static gint +fragment_addresses_equal(gconstpointer k1, gconstpointer k2) +{ + const fragment_addresses_key* key1 = (const fragment_addresses_key*) k1; + const fragment_addresses_key* key2 = (const fragment_addresses_key*) k2; + + /* + * key.id is the first item to compare since it's the item most + * likely to differ between sessions, thus short-circuiting + * the comparison of addresses. + */ + return (key1->id == key2->id) && + (addresses_equal(&key1->src, &key2->src)) && + (addresses_equal(&key1->dst, &key2->dst)); +} + +/* + * Create a fragment key for temporary use; it can point to non- + * persistent data, and so must only be used to look up and + * delete entries, not to add them. + */ +static gpointer +fragment_addresses_temporary_key(const packet_info *pinfo, const guint32 id, + const void *data _U_) +{ + fragment_addresses_key *key = g_slice_new(fragment_addresses_key); + + /* + * Do a shallow copy of the addresses. + */ + copy_address_shallow(&key->src, &pinfo->src); + copy_address_shallow(&key->dst, &pinfo->dst); + key->id = id; + + return (gpointer)key; +} + +/* + * Create a fragment key for permanent use; it must point to persistent + * data, so that it can be used to add entries. + */ +static gpointer +fragment_addresses_persistent_key(const packet_info *pinfo, const guint32 id, + const void *data _U_) +{ + fragment_addresses_key *key = g_slice_new(fragment_addresses_key); + + /* + * Do a deep copy of the addresses. + */ + copy_address(&key->src, &pinfo->src); + copy_address(&key->dst, &pinfo->dst); + key->id = id; + + return (gpointer)key; +} + +static void +fragment_addresses_free_temporary_key(gpointer ptr) +{ + fragment_addresses_key *key = (fragment_addresses_key *)ptr; + g_slice_free(fragment_addresses_key, key); +} + +static void +fragment_addresses_free_persistent_key(gpointer ptr) +{ + fragment_addresses_key *key = (fragment_addresses_key *)ptr; + + if(key){ + /* + * Free up the copies of the addresses from the old key. + */ + free_address(&key->src); + free_address(&key->dst); + + g_slice_free(fragment_addresses_key, key); + } +} + +const reassembly_table_functions +addresses_reassembly_table_functions = { + fragment_addresses_hash, + fragment_addresses_equal, + fragment_addresses_temporary_key, + fragment_addresses_persistent_key, + fragment_addresses_free_temporary_key, + fragment_addresses_free_persistent_key +}; + +/* + * Functions for reassembly tables where the endpoint addresses and ports, + * and a fragment ID, are used as the key. + */ +typedef struct _fragment_addresses_ports_key { + address src_addr; + address dst_addr; + guint32 src_port; + guint32 dst_port; + guint32 id; +} fragment_addresses_ports_key; + +static guint +fragment_addresses_ports_hash(gconstpointer k) +{ + const fragment_addresses_ports_key* key = (const fragment_addresses_ports_key*) k; + guint hash_val; +/* + int i; +*/ + + hash_val = 0; + +/* More than likely: in most captures src and dst addresses and ports + are the same, and would hash the same. + We only use id as the hash as an optimization. + + for (i = 0; i < key->src.len; i++) + hash_val += key->src_addr.data[i]; + for (i = 0; i < key->dst.len; i++) + hash_val += key->dst_addr.data[i]; + hash_val += key->src_port; + hash_val += key->dst_port; +*/ + + hash_val += key->id; + + return hash_val; +} + +static gint +fragment_addresses_ports_equal(gconstpointer k1, gconstpointer k2) +{ + const fragment_addresses_ports_key* key1 = (const fragment_addresses_ports_key*) k1; + const fragment_addresses_ports_key* key2 = (const fragment_addresses_ports_key*) k2; + + /* + * key.id is the first item to compare since it's the item most + * likely to differ between sessions, thus short-circuiting + * the comparison of addresses and ports. + */ + return (key1->id == key2->id) && + (addresses_equal(&key1->src_addr, &key2->src_addr)) && + (addresses_equal(&key1->dst_addr, &key2->dst_addr)) && + (key1->src_port == key2->src_port) && + (key1->dst_port == key2->dst_port); +} + +/* + * Create a fragment key for temporary use; it can point to non- + * persistent data, and so must only be used to look up and + * delete entries, not to add them. + */ +static gpointer +fragment_addresses_ports_temporary_key(const packet_info *pinfo, const guint32 id, + const void *data _U_) +{ + fragment_addresses_ports_key *key = g_slice_new(fragment_addresses_ports_key); + + /* + * Do a shallow copy of the addresses. + */ + copy_address_shallow(&key->src_addr, &pinfo->src); + copy_address_shallow(&key->dst_addr, &pinfo->dst); + key->src_port = pinfo->srcport; + key->dst_port = pinfo->destport; + key->id = id; + + return (gpointer)key; +} + +/* + * Create a fragment key for permanent use; it must point to persistent + * data, so that it can be used to add entries. + */ +static gpointer +fragment_addresses_ports_persistent_key(const packet_info *pinfo, + const guint32 id, const void *data _U_) +{ + fragment_addresses_ports_key *key = g_slice_new(fragment_addresses_ports_key); + + /* + * Do a deep copy of the addresses. + */ + copy_address(&key->src_addr, &pinfo->src); + copy_address(&key->dst_addr, &pinfo->dst); + key->src_port = pinfo->srcport; + key->dst_port = pinfo->destport; + key->id = id; + + return (gpointer)key; +} + +static void +fragment_addresses_ports_free_temporary_key(gpointer ptr) +{ + fragment_addresses_ports_key *key = (fragment_addresses_ports_key *)ptr; + g_slice_free(fragment_addresses_ports_key, key); +} + +static void +fragment_addresses_ports_free_persistent_key(gpointer ptr) +{ + fragment_addresses_ports_key *key = (fragment_addresses_ports_key *)ptr; + + if(key){ + /* + * Free up the copies of the addresses from the old key. + */ + free_address(&key->src_addr); + free_address(&key->dst_addr); + + g_slice_free(fragment_addresses_ports_key, key); + } +} + +const reassembly_table_functions +addresses_ports_reassembly_table_functions = { + fragment_addresses_ports_hash, + fragment_addresses_ports_equal, + fragment_addresses_ports_temporary_key, + fragment_addresses_ports_persistent_key, + fragment_addresses_ports_free_temporary_key, + fragment_addresses_ports_free_persistent_key +}; + +typedef struct _reassembled_key { + guint32 id; + guint32 frame; +} reassembled_key; + +static gint +reassembled_equal(gconstpointer k1, gconstpointer k2) +{ + const reassembled_key* key1 = (const reassembled_key*) k1; + const reassembled_key* key2 = (const reassembled_key*) k2; + + /* + * We assume that the frame numbers are unlikely to be equal, + * so we check them first. + */ + return key1->frame == key2->frame && key1->id == key2->id; +} + +static guint +reassembled_hash(gconstpointer k) +{ + const reassembled_key* key = (const reassembled_key*) k; + + return key->frame; +} + +static void +reassembled_key_free(gpointer ptr) +{ + g_slice_free(reassembled_key, (reassembled_key *)ptr); +} + +/* + * For a fragment hash table entry, free the associated fragments. + * The entry value (fd_chain) is freed herein and the entry is freed + * when the key freeing routine is called (as a consequence of returning + * TRUE from this function). + */ +static gboolean +free_all_fragments(gpointer key_arg _U_, gpointer value, gpointer user_data _U_) +{ + fragment_head *fd_head; + fragment_item *fd_i = NULL, *tmp_fd; + + /* g_hash_table_new_full() was used to supply a function + * to free the key and anything to which it points + */ + fd_head = (fragment_head *)value; + if (fd_head != NULL) { + fd_i = fd_head->next; + if(fd_head->tvb_data && !(fd_head->flags&FD_SUBSET_TVB)) + tvb_free(fd_head->tvb_data); + g_slice_free(fragment_head, fd_head); + } + + for (; fd_i != NULL; fd_i = tmp_fd) { + tmp_fd=fd_i->next; + + if(fd_i->tvb_data && !(fd_i->flags&FD_SUBSET_TVB)) + tvb_free(fd_i->tvb_data); + g_slice_free(fragment_item, fd_i); + } + + return TRUE; +} + +/* ------------------------- */ +static fragment_head *new_head(const guint32 flags) +{ + fragment_head *fd_head; + /* If head/first structure in list only holds no other data than + * 'datalen' then we don't have to change the head of the list + * even if we want to keep it sorted + */ + fd_head=g_slice_new0(fragment_head); + + fd_head->flags=flags; + return fd_head; +} + +/* + * For a reassembled-packet hash table entry, free the fragment data + * to which the value refers. (The key is freed by reassembled_key_free.) + */ +static void +free_fd_head(fragment_head *fd_head) +{ + fragment_item *fd_i, *tmp; + + if (fd_head->flags & FD_SUBSET_TVB) + fd_head->tvb_data = NULL; + if (fd_head->tvb_data) + tvb_free(fd_head->tvb_data); + for (fd_i = fd_head->next; fd_i; fd_i = tmp) { + tmp = fd_i->next; + if (fd_i->flags & FD_SUBSET_TVB) + fd_i->tvb_data = NULL; + if (fd_i->tvb_data) { + tvb_free(fd_i->tvb_data); + } + g_slice_free(fragment_item, fd_i); + } + g_slice_free(fragment_head, fd_head); +} + +static void +unref_fd_head(gpointer data) +{ + fragment_head *fd_head = (fragment_head *) data; + fd_head->ref_count--; + + if (fd_head->ref_count == 0) { + free_fd_head(fd_head); + } +} + +static void +reassembled_table_insert(GHashTable *reassembled_table, reassembled_key *key, fragment_head *fd_head) +{ + fragment_head *old_fd_head; + fd_head->ref_count++; + if ((old_fd_head = g_hash_table_lookup(reassembled_table, key)) != NULL) { + if (old_fd_head->ref_count == 1) { + /* We're replacing the last entry in the reassembled + * table for an old reassembly. Does it have a tvb? + * We might still be using that tvb's memory for an + * address via set_address_tvb(). (See #19094.) + */ + if (old_fd_head->tvb_data && fd_head->tvb_data) { + /* Free it when the new tvb is freed */ + tvb_set_child_real_data_tvbuff(fd_head->tvb_data, old_fd_head->tvb_data); + } + /* XXX: Set the old data to NULL regardless. If we + * have old data but not new data, that is odd (we're + * replacing a reassembly with tvb data with something + * with no tvb data, possibly because a zero length or + * null tvb was passed into a defragment function, + * which is a dissector bug.) + * This leaks the tvb data if we couldn't add it to + * a new tvb's chain, but we might not be able to free + * it yet if set_address_tvb() was used. + */ + old_fd_head->tvb_data = NULL; + } + } + g_hash_table_insert(reassembled_table, key, fd_head); +} + +typedef struct register_reassembly_table { + reassembly_table *table; + const reassembly_table_functions *funcs; +} register_reassembly_table_t; + +/* + * Register a reassembly table. + */ +void +reassembly_table_register(reassembly_table *table, + const reassembly_table_functions *funcs) +{ + register_reassembly_table_t* reg_table; + + DISSECTOR_ASSERT(table); + DISSECTOR_ASSERT(funcs); + + reg_table = g_new(register_reassembly_table_t,1); + + reg_table->table = table; + reg_table->funcs = funcs; + + reassembly_table_list = g_list_prepend(reassembly_table_list, reg_table); +} + +/* + * Initialize a reassembly table, with specified functions. + */ +void +reassembly_table_init(reassembly_table *table, + const reassembly_table_functions *funcs) +{ + if (table->temporary_key_func == NULL) + table->temporary_key_func = funcs->temporary_key_func; + if (table->persistent_key_func == NULL) + table->persistent_key_func = funcs->persistent_key_func; + if (table->free_temporary_key_func == NULL) + table->free_temporary_key_func = funcs->free_temporary_key_func; + if (table->fragment_table != NULL) { + /* + * The fragment hash table exists. + * + * Remove all entries and free fragment data for each entry. + * + * The keys, and anything to which they point, are freed by + * calling the table's key freeing function. The values + * are freed in free_all_fragments(). + */ + g_hash_table_foreach_remove(table->fragment_table, + free_all_fragments, NULL); + } else { + /* The fragment table does not exist. Create it */ + table->fragment_table = g_hash_table_new_full(funcs->hash_func, + funcs->equal_func, funcs->free_persistent_key_func, NULL); + } + + if (table->reassembled_table != NULL) { + /* + * The reassembled-packet hash table exists. + * + * Remove all entries and free reassembled packet + * data and key for each entry. + */ + g_hash_table_remove_all(table->reassembled_table); + } else { + /* The fragment table does not exist. Create it */ + table->reassembled_table = g_hash_table_new_full(reassembled_hash, + reassembled_equal, reassembled_key_free, unref_fd_head); + } +} + +/* + * Destroy a reassembly table. + */ +void +reassembly_table_destroy(reassembly_table *table) +{ + /* + * Clear the function pointers. + */ + table->temporary_key_func = NULL; + table->persistent_key_func = NULL; + table->free_temporary_key_func = NULL; + if (table->fragment_table != NULL) { + /* + * The fragment hash table exists. + * + * Remove all entries and free fragment data for each entry. + * + * The keys, and anything to which they point, are freed by + * calling the table's key freeing function. The values + * are freed in free_all_fragments(). + */ + g_hash_table_foreach_remove(table->fragment_table, + free_all_fragments, NULL); + + /* + * Now destroy the hash table. + */ + g_hash_table_destroy(table->fragment_table); + table->fragment_table = NULL; + } + if (table->reassembled_table != NULL) { + /* + * The reassembled-packet hash table exists. + * + * Remove all entries and free reassembled packet + * data and key for each entry. + */ + + g_hash_table_remove_all(table->reassembled_table); + + /* + * Now destroy the hash table. + */ + g_hash_table_destroy(table->reassembled_table); + table->reassembled_table = NULL; + } +} + +/* + * Look up an fd_head in the fragment table, optionally returning the key + * for it. + */ +static fragment_head * +lookup_fd_head(reassembly_table *table, const packet_info *pinfo, + const guint32 id, const void *data, gpointer *orig_keyp) +{ + gpointer key; + gpointer value; + + /* Create key to search hash with */ + key = table->temporary_key_func(pinfo, id, data); + + /* + * Look up the reassembly in the fragment table. + */ + if (!g_hash_table_lookup_extended(table->fragment_table, key, orig_keyp, + &value)) + value = NULL; + /* Free the key */ + table->free_temporary_key_func(key); + + return (fragment_head *)value; +} + +/* + * Insert an fd_head into the fragment table, and return the key used. + */ +static gpointer +insert_fd_head(reassembly_table *table, fragment_head *fd_head, + const packet_info *pinfo, const guint32 id, const void *data) +{ + gpointer key; + + /* + * We're going to use the key to insert the fragment, + * so make a persistent version of it. + */ + key = table->persistent_key_func(pinfo, id, data); + g_hash_table_insert(table->fragment_table, key, fd_head); + return key; +} + +/* This function cleans up the stored state and removes the reassembly data and + * (with one exception) all allocated memory for matching reassembly. + * + * The exception is : + * If the PDU was already completely reassembled, then the tvbuff containing the + * reassembled data WILL NOT be free()d, and the pointer to that tvbuff will be + * returned. + * Othervise the function will return NULL. + * + * So, if you call fragment_delete and it returns non-NULL, YOU are responsible + * to tvb_free() that tvbuff. + */ +tvbuff_t * +fragment_delete(reassembly_table *table, const packet_info *pinfo, + const guint32 id, const void *data) +{ + fragment_head *fd_head; + fragment_item *fd; + tvbuff_t *fd_tvb_data=NULL; + gpointer key; + + fd_head = lookup_fd_head(table, pinfo, id, data, &key); + if(fd_head==NULL){ + /* We do not recognize this as a PDU we have seen before. return */ + return NULL; + } + + fd_tvb_data=fd_head->tvb_data; + /* loop over all partial fragments and free any tvbuffs */ + for(fd=fd_head->next;fd;){ + fragment_item *tmp_fd; + tmp_fd=fd->next; + + if (fd->tvb_data && !(fd->flags & FD_SUBSET_TVB)) + tvb_free(fd->tvb_data); + g_slice_free(fragment_item, fd); + fd=tmp_fd; + } + g_slice_free(fragment_head, fd_head); + g_hash_table_remove(table->fragment_table, key); + + return fd_tvb_data; +} + +/* This function is used to check if there is partial or completed reassembly state + * matching this packet. I.e. Is there reassembly going on or not for this packet? + */ +fragment_head * +fragment_get(reassembly_table *table, const packet_info *pinfo, + const guint32 id, const void *data) +{ + return lookup_fd_head(table, pinfo, id, data, NULL); +} + +fragment_head * +fragment_get_reassembled_id(reassembly_table *table, const packet_info *pinfo, + const guint32 id) +{ + fragment_head *fd_head; + reassembled_key key; + + /* create key to search hash with */ + key.frame = pinfo->num; + key.id = id; + fd_head = (fragment_head *)g_hash_table_lookup(table->reassembled_table, &key); + + return fd_head; +} + +/* To specify the offset for the fragment numbering, the first fragment is added with 0, and + * afterwards this offset is set. All additional calls to off_seq_check will calculate + * the number in sequence in regards to the offset */ +void +fragment_add_seq_offset(reassembly_table *table, const packet_info *pinfo, const guint32 id, + const void *data, const guint32 fragment_offset) +{ + fragment_head *fd_head; + + fd_head = lookup_fd_head(table, pinfo, id, data, NULL); + if (!fd_head) + return; + + /* Reseting the offset is not allowed */ + if ( fd_head->fragment_nr_offset != 0 ) + return; + + fd_head->fragment_nr_offset = fragment_offset; +} + +static void +update_first_gap(fragment_head *fd_head, fragment_item *inserted, gboolean multi_insert) +{ + guint32 frag_end = inserted->offset + inserted->len; + fragment_item *iter; + guint32 contiguous; + + if (inserted->offset > fd_head->contiguous_len) { + /* first inserted node is after first gap */ + return; + } else if (fd_head->first_gap == NULL) { + /* we haven't seen first fragment yet */ + if (inserted->offset != 0) { + /* inserted node is not first fragment */ + return; + } + contiguous = inserted->len; + iter = inserted; + } else { + contiguous = MAX(fd_head->contiguous_len, frag_end); + iter = multi_insert ? inserted : fd_head->first_gap; + } + + while (iter->next) { + if (iter->next->offset > contiguous) { + break; + } + iter = iter->next; + contiguous = MAX(contiguous, iter->offset + iter->len); + } + + /* iter is either pointing to last fragment before gap or tail */ + fd_head->first_gap = iter; + fd_head->contiguous_len = contiguous; +} + +/* + * Keeping first gap and contiguous length in sync significantly speeds up + * LINK_FRAG() when fragments in capture file are mostly ordered. However, when + * fragments are removed from the list, the first gap can point to fragments + * that were either moved to another list or freed. Therefore when any fragment + * before first gap is removed, the first gap (and contiguous length) must be + * invalidated. + */ +static void fragment_reset_first_gap(fragment_head *fd_head) +{ + fd_head->first_gap = NULL; + fd_head->contiguous_len = 0; + if (fd_head->next) { + gboolean multi_insert = (fd_head->next->next != NULL); + update_first_gap(fd_head, fd_head->next, multi_insert); + } +} + +/* + * Determines whether list modification requires first gap reset. On entry + * modified is NULL if all elements were removed, otherwise it points to + * element (reachable from fd_head) whose next pointer was changed. + */ +static void fragment_items_removed(fragment_head *fd_head, fragment_item *modified) +{ + if ((fd_head->first_gap == modified) || + ((modified != NULL) && (modified->offset > fd_head->contiguous_len))) { + /* Removed elements were after first gap */ + return; + } + fragment_reset_first_gap(fd_head); +} + +/* + * For use with fragment_add (and not the fragment_add_seq functions). + * When the reassembled result is wrong (perhaps it needs to be extended), this + * function clears any previous reassembly result, allowing the new reassembled + * length to be set again. + */ +static void +fragment_reset_defragmentation(fragment_head *fd_head) +{ + /* Caller must ensure that this function is only called when + * defragmentation is safe to undo. */ + DISSECTOR_ASSERT(fd_head->flags & FD_DEFRAGMENTED); + + for (fragment_item *fd_i = fd_head->next; fd_i; fd_i = fd_i->next) { + if (!fd_i->tvb_data) { + fd_i->tvb_data = tvb_new_subset_remaining(fd_head->tvb_data, fd_i->offset); + fd_i->flags |= FD_SUBSET_TVB; + } + fd_i->flags &= (~FD_TOOLONGFRAGMENT) & (~FD_MULTIPLETAILS); + } + fd_head->flags &= ~(FD_DEFRAGMENTED|FD_PARTIAL_REASSEMBLY|FD_DATALEN_SET); + fd_head->flags &= ~(FD_TOOLONGFRAGMENT|FD_MULTIPLETAILS); + fd_head->datalen = 0; + fd_head->reassembled_in = 0; + fd_head->reas_in_layer_num = 0; +} + +/* This function can be used to explicitly set the total length (if known) + * for reassembly of a PDU. + * This is useful for reassembly of PDUs where one may have the total length specified + * in the first fragment instead of as for, say, IPv4 where a flag indicates which + * is the last fragment. + * + * Such protocols might fragment_add with a more_frags==TRUE for every fragment + * and just tell the reassembly engine the expected total length of the reassembled data + * using fragment_set_tot_len immediately after doing fragment_add for the first packet. + * + * Note that for FD_BLOCKSEQUENCE tot_len is the index for the tail fragment. + * i.e. since the block numbers start at 0, if we specify tot_len==2, that + * actually means we want to defragment 3 blocks, block 0, 1 and 2. + */ +void +fragment_set_tot_len(reassembly_table *table, const packet_info *pinfo, + const guint32 id, const void *data, const guint32 tot_len) +{ + fragment_head *fd_head; + fragment_item *fd; + guint32 max_offset = 0; + + fd_head = lookup_fd_head(table, pinfo, id, data, NULL); + if (!fd_head) + return; + + /* If we're setting a block sequence number, verify that it + * doesn't conflict with values set by existing fragments. + * XXX - eliminate this check? + */ + if (fd_head->flags & FD_BLOCKSEQUENCE) { + for (fd = fd_head->next; fd; fd = fd->next) { + if (fd->offset > max_offset) { + max_offset = fd->offset; + if (max_offset > tot_len) { + fd_head->error = "Bad total reassembly block count"; + THROW_MESSAGE(ReassemblyError, fd_head->error); + } + } + } + } + + if (fd_head->flags & FD_DEFRAGMENTED) { + if (max_offset != tot_len) { + fd_head->error = "Defragmented complete but total length not satisfied"; + THROW_MESSAGE(ReassemblyError, fd_head->error); + } + } + + /* We got this far so the value is sane. */ + fd_head->datalen = tot_len; + fd_head->flags |= FD_DATALEN_SET; +} + +void +fragment_reset_tot_len(reassembly_table *table, const packet_info *pinfo, + const guint32 id, const void *data, const guint32 tot_len) +{ + fragment_head *fd_head; + + fd_head = lookup_fd_head(table, pinfo, id, data, NULL); + if (!fd_head) + return; + + /* + * If FD_PARTIAL_REASSEMBLY is set, it would make the next fragment_add + * call set the reassembled length based on the fragment offset and + * length. As the length is known now, be sure to disable that magic. + */ + fd_head->flags &= ~FD_PARTIAL_REASSEMBLY; + + /* If the length is already as expected, there is nothing else to do. */ + if (tot_len == fd_head->datalen) + return; + + if (fd_head->flags & FD_DEFRAGMENTED) { + /* + * Fragments were reassembled before, clear it to allow + * increasing the reassembled length. + */ + fragment_reset_defragmentation(fd_head); + } + + fd_head->datalen = tot_len; + fd_head->flags |= FD_DATALEN_SET; +} + +void +fragment_truncate(reassembly_table *table, const packet_info *pinfo, + const guint32 id, const void *data, const guint32 tot_len) + +{ + tvbuff_t *old_tvb_data; + fragment_head *fd_head; + + fd_head = lookup_fd_head(table, pinfo, id, data, NULL); + if (!fd_head) + return; + + /* Caller must ensure that this function is only called when + * we are defragmented. */ + DISSECTOR_ASSERT(fd_head->flags & FD_DEFRAGMENTED); + + /* + * If FD_PARTIAL_REASSEMBLY is set, it would make the next fragment_add + * call set the reassembled length based on the fragment offset and + * length. As the length is known now, be sure to disable that magic. + */ + fd_head->flags &= ~FD_PARTIAL_REASSEMBLY; + + /* If the length is already as expected, there is nothing else to do. */ + if (tot_len == fd_head->datalen) + return; + + DISSECTOR_ASSERT(fd_head->datalen > tot_len); + + old_tvb_data=fd_head->tvb_data; + fd_head->tvb_data = tvb_clone_offset_len(old_tvb_data, 0, tot_len); + tvb_set_free_cb(fd_head->tvb_data, g_free); + + if (old_tvb_data) + tvb_add_to_chain(fd_head->tvb_data, old_tvb_data); + fd_head->datalen = tot_len; + + /* Keep the fragments before the split point, dividing any if + * necessary. + * XXX: In rare cases, there might be fragments marked as overlap that + * have data both before and after the split point, and which only + * overlap after the split point. In that case, after dividing the + * fragments the first part no longer overlap. + * However, at this point we can't test for overlap conflicts, + * so we'll just leave the overlap flags as-is. + */ + fd_head->flags &= ~(FD_OVERLAP|FD_OVERLAPCONFLICT|FD_TOOLONGFRAGMENT|FD_MULTIPLETAILS); + fragment_item *fd_i, *prev_fd = NULL; + for (fd_i = fd_head->next; fd_i && (fd_i->offset < tot_len); fd_i = fd_i->next) { + fd_i->flags &= ~(FD_TOOLONGFRAGMENT|FD_MULTIPLETAILS); + /* Check for the split point occuring in the middle of the + * fragment. */ + if (fd_i->offset + fd_i->len > tot_len) { + fd_i->len = tot_len - fd_i->offset; + } + fd_head->flags |= fd_i->flags & (FD_OVERLAP|FD_OVERLAPCONFLICT); + prev_fd = fd_i; + + /* Below should do nothing since this is already defragmented */ + if (fd_i->flags & FD_SUBSET_TVB) + fd_i->flags &= ~FD_SUBSET_TVB; + else if (fd_i->tvb_data) + tvb_free(fd_i->tvb_data); + + fd_i->tvb_data=NULL; + } + + /* Remove all the other fragments, as they are past the split point. */ + if (prev_fd) { + prev_fd->next = NULL; + } else { + fd_head->next = NULL; + } + fd_head->contiguous_len = MIN(fd_head->contiguous_len, tot_len); + fragment_items_removed(fd_head, prev_fd); + fragment_item *tmp_fd; + for (; fd_i; fd_i = tmp_fd) { + tmp_fd=fd_i->next; + + if (fd_i->tvb_data && !(fd_i->flags & FD_SUBSET_TVB)) + tvb_free(fd_i->tvb_data); + g_slice_free(fragment_item, fd_i); + } +} + +guint32 +fragment_get_tot_len(reassembly_table *table, const packet_info *pinfo, + const guint32 id, const void *data) +{ + fragment_head *fd_head; + + fd_head = lookup_fd_head(table, pinfo, id, data, NULL); + + if(fd_head){ + return fd_head->datalen; + } + + return 0; +} + +/* This function will set the partial reassembly flag for a fh. + When this function is called, the fh MUST already exist, i.e. + the fh MUST be created by the initial call to fragment_add() before + this function is called. + Also note that this function MUST be called to indicate a fh will be + extended (increase the already stored data) +*/ + +void +fragment_set_partial_reassembly(reassembly_table *table, + const packet_info *pinfo, const guint32 id, + const void *data) +{ + fragment_head *fd_head; + + fd_head = lookup_fd_head(table, pinfo, id, data, NULL); + + /* + * XXX - why not do all the stuff done early in "fragment_add_work()", + * turning off FD_DEFRAGMENTED and pointing the fragments' data + * pointers to the appropriate part of the already-reassembled + * data, and clearing the data length and "reassembled in" frame + * number, here? We currently have a hack in the TCP dissector + * not to set the "reassembled in" value if the "partial reassembly" + * flag is set, so that in the first pass through the packets + * we don't falsely set a packet as reassembled in that packet + * if the dissector decided that even more reassembly was needed. + */ + if(fd_head){ + fd_head->flags |= FD_PARTIAL_REASSEMBLY; + } +} + +/* + * This function gets rid of an entry from a fragment table, given + * a pointer to the key for that entry. + * + * The key freeing routine will be called by g_hash_table_remove(). + */ +static void +fragment_unhash(reassembly_table *table, gpointer key) +{ + /* + * Remove the entry from the fragment table. + */ + g_hash_table_remove(table->fragment_table, key); +} + +/* + * This function adds fragment_head structure to a reassembled-packet + * hash table, using the frame numbers of each of the frames from + * which it was reassembled as keys, and sets the "reassembled_in" + * frame number. + */ +static void +fragment_reassembled(reassembly_table *table, fragment_head *fd_head, + const packet_info *pinfo, const guint32 id) +{ + reassembled_key *new_key; + fragment_item *fd; + + fd_head->ref_count = 0; + if (fd_head->next == NULL) { + /* + * This was not fragmented, so there's no fragment + * table; just hash it using the current frame number. + */ + new_key = g_slice_new(reassembled_key); + new_key->frame = pinfo->num; + new_key->id = id; + reassembled_table_insert(table->reassembled_table, new_key, fd_head); + } else { + /* + * Hash it with the frame numbers for all the frames. + */ + for (fd = fd_head->next; fd != NULL; fd = fd->next){ + new_key = g_slice_new(reassembled_key); + new_key->frame = fd->frame; + new_key->id = id; + reassembled_table_insert(table->reassembled_table, new_key, fd_head); + } + } + fd_head->flags |= FD_DEFRAGMENTED; + fd_head->reassembled_in = pinfo->num; + fd_head->reas_in_layer_num = pinfo->curr_layer_num; +} + +/* + * This function is a variant of the above for the single sequence + * case, using id+offset (i.e., the original sequence number) for the id + * in the key. + */ +static void +fragment_reassembled_single(reassembly_table *table, fragment_head *fd_head, + const packet_info *pinfo, const guint32 id) +{ + reassembled_key *new_key; + fragment_item *fd; + + fd_head->ref_count = 0; + if (fd_head->next == NULL) { + /* + * This was not fragmented, so there's no fragment + * table; just hash it using the current frame number. + */ + new_key = g_slice_new(reassembled_key); + new_key->frame = pinfo->num; + new_key->id = id; + reassembled_table_insert(table->reassembled_table, new_key, fd_head); + } else { + /* + * Hash it with the frame numbers for all the frames. + */ + for (fd = fd_head->next; fd != NULL; fd = fd->next){ + new_key = g_slice_new(reassembled_key); + new_key->frame = fd->frame; + new_key->id = id + fd->offset; + reassembled_table_insert(table->reassembled_table, new_key, fd_head); + } + } + fd_head->flags |= FD_DEFRAGMENTED; + fd_head->reassembled_in = pinfo->num; + fd_head->reas_in_layer_num = pinfo->curr_layer_num; +} + +static void +LINK_FRAG(fragment_head *fd_head,fragment_item *fd) +{ + fragment_item *fd_i; + + /* add fragment to list, keep list sorted */ + if (fd_head->next == NULL || fd->offset < fd_head->next->offset) { + /* New first fragment */ + fd->next = fd_head->next; + fd_head->next = fd; + } else { + fd_i = fd_head->next; + if (fd_head->first_gap != NULL) { + if (fd->offset >= fd_head->first_gap->offset) { + /* fragment is after first gap */ + fd_i = fd_head->first_gap; + } + } + for(; fd_i->next; fd_i=fd_i->next) { + if (fd->offset < fd_i->next->offset ) + break; + } + fd->next = fd_i->next; + fd_i->next = fd; + } + + update_first_gap(fd_head, fd, FALSE); +} + +static void +MERGE_FRAG(fragment_head *fd_head, fragment_item *fd) +{ + fragment_item *fd_i, *tmp, *inserted = fd; + gboolean multi_insert; + + if (fd == NULL) return; + + multi_insert = (fd->next != NULL); + + if (fd_head->next == NULL) { + fd_head->next = fd; + update_first_gap(fd_head, fd, multi_insert); + return; + } + + if ((fd_head->first_gap != NULL) && + (fd->offset >= fd_head->first_gap->offset)) { + /* all new fragments go after first gap */ + fd_i = fd_head->first_gap; + } else { + /* at least one new fragment goes before first gap */ + if (fd->offset < fd_head->next->offset) { + /* inserted fragment is new head, "swap" the lists */ + tmp = fd_head->next; + fd_head->next = fd; + fd = tmp; + } + fd_i = fd_head->next; + } + + /* Traverse the list linked to fragment head ("main" list), checking if + * fd pointer ("merge" list) should go before or after fd_i->next. Swap + * fd_i->next ("main") and fd pointers ("merge") if "merge" list should + * go before iterated element (fd_i). After the swap what formerly was + * "merge" list essentially becomes part of "main" list (just detached + * element, i.e. fd, is now head of new "merge list"). + */ + for(; fd_i->next; fd_i=fd_i->next) { + if (fd->offset < fd_i->next->offset) { + tmp = fd_i->next; + fd_i->next = fd; + fd = tmp; + } + } + /* Reached "main" list end, attach remaining elements */ + fd_i->next = fd; + + update_first_gap(fd_head, inserted, multi_insert); +} + +/* + * This function adds a new fragment to the fragment hash table. + * If this is the first fragment seen for this datagram, a new entry + * is created in the hash table, otherwise this fragment is just added + * to the linked list of fragments for this packet. + * The list of fragments for a specific datagram is kept sorted for + * easier handling. + * + * Returns a pointer to the head of the fragment data list if we have all the + * fragments, NULL otherwise. + * + * This function assumes frag_offset being a byte offset into the defragment + * packet. + * + * 01-2002 + * Once the fh is defragmented (= FD_DEFRAGMENTED set), it can be + * extended using the FD_PARTIAL_REASSEMBLY flag. This flag should be set + * using fragment_set_partial_reassembly() before calling fragment_add + * with the new fragment. FD_TOOLONGFRAGMENT and FD_MULTIPLETAILS flags + * are lowered when a new extension process is started. + */ +static gboolean +fragment_add_work(fragment_head *fd_head, tvbuff_t *tvb, const int offset, + const packet_info *pinfo, const guint32 frag_offset, + const guint32 frag_data_len, const gboolean more_frags, + const guint32 frag_frame, const gboolean allow_overlaps) +{ + fragment_item *fd; + fragment_item *fd_i; + guint32 dfpos, fraglen, overlap; + tvbuff_t *old_tvb_data; + guint8 *data; + + /* create new fd describing this fragment */ + fd = g_slice_new(fragment_item); + fd->next = NULL; + fd->flags = 0; + fd->frame = frag_frame; + fd->offset = frag_offset; + fd->len = frag_data_len; + fd->tvb_data = NULL; + + /* + * Are we adding to an already-completed reassembly? + */ + if (fd_head->flags & FD_DEFRAGMENTED) { + /* + * Yes. Does this fragment go past the end of the results + * of that reassembly? + */ + if (frag_offset + frag_data_len > fd_head->datalen) { + /* + * Yes. Have we been requested to continue reassembly? + */ + if (fd_head->flags & FD_PARTIAL_REASSEMBLY) { + /* + * Yes. Set flag in already empty fds & + * point old fds to malloc'ed data. + */ + fragment_reset_defragmentation(fd_head); + } else if (!allow_overlaps) { + /* + * No. Bail out since we have no idea what to + * do with this fragment (and if we keep going + * we'll run past the end of a buffer sooner + * or later). + */ + g_slice_free(fragment_item, fd); + + /* + * This is an attempt to add a fragment to a + * reassembly that had already completed. + * If it had no error, we don't want to + * mark it with an error, and if it had an + * error, we don't want to overwrite it, so + * we don't set fd_head->error. + */ + if (frag_offset >= fd_head->datalen) { + /* + * The fragment starts past the end + * of the reassembled data. + */ + THROW_MESSAGE(ReassemblyError, "New fragment past old data limits"); + } else { + /* + * The fragment starts before the end + * of the reassembled data, but + * runs past the end. That could + * just be a retransmission with extra + * data, but the calling dissector + * didn't set FD_PARTIAL_REASSEMBLY + * so it won't be handled correctly. + * + * XXX: We could set FD_TOOLONGFRAGMENT + * below instead. + */ + THROW_MESSAGE(ReassemblyError, "New fragment overlaps old data (retransmission?)"); + } + } + } else { + /* + * No. That means it overlaps the completed reassembly. + * This is probably a retransmission and normal + * behavior. (If not, it's because the dissector + * doesn't handle reused sequence numbers correctly, + * e.g. #10503). Handle below. + */ + } + } + + /* Do this after we may have bailed out (above) so that we don't leave + * fd_head->frame in a bad state if we do */ + if (fd->frame > fd_head->frame) + fd_head->frame = fd->frame; + + if (!more_frags) { + /* + * This is the tail fragment in the sequence. + */ + if (fd_head->flags & FD_DATALEN_SET) { + /* ok we have already seen other tails for this packet + * it might be a duplicate. + */ + if (fd_head->datalen != (fd->offset + fd->len) ){ + /* Oops, this tail indicates a different packet + * len than the previous ones. Something's wrong. + */ + fd->flags |= FD_MULTIPLETAILS; + fd_head->flags |= FD_MULTIPLETAILS; + } + } else { + /* This was the first tail fragment; now we know + * what the length of the packet should be. + */ + fd_head->datalen = fd->offset + fd->len; + fd_head->flags |= FD_DATALEN_SET; + } + } + + + + /* If the packet is already defragmented, this MUST be an overlap. + * The entire defragmented packet is in fd_head->data. + * Even if we have previously defragmented this packet, we still + * check it. Someone might play overlap and TTL games. + */ + if (fd_head->flags & FD_DEFRAGMENTED) { + guint32 end_offset = fd->offset + fd->len; + fd->flags |= FD_OVERLAP; + fd_head->flags |= FD_OVERLAP; + /* make sure it's not too long */ + /* XXX: We probably don't call this, unlike the _seq() + * functions, because we throw an exception above. + */ + if (end_offset > fd_head->datalen || end_offset < fd->offset || end_offset < fd->len) { + fd->flags |= FD_TOOLONGFRAGMENT; + fd_head->flags |= FD_TOOLONGFRAGMENT; + } + /* make sure it doesn't conflict with previous data */ + else if ( tvb_memeql(fd_head->tvb_data, fd->offset, + tvb_get_ptr(tvb,offset,fd->len),fd->len) ){ + fd->flags |= FD_OVERLAPCONFLICT; + fd_head->flags |= FD_OVERLAPCONFLICT; + } + /* it was just an overlap, link it and return */ + LINK_FRAG(fd_head,fd); + return TRUE; + } + + + + /* If we have reached this point, the packet is not defragmented yet. + * Save all payload in a buffer until we can defragment. + */ + if (!tvb_bytes_exist(tvb, offset, fd->len)) { + g_slice_free(fragment_item, fd); + THROW(BoundsError); + } + fd->tvb_data = tvb_clone_offset_len(tvb, offset, fd->len); + LINK_FRAG(fd_head,fd); + + + if( !(fd_head->flags & FD_DATALEN_SET) ){ + /* if we don't know the datalen, there are still missing + * packets. Cheaper than the check below. + */ + return FALSE; + } + + /* Check if we have received the entire fragment. */ + if (fd_head->contiguous_len < fd_head->datalen) { + /* + * The amount of contiguous data we have is less than the + * amount of data we're trying to reassemble, so we haven't + * received all packets yet. + */ + return FALSE; + } + + /* we have received an entire packet, defragment it and + * free all fragments + */ + /* store old data just in case */ + old_tvb_data=fd_head->tvb_data; + data = (guint8 *) g_malloc(fd_head->datalen); + fd_head->tvb_data = tvb_new_real_data(data, fd_head->datalen, fd_head->datalen); + tvb_set_free_cb(fd_head->tvb_data, g_free); + + /* add all data fragments */ + for (dfpos=0,fd_i=fd_head->next;fd_i;fd_i=fd_i->next) { + if (fd_i->len) { + /* + * The contiguous length check above also + * ensures that the only gaps that exist here + * are ones where a fragment starts past the + * end of the reassembled datagram, and there's + * a gap between the previous fragment and + * that fragment. + * + * A "DESEGMENT_UNTIL_FIN" was involved wherein the + * FIN packet had an offset less than the highest + * fragment offset seen. [Seen from a fuzz-test: + * bug #2470]). + * + * Note that the "overlap" compare must only be + * done for fragments with (offset+len) <= fd_head->datalen + * and thus within the newly g_malloc'd buffer. + */ + + if (fd_i->offset >= fd_head->datalen) { + /* + * Fragment starts after the end + * of the reassembled packet. + * + * This can happen if the length was + * set after the offending fragment + * was added to the reassembly. + * + * Flag this fragment, but don't + * try to extract any data from + * it, as there's no place to put + * it. + * + * XXX - add different flag value + * for this. + */ + fd_i->flags |= FD_TOOLONGFRAGMENT; + fd_head->flags |= FD_TOOLONGFRAGMENT; + } else if (fd_i->offset + fd_i->len < fd_i->offset) { + /* Integer overflow, unhandled by rest of + * code so error out. This check handles + * all possible remaining overflows. + */ + fd_head->error = "offset + len < offset"; + } else if (!fd_i->tvb_data) { + fd_head->error = "no data"; + } else { + fraglen = fd_i->len; + if (fd_i->offset + fraglen > fd_head->datalen) { + /* + * Fragment goes past the end + * of the packet, as indicated + * by the last fragment. + * + * This can happen if the + * length was set after the + * offending fragment was + * added to the reassembly. + * + * Mark it as such, and only + * copy from it what fits in + * the packet. + */ + fd_i->flags |= FD_TOOLONGFRAGMENT; + fd_head->flags |= FD_TOOLONGFRAGMENT; + fraglen = fd_head->datalen - fd_i->offset; + } + overlap = dfpos - fd_i->offset; + /* Guaranteed to be >= 0, previous code + * has checked for gaps. */ + if (overlap) { + /* duplicate/retransmission/overlap */ + guint32 cmp_len = MIN(fd_i->len,overlap); + + fd_i->flags |= FD_OVERLAP; + fd_head->flags |= FD_OVERLAP; + if ( memcmp(data + fd_i->offset, + tvb_get_ptr(fd_i->tvb_data, 0, cmp_len), + cmp_len) + ) { + fd_i->flags |= FD_OVERLAPCONFLICT; + fd_head->flags |= FD_OVERLAPCONFLICT; + } + } + /* XXX: As in the fragment_add_seq funcs + * like fragment_defragment_and_free() the + * existing behavior does not overwrite + * overlapping bytes even if there is a + * conflict. It only adds new bytes. + * + * Since we only add fragments to a reassembly + * if the reassembly isn't complete, the most + * common case for overlap conflicts is when + * an earlier reassembly isn't fully contained + * in the capture, and we've reused an + * indentification number / wrapped around + * offset sequence numbers much later in the + * capture. In that case, we probably *do* + * want to overwrite conflicting bytes, since + * the earlier fragments didn't form a complete + * reassembly and should be effectively thrown + * out rather than mixed with the new ones? + */ + if (fd_i->offset + fraglen > dfpos) { + memcpy(data+dfpos, + tvb_get_ptr(fd_i->tvb_data, overlap, fraglen-overlap), + fraglen-overlap); + dfpos = fd_i->offset + fraglen; + } + } + + if (fd_i->flags & FD_SUBSET_TVB) + fd_i->flags &= ~FD_SUBSET_TVB; + else if (fd_i->tvb_data) + tvb_free(fd_i->tvb_data); + + fd_i->tvb_data=NULL; + } + } + + if (old_tvb_data) + tvb_add_to_chain(tvb, old_tvb_data); + /* mark this packet as defragmented. + allows us to skip any trailing fragments */ + fd_head->flags |= FD_DEFRAGMENTED; + fd_head->reassembled_in=pinfo->num; + fd_head->reas_in_layer_num = pinfo->curr_layer_num; + + /* we don't throw until here to avoid leaking old_data and others */ + if (fd_head->error) { + THROW_MESSAGE(ReassemblyError, fd_head->error); + } + + return TRUE; +} + +static fragment_head * +fragment_add_common(reassembly_table *table, tvbuff_t *tvb, const int offset, + const packet_info *pinfo, const guint32 id, + const void *data, const guint32 frag_offset, + const guint32 frag_data_len, const gboolean more_frags, + const gboolean check_already_added, + const guint32 frag_frame) +{ + fragment_head *fd_head; + fragment_item *fd_item; + gboolean already_added; + + + /* + * Dissector shouldn't give us garbage tvb info. + * + * XXX - should this code take responsibility for preventing + * reassembly if data is missing due to the packets being + * sliced, rather than leaving it up to dissectors? + */ + DISSECTOR_ASSERT(tvb_bytes_exist(tvb, offset, frag_data_len)); + + fd_head = lookup_fd_head(table, pinfo, id, data, NULL); + +#if 0 + /* debug output of associated fragments. */ + /* leave it here for future debugging sessions */ + if(strcmp(pinfo->current_proto, "DCERPC") == 0) { + printf("proto:%s num:%u id:%u offset:%u len:%u more:%u visited:%u\n", + pinfo->current_proto, pinfo->num, id, frag_offset, frag_data_len, more_frags, pinfo->fd->visited); + if(fd_head != NULL) { + for(fd_item=fd_head->next;fd_item;fd_item=fd_item->next){ + printf("fd_frame:%u fd_offset:%u len:%u datalen:%u\n", + fd_item->frame, fd_item->offset, fd_item->len, fd_item->datalen); + } + } + } +#endif + + /* + * Is this the first pass through the capture? + */ + if (!pinfo->fd->visited) { + /* + * Yes, so we could be doing reassembly. If + * "check_already_added" is true, and fd_head is non-null, + * meaning that this fragment would be added to an + * in-progress reassembly, check if we have seen this + * fragment before, i.e., if we have already added it to + * that reassembly. That can be true even on the first pass + * since we sometimes might call a subdissector multiple + * times. + * + * We check both the frame number and the fragment offset, + * so that we support multiple fragments from the same + * frame being added to the same reassembled PDU. + */ + if (check_already_added && fd_head != NULL) { + /* + * fd_head->frame is the maximum of the frame + * numbers of all the fragments added to this + * reassembly; if this frame is later than that + * frame, we know it hasn't been added yet. + */ + if (frag_frame <= fd_head->frame) { + already_added = FALSE; + /* + * The first item in the reassembly list + * is not a fragment, it's a data structure + * for the reassembled packet, so we + * start checking with the next item. + */ + for (fd_item = fd_head->next; fd_item; + fd_item = fd_item->next) { + if (frag_frame == fd_item->frame && + frag_offset == fd_item->offset) { + already_added = TRUE; + break; + } + } + if (already_added) { + /* + * Have we already finished + * reassembling? + */ + if (fd_head->flags & FD_DEFRAGMENTED) { + /* + * Yes. + * XXX - can this ever happen? + */ + THROW_MESSAGE(ReassemblyError, + "Frame already added in first pass"); + } else { + /* + * No. + */ + return NULL; + } + } + } + } + } else { + /* + * No, so we've already done all the reassembly and added + * all the fragments. Do we have a reassembly and, if so, + * have we finished reassembling? + */ + if (fd_head != NULL && fd_head->flags & FD_DEFRAGMENTED) { + /* + * Yes. This is probably being done after the + * first pass, and we've already done the work + * on the first pass. + * + * If the reassembly got a fatal error, throw that + * error again. + */ + if (fd_head->error) + THROW_MESSAGE(ReassemblyError, fd_head->error); + + /* + * Is it later in the capture than all of the + * fragments in the reassembly? + */ + if (frag_frame > fd_head->frame) { + /* + * Yes, so report this as a problem, + * possibly a retransmission. + */ + THROW_MESSAGE(ReassemblyError, "New fragment overlaps old data (retransmission?)"); + } + + /* + * Does this fragment go past the end of the + * results of that reassembly? + */ + if (frag_offset + frag_data_len > fd_head->datalen) { + /* + * Yes. + */ + if (frag_offset >= fd_head->datalen) { + /* + * The fragment starts past the + * end of the reassembled data. + */ + THROW_MESSAGE(ReassemblyError, "New fragment past old data limits"); + } else { + /* + * The fragment starts before the end + * of the reassembled data, but + * runs past the end. That could + * just be a retransmission. + */ + THROW_MESSAGE(ReassemblyError, "New fragment overlaps old data (retransmission?)"); + } + } + + return fd_head; + } else { + /* + * No. + */ + return NULL; + } + } + + if (fd_head==NULL){ + /* not found, this must be the first snooped fragment for this + * packet. Create list-head. + */ + fd_head = new_head(0); + + /* + * Insert it into the hash table. + */ + insert_fd_head(table, fd_head, pinfo, id, data); + } + + if (fragment_add_work(fd_head, tvb, offset, pinfo, frag_offset, + frag_data_len, more_frags, frag_frame, FALSE)) { + /* + * Reassembly is complete. + */ + return fd_head; + } else { + /* + * Reassembly isn't complete. + */ + return NULL; + } +} + +fragment_head * +fragment_add(reassembly_table *table, tvbuff_t *tvb, const int offset, + const packet_info *pinfo, const guint32 id, const void *data, + const guint32 frag_offset, const guint32 frag_data_len, + const gboolean more_frags) +{ + return fragment_add_common(table, tvb, offset, pinfo, id, data, + frag_offset, frag_data_len, more_frags, TRUE, pinfo->num); +} + +/* + * For use when you can have multiple fragments in the same frame added + * to the same reassembled PDU, e.g. with ONC RPC-over-TCP. + */ +fragment_head * +fragment_add_multiple_ok(reassembly_table *table, tvbuff_t *tvb, + const int offset, const packet_info *pinfo, + const guint32 id, const void *data, + const guint32 frag_offset, + const guint32 frag_data_len, const gboolean more_frags) +{ + return fragment_add_common(table, tvb, offset, pinfo, id, data, + frag_offset, frag_data_len, more_frags, FALSE, pinfo->num); +} + +/* + * For use in protocols like TCP when you are adding an out of order segment + * that arrived in an earlier frame because the correct fragment id could not + * be determined until later. By allowing fd->frame to be different than + * pinfo->num, show_fragment_tree will display the correct fragment numbers. + * + * Note that pinfo is still used to set reassembled_in if we have all the + * fragments, so that results on subsequent passes can be the same as the + * first pass. + */ +fragment_head * +fragment_add_out_of_order(reassembly_table *table, tvbuff_t *tvb, + const int offset, const packet_info *pinfo, + const guint32 id, const void *data, + const guint32 frag_offset, + const guint32 frag_data_len, + const gboolean more_frags, const guint32 frag_frame) +{ + return fragment_add_common(table, tvb, offset, pinfo, id, data, + frag_offset, frag_data_len, more_frags, TRUE, frag_frame); +} + +fragment_head * +fragment_add_check_with_fallback(reassembly_table *table, tvbuff_t *tvb, const int offset, + const packet_info *pinfo, const guint32 id, + const void *data, const guint32 frag_offset, + const guint32 frag_data_len, const gboolean more_frags, + const guint32 fallback_frame) +{ + reassembled_key reass_key; + fragment_head *fd_head; + gpointer orig_key; + gboolean late_retransmission = FALSE; + + /* + * If this isn't the first pass, look for this frame in the table + * of reassembled packets. + */ + if (pinfo->fd->visited) { + reass_key.frame = pinfo->num; + reass_key.id = id; + return (fragment_head *)g_hash_table_lookup(table->reassembled_table, &reass_key); + } + + /* Looks up a key in the GHashTable, returning the original key and the associated value + * and a gboolean which is TRUE if the key was found. This is useful if you need to free + * the memory allocated for the original key, for example before calling g_hash_table_remove() + */ + fd_head = lookup_fd_head(table, pinfo, id, data, &orig_key); + if ((fd_head == NULL) && (fallback_frame != pinfo->num)) { + /* Check if there is completed reassembly reachable from fallback frame */ + reass_key.frame = fallback_frame; + reass_key.id = id; + fd_head = (fragment_head *)g_hash_table_lookup(table->reassembled_table, &reass_key); + if (fd_head != NULL) { + /* Found completely reassembled packet, hash it with current frame number */ + reassembled_key *new_key = g_slice_new(reassembled_key); + new_key->frame = pinfo->num; + new_key->id = id; + reassembled_table_insert(table->reassembled_table, new_key, fd_head); + late_retransmission = TRUE; + } + } + if (fd_head == NULL) { + /* not found, this must be the first snooped fragment for this + * packet. Create list-head. + */ + fd_head = new_head(0); + + /* + * Save the key, for unhashing it later. + */ + orig_key = insert_fd_head(table, fd_head, pinfo, id, data); + } + + /* + * If this is a short frame, then we can't, and don't, do + * reassembly on it. We just give up. + */ + if (!tvb_bytes_exist(tvb, offset, frag_data_len)) { + return NULL; + } + + if (fragment_add_work(fd_head, tvb, offset, pinfo, frag_offset, + frag_data_len, more_frags, pinfo->num, late_retransmission)) { + /* Nothing left to do if it was a late retransmission */ + if (late_retransmission) { + return fd_head; + } + /* + * Reassembly is complete. + * Remove this from the table of in-progress + * reassemblies, add it to the table of + * reassembled packets, and return it. + */ + + /* + * Remove this from the table of in-progress reassemblies, + * and free up any memory used for it in that table. + */ + fragment_unhash(table, orig_key); + + /* + * Add this item to the table of reassembled packets. + */ + fragment_reassembled(table, fd_head, pinfo, id); + return fd_head; + } else { + /* + * Reassembly isn't complete. + */ + return NULL; + } +} + +fragment_head * +fragment_add_check(reassembly_table *table, tvbuff_t *tvb, const int offset, + const packet_info *pinfo, const guint32 id, + const void *data, const guint32 frag_offset, + const guint32 frag_data_len, const gboolean more_frags) +{ + return fragment_add_check_with_fallback(table, tvb, offset, pinfo, id, data, + frag_offset, frag_data_len, more_frags, pinfo->num); +} + +static void +fragment_defragment_and_free (fragment_head *fd_head, const packet_info *pinfo) +{ + fragment_item *fd_i = NULL; + fragment_item *last_fd = NULL; + guint32 dfpos = 0, size = 0; + tvbuff_t *old_tvb_data = NULL; + guint8 *data; + + for(fd_i=fd_head->next;fd_i;fd_i=fd_i->next) { + if(!last_fd || last_fd->offset!=fd_i->offset){ + size+=fd_i->len; + } + last_fd=fd_i; + } + + /* store old data in case the fd_i->data pointers refer to it */ + old_tvb_data=fd_head->tvb_data; + data = (guint8 *) g_malloc(size); + fd_head->tvb_data = tvb_new_real_data(data, size, size); + tvb_set_free_cb(fd_head->tvb_data, g_free); + fd_head->len = size; /* record size for caller */ + + /* add all data fragments */ + last_fd=NULL; + for (fd_i=fd_head->next; fd_i; fd_i=fd_i->next) { + if (fd_i->len) { + if(!last_fd || last_fd->offset != fd_i->offset) { + /* First fragment or in-sequence fragment */ + memcpy(data+dfpos, tvb_get_ptr(fd_i->tvb_data, 0, fd_i->len), fd_i->len); + dfpos += fd_i->len; + } else { + /* duplicate/retransmission/overlap */ + fd_i->flags |= FD_OVERLAP; + fd_head->flags |= FD_OVERLAP; + if(last_fd->len != fd_i->len + || tvb_memeql(last_fd->tvb_data, 0, tvb_get_ptr(fd_i->tvb_data, 0, last_fd->len), last_fd->len) ) { + fd_i->flags |= FD_OVERLAPCONFLICT; + fd_head->flags |= FD_OVERLAPCONFLICT; + } + } + } + last_fd=fd_i; + } + + /* we have defragmented the pdu, now free all fragments*/ + for (fd_i=fd_head->next;fd_i;fd_i=fd_i->next) { + if (fd_i->flags & FD_SUBSET_TVB) + fd_i->flags &= ~FD_SUBSET_TVB; + else if (fd_i->tvb_data) + tvb_free(fd_i->tvb_data); + fd_i->tvb_data=NULL; + } + if (old_tvb_data) + tvb_free(old_tvb_data); + + /* mark this packet as defragmented. + * allows us to skip any trailing fragments. + */ + fd_head->flags |= FD_DEFRAGMENTED; + fd_head->reassembled_in=pinfo->num; + fd_head->reas_in_layer_num = pinfo->curr_layer_num; +} + +/* + * This function adds a new fragment to the entry for a reassembly + * operation. + * + * The list of fragments for a specific datagram is kept sorted for + * easier handling. + * + * Returns TRUE if we have all the fragments, FALSE otherwise. + * + * This function assumes frag_number being a block sequence number. + * The bsn for the first block is 0. + */ +static gboolean +fragment_add_seq_work(fragment_head *fd_head, tvbuff_t *tvb, const int offset, + const packet_info *pinfo, const guint32 frag_number, + const guint32 frag_data_len, const gboolean more_frags) +{ + fragment_item *fd; + fragment_item *fd_i; + fragment_item *last_fd; + guint32 max, dfpos; + guint32 frag_number_work; + + /* Enables the use of fragment sequence numbers, which do not start with 0 */ + frag_number_work = frag_number; + if ( fd_head->fragment_nr_offset != 0 ) + if ( frag_number_work >= fd_head->fragment_nr_offset ) + frag_number_work = frag_number - fd_head->fragment_nr_offset; + + /* if the partial reassembly flag has been set, and we are extending + * the pdu, un-reassemble the pdu. This means pointing old fds to malloc'ed data. + */ + if(fd_head->flags & FD_DEFRAGMENTED && frag_number_work >= fd_head->datalen && + fd_head->flags & FD_PARTIAL_REASSEMBLY){ + guint32 lastdfpos = 0; + dfpos = 0; + for(fd_i=fd_head->next; fd_i; fd_i=fd_i->next){ + if( !fd_i->tvb_data ) { + if( fd_i->flags & FD_OVERLAP ) { + /* this is a duplicate of the previous + * fragment. */ + fd_i->tvb_data = tvb_new_subset_remaining(fd_head->tvb_data, lastdfpos); + } else { + fd_i->tvb_data = tvb_new_subset_remaining(fd_head->tvb_data, dfpos); + lastdfpos = dfpos; + dfpos += fd_i->len; + } + fd_i->flags |= FD_SUBSET_TVB; + } + fd_i->flags &= (~FD_TOOLONGFRAGMENT) & (~FD_MULTIPLETAILS); + } + fd_head->flags &= ~(FD_DEFRAGMENTED|FD_PARTIAL_REASSEMBLY|FD_DATALEN_SET); + fd_head->flags &= (~FD_TOOLONGFRAGMENT) & (~FD_MULTIPLETAILS); + fd_head->datalen=0; + fd_head->reassembled_in=0; + fd_head->reas_in_layer_num = 0; + } + + + /* create new fd describing this fragment */ + fd = g_slice_new(fragment_item); + fd->next = NULL; + fd->flags = 0; + fd->frame = pinfo->num; + fd->offset = frag_number_work; + fd->len = frag_data_len; + fd->tvb_data = NULL; + + /* fd_head->frame is the maximum of the frame numbers of all the + * fragments added to the reassembly. */ + if (fd->frame > fd_head->frame) + fd_head->frame = fd->frame; + + if (!more_frags) { + /* + * This is the tail fragment in the sequence. + */ + if (fd_head->flags&FD_DATALEN_SET) { + /* ok we have already seen other tails for this packet + * it might be a duplicate. + */ + if (fd_head->datalen != fd->offset ){ + /* Oops, this tail indicates a different packet + * len than the previous ones. Something's wrong. + */ + fd->flags |= FD_MULTIPLETAILS; + fd_head->flags |= FD_MULTIPLETAILS; + } + } else { + /* this was the first tail fragment, now we know the + * sequence number of that fragment (which is NOT + * the length of the packet!) + */ + fd_head->datalen = fd->offset; + fd_head->flags |= FD_DATALEN_SET; + } + } + + /* If the packet is already defragmented, this MUST be an overlap. + * The entire defragmented packet is in fd_head->data + * Even if we have previously defragmented this packet, we still check + * check it. Someone might play overlap and TTL games. + */ + if (fd_head->flags & FD_DEFRAGMENTED) { + fd->flags |= FD_OVERLAP; + fd_head->flags |= FD_OVERLAP; + + /* make sure it's not past the end */ + if (fd->offset > fd_head->datalen) { + /* new fragment comes after the end */ + fd->flags |= FD_TOOLONGFRAGMENT; + fd_head->flags |= FD_TOOLONGFRAGMENT; + LINK_FRAG(fd_head,fd); + return TRUE; + } + /* make sure it doesn't conflict with previous data */ + dfpos=0; + last_fd=NULL; + for (fd_i=fd_head->next;fd_i && (fd_i->offset!=fd->offset);fd_i=fd_i->next) { + if (!last_fd || last_fd->offset!=fd_i->offset){ + dfpos += fd_i->len; + } + last_fd=fd_i; + } + if(fd_i){ + /* new fragment overlaps existing fragment */ + if(fd_i->len!=fd->len){ + /* + * They have different lengths; this + * is definitely a conflict. + */ + fd->flags |= FD_OVERLAPCONFLICT; + fd_head->flags |= FD_OVERLAPCONFLICT; + LINK_FRAG(fd_head,fd); + return TRUE; + } + DISSECTOR_ASSERT(fd_head->len >= dfpos + fd->len); + if (tvb_memeql(fd_head->tvb_data, dfpos, + tvb_get_ptr(tvb,offset,fd->len),fd->len) ){ + /* + * They have the same length, but the + * data isn't the same. + */ + fd->flags |= FD_OVERLAPCONFLICT; + fd_head->flags |= FD_OVERLAPCONFLICT; + LINK_FRAG(fd_head,fd); + return TRUE; + } + /* it was just an overlap, link it and return */ + LINK_FRAG(fd_head,fd); + return TRUE; + } else { + /* + * New fragment doesn't overlap an existing + * fragment - there was presumably a gap in + * the sequence number space. + * + * XXX - what should we do here? Is it always + * the case that there are no gaps, or are there + * protcols using sequence numbers where there + * can be gaps? + * + * If the former, the check below for having + * received all the fragments should check for + * holes in the sequence number space and for the + * first sequence number being 0. If we do that, + * the only way we can get here is if this fragment + * is past the end of the sequence number space - + * but the check for "fd->offset > fd_head->datalen" + * would have caught that above, so it can't happen. + * + * If the latter, we don't have a good way of + * knowing whether reassembly is complete if we + * get packet out of order such that the "last" + * fragment doesn't show up last - but, unless + * in-order reliable delivery of fragments is + * guaranteed, an implementation of the protocol + * has no way of knowing whether reassembly is + * complete, either. + * + * For now, we just link the fragment in and + * return. + */ + LINK_FRAG(fd_head,fd); + return TRUE; + } + } + + /* If we have reached this point, the packet is not defragmented yet. + * Save all payload in a buffer until we can defragment. + */ + /* check len, there may be a fragment with 0 len, that is actually the tail */ + if (fd->len) { + if (!tvb_bytes_exist(tvb, offset, fd->len)) { + /* abort if we didn't capture the entire fragment due + * to a too-short snapshot length */ + g_slice_free(fragment_item, fd); + return FALSE; + } + + fd->tvb_data = tvb_clone_offset_len(tvb, offset, fd->len); + } + LINK_FRAG(fd_head,fd); + + + if( !(fd_head->flags & FD_DATALEN_SET) ){ + /* if we don't know the sequence number of the last fragment, + * there are definitely still missing packets. Cheaper than + * the check below. + */ + return FALSE; + } + + + /* check if we have received the entire fragment + * this is easy since the list is sorted and the head is faked. + * common case the whole list is scanned. + */ + max = 0; + for(fd_i=fd_head->next;fd_i;fd_i=fd_i->next) { + if ( fd_i->offset==max ){ + max++; + } + } + /* max will now be datalen+1 if all fragments have been seen */ + + if (max <= fd_head->datalen) { + /* we have not received all packets yet */ + return FALSE; + } + + + if (max > (fd_head->datalen+1)) { + /* oops, too long fragment detected */ + fd->flags |= FD_TOOLONGFRAGMENT; + fd_head->flags |= FD_TOOLONGFRAGMENT; + } + + + /* we have received an entire packet, defragment it and + * free all fragments + */ + fragment_defragment_and_free(fd_head, pinfo); + + return TRUE; +} + +/* + * This function adds a new fragment to the fragment hash table. + * If this is the first fragment seen for this datagram, a new entry + * is created in the hash table, otherwise this fragment is just added + * to the linked list of fragments for this packet. + * + * Returns a pointer to the head of the fragment data list if we have all the + * fragments, NULL otherwise. + * + * This function assumes frag_number being a block sequence number. + * The bsn for the first block is 0. + */ +static fragment_head * +fragment_add_seq_common(reassembly_table *table, tvbuff_t *tvb, + const int offset, const packet_info *pinfo, + const guint32 id, const void *data, + guint32 frag_number, const guint32 frag_data_len, + const gboolean more_frags, const guint32 flags, + gpointer *orig_keyp) +{ + fragment_head *fd_head; + gpointer orig_key; + + fd_head = lookup_fd_head(table, pinfo, id, data, &orig_key); + + /* have we already seen this frame ?*/ + if (pinfo->fd->visited) { + if (fd_head != NULL && fd_head->flags & FD_DEFRAGMENTED) { + if (orig_keyp != NULL) + *orig_keyp = orig_key; + return fd_head; + } else { + return NULL; + } + } + + if (fd_head==NULL){ + /* not found, this must be the first snooped fragment for this + * packet. Create list-head. + */ + fd_head= new_head(FD_BLOCKSEQUENCE); + + if((flags & (REASSEMBLE_FLAGS_NO_FRAG_NUMBER|REASSEMBLE_FLAGS_802_11_HACK)) + && !more_frags) { + /* + * This is the last fragment for this packet, and + * is the only one we've seen. + * + * Either we don't have sequence numbers, in which + * case we assume this is the first fragment for + * this packet, or we're doing special 802.11 + * processing, in which case we assume it's one + * of those reassembled packets with a non-zero + * fragment number (see packet-80211.c); just + * return a pointer to the head of the list; + * fragment_add_seq_check will then add it to the table + * of reassembled packets. + */ + if (orig_keyp != NULL) + *orig_keyp = NULL; + fd_head->reassembled_in=pinfo->num; + fd_head->reas_in_layer_num = pinfo->curr_layer_num; + return fd_head; + } + + orig_key = insert_fd_head(table, fd_head, pinfo, id, data); + if (orig_keyp != NULL) + *orig_keyp = orig_key; + + /* + * If we weren't given an initial fragment number, + * make it 0. + */ + if (flags & REASSEMBLE_FLAGS_NO_FRAG_NUMBER) + frag_number = 0; + } else { + if (orig_keyp != NULL) + *orig_keyp = orig_key; + + if (flags & REASSEMBLE_FLAGS_NO_FRAG_NUMBER) { + fragment_item *fd; + /* + * If we weren't given an initial fragment number, + * use the next expected fragment number as the fragment + * number for this fragment. + */ + for (fd = fd_head->next; fd != NULL; fd = fd->next) { + if (fd->next == NULL) + frag_number = fd->offset + 1; + } + } + } + + if (fragment_add_seq_work(fd_head, tvb, offset, pinfo, + frag_number, frag_data_len, more_frags)) { + /* + * Reassembly is complete. + */ + return fd_head; + } else { + /* + * Reassembly isn't complete. + */ + return NULL; + } +} + +fragment_head * +fragment_add_seq(reassembly_table *table, tvbuff_t *tvb, const int offset, + const packet_info *pinfo, const guint32 id, const void *data, + const guint32 frag_number, const guint32 frag_data_len, + const gboolean more_frags, const guint32 flags) +{ + return fragment_add_seq_common(table, tvb, offset, pinfo, id, data, + frag_number, frag_data_len, + more_frags, flags, NULL); +} + +/* + * This does the work for "fragment_add_seq_check()" and + * "fragment_add_seq_next()". + * + * This function assumes frag_number being a block sequence number. + * The bsn for the first block is 0. + * + * If REASSEMBLE_FLAGS_NO_FRAG_NUMBER, it uses the next expected fragment number + * as the fragment number if there is a reassembly in progress, otherwise + * it uses 0. + * + * If not REASSEMBLE_FLAGS_NO_FRAG_NUMBER, it uses the "frag_number" argument as + * the fragment number. + * + * If this is the first fragment seen for this datagram, a new + * "fragment_head" structure is allocated to refer to the reassembled + * packet. + * + * This fragment is added to the linked list of fragments for this packet. + * + * If "more_frags" is false and REASSEMBLE_FLAGS_802_11_HACK (as the name + * implies, a special hack for 802.11) or REASSEMBLE_FLAGS_NO_FRAG_NUMBER + * (implying messages must be in order since there's no sequence number) are + * set in "flags", then this (one element) list is returned. + * + * If, after processing this fragment, we have all the fragments, + * "fragment_add_seq_check_work()" removes that from the fragment hash + * table if necessary and adds it to the table of reassembled fragments, + * and returns a pointer to the head of the fragment list. + * + * Otherwise, it returns NULL. + * + * XXX - Should we simply return NULL for zero-length fragments? + */ +static fragment_head * +fragment_add_seq_check_work(reassembly_table *table, tvbuff_t *tvb, + const int offset, const packet_info *pinfo, + const guint32 id, const void *data, + const guint32 frag_number, + const guint32 frag_data_len, + const gboolean more_frags, const guint32 flags) +{ + reassembled_key reass_key; + fragment_head *fd_head; + gpointer orig_key; + + /* + * Have we already seen this frame? + * If so, look for it in the table of reassembled packets. + */ + if (pinfo->fd->visited) { + reass_key.frame = pinfo->num; + reass_key.id = id; + return (fragment_head *)g_hash_table_lookup(table->reassembled_table, &reass_key); + } + + fd_head = fragment_add_seq_common(table, tvb, offset, pinfo, id, data, + frag_number, frag_data_len, + more_frags, + flags, + &orig_key); + if (fd_head) { + /* + * Reassembly is complete. + * + * If this is in the table of in-progress reassemblies, + * remove it from that table. (It could be that this + * was the first and last fragment, so that no + * reassembly was done.) + */ + if (orig_key != NULL) + fragment_unhash(table, orig_key); + + /* + * Add this item to the table of reassembled packets. + */ + fragment_reassembled(table, fd_head, pinfo, id); + return fd_head; + } else { + /* + * Reassembly isn't complete. + */ + return NULL; + } +} + +fragment_head * +fragment_add_seq_check(reassembly_table *table, tvbuff_t *tvb, const int offset, + const packet_info *pinfo, const guint32 id, + const void *data, + const guint32 frag_number, const guint32 frag_data_len, + const gboolean more_frags) +{ + return fragment_add_seq_check_work(table, tvb, offset, pinfo, id, data, + frag_number, frag_data_len, + more_frags, 0); +} + +fragment_head * +fragment_add_seq_802_11(reassembly_table *table, tvbuff_t *tvb, + const int offset, const packet_info *pinfo, + const guint32 id, const void *data, + const guint32 frag_number, const guint32 frag_data_len, + const gboolean more_frags) +{ + return fragment_add_seq_check_work(table, tvb, offset, pinfo, id, data, + frag_number, frag_data_len, + more_frags, + REASSEMBLE_FLAGS_802_11_HACK); +} + +fragment_head * +fragment_add_seq_next(reassembly_table *table, tvbuff_t *tvb, const int offset, + const packet_info *pinfo, const guint32 id, + const void *data, const guint32 frag_data_len, + const gboolean more_frags) +{ + /* Use a dummy frag_number (0), it is ignored since + * REASSEMBLE_FLAGS_NO_FRAG_NUMBER is set. */ + return fragment_add_seq_check_work(table, tvb, offset, pinfo, id, data, + 0, frag_data_len, more_frags, + REASSEMBLE_FLAGS_NO_FRAG_NUMBER); +} + +static void +fragment_add_seq_single_move(reassembly_table *table, const packet_info *pinfo, + const guint32 id, const void *data, + const guint32 offset) +{ + fragment_head *fh, *new_fh; + fragment_item *fd, *prev_fd; + tvbuff_t *old_tvb_data; + if (offset == 0) { + return; + } + fh = lookup_fd_head(table, pinfo, id, data, NULL); + if (fh == NULL) { + /* Shouldn't be called this way. + * Probably wouldn't hurt to just create fh in this case. */ + ws_assert_not_reached(); + return; + } + if (fh->flags & FD_DATALEN_SET && fh->datalen <= offset) { + /* Don't take from past the end. <= because we don't + * want to take a First fragment from the next one + * either */ + return; + } + new_fh = lookup_fd_head(table, pinfo, id+offset, data, NULL); + if (new_fh != NULL) { + /* Attach to the end of the sorted list. */ + prev_fd = NULL; + for(fd = fh->next; fd != NULL; fd=fd->next) { + prev_fd = fd; + } + /* Don't take a reassembly starting with a First fragment. */ + fd = new_fh->next; + if (fd && fd->offset != 0) { + fragment_item *inserted = fd; + gboolean multi_insert = (inserted->next != NULL); + if (prev_fd) { + prev_fd->next = fd; + } else { + fh->next = fd; + } + for (; fd; fd=fd->next) { + fd->offset += offset; + if (fh->frame < fd->frame) { + fh->frame = fd->frame; + } + } + update_first_gap(fh, inserted, multi_insert); + /* If previously found a Last fragment, + * transfer that info to the new one. */ + if (new_fh->flags & FD_DATALEN_SET) { + fh->flags |= FD_DATALEN_SET; + fh->datalen = new_fh->datalen + offset; + } + /* Now remove and delete */ + new_fh->next = NULL; + old_tvb_data = fragment_delete(table, pinfo, id+offset, data); + if (old_tvb_data) + tvb_free(old_tvb_data); + } + } +} + +static fragment_head * +fragment_add_seq_single_work(reassembly_table *table, tvbuff_t *tvb, + const int offset, const packet_info *pinfo, + const guint32 id, const void* data, + const guint32 frag_data_len, + const gboolean first, const gboolean last, + const guint32 max_frags, const guint32 max_age, + const guint32 flags) +{ + reassembled_key reass_key; + tvbuff_t *old_tvb_data; + gpointer orig_key; + fragment_head *fh, *new_fh; + fragment_item *fd, *prev_fd; + guint32 frag_number, tmp_offset; + /* Have we already seen this frame? + * If so, look for it in the table of reassembled packets. + * Note here we store in the reassembly table by the single sequence + * number rather than the sequence number of the First fragment. */ + if (pinfo->fd->visited) { + reass_key.frame = pinfo->num; + reass_key.id = id; + fh = (fragment_head *)g_hash_table_lookup(table->reassembled_table, &reass_key); + return fh; + } + /* First let's figure out where we want to add our new fragment */ + fh = NULL; + if (first) { + frag_number = 0; + fh = lookup_fd_head(table, pinfo, id-frag_number, data, NULL); + if ((flags & REASSEMBLE_FLAGS_AGING) && + fh && ((fh->frame + max_age) < pinfo->num)) { + old_tvb_data = fragment_delete(table, pinfo, id-frag_number, data); + if (old_tvb_data) + tvb_free(old_tvb_data); + fh = NULL; + } + if (fh == NULL) { + /* Not found. Create list-head. */ + fh = new_head(FD_BLOCKSEQUENCE); + insert_fd_head(table, fh, pinfo, id-frag_number, data); + } + /* As this is the first fragment, we might have added segments + * for this reassembly to the previous one in-progress. */ + fd = NULL; + for (frag_number=1; frag_number < max_frags; frag_number++) { + new_fh = lookup_fd_head(table, pinfo, id-frag_number, data, NULL); + if (new_fh != NULL) { + prev_fd = NULL; + new_fh->frame = 0; + for (fd=new_fh->next; fd && fd->offset < frag_number; fd=fd->next) { + prev_fd = fd; + if (new_fh->frame < fd->frame) { + new_fh->frame = fd->frame; + } + } + if (prev_fd) { + prev_fd->next = NULL; + } else { + new_fh->next = NULL; + } + fragment_items_removed(new_fh, prev_fd); + break; + } + } + if (fd != NULL) { + tmp_offset = 0; + for (prev_fd = fd; prev_fd; prev_fd = prev_fd->next) { + prev_fd->offset -= frag_number; + tmp_offset = prev_fd->offset; + if (fh->frame < prev_fd->frame) { + fh->frame = prev_fd->frame; + } + } + MERGE_FRAG(fh, fd); + if (new_fh != NULL) { + /* If we've moved a Last packet, change datalen. + * Second part of this test prob. redundant? */ + if (new_fh->flags & FD_DATALEN_SET && + new_fh->datalen >= frag_number) { + fh->flags |= FD_DATALEN_SET; + fh->datalen = new_fh->datalen - frag_number; + new_fh->flags &= ~FD_DATALEN_SET; + new_fh->datalen = 0; + } + /* If we've moved all the fragments, + * delete the old head */ + if (new_fh->next == NULL) { + old_tvb_data = fragment_delete(table, pinfo, id-frag_number, data); + if (old_tvb_data) + tvb_free(old_tvb_data); + } + } else { + /* Look forward and take off the next (this is + * necessary in some edge cases where max_frags + * prevented some fragments from going on the + * previous First, but they can go on this one. */ + fragment_add_seq_single_move(table, pinfo, id, + data, tmp_offset); + } + } + frag_number = 0; /* For the rest of the function */ + } else { + for (frag_number=1; frag_number < max_frags; frag_number++) { + fh = lookup_fd_head(table, pinfo, id-frag_number, data, NULL); + if ((flags & REASSEMBLE_FLAGS_AGING) && + fh && ((fh->frame + max_age) < pinfo->num)) { + old_tvb_data = fragment_delete(table, pinfo, id-frag_number, data); + if (old_tvb_data) + tvb_free(old_tvb_data); + fh = NULL; + } + if (fh != NULL) { + if (fh->flags & FD_DATALEN_SET && + fh->datalen < frag_number) { + /* This fragment is after the Last + * fragment, so must go after here. */ + fh = NULL; + } + break; + } + } + if (fh == NULL) { /* Didn't find location, use default */ + frag_number = 1; + /* Already looked for frag_number 1, so just create */ + fh = new_head(FD_BLOCKSEQUENCE); + insert_fd_head(table, fh, pinfo, id-frag_number, data); + } + } + if (last) { + /* Look for fragments past the end set by this Last fragment. */ + prev_fd = NULL; + for (fd=fh->next; fd && fd->offset <= frag_number; fd=fd->next) { + prev_fd = fd; + } + /* fd is now all fragments offset > frag_number (the Last). + * It shouldn't have a fragment with offset frag_number+1, + * as that would be a First fragment not marked as such. + * However, this can happen if we had unreassembled fragments + * (missing, or at the start of the capture) and we've also + * looped around on the sequence numbers. It can also happen + * if bit errors mess up Last or First. */ + if (fd != NULL) { + if (prev_fd) { + prev_fd->next = NULL; + } else { + fh->next = NULL; + } + fragment_items_removed(fh, prev_fd); + fh->frame = 0; + for (prev_fd=fh->next; prev_fd; prev_fd=prev_fd->next) { + if (fh->frame < prev_fd->frame) { + fh->frame = prev_fd->frame; + } + } + while (fd && fd->offset == frag_number+1) { + /* Definitely have bad data here. Best to + * delete these and leave unreassembled. */ + fragment_item *tmp_fd; + tmp_fd=fd->next; + + if (fd->tvb_data && !(fd->flags & FD_SUBSET_TVB)) + tvb_free(fd->tvb_data); + g_slice_free(fragment_item, fd); + fd=tmp_fd; + } + } + if (fd != NULL) { + /* Move these onto the next frame. */ + new_fh = lookup_fd_head(table, pinfo, id+1, data, NULL); + if (new_fh==NULL) { + /* Not found. Create list-head. */ + new_fh = new_head(FD_BLOCKSEQUENCE); + insert_fd_head(table, new_fh, pinfo, id+1, data); + } + tmp_offset = 0; + for (prev_fd = fd; prev_fd; prev_fd = prev_fd->next) { + prev_fd->offset -= (frag_number+1); + tmp_offset = prev_fd->offset; + if (new_fh->frame < fd->frame) { + new_fh->frame = fd->frame; + } + } + MERGE_FRAG(new_fh, fd); + /* If we previously found a different Last fragment, + * transfer that information to the new reassembly. */ + if (fh->flags & FD_DATALEN_SET && + fh->datalen > frag_number) { + new_fh->flags |= FD_DATALEN_SET; + new_fh->datalen = fh->datalen - (frag_number+1); + fh->flags &= ~FD_DATALEN_SET; + fh->datalen = 0; + } else { + /* Look forward and take off the next (this is + * necessary in some edge cases where max_frags + * prevented some fragments from going on the + * previous First, but they can go on this one. */ + fragment_add_seq_single_move(table, pinfo, id+1, + data, tmp_offset); + } + } + } else { + fragment_add_seq_single_move(table, pinfo, id-frag_number, data, + frag_number+1); + } + /* Having cleaned up everything, finally ready to add our new + * fragment. Note that only this will ever complete a reassembly. */ + fh = fragment_add_seq_common(table, tvb, offset, pinfo, + id-frag_number, data, + frag_number, frag_data_len, + !last, 0, &orig_key); + if (fh) { + /* + * Reassembly is complete. + * + * If this is in the table of in-progress reassemblies, + * remove it from that table. (It could be that this + * was the first and last fragment, so that no + * reassembly was done.) + */ + if (orig_key != NULL) + fragment_unhash(table, orig_key); + + /* + * Add this item to the table of reassembled packets. + */ + fragment_reassembled_single(table, fh, pinfo, id-frag_number); + return fh; + } else { + /* + * Reassembly isn't complete. + */ + return NULL; + } +} + +fragment_head * +fragment_add_seq_single(reassembly_table *table, tvbuff_t *tvb, + const int offset, const packet_info *pinfo, + const guint32 id, const void* data, + const guint32 frag_data_len, + const gboolean first, const gboolean last, + const guint32 max_frags) +{ + return fragment_add_seq_single_work(table, tvb, offset, pinfo, + id, data, frag_data_len, + first, last, max_frags, 0, 0); +} + +fragment_head * +fragment_add_seq_single_aging(reassembly_table *table, tvbuff_t *tvb, + const int offset, const packet_info *pinfo, + const guint32 id, const void* data, + const guint32 frag_data_len, + const gboolean first, const gboolean last, + const guint32 max_frags, const guint32 max_age) +{ + return fragment_add_seq_single_work(table, tvb, offset, pinfo, + id, data, frag_data_len, + first, last, max_frags, max_age, + REASSEMBLE_FLAGS_AGING); +} + +void +fragment_start_seq_check(reassembly_table *table, const packet_info *pinfo, + const guint32 id, const void *data, + const guint32 tot_len) +{ + fragment_head *fd_head; + + /* Have we already seen this frame ?*/ + if (pinfo->fd->visited) { + return; + } + + /* Check if fragment data exists */ + fd_head = lookup_fd_head(table, pinfo, id, data, NULL); + + if (fd_head == NULL) { + /* Create list-head. */ + fd_head = g_slice_new(fragment_head); + fd_head->next = NULL; + fd_head->first_gap = NULL; + fd_head->contiguous_len = 0; + fd_head->frame = 0; + fd_head->len = 0; + fd_head->fragment_nr_offset = 0; + fd_head->datalen = tot_len; + fd_head->reassembled_in = 0; + fd_head->reas_in_layer_num = 0; + fd_head->flags = FD_BLOCKSEQUENCE|FD_DATALEN_SET; + fd_head->tvb_data = NULL; + fd_head->error = NULL; + + insert_fd_head(table, fd_head, pinfo, id, data); + } +} + +fragment_head * +fragment_end_seq_next(reassembly_table *table, const packet_info *pinfo, + const guint32 id, const void *data) +{ + reassembled_key reass_key; + reassembled_key *new_key; + fragment_head *fd_head; + fragment_item *fd; + gpointer orig_key; + guint32 max_offset = 0; + + /* + * Have we already seen this frame? + * If so, look for it in the table of reassembled packets. + */ + if (pinfo->fd->visited) { + reass_key.frame = pinfo->num; + reass_key.id = id; + return (fragment_head *)g_hash_table_lookup(table->reassembled_table, &reass_key); + } + + fd_head = lookup_fd_head(table, pinfo, id, data, &orig_key); + + if (fd_head) { + for (fd = fd_head->next; fd; fd = fd->next) { + if (fd->offset > max_offset) { + max_offset = fd->offset; + } + } + fd_head->datalen = max_offset; + fd_head->flags |= FD_DATALEN_SET; + + fragment_defragment_and_free (fd_head, pinfo); + + /* + * Remove this from the table of in-progress reassemblies, + * and free up any memory used for it in that table. + */ + fragment_unhash(table, orig_key); + + /* + * Add this item to the table of reassembled packets. + */ + fragment_reassembled(table, fd_head, pinfo, id); + if (fd_head->next != NULL) { + new_key = g_slice_new(reassembled_key); + new_key->frame = pinfo->num; + new_key->id = id; + reassembled_table_insert(table->reassembled_table, new_key, fd_head); + } + + return fd_head; + } else { + /* + * Fragment data not found. + */ + return NULL; + } +} + +/* + * Process reassembled data; if we're on the frame in which the data + * was reassembled, 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. + * offset from start of tvb, result up to end of tvb + */ +tvbuff_t * +process_reassembled_data(tvbuff_t *tvb, const int offset, packet_info *pinfo, + const char *name, fragment_head *fd_head, const fragment_items *fit, + gboolean *update_col_infop, proto_tree *tree) +{ + tvbuff_t *next_tvb; + gboolean update_col_info; + proto_item *frag_tree_item; + + if (fd_head != NULL && pinfo->num == fd_head->reassembled_in && pinfo->curr_layer_num == fd_head->reas_in_layer_num) { + /* + * OK, we've reassembled this. + * Is this something that's been reassembled from more + * than one fragment? + */ + if (fd_head->next != NULL) { + /* + * Yes. + * Allocate a new tvbuff, referring to the + * reassembled payload, and set + * the tvbuff to the list of tvbuffs to which + * the tvbuff we were handed refers, so it'll get + * cleaned up when that tvbuff is cleaned up. + */ + next_tvb = tvb_new_chain(tvb, fd_head->tvb_data); + + /* Add the defragmented data to the data source list. */ + add_new_data_source(pinfo, next_tvb, name); + + /* show all fragments */ + if (fd_head->flags & FD_BLOCKSEQUENCE) { + update_col_info = !show_fragment_seq_tree( + fd_head, fit, tree, pinfo, next_tvb, &frag_tree_item); + } else { + update_col_info = !show_fragment_tree(fd_head, + fit, tree, pinfo, next_tvb, &frag_tree_item); + } + } else { + /* + * No. + * Return a tvbuff with the payload. next_tvb ist from offset until end + */ + next_tvb = tvb_new_subset_remaining(tvb, offset); + pinfo->fragmented = FALSE; /* one-fragment packet */ + update_col_info = TRUE; + } + if (update_col_infop != NULL) + *update_col_infop = update_col_info; + } else { + /* + * We don't have the complete reassembled payload, or this + * isn't the final frame of that payload. + */ + next_tvb = NULL; + + /* + * If we know what frame this was reassembled in, + * and if there's a field to use for the number of + * the frame in which the packet was reassembled, + * add it to the protocol tree. + */ + if (fd_head != NULL && fit->hf_reassembled_in != NULL) { + proto_item *fei = proto_tree_add_uint(tree, + *(fit->hf_reassembled_in), tvb, + 0, 0, fd_head->reassembled_in); + proto_item_set_generated(fei); + } + } + return next_tvb; +} + +/* + * Show a single fragment in a fragment subtree, and put information about + * it in the top-level item for that subtree. + */ +static void +show_fragment(fragment_item *fd, const int offset, const fragment_items *fit, + proto_tree *ft, proto_item *fi, const gboolean first_frag, + const guint32 count, tvbuff_t *tvb, packet_info *pinfo) +{ + proto_item *fei=NULL; + int hf; + + if (first_frag) { + gchar *name; + if (count == 1) { + name = g_strdup(proto_registrar_get_name(*(fit->hf_fragment))); + } else { + name = g_strdup(proto_registrar_get_name(*(fit->hf_fragments))); + } + proto_item_set_text(fi, "%u %s (%u byte%s): ", count, name, tvb_captured_length(tvb), + plurality(tvb_captured_length(tvb), "", "s")); + g_free(name); + } else { + proto_item_append_text(fi, ", "); + } + proto_item_append_text(fi, "#%u(%u)", fd->frame, fd->len); + + if (fd->flags & (FD_OVERLAPCONFLICT + |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) { + hf = *(fit->hf_fragment_error); + } else { + hf = *(fit->hf_fragment); + } + if (fd->len == 0) { + fei = proto_tree_add_uint_format(ft, hf, + tvb, offset, fd->len, + fd->frame, + "Frame: %u (no data)", + fd->frame); + } else { + fei = proto_tree_add_uint_format(ft, hf, + tvb, offset, fd->len, + fd->frame, + "Frame: %u, payload: %u-%u (%u byte%s)", + fd->frame, + offset, + offset+fd->len-1, + fd->len, + plurality(fd->len, "", "s")); + } + proto_item_set_generated(fei); + mark_frame_as_depended_upon(pinfo->fd, fd->frame); + if (fd->flags & (FD_OVERLAP|FD_OVERLAPCONFLICT + |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) { + /* this fragment has some flags set, create a subtree + * for it and display the flags. + */ + proto_tree *fet=NULL; + + fet = proto_item_add_subtree(fei, *(fit->ett_fragment)); + if (fd->flags&FD_OVERLAP) { + fei=proto_tree_add_boolean(fet, + *(fit->hf_fragment_overlap), + tvb, 0, 0, + TRUE); + proto_item_set_generated(fei); + } + if (fd->flags&FD_OVERLAPCONFLICT) { + fei=proto_tree_add_boolean(fet, + *(fit->hf_fragment_overlap_conflict), + tvb, 0, 0, + TRUE); + proto_item_set_generated(fei); + } + if (fd->flags&FD_MULTIPLETAILS) { + fei=proto_tree_add_boolean(fet, + *(fit->hf_fragment_multiple_tails), + tvb, 0, 0, + TRUE); + proto_item_set_generated(fei); + } + if (fd->flags&FD_TOOLONGFRAGMENT) { + fei=proto_tree_add_boolean(fet, + *(fit->hf_fragment_too_long_fragment), + tvb, 0, 0, + TRUE); + proto_item_set_generated(fei); + } + } +} + +static gboolean +show_fragment_errs_in_col(fragment_head *fd_head, const fragment_items *fit, + packet_info *pinfo) +{ + if (fd_head->flags & (FD_OVERLAPCONFLICT + |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) { + col_add_fstr(pinfo->cinfo, COL_INFO, "[Illegal %s]", fit->tag); + return TRUE; + } + + return FALSE; +} + +/* This function will build the fragment subtree; it's for fragments + reassembled with "fragment_add()". + + It will return TRUE if there were fragmentation errors + or FALSE if fragmentation was ok. +*/ +gboolean +show_fragment_tree(fragment_head *fd_head, const fragment_items *fit, + proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb, proto_item **fi) +{ + fragment_item *fd; + proto_tree *ft; + gboolean first_frag; + guint32 count = 0; + /* It's not fragmented. */ + pinfo->fragmented = FALSE; + + *fi = proto_tree_add_item(tree, *(fit->hf_fragments), tvb, 0, -1, ENC_NA); + proto_item_set_generated(*fi); + + ft = proto_item_add_subtree(*fi, *(fit->ett_fragments)); + first_frag = TRUE; + for (fd = fd_head->next; fd != NULL; fd = fd->next) { + count++; + } + for (fd = fd_head->next; fd != NULL; fd = fd->next) { + show_fragment(fd, fd->offset, fit, ft, *fi, first_frag, count, tvb, pinfo); + first_frag = FALSE; + } + + if (fit->hf_fragment_count) { + proto_item *fli = proto_tree_add_uint(ft, *(fit->hf_fragment_count), + tvb, 0, 0, count); + proto_item_set_generated(fli); + } + + if (fit->hf_reassembled_length) { + proto_item *fli = proto_tree_add_uint(ft, *(fit->hf_reassembled_length), + tvb, 0, 0, tvb_captured_length (tvb)); + proto_item_set_generated(fli); + } + + if (fit->hf_reassembled_data) { + proto_item *fli = proto_tree_add_item(ft, *(fit->hf_reassembled_data), + tvb, 0, tvb_captured_length(tvb), ENC_NA); + proto_item_set_generated(fli); + } + + return show_fragment_errs_in_col(fd_head, fit, pinfo); +} + +/* This function will build the fragment subtree; it's for fragments + reassembled with "fragment_add_seq()" or "fragment_add_seq_check()". + + It will return TRUE if there were fragmentation errors + or FALSE if fragmentation was ok. +*/ +gboolean +show_fragment_seq_tree(fragment_head *fd_head, const fragment_items *fit, + proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb, proto_item **fi) +{ + guint32 offset, next_offset, count = 0; + fragment_item *fd, *last_fd; + proto_tree *ft; + gboolean first_frag; + + /* It's not fragmented. */ + pinfo->fragmented = FALSE; + + *fi = proto_tree_add_item(tree, *(fit->hf_fragments), tvb, 0, -1, ENC_NA); + proto_item_set_generated(*fi); + + ft = proto_item_add_subtree(*fi, *(fit->ett_fragments)); + offset = 0; + next_offset = 0; + last_fd = NULL; + first_frag = TRUE; + for (fd = fd_head->next; fd != NULL; fd = fd->next){ + count++; + } + for (fd = fd_head->next; fd != NULL; fd = fd->next){ + if (last_fd == NULL || last_fd->offset != fd->offset) { + offset = next_offset; + next_offset += fd->len; + } + last_fd = fd; + show_fragment(fd, offset, fit, ft, *fi, first_frag, count, tvb, pinfo); + first_frag = FALSE; + } + + if (fit->hf_fragment_count) { + proto_item *fli = proto_tree_add_uint(ft, *(fit->hf_fragment_count), + tvb, 0, 0, count); + proto_item_set_generated(fli); + } + + if (fit->hf_reassembled_length) { + proto_item *fli = proto_tree_add_uint(ft, *(fit->hf_reassembled_length), + tvb, 0, 0, tvb_captured_length (tvb)); + proto_item_set_generated(fli); + } + + if (fit->hf_reassembled_data) { + proto_item *fli = proto_tree_add_item(ft, *(fit->hf_reassembled_data), + tvb, 0, tvb_captured_length(tvb), ENC_NA); + proto_item_set_generated(fli); + } + + return show_fragment_errs_in_col(fd_head, fit, pinfo); +} + +static void +reassembly_table_init_reg_table(gpointer p, gpointer user_data _U_) +{ + register_reassembly_table_t* reg_table = (register_reassembly_table_t*)p; + reassembly_table_init(reg_table->table, reg_table->funcs); +} + +static void +reassembly_table_init_reg_tables(void) +{ + g_list_foreach(reassembly_table_list, reassembly_table_init_reg_table, NULL); +} + +static void +reassembly_table_cleanup_reg_table(gpointer p, gpointer user_data _U_) +{ + register_reassembly_table_t* reg_table = (register_reassembly_table_t*)p; + reassembly_table_destroy(reg_table->table); +} + +static void +reassembly_table_cleanup_reg_tables(void) +{ + g_list_foreach(reassembly_table_list, reassembly_table_cleanup_reg_table, NULL); +} + +void reassembly_tables_init(void) +{ + register_init_routine(&reassembly_table_init_reg_tables); + register_cleanup_routine(&reassembly_table_cleanup_reg_tables); +} + +static void +reassembly_table_free(gpointer p, gpointer user_data _U_) +{ + register_reassembly_table_t* reg_table = (register_reassembly_table_t*)p; + reassembly_table_destroy(reg_table->table); + g_free(reg_table); +} + +void +reassembly_table_cleanup(void) +{ + g_list_foreach(reassembly_table_list, reassembly_table_free, NULL); + g_list_free(reassembly_table_list); +} + +/* One instance of this structure is created for each pdu that spans across + * multiple segments. (MSP) */ +typedef struct _multisegment_pdu_t { + guint64 first_frame; + guint64 last_frame; + guint start_offset_at_first_frame; + guint end_offset_at_last_frame; + gint length; /* length of this MSP */ + guint32 streaming_reassembly_id; + /* pointer to previous multisegment_pdu */ + struct _multisegment_pdu_t* prev_msp; +} multisegment_pdu_t; + +/* struct for keeping the reassembly information of each stream */ +struct streaming_reassembly_info_t { + /* This map is keyed by frame num and keeps track of all MSPs for this + * stream. Different frames will point to the same MSP if they contain + * part data of this MSP. If a frame contains data that + * belongs to two MSPs, it will point to the second MSP. */ + wmem_map_t* multisegment_pdus; + /* This map is keyed by frame num and keeps track of the frag_offset + * of the first byte of frames for fragment_add() after first scan. */ + wmem_map_t* frame_num_frag_offset_map; + /* how many bytes the current uncompleted MSP still needs. (only valid for first scan) */ + gint prev_deseg_len; + /* the current uncompleted MSP (only valid for first scan) */ + multisegment_pdu_t* last_msp; +}; + +static guint32 +create_streaming_reassembly_id(void) +{ + static guint32 global_streaming_reassembly_id = 0; + return ++global_streaming_reassembly_id; +} + +streaming_reassembly_info_t* +streaming_reassembly_info_new(void) +{ + return wmem_new0(wmem_file_scope(), streaming_reassembly_info_t); +} + +/* Following is an example of ProtoA and ProtoB protocols from the declaration of this function in 'reassemble.h': + * + * +------------------ A Multisegment PDU of ProtoB ----------------------+ + * | | + * +--- ProtoA payload1 ---+ +- payload2 -+ +- Payload3 -+ +- Payload4 -+ +- ProtoA payload5 -+ + * | EoMSP | OmNFP | BoMSP | | MoMSP | | MoMSP | | MoMSP | | EoMSP | BoMSP | + * +-------+-------+-------+ +------------+ +------------+ +------------+ +---------+---------+ + * | | + * +----------------------------------------------------------------------+ + * + * For a ProtoA payload composed of EoMSP + OmNFP + BoMSP will call fragment_add() twice on EoMSP and BoMSP; and call + * process_reassembled_data() once for generating tvb of a MSP to which EoMSP belongs; and call subdissector twice on + * reassembled MSP of EoMSP and OmNFP + BoMSP. After that finds BoMSP is a beginning of a MSP at first scan. + * + * The rules are: + * + * - If a ProtoA payload contains EoMSP, we will need call fragment_add(), process_reassembled_data() and subdissector + * once on it to end a MSP. (May run twice or more times at first scan, because subdissector may only return the + * head length of message by pinfo->desegment_len. We need run second time for subdissector to determine the length + * of entire message). + * + * - If a ProtoA payload contains OmNFP, we will need only call subdissector once on it. The subdissector need dissect + * all non-fragment PDUs in it. (no desegment_len should output) + * + * - If a ProtoA payload contains BoMSP, we will need call subdissector once on BoMSP or OmNFP+BoMSP (because unknown + * during first scan). The subdissector will output desegment_len (!= 0). Then we will call fragment_add() + * with a new reassembly id on BoMSP for starting a new MSP. + * + * - If a ProtoA payload only contains MoMSP (entire payload is part of a MSP), we will only call fragment_add() once + * or twice (at first scan) on it. The subdissector will not be called. + * + * In this implementation, only multisegment PDUs are recorded in multisegment_pdus map keyed by the numbers (guint64) + * of frames belongs to MSPs. Each MSP in the map has a pointer referred to previous MSP, because we may need + * two MSPs to dissect a ProtoA payload that contains EoMSP + BoMSP at the same time. The multisegment_pdus map is built + * during first scan (pinfo->visited == FALSE) with help of prev_deseg_len and last_msp fields of streaming_reassembly_info_t + * for each direction of a ProtoA STREAM. The prev_deseg_len record how many bytes of subsequent ProtoA payloads belong to + * previous PDU during first scan. The last_msp member of streaming_reassembly_info_t is always point to last MSP which + * is created during scan previous or early ProtoA payloads. Since subdissector might return only the head length of entire + * message (by pinfo->desegment_len) when there is not enough data to determine the message length, we need to reopen + * reassembly fragments for adding more bytes during scanning the next ProtoA payload. We have to use fragment_add() + * instead of fragment_add_check() or fragment_add_seq_next(). + * + * Read more: please refer to comments of the declaration of this function in 'reassemble.h'. + */ +gint +reassemble_streaming_data_and_call_subdissector( + tvbuff_t* tvb, packet_info* pinfo, guint offset, gint length, + proto_tree* segment_tree, proto_tree* reassembled_tree, reassembly_table streaming_reassembly_table, + streaming_reassembly_info_t* reassembly_info, guint64 cur_frame_num, + dissector_handle_t subdissector_handle, proto_tree* subdissector_tree, void* subdissector_data, + const char* label, const fragment_items* frag_hf_items, int hf_segment_data +) +{ + gint orig_length = length; + gint datalen = 0; + gint bytes_belong_to_prev_msp = 0; /* bytes belong to previous MSP */ + guint32 reassembly_id = 0, frag_offset = 0; + fragment_head* head = NULL; + gboolean need_more = FALSE; + gboolean found_BoMSP = FALSE; + multisegment_pdu_t* cur_msp = NULL, * prev_msp = NULL; + guint16 save_can_desegment; + int save_desegment_offset; + guint32 save_desegment_len; + guint64* frame_ptr; + + save_can_desegment = pinfo->can_desegment; + save_desegment_offset = pinfo->desegment_offset; + save_desegment_len = pinfo->desegment_len; + + /* calculate how many bytes of this payload belongs to previous MSP (EoMSP) */ + if (!PINFO_FD_VISITED(pinfo)) { + /* this is first scan */ + if (reassembly_info->prev_deseg_len == DESEGMENT_ONE_MORE_SEGMENT) { + /* assuming the entire tvb belongs to the previous MSP */ + bytes_belong_to_prev_msp = length; + reassembly_info->prev_deseg_len = length; + } else if (reassembly_info->prev_deseg_len > 0) { + /* part or all of current payload belong to previous MSP */ + bytes_belong_to_prev_msp = MIN(reassembly_info->prev_deseg_len, length); + reassembly_info->prev_deseg_len -= bytes_belong_to_prev_msp; + need_more = (reassembly_info->prev_deseg_len > 0); + } /* else { beginning of a new PDU (might be a NFP or MSP) } */ + + if (bytes_belong_to_prev_msp > 0) { + DISSECTOR_ASSERT(reassembly_info->last_msp != NULL); + reassembly_id = reassembly_info->last_msp->streaming_reassembly_id; + frag_offset = reassembly_info->last_msp->length; + if (reassembly_info->frame_num_frag_offset_map == NULL) { + reassembly_info->frame_num_frag_offset_map = wmem_map_new(wmem_file_scope(), g_int64_hash, g_int64_equal); + } + frame_ptr = (guint64*)wmem_memdup(wmem_file_scope(), &cur_frame_num, sizeof(guint64)); + wmem_map_insert(reassembly_info->frame_num_frag_offset_map, frame_ptr, GUINT_TO_POINTER(frag_offset)); + /* This payload contains the data of previous msp, so we point to it. That may be overriden late. */ + wmem_map_insert(reassembly_info->multisegment_pdus, frame_ptr, reassembly_info->last_msp); + } + } else { + /* not first scan, use information of multisegment_pdus built during first scan */ + if (reassembly_info->multisegment_pdus) { + cur_msp = (multisegment_pdu_t*)wmem_map_lookup(reassembly_info->multisegment_pdus, &cur_frame_num); + } + if (cur_msp) { + if (cur_msp->first_frame == cur_frame_num) { + /* Current payload contains a beginning of a MSP. (BoMSP) + * The cur_msp contains information about the beginning MSP. + * If prev_msp is not null, that means this payload also contains + * the last part of previous MSP. (EoMSP) */ + prev_msp = cur_msp->prev_msp; + } else { + /* Current payload is not a first frame of a MSP (not include BoMSP). */ + prev_msp = cur_msp; + cur_msp = NULL; + } + } + + if (prev_msp && prev_msp->last_frame >= cur_frame_num) { + if (prev_msp->last_frame == cur_frame_num) { + /* this payload contains part of previous MSP (contains EoMSP) */ + bytes_belong_to_prev_msp = prev_msp->end_offset_at_last_frame - offset; + } else { /* if (prev_msp->last_frame > cur_frame_num) */ + /* this payload all belongs to previous MSP */ + bytes_belong_to_prev_msp = length; + need_more = TRUE; + } + reassembly_id = prev_msp->streaming_reassembly_id; + } + if (reassembly_info->frame_num_frag_offset_map) { + frag_offset = GPOINTER_TO_UINT(wmem_map_lookup(reassembly_info->frame_num_frag_offset_map, &cur_frame_num)); + } + } + + /* handling EoMSP or MoMSP (entire payload being middle part of a MSP) */ + while (bytes_belong_to_prev_msp > 0) { + tvbuff_t* reassembled_tvb = NULL; + DISSECTOR_ASSERT(reassembly_id > 0); + pinfo->can_desegment = 2; /* this will be decreased one while passing to subdissector */ + pinfo->desegment_offset = 0; + pinfo->desegment_len = 0; + + head = fragment_add(&streaming_reassembly_table, tvb, offset, pinfo, reassembly_id, NULL, + frag_offset, bytes_belong_to_prev_msp, need_more); + + if (head) { + if (frag_hf_items->hf_reassembled_in) { + proto_item_set_generated( + proto_tree_add_uint(segment_tree, *(frag_hf_items->hf_reassembled_in), tvb, offset, + bytes_belong_to_prev_msp, head->reassembled_in) + ); + } + + if (!need_more) { + reassembled_tvb = process_reassembled_data(tvb, offset, pinfo, + wmem_strdup_printf(pinfo->pool, "Reassembled %s", label), + head, frag_hf_items, NULL, reassembled_tree); + } + } + + proto_tree_add_bytes_format(segment_tree, hf_segment_data, tvb, offset, + bytes_belong_to_prev_msp, NULL, "%s Segment data (%u byte%s)", label, + bytes_belong_to_prev_msp, plurality(bytes_belong_to_prev_msp, "", "s")); + + if (reassembled_tvb) { + /* normally, this stage will dissect one or more completed pdus */ + /* Note, don't call_dissector_with_data because sometime the pinfo->curr_layer_num will changed + * after calling that will make reassembly failed! */ + call_dissector_only(subdissector_handle, reassembled_tvb, pinfo, subdissector_tree, subdissector_data); + } + + if (pinfo->desegment_len) { + /* that must only happen during first scan the reassembly_info->prev_deseg_len might be only the + * head length of entire message. */ + DISSECTOR_ASSERT(!PINFO_FD_VISITED(pinfo)); + DISSECTOR_ASSERT_HINT(pinfo->desegment_len != DESEGMENT_UNTIL_FIN, "Subdissector MUST NOT " + "set pinfo->desegment_len to DESEGMENT_UNTIL_FIN. Instead, it can set pinfo->desegment_len to " + " DESEGMENT_ONE_MORE_SEGMENT or the length of head if the length of entire message is not able to be determined."); + + if (pinfo->desegment_offset > 0) { + DISSECTOR_ASSERT_HINT(pinfo->desegment_offset > reassembly_info->last_msp->length + && pinfo->desegment_offset < reassembly_info->last_msp->length + bytes_belong_to_prev_msp, + wmem_strdup_printf(pinfo->pool, + "Subdissector MUST NOT set pinfo->desegment_offset(%d) in previous or next part of MSP, must between (%d, %d).", + pinfo->desegment_offset, reassembly_info->last_msp->length, reassembly_info->last_msp->length + bytes_belong_to_prev_msp)); + + /* shorten the bytes_belong_to_prev_msp and just truncate the ressembled tvb */ + bytes_belong_to_prev_msp = pinfo->desegment_offset - reassembly_info->last_msp->length; + fragment_truncate(&streaming_reassembly_table, pinfo, reassembly_id, NULL, pinfo->desegment_offset); + found_BoMSP = TRUE; + } else { + if (pinfo->desegment_len == DESEGMENT_ONE_MORE_SEGMENT) { + /* just need more bytes, all remaining bytes belongs to previous MSP (to run fragment_add again) */ + bytes_belong_to_prev_msp = length; + } + + /* Remove the data added by previous fragment_add(), and reopen fragments for adding more bytes. */ + fragment_truncate(&streaming_reassembly_table, pinfo, reassembly_id, NULL, reassembly_info->last_msp->length); + fragment_set_partial_reassembly(&streaming_reassembly_table, pinfo, reassembly_id, NULL); + + reassembly_info->prev_deseg_len = bytes_belong_to_prev_msp + pinfo->desegment_len; + bytes_belong_to_prev_msp = MIN(reassembly_info->prev_deseg_len, length); + reassembly_info->prev_deseg_len -= bytes_belong_to_prev_msp; + need_more = (reassembly_info->prev_deseg_len > 0); + continue; + } + } + + if (pinfo->desegment_len == 0 || found_BoMSP) { + /* We will arrive here, only when the MSP is defragmented and dissected or this + * payload all belongs to previous MSP (only fragment_add() with need_more=TRUE called) + * or BoMSP is parsed while pinfo->desegment_offset > 0 and pinfo->desegment_len != 0 + */ + offset += bytes_belong_to_prev_msp; + length -= bytes_belong_to_prev_msp; + DISSECTOR_ASSERT(length >= 0); + if (!PINFO_FD_VISITED(pinfo)) { + reassembly_info->last_msp->length += bytes_belong_to_prev_msp; + } + + if (!PINFO_FD_VISITED(pinfo) && reassembled_tvb) { + /* completed current msp */ + reassembly_info->last_msp->last_frame = cur_frame_num; + reassembly_info->last_msp->end_offset_at_last_frame = offset; + reassembly_info->prev_deseg_len = pinfo->desegment_len; + } + bytes_belong_to_prev_msp = 0; /* break */ + } + } + + /* to find and handle OmNFP, and find BoMSP at first scan. */ + if (length > 0 && !found_BoMSP) { + if (!PINFO_FD_VISITED(pinfo)) { + /* It is first scan, to dissect remaining bytes to find whether it is OmNFP only, or BoMSP only or OmNFP + BoMSP. */ + datalen = length; + DISSECTOR_ASSERT(cur_msp == NULL); + } else { + /* Not first scan */ + if (cur_msp) { + /* There's a BoMSP. Let's calculate the length of OmNFP between EoMSP and BoMSP */ + datalen = cur_msp->start_offset_at_first_frame - offset; /* if result is zero that means no OmNFP */ + } else { + /* This payload is not a beginning of MSP. The remaining bytes all belong to OmNFP without BoMSP */ + datalen = length; + } + } + DISSECTOR_ASSERT(datalen >= 0); + + /* Dissect the remaining of this payload. If (datalen == 0) means remaining only have one BoMSP without OmNFP. */ + if (datalen > 0) { + /* we dissect if it is not dissected before or it is a non-fragment pdu (between two multisegment pdus) */ + pinfo->can_desegment = 2; + pinfo->desegment_offset = 0; + pinfo->desegment_len = 0; + + call_dissector_only(subdissector_handle, tvb_new_subset_length(tvb, offset, datalen), + pinfo, subdissector_tree, subdissector_data); + + if (pinfo->desegment_len) { + DISSECTOR_ASSERT_HINT(pinfo->desegment_len != DESEGMENT_UNTIL_FIN, "Subdissector MUST NOT " + "set pinfo->desegment_len to DESEGMENT_UNTIL_FIN. Instead, it can set pinfo->desegment_len to " + " DESEGMENT_ONE_MORE_SEGMENT or the length of head if the length of entire message is not able to be determined."); + /* only happen during first scan */ + DISSECTOR_ASSERT(!PINFO_FD_VISITED(pinfo) && datalen == length); + offset += pinfo->desegment_offset; + length -= pinfo->desegment_offset; + } else { + /* all remaining bytes are consumed by subdissector */ + offset += datalen; + length -= datalen; + } + if (!PINFO_FD_VISITED(pinfo)) { + reassembly_info->prev_deseg_len = pinfo->desegment_len; + } + } /* else all remaining bytes (BoMSP) belong to a new MSP */ + DISSECTOR_ASSERT(length >= 0); + } + + /* handling BoMSP */ + if (length > 0) { + col_append_sep_fstr(pinfo->cinfo, COL_INFO, " ", "[%s segment of a reassembled PDU] ", label); + if (!PINFO_FD_VISITED(pinfo)) { + /* create a msp for current frame during first scan */ + cur_msp = wmem_new0(wmem_file_scope(), multisegment_pdu_t); + cur_msp->first_frame = cur_frame_num; + cur_msp->last_frame = G_MAXUINT64; + cur_msp->start_offset_at_first_frame = offset; + cur_msp->length = length; + cur_msp->streaming_reassembly_id = reassembly_id = create_streaming_reassembly_id(); + cur_msp->prev_msp = reassembly_info->last_msp; + reassembly_info->last_msp = cur_msp; + if (reassembly_info->multisegment_pdus == NULL) { + reassembly_info->multisegment_pdus = wmem_map_new(wmem_file_scope(), g_int64_hash, g_int64_equal); + } + frame_ptr = (guint64*)wmem_memdup(wmem_file_scope(), &cur_frame_num, sizeof(guint64)); + wmem_map_insert(reassembly_info->multisegment_pdus, frame_ptr, cur_msp); + } else { + DISSECTOR_ASSERT(cur_msp && cur_msp->start_offset_at_first_frame == offset); + reassembly_id = cur_msp->streaming_reassembly_id; + } + /* add first fragment of the new MSP to reassembly table */ + head = fragment_add(&streaming_reassembly_table, tvb, offset, pinfo, reassembly_id, + NULL, 0, length, TRUE); + + if (head && frag_hf_items->hf_reassembled_in) { + proto_item_set_generated( + proto_tree_add_uint(segment_tree, *(frag_hf_items->hf_reassembled_in), + tvb, offset, length, head->reassembled_in) + ); + } + proto_tree_add_bytes_format(segment_tree, hf_segment_data, tvb, offset, length, + NULL, "%s Segment data (%u byte%s)", label, length, plurality(length, "", "s")); + } + + pinfo->can_desegment = save_can_desegment; + pinfo->desegment_offset = save_desegment_offset; + pinfo->desegment_len = save_desegment_len; + + return orig_length; +} + +gint +additional_bytes_expected_to_complete_reassembly(streaming_reassembly_info_t* reassembly_info) +{ + return reassembly_info->prev_deseg_len; +} + +/* + * Editor modelines - https://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 8 + * tab-width: 8 + * indent-tabs-mode: t + * End: + * + * vi: set shiftwidth=8 tabstop=8 noexpandtab: + * :indentSize=8:tabSize=8:noTabs=false: + */ |