Removed trailing whitespaces from .h and .c files using the
[obnox/wireshark/wip.git] / packet-beep.c
1 /* packet-beep.c
2  * Routines for BEEP packet disassembly
3  *
4  * $Id: packet-beep.c,v 1.10 2002/08/02 23:35:47 jmayer Exp $
5  *
6  * Copyright (c) 2000 by Richard Sharpe <rsharpe@ns.aus.com>
7  * Modified 2001 Darren New <dnew@invisible.net> for BEEP.
8  *
9  * Original BXXP dissector developed with funding from InvisibleWorlds
10  * (www.invisibleworlds.com) via Collab.Net.
11  *
12  * Ethereal - Network traffic analyzer
13  * By Gerald Combs
14  * Copyright 1999 Gerald Combs
15  *
16  * This program is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU General Public License
18  * as published by the Free Software Foundation; either version 2
19  * of the License, or (at your option) any later version.
20  *
21  * This program is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24  * GNU General Public License for more details.
25  *
26  * You should have received a copy of the GNU General Public License
27  * along with this program; if not, write to the Free Software
28  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
29  */
30
31 #ifdef HAVE_CONFIG_H
32 #include "config.h"
33 #endif
34
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <ctype.h>
38 #include <time.h>
39 #include <glib.h>
40 #include <string.h>
41 #include <epan/packet.h>
42 #include <epan/resolv.h>
43 #include "prefs.h"
44 #include <epan/conversation.h>
45
46 #define TCP_PORT_BEEP 10288
47 void proto_reg_handoff_beep(void);
48
49
50 static int global_beep_tcp_port = TCP_PORT_BEEP;
51 static int global_beep_strict_term = TRUE;
52
53 static int proto_beep = -1;
54
55 static int hf_beep_req = -1;
56 static int hf_beep_req_chan = -1;
57 static int hf_beep_rsp_chan = -1;
58 static int hf_beep_seq_chan = -1;
59 static int hf_beep_rsp = -1;
60 static int hf_beep_seq = -1;
61 static int hf_beep_end = -1;
62 static int hf_beep_proto_viol = -1;
63 static int hf_beep_complete = -1;   /* No More data follows */
64 static int hf_beep_intermediate = -1; /* More data follows */
65 static int hf_beep_msgno = -1;
66 static int hf_beep_ansno = -1;
67 static int hf_beep_seqno = -1;
68 static int hf_beep_size = -1;
69 static int hf_beep_channel = -1;
70 static int hf_beep_positive = -1;
71 static int hf_beep_negative = -1;
72 static int hf_beep_ackno = -1;
73 static int hf_beep_window = -1;
74
75 /* Arrays of hf entry pointers for some routines to use. If you want more
76  * hidden items added for a field, add them to the list before the NULL, 
77  * and the various routines that these are passed to will add them.
78  */
79
80 static int *req_msgno_hfa[] = { &hf_beep_msgno, NULL };
81 static int *req_ansno_hfa[] = { &hf_beep_ansno, NULL };
82 static int *req_seqno_hfa[]  = { &hf_beep_seqno, NULL };
83 static int *req_size_hfa[]   = { &hf_beep_size, NULL };
84 static int *req_chan_hfa[]   = { &hf_beep_channel, &hf_beep_req_chan, NULL };
85 /*
86 static int *rsp_msgno_hfa[] = { &hf_beep_msgno, NULL };
87 static int *rsp_seqno_hfa[]  = { &hf_beep_seqno, NULL };
88 static int *rsp_size_hfa[]   = { &hf_beep_size, NULL };
89 */
90 static int *seq_chan_hfa[]   = { &hf_beep_channel, &hf_beep_seq_chan, NULL };
91 static int *seq_ackno_hfa[]  = { &hf_beep_ackno, NULL };
92 static int *seq_window_hfa[] = { &hf_beep_window, NULL };
93
94 static int ett_beep = -1;
95 static int ett_mime_header = -1;
96 static int ett_header = -1;
97 static int ett_trailer = -1;
98
99 static unsigned int tcp_port = 0;
100
101 /* Get the state of the more flag ... */
102
103 #define BEEP_VIOL         0
104 #define BEEP_INTERMEDIATE 1
105 #define BEEP_COMPLETE     2
106
107 /*
108  * Per-frame data
109  *
110  * pl_left is the amount of data in this packet that belongs to another
111  * frame ...
112  * 
113  * It relies on TCP segments not being re-ordered too much ...
114  */
115 struct beep_proto_data {
116   int pl_left;   /* Payload at beginning of frame */
117   int pl_size;   /* Payload in current message ...*/
118   int mime_hdr;  /* Whether we expect a mime header. 1 on first, 0 on rest 
119                   * in a message
120                   */
121 };
122
123 /*
124  * Conversation stuff
125  */
126 static int beep_packet_init_count = 100;
127
128 struct beep_request_key {
129   guint32 conversation;
130 };
131
132 struct beep_request_val {
133   guint16 processed;     /* Have we processed this conversation? */
134   int size;              /* Size of the message                  */
135                          /* We need an indication in each dirn of
136                           * whether on not a mime header is expected 
137                           */
138   int c_mime_hdr, s_mime_hdr;
139 };
140
141 static GHashTable *beep_request_hash = NULL;
142 static GMemChunk  *beep_request_keys = NULL;
143 static GMemChunk  *beep_request_vals = NULL;
144 static GMemChunk  *beep_packet_infos = NULL;
145
146 /* Hash Functions */
147 static gint
148 beep_equal(gconstpointer v, gconstpointer w)
149 {
150   struct beep_request_key *v1 = (struct beep_request_key *)v;
151   struct beep_request_key *v2 = (struct beep_request_key *)w;
152
153 #if defined(DEBUG_BEEP_HASH)
154   printf("Comparing %08X\n      and %08X\n",
155          v1->conversation, v2->conversation);
156 #endif
157
158   if (v1->conversation == v2->conversation)
159     return 1;
160
161   return 0;
162
163 }
164
165 static guint
166 beep_hash(gconstpointer v)
167 {
168   struct beep_request_key *key = (struct beep_request_key *)v;
169   guint val;
170
171   val = key->conversation;
172
173 #if defined(DEBUG_BEEP_HASH)
174   printf("BEEP Hash calculated as %u\n", val);
175 #endif
176
177   return val;
178
179 }
180
181 static void
182 beep_init_protocol(void)
183 {
184 #if defined(DEBUG_BEEP_HASH)
185   fprintf(stderr, "Initializing BEEP hashtable area\n");
186 #endif
187
188   if (beep_request_hash)
189     g_hash_table_destroy(beep_request_hash);
190   if (beep_request_keys)
191     g_mem_chunk_destroy(beep_request_keys);
192   if (beep_request_vals)
193     g_mem_chunk_destroy(beep_request_vals);
194   if (beep_packet_infos)
195     g_mem_chunk_destroy(beep_packet_infos);
196
197   beep_request_hash = g_hash_table_new(beep_hash, beep_equal);
198   beep_request_keys = g_mem_chunk_new("beep_request_keys",
199                                        sizeof(struct beep_request_key),
200                                        beep_packet_init_count * sizeof(struct beep_request_key), G_ALLOC_AND_FREE);
201   beep_request_vals = g_mem_chunk_new("beep_request_vals", 
202                                       sizeof(struct beep_request_val),
203                                       beep_packet_init_count * sizeof(struct beep_request_val), G_ALLOC_AND_FREE);
204   beep_packet_infos = g_mem_chunk_new("beep_packet_infos",
205                                       sizeof(struct beep_proto_data),
206                                       beep_packet_init_count * sizeof(struct beep_proto_data), G_ALLOC_AND_FREE);
207 }
208
209 /*
210  * BEEP routines
211  */
212
213 static int beep_get_more(char more)
214 {
215
216   if (more == '.')
217     return BEEP_COMPLETE;
218   else if (more == '*')
219     return BEEP_INTERMEDIATE;
220
221   return BEEP_VIOL;
222 }
223
224 /* dissect the more flag, and return a value of:
225  *  1 -> more
226  *  0 -> no more
227  *  -1 -> Proto violation
228  */
229
230 static int
231 dissect_beep_more(tvbuff_t *tvb, int offset,
232                   proto_tree *tree)
233 {
234
235
236   switch (beep_get_more(tvb_get_guint8(tvb, offset))) {
237
238   case BEEP_COMPLETE:
239
240     if (tree) {
241       proto_tree_add_boolean_hidden(tree, hf_beep_complete, tvb, offset, 1, TRUE);
242       proto_tree_add_text(tree, tvb, offset, 1, "More: Complete");
243     }
244
245     return 0;
246
247     break;
248
249   case BEEP_INTERMEDIATE:
250
251     if (tree) {
252       proto_tree_add_boolean_hidden(tree, hf_beep_intermediate, tvb, offset, 1, TRUE);
253       proto_tree_add_text(tree, tvb, offset, 1, "More: Intermediate");
254     }
255
256     return 1;
257
258     break;
259
260   default:  
261
262     if (tree) {
263       proto_tree_add_boolean_hidden(tree, hf_beep_proto_viol, tvb, offset, 1, TRUE);
264       proto_tree_add_text(tree, tvb, offset, 1, "PROTOCOL VIOLATION: Expected More Flag (* or .)");
265     }
266
267     return -1;
268
269     break;
270   }
271
272 }
273
274 static void dissect_beep_status(tvbuff_t *tvb, int offset,
275                                 proto_tree *tree)
276 {
277
278   /* FIXME: We should return a value to indicate all OK. */
279   
280   switch(tvb_get_guint8(tvb, offset)) {
281
282   case '+':
283
284     if (tree) {
285       proto_tree_add_boolean_hidden(tree, hf_beep_positive, tvb, offset, 1, TRUE);
286       proto_tree_add_text(tree, tvb, offset, 1, "Status: Positive");
287     }
288
289     break;
290
291   case '-':
292
293     if (tree) {
294       proto_tree_add_boolean_hidden(tree, hf_beep_negative, tvb, offset, 1, TRUE);
295       proto_tree_add_text(tree, tvb, offset, 1, "Status: Negative");
296     }
297
298     break;
299
300   default:  /* Proto violation: FIXME */
301
302     break;
303
304   }
305
306 }
307
308 static int num_len(tvbuff_t *tvb, int offset)
309 {
310   unsigned int i = 0;
311
312   while (isdigit(tvb_get_guint8(tvb, offset + i))) i++;
313
314   return i;
315
316 }
317
318 /*
319  * We check for a terminator. This can be CRLF, which will be recorded
320  * as a terminator, or CR or LF by itself, which will be redorded as
321  * an incorrect terminator ... We build the tree at this point
322  * However, we depend on the variable beep_strict_term
323  */ 
324
325 static int 
326 check_term(tvbuff_t *tvb, int offset, proto_tree *tree)
327 {
328
329   /* First, check for CRLF, or, if global_beep_strict_term is false, 
330    * one of CR or LF ... If neither of these hold, we add an element
331    * that complains of a protocol violation, and return -1, else
332    * we add a terminator to the tree (possibly non-standard) and return
333    * the count of characters we saw ... This may throw off the rest of the 
334    * dissection ... so-be-it!
335    */
336
337   if ((tvb_get_guint8(tvb, offset) == 0x0d && 
338        tvb_get_guint8(tvb, offset + 1) == 0x0a)){ /* Correct terminator */
339
340     if (tree) {
341       proto_tree_add_text(tree, tvb, offset, 2, "Terminator: CRLF");
342     }
343     return 2;
344
345   }
346   else if ((tvb_get_guint8(tvb, offset) == 0x0d) && !global_beep_strict_term) {
347
348     if (tree) {
349       proto_tree_add_text(tree, tvb, offset, 1, "Nonstandard Terminator: CR");
350       proto_tree_add_boolean_hidden(tree, hf_beep_proto_viol, tvb, offset, 1, TRUE);
351     }
352     return 1;
353
354   }
355   else if ((tvb_get_guint8(tvb, offset) == 0x0a) && !global_beep_strict_term) {
356
357     if (tree) {
358       proto_tree_add_text(tree, tvb, offset, 1, "Nonstandard Terminator: LF");
359       proto_tree_add_boolean_hidden(tree, hf_beep_proto_viol, tvb, offset, 1, TRUE);
360     }
361     return 1;
362
363   }
364   else {    
365
366     if (tree) {
367       proto_tree_add_text(tree, tvb, offset, 2, "PROTOCOL VIOLATION, Invalid Terminator: %s", tvb_format_text(tvb, offset, 2));
368       proto_tree_add_boolean_hidden(tree, hf_beep_proto_viol, tvb, offset, 2, TRUE);
369     }
370     return -1;
371
372   }
373
374 }
375
376 /* Get the header length, up to CRLF or CR or LF */
377 static int header_len(tvbuff_t *tvb, int offset)
378 {
379   int i = 0;
380   guint8 sc;
381
382   /* FIXME: Have to make sure we stop looking at the end of the tvb ... */
383
384   /* We look for CRLF, or CR or LF if global_beep_strict_term is 
385    * not set.
386    */
387
388   while (1) {
389
390     if (tvb_ensure_length_remaining(tvb, offset + i) < 1)
391       return i;   /* Not enough characters left ... */
392
393     if ((sc = tvb_get_guint8(tvb, offset + i)) == 0x0d 
394         && tvb_get_guint8(tvb, offset + i + 1) == 0x0a)
395       return i;   /* Done here ... */
396
397     if (!global_beep_strict_term && (sc == 0x0d || sc == 0x0a))
398       return i;   /* Done here also ... */
399           
400     i++;
401
402   }
403 }
404
405 static int
406 dissect_beep_mime_header(tvbuff_t *tvb, int offset, 
407                          struct beep_proto_data *frame_data,
408                          proto_tree *tree)
409 {
410   proto_tree    *ti = NULL, *mime_tree = NULL;
411   int           mime_length = header_len(tvb, offset), cc = 0;
412
413   if (frame_data && !frame_data->mime_hdr) return 0;
414
415   if (tree) {
416
417     /* FIXME: Should calculate the whole length of the mime headers */
418
419     ti = proto_tree_add_text(tree, tvb, offset, mime_length, "Mime header: %s", tvb_format_text(tvb, offset, mime_length));
420     mime_tree = proto_item_add_subtree(ti, ett_mime_header);
421   }
422
423   if (mime_length == 0) { /* Default header */
424
425     if (tree) {
426       proto_tree_add_text(mime_tree, tvb, offset, 0, "Default values");
427     }
428
429     if ((cc = check_term(tvb, offset, mime_tree)) <= 0) {
430
431       /* Ignore it, it will cause funnies in the rest of the dissect */
432
433     }
434
435   }
436   else {  /* FIXME: Process the headers */
437
438     if (tree) {
439       proto_tree_add_text(mime_tree, tvb, offset, mime_length, "Header: %s", 
440                           tvb_format_text(tvb, offset, mime_length));
441     }
442
443     if ((cc = check_term(tvb, offset + mime_length, mime_tree)) <= 0) {
444
445       /* Ignore it, it will cause funnies in the rest of the dissect */
446
447     }
448
449   }
450
451   return mime_length + cc;  /* FIXME: Check that the CRLF is there */
452
453 }
454
455 static int
456 dissect_beep_int(tvbuff_t *tvb, int offset,
457                     proto_tree *tree, int hf, int *val, int *hfa[])
458 {
459   int ival, ind = 0;
460   unsigned int i = num_len(tvb, offset);
461   guint8 int_buff[100];
462
463   memset(int_buff, '\0', sizeof(int_buff));
464
465   tvb_memcpy(tvb, int_buff, offset, MIN(sizeof(int_buff) - 1, i));
466
467   /* XXX - is this still "Dangerous" now that we don't copy to the
468      last byte of "int_buff[]"? */
469   sscanf(int_buff, "%d", &ival);
470
471   if (tree) {
472     proto_tree_add_uint(tree, hf, tvb, offset, i, ival);
473   }
474
475   while (hfa[ind]) {
476
477     proto_tree_add_uint_hidden(tree, *hfa[ind], tvb, offset, i, ival);
478     ind++;
479
480   }
481
482   *val = ival;  /* Return the value */
483
484   return i;
485
486 }
487
488 static void
489 set_mime_hdr_flags(int more, struct beep_request_val *request_val, 
490                    struct beep_proto_data *frame_data, packet_info *pinfo)
491 {
492
493   if (!request_val) return; /* Nothing to do ??? */
494
495   if (pinfo->destport == tcp_port) { /* Going to the server ... client */
496
497     if (request_val->c_mime_hdr) {
498
499       frame_data->mime_hdr = 0;
500
501       if (!more) request_val->c_mime_hdr = 0; 
502
503     }
504     else {
505
506       frame_data->mime_hdr = 1;
507
508       if (more) request_val->c_mime_hdr = 1;
509
510     }
511
512   }
513   else {
514
515     if (request_val->s_mime_hdr) {
516
517       frame_data->mime_hdr = 0;
518
519       if (!more) request_val->s_mime_hdr = 0; 
520
521     }
522     else {
523
524       frame_data->mime_hdr = 1;
525
526       if (more) request_val->s_mime_hdr = 1;
527
528     }
529
530   }
531
532 }
533
534 /* Build the tree
535  *
536  * A return value of <= 0 says we bailed out, skip the rest of this message,
537  * if any.
538  *
539  * A return value > 0 is the count of bytes we consumed ...
540  */
541
542 static int
543 dissect_beep_tree(tvbuff_t *tvb, int offset, packet_info *pinfo, 
544                   proto_tree *tree, struct beep_request_val *request_val, 
545                   struct beep_proto_data *frame_data)
546 {
547   proto_tree     *ti = NULL, *hdr = NULL;
548   int            st_offset, msgno, ansno, seqno, size, channel, ackno, window, cc,
549                  more;
550
551   char * cmd_temp = NULL;
552   int is_ANS = 0;
553   st_offset = offset;
554
555   if (tvb_strneql(tvb, offset, "MSG ", 4) == 0) 
556     cmd_temp = "Command: MSG";
557   if (tvb_strneql(tvb, offset, "RPY ", 4) == 0) 
558     cmd_temp = "Command: RPY";
559   if (tvb_strneql(tvb, offset, "ERR ", 4) == 0) 
560     cmd_temp = "Command: ERR";
561   if (tvb_strneql(tvb, offset, "NUL ", 4) == 0) 
562     cmd_temp = "Command: NUL";
563   if (tvb_strneql(tvb, offset, "ANS ", 4) == 0) {
564     cmd_temp = "Command: ANS";
565     is_ANS = 1;
566   }
567
568   if (cmd_temp != NULL) {
569
570     if (tree) {
571       ti = proto_tree_add_text(tree, tvb, offset, header_len(tvb, offset) + 2, "Header");
572
573       hdr = proto_item_add_subtree(ti, ett_header);
574
575       proto_tree_add_boolean_hidden(hdr, hf_beep_req, tvb, offset, 3, TRUE);
576       proto_tree_add_text(hdr, tvb, offset, 3, cmd_temp);
577     }
578
579     offset += 4;
580
581     /* Get the channel */
582     offset += dissect_beep_int(tvb, offset, hdr, hf_beep_channel, &channel, req_chan_hfa);
583     offset += 1; /* Skip the space */
584       
585     /* Dissect the message number */
586     offset += dissect_beep_int(tvb, offset, hdr, hf_beep_msgno, &msgno, req_msgno_hfa);
587     offset += 1; /* skip the space */
588
589     /* Insert the more elements ... */
590     if ((more = dissect_beep_more(tvb, offset, hdr)) >= 0) {
591       /* Figure out which direction this is in and what mime_hdr flag to 
592        * add to the frame_data. If there are missing segments, this code
593        * will get it wrong!
594        */
595       set_mime_hdr_flags(more, request_val, frame_data, pinfo);
596     }
597     else {  /* Protocol violation, so dissect rest as undisectable */
598       if (tree) {
599         proto_tree_add_text(hdr, tvb, offset, 
600                             tvb_length_remaining(tvb, offset),
601                             "Undissected Payload: %s",
602                             tvb_format_text(tvb, offset,
603                                             tvb_length_remaining(tvb, offset)
604                                             )
605                             );
606
607       }
608       return -1;
609     }
610
611     offset += 2; /* Skip the flag and the space ... */
612
613     /* now for the seqno */
614     offset += dissect_beep_int(tvb, offset, hdr, hf_beep_seqno, &seqno, req_seqno_hfa);
615     offset += 1; /* skip the space */
616
617     offset += dissect_beep_int(tvb, offset, hdr, hf_beep_size, &size, req_size_hfa);
618     if (request_val)   /* FIXME, is this the right order ... */
619       request_val -> size = size;  /* Stash this away */
620     else {
621       frame_data->pl_size = size;
622       if (frame_data->pl_size < 0) frame_data->pl_size = 0; /* FIXME: OK? */
623     }
624     /* offset += 1; skip the space */
625
626     if (is_ANS) { /* We need to put in the ansno */
627         offset += 1; /* skip the space */
628         /* Dissect the message number */
629         offset += dissect_beep_int(tvb, offset, hdr, hf_beep_ansno, &ansno, req_ansno_hfa);
630     }
631
632     if ((cc = check_term(tvb, offset, hdr)) <= 0) {
633
634       /* We dissect the rest as data and bail ... */
635
636       if (tree) {
637         proto_tree_add_text(hdr, tvb, offset, 
638                             tvb_length_remaining(tvb, offset),
639                             "Undissected Payload: %s", 
640                             tvb_format_text(tvb, offset, 
641                                             tvb_length_remaining(tvb, offset)
642                                             )
643                             );
644       }
645
646       return -1;
647
648     }
649
650     offset += cc;
651     
652     /* Insert MIME header ... */
653
654     if (frame_data && frame_data->mime_hdr)
655       offset += dissect_beep_mime_header(tvb, offset, frame_data, hdr);
656
657     /* Now for the payload, if any */
658
659     if (tvb_length_remaining(tvb, offset) > 0) { /* Dissect what is left as payload */
660
661       int pl_size = MIN(size, tvb_length_remaining(tvb, offset));
662
663       /* Except, check the payload length, and only dissect that much */
664
665       /* We need to keep track, in the conversation, of how much is left 
666        * so in the next packet, we can figure out what is part of the payload
667        * and what is the next message
668        */
669
670       if (tree) {
671         proto_tree_add_text(tree, tvb, offset, pl_size, "Payload: %s", tvb_format_text(tvb, offset, pl_size));
672
673       }
674
675       offset += pl_size;
676
677       if (request_val) {
678         request_val->size -= pl_size;
679         if (request_val->size < 0) request_val->size = 0;
680       }
681       else {
682         frame_data->pl_size -= pl_size;
683         if (frame_data->pl_size < 0) frame_data->pl_size = 0;
684       }
685     }
686       
687     /* If anything else left, dissect it ... */
688
689     if (tvb_length_remaining(tvb, offset) > 0)
690       offset += dissect_beep_tree(tvb, offset, pinfo, tree, request_val, frame_data);
691
692   } else if (tvb_strneql(tvb, offset, "SEQ ", 4) == 0) {
693
694     if (tree) {
695       proto_tree_add_boolean_hidden(tree, hf_beep_seq, tvb, offset, 3, TRUE);
696       proto_tree_add_text(tree, tvb, offset, 3, "Command: SEQ");
697     }
698
699     offset += 3;
700
701     /* Now check the space: FIXME */
702
703     offset += 1;
704
705     offset += dissect_beep_int(tvb, offset, tree, hf_beep_channel, &channel, seq_chan_hfa);
706
707     /* Check the space: FIXME */
708
709     offset += 1;
710
711     offset += dissect_beep_int(tvb, offset, tree, hf_beep_ackno, &ackno, seq_ackno_hfa);
712
713     /* Check the space: FIXME */
714
715     offset += 1;
716
717     offset += dissect_beep_int(tvb, offset, tree, hf_beep_window, &window, seq_window_hfa);
718
719     if ((cc = check_term(tvb, offset, tree)) <= 0) {
720
721       /* We dissect the rest as data and bail ... */
722
723       if (tree) {
724         proto_tree_add_text(tree, tvb, offset, 
725                             tvb_length_remaining(tvb, offset),
726                             "Undissected Payload: %s", 
727                             tvb_format_text(tvb, offset, 
728                                             tvb_length_remaining(tvb, offset)
729                                             )
730                             );
731       }
732
733       return -1;
734
735     }
736
737     offset += cc;
738
739   } else if (tvb_strneql(tvb, offset, "END", 3) == 0) {
740
741     proto_tree *tr = NULL;
742
743     if (tree) {
744       ti = proto_tree_add_text(tree, tvb, offset, MIN(5, tvb_length_remaining(tvb, offset)), "Trailer");
745
746       tr = proto_item_add_subtree(ti, ett_trailer);
747
748       proto_tree_add_boolean_hidden(tr, hf_beep_end, tvb, offset, 3, TRUE);
749       proto_tree_add_text(tr, tvb, offset, 3, "Command: END");
750
751     }
752
753     offset += 3;
754
755     if ((cc = check_term(tvb, offset, tr)) <= 0) {
756
757       /* We dissect the rest as data and bail ... */
758
759       if (tree) { 
760         proto_tree_add_text(tr, tvb, offset, tvb_length_remaining(tvb, offset),
761                             "Undissected Payload: %s", 
762                             tvb_format_text(tvb, offset, 
763                                             tvb_length_remaining(tvb, offset)
764                                             )
765                             );
766       }
767
768       return -1;
769
770     }
771
772     offset += cc;
773
774   }
775
776   if (tvb_length_remaining(tvb, offset) > 0) { /* Dissect anything left over */
777
778     int pl_size = 0;
779
780     if (request_val) {
781
782       pl_size = MIN(request_val->size, tvb_length_remaining(tvb, offset));
783
784       if (pl_size == 0) { /* The whole of the rest must be payload */
785       
786         pl_size = tvb_length_remaining(tvb, offset); /* Right place ? */
787       
788       }
789
790     } else if (frame_data) {
791       pl_size = MIN(frame_data->pl_size, tvb_length_remaining(tvb, offset));
792     } else { /* Just in case */
793       pl_size = tvb_length_remaining(tvb, offset);
794     }
795
796     /* Take care here to handle the payload correctly, and if there is 
797      * another message here, then handle it correctly as well.
798      */
799
800     /* If the pl_size == 0 and the offset == 0?, then we have not processed
801      * anything in this frame above, so we better treat all this data as 
802      * payload to avoid recursion loops
803      */
804
805     if (pl_size == 0 && offset == st_offset) 
806       pl_size = tvb_length_remaining(tvb, offset);
807
808     if (pl_size > 0) {
809
810       if (tree) {
811         proto_tree_add_text(tree, tvb, offset, pl_size, "Payload: %s",
812                             tvb_format_text(tvb, offset, pl_size));
813       }
814
815       offset += pl_size;            /* Advance past the payload */
816
817       if (request_val){
818         request_val->size -= pl_size; /* Reduce payload by what we added */
819         if (request_val->size < 0) request_val->size = 0;
820       }
821       else {
822         frame_data->pl_size -= pl_size;
823         if (frame_data->pl_size < 0) frame_data->pl_size = 0;
824       }
825     }
826
827     if (tvb_length_remaining(tvb, offset) > 0) {
828       offset += dissect_beep_tree(tvb, offset, pinfo, tree, request_val, frame_data);
829     }
830   }
831
832   return offset - st_offset;
833
834 }
835
836 static void
837 dissect_beep(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
838 {
839   int offset;
840   struct beep_proto_data  *frame_data = NULL;
841   proto_tree              *beep_tree = NULL, *ti = NULL;
842   conversation_t          *conversation = NULL;
843   struct beep_request_key request_key, *new_request_key;
844   struct beep_request_val *request_val = NULL;
845
846   offset = 0;
847
848   /* If we have per frame data, use that, else, we must have lost the per-
849    * frame data, and we have to do a full dissect pass again.
850    *
851    * The per-frame data tells us how much of this frame is left over from a
852    * previous frame, so we dissect it as payload and then try to dissect the
853    * rest.
854    * 
855    * We use the conversation to build up info on the first pass over the
856    * packets of type BEEP, and record anything that is needed if the user
857    * does random dissects of packets in per packet data.
858    *
859    * Once we have per-packet data, we don't need the conversation stuff 
860    * anymore, but if per-packet data and conversation stuff gets deleted, as 
861    * it does under some circumstances when a rescan is done, it all gets 
862    * rebuilt.
863    */
864
865   /* Find out what conversation this packet is part of ... but only
866    * if we have no information on this packet, so find the per-frame 
867    * info first.
868    */
869
870   frame_data = p_get_proto_data(pinfo->fd, proto_beep);
871
872   if (!frame_data) {
873
874     conversation = find_conversation(&pinfo->src, &pinfo->dst, pinfo->ptype,
875                                        pinfo->srcport, pinfo->destport, 0);
876     if (conversation == NULL) { /* No conversation, create one */
877         conversation = conversation_new(&pinfo->src, &pinfo->dst, pinfo->ptype,
878                                         pinfo->srcport, pinfo->destport, 0);
879
880       }
881
882       /* 
883        * Check for and insert an entry in the request table if does not exist
884        */
885       request_key.conversation = conversation->index;
886
887       request_val = (struct beep_request_val *)g_hash_table_lookup(beep_request_hash, &request_key);
888       
889       if (!request_val) { /* Create one */
890
891         new_request_key = g_mem_chunk_alloc(beep_request_keys);
892         new_request_key->conversation = conversation->index;
893
894         request_val = g_mem_chunk_alloc(beep_request_vals);
895         request_val->processed = 0;
896         request_val->size = 0;
897
898         g_hash_table_insert(beep_request_hash, new_request_key, request_val);
899
900       }
901     }
902
903   if (check_col(pinfo->cinfo, COL_PROTOCOL))
904     col_set_str(pinfo->cinfo, COL_PROTOCOL, "BEEP");
905
906   if (check_col(pinfo->cinfo, COL_INFO)) {  /* Check the type ... */
907
908     /* "tvb_format_text()" is passed a value that won't go past the end
909      * of the packet, so it won't throw an exception. */
910     col_add_str(pinfo->cinfo, COL_INFO, tvb_format_text(tvb, offset, tvb_length_remaining(tvb, offset)));
911
912   }
913
914   /* Here, we parse the message so we can retrieve the info we need, which 
915    * is that there is some payload left from a previous segment on the 
916    * front of this segment ... This all depends on TCP segments not getting
917    * out of order ... 
918    *
919    * As a huge kludge, we push the checking for the tree down into the code
920    * and process as if we were given a tree but not call the routines that
921    * adorn the protocol tree if they were NULL.
922    */
923
924   if (tree) {  /* Build the tree info ... */
925
926     ti = proto_tree_add_item(tree, proto_beep, tvb, offset, -1, FALSE);
927
928     beep_tree = proto_item_add_subtree(ti, ett_beep);
929
930   }
931   
932   /* Check the per-frame data and the conversation for any left-over 
933    * payload from the previous frame 
934    *
935    * We check that per-frame data exists first, and if so, use it,
936    * else we use the conversation data.
937    *
938    * We create per-frame data here as well, but we must ensure we create it
939    * after we have done the check for per-frame or conversation data.
940    *
941    * We also depend on the first frame in a group having a pl_size of 0.
942    */
943
944   if (frame_data && frame_data->pl_left > 0) {
945
946     int pl_left = frame_data->pl_left;
947
948     pl_left = MIN(pl_left, tvb_length_remaining(tvb, offset));
949
950     /* Add the payload bit, only if we have a tree */
951     if (tree) {
952       proto_tree_add_text(beep_tree, tvb, offset, pl_left, "Payload: %s",
953                           tvb_format_text(tvb, offset, pl_left));
954     }
955     offset += pl_left;
956   }
957   else if (request_val && request_val->size > 0) {
958
959     int pl_left = request_val->size;
960
961     request_val->size = 0;
962
963     /* We create the frame data here for this case, and 
964      * elsewhere for other frames
965      */
966
967     frame_data = g_mem_chunk_alloc(beep_packet_infos);
968
969     frame_data->pl_left = pl_left;
970     frame_data->pl_size = 0;
971     frame_data->mime_hdr = 0;
972       
973     p_add_proto_data(pinfo->fd, proto_beep, frame_data);
974
975   }
976
977   /* Set up the per-frame data here if not already done so
978    * This _must_ come after the checks above ...
979    */
980
981   if (frame_data == NULL) { 
982
983     frame_data = g_mem_chunk_alloc(beep_packet_infos);
984
985     frame_data->pl_left = 0;
986     frame_data->pl_size = 0;
987     frame_data->mime_hdr = 0;
988
989     p_add_proto_data(pinfo->fd, proto_beep, frame_data);
990         
991   }
992
993   if (tvb_length_remaining(tvb, offset) > 0) {
994
995     offset += dissect_beep_tree(tvb, offset, pinfo, beep_tree, request_val, frame_data);
996
997   }
998
999 }
1000
1001 /* Register all the bits needed with the filtering engine */
1002
1003 void 
1004 proto_register_beep(void)
1005 {
1006   static hf_register_info hf[] = {
1007     { &hf_beep_proto_viol,
1008       { "Protocol Violation", "beep.violation", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
1009
1010     { &hf_beep_req,
1011       { "Request", "beep.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
1012
1013     { &hf_beep_req_chan,
1014       { "Request Channel Number", "beep.req.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
1015
1016     { &hf_beep_rsp,
1017       { "Response", "beep.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
1018
1019     { &hf_beep_rsp_chan,
1020       { "Response Channel Number", "beep.rsp.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
1021
1022     { &hf_beep_seq,
1023       { "Sequence", "beep.seq", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
1024
1025     { &hf_beep_seq_chan,
1026       { "Sequence Channel Number", "beep.seq.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
1027
1028     { &hf_beep_end,
1029       { "End", "beep.end", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
1030
1031     { &hf_beep_complete,
1032       { "Complete", "beep.more.complete", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
1033
1034     { &hf_beep_intermediate,
1035       { "Intermediate", "beep.more.intermediate", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
1036
1037     { &hf_beep_msgno,
1038       { "Msgno", "beep.msgno", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
1039
1040     { &hf_beep_ansno,
1041       { "Ansno", "beep.ansno", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
1042
1043     { &hf_beep_seqno,
1044       { "Seqno", "beep.seqno", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
1045
1046     { &hf_beep_size,
1047       { "Size", "beep.size", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
1048
1049     { &hf_beep_channel,
1050       { "Channel", "beep.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
1051
1052     { &hf_beep_negative,
1053       { "Negative", "beep.status.negative", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
1054
1055     { &hf_beep_positive,
1056       { "Positive", "beep.status.positive", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
1057
1058     { &hf_beep_ackno,
1059       { "Ackno", "beep.seq.ackno", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
1060
1061     { &hf_beep_window,
1062       { "Window", "beep.seq.window", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
1063
1064   };
1065   static gint *ett[] = {
1066     &ett_beep,
1067     &ett_mime_header,
1068     &ett_header,
1069     &ett_trailer,
1070   };
1071   module_t *beep_module; 
1072
1073   proto_beep = proto_register_protocol("Blocks Extensible Exchange Protocol",
1074                                        "BEEP", "beep");
1075
1076   proto_register_field_array(proto_beep, hf, array_length(hf));
1077   proto_register_subtree_array(ett, array_length(ett));
1078   register_init_routine(&beep_init_protocol);
1079
1080   /* Register our configuration options for BEEP, particularly our port */
1081
1082   beep_module = prefs_register_protocol(proto_beep, proto_reg_handoff_beep);
1083
1084   prefs_register_uint_preference(beep_module, "tcp.port", "BEEP TCP Port",
1085                                  "Set the port for BEEP messages (if other"
1086                                  " than the default of 10288)",
1087                                  10, &global_beep_tcp_port);
1088
1089   prefs_register_bool_preference(beep_module, "strict_header_terminator", 
1090                                  "BEEP Header Requires CRLF", 
1091                                  "Specifies that BEEP requires CRLF as a "
1092                                  "terminator, and not just CR or LF",
1093                                  &global_beep_strict_term);
1094 }
1095
1096 /* The registration hand-off routine */
1097 void
1098 proto_reg_handoff_beep(void)
1099 {
1100   static int beep_prefs_initialized = FALSE;
1101   static dissector_handle_t beep_handle;
1102
1103   if (!beep_prefs_initialized) {
1104
1105     beep_handle = create_dissector_handle(dissect_beep, proto_beep);
1106
1107     beep_prefs_initialized = TRUE;
1108
1109   }
1110   else {
1111
1112     dissector_delete("tcp.port", tcp_port, beep_handle);
1113
1114   }
1115
1116   /* Set our port number for future use */
1117
1118   tcp_port = global_beep_tcp_port;
1119
1120   dissector_add("tcp.port", global_beep_tcp_port, beep_handle);
1121
1122 }