reassemble.c

   1 /* reassemble.c
   2  * Routines for {fragment,segment} reassembly
   3  *
   4  * $Id$
   5  *
   6  * Ethereal - Network traffic analyzer
   7  * By Gerald Combs <gerald@ethereal.com>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #include <string.h>
  30
  31 #include <epan/packet.h>
  32
  33 #include "reassemble.h"
  34
  35 #include <epan/dissectors/packet-dcerpc.h>
  36
  37 typedef struct _fragment_key {
  38         address src;
  39         address dst;
  40         guint32 id;
  41 } fragment_key;
  42
  43 typedef struct _dcerpc_fragment_key {
  44        address src;
  45        address dst;
  46        guint32 id;
  47     e_uuid_t act_id;
  48 } dcerpc_fragment_key;
  49
  50 static GMemChunk *fragment_key_chunk = NULL;
  51 static GMemChunk *dcerpc_fragment_key_chunk = NULL;
  52 static GMemChunk *fragment_data_chunk = NULL;
  53 static int fragment_init_count = 200;
  54
  55 #define LINK_FRAG(fd_head,fd)                                   \
  56         {       fragment_data *fd_i;                            \
  57                 /* add fragment to list, keep list sorted */            \
  58                 for(fd_i=(fd_head);fd_i->next;fd_i=fd_i->next){ \
  59                         if( ((fd)->offset) < (fd_i->next->offset) )     \
  60                                 break;                                  \
  61                 }                                                       \
  62                 (fd)->next=fd_i->next;                          \
  63                 fd_i->next=(fd);                                        \
  64         }
  65
  66 static gint
  67 fragment_equal(gconstpointer k1, gconstpointer k2)
  68 {
  69         const fragment_key* key1 = (const fragment_key*) k1;
  70         const fragment_key* key2 = (const fragment_key*) k2;
  71
  72         /*key.id is the first item to compare since item is most
  73           likely to differ between sessions, thus shortcircuiting
  74           the comparasion of addresses.
  75         */
  76         return ( ( (key1->id    == key2->id) &&
  77                    (ADDRESSES_EQUAL(&key1->src, &key2->src)) &&
  78                    (ADDRESSES_EQUAL(&key1->dst, &key2->dst))
  79                  ) ?
  80                  TRUE : FALSE);
  81 }
  82
  83 static guint
  84 fragment_hash(gconstpointer k)
  85 {
  86         const fragment_key* key = (const fragment_key*) k;
  87         guint hash_val;
  88 /*
  89         int i;
  90 */
  91
  92         hash_val = 0;
  93
  94 /*      More than likely: in most captures src and dst addresses are the
  95         same, and would hash the same.
  96         We only use id as the hash as an optimization.
  97
  98         for (i = 0; i < key->src.len; i++)
  99                 hash_val += key->src.data[i];
 100         for (i = 0; i < key->dst.len; i++)
 101                 hash_val += key->dst.data[i];
 102 */
 103
 104         hash_val += key->id;
 105
 106         return hash_val;
 107 }
 108
 109 static gint
 110 dcerpc_fragment_equal(gconstpointer k1, gconstpointer k2)
 111 {
 112        const dcerpc_fragment_key* key1 = (const dcerpc_fragment_key*) k1;
 113        const dcerpc_fragment_key* key2 = (const dcerpc_fragment_key*) k2;
 114
 115        /*key.id is the first item to compare since item is most
 116          likely to differ between sessions, thus shortcircuiting
 117          the comparasion of addresses.
 118        */
 119        return (((key1->id == key2->id)
 120              && (ADDRESSES_EQUAL(&key1->src, &key2->src))
 121              && (ADDRESSES_EQUAL(&key1->dst, &key2->dst))
 122              && (memcmp (&key1->act_id, &key2->act_id, sizeof (e_uuid_t)) == 0))
 123             ? TRUE : FALSE);
 124 }
 125
 126 static guint
 127 dcerpc_fragment_hash(gconstpointer k)
 128 {
 129        const dcerpc_fragment_key* key = (const dcerpc_fragment_key*) k;
 130        guint hash_val;
 131
 132        hash_val = 0;
 133
 134        hash_val += key->id;
 135        hash_val += key->act_id.Data1;
 136        hash_val += key->act_id.Data2 << 16;
 137        hash_val += key->act_id.Data3;
 138
 139        return hash_val;
 140 }
 141
 142 typedef struct _reassembled_key {
 143         guint32 id;
 144         guint32 frame;
 145 } reassembled_key;
 146
 147 static GMemChunk *reassembled_key_chunk = NULL;
 148
 149 static gint
 150 reassembled_equal(gconstpointer k1, gconstpointer k2)
 151 {
 152         const reassembled_key* key1 = (const reassembled_key*) k1;
 153         const reassembled_key* key2 = (const reassembled_key*) k2;
 154
 155         /*
 156          * We assume that the frame numbers are unlikely to be equal,
 157          * so we check them first.
 158          */
 159         return key1->frame == key2->frame && key1->id == key2->id;
 160 }
 161
 162 static guint
 163 reassembled_hash(gconstpointer k)
 164 {
 165         const reassembled_key* key = (const reassembled_key*) k;
 166
 167         return key->frame;
 168 }
 169
 170 /*
 171  * For a fragment hash table entry, free the address data to which the key
 172  * refers and the fragment data to which the value refers.
 173  * (The actual key and value structures get freed by "reassemble_init()".)
 174  */
 175 static gboolean
 176 free_all_fragments(gpointer key_arg, gpointer value, gpointer user_data _U_)
 177 {
 178         fragment_key *key = key_arg;
 179         fragment_data *fd_head;
 180
 181         /*
 182          * Grr.  I guess the theory here is that freeing
 183          * something sure as heck modifies it, so you
 184          * want to ban attempts to free it, but, alas,
 185          * if we make the "data" field of an "address"
 186          * structure not a "const", the compiler whines if
 187          * we try to make it point into the data for a packet,
 188          * as that's a "const" array (and should be, as dissectors
 189          * shouldn't trash it).
 190          *
 191          * So we cast the complaint into oblivion, and rely on
 192          * the fact that these addresses are known to have had
 193          * their data mallocated, i.e. they don't point into,
 194          * say, the middle of the data for a packet.
 195          */
 196         g_free((gpointer)key->src.data);
 197         g_free((gpointer)key->dst.data);
 198
 199         for (fd_head = value; fd_head != NULL; fd_head = fd_head->next) {
 200                 if(fd_head->data && !(fd_head->flags&FD_NOT_MALLOCED))
 201                         g_free(fd_head->data);
 202         }
 203
 204         return TRUE;
 205 }
 206
 207 /*
 208  * For a reassembled-packet hash table entry, free the fragment data
 209  * to which the value refers.
 210  * (The actual value structures get freed by "reassemble_init()".)
 211  */
 212 static gboolean
 213 free_all_reassembled_fragments(gpointer key_arg _U_, gpointer value,
 214                                gpointer user_data _U_)
 215 {
 216         fragment_data *fd_head;
 217
 218         for (fd_head = value; fd_head != NULL; fd_head = fd_head->next) {
 219                 if(fd_head->data && !(fd_head->flags&FD_NOT_MALLOCED)) {
 220                         g_free(fd_head->data);
 221
 222                         /*
 223                          * A reassembled packet is inserted into the
 224                          * hash table once for every frame that made
 225                          * up the reassembled packet; clear the data
 226                          * pointer so that we only free the data the
 227                          * first time we see it.
 228                          */
 229                         fd_head->data = NULL;
 230                 }
 231         }
 232
 233         return TRUE;
 234 }
 235
 236 /*
 237  * Initialize a fragment table.
 238  */
 239 void
 240 fragment_table_init(GHashTable **fragment_table)
 241 {
 242         if (*fragment_table != NULL) {
 243                 /*
 244                  * The fragment hash table exists.
 245                  *
 246                  * Remove all entries and free fragment data for
 247                  * each entry.  (The key and value data is freed
 248                  * by "reassemble_init()".)
 249                  */
 250                 g_hash_table_foreach_remove(*fragment_table,
 251                                 free_all_fragments, NULL);
 252         } else {
 253                 /* The fragment table does not exist. Create it */
 254                 *fragment_table = g_hash_table_new(fragment_hash,
 255                                 fragment_equal);
 256         }
 257 }
 258
 259 void
 260 dcerpc_fragment_table_init(GHashTable **fragment_table)
 261 {
 262        if (*fragment_table != NULL) {
 263                /*
 264                 * The fragment hash table exists.
 265                 *
 266                 * Remove all entries and free fragment data for
 267                 * each entry.  (The key and value data is freed
 268                 * by "reassemble_init()".)
 269                 */
 270                g_hash_table_foreach_remove(*fragment_table,
 271                                free_all_fragments, NULL);
 272        } else {
 273                /* The fragment table does not exist. Create it */
 274                *fragment_table = g_hash_table_new(dcerpc_fragment_hash,
 275                                dcerpc_fragment_equal);
 276        }
 277 }
 278
 279 /*
 280  * Initialize a reassembled-packet table.
 281  */
 282 void
 283 reassembled_table_init(GHashTable **reassembled_table)
 284 {
 285         if (*reassembled_table != NULL) {
 286                 /*
 287                  * The reassembled-packet hash table exists.
 288                  *
 289                  * Remove all entries and free reassembled packet
 290                  * data for each entry.  (The key data is freed
 291                  * by "reassemble_init()".)
 292                  */
 293                 g_hash_table_foreach_remove(*reassembled_table,
 294                                 free_all_reassembled_fragments, NULL);
 295         } else {
 296                 /* The fragment table does not exist. Create it */
 297                 *reassembled_table = g_hash_table_new(reassembled_hash,
 298                                 reassembled_equal);
 299         }
 300 }
 301
 302 /*
 303  * Free up all space allocated for fragment keys and data and
 304  * reassembled keys.
 305  */
 306 void
 307 reassemble_init(void)
 308 {
 309         if (fragment_key_chunk != NULL)
 310                 g_mem_chunk_destroy(fragment_key_chunk);
 311         if (dcerpc_fragment_key_chunk != NULL)
 312                 g_mem_chunk_destroy(dcerpc_fragment_key_chunk);
 313         if (fragment_data_chunk != NULL)
 314                 g_mem_chunk_destroy(fragment_data_chunk);
 315         if (reassembled_key_chunk != NULL)
 316                 g_mem_chunk_destroy(reassembled_key_chunk);
 317         fragment_key_chunk = g_mem_chunk_new("fragment_key_chunk",
 318             sizeof(fragment_key),
 319             fragment_init_count * sizeof(fragment_key),
 320             G_ALLOC_AND_FREE);
 321         dcerpc_fragment_key_chunk = g_mem_chunk_new("dcerpc_fragment_key_chunk",
 322             sizeof(dcerpc_fragment_key),
 323             fragment_init_count * sizeof(dcerpc_fragment_key),
 324             G_ALLOC_AND_FREE);
 325         fragment_data_chunk = g_mem_chunk_new("fragment_data_chunk",
 326             sizeof(fragment_data),
 327             fragment_init_count * sizeof(fragment_data),
 328             G_ALLOC_ONLY);
 329         reassembled_key_chunk = g_mem_chunk_new("reassembled_key_chunk",
 330             sizeof(reassembled_key),
 331             fragment_init_count * sizeof(reassembled_key),
 332             G_ALLOC_AND_FREE);
 333 }
 334
 335 /* This function cleans up the stored state and removes the reassembly data and
 336  * (with one exception) all allocated memory for matching reassembly.
 337  *
 338  * The exception is :
 339  * If the PDU was already completely reassembled, then the buffer containing the
 340  * reassembled data WILL NOT be free()d, and the pointer to that buffer will be
 341  * returned.
 342  * Othervise the function will return NULL.
 343  *
 344  * So, if you call fragment_delete and it returns non-NULL, YOU are responsible to
 345  * g_free() that buffer.
 346  */
 347 unsigned char *
 348 fragment_delete(packet_info *pinfo, guint32 id, GHashTable *fragment_table)
 349 {
 350         fragment_data *fd_head, *fd;
 351         fragment_key key;
 352         unsigned char *data=NULL;
 353
 354         /* create key to search hash with */
 355         key.src = pinfo->src;
 356         key.dst = pinfo->dst;
 357         key.id  = id;
 358
 359         fd_head = g_hash_table_lookup(fragment_table, &key);
 360
 361         if(fd_head==NULL){
 362                 /* We do not recognize this as a PDU we have seen before. return*/
 363                 return NULL;
 364         }
 365
 366         data=fd_head->data;
 367         /* loop over all partial fragments and free any buffers */
 368         for(fd=fd_head->next;fd;){
 369                 fragment_data *tmp_fd;
 370                 tmp_fd=fd->next;
 371
 372                 if( !(fd->flags&FD_NOT_MALLOCED) )
 373                         g_free(fd->data);
 374                 g_mem_chunk_free(fragment_data_chunk, fd);
 375                 fd=tmp_fd;
 376         }
 377         g_mem_chunk_free(fragment_data_chunk, fd_head);
 378         g_hash_table_remove(fragment_table, &key);
 379
 380         return data;
 381 }
 382
 383 /* This function is used to check if there is partial or completed reassembly state
 384  * matching this packet. I.e. Are there reassembly going on or not for this packet?
 385  */
 386 fragment_data *
 387 fragment_get(packet_info *pinfo, guint32 id, GHashTable *fragment_table)
 388 {
 389         fragment_data *fd_head;
 390         fragment_key key;
 391
 392         /* create key to search hash with */
 393         key.src = pinfo->src;
 394         key.dst = pinfo->dst;
 395         key.id  = id;
 396
 397         fd_head = g_hash_table_lookup(fragment_table, &key);
 398
 399         return fd_head;
 400 }
 401
 402 /* This function can be used to explicitely set the total length (if known)
 403  * for reassembly of a PDU.
 404  * This is useful for reassembly of PDUs where one may have the total length specified
 405  * in the first fragment instead of as for, say, IPv4 where a flag indicates which
 406  * is the last fragment.
 407  *
 408  * Such protocols might fragment_add with a more_frags==TRUE for every fragment
 409  * and just tell the reassembly engine the expected total length of the reassembled data
 410  * using fragment_set_tot_len immediately after doing fragment_add for the first packet.
 411  *
 412  * note that for FD_BLOCKSEQUENCE tot_len is the index for the tail fragment.
 413  * i.e. since the block numbers start at 0, if we specify tot_len==2, that
 414  * actually means we want to defragment 3 blocks, block 0, 1 and 2.
 415  */
 416 void
 417 fragment_set_tot_len(packet_info *pinfo, guint32 id, GHashTable *fragment_table,
 418                      guint32 tot_len)
 419 {
 420         fragment_data *fd_head;
 421         fragment_key key;
 422
 423         /* create key to search hash with */
 424         key.src = pinfo->src;
 425         key.dst = pinfo->dst;
 426         key.id  = id;
 427
 428         fd_head = g_hash_table_lookup(fragment_table, &key);
 429
 430         if(fd_head){
 431                 fd_head->datalen = tot_len;
 432         }
 433
 434         return;
 435 }
 436
 437 guint32
 438 fragment_get_tot_len(packet_info *pinfo, guint32 id, GHashTable *fragment_table)
 439 {
 440         fragment_data *fd_head;
 441         fragment_key key;
 442
 443         /* create key to search hash with */
 444         key.src = pinfo->src;
 445         key.dst = pinfo->dst;
 446         key.id  = id;
 447
 448         fd_head = g_hash_table_lookup(fragment_table, &key);
 449
 450         if(fd_head){
 451                 return fd_head->datalen;
 452         }
 453
 454         return 0;
 455 }
 456
 457
 458 /* This function will set the partial reassembly flag for a fh.
 459    When this function is called, the fh MUST already exist, i.e.
 460    the fh MUST be created by the initial call to fragment_add() before
 461    this function is called.
 462    Also note that this function MUST be called to indicate a fh will be
 463    extended (increase the already stored data)
 464 */
 465
 466 void
 467 fragment_set_partial_reassembly(packet_info *pinfo, guint32 id, GHashTable *fragment_table)
 468 {
 469         fragment_data *fd_head;
 470         fragment_key key;
 471
 472         /* create key to search hash with */
 473         key.src = pinfo->src;
 474         key.dst = pinfo->dst;
 475         key.id  = id;
 476
 477         fd_head = g_hash_table_lookup(fragment_table, &key);
 478
 479         if(fd_head){
 480                 fd_head->flags |= FD_PARTIAL_REASSEMBLY;
 481         }
 482 }
 483
 484 /*
 485  * This function gets rid of an entry from a fragment table, given
 486  * a pointer to the key for that entry; it also frees up the key
 487  * and the addresses in it.
 488  */
 489 static void
 490 fragment_unhash(GHashTable *fragment_table, fragment_key *key)
 491 {
 492         /*
 493          * Free up the copies of the addresses from the old key.
 494          */
 495         g_free((gpointer)key->src.data);
 496         g_free((gpointer)key->dst.data);
 497
 498         /*
 499          * Remove the entry from the fragment table.
 500          */
 501         g_hash_table_remove(fragment_table, key);
 502
 503         /*
 504          * Free the key itself.
 505          */
 506         g_mem_chunk_free(fragment_key_chunk, key);
 507 }
 508
 509 /*
 510  * This function adds fragment_data structure to a reassembled-packet
 511  * hash table, using the frame numbers of each of the frames from
 512  * which it was reassembled as keys, and sets the "reassembled_in"
 513  * frame number.
 514  */
 515 static void
 516 fragment_reassembled(fragment_data *fd_head, packet_info *pinfo,
 517              GHashTable *reassembled_table, guint32 id)
 518 {
 519         reassembled_key *new_key;
 520         fragment_data *fd;
 521
 522         if (fd_head->next == NULL) {
 523                 /*
 524                  * This was not fragmented, so there's no fragment
 525                  * table; just hash it using the current frame number.
 526                  */
 527                 new_key = g_mem_chunk_alloc(reassembled_key_chunk);
 528                 new_key->frame = pinfo->fd->num;
 529                 new_key->id = id;
 530                 g_hash_table_insert(reassembled_table, new_key, fd_head);
 531         } else {
 532                 /*
 533                  * Hash it with the frame numbers for all the frames.
 534                  */
 535                 for (fd = fd_head->next; fd != NULL; fd = fd->next){
 536                         new_key = g_mem_chunk_alloc(reassembled_key_chunk);
 537                         new_key->frame = fd->frame;
 538                         new_key->id = id;
 539                         g_hash_table_insert(reassembled_table, new_key,
 540                             fd_head);
 541                 }
 542         }
 543         fd_head->flags |= FD_DEFRAGMENTED;
 544         fd_head->reassembled_in = pinfo->fd->num;
 545 }
 546
 547 /*
 548  * This function adds a new fragment to the fragment hash table.
 549  * If this is the first fragment seen for this datagram, a new entry
 550  * is created in the hash table, otherwise this fragment is just added
 551  * to the linked list of fragments for this packet.
 552  * The list of fragments for a specific datagram is kept sorted for
 553  * easier handling.
 554  *
 555  * Returns a pointer to the head of the fragment data list if we have all the
 556  * fragments, NULL otherwise.
 557  *
 558  * This function assumes frag_offset being a byte offset into the defragment
 559  * packet.
 560  *
 561  * 01-2002
 562  * Once the fh is defragmented (= FD_DEFRAGMENTED set), it can be
 563  * extended using the FD_PARTIAL_REASSEMBLY flag. This flag should be set
 564  * using fragment_set_partial_reassembly() before calling fragment_add
 565  * with the new fragment. FD_TOOLONGFRAGMENT and FD_MULTIPLETAILS flags
 566  * are lowered when a new extension process is started.
 567  */
 568 static gboolean
 569 fragment_add_work(fragment_data *fd_head, tvbuff_t *tvb, int offset,
 570              packet_info *pinfo, guint32 frag_offset,
 571              guint32 frag_data_len, gboolean more_frags)
 572 {
 573         fragment_data *fd;
 574         fragment_data *fd_i;
 575         guint32 max, dfpos;
 576         unsigned char *old_data;
 577
 578         /* create new fd describing this fragment */
 579         fd = g_mem_chunk_alloc(fragment_data_chunk);
 580         fd->next = NULL;
 581         fd->flags = 0;
 582         fd->frame = pinfo->fd->num;
 583         fd->offset = frag_offset;
 584         fd->len  = frag_data_len;
 585         fd->data = NULL;
 586
 587         /*
 588          * If it was already defragmented and this new fragment goes beyond
 589          * data limits, set flag in already empty fds & point old fds to malloc'ed data.
 590          */
 591         if(fd_head->flags & FD_DEFRAGMENTED && (frag_offset+frag_data_len) >= fd_head->datalen &&
 592                 fd_head->flags & FD_PARTIAL_REASSEMBLY){
 593                 for(fd_i=fd_head->next; fd_i; fd_i=fd_i->next){
 594                         if( !fd_i->data ) {
 595                                 fd_i->data = fd_head->data + fd_i->offset;
 596                                 fd_i->flags |= FD_NOT_MALLOCED;
 597                         }
 598                         fd_i->flags &= (~FD_TOOLONGFRAGMENT) & (~FD_MULTIPLETAILS);
 599                 }
 600                 fd_head->flags ^= FD_DEFRAGMENTED|FD_PARTIAL_REASSEMBLY;
 601                 fd_head->flags &= (~FD_TOOLONGFRAGMENT) & (~FD_MULTIPLETAILS);
 602                 fd_head->datalen=0;
 603         }
 604
 605         if (!more_frags) {
 606                 /*
 607                  * This is the tail fragment in the sequence.
 608                  */
 609                 if (fd_head->datalen) {
 610                         /* ok we have already seen other tails for this packet
 611                          * it might be a duplicate.
 612                          */
 613                         if (fd_head->datalen != (fd->offset + fd->len) ){
 614                                 /* Oops, this tail indicates a different packet
 615                                  * len than the previous ones. Somethings wrong
 616                                  */
 617                                 fd->flags      |= FD_MULTIPLETAILS;
 618                                 fd_head->flags |= FD_MULTIPLETAILS;
 619                         }
 620                 } else {
 621                         /* this was the first tail fragment, now we know the
 622                          * length of the packet
 623                          */
 624                         fd_head->datalen = fd->offset + fd->len;
 625                 }
 626         }
 627
 628
 629
 630
 631         /* If the packet is already defragmented, this MUST be an overlap.
 632          * The entire defragmented packet is in fd_head->data
 633          * Even if we have previously defragmented this packet, we still check
 634          * check it. Someone might play overlap and TTL games.
 635          */
 636         if (fd_head->flags & FD_DEFRAGMENTED) {
 637                 fd->flags      |= FD_OVERLAP;
 638                 fd_head->flags |= FD_OVERLAP;
 639                 /* make sure its not too long */
 640                 if (fd->offset + fd->len > fd_head->datalen) {
 641                         fd->flags      |= FD_TOOLONGFRAGMENT;
 642                         fd_head->flags |= FD_TOOLONGFRAGMENT;
 643                         LINK_FRAG(fd_head,fd);
 644                         return TRUE;
 645                 }
 646                 /* make sure it doesnt conflict with previous data */
 647                 if ( memcmp(fd_head->data+fd->offset,
 648                         tvb_get_ptr(tvb,offset,fd->len),fd->len) ){
 649                         fd->flags      |= FD_OVERLAPCONFLICT;
 650                         fd_head->flags |= FD_OVERLAPCONFLICT;
 651                         LINK_FRAG(fd_head,fd);
 652                         return TRUE;
 653                 }
 654                 /* it was just an overlap, link it and return */
 655                 LINK_FRAG(fd_head,fd);
 656                 return TRUE;
 657         }
 658
 659
 660
 661         /* If we have reached this point, the packet is not defragmented yet.
 662          * Save all payload in a buffer until we can defragment.
 663          * XXX - what if we didn't capture the entire fragment due
 664          * to a too-short snapshot length?
 665          */
 666         fd->data = g_malloc(fd->len);
 667         tvb_memcpy(tvb, fd->data, offset, fd->len);
 668         LINK_FRAG(fd_head,fd);
 669
 670
 671         if( !(fd_head->datalen) ){
 672                 /* if we dont know the datalen, there are still missing
 673                  * packets. Cheaper than the check below.
 674                  */
 675                 return FALSE;
 676         }
 677
 678
 679         /* check if we have received the entire fragment
 680          * this is easy since the list is sorted and the head is faked.
 681          */
 682         max = 0;
 683         for (fd_i=fd_head->next;fd_i;fd_i=fd_i->next) {
 684                 if ( ((fd_i->offset)<=max) &&
 685                     ((fd_i->offset+fd_i->len)>max) ){
 686                         max = fd_i->offset+fd_i->len;
 687                 }
 688         }
 689
 690         if (max < (fd_head->datalen)) {
 691                 /* we have not received all packets yet */
 692                 return FALSE;
 693         }
 694
 695
 696         if (max > (fd_head->datalen)) {
 697                 /*XXX not sure if current fd was the TOOLONG*/
 698                 /*XXX is it fair to flag current fd*/
 699                 /* oops, too long fragment detected */
 700                 fd->flags      |= FD_TOOLONGFRAGMENT;
 701                 fd_head->flags |= FD_TOOLONGFRAGMENT;
 702         }
 703
 704
 705         /* we have received an entire packet, defragment it and
 706          * free all fragments
 707          */
 708         /* store old data just in case */
 709         old_data=fd_head->data;
 710         fd_head->data = g_malloc(max);
 711
 712         /* add all data fragments */
 713         for (dfpos=0,fd_i=fd_head;fd_i;fd_i=fd_i->next) {
 714                 if (fd_i->len) {
 715                         if (fd_i->offset < dfpos) {
 716                                 fd_i->flags    |= FD_OVERLAP;
 717                                 fd_head->flags |= FD_OVERLAP;
 718                                 if ( memcmp(fd_head->data+fd_i->offset,
 719                                         fd_i->data,
 720                                         MIN(fd_i->len,(dfpos-fd_i->offset))
 721                                         ) ){
 722                                         fd_i->flags    |= FD_OVERLAPCONFLICT;
 723                                         fd_head->flags |= FD_OVERLAPCONFLICT;
 724                                 }
 725                         }
 726                         /* dfpos is always >= than fd_i->offset */
 727                         /* No gaps can exist here, max_loop(above) does this */
 728                         if( fd_i->offset+fd_i->len > dfpos )
 729                                 memcpy(fd_head->data+dfpos, fd_i->data+(dfpos-fd_i->offset),
 730                                         fd_i->len-(dfpos-fd_i->offset));
 731                         if( fd_i->flags & FD_NOT_MALLOCED )
 732                                 fd_i->flags ^= FD_NOT_MALLOCED;
 733                         else
 734                                 g_free(fd_i->data);
 735                         fd_i->data=NULL;
 736
 737                         dfpos=MAX(dfpos,(fd_i->offset+fd_i->len));
 738                 }
 739         }
 740
 741         if( old_data )
 742                 g_free(old_data);
 743         /* mark this packet as defragmented.
 744            allows us to skip any trailing fragments */
 745         fd_head->flags |= FD_DEFRAGMENTED;
 746         fd_head->reassembled_in=pinfo->fd->num;
 747
 748         return TRUE;
 749 }
 750
 751 fragment_data *
 752 fragment_add_common(tvbuff_t *tvb, int offset, packet_info *pinfo, guint32 id,
 753              GHashTable *fragment_table, guint32 frag_offset,
 754              guint32 frag_data_len, gboolean more_frags,
 755              gboolean check_already_added)
 756 {
 757         fragment_key key, *new_key;
 758         fragment_data *fd_head;
 759         fragment_data *fd_item;
 760         gboolean already_added=pinfo->fd->flags.visited;
 761
 762         /* create key to search hash with */
 763         key.src = pinfo->src;
 764         key.dst = pinfo->dst;
 765         key.id  = id;
 766
 767         fd_head = g_hash_table_lookup(fragment_table, &key);
 768
 769         /*
 770          * "already_added" is true if "pinfo->fd->flags.visited" is true;
 771          * if "pinfo->fd->flags.visited", this isn't the first pass, so
 772          * we've already done all the reassembly and added all the
 773          * fragments.
 774          *
 775          * If it's not true, but "check_already_added" is true, just check
 776          * if we have seen this fragment before, i.e., if we have already
 777          * added it to reassembly.
 778          * That can be true even if "pinfo->fd->flags.visited" is false
 779          * since we sometimes might call a subdissector multiple times.
 780          * As an additional check, just make sure we have not already added
 781          * this frame to the reassembly list, if there is a reassembly list;
 782          * note that the first item in the reassembly list is not a
 783          * fragment, it's a data structure for the reassembled packet.
 784          * We don't check it because its "frame" member isn't initialized
 785          * to anything, and because it doesn't count in any case.
 786          */
 787         if (!already_added && check_already_added && fd_head != NULL) {
 788                 for(fd_item=fd_head->next;fd_item;fd_item=fd_item->next){
 789                         if(pinfo->fd->num==fd_item->frame){
 790                                 already_added=TRUE;
 791                         }
 792                 }
 793         }
 794         /* have we already added this frame ?*/
 795         if (already_added) {
 796                 if (fd_head != NULL && fd_head->flags & FD_DEFRAGMENTED) {
 797                         return fd_head;
 798                 } else {
 799                         return NULL;
 800                 }
 801         }
 802
 803         if (fd_head==NULL){
 804                 /* not found, this must be the first snooped fragment for this
 805                  * packet. Create list-head.
 806                  */
 807                 fd_head=g_mem_chunk_alloc(fragment_data_chunk);
 808
 809                 /* head/first structure in list only holds no other data than
 810                  * 'datalen' then we don't have to change the head of the list
 811                  * even if we want to keep it sorted
 812                  */
 813                 fd_head->next=NULL;
 814                 fd_head->datalen=0;
 815                 fd_head->offset=0;
 816                 fd_head->len=0;
 817                 fd_head->flags=0;
 818                 fd_head->data=NULL;
 819                 fd_head->reassembled_in=0;
 820
 821                 /*
 822                  * We're going to use the key to insert the fragment,
 823                  * so allocate a structure for it, and copy the
 824                  * addresses, allocating new buffers for the address
 825                  * data.
 826                  */
 827                 new_key = g_mem_chunk_alloc(fragment_key_chunk);
 828                 COPY_ADDRESS(&new_key->src, &key.src);
 829                 COPY_ADDRESS(&new_key->dst, &key.dst);
 830                 new_key->id = key.id;
 831                 g_hash_table_insert(fragment_table, new_key, fd_head);
 832         }
 833
 834         if (fragment_add_work(fd_head, tvb, offset, pinfo, frag_offset,
 835             frag_data_len, more_frags)) {
 836                 /*
 837                  * Reassembly is complete.
 838                  */
 839                 return fd_head;
 840         } else {
 841                 /*
 842                  * Reassembly isn't complete.
 843                  */
 844                 return NULL;
 845         }
 846 }
 847
 848 fragment_data *
 849 fragment_add(tvbuff_t *tvb, int offset, packet_info *pinfo, guint32 id,
 850              GHashTable *fragment_table, guint32 frag_offset,
 851              guint32 frag_data_len, gboolean more_frags)
 852 {
 853         return fragment_add_common(tvb, offset, pinfo, id, fragment_table,
 854             frag_offset, frag_data_len, more_frags, TRUE);
 855 }
 856
 857 /*
 858  * For use when you can have multiple fragments in the same frame added
 859  * to the same reassembled PDU, e.g. with ONC RPC-over-TCP.
 860  */
 861 fragment_data *
 862 fragment_add_multiple_ok(tvbuff_t *tvb, int offset, packet_info *pinfo,
 863                          guint32 id, GHashTable *fragment_table,
 864                          guint32 frag_offset, guint32 frag_data_len,
 865                          gboolean more_frags)
 866 {
 867         return fragment_add_common(tvb, offset, pinfo, id, fragment_table,
 868             frag_offset, frag_data_len, more_frags, FALSE);
 869 }
 870
 871 fragment_data *
 872 fragment_add_check(tvbuff_t *tvb, int offset, packet_info *pinfo,
 873              guint32 id, GHashTable *fragment_table,
 874              GHashTable *reassembled_table, guint32 frag_offset,
 875              guint32 frag_data_len, gboolean more_frags)
 876 {
 877         reassembled_key reass_key;
 878         fragment_key key, *new_key, *old_key;
 879         gpointer orig_key, value;
 880         fragment_data *fd_head;
 881
 882         /*
 883          * If this isn't the first pass, look for this frame in the table
 884          * of reassembled packets.
 885          */
 886         if (pinfo->fd->flags.visited) {
 887                 reass_key.frame = pinfo->fd->num;
 888                 reass_key.id = id;
 889                 return g_hash_table_lookup(reassembled_table, &reass_key);
 890         }
 891
 892         /* create key to search hash with */
 893         key.src = pinfo->src;
 894         key.dst = pinfo->dst;
 895         key.id  = id;
 896
 897         if (!g_hash_table_lookup_extended(fragment_table, &key,
 898                                           &orig_key, &value)) {
 899                 /* not found, this must be the first snooped fragment for this
 900                  * packet. Create list-head.
 901                  */
 902                 fd_head=g_mem_chunk_alloc(fragment_data_chunk);
 903
 904                 /* head/first structure in list only holds no other data than
 905                  * 'datalen' then we don't have to change the head of the list
 906                  * even if we want to keep it sorted
 907                  */
 908                 fd_head->next=NULL;
 909                 fd_head->datalen=0;
 910                 fd_head->offset=0;
 911                 fd_head->len=0;
 912                 fd_head->flags=0;
 913                 fd_head->data=NULL;
 914                 fd_head->reassembled_in=0;
 915
 916                 /*
 917                  * We're going to use the key to insert the fragment,
 918                  * so allocate a structure for it, and copy the
 919                  * addresses, allocating new buffers for the address
 920                  * data.
 921                  */
 922                 new_key = g_mem_chunk_alloc(fragment_key_chunk);
 923                 COPY_ADDRESS(&new_key->src, &key.src);
 924                 COPY_ADDRESS(&new_key->dst, &key.dst);
 925                 new_key->id = key.id;
 926                 g_hash_table_insert(fragment_table, new_key, fd_head);
 927
 928                 orig_key = new_key;     /* for unhashing it later */
 929         } else {
 930                 /*
 931                  * We found it.
 932                  */
 933                 fd_head = value;
 934         }
 935
 936         /*
 937          * If this is a short frame, then we can't, and don't, do
 938          * reassembly on it.  We just give up.
 939          */
 940         if (tvb_reported_length(tvb) > tvb_length(tvb))
 941                 return NULL;
 942
 943         if (fragment_add_work(fd_head, tvb, offset, pinfo, frag_offset,
 944             frag_data_len, more_frags)) {
 945                 /*
 946                  * Reassembly is complete.
 947                  * Remove this from the table of in-progress
 948                  * reassemblies, add it to the table of
 949                  * reassembled packets, and return it.
 950                  */
 951
 952                 /*
 953                  * Remove this from the table of in-progress reassemblies,
 954                  * and free up any memory used for it in that table.
 955                  */
 956                 old_key = orig_key;
 957                 fragment_unhash(fragment_table, old_key);
 958
 959                 /*
 960                  * Add this item to the table of reassembled packets.
 961                  */
 962                 fragment_reassembled(fd_head, pinfo, reassembled_table, id);
 963                 return fd_head;
 964         } else {
 965                 /*
 966                  * Reassembly isn't complete.
 967                  */
 968                 return NULL;
 969         }
 970 }
 971
 972 /*
 973  * This function adds a new fragment to the entry for a reassembly
 974  * operation.
 975  *
 976  * The list of fragments for a specific datagram is kept sorted for
 977  * easier handling.
 978  *
 979  * Returns TRUE if we have all the fragments, FALSE otherwise.
 980  *
 981  * This function assumes frag_number being a block sequence number.
 982  * The bsn for the first block is 0.
 983  */
 984 static gboolean
 985 fragment_add_seq_work(fragment_data *fd_head, tvbuff_t *tvb, int offset,
 986              packet_info *pinfo, guint32 frag_number,
 987              guint32 frag_data_len, gboolean more_frags)
 988 {
 989         fragment_data *fd;
 990         fragment_data *fd_i;
 991         fragment_data *last_fd;
 992         guint32 max, dfpos, size;
 993
 994         /* create new fd describing this fragment */
 995         fd = g_mem_chunk_alloc(fragment_data_chunk);
 996         fd->next = NULL;
 997         fd->flags = 0;
 998         fd->frame = pinfo->fd->num;
 999         fd->offset = frag_number;
1000         fd->len  = frag_data_len;
1001         fd->data = NULL;
1002
1003         if (!more_frags) {
1004                 /*
1005                  * This is the tail fragment in the sequence.
1006                  */
1007                 if (fd_head->datalen) {
1008                         /* ok we have already seen other tails for this packet
1009                          * it might be a duplicate.
1010                          */
1011                         if (fd_head->datalen != fd->offset ){
1012                                 /* Oops, this tail indicates a different packet
1013                                  * len than the previous ones. Somethings wrong
1014                                  */
1015                                 fd->flags      |= FD_MULTIPLETAILS;
1016                                 fd_head->flags |= FD_MULTIPLETAILS;
1017                         }
1018                 } else {
1019                         /* this was the first tail fragment, now we know the
1020                          * sequence number of that fragment (which is NOT
1021                          * the length of the packet!)
1022                          */
1023                         fd_head->datalen = fd->offset;
1024                 }
1025         }
1026
1027         /* If the packet is already defragmented, this MUST be an overlap.
1028          * The entire defragmented packet is in fd_head->data
1029          * Even if we have previously defragmented this packet, we still check
1030          * check it. Someone might play overlap and TTL games.
1031          */
1032         if (fd_head->flags & FD_DEFRAGMENTED) {
1033                 fd->flags      |= FD_OVERLAP;
1034                 fd_head->flags |= FD_OVERLAP;
1035
1036                 /* make sure it's not past the end */
1037                 if (fd->offset > fd_head->datalen) {
1038                         /* new fragment comes after the end */
1039                         fd->flags      |= FD_TOOLONGFRAGMENT;
1040                         fd_head->flags |= FD_TOOLONGFRAGMENT;
1041                         LINK_FRAG(fd_head,fd);
1042                         return TRUE;
1043                 }
1044                 /* make sure it doesnt conflict with previous data */
1045                 dfpos=0;
1046                 last_fd=NULL;
1047                 for (fd_i=fd_head->next;fd_i->offset!=fd->offset;fd_i=fd_i->next) {
1048                   if (!last_fd || last_fd->offset!=fd_i->offset){
1049                     dfpos += fd_i->len;
1050                   }
1051                   last_fd=fd_i;
1052                 }
1053                 if(fd_i){
1054                         /* new fragment overlaps existing fragment */
1055                         if(fd_i->len!=fd->len){
1056                                 /*
1057                                  * They have different lengths; this
1058                                  * is definitely a conflict.
1059                                  */
1060                                 fd->flags      |= FD_OVERLAPCONFLICT;
1061                                 fd_head->flags |= FD_OVERLAPCONFLICT;
1062                                 LINK_FRAG(fd_head,fd);
1063                                 return TRUE;
1064                         }
1065                         g_assert(fd_head->len >= dfpos + fd->len);
1066                         if ( memcmp(fd_head->data+dfpos,
1067                             tvb_get_ptr(tvb,offset,fd->len),fd->len) ){
1068                                 /*
1069                                  * They have the same length, but the
1070                                  * data isn't the same.
1071                                  */
1072                                 fd->flags      |= FD_OVERLAPCONFLICT;
1073                                 fd_head->flags |= FD_OVERLAPCONFLICT;
1074                                 LINK_FRAG(fd_head,fd);
1075                                 return TRUE;
1076                         }
1077                         /* it was just an overlap, link it and return */
1078                         LINK_FRAG(fd_head,fd);
1079                         return TRUE;
1080                 } else {
1081                         /*
1082                          * New fragment doesn't overlap an existing
1083                          * fragment - there was presumably a gap in
1084                          * the sequence number space.
1085                          *
1086                          * XXX - what should we do here?  Is it always
1087                          * the case that there are no gaps, or are there
1088                          * protcols using sequence numbers where there
1089                          * can be gaps?
1090                          *
1091                          * If the former, the check below for having
1092                          * received all the fragments should check for
1093                          * holes in the sequence number space and for the
1094                          * first sequence number being 0.  If we do that,
1095                          * the only way we can get here is if this fragment
1096                          * is past the end of the sequence number space -
1097                          * but the check for "fd->offset > fd_head->datalen"
1098                          * would have caught that above, so it can't happen.
1099                          *
1100                          * If the latter, we don't have a good way of
1101                          * knowing whether reassembly is complete if we
1102                          * get packet out of order such that the "last"
1103                          * fragment doesn't show up last - but, unless
1104                          * in-order reliable delivery of fragments is
1105                          * guaranteed, an implementation of the protocol
1106                          * has no way of knowing whether reassembly is
1107                          * complete, either.
1108                          *
1109                          * For now, we just link the fragment in and
1110                          * return.
1111                          */
1112                         LINK_FRAG(fd_head,fd);
1113                         return TRUE;
1114                 }
1115         }
1116
1117         /* If we have reached this point, the packet is not defragmented yet.
1118          * Save all payload in a buffer until we can defragment.
1119          * XXX - what if we didn't capture the entire fragment due
1120          * to a too-short snapshot length?
1121          */
1122         fd->data = g_malloc(fd->len);
1123         tvb_memcpy(tvb, fd->data, offset, fd->len);
1124         LINK_FRAG(fd_head,fd);
1125
1126
1127         if( !(fd_head->datalen) ){
1128                 /* if we dont know the sequence number of the last fragment,
1129                  * there are definitely still missing packets. Cheaper than
1130                  * the check below.
1131                  */
1132                 return FALSE;
1133         }
1134
1135
1136         /* check if we have received the entire fragment
1137          * this is easy since the list is sorted and the head is faked.
1138          */
1139         max = 0;
1140         for(fd_i=fd_head->next;fd_i;fd_i=fd_i->next) {
1141           if ( fd_i->offset==max ){
1142             max++;
1143           }
1144         }
1145         /* max will now be datalen+1 if all fragments have been seen */
1146
1147         if (max <= fd_head->datalen) {
1148                 /* we have not received all packets yet */
1149                 return FALSE;
1150         }
1151
1152
1153         if (max > (fd_head->datalen+1)) {
1154                 /* oops, too long fragment detected */
1155                 fd->flags      |= FD_TOOLONGFRAGMENT;
1156                 fd_head->flags |= FD_TOOLONGFRAGMENT;
1157         }
1158
1159
1160         /* we have received an entire packet, defragment it and
1161          * free all fragments
1162          */
1163         size=0;
1164         last_fd=NULL;
1165         for(fd_i=fd_head->next;fd_i;fd_i=fd_i->next) {
1166           if(!last_fd || last_fd->offset!=fd_i->offset){
1167             size+=fd_i->len;
1168           }
1169           last_fd=fd_i;
1170         }
1171         fd_head->data = g_malloc(size);
1172         fd_head->len = size;            /* record size for caller       */
1173
1174         /* add all data fragments */
1175         last_fd=NULL;
1176         for (dfpos=0,fd_i=fd_head->next;fd_i;fd_i=fd_i->next) {
1177           if (fd_i->len) {
1178             if(!last_fd || last_fd->offset!=fd_i->offset){
1179               memcpy(fd_head->data+dfpos,fd_i->data,fd_i->len);
1180               dfpos += fd_i->len;
1181             } else {
1182               /* duplicate/retransmission/overlap */
1183               fd_i->flags    |= FD_OVERLAP;
1184               fd_head->flags |= FD_OVERLAP;
1185               if( (last_fd->len!=fd_i->datalen)
1186                   || memcmp(last_fd->data, fd_i->data, last_fd->len) ){
1187                         fd->flags      |= FD_OVERLAPCONFLICT;
1188                         fd_head->flags |= FD_OVERLAPCONFLICT;
1189               }
1190             }
1191             last_fd=fd_i;
1192           }
1193         }
1194
1195         /* we have defragmented the pdu, now free all fragments*/
1196         for (fd_i=fd_head->next;fd_i;fd_i=fd_i->next) {
1197           if(fd_i->data){
1198             g_free(fd_i->data);
1199             fd_i->data=NULL;
1200           }
1201         }
1202
1203         /* mark this packet as defragmented.
1204            allows us to skip any trailing fragments */
1205         fd_head->flags |= FD_DEFRAGMENTED;
1206         fd_head->reassembled_in=pinfo->fd->num;
1207
1208         return TRUE;
1209 }
1210
1211 /*
1212  * This function adds a new fragment to the fragment hash table.
1213  * If this is the first fragment seen for this datagram, a new entry
1214  * is created in the hash table, otherwise this fragment is just added
1215  * to the linked list of fragments for this packet.
1216  *
1217  * Returns a pointer to the head of the fragment data list if we have all the
1218  * fragments, NULL otherwise.
1219  *
1220  * This function assumes frag_number being a block sequence number.
1221  * The bsn for the first block is 0.
1222  */
1223 fragment_data *
1224 fragment_add_seq(tvbuff_t *tvb, int offset, packet_info *pinfo, guint32 id,
1225              GHashTable *fragment_table, guint32 frag_number,
1226              guint32 frag_data_len, gboolean more_frags)
1227 {
1228         fragment_key key, *new_key;
1229         fragment_data *fd_head;
1230
1231         /* create key to search hash with */
1232         key.src = pinfo->src;
1233         key.dst = pinfo->dst;
1234         key.id  = id;
1235
1236         fd_head = g_hash_table_lookup(fragment_table, &key);
1237
1238         /* have we already seen this frame ?*/
1239         if (pinfo->fd->flags.visited) {
1240                 if (fd_head != NULL && fd_head->flags & FD_DEFRAGMENTED) {
1241                         return fd_head;
1242                 } else {
1243                         return NULL;
1244                 }
1245         }
1246
1247         if (fd_head==NULL){
1248                 /* not found, this must be the first snooped fragment for this
1249                  * packet. Create list-head.
1250                  */
1251                 fd_head=g_mem_chunk_alloc(fragment_data_chunk);
1252
1253                 /* head/first structure in list only holds no other data than
1254                  * 'datalen' then we don't have to change the head of the list
1255                  * even if we want to keep it sorted
1256                  */
1257                 fd_head->next=NULL;
1258                 fd_head->datalen=0;
1259                 fd_head->offset=0;
1260                 fd_head->len=0;
1261                 fd_head->flags=FD_BLOCKSEQUENCE;
1262                 fd_head->data=NULL;
1263                 fd_head->reassembled_in=0;
1264
1265                 /*
1266                  * We're going to use the key to insert the fragment,
1267                  * so allocate a structure for it, and copy the
1268                  * addresses, allocating new buffers for the address
1269                  * data.
1270                  */
1271                 new_key = g_mem_chunk_alloc(fragment_key_chunk);
1272                 COPY_ADDRESS(&new_key->src, &key.src);
1273                 COPY_ADDRESS(&new_key->dst, &key.dst);
1274                 new_key->id = key.id;
1275                 g_hash_table_insert(fragment_table, new_key, fd_head);
1276         }
1277
1278         if (fragment_add_seq_work(fd_head, tvb, offset, pinfo,
1279                                   frag_number, frag_data_len, more_frags)) {
1280                 /*
1281                  * Reassembly is complete.
1282                  */
1283                 return fd_head;
1284         } else {
1285                 /*
1286                  * Reassembly isn't complete.
1287                  */
1288                 return NULL;
1289         }
1290 }
1291
1292 fragment_data *
1293 fragment_add_dcerpc(tvbuff_t *tvb, int offset, packet_info *pinfo, guint32 id,
1294                     void *v_act_id,
1295                     GHashTable *fragment_table, guint32 frag_number,
1296                     guint32 frag_data_len, gboolean more_frags)
1297 {
1298        dcerpc_fragment_key key, *new_key;
1299        fragment_data *fd_head;
1300        e_uuid_t *act_id = (e_uuid_t *)v_act_id;
1301
1302        /* create key to search hash with */
1303        key.src = pinfo->src;
1304        key.dst = pinfo->dst;
1305        key.id  = id;
1306        key.act_id  = *act_id;
1307
1308        fd_head = g_hash_table_lookup(fragment_table, &key);
1309
1310        /* have we already seen this frame ?*/
1311        if (pinfo->fd->flags.visited) {
1312                if (fd_head != NULL && fd_head->flags & FD_DEFRAGMENTED) {
1313                        return fd_head;
1314                } else {
1315                        return NULL;
1316                }
1317        }
1318
1319        if (fd_head==NULL){
1320                /* not found, this must be the first snooped fragment for this
1321                  * packet. Create list-head.
1322                 */
1323                fd_head=g_mem_chunk_alloc(fragment_data_chunk);
1324
1325                /* head/first structure in list only holds no other data than
1326                  * 'datalen' then we don't have to change the head of the list
1327                  * even if we want to keep it sorted
1328                  */
1329                fd_head->next=NULL;
1330                fd_head->datalen=0;
1331                fd_head->offset=0;
1332                fd_head->len=0;
1333                fd_head->flags=FD_BLOCKSEQUENCE;
1334                fd_head->data=NULL;
1335                fd_head->reassembled_in=0;
1336
1337                /*
1338                 * We're going to use the key to insert the fragment,
1339                 * so allocate a structure for it, and copy the
1340                 * addresses, allocating new buffers for the address
1341                 * data.
1342                 */
1343                new_key = g_mem_chunk_alloc(dcerpc_fragment_key_chunk);
1344                COPY_ADDRESS(&new_key->src, &key.src);
1345                COPY_ADDRESS(&new_key->dst, &key.dst);
1346                new_key->id = key.id;
1347                new_key->act_id = key.act_id;
1348                g_hash_table_insert(fragment_table, new_key, fd_head);
1349        }
1350
1351        if (fragment_add_seq_work(fd_head, tvb, offset, pinfo,
1352                                  frag_number, frag_data_len, more_frags)) {
1353                /*
1354                 * Reassembly is complete.
1355                 */
1356                return fd_head;
1357        } else {
1358                /*
1359                 * Reassembly isn't complete.
1360                 */
1361                return NULL;
1362        }
1363 }
1364
1365 /*
1366  * This does the work for "fragment_add_seq_check()" and
1367  * "fragment_add_seq_next()".
1368  *
1369  * This function assumes frag_number being a block sequence number.
1370  * The bsn for the first block is 0.
1371  *
1372  * If "no_frag_number" is TRUE, it uses the next expected fragment number
1373  * as the fragment number if there is a reassembly in progress, otherwise
1374  * it uses 0.
1375  *
1376  * If "no_frag_number" is FALSE, it uses the "frag_number" argument as
1377  * the fragment number.
1378  *
1379  * If this is the first fragment seen for this datagram, a new
1380  * "fragment_data" structure is allocated to refer to the reassembled,
1381  * packet, and:
1382  *
1383  *      if "more_frags" is false and "frag_802_11_hack" is true, the
1384  *      structure is not added to the hash table, and not given any
1385  *      fragments to refer to, but is just returned - this is a special
1386  *      hack for the 802.11 dissector (see packet-80211.c);
1387  *
1388  *      otherwise, this fragment is added to the linked list of fragments
1389  *      for this packet, and the "fragment_data" structure is put into
1390  *      the hash table.
1391  *
1392  * Otherwise, this fragment is just added to the linked list of fragments
1393  * for this packet.
1394  *
1395  * If, after processing this fragment, we have all the fragments,
1396  * "fragment_add_seq_check_work()" removes that from the fragment hash
1397  * table if necessary and adds it to the table of reassembled fragments,
1398  * and returns a pointer to the head of the fragment list.
1399  *
1400  * If this is the first fragment we've seen, and "more_frags" is false
1401  * and "frag_802_11_hack" is true, "fragment_add_seq_check_work()" does
1402  * nothing to the fragment data list, and returns a pointer to the head
1403  * of that (empty) list.
1404  *
1405  * Otherwise, it returns NULL.
1406  */
1407 static fragment_data *
1408 fragment_add_seq_check_work(tvbuff_t *tvb, int offset, packet_info *pinfo,
1409              guint32 id, GHashTable *fragment_table,
1410              GHashTable *reassembled_table, guint32 frag_number,
1411              guint32 frag_data_len, gboolean more_frags,
1412              gboolean no_frag_number, gboolean frag_802_11_hack)
1413 {
1414         reassembled_key reass_key;
1415         fragment_key key, *new_key, *old_key;
1416         gpointer orig_key, value;
1417         fragment_data *fd_head, *fd;
1418
1419         /*
1420          * Have we already seen this frame?
1421          * If so, look for it in the table of reassembled packets.
1422          */
1423         if (pinfo->fd->flags.visited) {
1424                 reass_key.frame = pinfo->fd->num;
1425                 reass_key.id = id;
1426                 return g_hash_table_lookup(reassembled_table, &reass_key);
1427         }
1428
1429         /* create key to search hash with */
1430         key.src = pinfo->src;
1431         key.dst = pinfo->dst;
1432         key.id  = id;
1433
1434         if (!g_hash_table_lookup_extended(fragment_table, &key,
1435                                           &orig_key, &value)) {
1436                 /* not found, this must be the first snooped fragment for this
1437                  * packet. Create list-head.
1438                  */
1439                 fd_head=g_mem_chunk_alloc(fragment_data_chunk);
1440
1441                 /* head/first structure in list only holds no other data than
1442                  * 'datalen' then we don't have to change the head of the list
1443                  * even if we want to keep it sorted
1444                  */
1445                 fd_head->next=NULL;
1446                 fd_head->datalen=0;
1447                 fd_head->offset=0;
1448                 fd_head->len=0;
1449                 fd_head->flags=FD_BLOCKSEQUENCE;
1450                 fd_head->data=NULL;
1451                 fd_head->reassembled_in=0;
1452
1453                 if ((no_frag_number || frag_802_11_hack) && !more_frags) {
1454                         /*
1455                          * This is the last fragment for this packet, and
1456                          * is the only one we've seen.
1457                          *
1458                          * Either we don't have sequence numbers, in which
1459                          * case we assume this is the first fragment for
1460                          * this packet, or we're doing special 802.11
1461                          * processing, in which case we assume it's one
1462                          * of those reassembled packets with a non-zero
1463                          * fragment number (see packet-80211.c); just
1464                          * add the fragment to the table of reassembled
1465                          * packets, and return a pointer to the head of
1466                          * the list.
1467                          */
1468                         fragment_reassembled(fd_head, pinfo,
1469                                reassembled_table, id);
1470                         return fd_head;
1471                 }
1472
1473                 /*
1474                  * We're going to use the key to insert the fragment,
1475                  * so allocate a structure for it, and copy the
1476                  * addresses, allocating new buffers for the address
1477                  * data.
1478                  */
1479                 new_key = g_mem_chunk_alloc(fragment_key_chunk);
1480                 COPY_ADDRESS(&new_key->src, &key.src);
1481                 COPY_ADDRESS(&new_key->dst, &key.dst);
1482                 new_key->id = key.id;
1483                 g_hash_table_insert(fragment_table, new_key, fd_head);
1484
1485                 orig_key = new_key;     /* for unhashing it later */
1486
1487                 /*
1488                  * If we weren't given an initial fragment number,
1489                  * make it 0.
1490                  */
1491                 if (no_frag_number)
1492                         frag_number = 0;
1493         } else {
1494                 /*
1495                  * We found it.
1496                  */
1497                 fd_head = value;
1498
1499                 /*
1500                  * If we weren't given an initial fragment number,
1501                  * use the next expected fragment number as the fragment
1502                  * number for this fragment.
1503                  */
1504                 if (no_frag_number) {
1505                         for (fd = fd_head; fd != NULL; fd = fd->next) {
1506                                 if (fd->next == NULL)
1507                                         frag_number = fd->offset + 1;
1508                         }
1509                 }
1510         }
1511
1512         /*
1513          * If we don't have all the data that is in this fragment,
1514          * then we can't, and don't, do reassembly on it.
1515          *
1516          * If it's the first frame, handle it as an unfragmented packet.
1517          * Otherwise, just handle it as a fragment.
1518          *
1519          * If "more_frags" isn't set, we get rid of the entry in the
1520          * hash table for this reassembly, as we don't need it any more.
1521          */
1522         if (!tvb_bytes_exist(tvb, offset, frag_data_len)) {
1523                 if (!more_frags) {
1524                         /*
1525                          * Remove this from the table of in-progress
1526                          * reassemblies, and free up any memory used for
1527                          * it in that table.
1528                          */
1529                         old_key = orig_key;
1530                         fragment_unhash(fragment_table, old_key);
1531                 }
1532                 return frag_number == 0 ? fd_head : NULL;
1533         }
1534
1535         if (fragment_add_seq_work(fd_head, tvb, offset, pinfo,
1536                                   frag_number, frag_data_len, more_frags)) {
1537                 /*
1538                  * Reassembly is complete.
1539                  * Remove this from the table of in-progress
1540                  * reassemblies, add it to the table of
1541                  * reassembled packets, and return it.
1542                  */
1543
1544                 /*
1545                  * Remove this from the table of in-progress reassemblies,
1546                  * and free up any memory used for it in that table.
1547                  */
1548                 old_key = orig_key;
1549                 fragment_unhash(fragment_table, old_key);
1550
1551                 /*
1552                  * Add this item to the table of reassembled packets.
1553                  */
1554                 fragment_reassembled(fd_head, pinfo, reassembled_table, id);
1555                 return fd_head;
1556         } else {
1557                 /*
1558                  * Reassembly isn't complete.
1559                  */
1560                 return NULL;
1561         }
1562 }
1563
1564 fragment_data *
1565 fragment_add_seq_check(tvbuff_t *tvb, int offset, packet_info *pinfo,
1566              guint32 id, GHashTable *fragment_table,
1567              GHashTable *reassembled_table, guint32 frag_number,
1568              guint32 frag_data_len, gboolean more_frags)
1569 {
1570         return fragment_add_seq_check_work(tvb, offset, pinfo, id,
1571             fragment_table, reassembled_table, frag_number, frag_data_len,
1572             more_frags, FALSE, FALSE);
1573 }
1574
1575 fragment_data *
1576 fragment_add_seq_802_11(tvbuff_t *tvb, int offset, packet_info *pinfo,
1577              guint32 id, GHashTable *fragment_table,
1578              GHashTable *reassembled_table, guint32 frag_number,
1579              guint32 frag_data_len, gboolean more_frags)
1580 {
1581         return fragment_add_seq_check_work(tvb, offset, pinfo, id,
1582             fragment_table, reassembled_table, frag_number, frag_data_len,
1583             more_frags, FALSE, TRUE);
1584 }
1585
1586 fragment_data *
1587 fragment_add_seq_next(tvbuff_t *tvb, int offset, packet_info *pinfo,
1588              guint32 id, GHashTable *fragment_table,
1589              GHashTable *reassembled_table, guint32 frag_data_len,
1590              gboolean more_frags)
1591 {
1592         return fragment_add_seq_check_work(tvb, offset, pinfo, id,
1593             fragment_table, reassembled_table, 0, frag_data_len,
1594             more_frags, TRUE, FALSE);
1595 }
1596
1597 /*
1598  * Process reassembled data; if we're on the frame in which the data
1599  * was reassembled, put the fragment information into the protocol
1600  * tree, and construct a tvbuff with the reassembled data, otherwise
1601  * just put a "reassembled in" item into the protocol tree.
1602  */
1603 tvbuff_t *
1604 process_reassembled_data(tvbuff_t *tvb, int offset, packet_info *pinfo,
1605     char *name, fragment_data *fd_head, const fragment_items *fit,
1606     gboolean *update_col_infop, proto_tree *tree)
1607 {
1608         tvbuff_t *next_tvb;
1609         gboolean update_col_info;
1610
1611         if (fd_head != NULL && pinfo->fd->num == fd_head->reassembled_in) {
1612                 /*
1613                  * OK, we've reassembled this.
1614                  * Is this something that's been reassembled from more
1615                  * than one fragment?
1616                  */
1617                 if (fd_head->next != NULL) {
1618                         /*
1619                          * Yes.
1620                          * Allocate a new tvbuff, referring to the
1621                          * reassembled payload.
1622                          */
1623                         if (fd_head->flags & FD_BLOCKSEQUENCE) {
1624                                 next_tvb = tvb_new_real_data(fd_head->data,
1625                                       fd_head->len, fd_head->len);
1626                         } else {
1627                                 next_tvb = tvb_new_real_data(fd_head->data,
1628                                       fd_head->datalen, fd_head->datalen);
1629                         }
1630
1631                         /*
1632                          * Add the tvbuff to the list of tvbuffs to which
1633                          * the tvbuff we were handed refers, so it'll get
1634                          * cleaned up when that tvbuff is cleaned up.
1635                          */
1636                         tvb_set_child_real_data_tvbuff(tvb, next_tvb);
1637
1638                         /* Add the defragmented data to the data source list. */
1639                         add_new_data_source(pinfo, next_tvb, name);
1640
1641                         /* show all fragments */
1642                         if (fd_head->flags & FD_BLOCKSEQUENCE) {
1643                                 update_col_info = !show_fragment_seq_tree(
1644                                     fd_head, fit,  tree, pinfo, next_tvb);
1645                         } else {
1646                                 update_col_info = !show_fragment_tree(fd_head,
1647                                     fit, tree, pinfo, next_tvb);
1648                         }
1649                 } else {
1650                         /*
1651                          * No.
1652                          * Return a tvbuff with the payload.
1653                          */
1654                         next_tvb = tvb_new_subset(tvb, offset, -1, -1);
1655                         pinfo->fragmented = FALSE;      /* one-fragment packet */
1656                         update_col_info = TRUE;
1657                 }
1658                 if (update_col_infop != NULL)
1659                         *update_col_infop = update_col_info;
1660         } else {
1661                 /*
1662                  * We don't have the complete reassembled payload, or this
1663                  * isn't the final frame of that payload.
1664                  */
1665                 next_tvb = NULL;
1666
1667                 /*
1668                  * If we know what frame this was reassembled in,
1669                  * and if there's a field to use for the number of
1670                  * the frame in which the packet was reassembled,
1671                  * add it to the protocol tree.
1672                  */
1673                 if (fd_head != NULL && fit->hf_reassembled_in != NULL) {
1674                         proto_tree_add_uint(tree,
1675                             *(fit->hf_reassembled_in), tvb,
1676                             0, 0, fd_head->reassembled_in);
1677                 }
1678         }
1679         return next_tvb;
1680 }
1681
1682 /*
1683  * Show a single fragment in a fragment subtree.
1684  */
1685 static void
1686 show_fragment(fragment_data *fd, int offset, const fragment_items *fit,
1687     proto_tree *ft, tvbuff_t *tvb)
1688 {
1689         proto_item *fei=NULL;
1690         int hf;
1691
1692         if (fd->flags & (FD_OVERLAPCONFLICT
1693                 |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
1694                 hf = *(fit->hf_fragment_error);
1695         } else {
1696                 hf = *(fit->hf_fragment);
1697         }
1698         if (fd->len == 0) {
1699                 fei = proto_tree_add_uint_format(ft, hf,
1700                         tvb, offset, fd->len,
1701                         fd->frame,
1702                         "Frame: %u (no data)",
1703                         fd->frame);
1704         } else {
1705                 fei = proto_tree_add_uint_format(ft, hf,
1706                         tvb, offset, fd->len,
1707                         fd->frame,
1708                         "Frame: %u, payload: %u-%u (%u bytes)",
1709                         fd->frame,
1710                         offset,
1711                         offset+fd->len-1,
1712                         fd->len);
1713         }
1714         PROTO_ITEM_SET_GENERATED(fei);
1715         if (fd->flags & (FD_OVERLAP|FD_OVERLAPCONFLICT
1716                 |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
1717                 /* this fragment has some flags set, create a subtree
1718                  * for it and display the flags.
1719                  */
1720                 proto_tree *fet=NULL;
1721
1722                 fet = proto_item_add_subtree(fei, *(fit->ett_fragment));
1723                 if (fd->flags&FD_OVERLAP) {
1724                         fei=proto_tree_add_boolean(fet,
1725                                 *(fit->hf_fragment_overlap),
1726                                 tvb, 0, 0,
1727                                 TRUE);
1728                         PROTO_ITEM_SET_GENERATED(fei);
1729                 }
1730                 if (fd->flags&FD_OVERLAPCONFLICT) {
1731                         fei=proto_tree_add_boolean(fet,
1732                                 *(fit->hf_fragment_overlap_conflict),
1733                                 tvb, 0, 0,
1734                                 TRUE);
1735                         PROTO_ITEM_SET_GENERATED(fei);
1736                 }
1737                 if (fd->flags&FD_MULTIPLETAILS) {
1738                         fei=proto_tree_add_boolean(fet,
1739                                 *(fit->hf_fragment_multiple_tails),
1740                                 tvb, 0, 0,
1741                                 TRUE);
1742                         PROTO_ITEM_SET_GENERATED(fei);
1743                 }
1744                 if (fd->flags&FD_TOOLONGFRAGMENT) {
1745                         fei=proto_tree_add_boolean(fet,
1746                                 *(fit->hf_fragment_too_long_fragment),
1747                                 tvb, 0, 0,
1748                                 TRUE);
1749                         PROTO_ITEM_SET_GENERATED(fei);
1750                 }
1751         }
1752 }
1753
1754 static gboolean
1755 show_fragment_errs_in_col(fragment_data *fd_head, const fragment_items *fit,
1756     packet_info *pinfo)
1757 {
1758         if (fd_head->flags & (FD_OVERLAPCONFLICT
1759                 |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
1760                 if (check_col(pinfo->cinfo, COL_INFO)) {
1761                         col_add_fstr(pinfo->cinfo, COL_INFO,
1762                                 "[Illegal %s]", fit->tag);
1763                         return TRUE;
1764                 }
1765         }
1766
1767         return FALSE;
1768 }
1769
1770 /* This function will build the fragment subtree; it's for fragments
1771    reassembled with "fragment_add()".
1772
1773    It will return TRUE if there were fragmentation errors
1774    or FALSE if fragmentation was ok.
1775 */
1776 gboolean
1777 show_fragment_tree(fragment_data *fd_head, const fragment_items *fit,
1778     proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb)
1779 {
1780         fragment_data *fd;
1781         proto_tree *ft;
1782         proto_item *fi;
1783
1784         /* It's not fragmented. */
1785         pinfo->fragmented = FALSE;
1786
1787         fi = proto_tree_add_item(tree, *(fit->hf_fragments),
1788             tvb, 0, -1, FALSE);
1789         PROTO_ITEM_SET_GENERATED(fi);
1790
1791         ft = proto_item_add_subtree(fi, *(fit->ett_fragments));
1792         for (fd = fd_head->next; fd != NULL; fd = fd->next)
1793                 show_fragment(fd, fd->offset, fit, ft, tvb);
1794
1795         return show_fragment_errs_in_col(fd_head, fit, pinfo);
1796 }
1797
1798 /* This function will build the fragment subtree; it's for fragments
1799    reassembled with "fragment_add_seq()" or "fragment_add_seq_check()".
1800
1801    It will return TRUE if there were fragmentation errors
1802    or FALSE if fragmentation was ok.
1803 */
1804 gboolean
1805 show_fragment_seq_tree(fragment_data *fd_head, const fragment_items *fit,
1806     proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb)
1807 {
1808         guint32 offset, next_offset;
1809         fragment_data *fd, *last_fd;
1810         proto_tree *ft;
1811         proto_item *fi;
1812
1813         /* It's not fragmented. */
1814         pinfo->fragmented = FALSE;
1815
1816         fi = proto_tree_add_item(tree, *(fit->hf_fragments),
1817             tvb, 0, -1, FALSE);
1818         PROTO_ITEM_SET_GENERATED(fi);
1819         ft = proto_item_add_subtree(fi, *(fit->ett_fragments));
1820         offset = 0;
1821         next_offset = 0;
1822         last_fd = NULL;
1823         for (fd = fd_head->next; fd != NULL; fd = fd->next){
1824                 if (last_fd == NULL || last_fd->offset != fd->offset) {
1825                         offset = next_offset;
1826                         next_offset += fd->len;
1827                 }
1828                 last_fd = fd;
1829                 show_fragment(fd, offset, fit, ft, tvb);
1830         }
1831
1832         return show_fragment_errs_in_col(fd_head, fit, pinfo);
1833 }