d40ee7677d51fa4249fdf88324b054c16112c9ab
[obnox/wireshark/wip.git] / epan / conversation.c
1 /* conversation.c
2  * Routines for building lists of packets that are part of a "conversation"
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 <stdio.h>
30
31 #include <string.h>
32 #include <glib.h>
33 #include "packet.h"
34 #include "emem.h"
35 #include "conversation.h"
36
37 /*
38  * Hash table for conversations with no wildcards.
39  */
40 static GHashTable *conversation_hashtable_exact = NULL;
41
42 /*
43  * Hash table for conversations with one wildcard address.
44  */
45 static GHashTable *conversation_hashtable_no_addr2 = NULL;
46
47 /*
48  * Hash table for conversations with one wildcard port.
49  */
50 static GHashTable *conversation_hashtable_no_port2 = NULL;
51
52 /*
53  * Hash table for conversations with one wildcard address and port.
54  */
55 static GHashTable *conversation_hashtable_no_addr2_or_port2 = NULL;
56
57
58 #ifdef __NOT_USED__
59 typedef struct conversation_key {
60         struct conversation_key *next;
61         address addr1;
62         address addr2;
63         port_type ptype;
64         guint32 port1;
65         guint32 port2;
66 } conversation_key;
67 #endif
68 /*
69  * Linked list of conversation keys, so we can, before freeing them all,
70  * free the address data allocations associated with them.
71  */
72 static conversation_key *conversation_keys;
73
74 static guint32 new_index;
75
76 /*
77  * Protocol-specific data attached to a conversation_t structure - protocol
78  * index and opaque pointer.
79  */
80 typedef struct _conv_proto_data {
81         int     proto;
82         void    *proto_data;
83 } conv_proto_data;
84
85 /*
86  * Creates a new conversation with known endpoints based on a conversation
87  * created with the CONVERSATION_TEMPLATE option while keeping the
88  * conversation created with the CONVERSATION_TEMPLATE option so it can still
89  * match future connections.
90  *
91  * Passing a pointer to a conversation whose options mask does not include
92  * CONVERSATION_TEMPLATE or where the conversation's protocol type (ptype)
93  * indicates a non-connnection oriented protocol will return the conversation
94  * without changes.
95  *
96  * addr2 and port2 are used in the function if their respective conversation
97  * options bits are set (NO_ADDR2 and NO_PORT2).
98  */
99 static conversation_t *
100 conversation_create_from_template(conversation_t *conversation, const address *addr2, const guint32 port2)
101 {
102    /*
103     * Add a new conversation and keep the conversation template only if the
104     * CONVERSATION_TEMPLATE bit is set for a connection oriented protocol.
105     */
106    if(conversation->options & CONVERSATION_TEMPLATE &&
107       conversation->key_ptr->ptype != PT_UDP)
108    {
109       /*
110        * Set up a new options mask where the conversation template bit and the
111        * bits for absence of a second address and port pair have been removed.
112        */
113       conversation_t *new_conversation_from_template;
114       guint options = conversation->options & ~(CONVERSATION_TEMPLATE | NO_ADDR2 | NO_PORT2);
115
116       /*
117        * Are both the NO_ADDR2 and NO_PORT2 wildcards set in the options mask?
118        */
119       if(conversation->options & NO_ADDR2 &&
120          conversation->options & NO_PORT2)
121       {
122          /*
123           * The conversation template was created without knowledge of both
124           * the second address as well as the second port. Create a new
125           * conversation with new 2nd address and 2nd port.
126           */
127          new_conversation_from_template =
128             conversation_new(conversation->setup_frame,
129                              &conversation->key_ptr->addr1, addr2,
130                              conversation->key_ptr->ptype, conversation->key_ptr->port1,
131                              port2, options);
132       }
133       else if(conversation->options & NO_PORT2)
134       {
135          /*
136           * The conversation template was created without knowledge of port 2
137           * only. Create a new conversation with new 2nd port.
138           */
139          new_conversation_from_template =
140             conversation_new(conversation->setup_frame,
141                              &conversation->key_ptr->addr1, &conversation->key_ptr->addr2,
142                              conversation->key_ptr->ptype, conversation->key_ptr->port1,
143                              port2, options);
144       }
145       else if(conversation->options & NO_ADDR2)
146       {
147          /*
148           * The conversation template was created without knowledge of address
149           * 2. Create a new conversation with new 2nd address.
150           */
151          new_conversation_from_template =
152             conversation_new(conversation->setup_frame,
153                              &conversation->key_ptr->addr1, addr2,
154                              conversation->key_ptr->ptype, conversation->key_ptr->port1,
155                              conversation->key_ptr->port2, options);
156       }
157       else
158       {
159          /*
160           * The CONVERSATION_TEMPLATE bit was set, but no other bit that the
161           * CONVERSATION_TEMPLATE bit controls is active. Just return the old
162           * conversation.
163           */
164          return conversation;
165       }
166
167       /*
168        * Set the protocol dissector used for the template conversation as
169        * the handler of the new conversation as well.
170        */
171       new_conversation_from_template->dissector_handle = conversation->dissector_handle;
172
173       return new_conversation_from_template;
174    }
175    else
176    {
177       return conversation;
178    }
179 }
180
181 /*
182  * Compute the hash value for two given address/port pairs if the match
183  * is to be exact.
184  */
185 static guint
186 conversation_hash_exact(gconstpointer v)
187 {
188         const conversation_key *key = (const conversation_key *)v;
189         guint hash_val;
190
191         hash_val = 0;
192         ADD_ADDRESS_TO_HASH(hash_val, &key->addr1);
193         hash_val += key->port1;
194         ADD_ADDRESS_TO_HASH(hash_val, &key->addr2);
195         hash_val += key->port2;
196
197         return hash_val;
198 }
199
200 /*
201  * Compare two conversation keys for an exact match.
202  */
203 static gint
204 conversation_match_exact(gconstpointer v, gconstpointer w)
205 {
206         const conversation_key *v1 = (const conversation_key *)v;
207         const conversation_key *v2 = (const conversation_key *)w;
208
209         if (v1->ptype != v2->ptype)
210                 return 0;       /* different types of port */
211
212         /*
213          * Are the first and second port 1 values the same, the first and
214          * second port 2 values the same, the first and second address
215          * 1 values the same, and the first and second address 2 values
216          * the same?
217          */
218         if (v1->port1 == v2->port1 &&
219             v1->port2 == v2->port2 &&
220             ADDRESSES_EQUAL(&v1->addr1, &v2->addr1) &&
221             ADDRESSES_EQUAL(&v1->addr2, &v2->addr2)) {
222                 /*
223                  * Yes.  It's the same conversation, and the two
224                  * address/port pairs are going in the same direction.
225                  */
226                 return 1;
227         }
228
229         /*
230          * Is the first port 2 the same as the second port 1, the first
231          * port 1 the same as the second port 2, the first address 2
232          * the same as the second address 1, and the first address 1
233          * the same as the second address 2?
234          */
235         if (v1->port2 == v2->port1 &&
236             v1->port1 == v2->port2 &&
237             ADDRESSES_EQUAL(&v1->addr2, &v2->addr1) &&
238             ADDRESSES_EQUAL(&v1->addr1, &v2->addr2)) {
239                 /*
240                  * Yes.  It's the same conversation, and the two
241                  * address/port pairs are going in opposite directions.
242                  */
243                 return 1;
244         }
245
246         /*
247          * The addresses or the ports don't match.
248          */
249         return 0;
250 }
251
252 /*
253  * Compute the hash value for two given address/port pairs if the match
254  * has a wildcard address 2.
255  */
256 static guint
257 conversation_hash_no_addr2(gconstpointer v)
258 {
259         const conversation_key *key = (const conversation_key *)v;
260         guint hash_val;
261
262         hash_val = 0;
263         ADD_ADDRESS_TO_HASH(hash_val, &key->addr1);
264         hash_val += key->port1;
265         hash_val += key->port2;
266
267         return hash_val;
268 }
269
270 /*
271  * Compare two conversation keys, except for the address 2 value.
272  * We don't check both directions of the conversation - the routine
273  * doing the hash lookup has to do two searches, as the hash key
274  * will be different for the two directions.
275  */
276 static gint
277 conversation_match_no_addr2(gconstpointer v, gconstpointer w)
278 {
279         const conversation_key *v1 = (const conversation_key *)v;
280         const conversation_key *v2 = (const conversation_key *)w;
281
282         if (v1->ptype != v2->ptype)
283                 return 0;       /* different types of port */
284
285         /*
286          * Are the first and second port 1 values the same, the first and
287          * second port 2 valuess the same, and the first and second
288          * address 1 values the same?
289          */
290         if (v1->port1 == v2->port1 &&
291             v1->port2 == v2->port2 &&
292             ADDRESSES_EQUAL(&v1->addr1, &v2->addr1)) {
293                 /*
294                  * Yes.  It's the same conversation, and the two
295                  * address/port pairs are going in the same direction.
296                  */
297                 return 1;
298         }
299
300         /*
301          * The addresses or the ports don't match.
302          */
303         return 0;
304 }
305
306 /*
307  * Compute the hash value for two given address/port pairs if the match
308  * has a wildcard port 2.
309  */
310 static guint
311 conversation_hash_no_port2(gconstpointer v)
312 {
313         const conversation_key *key = (const conversation_key *)v;
314         guint hash_val;
315
316         hash_val = 0;
317         ADD_ADDRESS_TO_HASH(hash_val, &key->addr1);
318         hash_val += key->port1;
319         ADD_ADDRESS_TO_HASH(hash_val, &key->addr2);
320
321         return hash_val;
322 }
323
324 /*
325  * Compare two conversation keys, except for the port 2 value.
326  * We don't check both directions of the conversation - the routine
327  * doing the hash lookup has to do two searches, as the hash key
328  * will be different for the two directions.
329  */
330 static gint
331 conversation_match_no_port2(gconstpointer v, gconstpointer w)
332 {
333         const conversation_key *v1 = (const conversation_key *)v;
334         const conversation_key *v2 = (const conversation_key *)w;
335
336         if (v1->ptype != v2->ptype)
337                 return 0;       /* different types of port */
338
339         /*
340          * Are the first and second port 1 values the same, the first and
341          * second address 1 values the same, and the first and second
342          * address 2 values the same?
343          */
344         if (v1->port1 == v2->port1 &&
345             ADDRESSES_EQUAL(&v1->addr1, &v2->addr1) &&
346             ADDRESSES_EQUAL(&v1->addr2, &v2->addr2)) {
347                 /*
348                  * Yes.  It's the same conversation, and the two
349                  * address/port pairs are going in the same direction.
350                  */
351                 return 1;
352         }
353
354         /*
355          * The addresses or the ports don't match.
356          */
357         return 0;
358 }
359
360 /*
361  * Compute the hash value for two given address/port pairs if the match
362  * has a wildcard address 2 and port 2.
363  */
364 static guint
365 conversation_hash_no_addr2_or_port2(gconstpointer v)
366 {
367         const conversation_key *key = (const conversation_key *)v;
368         guint hash_val;
369
370         hash_val = 0;
371         ADD_ADDRESS_TO_HASH(hash_val, &key->addr1);
372         hash_val += key->port1;
373
374         return hash_val;
375 }
376
377 /*
378  * Compare the address 1 and port 1 in the two conversation keys.
379  * We don't check both directions of the conversation - the routine
380  * doing the hash lookup has to do two searches, as the hash key
381  * will be different for the two directions.
382  */
383 static gint
384 conversation_match_no_addr2_or_port2(gconstpointer v, gconstpointer w)
385 {
386         const conversation_key *v1 = (const conversation_key *)v;
387         const conversation_key *v2 = (const conversation_key *)w;
388
389         if (v1->ptype != v2->ptype)
390                 return 0;       /* different types of port */
391
392         /*
393          * Are the first and second port 1 values the same and the first
394          * and second address 1 values the same?
395          */
396         if (v1->port1 == v2->port1 &&
397             ADDRESSES_EQUAL(&v1->addr1, &v2->addr1)) {
398                 /*
399                  * Yes.  It's the same conversation, and the two
400                  * address/port pairs are going in the same direction.
401                  */
402                 return 1;
403         }
404
405         /*
406          * The addresses or the ports don't match.
407          */
408         return 0;
409 }
410
411 /*
412  * Free the proto_data.  The conversation itself is se_allocated.
413  */
414 void
415 free_data_list(gpointer key _U_, gpointer value, gpointer user_data _U_)
416 {
417         conversation_t *conv = value;
418
419         /* TODO: se_slist? */
420         g_slist_free(conv->data_list);
421
422         /* Not really necessary, but... */
423         conv->data_list = NULL;
424
425 }
426
427 /*
428  * Destroy all existing conversations
429  */
430 void
431 conversation_cleanup(void)
432 {
433         /*  Clean up the hash tables, but only after freeing any proto_data
434          *  that may be hanging off the conversations.
435          *  The conversation keys are se_ allocated so we don't have to clean them up.
436          */
437         conversation_keys = NULL;
438         if (conversation_hashtable_exact != NULL) {
439                 g_hash_table_foreach(conversation_hashtable_exact, free_data_list, NULL);
440                 g_hash_table_destroy(conversation_hashtable_exact);
441         }
442         if (conversation_hashtable_no_addr2 != NULL) {
443                 g_hash_table_foreach(conversation_hashtable_no_addr2, free_data_list, NULL);
444                 g_hash_table_destroy(conversation_hashtable_no_addr2);
445         }
446         if (conversation_hashtable_no_port2 != NULL) {
447                 g_hash_table_foreach(conversation_hashtable_no_port2, free_data_list, NULL);
448                 g_hash_table_destroy(conversation_hashtable_no_port2);
449         }
450         if (conversation_hashtable_no_addr2_or_port2 != NULL) {
451                 g_hash_table_foreach(conversation_hashtable_no_addr2_or_port2, free_data_list, NULL);
452                 g_hash_table_destroy(conversation_hashtable_no_addr2_or_port2);
453         }
454
455         conversation_hashtable_exact = NULL;
456         conversation_hashtable_no_addr2 = NULL;
457         conversation_hashtable_no_port2 = NULL;
458         conversation_hashtable_no_addr2_or_port2 = NULL;
459 }
460
461 /*
462  * Initialize some variables every time a file is loaded or re-loaded.
463  * Create a new hash table for the conversations in the new file.
464  */
465 void
466 conversation_init(void)
467 {
468         /*
469          * Free up any space allocated for conversation protocol data
470          * areas.
471          *
472          * We can free the space, as the structures it contains are
473          * pointed to by conversation data structures that were freed
474          * above.
475          */
476         conversation_hashtable_exact =
477             g_hash_table_new(conversation_hash_exact,
478               conversation_match_exact);
479         conversation_hashtable_no_addr2 =
480             g_hash_table_new(conversation_hash_no_addr2,
481               conversation_match_no_addr2);
482         conversation_hashtable_no_port2 =
483             g_hash_table_new(conversation_hash_no_port2,
484               conversation_match_no_port2);
485         conversation_hashtable_no_addr2_or_port2 =
486             g_hash_table_new(conversation_hash_no_addr2_or_port2,
487               conversation_match_no_addr2_or_port2);
488
489         /*
490          * Start the conversation indices over at 0.
491          */
492         new_index = 0;
493 }
494
495 /*
496  * Given two address/port pairs for a packet, create a new conversation
497  * to contain packets between those address/port pairs.
498  *
499  * The options field is used to specify whether the address 2 value
500  * and/or port 2 value are not given and any value is acceptable
501  * when searching for this conversation.
502  */
503 conversation_t *
504 conversation_new(const guint32 setup_frame, const address *addr1, const address *addr2, const port_type ptype,
505     const guint32 port1, const guint32 port2, const guint options)
506 {
507 /*
508         DISSECTOR_ASSERT(!(options | CONVERSATION_TEMPLATE) || ((options | (NO_ADDR2 | NO_PORT2 | NO_PORT2_FORCE))) &&
509                                 "A conversation template may not be constructed without wildcard options");
510 */
511         GHashTable* hashtable;
512         conversation_t *conversation;
513         conversation_t *tc;
514         conversation_key existing_key;
515         conversation_key *new_key;
516
517         if (options & NO_ADDR2) {
518                 if (options & (NO_PORT2|NO_PORT2_FORCE)) {
519                         hashtable = conversation_hashtable_no_addr2_or_port2;
520                 } else {
521                         hashtable = conversation_hashtable_no_addr2;
522                 }
523         } else {
524                 if (options & (NO_PORT2|NO_PORT2_FORCE)) {
525                         hashtable = conversation_hashtable_no_port2;
526                 } else {
527                         hashtable = conversation_hashtable_exact;
528                 }
529         }
530
531         existing_key.addr1 = *addr1;
532         existing_key.addr2 = *addr2;
533         existing_key.ptype = ptype;
534         existing_key.port1 = port1;
535         existing_key.port2 = port2;
536
537         conversation = g_hash_table_lookup(hashtable, &existing_key);
538         tc = conversation; /* Remember if lookup was successful */
539
540         new_key = se_alloc(sizeof(struct conversation_key));
541         new_key->next = conversation_keys;
542         conversation_keys = new_key;
543         SE_COPY_ADDRESS(&new_key->addr1, addr1);
544         SE_COPY_ADDRESS(&new_key->addr2, addr2);
545         new_key->ptype = ptype;
546         new_key->port1 = port1;
547         new_key->port2 = port2;
548
549         if (conversation) {
550                 for (; conversation->next; conversation = conversation->next)
551                         ;
552                 conversation->next = se_alloc(sizeof(conversation_t));
553                 conversation = conversation->next;
554         } else {
555                 conversation = se_alloc(sizeof(conversation_t));
556         }
557
558         conversation->next = NULL;
559         conversation->index = new_index;
560         conversation->setup_frame = setup_frame;
561         conversation->data_list = NULL;
562
563         /* clear dissector handle */
564         conversation->dissector_handle = NULL;
565
566         /* set the options and key pointer */
567         conversation->options = options;
568         conversation->key_ptr = new_key;
569
570         new_index++;
571
572         /* only insert a hash table entry if this
573          * is the first conversation with this key */
574         if (!tc)
575                 g_hash_table_insert(hashtable, new_key, conversation);
576
577         return conversation;
578 }
579
580 /*
581  * Set the port 2 value in a key.  Remove the original from table,
582  * update the options and port values, insert the updated key.
583  */
584 void
585 conversation_set_port2(conversation_t *conv, const guint32 port)
586 {
587    DISSECTOR_ASSERT(!(conv->options & CONVERSATION_TEMPLATE) &&
588             "Use the conversation_create_from_template function when the CONVERSATION_TEMPLATE bit is set in the options mask");
589
590         /*
591          * If the port 2 value is not wildcarded, don't set it.
592          */
593         if ((!(conv->options & NO_PORT2)) || (conv->options & NO_PORT2_FORCE))
594                 return;
595
596         if (conv->options & NO_ADDR2) {
597                 g_hash_table_remove(conversation_hashtable_no_addr2_or_port2,
598                     conv->key_ptr);
599         } else {
600                 g_hash_table_remove(conversation_hashtable_no_port2,
601                     conv->key_ptr);
602         }
603         conv->options &= ~NO_PORT2;
604         conv->key_ptr->port2  = port;
605         if (conv->options & NO_ADDR2) {
606                 g_hash_table_insert(conversation_hashtable_no_addr2,
607                     conv->key_ptr, conv);
608         } else {
609                 g_hash_table_insert(conversation_hashtable_exact,
610                     conv->key_ptr, conv);
611         }
612 }
613
614 /*
615  * Set the address 2 value in a key.  Remove the original from
616  * table, update the options and port values, insert the updated key.
617  */
618 void
619 conversation_set_addr2(conversation_t *conv, const address *addr)
620 {
621    DISSECTOR_ASSERT(!(conv->options & CONVERSATION_TEMPLATE) &&
622             "Use the conversation_create_from_template function when the CONVERSATION_TEMPLATE bit is set in the options mask");
623
624         /*
625          * If the address 2 value is not wildcarded, don't set it.
626          */
627         if (!(conv->options & NO_ADDR2))
628                 return;
629
630         if (conv->options & NO_PORT2) {
631                 g_hash_table_remove(conversation_hashtable_no_addr2_or_port2,
632                     conv->key_ptr);
633         } else {
634                 g_hash_table_remove(conversation_hashtable_no_addr2,
635                     conv->key_ptr);
636         }
637         conv->options &= ~NO_ADDR2;
638         SE_COPY_ADDRESS(&conv->key_ptr->addr2, addr);
639         if (conv->options & NO_PORT2) {
640                 g_hash_table_insert(conversation_hashtable_no_port2,
641                     conv->key_ptr, conv);
642         } else {
643                 g_hash_table_insert(conversation_hashtable_exact,
644                     conv->key_ptr, conv);
645         }
646 }
647
648 /*
649  * Search a particular hash table for a conversation with the specified
650  * {addr1, port1, addr2, port2} and set up before frame_num.
651  */
652 static conversation_t *
653 conversation_lookup_hashtable(GHashTable *hashtable, const guint32 frame_num, const address *addr1, const address *addr2,
654     const port_type ptype, const guint32 port1, const guint32 port2)
655 {
656         conversation_t* conversation;
657         conversation_t* match;
658         conversation_key key;
659
660         /*
661          * We don't make a copy of the address data, we just copy the
662          * pointer to it, as "key" disappears when we return.
663          */
664         key.addr1 = *addr1;
665         key.addr2 = *addr2;
666         key.ptype = ptype;
667         key.port1 = port1;
668         key.port2 = port2;
669
670         match = g_hash_table_lookup(hashtable, &key);
671
672         if (match) {
673                 for (conversation = match->next; conversation; conversation = conversation->next) {
674                         if ((conversation->setup_frame <= frame_num)
675                                 && (conversation->setup_frame > match->setup_frame))
676                                 match = conversation;
677                 }
678                 if (match->setup_frame > frame_num)
679                         match = NULL;
680         }
681
682         return match;
683 }
684
685
686 /*
687  * Given two address/port pairs for a packet, search for a conversation
688  * containing packets between those address/port pairs.  Returns NULL if
689  * not found.
690  *
691  * We try to find the most exact match that we can, and then proceed to
692  * try wildcard matches on the "addr_b" and/or "port_b" argument if a more
693  * exact match failed.
694  *
695  * Either or both of the "addr_b" and "port_b" arguments may be specified as
696  * a wildcard by setting the NO_ADDR_B or NO_PORT_B flags in the "options"
697  * argument.  We do only wildcard matches on addresses and ports specified
698  * as wildcards.
699  *
700  * I.e.:
701  *
702  *      if neither "addr_b" nor "port_b" were specified as wildcards, we
703  *      do an exact match (addr_a/port_a and addr_b/port_b) and, if that
704  *      succeeds, we return a pointer to the matched conversation;
705  *
706  *      otherwise, if "port_b" wasn't specified as a wildcard, we try to
707  *      match any address 2 with the specified port 2 (addr_a/port_a and
708  *      {any}/addr_b) and, if that succeeds, we return a pointer to the
709  *      matched conversation;
710  *
711  *      otherwise, if "addr_b" wasn't specified as a wildcard, we try to
712  *      match any port 2 with the specified address 2 (addr_a/port_a and
713  *      addr_b/{any}) and, if that succeeds, we return a pointer to the
714  *      matched conversation;
715  *
716  *      otherwise, we try to match any address 2 and any port 2
717  *      (addr_a/port_a and {any}/{any}) and, if that succeeds, we return
718  *      a pointer to the matched conversation;
719  *
720  *      otherwise, we found no matching conversation, and return NULL.
721  */
722 conversation_t *
723 find_conversation(const guint32 frame_num, const address *addr_a, const address *addr_b, const port_type ptype,
724     const guint32 port_a, const guint32 port_b, const guint options)
725 {
726    conversation_t *conversation;
727
728    /*
729     * First try an exact match, if we have two addresses and ports.
730     */
731    if (!(options & (NO_ADDR_B|NO_PORT_B))) {
732       /*
733        * Neither search address B nor search port B are wildcarded,
734        * start out with an exact match.
735        * Exact matches check both directions.
736        */
737       conversation =
738          conversation_lookup_hashtable(conversation_hashtable_exact,
739          frame_num, addr_a, addr_b, ptype,
740          port_a, port_b);
741       if ((conversation == NULL) && (addr_a->type == AT_FC)) {
742          /* In Fibre channel, OXID & RXID are never swapped as
743           * TCP/UDP ports are in TCP/IP.
744           */
745          conversation =
746             conversation_lookup_hashtable(conversation_hashtable_exact,
747             frame_num, addr_b, addr_a, ptype,
748             port_a, port_b);
749       }
750       if (conversation != NULL)
751          return conversation;
752    }
753
754    /*
755     * Well, that didn't find anything.  Try matches that wildcard
756     * one of the addresses, if we have two ports.
757     */
758    if (!(options & NO_PORT_B)) {
759       /*
760        * Search port B isn't wildcarded.
761        *
762        * First try looking for a conversation with the specified
763        * address A and port A as the first address and port, and
764        * with any address and the specified port B as the second
765        * address and port.
766        * ("addr_b" doesn't take part in this lookup.)
767        */
768       conversation =
769          conversation_lookup_hashtable(conversation_hashtable_no_addr2,
770          frame_num, addr_a, addr_b, ptype, port_a, port_b);
771       if ((conversation == NULL) && (addr_a->type == AT_FC)) {
772          /* In Fibre channel, OXID & RXID are never swapped as
773           * TCP/UDP ports are in TCP/IP.
774           */
775          conversation =
776             conversation_lookup_hashtable(conversation_hashtable_no_addr2,
777             frame_num, addr_b, addr_a, ptype,
778             port_a, port_b);
779       }
780       if (conversation != NULL) {
781          /*
782           * If search address B isn't wildcarded, and this is for a
783           * connection-oriented protocol, set the second address for this
784           * conversation to address B, as that's the address that matched the
785           * wildcarded second address for this conversation.
786           *
787           * (This assumes that, for all connection oriented protocols, the
788           * endpoints of a connection have only one address each, i.e. you
789           * don't get packets in a given direction coming from more than one
790           * address, unless the CONVERSATION_TEMPLATE option is set.)
791           */
792          if (!(conversation->options & NO_ADDR_B) && ptype != PT_UDP)
793          {
794             if(!(conversation->options & CONVERSATION_TEMPLATE))
795             {
796                conversation_set_addr2(conversation, addr_b);
797             }
798             else
799             {
800                conversation =
801                   conversation_create_from_template(conversation, addr_b, 0);
802             }
803          }
804          return conversation;
805       }
806
807       /*
808        * Well, that didn't find anything.
809        * If search address B was specified, try looking for a
810        * conversation with the specified address B and port B as
811        * the first address and port, and with any address and the
812        * specified port A as the second address and port (this
813        * packet may be going in the opposite direction from the
814        * first packet in the conversation).
815        * ("addr_a" doesn't take part in this lookup.)
816        */
817       if (!(options & NO_ADDR_B)) {
818          conversation =
819             conversation_lookup_hashtable(conversation_hashtable_no_addr2,
820             frame_num, addr_b, addr_a, ptype, port_b, port_a);
821          if (conversation != NULL) {
822             /*
823              * If this is for a connection-oriented
824              * protocol, set the second address for
825              * this conversation to address A, as
826              * that's the address that matched the
827              * wildcarded second address for this
828              * conversation.
829              */
830             if (ptype != PT_UDP) {
831                if(!(conversation->options & CONVERSATION_TEMPLATE))
832                {
833                   conversation_set_addr2(conversation, addr_a);
834                }
835                else
836                {
837                   conversation =
838                      conversation_create_from_template(conversation, addr_a, 0);
839                }
840             }
841             return conversation;
842          }
843       }
844    }
845
846    /*
847     * Well, that didn't find anything.  Try matches that wildcard
848     * one of the ports, if we have two addresses.
849    */
850    if (!(options & NO_ADDR_B)) {
851       /*
852        * Search address B isn't wildcarded.
853        *
854        * First try looking for a conversation with the specified
855        * address A and port A as the first address and port, and
856        * with the specified address B and any port as the second
857        * address and port.
858        * ("port_b" doesn't take part in this lookup.)
859        */
860       conversation =
861          conversation_lookup_hashtable(conversation_hashtable_no_port2,
862          frame_num, addr_a, addr_b, ptype, port_a, port_b);
863       if ((conversation == NULL) && (addr_a->type == AT_FC)) {
864          /* In Fibre channel, OXID & RXID are never swapped as
865           * TCP/UDP ports are in TCP/IP
866           */
867          conversation =
868             conversation_lookup_hashtable(conversation_hashtable_no_port2,
869             frame_num, addr_b, addr_a, ptype, port_a, port_b);
870       }
871       if (conversation != NULL) {
872          /*
873           * If search port B isn't wildcarded, and this is for a connection-
874           * oriented protocol, set the second port for this conversation to
875           * port B, as that's the port that matched the wildcarded second port
876           * for this conversation.
877           *
878           * (This assumes that, for all connection oriented protocols, the
879           * endpoints of a connection have only one port each, i.e. you don't
880           * get packets in a given direction coming from more than one port,
881           * unless the CONVERSATION_TEMPLATE option is set.)
882           */
883          if (!(conversation->options & NO_PORT_B) && ptype != PT_UDP)
884          {
885             if(!(conversation->options & CONVERSATION_TEMPLATE))
886             {
887                conversation_set_port2(conversation, port_b);
888             }
889             else
890             {
891                conversation =
892                   conversation_create_from_template(conversation, 0, port_b);
893             }
894          }
895          return conversation;
896       }
897
898       /*
899        * Well, that didn't find anything.
900        * If search port B was specified, try looking for a
901        * conversation with the specified address B and port B
902        * as the first address and port, and with the specified
903        * address A and any port as the second address and port
904        * (this packet may be going in the opposite direction
905        * from the first packet in the conversation).
906        * ("port_a" doesn't take part in this lookup.)
907        */
908       if (!(options & NO_PORT_B)) {
909          conversation =
910             conversation_lookup_hashtable(conversation_hashtable_no_port2,
911             frame_num, addr_b, addr_a, ptype, port_b, port_a);
912          if (conversation != NULL) {
913             /*
914              * If this is for a connection-oriented
915              * protocol, set the second port for
916              * this conversation to port A, as
917              * that's the address that matched the
918              * wildcarded second address for this
919              * conversation.
920              */
921             if (ptype != PT_UDP)
922             {
923                if(!(conversation->options & CONVERSATION_TEMPLATE))
924                {
925                   conversation_set_port2(conversation, port_a);
926                }
927                else
928                {
929                   conversation =
930                      conversation_create_from_template(conversation, 0, port_a);
931                }
932             }
933             return conversation;
934          }
935       }
936    }
937
938    /*
939     * Well, that didn't find anything.  Try matches that wildcard
940     * one address/port pair.
941     *
942     * First try looking for a conversation with the specified address A
943     * and port A as the first address and port.
944     * (Neither "addr_b" nor "port_b" take part in this lookup.)
945     */
946    conversation =
947       conversation_lookup_hashtable(conversation_hashtable_no_addr2_or_port2,
948       frame_num, addr_a, addr_b, ptype, port_a, port_b);
949    if (conversation != NULL) {
950       /*
951        * If this is for a connection-oriented protocol:
952        *
953        * if search address B isn't wildcarded, set the
954        * second address for this conversation to address
955        * B, as that's the address that matched the
956        * wildcarded second address for this conversation;
957        *
958        * if search port B isn't wildcarded, set the
959        * second port for this conversation to port B,
960        * as that's the port that matched the wildcarded
961        * second port for this conversation.
962        */
963       if (ptype != PT_UDP)
964       {
965          if(!(conversation->options & CONVERSATION_TEMPLATE))
966          {
967             if (!(conversation->options & NO_ADDR_B))
968                conversation_set_addr2(conversation, addr_b);
969             if (!(conversation->options & NO_PORT_B))
970                conversation_set_port2(conversation, port_b);
971          }
972          else
973          {
974             conversation =
975                conversation_create_from_template(conversation, addr_b, port_b);
976          }
977       }
978       return conversation;
979    }
980
981    /*
982     * Well, that didn't find anything.
983     * If search address and port B were specified, try looking for a
984     * conversation with the specified address B and port B as the
985     * first address and port, and with any second address and port
986     * (this packet may be going in the opposite direction from the
987     * first packet in the conversation).
988     * (Neither "addr_a" nor "port_a" take part in this lookup.)
989     */
990    if (addr_a->type == AT_FC)
991       conversation =
992       conversation_lookup_hashtable(conversation_hashtable_no_addr2_or_port2,
993       frame_num, addr_b, addr_a, ptype, port_a, port_b);
994    else
995       conversation =
996       conversation_lookup_hashtable(conversation_hashtable_no_addr2_or_port2,
997       frame_num, addr_b, addr_a, ptype, port_b, port_a);
998    if (conversation != NULL) {
999       /*
1000        * If this is for a connection-oriented protocol, set the
1001        * second address for this conversation to address A, as
1002        * that's the address that matched the wildcarded second
1003        * address for this conversation, and set the second port
1004        * for this conversation to port A, as that's the port
1005        * that matched the wildcarded second port for this
1006        * conversation.
1007        */
1008       if (ptype != PT_UDP)
1009       {
1010          if(!(conversation->options & CONVERSATION_TEMPLATE))
1011          {
1012             conversation_set_addr2(conversation, addr_a);
1013             conversation_set_port2(conversation, port_a);
1014          }
1015          else
1016          {
1017             conversation = conversation_create_from_template(conversation, addr_a, port_a);
1018          }
1019       }
1020       return conversation;
1021    }
1022
1023    /*
1024     * We found no conversation.
1025     */
1026    return NULL;
1027 }
1028
1029 static gint
1030 p_compare(gconstpointer a, gconstpointer b)
1031 {
1032         const conv_proto_data *ap = (const conv_proto_data *)a;
1033         const conv_proto_data *bp = (const conv_proto_data *)b;
1034
1035         if (ap->proto > bp->proto)
1036                 return 1;
1037         else if (ap->proto == bp->proto)
1038                 return 0;
1039         else
1040                 return -1;
1041 }
1042
1043 void
1044 conversation_add_proto_data(conversation_t *conv, const int proto, void *proto_data)
1045 {
1046         conv_proto_data *p1 = se_alloc(sizeof(conv_proto_data));
1047
1048         p1->proto = proto;
1049         p1->proto_data = proto_data;
1050
1051         /* Add it to the list of items for this conversation. */
1052
1053         conv->data_list = g_slist_insert_sorted(conv->data_list, (gpointer *)p1,
1054             p_compare);
1055 }
1056
1057 void *
1058 conversation_get_proto_data(const conversation_t *conv, const int proto)
1059 {
1060         conv_proto_data temp, *p1;
1061         GSList *item;
1062
1063         temp.proto = proto;
1064         temp.proto_data = NULL;
1065
1066         item = g_slist_find_custom(conv->data_list, (gpointer *)&temp,
1067             p_compare);
1068
1069         if (item != NULL) {
1070                 p1 = (conv_proto_data *)item->data;
1071                 return p1->proto_data;
1072         }
1073
1074         return NULL;
1075 }
1076
1077 void
1078 conversation_delete_proto_data(conversation_t *conv, const int proto)
1079 {
1080         conv_proto_data temp;
1081         GSList *item;
1082
1083         temp.proto = proto;
1084         temp.proto_data = NULL;
1085
1086         item = g_slist_find_custom(conv->data_list, (gpointer *)&temp,
1087             p_compare);
1088
1089         while(item){
1090                 conv->data_list = g_slist_remove(conv->data_list, item->data);
1091                 item=item->next;
1092         }
1093 }
1094
1095 void
1096 conversation_set_dissector(conversation_t *conversation, const dissector_handle_t handle)
1097 {
1098         conversation->dissector_handle = handle;
1099 }
1100
1101 /*
1102  * Given two address/port pairs for a packet, search for a matching
1103  * conversation and, if found and it has a conversation dissector,
1104  * call that dissector and return TRUE, otherwise return FALSE.
1105  *
1106  * This helper uses call_dissector_only which will NOT call the default
1107  * "data" dissector if the packet was rejected.
1108  * Our caller is responsible to call the data dissector explicitely in case
1109  * this function returns FALSE.
1110  */
1111 gboolean
1112 try_conversation_dissector(const address *addr_a, const address *addr_b, const port_type ptype,
1113     const guint32 port_a, const guint32 port_b, tvbuff_t *tvb, packet_info *pinfo,
1114     proto_tree *tree)
1115 {
1116         conversation_t *conversation;
1117
1118         conversation = find_conversation(pinfo->fd->num, addr_a, addr_b, ptype, port_a,
1119             port_b, 0);
1120
1121         if (conversation != NULL) {
1122                 int ret;
1123                 if (conversation->dissector_handle == NULL)
1124                         return FALSE;
1125                 ret=call_dissector_only(conversation->dissector_handle, tvb, pinfo,
1126                     tree);
1127                 if(!ret) {
1128                         /* this packet was rejected by the dissector
1129                          * so return FALSE in case our caller wants
1130                          * to do some cleaning up.
1131                          */
1132                         return FALSE;
1133                 }
1134                 return TRUE;
1135         }
1136         return FALSE;
1137 }
1138
1139 /*  A helper function that calls find_conversation() and, if a conversation is
1140  *  not found, calls conversation_new().
1141  *  The frame number and addresses are taken from pinfo.
1142  *  No options are used, though we could extend this API to include an options
1143  *  parameter.
1144  */
1145 conversation_t *
1146 find_or_create_conversation(packet_info *pinfo)
1147 {
1148         conversation_t *conv=NULL;
1149
1150         /* Have we seen this conversation before? */
1151         if((conv = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst,
1152                                      pinfo->ptype, pinfo->srcport,
1153                                      pinfo->destport, 0)) == NULL) {
1154                 /* No, this is a new conversation. */
1155                 conv = conversation_new(pinfo->fd->num, &pinfo->src,
1156                                         &pinfo->dst, pinfo->ptype,
1157                                         pinfo->srcport, pinfo->destport, 0);
1158         }
1159
1160         return conv;
1161 }