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