fix doxygen generation
[obnox/wireshark/wip.git] / h225-persistentdata.c
1 /*
2  * h225-persistentdata.c
3  * Source for lists and hash tables used in ethereal's h225 dissector
4  * for calculation of delays in h225-calls
5  *
6  * Copyright 2003 Lars Roland
7  *
8  * $Id$
9  *
10  * Ethereal - Network traffic analyzer
11  * By Gerald Combs <gerald@ethereal.com>
12  * Copyright 1998 Gerald Combs
13  *
14  * This program is free software; you can redistribute it and/or
15  * modify it under the terms of the GNU General Public License
16  * as published by the Free Software Foundation; either version 2
17  * of the License, or (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
27  */
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <glib.h>
34 #include <epan/packet.h>
35 #include <epan/conversation.h>
36
37 #include <stdio.h>
38 #include <string.h>
39
40 #include "h225-persistentdata.h"
41
42 /* Global Memory Chunks for lists and Global hash tables*/
43
44 static GMemChunk *h225ras_call_info_key_chunk = NULL;
45 static GMemChunk *h225ras_call_info_value_chunk = NULL;
46
47 static GHashTable *ras_calls[7] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL};
48
49 /*
50  * Functions needed for Ras-Hash-Table
51  */
52
53 /* compare 2 keys */
54 static gint h225ras_call_equal(gconstpointer k1, gconstpointer k2)
55 {
56         const h225ras_call_info_key* key1 = (const h225ras_call_info_key*) k1;
57         const h225ras_call_info_key* key2 = (const h225ras_call_info_key*) k2;
58
59         return (key1->reqSeqNum == key2->reqSeqNum &&
60             key1->conversation == key2->conversation);
61 }
62
63 /* calculate a hash key */
64 static guint h225ras_call_hash(gconstpointer k)
65 {
66         const h225ras_call_info_key* key = (const h225ras_call_info_key*) k;
67
68         return key->reqSeqNum  + (guint32)(key->conversation);
69 }
70
71
72 h225ras_call_t * find_h225ras_call(h225ras_call_info_key *h225ras_call_key ,int category)
73 {
74         h225ras_call_t *h225ras_call = NULL;
75         h225ras_call = (h225ras_call_t *)g_hash_table_lookup(ras_calls[category], h225ras_call_key);
76
77         return h225ras_call;
78 }
79
80 h225ras_call_t * new_h225ras_call(h225ras_call_info_key *h225ras_call_key, packet_info *pinfo, guint8 *guid, int category)
81 {
82         h225ras_call_info_key *new_h225ras_call_key;
83         h225ras_call_t *h225ras_call = NULL;
84
85
86         /* Prepare the value data.
87            "req_num" and "rsp_num" are frame numbers;
88            frame numbers are 1-origin, so we use 0
89            to mean "we don't yet know in which frame
90            the reply for this call appears". */
91         new_h225ras_call_key = (h225ras_call_info_key *)g_mem_chunk_alloc(h225ras_call_info_key_chunk);
92         new_h225ras_call_key->reqSeqNum = h225ras_call_key->reqSeqNum;
93         new_h225ras_call_key->conversation = h225ras_call_key->conversation;
94         h225ras_call = (h225ras_call_t *)g_mem_chunk_alloc(h225ras_call_info_value_chunk);
95         h225ras_call->req_num = pinfo->fd->num;
96         h225ras_call->rsp_num = 0;
97         h225ras_call->requestSeqNum = h225ras_call_key->reqSeqNum;
98         h225ras_call->responded = FALSE;
99         h225ras_call->next_call = NULL;
100         h225ras_call->req_time.secs=pinfo->fd->abs_secs;
101         h225ras_call->req_time.nsecs=pinfo->fd->abs_usecs*1000;
102         memcpy(h225ras_call->guid, guid,16);
103         /* store it */
104         g_hash_table_insert(ras_calls[category], new_h225ras_call_key, h225ras_call);
105
106         return h225ras_call;
107 }
108
109 h225ras_call_t * append_h225ras_call(h225ras_call_t *prev_call, packet_info *pinfo, guint8 *guid, int category _U_)
110 {
111         h225ras_call_t *h225ras_call = NULL;
112
113         /* Prepare the value data.
114            "req_num" and "rsp_num" are frame numbers;
115            frame numbers are 1-origin, so we use 0
116            to mean "we don't yet know in which frame
117            the reply for this call appears". */
118         h225ras_call = (h225ras_call_t *)g_mem_chunk_alloc(h225ras_call_info_value_chunk);
119         h225ras_call->req_num = pinfo->fd->num;
120         h225ras_call->rsp_num = 0;
121         h225ras_call->requestSeqNum = prev_call->requestSeqNum;
122         h225ras_call->responded = FALSE;
123         h225ras_call->next_call = NULL;
124         h225ras_call->req_time.secs=pinfo->fd->abs_secs;
125         h225ras_call->req_time.nsecs=pinfo->fd->abs_usecs*1000;
126         memcpy(h225ras_call->guid, guid,16);
127
128         prev_call->next_call = h225ras_call;
129         return h225ras_call;
130 }
131
132
133 /* Init routine for hash tables and delay calculation
134    This routine will be called by Ethereal, before it
135    is (re-)dissecting a trace file from beginning.
136    We need to discard and init any state we've saved */
137
138 void
139 h225_init_routine(void)
140 {
141         int i;
142
143         /* free hash-tables and mem_chunks for RAS SRT */
144         for(i=0;i<7;i++) {
145                 if (ras_calls[i] != NULL) {
146                         g_hash_table_destroy(ras_calls[i]);
147                         ras_calls[i] = NULL;
148                 }
149         }
150
151         if (h225ras_call_info_key_chunk != NULL) {
152                 g_mem_chunk_destroy(h225ras_call_info_key_chunk);
153                 h225ras_call_info_key_chunk = NULL;
154         }
155         if (h225ras_call_info_value_chunk != NULL) {
156                 g_mem_chunk_destroy(h225ras_call_info_value_chunk);
157                 h225ras_call_info_value_chunk = NULL;
158         }
159
160         /* create new hash-tables and mem_chunks for RAS SRT */
161
162         for(i=0;i<7;i++) {
163                 ras_calls[i] = g_hash_table_new(h225ras_call_hash, h225ras_call_equal);
164         }
165
166         h225ras_call_info_key_chunk = g_mem_chunk_new("call_info_key_chunk",
167             sizeof(h225ras_call_info_key),
168             400 * sizeof(h225ras_call_info_key),
169             G_ALLOC_ONLY);
170         h225ras_call_info_value_chunk = g_mem_chunk_new("call_info_value_chunk",
171             sizeof(h225ras_call_t),
172             400 * sizeof(h225ras_call_t),
173             G_ALLOC_ONLY);
174 }