Rework some comments.
[obnox/wireshark/wip.git] / epan / reassemble.c
1 /* reassemble.c
2  * Routines for {fragment,segment} reassembly
3  *
4  * $Id$
5  *
6  * Wireshark - Network traffic analyzer
7  * By Gerald Combs <gerald@wireshark.org>
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 <epan/reassemble.h>
34
35 #include <epan/emem.h>
36
37 #include <epan/dissectors/packet-dcerpc.h>
38
39 typedef struct _fragment_key {
40         address src;
41         address dst;
42         guint32 id;
43 } fragment_key;
44
45 typedef struct _dcerpc_fragment_key {
46         address src;
47         address dst;
48         guint32 id;
49         e_uuid_t act_id;
50 } dcerpc_fragment_key;
51
52 #if GLIB_CHECK_VERSION(2,10,0)
53 #else
54 static GMemChunk *fragment_key_chunk = NULL;
55 static GMemChunk *fragment_data_chunk = NULL;
56 static GMemChunk *dcerpc_fragment_key_chunk = NULL;
57 static int fragment_init_count = 200;
58 #endif
59
60 static void LINK_FRAG(fragment_data *fd_head,fragment_data *fd)
61 {
62         fragment_data *fd_i;
63
64         /* add fragment to list, keep list sorted */
65         for(fd_i= fd_head; fd_i->next;fd_i=fd_i->next) {
66                 if (fd->offset < fd_i->next->offset )
67                         break;
68         }
69         fd->next=fd_i->next;
70         fd_i->next=fd;
71 }
72
73 /* copy a fragment key to heap store to insert in the hash */
74 static void *fragment_key_copy(const void *k)
75 {
76         const fragment_key* key = (const fragment_key*) k;
77 #if GLIB_CHECK_VERSION(2,10,0)
78         fragment_key *new_key = g_slice_new(fragment_key);
79 #else
80         fragment_key *new_key = g_mem_chunk_alloc(fragment_key_chunk);
81 #endif
82
83         COPY_ADDRESS(&new_key->src, &key->src);
84         COPY_ADDRESS(&new_key->dst, &key->dst);
85         new_key->id = key->id;
86         return new_key;
87 }
88
89 /* copy a dcerpc fragment key to heap store to insert in the hash */
90 static void *dcerpc_fragment_key_copy(const void *k)
91 {
92         const dcerpc_fragment_key* key = (const dcerpc_fragment_key*) k;
93
94 #if GLIB_CHECK_VERSION(2,10,0)
95         dcerpc_fragment_key *new_key = g_slice_new(dcerpc_fragment_key);
96 #else
97         dcerpc_fragment_key *new_key = g_mem_chunk_alloc(dcerpc_fragment_key_chunk);
98 #endif
99
100         COPY_ADDRESS(&new_key->src, &key->src);
101         COPY_ADDRESS(&new_key->dst, &key->dst);
102         new_key->id = key->id;
103         new_key->act_id = key->act_id;
104
105         return new_key;
106 }
107
108
109 static gint
110 fragment_equal(gconstpointer k1, gconstpointer k2)
111 {
112         const fragment_key* key1 = (const fragment_key*) k1;
113         const fragment_key* key2 = (const 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                  ) ?
123                  TRUE : FALSE);
124 }
125
126 static guint
127 fragment_hash(gconstpointer k)
128 {
129         const fragment_key* key = (const fragment_key*) k;
130         guint hash_val;
131 /*
132         int i;
133 */
134
135         hash_val = 0;
136
137 /*      More than likely: in most captures src and dst addresses are the
138         same, and would hash the same.
139         We only use id as the hash as an optimization.
140
141         for (i = 0; i < key->src.len; i++)
142                 hash_val += key->src.data[i];
143         for (i = 0; i < key->dst.len; i++)
144                 hash_val += key->dst.data[i];
145 */
146
147         hash_val += key->id;
148
149         return hash_val;
150 }
151
152 static gint
153 dcerpc_fragment_equal(gconstpointer k1, gconstpointer k2)
154 {
155         const dcerpc_fragment_key* key1 = (const dcerpc_fragment_key*) k1;
156         const dcerpc_fragment_key* key2 = (const dcerpc_fragment_key*) k2;
157
158         /*key.id is the first item to compare since item is most
159           likely to differ between sessions, thus shortcircuiting
160           the comparison of addresses.
161         */
162         return (((key1->id == key2->id)
163                   && (ADDRESSES_EQUAL(&key1->src, &key2->src))
164                   && (ADDRESSES_EQUAL(&key1->dst, &key2->dst))
165                   && (memcmp (&key1->act_id, &key2->act_id, sizeof (e_uuid_t)) == 0))
166                  ? TRUE : FALSE);
167 }
168
169 static guint
170 dcerpc_fragment_hash(gconstpointer k)
171 {
172         const dcerpc_fragment_key* key = (const dcerpc_fragment_key*) k;
173         guint hash_val;
174
175         hash_val = 0;
176
177         hash_val += key->id;
178         hash_val += key->act_id.Data1;
179         hash_val += key->act_id.Data2 << 16;
180         hash_val += key->act_id.Data3;
181
182         return hash_val;
183 }
184
185 typedef struct _reassembled_key {
186         guint32 id;
187         guint32 frame;
188 } reassembled_key;
189
190 static gint
191 reassembled_equal(gconstpointer k1, gconstpointer k2)
192 {
193         const reassembled_key* key1 = (const reassembled_key*) k1;
194         const reassembled_key* key2 = (const reassembled_key*) k2;
195
196         /*
197          * We assume that the frame numbers are unlikely to be equal,
198          * so we check them first.
199          */
200         return key1->frame == key2->frame && key1->id == key2->id;
201 }
202
203 static guint
204 reassembled_hash(gconstpointer k)
205 {
206         const reassembled_key* key = (const reassembled_key*) k;
207
208         return key->frame;
209 }
210
211 /*
212  * For a fragment hash table entry, free the associated fragments.
213  * If slices are used (GLIB >= 2.10) the entry value (fd_chain) is
214  * freed herein and the entry is freed when fragment_free_key()
215  * [or dcerpc_fragment_free_key()] is called (as a consequence of
216  * returning TRUE from this function).
217  * If mem_chunks are used, free the address data to which the key
218  * refers; the the actual key and value structures get freed
219  * by "reassemble_cleanup()").
220  */
221 static gboolean
222 free_all_fragments(gpointer key_arg _U_, gpointer value, gpointer user_data _U_)
223 {
224         fragment_data *fd_head, *tmp_fd;
225
226 #if GLIB_CHECK_VERSION(2,10,0)
227         /* If Glib version => 2.10 we do g_hash_table_new_full() and supply a function
228          * to free the key and the addresses.
229          */
230 #else
231         fragment_key *key = key_arg;
232         /*
233          * Grr.  I guess the theory here is that freeing
234          * something sure as heck modifies it, so you
235          * want to ban attempts to free it, but, alas,
236          * if we make the "data" field of an "address"
237          * structure not a "const", the compiler whines if
238          * we try to make it point into the data for a packet,
239          * as that's a "const" array (and should be, as dissectors
240          * shouldn't trash it).
241          *
242          * So we cast the complaint into oblivion, and rely on
243          * the fact that these addresses are known to have had
244          * their data mallocated, i.e. they don't point into,
245          * say, the middle of the data for a packet.
246          */
247         g_free((gpointer)key->src.data);
248         g_free((gpointer)key->dst.data);
249 #endif
250         for (fd_head = value; fd_head != NULL; fd_head = tmp_fd) {
251                 tmp_fd=fd_head->next;
252
253                 if(fd_head->data && !(fd_head->flags&FD_NOT_MALLOCED))
254                         g_free(fd_head->data);
255 #if GLIB_CHECK_VERSION(2,10,0)
256                 g_slice_free(fragment_data, fd_head);
257 #endif
258         }
259
260         return TRUE;
261 }
262
263 /* ------------------------- */
264 static fragment_data *new_head(const guint32 flags)
265 {
266         fragment_data *fd_head;
267         /* If head/first structure in list only holds no other data than
268         * 'datalen' then we don't have to change the head of the list
269         * even if we want to keep it sorted
270         */
271 #if GLIB_CHECK_VERSION(2,10,0)
272         fd_head=g_slice_new0(fragment_data);
273 #else
274         fd_head=g_mem_chunk_alloc0(fragment_data_chunk);
275 #endif
276
277         fd_head->flags=flags;
278         return fd_head;
279 }
280
281 /*
282  * For a reassembled-packet hash table entry, free the fragment data
283  * to which the value refers.
284  * (The actual value structures get freed by "reassemble_cleanup()".)
285  */
286 static gboolean
287 free_all_reassembled_fragments(gpointer key_arg _U_, gpointer value,
288                                    gpointer user_data _U_)
289 {
290         fragment_data *fd_head;
291
292         for (fd_head = value; fd_head != NULL; fd_head = fd_head->next) {
293                 if(fd_head->data && !(fd_head->flags&FD_NOT_MALLOCED)) {
294                         g_free(fd_head->data);
295
296                         /*
297                          * A reassembled packet is inserted into the
298                          * hash table once for every frame that made
299                          * up the reassembled packet; clear the data
300                          * pointer so that we only free the data the
301                          * first time we see it.
302                          */
303                         fd_head->data = NULL;
304                 }
305         }
306
307         return TRUE;
308 }
309
310 #if GLIB_CHECK_VERSION(2,10,0)
311 static void
312 fragment_free_key(void *ptr)
313 {
314         fragment_key *key = (fragment_key *)ptr;
315
316         if(key){
317                 /*
318                  * Free up the copies of the addresses from the old key.
319                  */
320                 g_free((gpointer)key->src.data);
321                 g_free((gpointer)key->dst.data);
322
323                 g_slice_free(fragment_key, key);
324         }
325 }
326
327 static void
328 dcerpc_fragment_free_key(void *ptr)
329 {
330         dcerpc_fragment_key *key = (dcerpc_fragment_key *)ptr;
331
332         if(key){
333                 /*
334                  * Free up the copies of the addresses from the old key.
335                  */
336                 g_free((gpointer)key->src.data);
337                 g_free((gpointer)key->dst.data);
338
339                 g_slice_free(dcerpc_fragment_key, key);
340         }
341 }
342 #endif
343 /*
344  * Initialize a fragment table.
345  */
346 void
347 fragment_table_init(GHashTable **fragment_table)
348 {
349         if (*fragment_table != NULL) {
350                 /*
351                  * The fragment hash table exists.
352                  *
353                  * Remove all entries and free fragment data for each entry.
354                  *
355                  * If slices are used (GLIB >= 2.10)
356                  * the keys are freed by calling fragment_free_key()
357                  * and the values are freed in free_all_fragments().
358                  *
359                  * If mem_chunks are used, the key and value data
360                  * are freed by "reassemble_cleanup()". free_all_fragments()
361                  * will free the adrress data associated with the key
362                  */
363                 g_hash_table_foreach_remove(*fragment_table,
364                                 free_all_fragments, NULL);
365         } else {
366 #if GLIB_CHECK_VERSION(2,10,0)
367                 /* The fragment table does not exist. Create it */
368                 *fragment_table = g_hash_table_new_full(fragment_hash,
369                                                         fragment_equal, fragment_free_key, NULL);
370 #else
371                 /* The fragment table does not exist. Create it */
372                 *fragment_table = g_hash_table_new(fragment_hash,
373                                 fragment_equal);
374 #endif
375         }
376 }
377
378 void
379 dcerpc_fragment_table_init(GHashTable **fragment_table)
380 {
381         if (*fragment_table != NULL) {
382                 /*
383                  * The fragment hash table exists.
384                  *
385                  * Remove all entries and free fragment data for each entry.
386                  *
387                  * If slices are used (GLIB >= 2.10)
388                  * the keys are freed by calling dcerpc_fragment_free_key()
389                  * and the values are freed in free_all_fragments().
390                  *
391                  * If mem_chunks are used, the key and value data
392                  * are freed by "reassemble_cleanup()". free_all_fragments()
393                  * will free the adrress data associated with the key
394                  */
395                    g_hash_table_foreach_remove(*fragment_table,
396                                                    free_all_fragments, NULL);
397         } else {
398 #if GLIB_CHECK_VERSION(2,10,0)
399                    /* The fragment table does not exist. Create it */
400                 *fragment_table = g_hash_table_new_full(dcerpc_fragment_hash,
401                                                         dcerpc_fragment_equal, dcerpc_fragment_free_key, NULL);
402 #else
403                 /* The fragment table does not exist. Create it */
404                    *fragment_table = g_hash_table_new(dcerpc_fragment_hash,
405                                                    dcerpc_fragment_equal);
406 #endif
407         }
408 }
409
410 /*
411  * Initialize a reassembled-packet table.
412  */
413 void
414 reassembled_table_init(GHashTable **reassembled_table)
415 {
416         if (*reassembled_table != NULL) {
417                 /*
418                  * The reassembled-packet hash table exists.
419                  *
420                  * Remove all entries and free reassembled packet
421                  * data for each entry.  (The key data is freed
422                  * by "reassemble_cleanup()".)
423                  */
424                 g_hash_table_foreach_remove(*reassembled_table,
425                                 free_all_reassembled_fragments, NULL);
426         } else {
427                 /* The fragment table does not exist. Create it */
428                 *reassembled_table = g_hash_table_new(reassembled_hash,
429                                 reassembled_equal);
430         }
431 }
432
433 /*
434  * Free up all space allocated for fragment keys and data and
435  * reassembled keys.
436  */
437 void
438 reassemble_cleanup(void)
439 {
440 #if GLIB_CHECK_VERSION(2,10,0)
441 #else
442         if (fragment_key_chunk != NULL)
443                 g_mem_chunk_destroy(fragment_key_chunk);
444         if (dcerpc_fragment_key_chunk != NULL)
445                 g_mem_chunk_destroy(dcerpc_fragment_key_chunk);
446         if (fragment_data_chunk != NULL)
447                 g_mem_chunk_destroy(fragment_data_chunk);
448
449         fragment_key_chunk = NULL;
450         dcerpc_fragment_key_chunk = NULL;
451         fragment_data_chunk = NULL;
452 #endif
453 }
454
455 void
456 reassemble_init(void)
457 {
458 #if GLIB_CHECK_VERSION(2,10,0)
459 #else
460         fragment_key_chunk = g_mem_chunk_new("fragment_key_chunk",
461                 sizeof(fragment_key),
462                 fragment_init_count * sizeof(fragment_key),
463                 G_ALLOC_AND_FREE);
464         dcerpc_fragment_key_chunk = g_mem_chunk_new("dcerpc_fragment_key_chunk",
465                 sizeof(dcerpc_fragment_key),
466                 fragment_init_count * sizeof(dcerpc_fragment_key),
467                 G_ALLOC_AND_FREE);
468         fragment_data_chunk = g_mem_chunk_new("fragment_data_chunk",
469                 sizeof(fragment_data),
470                 fragment_init_count * sizeof(fragment_data),
471                 G_ALLOC_ONLY);
472 #endif
473 }
474
475 /* This function cleans up the stored state and removes the reassembly data and
476  * (with one exception) all allocated memory for matching reassembly.
477  *
478  * The exception is :
479  * If the PDU was already completely reassembled, then the buffer containing the
480  * reassembled data WILL NOT be free()d, and the pointer to that buffer will be
481  * returned.
482  * Othervise the function will return NULL.
483  *
484  * So, if you call fragment_delete and it returns non-NULL, YOU are responsible to
485  * g_free() that buffer.
486  */
487 unsigned char *
488 fragment_delete(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table)
489 {
490         fragment_data *fd_head, *fd;
491         fragment_key key;
492         unsigned char *data=NULL;
493
494         /* create key to search hash with */
495         key.src = pinfo->src;
496         key.dst = pinfo->dst;
497         key.id  = id;
498
499         fd_head = g_hash_table_lookup(fragment_table, &key);
500
501         if(fd_head==NULL){
502                 /* We do not recognize this as a PDU we have seen before. return */
503                 return NULL;
504         }
505
506         data=fd_head->data;
507         /* loop over all partial fragments and free any buffers */
508         for(fd=fd_head->next;fd;){
509                 fragment_data *tmp_fd;
510                 tmp_fd=fd->next;
511
512                 if( !(fd->flags&FD_NOT_MALLOCED) )
513                         g_free(fd->data);
514 #if GLIB_CHECK_VERSION(2,10,0)
515                 g_slice_free(fragment_data, fd);
516 #else
517                 g_mem_chunk_free(fragment_data_chunk, fd);
518 #endif
519                 fd=tmp_fd;
520         }
521 #if GLIB_CHECK_VERSION(2,10,0)
522         g_slice_free(fragment_data, fd_head);
523 #else
524         g_mem_chunk_free(fragment_data_chunk, fd_head);
525 #endif
526         g_hash_table_remove(fragment_table, &key);
527
528         return data;
529 }
530
531 /* This function is used to check if there is partial or completed reassembly state
532  * matching this packet. I.e. Is there reassembly going on or not for this packet?
533  */
534 fragment_data *
535 fragment_get(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table)
536 {
537         fragment_data *fd_head;
538         fragment_key key;
539
540         /* create key to search hash with */
541         key.src = pinfo->src;
542         key.dst = pinfo->dst;
543         key.id  = id;
544
545         fd_head = g_hash_table_lookup(fragment_table, &key);
546
547         return fd_head;
548 }
549
550 /* id *must* be the frame number for this to work! */
551 fragment_data *
552 fragment_get_reassembled(const guint32 id, GHashTable *reassembled_table)
553 {
554         fragment_data *fd_head;
555         reassembled_key key;
556
557         /* create key to search hash with */
558         key.frame = id;
559         key.id = id;
560         fd_head = g_hash_table_lookup(reassembled_table, &key);
561
562         return fd_head;
563 }
564
565 fragment_data *
566 fragment_get_reassembled_id(const packet_info *pinfo, const guint32 id, GHashTable *reassembled_table)
567 {
568         fragment_data *fd_head;
569         reassembled_key key;
570
571         /* create key to search hash with */
572         key.frame = pinfo->fd->num;
573         key.id = id;
574         fd_head = g_hash_table_lookup(reassembled_table, &key);
575
576         return fd_head;
577 }
578
579 /* This function can be used to explicitly set the total length (if known)
580  * for reassembly of a PDU.
581  * This is useful for reassembly of PDUs where one may have the total length specified
582  * in the first fragment instead of as for, say, IPv4 where a flag indicates which
583  * is the last fragment.
584  *
585  * Such protocols might fragment_add with a more_frags==TRUE for every fragment
586  * and just tell the reassembly engine the expected total length of the reassembled data
587  * using fragment_set_tot_len immediately after doing fragment_add for the first packet.
588  *
589  * Note that for FD_BLOCKSEQUENCE tot_len is the index for the tail fragment.
590  * i.e. since the block numbers start at 0, if we specify tot_len==2, that
591  * actually means we want to defragment 3 blocks, block 0, 1 and 2.
592  */
593 void
594 fragment_set_tot_len(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table,
595                          const guint32 tot_len)
596 {
597         fragment_data *fd_head;
598         fragment_key key;
599
600         /* create key to search hash with */
601         key.src = pinfo->src;
602         key.dst = pinfo->dst;
603         key.id  = id;
604
605         fd_head = g_hash_table_lookup(fragment_table, &key);
606
607         if(fd_head){
608                 fd_head->datalen = tot_len;
609                 fd_head->flags |= FD_DATALEN_SET;
610         }
611
612         return;
613 }
614
615 guint32
616 fragment_get_tot_len(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table)
617 {
618         fragment_data *fd_head;
619         fragment_key key;
620
621         /* create key to search hash with */
622         key.src = pinfo->src;
623         key.dst = pinfo->dst;
624         key.id  = id;
625
626         fd_head = g_hash_table_lookup(fragment_table, &key);
627
628         if(fd_head){
629                 return fd_head->datalen;
630         }
631
632         return 0;
633 }
634
635
636 /* This function will set the partial reassembly flag for a fh.
637    When this function is called, the fh MUST already exist, i.e.
638    the fh MUST be created by the initial call to fragment_add() before
639    this function is called.
640    Also note that this function MUST be called to indicate a fh will be
641    extended (increase the already stored data)
642 */
643
644 void
645 fragment_set_partial_reassembly(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table)
646 {
647         fragment_data *fd_head;
648         fragment_key key;
649
650         /* create key to search hash with */
651         key.src = pinfo->src;
652         key.dst = pinfo->dst;
653         key.id  = id;
654
655         fd_head = g_hash_table_lookup(fragment_table, &key);
656
657         /*
658          * XXX - why not do all the stuff done early in "fragment_add_work()",
659          * turning off FD_DEFRAGMENTED and pointing the fragments' data
660          * pointers to the appropriate part of the already-reassembled
661          * data, and clearing the data length and "reassembled in" frame
662          * number, here?  We currently have a hack in the TCP dissector
663          * not to set the "reassembled in" value if the "partial reassembly"
664          * flag is set, so that in the first pass through the packets
665          * we don't falsely set a packet as reassembled in that packet
666          * if the dissector decided that even more reassembly was needed.
667          */
668         if(fd_head){
669                 fd_head->flags |= FD_PARTIAL_REASSEMBLY;
670         }
671 }
672
673 /*
674  * This function gets rid of an entry from a fragment table, given
675  * a pointer to the key for that entry; it also frees up the key
676  * and the addresses in it.
677  * Note: If we use slices keys are freed by fragment_free_key()
678          [or dcerpc_fragment_free_key()] being called
679  *       during g_hash_table_remove().
680  */
681 static void
682 fragment_unhash(GHashTable *fragment_table, fragment_key *key)
683 {
684         /*
685          * Remove the entry from the fragment table.
686          */
687         g_hash_table_remove(fragment_table, key);
688
689         /*
690          * Free the key itself.
691          */
692 #if GLIB_CHECK_VERSION(2,10,0)
693 #else
694         /*
695          * Free up the copies of the addresses from the old key.
696          */
697         g_free((gpointer)key->src.data);
698         g_free((gpointer)key->dst.data);
699
700         g_mem_chunk_free(fragment_key_chunk, key);
701 #endif
702 }
703
704 /*
705  * This function adds fragment_data structure to a reassembled-packet
706  * hash table, using the frame numbers of each of the frames from
707  * which it was reassembled as keys, and sets the "reassembled_in"
708  * frame number.
709  */
710 static void
711 fragment_reassembled(fragment_data *fd_head, const packet_info *pinfo,
712                  GHashTable *reassembled_table, const guint32 id)
713 {
714         reassembled_key *new_key;
715         fragment_data *fd;
716
717         if (fd_head->next == NULL) {
718                 /*
719                  * This was not fragmented, so there's no fragment
720                  * table; just hash it using the current frame number.
721                  */
722                 new_key = se_alloc(sizeof(reassembled_key));
723                 new_key->frame = pinfo->fd->num;
724                 new_key->id = id;
725                 g_hash_table_insert(reassembled_table, new_key, fd_head);
726         } else {
727                 /*
728                  * Hash it with the frame numbers for all the frames.
729                  */
730                 for (fd = fd_head->next; fd != NULL; fd = fd->next){
731                         new_key = se_alloc(sizeof(reassembled_key));
732                         new_key->frame = fd->frame;
733                         new_key->id = id;
734                         g_hash_table_insert(reassembled_table, new_key,
735                                 fd_head);
736                 }
737         }
738         fd_head->flags |= FD_DEFRAGMENTED;
739         fd_head->reassembled_in = pinfo->fd->num;
740 }
741
742 /*
743  * This function adds a new fragment to the fragment hash table.
744  * If this is the first fragment seen for this datagram, a new entry
745  * is created in the hash table, otherwise this fragment is just added
746  * to the linked list of fragments for this packet.
747  * The list of fragments for a specific datagram is kept sorted for
748  * easier handling.
749  *
750  * Returns a pointer to the head of the fragment data list if we have all the
751  * fragments, NULL otherwise.
752  *
753  * This function assumes frag_offset being a byte offset into the defragment
754  * packet.
755  *
756  * 01-2002
757  * Once the fh is defragmented (= FD_DEFRAGMENTED set), it can be
758  * extended using the FD_PARTIAL_REASSEMBLY flag. This flag should be set
759  * using fragment_set_partial_reassembly() before calling fragment_add
760  * with the new fragment. FD_TOOLONGFRAGMENT and FD_MULTIPLETAILS flags
761  * are lowered when a new extension process is started.
762  */
763 static gboolean
764 fragment_add_work(fragment_data *fd_head, tvbuff_t *tvb, const int offset,
765                  const packet_info *pinfo, const guint32 frag_offset,
766                  const guint32 frag_data_len, const gboolean more_frags)
767 {
768         fragment_data *fd;
769         fragment_data *fd_i;
770         guint32 max, dfpos;
771         unsigned char *old_data;
772
773         /* create new fd describing this fragment */
774 #if GLIB_CHECK_VERSION(2,10,0)
775         fd = g_slice_new(fragment_data);
776 #else
777         fd = g_mem_chunk_alloc(fragment_data_chunk);
778 #endif
779         fd->next = NULL;
780         fd->flags = 0;
781         fd->frame = pinfo->fd->num;
782         if (fd->frame > fd_head->frame)
783                 fd_head->frame = fd->frame;
784         fd->offset = frag_offset;
785         fd->len  = frag_data_len;
786         fd->data = NULL;
787
788         /*
789          * If it was already defragmented and this new fragment goes beyond
790          * data limits, set flag in already empty fds & point old fds to malloc'ed data.
791          */
792         if(fd_head->flags & FD_DEFRAGMENTED && (frag_offset+frag_data_len) >= fd_head->datalen &&
793                 fd_head->flags & FD_PARTIAL_REASSEMBLY){
794                 for(fd_i=fd_head->next; fd_i; fd_i=fd_i->next){
795                         if( !fd_i->data ) {
796                                 fd_i->data = fd_head->data + fd_i->offset;
797                                 fd_i->flags |= FD_NOT_MALLOCED;
798                         }
799                         fd_i->flags &= (~FD_TOOLONGFRAGMENT) & (~FD_MULTIPLETAILS);
800                 }
801                 fd_head->flags &= ~(FD_DEFRAGMENTED|FD_PARTIAL_REASSEMBLY|FD_DATALEN_SET);
802                 fd_head->flags &= (~FD_TOOLONGFRAGMENT) & (~FD_MULTIPLETAILS);
803                 fd_head->datalen=0;
804                 fd_head->reassembled_in=0;
805         }
806
807         if (!more_frags) {
808                 /*
809                  * This is the tail fragment in the sequence.
810                  */
811                 if (fd_head->flags & FD_DATALEN_SET) {
812                         /* ok we have already seen other tails for this packet
813                          * it might be a duplicate.
814                          */
815                         if (fd_head->datalen != (fd->offset + fd->len) ){
816                                 /* Oops, this tail indicates a different packet
817                                  * len than the previous ones. Something's wrong.
818                                  */
819                                 fd->flags          |= FD_MULTIPLETAILS;
820                                 fd_head->flags |= FD_MULTIPLETAILS;
821                         }
822                 } else {
823                         /* this was the first tail fragment, now we know the
824                          * length of the packet
825                          */
826                         fd_head->datalen = fd->offset + fd->len;
827                         fd_head->flags |= FD_DATALEN_SET;
828                 }
829         }
830
831
832
833
834         /* If the packet is already defragmented, this MUST be an overlap.
835          * The entire defragmented packet is in fd_head->data.
836          * Even if we have previously defragmented this packet, we still
837          * check it. Someone might play overlap and TTL games.
838          */
839         if (fd_head->flags & FD_DEFRAGMENTED) {
840                 guint32 end_offset = fd->offset + fd->len;
841                 fd->flags          |= FD_OVERLAP;
842                 fd_head->flags |= FD_OVERLAP;
843                 /* make sure it's not too long */
844                 if (end_offset > fd_head->datalen || end_offset < fd->offset || end_offset < fd->len) {
845                         fd->flags          |= FD_TOOLONGFRAGMENT;
846                         fd_head->flags |= FD_TOOLONGFRAGMENT;
847                 }
848                 /* make sure it doesn't conflict with previous data */
849                 else if ( memcmp(fd_head->data+fd->offset,
850                         tvb_get_ptr(tvb,offset,fd->len),fd->len) ){
851                         fd->flags          |= FD_OVERLAPCONFLICT;
852                         fd_head->flags |= FD_OVERLAPCONFLICT;
853                 }
854                 /* it was just an overlap, link it and return */
855                 LINK_FRAG(fd_head,fd);
856                 return TRUE;
857         }
858
859
860
861         /* If we have reached this point, the packet is not defragmented yet.
862                  * Save all payload in a buffer until we can defragment.
863          * XXX - what if we didn't capture the entire fragment due
864          * to a too-short snapshot length?
865          */
866         fd->data = g_malloc(fd->len);
867         tvb_memcpy(tvb, fd->data, offset, fd->len);
868         LINK_FRAG(fd_head,fd);
869
870
871         if( !(fd_head->flags & FD_DATALEN_SET) ){
872                 /* if we dont know the datalen, there are still missing
873                  * packets. Cheaper than the check below.
874                  */
875                 return FALSE;
876         }
877
878
879         /*
880          * Check if we have received the entire fragment.
881          * This is easy since the list is sorted and the head is faked.
882          *
883          * First, we compute the amount of contiguous data that's
884          * available.  (The check for fd_i->offset <= max rules out
885          * fragments that don't start before or at the end of the
886          * previous fragment, i.e. fragments that have a gap between
887          * them and the previous fragment.)
888          */
889         max = 0;
890         for (fd_i=fd_head->next;fd_i;fd_i=fd_i->next) {
891                 if ( ((fd_i->offset)<=max) &&
892                         ((fd_i->offset+fd_i->len)>max) ){
893                         max = fd_i->offset+fd_i->len;
894                 }
895         }
896
897         if (max < (fd_head->datalen)) {
898                 /*
899                  * The amount of contiguous data we have is less than the
900                  * amount of data we're trying to reassemble, so we haven't
901                  * received all packets yet.
902                  */
903                 return FALSE;
904         }
905
906
907         if (max > (fd_head->datalen)) {
908                 /*XXX not sure if current fd was the TOOLONG*/
909                 /*XXX is it fair to flag current fd*/
910                 /* oops, too long fragment detected */
911                 fd->flags          |= FD_TOOLONGFRAGMENT;
912                 fd_head->flags |= FD_TOOLONGFRAGMENT;
913         }
914
915         /* we have received an entire packet, defragment it and
916                  * free all fragments
917                  */
918         /* store old data just in case */
919         old_data=fd_head->data;
920         fd_head->data = g_malloc(max);
921
922         /* add all data fragments */
923         for (dfpos=0,fd_i=fd_head;fd_i;fd_i=fd_i->next) {
924                 if (fd_i->len) {
925                         /* dfpos is always >= than fd_i->offset */
926                         /* No gaps can exist here, max_loop(above) does this */
927                         /* XXX - true? Can we get fd_i->offset+fd-i->len */
928                         /* overflowing, for example? */
929                         /*      Actually: there is at least one pathological case wherein there can be fragments
930                                 on the list which are for offsets greater than max (i.e.: following a gap after max).
931                                 (Apparently a "DESEGMENT_UNTIL_FIN" was involved wherein the FIN packet had an offset
932                                 less than the highest fragment offset seen. [Seen from a fuzz-test: bug #2470]).
933                                                         Note that the "overlap" compare must only be done for fragments with (offset+len) <= max
934                                 and thus within the newly g_malloc'd buffer.
935                         */
936
937                         if ( fd_i->offset+fd_i->len > dfpos ) {
938                                 if (fd_i->offset+fd_i->len > max)
939                                         g_warning("Reassemble error in frame %u: offset %u + len %u > max %u",
940                                                 pinfo->fd->num, fd_i->offset,
941                                                 fd_i->len, max);
942                                 else if (dfpos < fd_i->offset)
943                                         g_warning("Reassemble error in frame %u: dfpos %u < offset %u",
944                                                 pinfo->fd->num, dfpos, fd_i->offset);
945                                 else if (dfpos-fd_i->offset > fd_i->len)
946                                         g_warning("Reassemble error in frame %u: dfpos %u - offset %u > len %u",
947                                                 pinfo->fd->num, dfpos, fd_i->offset,
948                                                 fd_i->len);
949                                 else {
950                                         if (fd_i->offset < dfpos) {
951                                                 fd_i->flags    |= FD_OVERLAP;
952                                                 fd_head->flags |= FD_OVERLAP;
953                                                 if ( memcmp(fd_head->data+fd_i->offset,
954                                                                 fd_i->data,
955                                                                 MIN(fd_i->len,(dfpos-fd_i->offset))
956                                                                  ) ) {
957                                                         fd_i->flags    |= FD_OVERLAPCONFLICT;
958                                                         fd_head->flags |= FD_OVERLAPCONFLICT;
959                                                 }
960                                         }
961                                         memcpy(fd_head->data+dfpos,
962                                                 fd_i->data+(dfpos-fd_i->offset),
963                                                 fd_i->len-(dfpos-fd_i->offset));
964                                 }
965                         } else {
966                                 if (fd_i->offset+fd_i->len < fd_i->offset)
967                                         g_warning("Reassemble error in frame %u: offset %u + len %u < offset",
968                                                 pinfo->fd->num, fd_i->offset,
969                                                 fd_i->len);
970                         }
971                         if( fd_i->flags & FD_NOT_MALLOCED )
972                                 fd_i->flags &= ~FD_NOT_MALLOCED;
973                         else
974                                 g_free(fd_i->data);
975                         fd_i->data=NULL;
976
977                         dfpos=MAX(dfpos,(fd_i->offset+fd_i->len));
978                 }
979         }
980
981         g_free(old_data);
982         /* mark this packet as defragmented.
983                    allows us to skip any trailing fragments */
984         fd_head->flags |= FD_DEFRAGMENTED;
985         fd_head->reassembled_in=pinfo->fd->num;
986
987         return TRUE;
988 }
989
990 static fragment_data *
991 fragment_add_common(tvbuff_t *tvb, const int offset, const packet_info *pinfo, const guint32 id,
992                  GHashTable *fragment_table, const guint32 frag_offset,
993                  const guint32 frag_data_len, const gboolean more_frags,
994                  const gboolean check_already_added)
995 {
996         fragment_key key, *new_key;
997         fragment_data *fd_head;
998         fragment_data *fd_item;
999         gboolean already_added=pinfo->fd->flags.visited;
1000
1001
1002         /* dissector shouldn't give us garbage tvb info */
1003         DISSECTOR_ASSERT(tvb_bytes_exist(tvb, offset, frag_data_len));
1004
1005         /* create key to search hash with */
1006         key.src = pinfo->src;
1007         key.dst = pinfo->dst;
1008         key.id  = id;
1009
1010         fd_head = g_hash_table_lookup(fragment_table, &key);
1011
1012 #if 0
1013         /* debug output of associated fragments. */
1014         /* leave it here for future debugging sessions */
1015         if(strcmp(pinfo->current_proto, "DCERPC") == 0) {
1016                 printf("proto:%s num:%u id:%u offset:%u len:%u more:%u visited:%u\n",
1017                         pinfo->current_proto, pinfo->fd->num, id, frag_offset, frag_data_len, more_frags, pinfo->fd->flags.visited);
1018                 if(fd_head != NULL) {
1019                         for(fd_item=fd_head->next;fd_item;fd_item=fd_item->next){
1020                                 printf("fd_frame:%u fd_offset:%u len:%u datalen:%u\n",
1021                                         fd_item->frame, fd_item->offset, fd_item->len, fd_item->datalen);
1022                         }
1023                 }
1024         }
1025 #endif
1026
1027         /*
1028          * "already_added" is true if "pinfo->fd->flags.visited" is true;
1029          * if "pinfo->fd->flags.visited", this isn't the first pass, so
1030          * we've already done all the reassembly and added all the
1031          * fragments.
1032          *
1033          * If it's not true, but "check_already_added" is true, just check
1034          * if we have seen this fragment before, i.e., if we have already
1035          * added it to reassembly.
1036          * That can be true even if "pinfo->fd->flags.visited" is false
1037          * since we sometimes might call a subdissector multiple times.
1038          * As an additional check, just make sure we have not already added
1039          * this frame to the reassembly list, if there is a reassembly list;
1040          * note that the first item in the reassembly list is not a
1041          * fragment, it's a data structure for the reassembled packet.
1042          * We don't check it because its "frame" member isn't initialized
1043          * to anything, and because it doesn't count in any case.
1044          *
1045          * And as another additional check, make sure the fragment offsets are
1046          * the same, as otherwise we get into trouble if multiple fragments
1047          * are in one PDU.
1048          */
1049         if (!already_added && check_already_added && fd_head != NULL) {
1050                 if (pinfo->fd->num <= fd_head->frame) {
1051                         for(fd_item=fd_head->next;fd_item;fd_item=fd_item->next){
1052                                 if(pinfo->fd->num==fd_item->frame && frag_offset==fd_item->offset){
1053                                         already_added=TRUE;
1054                                 }
1055                         }
1056                 }
1057         }
1058         /* have we already added this frame ?*/
1059         if (already_added) {
1060                 if (fd_head != NULL && fd_head->flags & FD_DEFRAGMENTED) {
1061                         return fd_head;
1062                 } else {
1063                         return NULL;
1064                 }
1065         }
1066
1067         if (fd_head==NULL){
1068                 /* not found, this must be the first snooped fragment for this
1069                                  * packet. Create list-head.
1070                  */
1071                 fd_head = new_head(0);
1072
1073                 /*
1074                  * We're going to use the key to insert the fragment,
1075                  * so allocate a structure for it, and copy the
1076                  * addresses, allocating new buffers for the address
1077                  * data.
1078                  */
1079 #if GLIB_CHECK_VERSION(2,10,0)
1080                 new_key = g_slice_new(fragment_key);
1081 #else
1082                 new_key = g_mem_chunk_alloc(fragment_key_chunk);
1083 #endif
1084                 COPY_ADDRESS(&new_key->src, &key.src);
1085                 COPY_ADDRESS(&new_key->dst, &key.dst);
1086                 new_key->id = key.id;
1087                 g_hash_table_insert(fragment_table, new_key, fd_head);
1088         }
1089
1090         if (fragment_add_work(fd_head, tvb, offset, pinfo, frag_offset,
1091                 frag_data_len, more_frags)) {
1092                 /*
1093                  * Reassembly is complete.
1094                  */
1095                 return fd_head;
1096         } else {
1097                 /*
1098                  * Reassembly isn't complete.
1099                  */
1100                 return NULL;
1101         }
1102 }
1103
1104 fragment_data *
1105 fragment_add(tvbuff_t *tvb, const int offset, const packet_info *pinfo, const guint32 id,
1106                  GHashTable *fragment_table, const guint32 frag_offset,
1107                  const guint32 frag_data_len, const gboolean more_frags)
1108 {
1109         return fragment_add_common(tvb, offset, pinfo, id, fragment_table,
1110                 frag_offset, frag_data_len, more_frags, TRUE);
1111 }
1112
1113 /*
1114  * For use when you can have multiple fragments in the same frame added
1115  * to the same reassembled PDU, e.g. with ONC RPC-over-TCP.
1116  */
1117 fragment_data *
1118 fragment_add_multiple_ok(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
1119                          const guint32 id, GHashTable *fragment_table,
1120                          const guint32 frag_offset, const guint32 frag_data_len,
1121                          const gboolean more_frags)
1122 {
1123         return fragment_add_common(tvb, offset, pinfo, id, fragment_table,
1124                 frag_offset, frag_data_len, more_frags, FALSE);
1125 }
1126
1127 fragment_data *
1128 fragment_add_check(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
1129                  const guint32 id, GHashTable *fragment_table,
1130                  GHashTable *reassembled_table, const guint32 frag_offset,
1131                  const guint32 frag_data_len, const gboolean more_frags)
1132 {
1133         reassembled_key reass_key;
1134         fragment_key key, *new_key, *old_key;
1135         gpointer orig_key, value;
1136         fragment_data *fd_head;
1137
1138         /*
1139          * If this isn't the first pass, look for this frame in the table
1140          * of reassembled packets.
1141          */
1142         if (pinfo->fd->flags.visited) {
1143                 reass_key.frame = pinfo->fd->num;
1144                 reass_key.id = id;
1145                 return g_hash_table_lookup(reassembled_table, &reass_key);
1146         }
1147
1148         /* create key to search hash with */
1149         key.src = pinfo->src;
1150         key.dst = pinfo->dst;
1151         key.id  = id;
1152
1153         /* Looks up a key in the GHashTable, returning the original key and the associated value
1154          * and a gboolean which is TRUE if the key was found. This is useful if you need to free
1155          * the memory allocated for the original key, for example before calling g_hash_table_remove()
1156          */
1157         if (!g_hash_table_lookup_extended(fragment_table, &key,
1158                                           &orig_key, &value)) {
1159                 /* not found, this must be the first snooped fragment for this
1160                                  * packet. Create list-head.
1161                  */
1162                 fd_head = new_head(0);
1163
1164                 /*
1165                  * We're going to use the key to insert the fragment,
1166                  * so allocate a structure for it, and copy the
1167                  * addresses, allocating new buffers for the address
1168                  * data.
1169                  */
1170 #if GLIB_CHECK_VERSION(2,10,0)
1171                 new_key = g_slice_new(fragment_key);
1172 #else
1173                 new_key = g_mem_chunk_alloc(fragment_key_chunk);
1174 #endif
1175                 COPY_ADDRESS(&new_key->src, &key.src);
1176                 COPY_ADDRESS(&new_key->dst, &key.dst);
1177                 new_key->id = key.id;
1178                 g_hash_table_insert(fragment_table, new_key, fd_head);
1179
1180                 orig_key = new_key; /* for unhashing it later */
1181         } else {
1182                 /*
1183                  * We found it.
1184                  */
1185                 fd_head = value;
1186         }
1187
1188         /*
1189          * If this is a short frame, then we can't, and don't, do
1190          * reassembly on it.  We just give up.
1191          */
1192         if (tvb_reported_length(tvb) > tvb_length(tvb))
1193                 return NULL;
1194
1195         if (fragment_add_work(fd_head, tvb, offset, pinfo, frag_offset,
1196                 frag_data_len, more_frags)) {
1197                 /*
1198                  * Reassembly is complete.
1199                  * Remove this from the table of in-progress
1200                  * reassemblies, add it to the table of
1201                  * reassembled packets, and return it.
1202                  */
1203
1204                 /*
1205                  * Remove this from the table of in-progress reassemblies,
1206                  * and free up any memory used for it in that table.
1207                  */
1208                 old_key = orig_key;
1209                 fragment_unhash(fragment_table, old_key);
1210
1211                 /*
1212                  * Add this item to the table of reassembled packets.
1213                  */
1214                 fragment_reassembled(fd_head, pinfo, reassembled_table, id);
1215                 return fd_head;
1216         } else {
1217                 /*
1218                  * Reassembly isn't complete.
1219                  */
1220                 return NULL;
1221         }
1222 }
1223
1224 static void
1225 fragment_defragment_and_free (fragment_data *fd_head, fragment_data *fd,
1226                                   const packet_info *pinfo)
1227 {
1228         fragment_data *fd_i = NULL;
1229         fragment_data *last_fd = NULL;
1230         guint32  dfpos = 0, size = 0;
1231         void *old_data = NULL;
1232
1233         for(fd_i=fd_head->next;fd_i;fd_i=fd_i->next) {
1234                 if(!last_fd || last_fd->offset!=fd_i->offset){
1235                         size+=fd_i->len;
1236                 }
1237                 last_fd=fd_i;
1238         }
1239
1240         /* store old data in case the fd_i->data pointers refer to it */
1241         old_data=fd_head->data;
1242         fd_head->data = g_malloc(size);
1243         fd_head->len = size;            /* record size for caller       */
1244
1245         /* add all data fragments */
1246         last_fd=NULL;
1247         for (fd_i=fd_head->next;fd_i && fd_i->len + dfpos <= size;fd_i=fd_i->next) {
1248                 if (fd_i->len) {
1249                         if(!last_fd || last_fd->offset!=fd_i->offset){
1250                                 memcpy(fd_head->data+dfpos,fd_i->data,fd_i->len);
1251                                 dfpos += fd_i->len;
1252                         } else {
1253                                 /* duplicate/retransmission/overlap */
1254                                 fd_i->flags    |= FD_OVERLAP;
1255                                 fd_head->flags |= FD_OVERLAP;
1256                                 if( (last_fd->len!=fd_i->len)
1257                                         || memcmp(last_fd->data, fd_i->data, last_fd->len) ) {
1258                                         if (fd) {
1259                                                 fd->flags |= FD_OVERLAPCONFLICT;
1260                                         }
1261                                         fd_head->flags |= FD_OVERLAPCONFLICT;
1262                                 }
1263                         }
1264                 }
1265                 last_fd=fd_i;
1266         }
1267
1268         /* we have defragmented the pdu, now free all fragments*/
1269         for (fd_i=fd_head->next;fd_i;fd_i=fd_i->next) {
1270                 if( fd_i->flags & FD_NOT_MALLOCED )
1271                         fd_i->flags &= ~FD_NOT_MALLOCED;
1272                 else
1273                         g_free(fd_i->data);
1274                 fd_i->data=NULL;
1275         }
1276         g_free(old_data);
1277
1278         /* mark this packet as defragmented.
1279                    allows us to skip any trailing fragments */
1280         fd_head->flags |= FD_DEFRAGMENTED;
1281         fd_head->reassembled_in=pinfo->fd->num;
1282 }
1283
1284 /*
1285  * This function adds a new fragment to the entry for a reassembly
1286  * operation.
1287  *
1288  * The list of fragments for a specific datagram is kept sorted for
1289  * easier handling.
1290  *
1291  * Returns TRUE if we have all the fragments, FALSE otherwise.
1292  *
1293  * This function assumes frag_number being a block sequence number.
1294  * The bsn for the first block is 0.
1295  */
1296 static gboolean
1297 fragment_add_seq_work(fragment_data *fd_head, tvbuff_t *tvb, const int offset,
1298                  const packet_info *pinfo, const guint32 frag_number,
1299                  const guint32 frag_data_len, const gboolean more_frags,
1300                  const guint32 flags _U_)
1301 {
1302         fragment_data *fd;
1303         fragment_data *fd_i;
1304         fragment_data *last_fd;
1305         guint32 max, dfpos;
1306
1307         /* if the partial reassembly flag has been set, and we are extending
1308          * the pdu, un-reassemble the pdu. This means pointing old fds to malloc'ed data.
1309          */
1310         if(fd_head->flags & FD_DEFRAGMENTED && frag_number >= fd_head->datalen &&
1311                 fd_head->flags & FD_PARTIAL_REASSEMBLY){
1312                 guint32 lastdfpos = 0;
1313                 dfpos = 0;
1314                 for(fd_i=fd_head->next; fd_i; fd_i=fd_i->next){
1315                         if( !fd_i->data ) {
1316                                 if( fd_i->flags & FD_OVERLAP ) {
1317                                         /* this is a duplicate of the previous
1318                                          * fragment. */
1319                                         fd_i->data = fd_head->data + lastdfpos;
1320                                 } else {
1321                                         fd_i->data = fd_head->data + dfpos;
1322                                         lastdfpos = dfpos;
1323                                         dfpos += fd_i->len;
1324                                 }
1325                                 fd_i->flags |= FD_NOT_MALLOCED;
1326                         }
1327                         fd_i->flags &= (~FD_TOOLONGFRAGMENT) & (~FD_MULTIPLETAILS);
1328                 }
1329                 fd_head->flags &= ~(FD_DEFRAGMENTED|FD_PARTIAL_REASSEMBLY|FD_DATALEN_SET);
1330                 fd_head->flags &= (~FD_TOOLONGFRAGMENT) & (~FD_MULTIPLETAILS);
1331                 fd_head->datalen=0;
1332                 fd_head->reassembled_in=0;
1333         }
1334
1335
1336         /* create new fd describing this fragment */
1337 #if GLIB_CHECK_VERSION(2,10,0)
1338         fd = g_slice_new(fragment_data);
1339 #else
1340         fd = g_mem_chunk_alloc(fragment_data_chunk);
1341 #endif
1342         fd->next = NULL;
1343         fd->flags = 0;
1344         fd->frame = pinfo->fd->num;
1345         fd->offset = frag_number;
1346         fd->len  = frag_data_len;
1347         fd->data = NULL;
1348
1349         if (!more_frags) {
1350                 /*
1351                  * This is the tail fragment in the sequence.
1352                  */
1353                 if (fd_head->flags&FD_DATALEN_SET) {
1354                         /* ok we have already seen other tails for this packet
1355                          * it might be a duplicate.
1356                          */
1357                         if (fd_head->datalen != fd->offset ){
1358                                 /* Oops, this tail indicates a different packet
1359                                  * len than the previous ones. Something's wrong.
1360                                  */
1361                                 fd->flags          |= FD_MULTIPLETAILS;
1362                                 fd_head->flags |= FD_MULTIPLETAILS;
1363                         }
1364                 } else {
1365                         /* this was the first tail fragment, now we know the
1366                          * sequence number of that fragment (which is NOT
1367                          * the length of the packet!)
1368                          */
1369                         fd_head->datalen = fd->offset;
1370                         fd_head->flags |= FD_DATALEN_SET;
1371                 }
1372         }
1373
1374         /* If the packet is already defragmented, this MUST be an overlap.
1375                  * The entire defragmented packet is in fd_head->data
1376          * Even if we have previously defragmented this packet, we still check
1377          * check it. Someone might play overlap and TTL games.
1378                  */
1379         if (fd_head->flags & FD_DEFRAGMENTED) {
1380                 fd->flags          |= FD_OVERLAP;
1381                 fd_head->flags |= FD_OVERLAP;
1382
1383                 /* make sure it's not past the end */
1384                 if (fd->offset > fd_head->datalen) {
1385                         /* new fragment comes after the end */
1386                         fd->flags          |= FD_TOOLONGFRAGMENT;
1387                         fd_head->flags |= FD_TOOLONGFRAGMENT;
1388                         LINK_FRAG(fd_head,fd);
1389                         return TRUE;
1390                 }
1391                 /* make sure it doesn't conflict with previous data */
1392                 dfpos=0;
1393                 last_fd=NULL;
1394                 for (fd_i=fd_head->next;fd_i && (fd_i->offset!=fd->offset);fd_i=fd_i->next) {
1395                   if (!last_fd || last_fd->offset!=fd_i->offset){
1396                         dfpos += fd_i->len;
1397                   }
1398                   last_fd=fd_i;
1399                 }
1400                 if(fd_i){
1401                         /* new fragment overlaps existing fragment */
1402                         if(fd_i->len!=fd->len){
1403                                 /*
1404                                  * They have different lengths; this
1405                                  * is definitely a conflict.
1406                                  */
1407                                 fd->flags          |= FD_OVERLAPCONFLICT;
1408                                 fd_head->flags |= FD_OVERLAPCONFLICT;
1409                                 LINK_FRAG(fd_head,fd);
1410                                 return TRUE;
1411                         }
1412                         DISSECTOR_ASSERT(fd_head->len >= dfpos + fd->len);
1413                         if ( memcmp(fd_head->data+dfpos,
1414                                 tvb_get_ptr(tvb,offset,fd->len),fd->len) ){
1415                                 /*
1416                                  * They have the same length, but the
1417                                  * data isn't the same.
1418                                  */
1419                                 fd->flags          |= FD_OVERLAPCONFLICT;
1420                                 fd_head->flags |= FD_OVERLAPCONFLICT;
1421                                 LINK_FRAG(fd_head,fd);
1422                                 return TRUE;
1423                         }
1424                         /* it was just an overlap, link it and return */
1425                         LINK_FRAG(fd_head,fd);
1426                         return TRUE;
1427                 } else {
1428                         /*
1429                          * New fragment doesn't overlap an existing
1430                          * fragment - there was presumably a gap in
1431                          * the sequence number space.
1432                          *
1433                          * XXX - what should we do here?  Is it always
1434                          * the case that there are no gaps, or are there
1435                          * protcols using sequence numbers where there
1436                          * can be gaps?
1437                          *
1438                          * If the former, the check below for having
1439                          * received all the fragments should check for
1440                          * holes in the sequence number space and for the
1441                          * first sequence number being 0.  If we do that,
1442                          * the only way we can get here is if this fragment
1443                          * is past the end of the sequence number space -
1444                          * but the check for "fd->offset > fd_head->datalen"
1445                          * would have caught that above, so it can't happen.
1446                          *
1447                          * If the latter, we don't have a good way of
1448                          * knowing whether reassembly is complete if we
1449                          * get packet out of order such that the "last"
1450                          * fragment doesn't show up last - but, unless
1451                          * in-order reliable delivery of fragments is
1452                          * guaranteed, an implementation of the protocol
1453                          * has no way of knowing whether reassembly is
1454                          * complete, either.
1455                          *
1456                          * For now, we just link the fragment in and
1457                          * return.
1458                          */
1459                         LINK_FRAG(fd_head,fd);
1460                         return TRUE;
1461                 }
1462         }
1463
1464         /* If we have reached this point, the packet is not defragmented yet.
1465                  * Save all payload in a buffer until we can defragment.
1466          * XXX - what if we didn't capture the entire fragment due
1467          * to a too-short snapshot length?
1468          */
1469         /* check len, there may be a fragment with 0 len, that is actually the tail */
1470         if (fd->len) {
1471                 fd->data = g_malloc(fd->len);
1472                 tvb_memcpy(tvb, fd->data, offset, fd->len);
1473         }
1474         LINK_FRAG(fd_head,fd);
1475
1476
1477         if( !(fd_head->flags & FD_DATALEN_SET) ){
1478                 /* if we dont know the sequence number of the last fragment,
1479                  * there are definitely still missing packets. Cheaper than
1480                  * the check below.
1481                  */
1482                 return FALSE;
1483         }
1484
1485
1486         /* check if we have received the entire fragment
1487          * this is easy since the list is sorted and the head is faked.
1488          * common case the whole list is scanned.
1489          */
1490         max = 0;
1491         for(fd_i=fd_head->next;fd_i;fd_i=fd_i->next) {
1492           if ( fd_i->offset==max ){
1493                 max++;
1494           }
1495         }
1496         /* max will now be datalen+1 if all fragments have been seen */
1497
1498         if (max <= fd_head->datalen) {
1499                 /* we have not received all packets yet */
1500                 return FALSE;
1501         }
1502
1503
1504         if (max > (fd_head->datalen+1)) {
1505                 /* oops, too long fragment detected */
1506                 fd->flags          |= FD_TOOLONGFRAGMENT;
1507                 fd_head->flags |= FD_TOOLONGFRAGMENT;
1508         }
1509
1510
1511         /* we have received an entire packet, defragment it and
1512                  * free all fragments
1513                  */
1514         fragment_defragment_and_free(fd_head, fd, pinfo);
1515
1516         return TRUE;
1517 }
1518
1519 /*
1520  * This function adds a new fragment to the fragment hash table.
1521  * If this is the first fragment seen for this datagram, a new entry
1522  * is created in the hash table, otherwise this fragment is just added
1523  * to the linked list of fragments for this packet.
1524  *
1525  * Returns a pointer to the head of the fragment data list if we have all the
1526  * fragments, NULL otherwise.
1527  *
1528  * This function assumes frag_number being a block sequence number.
1529  * The bsn for the first block is 0.
1530  */
1531 fragment_data *
1532 fragment_add_seq(tvbuff_t *tvb, const int offset, const packet_info *pinfo, const guint32 id,
1533                  GHashTable *fragment_table, const guint32 frag_number,
1534                  const guint32 frag_data_len, const gboolean more_frags)
1535 {
1536         fragment_key key;
1537
1538         /* create key to search hash with */
1539         key.src = pinfo->src;
1540         key.dst = pinfo->dst;
1541         key.id  = id;
1542
1543         return fragment_add_seq_key(tvb, offset, pinfo,
1544                                         &key, fragment_key_copy,
1545                                         fragment_table, frag_number,
1546                                         frag_data_len, more_frags, 0);
1547 }
1548
1549
1550 fragment_data *
1551 fragment_add_dcerpc_dg(tvbuff_t *tvb, const int offset, const packet_info *pinfo, const guint32 id,
1552                                         void *v_act_id,
1553                                         GHashTable *fragment_table, const guint32 frag_number,
1554                                         const guint32 frag_data_len, const gboolean more_frags)
1555 {
1556         e_uuid_t *act_id = (e_uuid_t *)v_act_id;
1557         dcerpc_fragment_key key;
1558
1559         /* create key to search hash with */
1560         key.src = pinfo->src;
1561         key.dst = pinfo->dst;
1562         key.id  = id;
1563         key.act_id      = *act_id;
1564
1565         return fragment_add_seq_key(tvb, offset, pinfo,
1566                                         &key, dcerpc_fragment_key_copy,
1567                                         fragment_table, frag_number,
1568                                         frag_data_len, more_frags, 0);
1569 }
1570
1571 fragment_data *
1572 fragment_add_seq_key(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
1573                                          void *key, fragment_key_copier key_copier,
1574                                         GHashTable *fragment_table, guint32 frag_number,
1575                                         const guint32 frag_data_len, const gboolean more_frags,
1576                                         const guint32 flags)
1577 {
1578         fragment_data *fd_head;
1579         fd_head = g_hash_table_lookup(fragment_table, key);
1580
1581         /* have we already seen this frame ?*/
1582         if (pinfo->fd->flags.visited) {
1583                 if (fd_head != NULL && fd_head->flags & FD_DEFRAGMENTED) {
1584                         return fd_head;
1585                 } else {
1586                         return NULL;
1587                 }
1588         }
1589
1590         if (fd_head==NULL){
1591                 /* not found, this must be the first snooped fragment for this
1592                                  * packet. Create list-head.
1593                  */
1594                 fd_head= new_head(FD_BLOCKSEQUENCE);
1595
1596                 if((flags & (REASSEMBLE_FLAGS_NO_FRAG_NUMBER|REASSEMBLE_FLAGS_802_11_HACK))
1597                    && !more_frags) {
1598                         /*
1599                          * This is the last fragment for this packet, and
1600                          * is the only one we've seen.
1601                          *
1602                          * Either we don't have sequence numbers, in which
1603                          * case we assume this is the first fragment for
1604                          * this packet, or we're doing special 802.11
1605                          * processing, in which case we assume it's one
1606                          * of those reassembled packets with a non-zero
1607                          * fragment number (see packet-80211.c); just
1608                          * return a pointer to the head of the list;
1609                          * fragment_add_seq_check will then add it to the table
1610                          * of reassembled packets.
1611                          */
1612                         fd_head->reassembled_in=pinfo->fd->num;
1613                         return fd_head;
1614                 }
1615
1616                 /*
1617                  * We're going to use the key to insert the fragment,
1618                  * so copy it to a long-term store.
1619                  */
1620                 if(key_copier != NULL)
1621                         key = key_copier(key);
1622                 g_hash_table_insert(fragment_table, key, fd_head);
1623
1624                 /*
1625                  * If we weren't given an initial fragment number,
1626                  * make it 0.
1627                  */
1628                 if (flags & REASSEMBLE_FLAGS_NO_FRAG_NUMBER)
1629                         frag_number = 0;
1630         } else {
1631                 if (flags & REASSEMBLE_FLAGS_NO_FRAG_NUMBER) {
1632                         fragment_data *fd;
1633                         /*
1634                          * If we weren't given an initial fragment number,
1635                          * use the next expected fragment number as the fragment
1636                          * number for this fragment.
1637                          */
1638                         for (fd = fd_head; fd != NULL; fd = fd->next) {
1639                                 if (fd->next == NULL)
1640                                         frag_number = fd->offset + 1;
1641                         }
1642                 }
1643         }
1644
1645         /*
1646          * XXX I've copied this over from the old separate
1647          * fragment_add_seq_check_work, but I'm not convinced it's doing the
1648          * right thing -- rav
1649          *
1650          * If we don't have all the data that is in this fragment,
1651          * then we can't, and don't, do reassembly on it.
1652          *
1653          * If it's the first frame, handle it as an unfragmented packet.
1654          * Otherwise, just handle it as a fragment.
1655          *
1656          * If "more_frags" isn't set, we get rid of the entry in the
1657          * hash table for this reassembly, as we don't need it any more.
1658          */
1659         if ((flags & REASSEMBLE_FLAGS_CHECK_DATA_PRESENT) &&
1660                 !tvb_bytes_exist(tvb, offset, frag_data_len)) {
1661                 if (!more_frags) {
1662                         gpointer orig_key;
1663                         /*
1664                          * Remove this from the table of in-progress
1665                          * reassemblies, and free up any memory used for
1666                          * it in that table.
1667                          */
1668                         if (g_hash_table_lookup_extended(fragment_table, key,
1669                                                          &orig_key, NULL)) {
1670                                 fragment_unhash(fragment_table, (fragment_key *)orig_key);
1671                         }
1672                 }
1673                 fd_head -> flags |= FD_DATA_NOT_PRESENT;
1674                 return frag_number == 0 ? fd_head : NULL;
1675         }
1676
1677         if (fragment_add_seq_work(fd_head, tvb, offset, pinfo,
1678                                   frag_number, frag_data_len, more_frags, flags)) {
1679                 /*
1680                  * Reassembly is complete.
1681                  */
1682                 return fd_head;
1683         } else {
1684                 /*
1685                  * Reassembly isn't complete.
1686                  */
1687                 return NULL;
1688         }
1689 }
1690
1691 /*
1692  * This does the work for "fragment_add_seq_check()" and
1693  * "fragment_add_seq_next()".
1694  *
1695  * This function assumes frag_number being a block sequence number.
1696  * The bsn for the first block is 0.
1697  *
1698  * If "no_frag_number" is TRUE, it uses the next expected fragment number
1699  * as the fragment number if there is a reassembly in progress, otherwise
1700  * it uses 0.
1701  *
1702  * If "no_frag_number" is FALSE, it uses the "frag_number" argument as
1703  * the fragment number.
1704  *
1705  * If this is the first fragment seen for this datagram, a new
1706  * "fragment_data" structure is allocated to refer to the reassembled
1707  * packet.
1708  *
1709  * This fragment is added to the linked list of fragments for this packet.
1710  *
1711  * If "more_frags" is false and REASSEMBLE_FLAGS_802_11_HACK (as the name
1712  * implies, a special hack for 802.11) or REASSEMBLE_FLAGS_NO_FRAG_NUMBER
1713  * (implying messages must be in order since there's no sequence number) are
1714  * set in "flags", then this (one element) list is returned.
1715  *
1716  * If, after processing this fragment, we have all the fragments,
1717  * "fragment_add_seq_check_work()" removes that from the fragment hash
1718  * table if necessary and adds it to the table of reassembled fragments,
1719  * and returns a pointer to the head of the fragment list.
1720  *
1721  * Otherwise, it returns NULL.
1722  *
1723  * XXX - Should we simply return NULL for zero-length fragments?
1724  */
1725 static fragment_data *
1726 fragment_add_seq_check_work(tvbuff_t *tvb, const int offset,
1727                             const packet_info *pinfo, const guint32 id,
1728                             GHashTable *fragment_table,
1729                             GHashTable *reassembled_table,
1730                             const guint32 frag_number,
1731                             const guint32 frag_data_len,
1732                             const gboolean more_frags, const guint32 flags)
1733 {
1734         reassembled_key reass_key;
1735         fragment_key key;
1736         fragment_data *fd_head;
1737
1738         /*
1739          * Have we already seen this frame?
1740          * If so, look for it in the table of reassembled packets.
1741          */
1742         if (pinfo->fd->flags.visited) {
1743                 reass_key.frame = pinfo->fd->num;
1744                 reass_key.id = id;
1745                 return g_hash_table_lookup(reassembled_table, &reass_key);
1746         }
1747
1748         /* create key to search hash with */
1749         key.src = pinfo->src;
1750         key.dst = pinfo->dst;
1751         key.id  = id;
1752
1753         fd_head = fragment_add_seq_key(tvb, offset, pinfo,
1754                                            &key, fragment_key_copy,
1755                                            fragment_table, frag_number,
1756                                            frag_data_len, more_frags, flags|REASSEMBLE_FLAGS_CHECK_DATA_PRESENT);
1757         if (fd_head) {
1758                 gpointer orig_key;
1759
1760                 if(fd_head->flags & FD_DATA_NOT_PRESENT) {
1761                         /* this is the first fragment of a datagram with
1762                          * truncated fragments. Don't move it to the
1763                          * reassembled table. */
1764                         return fd_head;
1765                 }
1766
1767                 /*
1768                  * Reassembly is complete.
1769                  * Remove this from the table of in-progress
1770                  * reassemblies, add it to the table of
1771                  * reassembled packets, and return it.
1772                  */
1773                 if (g_hash_table_lookup_extended(fragment_table, &key,
1774                                                  &orig_key, NULL)) {
1775                         /*
1776                          * Remove this from the table of in-progress reassemblies,
1777                          * and free up any memory used for it in that table.
1778                          */
1779                         fragment_unhash(fragment_table, (fragment_key *)orig_key);
1780                 }
1781
1782                 /*
1783                  * Add this item to the table of reassembled packets.
1784                  */
1785                 fragment_reassembled(fd_head, pinfo, reassembled_table, id);
1786                 return fd_head;
1787         } else {
1788                 /*
1789                  * Reassembly isn't complete.
1790                  */
1791                 return NULL;
1792         }
1793 }
1794
1795 fragment_data *
1796 fragment_add_seq_check(tvbuff_t *tvb, const int offset,
1797                        const packet_info *pinfo, const guint32 id,
1798                        GHashTable *fragment_table,
1799                        GHashTable *reassembled_table, const guint32 frag_number,
1800                        const guint32 frag_data_len, const gboolean more_frags)
1801 {
1802         return fragment_add_seq_check_work(tvb, offset, pinfo, id,
1803                                            fragment_table, reassembled_table,
1804                                            frag_number, frag_data_len,
1805                                            more_frags, 0);
1806 }
1807
1808 fragment_data *
1809 fragment_add_seq_802_11(tvbuff_t *tvb, const int offset,
1810                         const packet_info *pinfo, const guint32 id,
1811                         GHashTable *fragment_table,
1812                         GHashTable *reassembled_table,
1813                         const guint32 frag_number, const guint32 frag_data_len,
1814                         const gboolean more_frags)
1815 {
1816         return fragment_add_seq_check_work(tvb, offset, pinfo, id,
1817                                            fragment_table, reassembled_table,
1818                                            frag_number, frag_data_len,
1819                                            more_frags,
1820                                            REASSEMBLE_FLAGS_802_11_HACK);
1821 }
1822
1823 fragment_data *
1824 fragment_add_seq_next(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
1825                       const guint32 id, GHashTable *fragment_table,
1826                       GHashTable *reassembled_table, const guint32 frag_data_len,
1827                       const gboolean more_frags)
1828 {
1829         return fragment_add_seq_check_work(tvb, offset, pinfo, id,
1830                                            fragment_table, reassembled_table, 0,
1831                                            frag_data_len, more_frags,
1832                                            REASSEMBLE_FLAGS_NO_FRAG_NUMBER);
1833 }
1834
1835 void
1836 fragment_start_seq_check(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table,
1837                          const guint32 tot_len)
1838 {
1839         fragment_key key, *new_key;
1840         fragment_data *fd_head;
1841
1842         /* Have we already seen this frame ?*/
1843         if (pinfo->fd->flags.visited) {
1844                 return;
1845         }
1846
1847         /* Create key to search hash with */
1848         key.src = pinfo->src;
1849         key.dst = pinfo->dst;
1850         key.id  = id;
1851
1852         /* Check if fragment data exist for this key */
1853         fd_head = g_hash_table_lookup(fragment_table, &key);
1854
1855         if (fd_head == NULL) {
1856                 /* Create list-head. */
1857 #if GLIB_CHECK_VERSION(2,10,0)
1858                 fd_head = g_slice_new(fragment_data);
1859 #else
1860                 fd_head = g_mem_chunk_alloc(fragment_data_chunk);
1861 #endif
1862
1863                 fd_head->next = NULL;
1864                 fd_head->datalen = tot_len;
1865                 fd_head->offset = 0;
1866                 fd_head->len = 0;
1867                 fd_head->flags = FD_BLOCKSEQUENCE|FD_DATALEN_SET;
1868                 fd_head->data = NULL;
1869                 fd_head->reassembled_in = 0;
1870                 /*
1871                  * We're going to use the key to insert the fragment,
1872                  * so copy it to a long-term store.
1873                  */
1874                 new_key = fragment_key_copy(&key);
1875                 g_hash_table_insert(fragment_table, new_key, fd_head);
1876         }
1877 }
1878
1879 fragment_data *
1880 fragment_end_seq_next(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table,
1881                           GHashTable *reassembled_table)
1882 {
1883         reassembled_key reass_key;
1884         reassembled_key *new_key;
1885         fragment_key key;
1886         fragment_data *fd_head;
1887
1888         /*
1889          * Have we already seen this frame?
1890          * If so, look for it in the table of reassembled packets.
1891          */
1892         if (pinfo->fd->flags.visited) {
1893                 reass_key.frame = pinfo->fd->num;
1894                 reass_key.id = id;
1895                 return g_hash_table_lookup(reassembled_table, &reass_key);
1896         }
1897
1898         /* create key to search hash with */
1899         key.src = pinfo->src;
1900         key.dst = pinfo->dst;
1901         key.id  = id;
1902
1903         fd_head = g_hash_table_lookup (fragment_table, &key);
1904
1905         if (fd_head) {
1906                 gpointer orig_key;
1907
1908                 if (fd_head->flags & FD_DATA_NOT_PRESENT) {
1909                         /* No data added */
1910                         return NULL;
1911                 }
1912
1913                 fd_head->datalen = fd_head->offset;
1914                 fd_head->flags |= FD_DATALEN_SET;
1915
1916                 fragment_defragment_and_free (fd_head, NULL, pinfo);
1917
1918                 /*
1919                  * Remove this from the table of in-progress
1920                  * reassemblies, add it to the table of
1921                  * reassembled packets, and return it.
1922                  */
1923                 if (g_hash_table_lookup_extended(fragment_table, &key,
1924                                                  &orig_key, NULL)) {
1925                         /*
1926                          * Remove this from the table of in-progress reassemblies,
1927                          * and free up any memory used for it in that table.
1928                          */
1929                         fragment_unhash(fragment_table, (fragment_key *)orig_key);
1930                 }
1931
1932                 /*
1933                  * Add this item to the table of reassembled packets.
1934                  */
1935                 fragment_reassembled(fd_head, pinfo, reassembled_table, id);
1936                 if (fd_head->next != NULL) {
1937                         new_key = se_alloc(sizeof(reassembled_key));
1938                         new_key->frame = pinfo->fd->num;
1939                         new_key->id = id;
1940                         g_hash_table_insert(reassembled_table, new_key, fd_head);
1941                 }
1942
1943                 return fd_head;
1944         } else {
1945                 /*
1946                  * Fragment data not found.
1947                  */
1948                 return NULL;
1949         }
1950 }
1951
1952 /*
1953  * Process reassembled data; if we're on the frame in which the data
1954  * was reassembled, put the fragment information into the protocol
1955  * tree, and construct a tvbuff with the reassembled data, otherwise
1956  * just put a "reassembled in" item into the protocol tree.
1957  */
1958 tvbuff_t *
1959 process_reassembled_data(tvbuff_t *tvb, const int offset, packet_info *pinfo,
1960         const char *name, fragment_data *fd_head, const fragment_items *fit,
1961         gboolean *update_col_infop, proto_tree *tree)
1962 {
1963         tvbuff_t *next_tvb;
1964         gboolean update_col_info;
1965         proto_item *frag_tree_item;
1966
1967         if (fd_head != NULL && pinfo->fd->num == fd_head->reassembled_in) {
1968                 /*
1969                  * OK, we've reassembled this.
1970                  * Is this something that's been reassembled from more
1971                  * than one fragment?
1972                  */
1973                 if (fd_head->next != NULL) {
1974                         /*
1975                          * Yes.
1976                          * Allocate a new tvbuff, referring to the
1977                          * reassembled payload.
1978                          */
1979                         if (fd_head->flags & FD_BLOCKSEQUENCE) {
1980                                 next_tvb = tvb_new_real_data(fd_head->data,
1981                                           fd_head->len, fd_head->len);
1982                         } else {
1983                                 next_tvb = tvb_new_real_data(fd_head->data,
1984                                           fd_head->datalen, fd_head->datalen);
1985                         }
1986
1987                         /*
1988                          * Add the tvbuff to the list of tvbuffs to which
1989                          * the tvbuff we were handed refers, so it'll get
1990                          * cleaned up when that tvbuff is cleaned up.
1991                          */
1992                         tvb_set_child_real_data_tvbuff(tvb, next_tvb);
1993
1994                         /* Add the defragmented data to the data source list. */
1995                         add_new_data_source(pinfo, next_tvb, name);
1996
1997                         /* show all fragments */
1998                         if (fd_head->flags & FD_BLOCKSEQUENCE) {
1999                                 update_col_info = !show_fragment_seq_tree(
2000                                         fd_head, fit,  tree, pinfo, next_tvb, &frag_tree_item);
2001                         } else {
2002                                 update_col_info = !show_fragment_tree(fd_head,
2003                                         fit, tree, pinfo, next_tvb, &frag_tree_item);
2004                         }
2005                 } else {
2006                         /*
2007                          * No.
2008                          * Return a tvbuff with the payload.
2009                          */
2010                         next_tvb = tvb_new_subset_remaining(tvb, offset);
2011                         pinfo->fragmented = FALSE;      /* one-fragment packet */
2012                         update_col_info = TRUE;
2013                 }
2014                 if (update_col_infop != NULL)
2015                         *update_col_infop = update_col_info;
2016         } else {
2017                 /*
2018                  * We don't have the complete reassembled payload, or this
2019                  * isn't the final frame of that payload.
2020                  */
2021                 next_tvb = NULL;
2022
2023                 /*
2024                  * If we know what frame this was reassembled in,
2025                  * and if there's a field to use for the number of
2026                  * the frame in which the packet was reassembled,
2027                  * add it to the protocol tree.
2028                  */
2029                 if (fd_head != NULL && fit->hf_reassembled_in != NULL) {
2030                         proto_tree_add_uint(tree,
2031                                 *(fit->hf_reassembled_in), tvb,
2032                                 0, 0, fd_head->reassembled_in);
2033                 }
2034         }
2035         return next_tvb;
2036 }
2037
2038 /*
2039  * Show a single fragment in a fragment subtree, and put information about
2040  * it in the top-level item for that subtree.
2041  */
2042 static void
2043 show_fragment(fragment_data *fd, const int offset, const fragment_items *fit,
2044         proto_tree *ft, proto_item *fi, const gboolean first_frag, const guint32 count, tvbuff_t *tvb)
2045 {
2046         proto_item *fei=NULL;
2047         int hf;
2048
2049         if (first_frag) {
2050                 gchar *name;
2051                 if (count == 1) {
2052                         name = g_strdup(proto_registrar_get_name(*(fit->hf_fragment)));
2053                 } else {
2054                         name = g_strdup(proto_registrar_get_name(*(fit->hf_fragments)));
2055                 }
2056                 proto_item_set_text(fi, "%u %s (%u byte%s): ", count, name, tvb_length(tvb),
2057                                     plurality(tvb_length(tvb), "", "s"));
2058                 g_free(name);
2059         } else {
2060                 proto_item_append_text(fi, ", ");
2061         }
2062         proto_item_append_text(fi, "#%u(%u)", fd->frame, fd->len);
2063
2064         if (fd->flags & (FD_OVERLAPCONFLICT
2065                 |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
2066                 hf = *(fit->hf_fragment_error);
2067         } else {
2068                 hf = *(fit->hf_fragment);
2069         }
2070         if (fd->len == 0) {
2071                 fei = proto_tree_add_uint_format(ft, hf,
2072                         tvb, offset, fd->len,
2073                         fd->frame,
2074                         "Frame: %u (no data)",
2075                         fd->frame);
2076         } else {
2077                 fei = proto_tree_add_uint_format(ft, hf,
2078                         tvb, offset, fd->len,
2079                         fd->frame,
2080                         "Frame: %u, payload: %u-%u (%u byte%s)",
2081                         fd->frame,
2082                         offset,
2083                         offset+fd->len-1,
2084                         fd->len,
2085                         plurality(fd->len, "", "s"));
2086         }
2087         PROTO_ITEM_SET_GENERATED(fei);
2088         if (fd->flags & (FD_OVERLAP|FD_OVERLAPCONFLICT
2089                 |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
2090                 /* this fragment has some flags set, create a subtree
2091                  * for it and display the flags.
2092                  */
2093                 proto_tree *fet=NULL;
2094
2095                 fet = proto_item_add_subtree(fei, *(fit->ett_fragment));
2096                 if (fd->flags&FD_OVERLAP) {
2097                         fei=proto_tree_add_boolean(fet,
2098                                 *(fit->hf_fragment_overlap),
2099                                 tvb, 0, 0,
2100                                 TRUE);
2101                         PROTO_ITEM_SET_GENERATED(fei);
2102                 }
2103                 if (fd->flags&FD_OVERLAPCONFLICT) {
2104                         fei=proto_tree_add_boolean(fet,
2105                                 *(fit->hf_fragment_overlap_conflict),
2106                                 tvb, 0, 0,
2107                                 TRUE);
2108                         PROTO_ITEM_SET_GENERATED(fei);
2109                 }
2110                 if (fd->flags&FD_MULTIPLETAILS) {
2111                         fei=proto_tree_add_boolean(fet,
2112                                 *(fit->hf_fragment_multiple_tails),
2113                                 tvb, 0, 0,
2114                                 TRUE);
2115                         PROTO_ITEM_SET_GENERATED(fei);
2116                 }
2117                 if (fd->flags&FD_TOOLONGFRAGMENT) {
2118                         fei=proto_tree_add_boolean(fet,
2119                                 *(fit->hf_fragment_too_long_fragment),
2120                                 tvb, 0, 0,
2121                                 TRUE);
2122                         PROTO_ITEM_SET_GENERATED(fei);
2123                 }
2124         }
2125 }
2126
2127 static gboolean
2128 show_fragment_errs_in_col(fragment_data *fd_head, const fragment_items *fit,
2129         packet_info *pinfo)
2130 {
2131         if (fd_head->flags & (FD_OVERLAPCONFLICT
2132                 |FD_MULTIPLETAILS|FD_TOOLONGFRAGMENT) ) {
2133                 if (check_col(pinfo->cinfo, COL_INFO)) {
2134                         col_add_fstr(pinfo->cinfo, COL_INFO,
2135                                 "[Illegal %s]", fit->tag);
2136                         return TRUE;
2137                 }
2138         }
2139
2140         return FALSE;
2141 }
2142
2143 /* This function will build the fragment subtree; it's for fragments
2144    reassembled with "fragment_add()".
2145
2146    It will return TRUE if there were fragmentation errors
2147    or FALSE if fragmentation was ok.
2148 */
2149 gboolean
2150 show_fragment_tree(fragment_data *fd_head, const fragment_items *fit,
2151         proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb, proto_item **fi)
2152 {
2153         fragment_data *fd;
2154         proto_tree *ft;
2155         gboolean first_frag;
2156         guint32 count = 0;
2157         /* It's not fragmented. */
2158         pinfo->fragmented = FALSE;
2159
2160         *fi = proto_tree_add_item(tree, *(fit->hf_fragments),
2161                 tvb, 0, -1, FALSE);
2162         PROTO_ITEM_SET_GENERATED(*fi);
2163
2164         ft = proto_item_add_subtree(*fi, *(fit->ett_fragments));
2165         first_frag = TRUE;
2166         for (fd = fd_head->next; fd != NULL; fd = fd->next) {
2167                 count++;
2168         }
2169         for (fd = fd_head->next; fd != NULL; fd = fd->next) {
2170                 show_fragment(fd, fd->offset, fit, ft, *fi, first_frag, count, tvb);
2171                 first_frag = FALSE;
2172         }
2173
2174         if (fit->hf_reassembled_length) {
2175                 proto_item *fli = proto_tree_add_uint(ft, *(fit->hf_reassembled_length),
2176                                                       tvb, 0, 0, tvb_length (tvb));
2177                 PROTO_ITEM_SET_GENERATED(fli);
2178         }
2179
2180         return show_fragment_errs_in_col(fd_head, fit, pinfo);
2181 }
2182
2183 /* This function will build the fragment subtree; it's for fragments
2184    reassembled with "fragment_add_seq()" or "fragment_add_seq_check()".
2185
2186    It will return TRUE if there were fragmentation errors
2187    or FALSE if fragmentation was ok.
2188 */
2189 gboolean
2190 show_fragment_seq_tree(fragment_data *fd_head, const fragment_items *fit,
2191         proto_tree *tree, packet_info *pinfo, tvbuff_t *tvb, proto_item **fi)
2192 {
2193         guint32 offset, next_offset, count = 0;
2194         fragment_data *fd, *last_fd;
2195         proto_tree *ft;
2196         gboolean first_frag;
2197
2198         /* It's not fragmented. */
2199         pinfo->fragmented = FALSE;
2200
2201         *fi = proto_tree_add_item(tree, *(fit->hf_fragments),
2202                 tvb, 0, -1, FALSE);
2203         PROTO_ITEM_SET_GENERATED(*fi);
2204
2205         ft = proto_item_add_subtree(*fi, *(fit->ett_fragments));
2206         offset = 0;
2207         next_offset = 0;
2208         last_fd = NULL;
2209         first_frag = TRUE;
2210         for (fd = fd_head->next; fd != NULL; fd = fd->next){
2211                 count++;
2212         }
2213         for (fd = fd_head->next; fd != NULL; fd = fd->next){
2214                 if (last_fd == NULL || last_fd->offset != fd->offset) {
2215                         offset = next_offset;
2216                         next_offset += fd->len;
2217                 }
2218                 last_fd = fd;
2219                 show_fragment(fd, offset, fit, ft, *fi, first_frag, count, tvb);
2220                 first_frag = FALSE;
2221         }
2222
2223         if (fit->hf_reassembled_length) {
2224                 proto_item *fli = proto_tree_add_uint(ft, *(fit->hf_reassembled_length),
2225                                                       tvb, 0, 0, tvb_length (tvb));
2226                 PROTO_ITEM_SET_GENERATED(fli);
2227         }
2228
2229         return show_fragment_errs_in_col(fd_head, fit, pinfo);
2230 }
2231
2232 /*
2233  * Local Variables:
2234  * c-basic-offset: 8
2235  * indent-tabs-mode: t
2236  * tab-width: 8
2237  * End:
2238  */