Add URL for the Linux Documentation dir file describing USB/IP.
[metze/wireshark/wip.git] / epan / circuit.c
1 /* circuit.c
2  * Routines for building lists of packets that are part of a "circuit"
3  *
4  * Wireshark - Network traffic analyzer
5  * By Gerald Combs <gerald@wireshark.org>
6  * Copyright 1998 Gerald Combs
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21  */
22
23 #include "config.h"
24
25 #include <glib.h>
26 #include "packet.h"
27 #include "circuit.h"
28
29 /*
30  * Hash table for circuits.
31  */
32 static GHashTable *circuit_hashtable = NULL;
33
34 static guint32 new_index;
35
36 /*
37  * Protocol-specific data attached to a circuit_t structure - protocol
38  * index and opaque pointer.
39  */
40 typedef struct _circuit_proto_data {
41         int     proto;
42         void    *proto_data;
43 } circuit_proto_data;
44
45 /*
46  * Compute the hash value for a circuit.
47  */
48 static guint
49 circuit_hash(gconstpointer v)
50 {
51         const circuit_key *key = (const circuit_key *)v;
52
53         return key->ctype ^ key->circuit_id;
54 }
55
56 /*
57  * Compare two circuit keys.
58  */
59 static gint
60 circuit_match(gconstpointer v, gconstpointer w)
61 {
62         const circuit_key *v1 = (const circuit_key *)v;
63         const circuit_key *v2 = (const circuit_key *)w;
64
65         return v1->ctype == v2->ctype && v1->circuit_id == v2->circuit_id;
66 }
67
68 /*
69  * Destroy all existing circuits.
70  */
71 void
72 circuit_cleanup(void)
73 {
74         /*
75          * Free up any space allocated for the circuit hashtable.
76          *
77          * We can free the hash as the structures pointed to in the
78          * hash are in "seasonal" memory which is freed separately.
79          * Note: circuit_cleanup() must be called only when
80          *       seasonal memory is also freed.
81          */
82
83         if (circuit_hashtable != NULL)
84                 g_hash_table_destroy(circuit_hashtable);
85
86         circuit_hashtable = NULL;
87 }
88
89 /*
90  * Initialize some variables every time a file is loaded or re-loaded.
91  * Create a new hash table for the circuits in the new file.
92  */
93 void
94 circuit_init(void)
95 {
96         g_assert(circuit_hashtable == NULL);
97         circuit_hashtable = g_hash_table_new(circuit_hash, circuit_match);
98
99         /*
100          * Start the circuit indices over at 0.
101          */
102         new_index = 0;
103 }
104
105 /*
106  * Given a circuit type and circuit ID for a packet, create a new circuit
107  * to contain packets for that circuit.
108  */
109 circuit_t *
110 circuit_new(circuit_type ctype, guint32 circuit_id, guint32 first_frame)
111 {
112         circuit_t *circuit, *old_circuit;
113         circuit_key *new_key;
114
115         new_key = wmem_new(wmem_file_scope(), struct circuit_key);
116         new_key->ctype = ctype;
117         new_key->circuit_id = circuit_id;
118
119         circuit = wmem_new(wmem_file_scope(), circuit_t);
120         circuit->next = NULL;
121         circuit->first_frame = first_frame;
122         circuit->last_frame = 0;        /* not known yet */
123         circuit->index = new_index;
124         circuit->data_list = NULL;
125         circuit->dissector_handle = NULL;
126         circuit->key_ptr = new_key;
127
128         new_index++;
129
130         /*
131          * Is there already a circuit with this circuit ID?
132          */
133         old_circuit = (circuit_t *)g_hash_table_lookup(circuit_hashtable, new_key);
134         if (old_circuit != NULL) {
135                 /*
136                  * Yes.  Find the last circuit in the list of circuits
137                  * with this circuit ID, and if its last frame isn't
138                  * known, make it be the previous frame to this one.
139                  */
140                 while (old_circuit->next != NULL)
141                         old_circuit = old_circuit->next;
142                 if (old_circuit->last_frame == 0)
143                         old_circuit->last_frame = first_frame - 1;
144
145                 /*
146                  * Now put the new circuit after the last one in the
147                  * list.
148                  */
149                 old_circuit->next = circuit;
150         } else {
151                 /*
152                  * No.  This is the first one with this circuit ID; add
153                  * it to the hash table.
154                  */
155                 g_hash_table_insert(circuit_hashtable, new_key, circuit);
156         }
157
158         return circuit;
159 }
160
161 /*
162  * Given a circuit type and ID, and a frame number, search for a circuit with
163  * that type and ID whose range of frames includes that frame number.
164  * Returns NULL if not found.
165  */
166 circuit_t *
167 find_circuit(circuit_type ctype, guint32 circuit_id, guint32 frame)
168 {
169         circuit_key key;
170         circuit_t *circuit;
171
172         key.ctype = ctype;
173         key.circuit_id = circuit_id;
174
175         /*
176          * OK, search the list of circuits with that type and ID for
177          * a circuit whose range of frames includes that frame number.
178          */
179         for (circuit = (circuit_t *)g_hash_table_lookup(circuit_hashtable, &key);
180             circuit != NULL; circuit = circuit->next) {
181                 /*
182                  * The circuit includes that frame number if:
183                  *
184                  *      the circuit's first frame is unknown or is at or
185                  *      before that frame
186                  *
187                  * and
188                  *
189                  *      the circuit's last frame is unknown or is at or
190                  *      after that frame.
191                  */
192                 if ((circuit->first_frame == 0 || circuit->first_frame <= frame)
193                     && (circuit->last_frame == 0 || circuit->last_frame >= frame))
194                         break;
195         }
196         return circuit;
197 }
198
199 /*
200  * Set the last frame of a circuit, if it's not already known,
201  * "closing" the circuit.
202  */
203 void
204 close_circuit(circuit_t *circuit, guint32 last_frame)
205 {
206         if (circuit->last_frame == 0)
207                 circuit->last_frame = last_frame;
208 }
209
210 static gint
211 p_compare(gconstpointer a, gconstpointer b)
212 {
213         const circuit_proto_data *ap = (const circuit_proto_data *)a;
214         const circuit_proto_data *bp = (const circuit_proto_data *)b;
215
216         if (ap->proto > bp->proto)
217                 return 1;
218         else if (ap->proto == bp->proto)
219                 return 0;
220         else
221                 return -1;
222 }
223
224 void
225 circuit_add_proto_data(circuit_t *conv, int proto, void *proto_data)
226 {
227         circuit_proto_data *p1 = wmem_new(wmem_file_scope(), circuit_proto_data);
228
229         p1->proto = proto;
230         p1->proto_data = proto_data;
231
232         /* Add it to the list of items for this circuit. */
233
234         conv->data_list = g_slist_insert_sorted(conv->data_list, (gpointer *)p1,
235             p_compare);
236 }
237
238 void *
239 circuit_get_proto_data(circuit_t *conv, int proto)
240 {
241         circuit_proto_data temp, *p1;
242         GSList *item;
243
244         temp.proto = proto;
245         temp.proto_data = NULL;
246
247         item = g_slist_find_custom(conv->data_list, (gpointer *)&temp,
248             p_compare);
249
250         if (item != NULL) {
251                 p1 = (circuit_proto_data *)item->data;
252                 return p1->proto_data;
253         }
254
255         return NULL;
256 }
257
258 void
259 circuit_delete_proto_data(circuit_t *conv, int proto)
260 {
261         circuit_proto_data temp;
262         GSList *item;
263
264         temp.proto = proto;
265         temp.proto_data = NULL;
266
267         item = g_slist_find_custom(conv->data_list, (gpointer *)&temp,
268             p_compare);
269
270         if (item != NULL)
271                 conv->data_list = g_slist_remove(conv->data_list, item);
272 }
273
274 void
275 circuit_set_dissector(circuit_t *circuit, dissector_handle_t handle)
276 {
277         circuit->dissector_handle = handle;
278 }
279
280 dissector_handle_t
281 circuit_get_dissector(circuit_t *circuit)
282 {
283         return circuit->dissector_handle;
284 }
285
286 /*
287  * Given a circuit type and ID for a packet, search for a matching
288  * circuit and, if found and it has a circuit dissector,
289  * call that dissector and return TRUE, otherwise return FALSE.
290  */
291 gboolean
292 try_circuit_dissector(circuit_type ctype, guint32 circuit_id, guint32 frame,
293                       tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
294 {
295         circuit_t *circuit;
296
297         circuit = find_circuit(ctype, circuit_id, frame);
298
299         if (circuit != NULL) {
300                 if (circuit->dissector_handle == NULL)
301                         return FALSE;
302                 call_dissector_with_data(circuit->dissector_handle, tvb, pinfo,
303                     tree, data);
304                 return TRUE;
305         }
306         return FALSE;
307 }
308
309 /*
310  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
311  *
312  * Local variables:
313  * c-basic-offset: 8
314  * tab-width: 8
315  * indent-tabs-mode: t
316  * End:
317  *
318  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
319  * :indentSize=8:tabSize=8:noTabs=false:
320  */