Commit | Line | Data |
---|---|---|
165db1a8 | 1 | /* -*-c-*- |
2 | * | |
28461f0e | 3 | * TrIPE protocol dissector for Wireshark |
165db1a8 | 4 | * |
5 | * (c) 2003 Straylight/Edgeware | |
6 | */ | |
7 | ||
e04c2d50 | 8 | /*----- Licensing notice --------------------------------------------------* |
165db1a8 | 9 | * |
10 | * This file is part of Trivial IP Encryption (TrIPE). | |
11 | * | |
12 | * TrIPE is free software; you can redistribute it and/or modify | |
13 | * it under the terms of the GNU General Public License as published by | |
14 | * the Free Software Foundation; either version 2 of the License, or | |
15 | * (at your option) any later version. | |
e04c2d50 | 16 | * |
165db1a8 | 17 | * TrIPE is distributed in the hope that it will be useful, |
18 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
20 | * GNU General Public License for more details. | |
e04c2d50 | 21 | * |
165db1a8 | 22 | * You should have received a copy of the GNU General Public License |
23 | * along with TrIPE; if not, write to the Free Software Foundation, | |
24 | * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
25 | */ | |
26 | ||
165db1a8 | 27 | /*----- Header files ------------------------------------------------------*/ |
28 | ||
29 | #include "config.h" | |
30 | ||
31 | #include <stdio.h> | |
32 | #include <stdlib.h> | |
33 | #include <string.h> | |
34 | ||
35 | #include <netinet/in.h> | |
36 | ||
37 | #include <glib.h> | |
38 | #include <gmodule.h> | |
28461f0e MW |
39 | #include <wireshark/config.h> |
40 | #include <wireshark/epan/packet.h> | |
41 | #include <wireshark/epan/prefs.h> | |
165db1a8 | 42 | |
78698994 | 43 | #include "protocol.h" |
165db1a8 | 44 | |
45 | /*----- Static variables --------------------------------------------------*/ | |
46 | ||
47 | static int proto_tripe = -1; | |
48 | ||
b5c45da1 | 49 | static guint hashsz = 20, tagsz = 10, ivsz = 8; |
50 | ||
52c03a2a | 51 | typedef struct hfmp { |
52 | int hf, hf_len, hf_val, tt; | |
53 | } hfmp; | |
54 | typedef struct hfge { | |
55 | int hf, hf_len, hf_val, hfx_len, hfx_val, hfy_len, hfy_val, tt; | |
56 | } hfge; | |
165db1a8 | 57 | |
58 | static int hf_tripe_cat = -1; | |
59 | static int hf_tripe_packet_type = -1; | |
60 | static int hf_tripe_ct = -1; | |
61 | static int hf_tripe_ct_seq = -1; | |
62 | static int hf_tripe_ct_iv = -1; | |
b5c45da1 | 63 | static int hf_tripe_ct_ct = -1; |
64 | static int hf_tripe_ct_tag = -1; | |
0ba8de86 | 65 | static int hf_tripe_misc_type = -1; |
66 | static int hf_tripe_misc_payload = -1; | |
165db1a8 | 67 | static int hf_tripe_kx_type = -1; |
52c03a2a | 68 | static hfge hf_tripe_kx_mychal = { -1, -1, -1, -1, -1, -1, -1, -1 }; |
165db1a8 | 69 | static int hf_tripe_kx_mycookie = -1; |
70 | static int hf_tripe_kx_yourcookie = -1; | |
71 | static hfmp hf_tripe_kx_check = { -1, -1, -1, -1 }; | |
72 | static int hf_tripe_huh = -1; | |
73 | ||
74 | static int tt_tripe = -1; | |
75 | static int tt_tripe_ct = -1; | |
76 | ||
77 | G_MODULE_EXPORT const gchar version[] = VERSION; | |
78 | ||
79 | /*----- Main code ---------------------------------------------------------*/ | |
80 | ||
b5c45da1 | 81 | static void prefcb(void) { } |
82 | ||
165db1a8 | 83 | static gint gethash(proto_tree *tt, int hf, tvbuff_t *b, gint off) |
84 | { | |
b5c45da1 | 85 | proto_tree_add_item(tt, hf, b, off, hashsz, FALSE); |
e04c2d50 | 86 | return (off + hashsz); |
165db1a8 | 87 | } |
88 | ||
89 | static gint getmp(proto_tree *tt, const hfmp *hf, tvbuff_t *b, gint off) | |
90 | { | |
91 | guint16 len = tvb_get_ntohs(b, off); | |
92 | proto_item *ti = proto_tree_add_item(tt, hf->hf, b, off, len + 2, FALSE); | |
93 | tt = proto_item_add_subtree(ti, hf->tt); | |
94 | proto_tree_add_item(tt, hf->hf_len, b, off, 2, FALSE); | |
95 | proto_tree_add_item(tt, hf->hf_val, b, off + 2, len, FALSE); | |
96 | return (off + 2 + len); | |
97 | } | |
98 | ||
52c03a2a | 99 | static gint getge(proto_tree *tt, const hfge *hf, tvbuff_t *b, gint off) |
100 | { | |
101 | guint16 len = tvb_get_ntohs(b, off), len2; | |
102 | guint r; | |
103 | proto_item *ti; | |
104 | r = tvb_length_remaining(b, off); | |
105 | if (r < 4 + len || | |
106 | (len2 = tvb_get_ntohs(b, off + 2 + len), r < 4 + len + len2)) { | |
107 | ti = proto_tree_add_item(tt, hf->hf, b, off, len + 2, FALSE); | |
108 | tt = proto_item_add_subtree(ti, hf->tt); | |
109 | proto_tree_add_item(tt, hf->hf_len, b, off, 2, FALSE); | |
110 | proto_tree_add_item(tt, hf->hf_val, b, off + 2, len, FALSE); | |
111 | r = off + len + 2; | |
112 | } else { | |
113 | ti = proto_tree_add_item(tt, hf->hf, b, off, len + len2 + 4, FALSE); | |
114 | tt = proto_item_add_subtree(ti, hf->tt); | |
115 | proto_tree_add_item(tt, hf->hfx_len, b, off, 2, FALSE); | |
116 | proto_tree_add_item(tt, hf->hfx_val, b, off + 2, len, FALSE); | |
117 | proto_tree_add_item(tt, hf->hfy_len, b, off + 2 + len, 2, FALSE); | |
118 | proto_tree_add_item(tt, hf->hfy_val, b, off + 4 + len, len2, FALSE); | |
119 | r = off + len + len2 + 4; | |
e04c2d50 | 120 | } |
52c03a2a | 121 | return (r); |
122 | } | |
123 | ||
165db1a8 | 124 | static void dissect_tripe(tvbuff_t *b, packet_info *p, proto_tree *t) |
125 | { | |
126 | proto_item *ti; | |
127 | proto_tree *tt; | |
128 | guint8 ty; | |
3cdc3f3a | 129 | gint off = 0; |
165db1a8 | 130 | guint32 seq; |
131 | ||
132 | /* --- Initialize the summary cells --- */ | |
133 | ||
6a3500e3 MW |
134 | col_set_str(p->cinfo, COL_PROTOCOL, "TrIPE"); |
135 | col_clear(p->cinfo, COL_INFO); | |
165db1a8 | 136 | ty = tvb_get_guint8(b, 0); |
6a3500e3 MW |
137 | col_clear(p->cinfo, COL_INFO); |
138 | switch (ty & MSG_CATMASK) { | |
139 | case MSG_PACKET: | |
140 | switch (ty & MSG_TYPEMASK) { | |
141 | case 0: | |
142 | col_set_str(p->cinfo, COL_INFO, "Packet data"); | |
143 | break; | |
144 | default: | |
145 | col_add_fstr(p->cinfo, COL_INFO, | |
146 | "Packet data, unknown type code %u", | |
147 | ty & MSG_TYPEMASK); | |
148 | break; | |
149 | } | |
150 | break; | |
151 | case MSG_KEYEXCH: | |
152 | switch (ty & MSG_TYPEMASK) { | |
153 | case KX_PRECHAL: | |
154 | col_set_str(p->cinfo, COL_INFO, "Key exchange, prechallenge"); | |
155 | break; | |
156 | case KX_CHAL: | |
157 | col_set_str(p->cinfo, COL_INFO, "Key exchange, challenge"); | |
158 | break; | |
159 | case KX_REPLY: | |
160 | col_set_str(p->cinfo, COL_INFO, "Key exchange, reply"); | |
161 | break; | |
162 | case KX_SWITCH: | |
163 | col_set_str(p->cinfo, COL_INFO, "Key exchange, switch request"); | |
164 | break; | |
165 | case KX_SWITCHOK: | |
166 | col_set_str(p->cinfo, COL_INFO, "Key exchange, switch response"); | |
167 | break; | |
168 | default: | |
169 | col_add_fstr(p->cinfo, COL_INFO, | |
170 | "Key exchange, unknown type code %u", | |
171 | ty & MSG_TYPEMASK); | |
172 | break; | |
173 | } | |
174 | break; | |
175 | case MSG_MISC: | |
176 | switch (ty & MSG_TYPEMASK) { | |
177 | case MISC_NOP: | |
178 | col_set_str(p->cinfo, COL_INFO, "Miscellaneous, no-operation"); | |
179 | break; | |
180 | case MISC_PING: | |
181 | col_set_str(p->cinfo, COL_INFO, "Miscellaneous, transport ping"); | |
182 | break; | |
183 | case MISC_PONG: | |
184 | col_set_str(p->cinfo, COL_INFO, | |
185 | "Miscellaneous, transport ping reply"); | |
186 | break; | |
187 | case MISC_EPING: | |
188 | col_set_str(p->cinfo, COL_INFO, "Miscellaneous, encrypted ping"); | |
189 | break; | |
190 | case MISC_EPONG: | |
191 | col_set_str(p->cinfo, COL_INFO, | |
192 | "Miscellaneous, encrypted ping reply"); | |
193 | break; | |
194 | case MISC_GREET: | |
195 | col_set_str(p->cinfo, COL_INFO, | |
196 | "Miscellaneous, greeting"); | |
197 | break; | |
198 | default: | |
199 | col_add_fstr(p->cinfo, COL_INFO, | |
200 | "Miscellaneous, unknown type code %u", | |
201 | ty & MSG_TYPEMASK); | |
202 | break; | |
203 | } | |
204 | break; | |
205 | default: | |
206 | col_add_fstr(p->cinfo, COL_INFO, | |
207 | "Unknown category code %u, unknown type code %u", | |
208 | ty & MSG_CATMASK, ty & MSG_TYPEMASK); | |
209 | break; | |
165db1a8 | 210 | } |
211 | ||
212 | /* --- Fill in the tree --- */ | |
213 | ||
214 | if (t) { | |
215 | ti = proto_tree_add_item(t, proto_tripe, b, 0, -1, FALSE); | |
216 | tt = proto_item_add_subtree(ti, tt_tripe); | |
217 | ||
218 | proto_tree_add_item(tt, hf_tripe_cat, b, 0, 1, FALSE); | |
219 | ||
220 | off = 1; | |
221 | switch (ty & MSG_CATMASK) { | |
222 | case MSG_PACKET: | |
223 | proto_tree_add_item(tt, hf_tripe_packet_type, b, 0, 1, FALSE); | |
224 | switch (ty & MSG_TYPEMASK) { | |
225 | case 0: | |
226 | goto ct; | |
227 | default: | |
228 | goto huh; | |
229 | } | |
230 | break; | |
231 | case MSG_KEYEXCH: | |
232 | proto_tree_add_item(tt, hf_tripe_kx_type, b, 0, 1, FALSE); | |
233 | switch (ty & MSG_TYPEMASK) { | |
234 | case KX_PRECHAL: | |
52c03a2a | 235 | off = getge(tt, &hf_tripe_kx_mychal, b, off); |
165db1a8 | 236 | goto tail; |
165db1a8 | 237 | case KX_CHAL: |
52c03a2a | 238 | off = getge(tt, &hf_tripe_kx_mychal, b, off); |
165db1a8 | 239 | off = gethash(tt, hf_tripe_kx_yourcookie, b, off); |
240 | off = getmp(tt, &hf_tripe_kx_check, b, off); | |
241 | goto tail; | |
242 | case KX_REPLY: | |
28461f0e | 243 | off = getge(tt, &hf_tripe_kx_mychal, b, off); |
165db1a8 | 244 | off = gethash(tt, hf_tripe_kx_yourcookie, b, off); |
245 | off = getmp(tt, &hf_tripe_kx_check, b, off); | |
246 | goto ct; | |
247 | case KX_SWITCH: | |
248 | off = gethash(tt, hf_tripe_kx_mycookie, b, off); | |
249 | off = gethash(tt, hf_tripe_kx_yourcookie, b, off); | |
250 | goto ct; | |
251 | case KX_SWITCHOK: | |
252 | goto ct; | |
253 | default: | |
254 | goto huh; | |
255 | } | |
256 | break; | |
0ba8de86 | 257 | case MSG_MISC: |
258 | proto_tree_add_item(tt, hf_tripe_misc_type, b, 0, 1, FALSE); | |
259 | switch (ty & MSG_TYPEMASK) { | |
260 | case MISC_NOP: | |
261 | case MISC_PING: | |
262 | case MISC_PONG: | |
37941236 | 263 | case MISC_GREET: |
0ba8de86 | 264 | proto_tree_add_item(tt, hf_tripe_misc_payload, |
265 | b, off, -1, FALSE); | |
266 | goto done; | |
267 | case MISC_EPING: | |
268 | case MISC_EPONG: | |
269 | goto ct; | |
270 | default: | |
271 | goto huh; | |
272 | } | |
273 | break; | |
165db1a8 | 274 | default: |
275 | goto huh; | |
276 | } | |
277 | tail: | |
278 | if (tvb_offset_exists(b, off)) | |
279 | goto huh; | |
280 | goto done; | |
281 | huh: | |
282 | proto_tree_add_item(tt, hf_tripe_huh, b, off, -1, FALSE); | |
283 | goto done; | |
284 | ct: | |
285 | ti = proto_tree_add_item(tt, hf_tripe_ct, b, off, -1, FALSE); | |
b5c45da1 | 286 | seq = tvb_get_ntohl(b, off + tagsz); |
165db1a8 | 287 | proto_item_set_text(ti, "Encrypted ciphertext (sequence number %lu)", |
288 | (unsigned long)seq); | |
289 | tt = proto_item_add_subtree(ti, tt_tripe_ct); | |
b5c45da1 | 290 | if (tagsz) { |
291 | proto_tree_add_item(tt, hf_tripe_ct_tag, b, off, tagsz, FALSE); | |
292 | off += tagsz; | |
293 | } | |
165db1a8 | 294 | proto_tree_add_item(tt, hf_tripe_ct_seq, b, off, 4, FALSE); |
295 | off += 4; | |
b5c45da1 | 296 | if (ivsz) { |
297 | proto_tree_add_item(tt, hf_tripe_ct_iv, b, off, ivsz, FALSE); | |
298 | off += ivsz; | |
299 | } | |
300 | proto_tree_add_item(ti, hf_tripe_ct_ct, b, off, -1, FALSE); | |
165db1a8 | 301 | goto done; |
302 | done:; | |
e04c2d50 | 303 | } |
165db1a8 | 304 | } |
305 | ||
306 | void proto_register_tripe(void) | |
307 | { | |
b5c45da1 | 308 | module_t *mod; |
309 | ||
165db1a8 | 310 | static value_string vs_kxtype[] = { |
311 | { KX_PRECHAL, "KX_PRECHAL (prechallenge)" }, | |
165db1a8 | 312 | { KX_CHAL, "KX_CHAL (challenge)" }, |
313 | { KX_REPLY, "KX_REPLY (reply)" }, | |
314 | { KX_SWITCH, "KX_SWITCH (switch request)" }, | |
315 | { KX_SWITCHOK, "KX_SWITCHOK (switch response)" }, | |
316 | { 0, 0 } | |
317 | }; | |
318 | ||
319 | static hf_register_info hfs[] = { | |
3cdc3f3a | 320 | { &hf_tripe_cat, { |
165db1a8 | 321 | "Message category", "tripe.cat", |
322 | FT_UINT8, BASE_HEX, 0, MSG_CATMASK | |
3cdc3f3a | 323 | } }, |
324 | { &hf_tripe_packet_type, { | |
165db1a8 | 325 | "Packet message type", "tripe.packet.type", |
326 | FT_UINT8, BASE_HEX, 0, MSG_TYPEMASK, | |
327 | "This is the TrIPE packet type subcode." | |
3cdc3f3a | 328 | } }, |
329 | { &hf_tripe_ct, { | |
165db1a8 | 330 | "Encrypted ciphertext", "tripe.ct", |
331 | FT_BYTES, BASE_NONE, 0, 0, | |
332 | "This is an encrypted message." | |
3cdc3f3a | 333 | } }, |
334 | { &hf_tripe_ct_seq, { | |
165db1a8 | 335 | "Ciphertext sequence number", "tripe.ct.seq", |
336 | FT_UINT32, BASE_DEC, 0, 0, | |
337 | "This is the unique sequence number for the ciphertext." | |
3cdc3f3a | 338 | } }, |
339 | { &hf_tripe_ct_iv, { | |
165db1a8 | 340 | "Ciphertext initialization vector", "tripe.ct.iv", |
341 | FT_BYTES, BASE_NONE, 0, 0, | |
342 | "This is the initialization vector used for the actual encryption." | |
3cdc3f3a | 343 | } }, |
344 | { &hf_tripe_ct_ct, { | |
b5c45da1 | 345 | "Actual encrypted data", "tripe.ct.ct", |
165db1a8 | 346 | FT_BYTES, BASE_NONE, 0, 0, |
b5c45da1 | 347 | "This is the encrypted message. Reading it ought to be hard." |
3cdc3f3a | 348 | } }, |
349 | { &hf_tripe_ct_tag, { | |
b5c45da1 | 350 | "Message authentication code", "tripe.ct.tag", |
165db1a8 | 351 | FT_BYTES, BASE_NONE, 0, 0, |
b5c45da1 | 352 | "This is the message authentication code tag for the ciphertext." |
3cdc3f3a | 353 | } }, |
0ba8de86 | 354 | { &hf_tripe_misc_type, { |
355 | "Miscellaneous message type", "tripe.misc.type", | |
356 | FT_UINT8, BASE_HEX, 0, MSG_TYPEMASK, | |
357 | "This is the TrIPE miscellaneous message type subcode." | |
358 | } }, | |
359 | { &hf_tripe_misc_payload, { | |
37941236 | 360 | "Miscellaneous message payload", "tripe.misc.payload", |
0ba8de86 | 361 | FT_BYTES, BASE_NONE, 0, 0, |
362 | "This is the miscellaneous message payload." | |
363 | } }, | |
3cdc3f3a | 364 | { &hf_tripe_kx_type, { |
165db1a8 | 365 | "Key-exchange message type", "tripe.kx.type", |
366 | FT_UINT8, BASE_HEX, vs_kxtype, MSG_TYPEMASK, | |
367 | "This is the TrIPE key-exchange type subcode." | |
3cdc3f3a | 368 | } }, |
369 | { &hf_tripe_kx_mychal.hf, { | |
165db1a8 | 370 | "Sender's challenge data", "tripe.kx.mychal", |
371 | FT_BYTES, BASE_NONE, 0, 0, | |
52c03a2a | 372 | "This is the sender's challenge." |
3cdc3f3a | 373 | } }, |
374 | { &hf_tripe_kx_mychal.hf_len, { | |
165db1a8 | 375 | "Challenge length", "tripe.kx.mychal.len", |
376 | FT_UINT16, BASE_DEC, 0, 0, | |
52c03a2a | 377 | "This is the length of the sender's challenge." |
3cdc3f3a | 378 | } }, |
379 | { &hf_tripe_kx_mychal.hf_val, { | |
52c03a2a | 380 | "Challenge", "tripe.kx.mychal.val", |
381 | FT_BYTES, BASE_NONE, 0, 0, | |
382 | "This is the value of the sender's challenge." | |
3cdc3f3a | 383 | } }, |
384 | { &hf_tripe_kx_mychal.hfx_len, { | |
52c03a2a | 385 | "Challenge x length", "tripe.kx.mychal.x.len", |
386 | FT_UINT16, BASE_DEC, 0, 0, | |
387 | "This is the length of the sender's challenge x-coordinate." | |
3cdc3f3a | 388 | } }, |
e94fafe4 | 389 | { &hf_tripe_kx_mychal.hfx_val, { |
52c03a2a | 390 | "Challenge x value", "tripe.kx.mychal.x.val", |
391 | FT_BYTES, BASE_NONE, 0, 0, | |
392 | "This is the value of the sender's challenge x-coordinate." | |
3cdc3f3a | 393 | } }, |
394 | { &hf_tripe_kx_mychal.hfy_len, { | |
52c03a2a | 395 | "Challenge y length", "tripe.kx.mychal.y.len", |
396 | FT_UINT16, BASE_DEC, 0, 0, | |
397 | "This is the length of the sender's challenge x-coordinate." | |
3cdc3f3a | 398 | } }, |
e94fafe4 | 399 | { &hf_tripe_kx_mychal.hfy_val, { |
52c03a2a | 400 | "Challenge y value", "tripe.kx.mychal.y.val", |
165db1a8 | 401 | FT_BYTES, BASE_NONE, 0, 0, |
52c03a2a | 402 | "This is the value of the sender's challenge x-coordinate." |
3cdc3f3a | 403 | } }, |
404 | { &hf_tripe_kx_mycookie, { | |
165db1a8 | 405 | "Sender's hashed cookie", "tripe.kx.mycookie", |
406 | FT_BYTES, BASE_NONE, 0, 0, | |
407 | "This is the hash of the sender's challenge." | |
3cdc3f3a | 408 | } }, |
409 | { &hf_tripe_kx_yourcookie, { | |
165db1a8 | 410 | "Recipient's hashed cookie", "tripe.kx.yourcookie", |
411 | FT_BYTES, BASE_NONE, 0, 0, | |
412 | "This is the hash of the recipient's challenge." | |
3cdc3f3a | 413 | } }, |
414 | { &hf_tripe_kx_check.hf, { | |
165db1a8 | 415 | "Challenge check-value", "tripe.kx.check", |
416 | FT_BYTES, BASE_NONE, 0, 0, | |
417 | "This is an encrypted check-value which proves that the sender " | |
418 | "knows the answer to the challenge, and that it is therefore honest." | |
3cdc3f3a | 419 | } }, |
420 | { &hf_tripe_kx_check.hf_len, { | |
165db1a8 | 421 | "Check-value length", "tripe.kx.check.len", |
422 | FT_UINT16, BASE_DEC, 0, 0, | |
423 | "This is the length of the encrypted check-value." | |
3cdc3f3a | 424 | } }, |
425 | { &hf_tripe_kx_check.hf_val, { | |
165db1a8 | 426 | "Check-value data", "tripe.kx.check.val", |
427 | FT_BYTES, BASE_NONE, 0, 0, | |
428 | "This is the actual encrypted check-value." | |
3cdc3f3a | 429 | } }, |
430 | { &hf_tripe_huh, { | |
165db1a8 | 431 | "Unknown data", "tripe.huh", |
432 | FT_BYTES, BASE_NONE, 0, 0, | |
433 | "I don't know what's meant to appear here." | |
3cdc3f3a | 434 | } }, |
165db1a8 | 435 | }; |
436 | ||
437 | static gint *tts[] = { | |
438 | &tt_tripe, | |
439 | &tt_tripe_ct, | |
440 | &hf_tripe_kx_mychal.tt, | |
441 | &hf_tripe_kx_check.tt, | |
442 | }; | |
443 | ||
444 | proto_tripe = proto_register_protocol("TrIPE", "TrIPE", "tripe"); | |
445 | proto_register_field_array(proto_tripe, hfs, array_length(hfs)); | |
446 | proto_register_subtree_array(tts, array_length(tts)); | |
b5c45da1 | 447 | |
448 | mod = prefs_register_protocol(proto_tripe, prefcb); | |
449 | prefs_register_uint_preference(mod, "hashsz", "Hash length", | |
450 | "hash function output length (in octets)", | |
451 | 10, &hashsz); | |
452 | prefs_register_uint_preference(mod, "tagsz", "MAC tag length", | |
453 | "MAC tag length (in octets)", 10, &tagsz); | |
454 | prefs_register_uint_preference(mod, "ivsz", "IV length", | |
455 | "block cipher initialization vector length" | |
456 | " (in octets)", | |
457 | 10, &ivsz); | |
165db1a8 | 458 | } |
459 | ||
460 | void proto_reg_handoff_tripe(void) | |
461 | { | |
462 | dissector_handle_t dh; | |
463 | ||
464 | dh = create_dissector_handle(dissect_tripe, proto_tripe); | |
6a3500e3 | 465 | dissector_add_uint("udp.port", TRIPE_PORT, dh); |
165db1a8 | 466 | } |
467 | ||
468 | G_MODULE_EXPORT void plugin_reg_handoff(void) | |
469 | { | |
470 | proto_reg_handoff_tripe(); | |
471 | } | |
472 | ||
3cdc3f3a | 473 | G_MODULE_EXPORT void plugin_register(void) |
165db1a8 | 474 | { |
165db1a8 | 475 | if (proto_tripe == -1) |
476 | proto_register_tripe(); | |
477 | } | |
478 | ||
479 | /*----- That's all, folks -------------------------------------------------*/ |