2001-12-08 01:45:36 +00:00
|
|
|
/* packet-beep.c
|
|
|
|
* Routines for BEEP packet disassembly
|
2000-08-30 12:42:31 +00:00
|
|
|
*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
2000-08-30 12:42:31 +00:00
|
|
|
*
|
|
|
|
* Copyright (c) 2000 by Richard Sharpe <rsharpe@ns.aus.com>
|
2001-12-08 01:45:36 +00:00
|
|
|
* Modified 2001 Darren New <dnew@invisible.net> for BEEP.
|
2000-08-30 12:42:31 +00:00
|
|
|
*
|
2001-12-08 01:45:36 +00:00
|
|
|
* Original BXXP dissector developed with funding from InvisibleWorlds
|
|
|
|
* (www.invisibleworlds.com) via Collab.Net.
|
2000-10-09 03:36:15 +00:00
|
|
|
*
|
2000-08-30 12:42:31 +00:00
|
|
|
* Ethereal - Network traffic analyzer
|
|
|
|
* By Gerald Combs
|
|
|
|
* Copyright 1999 Gerald Combs
|
2001-12-08 01:45:36 +00:00
|
|
|
*
|
2000-08-30 12:42:31 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <glib.h>
|
|
|
|
#include <string.h>
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/packet.h>
|
2004-08-06 19:57:49 +00:00
|
|
|
#include <epan/addr_resolv.h>
|
2000-08-30 12:42:31 +00:00
|
|
|
#include "prefs.h"
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/conversation.h>
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
#define TCP_PORT_BEEP 10288
|
|
|
|
void proto_reg_handoff_beep(void);
|
|
|
|
|
|
|
|
|
|
|
|
static int global_beep_tcp_port = TCP_PORT_BEEP;
|
|
|
|
static int global_beep_strict_term = TRUE;
|
|
|
|
|
|
|
|
static int proto_beep = -1;
|
|
|
|
|
|
|
|
static int hf_beep_req = -1;
|
|
|
|
static int hf_beep_req_chan = -1;
|
|
|
|
static int hf_beep_rsp_chan = -1;
|
|
|
|
static int hf_beep_seq_chan = -1;
|
|
|
|
static int hf_beep_rsp = -1;
|
|
|
|
static int hf_beep_seq = -1;
|
|
|
|
static int hf_beep_end = -1;
|
|
|
|
static int hf_beep_proto_viol = -1;
|
|
|
|
static int hf_beep_complete = -1; /* No More data follows */
|
|
|
|
static int hf_beep_intermediate = -1; /* More data follows */
|
|
|
|
static int hf_beep_msgno = -1;
|
|
|
|
static int hf_beep_ansno = -1;
|
|
|
|
static int hf_beep_seqno = -1;
|
|
|
|
static int hf_beep_size = -1;
|
|
|
|
static int hf_beep_channel = -1;
|
|
|
|
static int hf_beep_positive = -1;
|
|
|
|
static int hf_beep_negative = -1;
|
|
|
|
static int hf_beep_ackno = -1;
|
|
|
|
static int hf_beep_window = -1;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
/* Arrays of hf entry pointers for some routines to use. If you want more
|
2002-08-28 21:04:11 +00:00
|
|
|
* hidden items added for a field, add them to the list before the NULL,
|
2000-10-02 01:44:58 +00:00
|
|
|
* and the various routines that these are passed to will add them.
|
|
|
|
*/
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
static int *req_msgno_hfa[] = { &hf_beep_msgno, NULL };
|
|
|
|
static int *req_ansno_hfa[] = { &hf_beep_ansno, NULL };
|
|
|
|
static int *req_seqno_hfa[] = { &hf_beep_seqno, NULL };
|
|
|
|
static int *req_size_hfa[] = { &hf_beep_size, NULL };
|
|
|
|
static int *req_chan_hfa[] = { &hf_beep_channel, &hf_beep_req_chan, NULL };
|
|
|
|
/*
|
|
|
|
static int *rsp_msgno_hfa[] = { &hf_beep_msgno, NULL };
|
|
|
|
static int *rsp_seqno_hfa[] = { &hf_beep_seqno, NULL };
|
|
|
|
static int *rsp_size_hfa[] = { &hf_beep_size, NULL };
|
|
|
|
*/
|
|
|
|
static int *seq_chan_hfa[] = { &hf_beep_channel, &hf_beep_seq_chan, NULL };
|
|
|
|
static int *seq_ackno_hfa[] = { &hf_beep_ackno, NULL };
|
|
|
|
static int *seq_window_hfa[] = { &hf_beep_window, NULL };
|
|
|
|
|
|
|
|
static int ett_beep = -1;
|
2000-08-30 12:42:31 +00:00
|
|
|
static int ett_mime_header = -1;
|
|
|
|
static int ett_header = -1;
|
|
|
|
static int ett_trailer = -1;
|
|
|
|
|
2001-04-27 01:27:37 +00:00
|
|
|
static unsigned int tcp_port = 0;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
/* Get the state of the more flag ... */
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
#define BEEP_VIOL 0
|
|
|
|
#define BEEP_INTERMEDIATE 1
|
|
|
|
#define BEEP_COMPLETE 2
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-09-08 06:19:37 +00:00
|
|
|
/*
|
|
|
|
* Per-frame data
|
2000-09-12 02:24:19 +00:00
|
|
|
*
|
|
|
|
* pl_left is the amount of data in this packet that belongs to another
|
|
|
|
* frame ...
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2000-09-12 02:24:19 +00:00
|
|
|
* It relies on TCP segments not being re-ordered too much ...
|
2000-09-08 06:19:37 +00:00
|
|
|
*/
|
2001-12-08 01:45:36 +00:00
|
|
|
struct beep_proto_data {
|
2000-09-12 02:24:19 +00:00
|
|
|
int pl_left; /* Payload at beginning of frame */
|
|
|
|
int pl_size; /* Payload in current message ...*/
|
2002-08-28 21:04:11 +00:00
|
|
|
int mime_hdr; /* Whether we expect a mime header. 1 on first, 0 on rest
|
2000-10-05 13:13:49 +00:00
|
|
|
* in a message
|
|
|
|
*/
|
2000-09-08 06:19:37 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Conversation stuff
|
|
|
|
*/
|
2001-12-08 01:45:36 +00:00
|
|
|
static int beep_packet_init_count = 100;
|
2000-09-08 06:19:37 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
struct beep_request_key {
|
2000-09-08 06:19:37 +00:00
|
|
|
guint32 conversation;
|
|
|
|
};
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
struct beep_request_val {
|
2000-09-08 06:19:37 +00:00
|
|
|
guint16 processed; /* Have we processed this conversation? */
|
2000-09-12 02:24:19 +00:00
|
|
|
int size; /* Size of the message */
|
2000-10-05 13:13:49 +00:00
|
|
|
/* We need an indication in each dirn of
|
2002-08-28 21:04:11 +00:00
|
|
|
* whether on not a mime header is expected
|
2000-10-05 13:13:49 +00:00
|
|
|
*/
|
|
|
|
int c_mime_hdr, s_mime_hdr;
|
2000-09-08 06:19:37 +00:00
|
|
|
};
|
|
|
|
|
2002-04-08 02:13:36 +00:00
|
|
|
static GHashTable *beep_request_hash = NULL;
|
|
|
|
static GMemChunk *beep_request_keys = NULL;
|
|
|
|
static GMemChunk *beep_request_vals = NULL;
|
|
|
|
static GMemChunk *beep_packet_infos = NULL;
|
2000-09-08 06:19:37 +00:00
|
|
|
|
|
|
|
/* Hash Functions */
|
2001-04-27 01:27:37 +00:00
|
|
|
static gint
|
2001-12-08 01:45:36 +00:00
|
|
|
beep_equal(gconstpointer v, gconstpointer w)
|
2000-09-08 06:19:37 +00:00
|
|
|
{
|
2002-11-28 03:57:50 +00:00
|
|
|
const struct beep_request_key *v1 = (const struct beep_request_key *)v;
|
|
|
|
const struct beep_request_key *v2 = (const struct beep_request_key *)w;
|
2000-09-08 06:19:37 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
#if defined(DEBUG_BEEP_HASH)
|
2000-09-08 06:19:37 +00:00
|
|
|
printf("Comparing %08X\n and %08X\n",
|
|
|
|
v1->conversation, v2->conversation);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (v1->conversation == v2->conversation)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static guint
|
2001-12-08 01:45:36 +00:00
|
|
|
beep_hash(gconstpointer v)
|
2000-09-08 06:19:37 +00:00
|
|
|
{
|
2002-11-28 03:57:50 +00:00
|
|
|
const struct beep_request_key *key = (const struct beep_request_key *)v;
|
2000-09-08 06:19:37 +00:00
|
|
|
guint val;
|
|
|
|
|
|
|
|
val = key->conversation;
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
#if defined(DEBUG_BEEP_HASH)
|
|
|
|
printf("BEEP Hash calculated as %u\n", val);
|
2000-09-08 06:19:37 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
return val;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2001-12-08 01:45:36 +00:00
|
|
|
beep_init_protocol(void)
|
2000-09-08 06:19:37 +00:00
|
|
|
{
|
2001-12-08 01:45:36 +00:00
|
|
|
#if defined(DEBUG_BEEP_HASH)
|
|
|
|
fprintf(stderr, "Initializing BEEP hashtable area\n");
|
2000-09-08 06:19:37 +00:00
|
|
|
#endif
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
if (beep_request_hash)
|
|
|
|
g_hash_table_destroy(beep_request_hash);
|
|
|
|
if (beep_request_keys)
|
|
|
|
g_mem_chunk_destroy(beep_request_keys);
|
|
|
|
if (beep_request_vals)
|
|
|
|
g_mem_chunk_destroy(beep_request_vals);
|
|
|
|
if (beep_packet_infos)
|
|
|
|
g_mem_chunk_destroy(beep_packet_infos);
|
|
|
|
|
|
|
|
beep_request_hash = g_hash_table_new(beep_hash, beep_equal);
|
|
|
|
beep_request_keys = g_mem_chunk_new("beep_request_keys",
|
|
|
|
sizeof(struct beep_request_key),
|
|
|
|
beep_packet_init_count * sizeof(struct beep_request_key), G_ALLOC_AND_FREE);
|
2002-08-28 21:04:11 +00:00
|
|
|
beep_request_vals = g_mem_chunk_new("beep_request_vals",
|
2001-12-08 01:45:36 +00:00
|
|
|
sizeof(struct beep_request_val),
|
|
|
|
beep_packet_init_count * sizeof(struct beep_request_val), G_ALLOC_AND_FREE);
|
|
|
|
beep_packet_infos = g_mem_chunk_new("beep_packet_infos",
|
|
|
|
sizeof(struct beep_proto_data),
|
|
|
|
beep_packet_init_count * sizeof(struct beep_proto_data), G_ALLOC_AND_FREE);
|
2000-09-08 06:19:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2001-12-08 01:45:36 +00:00
|
|
|
* BEEP routines
|
2000-09-08 06:19:37 +00:00
|
|
|
*/
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
static int beep_get_more(char more)
|
2000-08-30 12:42:31 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
if (more == '.')
|
2001-12-08 01:45:36 +00:00
|
|
|
return BEEP_COMPLETE;
|
2000-08-30 12:42:31 +00:00
|
|
|
else if (more == '*')
|
2001-12-08 01:45:36 +00:00
|
|
|
return BEEP_INTERMEDIATE;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
return BEEP_VIOL;
|
2000-08-30 12:42:31 +00:00
|
|
|
}
|
|
|
|
|
2000-10-05 13:13:49 +00:00
|
|
|
/* dissect the more flag, and return a value of:
|
|
|
|
* 1 -> more
|
|
|
|
* 0 -> no more
|
|
|
|
* -1 -> Proto violation
|
|
|
|
*/
|
|
|
|
|
2001-04-27 01:27:37 +00:00
|
|
|
static int
|
2002-04-08 02:13:36 +00:00
|
|
|
dissect_beep_more(tvbuff_t *tvb, int offset,
|
2000-08-30 12:42:31 +00:00
|
|
|
proto_tree *tree)
|
|
|
|
{
|
|
|
|
|
2000-10-05 13:13:49 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
switch (beep_get_more(tvb_get_guint8(tvb, offset))) {
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
case BEEP_COMPLETE:
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
if (tree) {
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_tree_add_boolean_hidden(tree, hf_beep_complete, tvb, offset, 1, TRUE);
|
2000-10-02 01:44:58 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1, "More: Complete");
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-05 13:13:49 +00:00
|
|
|
return 0;
|
|
|
|
|
2000-08-30 12:42:31 +00:00
|
|
|
break;
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
case BEEP_INTERMEDIATE:
|
2000-10-02 01:44:58 +00:00
|
|
|
|
|
|
|
if (tree) {
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_tree_add_boolean_hidden(tree, hf_beep_intermediate, tvb, offset, 1, TRUE);
|
2000-10-02 01:44:58 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1, "More: Intermediate");
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-05 13:13:49 +00:00
|
|
|
return 1;
|
|
|
|
|
2000-08-30 12:42:31 +00:00
|
|
|
break;
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
default:
|
2000-10-05 13:13:49 +00:00
|
|
|
|
|
|
|
if (tree) {
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_tree_add_boolean_hidden(tree, hf_beep_proto_viol, tvb, offset, 1, TRUE);
|
2000-10-05 13:13:49 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1, "PROTOCOL VIOLATION: Expected More Flag (* or .)");
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2003-07-25 04:17:37 +00:00
|
|
|
#if 0
|
2002-04-08 02:13:36 +00:00
|
|
|
static void dissect_beep_status(tvbuff_t *tvb, int offset,
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_tree *tree)
|
2000-08-30 12:42:31 +00:00
|
|
|
{
|
2000-10-02 01:44:58 +00:00
|
|
|
|
|
|
|
/* FIXME: We should return a value to indicate all OK. */
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-09-08 06:19:37 +00:00
|
|
|
switch(tvb_get_guint8(tvb, offset)) {
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
case '+':
|
2000-10-02 01:44:58 +00:00
|
|
|
|
|
|
|
if (tree) {
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_tree_add_boolean_hidden(tree, hf_beep_positive, tvb, offset, 1, TRUE);
|
2000-10-02 01:44:58 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1, "Status: Positive");
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '-':
|
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
if (tree) {
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_tree_add_boolean_hidden(tree, hf_beep_negative, tvb, offset, 1, TRUE);
|
2000-10-02 01:44:58 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 1, "Status: Negative");
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
default: /* Proto violation: FIXME */
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2003-07-25 04:17:37 +00:00
|
|
|
#endif
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-04-27 01:27:37 +00:00
|
|
|
static int num_len(tvbuff_t *tvb, int offset)
|
2000-08-30 12:42:31 +00:00
|
|
|
{
|
2001-04-27 01:27:37 +00:00
|
|
|
unsigned int i = 0;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-09-08 06:19:37 +00:00
|
|
|
while (isdigit(tvb_get_guint8(tvb, offset + i))) i++;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
return i;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2000-10-03 10:59:10 +00:00
|
|
|
/*
|
|
|
|
* We check for a terminator. This can be CRLF, which will be recorded
|
|
|
|
* as a terminator, or CR or LF by itself, which will be redorded as
|
|
|
|
* an incorrect terminator ... We build the tree at this point
|
2001-12-08 01:45:36 +00:00
|
|
|
* However, we depend on the variable beep_strict_term
|
2002-08-28 21:04:11 +00:00
|
|
|
*/
|
2000-10-03 10:59:10 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
static int
|
2000-10-03 10:59:10 +00:00
|
|
|
check_term(tvbuff_t *tvb, int offset, proto_tree *tree)
|
|
|
|
{
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/* First, check for CRLF, or, if global_beep_strict_term is false,
|
2000-10-03 10:59:10 +00:00
|
|
|
* one of CR or LF ... If neither of these hold, we add an element
|
|
|
|
* that complains of a protocol violation, and return -1, else
|
|
|
|
* we add a terminator to the tree (possibly non-standard) and return
|
2002-08-28 21:04:11 +00:00
|
|
|
* the count of characters we saw ... This may throw off the rest of the
|
2000-10-03 10:59:10 +00:00
|
|
|
* dissection ... so-be-it!
|
|
|
|
*/
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
if ((tvb_get_guint8(tvb, offset) == 0x0d &&
|
2000-10-03 10:59:10 +00:00
|
|
|
tvb_get_guint8(tvb, offset + 1) == 0x0a)){ /* Correct terminator */
|
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 2, "Terminator: CRLF");
|
|
|
|
}
|
|
|
|
return 2;
|
|
|
|
|
|
|
|
}
|
2001-12-08 01:45:36 +00:00
|
|
|
else if ((tvb_get_guint8(tvb, offset) == 0x0d) && !global_beep_strict_term) {
|
2000-10-03 10:59:10 +00:00
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 1, "Nonstandard Terminator: CR");
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_tree_add_boolean_hidden(tree, hf_beep_proto_viol, tvb, offset, 1, TRUE);
|
2000-10-03 10:59:10 +00:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
}
|
2001-12-08 01:45:36 +00:00
|
|
|
else if ((tvb_get_guint8(tvb, offset) == 0x0a) && !global_beep_strict_term) {
|
2000-10-03 10:59:10 +00:00
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 1, "Nonstandard Terminator: LF");
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_tree_add_boolean_hidden(tree, hf_beep_proto_viol, tvb, offset, 1, TRUE);
|
2000-10-03 10:59:10 +00:00
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
}
|
2002-08-28 21:04:11 +00:00
|
|
|
else {
|
2000-10-03 10:59:10 +00:00
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
proto_tree_add_text(tree, tvb, offset, 2, "PROTOCOL VIOLATION, Invalid Terminator: %s", tvb_format_text(tvb, offset, 2));
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_tree_add_boolean_hidden(tree, hf_beep_proto_viol, tvb, offset, 2, TRUE);
|
2000-10-03 10:59:10 +00:00
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2000-10-05 13:13:49 +00:00
|
|
|
/* Get the header length, up to CRLF or CR or LF */
|
2001-04-27 01:27:37 +00:00
|
|
|
static int header_len(tvbuff_t *tvb, int offset)
|
2000-08-30 12:42:31 +00:00
|
|
|
{
|
|
|
|
int i = 0;
|
2000-10-03 10:59:10 +00:00
|
|
|
guint8 sc;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-03 10:59:10 +00:00
|
|
|
/* FIXME: Have to make sure we stop looking at the end of the tvb ... */
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/* We look for CRLF, or CR or LF if global_beep_strict_term is
|
2000-10-03 10:59:10 +00:00
|
|
|
* not set.
|
|
|
|
*/
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-03 10:59:10 +00:00
|
|
|
while (1) {
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
if ((sc = tvb_get_guint8(tvb, offset + i)) == 0x0d
|
2000-10-03 10:59:10 +00:00
|
|
|
&& tvb_get_guint8(tvb, offset + i + 1) == 0x0a)
|
|
|
|
return i; /* Done here ... */
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
if (!global_beep_strict_term && (sc == 0x0d || sc == 0x0a))
|
2000-10-03 10:59:10 +00:00
|
|
|
return i; /* Done here also ... */
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-10-03 10:59:10 +00:00
|
|
|
i++;
|
|
|
|
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
}
|
|
|
|
|
2001-04-27 01:27:37 +00:00
|
|
|
static int
|
2002-08-28 21:04:11 +00:00
|
|
|
dissect_beep_mime_header(tvbuff_t *tvb, int offset,
|
2001-12-08 01:45:36 +00:00
|
|
|
struct beep_proto_data *frame_data,
|
2000-08-30 12:42:31 +00:00
|
|
|
proto_tree *tree)
|
|
|
|
{
|
2000-10-02 01:44:58 +00:00
|
|
|
proto_tree *ti = NULL, *mime_tree = NULL;
|
2000-10-03 10:59:10 +00:00
|
|
|
int mime_length = header_len(tvb, offset), cc = 0;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-05 13:13:49 +00:00
|
|
|
if (frame_data && !frame_data->mime_hdr) return 0;
|
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
if (tree) {
|
2000-10-03 10:59:10 +00:00
|
|
|
|
|
|
|
/* FIXME: Should calculate the whole length of the mime headers */
|
|
|
|
|
|
|
|
ti = proto_tree_add_text(tree, tvb, offset, mime_length, "Mime header: %s", tvb_format_text(tvb, offset, mime_length));
|
2000-10-02 01:44:58 +00:00
|
|
|
mime_tree = proto_item_add_subtree(ti, ett_mime_header);
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
if (mime_length == 0) { /* Default header */
|
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
if (tree) {
|
2000-10-03 10:59:10 +00:00
|
|
|
proto_tree_add_text(mime_tree, tvb, offset, 0, "Default values");
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cc = check_term(tvb, offset, mime_tree)) <= 0) {
|
|
|
|
|
|
|
|
/* Ignore it, it will cause funnies in the rest of the dissect */
|
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
else { /* FIXME: Process the headers */
|
|
|
|
|
2000-10-03 10:59:10 +00:00
|
|
|
if (tree) {
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(mime_tree, tvb, offset, mime_length, "Header: %s",
|
2000-10-03 10:59:10 +00:00
|
|
|
tvb_format_text(tvb, offset, mime_length));
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cc = check_term(tvb, offset + mime_length, mime_tree)) <= 0) {
|
|
|
|
|
|
|
|
/* Ignore it, it will cause funnies in the rest of the dissect */
|
|
|
|
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2000-10-03 10:59:10 +00:00
|
|
|
return mime_length + cc; /* FIXME: Check that the CRLF is there */
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2001-04-27 01:27:37 +00:00
|
|
|
static int
|
2002-04-08 02:13:36 +00:00
|
|
|
dissect_beep_int(tvbuff_t *tvb, int offset,
|
2000-10-02 01:44:58 +00:00
|
|
|
proto_tree *tree, int hf, int *val, int *hfa[])
|
2000-08-30 12:42:31 +00:00
|
|
|
{
|
2001-04-27 01:27:37 +00:00
|
|
|
int ival, ind = 0;
|
|
|
|
unsigned int i = num_len(tvb, offset);
|
2000-09-08 06:19:37 +00:00
|
|
|
guint8 int_buff[100];
|
|
|
|
|
|
|
|
memset(int_buff, '\0', sizeof(int_buff));
|
|
|
|
|
2002-06-13 07:32:34 +00:00
|
|
|
tvb_memcpy(tvb, int_buff, offset, MIN(sizeof(int_buff) - 1, i));
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2002-06-13 07:32:34 +00:00
|
|
|
/* XXX - is this still "Dangerous" now that we don't copy to the
|
|
|
|
last byte of "int_buff[]"? */
|
|
|
|
sscanf(int_buff, "%d", &ival);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
if (tree) {
|
|
|
|
proto_tree_add_uint(tree, hf, tvb, offset, i, ival);
|
|
|
|
}
|
|
|
|
|
|
|
|
while (hfa[ind]) {
|
|
|
|
|
|
|
|
proto_tree_add_uint_hidden(tree, *hfa[ind], tvb, offset, i, ival);
|
|
|
|
ind++;
|
|
|
|
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
*val = ival; /* Return the value */
|
|
|
|
|
|
|
|
return i;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2001-04-27 01:27:37 +00:00
|
|
|
static void
|
2002-08-28 21:04:11 +00:00
|
|
|
set_mime_hdr_flags(int more, struct beep_request_val *request_val,
|
2001-12-08 01:45:36 +00:00
|
|
|
struct beep_proto_data *frame_data, packet_info *pinfo)
|
2000-10-05 13:13:49 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
if (!request_val) return; /* Nothing to do ??? */
|
|
|
|
|
2001-07-03 04:56:46 +00:00
|
|
|
if (pinfo->destport == tcp_port) { /* Going to the server ... client */
|
2000-10-05 13:13:49 +00:00
|
|
|
|
|
|
|
if (request_val->c_mime_hdr) {
|
|
|
|
|
|
|
|
frame_data->mime_hdr = 0;
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
if (!more) request_val->c_mime_hdr = 0;
|
2000-10-05 13:13:49 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
|
|
|
|
frame_data->mime_hdr = 1;
|
|
|
|
|
|
|
|
if (more) request_val->c_mime_hdr = 1;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
|
|
|
|
if (request_val->s_mime_hdr) {
|
|
|
|
|
|
|
|
frame_data->mime_hdr = 0;
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
if (!more) request_val->s_mime_hdr = 0;
|
2000-10-05 13:13:49 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
|
|
|
|
frame_data->mime_hdr = 1;
|
|
|
|
|
|
|
|
if (more) request_val->s_mime_hdr = 1;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
/* Build the tree
|
|
|
|
*
|
|
|
|
* A return value of <= 0 says we bailed out, skip the rest of this message,
|
|
|
|
* if any.
|
|
|
|
*
|
|
|
|
* A return value > 0 is the count of bytes we consumed ...
|
|
|
|
*/
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-04-27 01:27:37 +00:00
|
|
|
static int
|
2002-08-28 21:04:11 +00:00
|
|
|
dissect_beep_tree(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
|
|
|
proto_tree *tree, struct beep_request_val *request_val,
|
2001-12-08 01:45:36 +00:00
|
|
|
struct beep_proto_data *frame_data)
|
2000-08-30 12:42:31 +00:00
|
|
|
{
|
2000-10-02 01:44:58 +00:00
|
|
|
proto_tree *ti = NULL, *hdr = NULL;
|
2001-12-08 01:45:36 +00:00
|
|
|
int st_offset, msgno, ansno, seqno, size, channel, ackno, window, cc,
|
2000-10-05 13:13:49 +00:00
|
|
|
more;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
char * cmd_temp = NULL;
|
|
|
|
int is_ANS = 0;
|
2000-08-30 12:42:31 +00:00
|
|
|
st_offset = offset;
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
if (tvb_strneql(tvb, offset, "MSG ", 4) == 0)
|
2001-12-08 01:45:36 +00:00
|
|
|
cmd_temp = "Command: MSG";
|
2002-08-28 21:04:11 +00:00
|
|
|
if (tvb_strneql(tvb, offset, "RPY ", 4) == 0)
|
2001-12-08 01:45:36 +00:00
|
|
|
cmd_temp = "Command: RPY";
|
2002-08-28 21:04:11 +00:00
|
|
|
if (tvb_strneql(tvb, offset, "ERR ", 4) == 0)
|
2001-12-08 01:45:36 +00:00
|
|
|
cmd_temp = "Command: ERR";
|
2002-08-28 21:04:11 +00:00
|
|
|
if (tvb_strneql(tvb, offset, "NUL ", 4) == 0)
|
2001-12-08 01:45:36 +00:00
|
|
|
cmd_temp = "Command: NUL";
|
|
|
|
if (tvb_strneql(tvb, offset, "ANS ", 4) == 0) {
|
|
|
|
cmd_temp = "Command: ANS";
|
|
|
|
is_ANS = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cmd_temp != NULL) {
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
if (tree) {
|
|
|
|
ti = proto_tree_add_text(tree, tvb, offset, header_len(tvb, offset) + 2, "Header");
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
hdr = proto_item_add_subtree(ti, ett_header);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_tree_add_boolean_hidden(hdr, hf_beep_req, tvb, offset, 3, TRUE);
|
|
|
|
proto_tree_add_text(hdr, tvb, offset, 3, cmd_temp);
|
2000-10-02 01:44:58 +00:00
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
offset += 4;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
/* Get the channel */
|
2002-04-08 02:13:36 +00:00
|
|
|
offset += dissect_beep_int(tvb, offset, hdr, hf_beep_channel, &channel, req_chan_hfa);
|
2001-12-08 01:45:36 +00:00
|
|
|
offset += 1; /* Skip the space */
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
/* Dissect the message number */
|
2002-04-08 02:13:36 +00:00
|
|
|
offset += dissect_beep_int(tvb, offset, hdr, hf_beep_msgno, &msgno, req_msgno_hfa);
|
2001-12-08 01:45:36 +00:00
|
|
|
offset += 1; /* skip the space */
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
/* Insert the more elements ... */
|
2002-04-08 02:13:36 +00:00
|
|
|
if ((more = dissect_beep_more(tvb, offset, hdr)) >= 0) {
|
2002-08-28 21:04:11 +00:00
|
|
|
/* Figure out which direction this is in and what mime_hdr flag to
|
2000-10-05 13:13:49 +00:00
|
|
|
* add to the frame_data. If there are missing segments, this code
|
|
|
|
* will get it wrong!
|
|
|
|
*/
|
2001-07-03 04:56:46 +00:00
|
|
|
set_mime_hdr_flags(more, request_val, frame_data, pinfo);
|
2000-10-05 13:13:49 +00:00
|
|
|
}
|
|
|
|
else { /* Protocol violation, so dissect rest as undisectable */
|
|
|
|
if (tree) {
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(hdr, tvb, offset,
|
2000-10-05 13:13:49 +00:00
|
|
|
tvb_length_remaining(tvb, offset),
|
|
|
|
"Undissected Payload: %s",
|
|
|
|
tvb_format_text(tvb, offset,
|
|
|
|
tvb_length_remaining(tvb, offset)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
offset += 2; /* Skip the flag and the space ... */
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
/* now for the seqno */
|
2002-04-08 02:13:36 +00:00
|
|
|
offset += dissect_beep_int(tvb, offset, hdr, hf_beep_seqno, &seqno, req_seqno_hfa);
|
2001-12-08 01:45:36 +00:00
|
|
|
offset += 1; /* skip the space */
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2002-04-08 02:13:36 +00:00
|
|
|
offset += dissect_beep_int(tvb, offset, hdr, hf_beep_size, &size, req_size_hfa);
|
2000-10-05 13:13:49 +00:00
|
|
|
if (request_val) /* FIXME, is this the right order ... */
|
2000-09-12 02:24:19 +00:00
|
|
|
request_val -> size = size; /* Stash this away */
|
|
|
|
else {
|
|
|
|
frame_data->pl_size = size;
|
2000-10-05 13:13:49 +00:00
|
|
|
if (frame_data->pl_size < 0) frame_data->pl_size = 0; /* FIXME: OK? */
|
2000-09-12 02:24:19 +00:00
|
|
|
}
|
2001-12-08 01:45:36 +00:00
|
|
|
/* offset += 1; skip the space */
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
if (is_ANS) { /* We need to put in the ansno */
|
|
|
|
offset += 1; /* skip the space */
|
|
|
|
/* Dissect the message number */
|
2002-04-08 02:13:36 +00:00
|
|
|
offset += dissect_beep_int(tvb, offset, hdr, hf_beep_ansno, &ansno, req_ansno_hfa);
|
2001-12-08 01:45:36 +00:00
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-03 10:59:10 +00:00
|
|
|
if ((cc = check_term(tvb, offset, hdr)) <= 0) {
|
2000-10-02 01:44:58 +00:00
|
|
|
|
|
|
|
/* We dissect the rest as data and bail ... */
|
|
|
|
|
|
|
|
if (tree) {
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(hdr, tvb, offset,
|
2000-10-02 01:44:58 +00:00
|
|
|
tvb_length_remaining(tvb, offset),
|
2002-08-28 21:04:11 +00:00
|
|
|
"Undissected Payload: %s",
|
|
|
|
tvb_format_text(tvb, offset,
|
2000-10-02 01:44:58 +00:00
|
|
|
tvb_length_remaining(tvb, offset)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
return -1;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
offset += cc;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-08-30 12:42:31 +00:00
|
|
|
/* Insert MIME header ... */
|
|
|
|
|
2000-10-05 13:13:49 +00:00
|
|
|
if (frame_data && frame_data->mime_hdr)
|
2001-12-08 01:45:36 +00:00
|
|
|
offset += dissect_beep_mime_header(tvb, offset, frame_data, hdr);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
/* Now for the payload, if any */
|
|
|
|
|
2000-09-08 06:19:37 +00:00
|
|
|
if (tvb_length_remaining(tvb, offset) > 0) { /* Dissect what is left as payload */
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-09-08 06:19:37 +00:00
|
|
|
int pl_size = MIN(size, tvb_length_remaining(tvb, offset));
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
/* Except, check the payload length, and only dissect that much */
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/* We need to keep track, in the conversation, of how much is left
|
2000-09-12 02:24:19 +00:00
|
|
|
* so in the next packet, we can figure out what is part of the payload
|
|
|
|
* and what is the next message
|
|
|
|
*/
|
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
if (tree) {
|
|
|
|
proto_tree_add_text(tree, tvb, offset, pl_size, "Payload: %s", tvb_format_text(tvb, offset, pl_size));
|
|
|
|
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
offset += pl_size;
|
|
|
|
|
2000-09-12 02:24:19 +00:00
|
|
|
if (request_val) {
|
|
|
|
request_val->size -= pl_size;
|
|
|
|
if (request_val->size < 0) request_val->size = 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
frame_data->pl_size -= pl_size;
|
|
|
|
if (frame_data->pl_size < 0) frame_data->pl_size = 0;
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
}
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
/* If anything else left, dissect it ... */
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-09-08 06:19:37 +00:00
|
|
|
if (tvb_length_remaining(tvb, offset) > 0)
|
2001-12-08 01:45:36 +00:00
|
|
|
offset += dissect_beep_tree(tvb, offset, pinfo, tree, request_val, frame_data);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-09-08 06:19:37 +00:00
|
|
|
} else if (tvb_strneql(tvb, offset, "SEQ ", 4) == 0) {
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
if (tree) {
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_tree_add_boolean_hidden(tree, hf_beep_seq, tvb, offset, 3, TRUE);
|
2000-10-02 01:44:58 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset, 3, "Command: SEQ");
|
|
|
|
}
|
|
|
|
|
2000-08-30 12:42:31 +00:00
|
|
|
offset += 3;
|
|
|
|
|
|
|
|
/* Now check the space: FIXME */
|
|
|
|
|
|
|
|
offset += 1;
|
|
|
|
|
2002-04-08 02:13:36 +00:00
|
|
|
offset += dissect_beep_int(tvb, offset, tree, hf_beep_channel, &channel, seq_chan_hfa);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
/* Check the space: FIXME */
|
|
|
|
|
|
|
|
offset += 1;
|
|
|
|
|
2002-04-08 02:13:36 +00:00
|
|
|
offset += dissect_beep_int(tvb, offset, tree, hf_beep_ackno, &ackno, seq_ackno_hfa);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
/* Check the space: FIXME */
|
|
|
|
|
|
|
|
offset += 1;
|
|
|
|
|
2002-04-08 02:13:36 +00:00
|
|
|
offset += dissect_beep_int(tvb, offset, tree, hf_beep_window, &window, seq_window_hfa);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-03 10:59:10 +00:00
|
|
|
if ((cc = check_term(tvb, offset, tree)) <= 0) {
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
/* We dissect the rest as data and bail ... */
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
if (tree) {
|
2002-08-28 21:04:11 +00:00
|
|
|
proto_tree_add_text(tree, tvb, offset,
|
2000-10-02 01:44:58 +00:00
|
|
|
tvb_length_remaining(tvb, offset),
|
2002-08-28 21:04:11 +00:00
|
|
|
"Undissected Payload: %s",
|
|
|
|
tvb_format_text(tvb, offset,
|
2000-10-02 01:44:58 +00:00
|
|
|
tvb_length_remaining(tvb, offset)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
return -1;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
offset += cc;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-09-08 06:19:37 +00:00
|
|
|
} else if (tvb_strneql(tvb, offset, "END", 3) == 0) {
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
proto_tree *tr = NULL;
|
|
|
|
|
|
|
|
if (tree) {
|
|
|
|
ti = proto_tree_add_text(tree, tvb, offset, MIN(5, tvb_length_remaining(tvb, offset)), "Trailer");
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
tr = proto_item_add_subtree(ti, ett_trailer);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_tree_add_boolean_hidden(tr, hf_beep_end, tvb, offset, 3, TRUE);
|
2000-10-02 01:44:58 +00:00
|
|
|
proto_tree_add_text(tr, tvb, offset, 3, "Command: END");
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
offset += 3;
|
|
|
|
|
2000-10-03 10:59:10 +00:00
|
|
|
if ((cc = check_term(tvb, offset, tr)) <= 0) {
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
/* We dissect the rest as data and bail ... */
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
if (tree) {
|
2000-10-02 01:44:58 +00:00
|
|
|
proto_tree_add_text(tr, tvb, offset, tvb_length_remaining(tvb, offset),
|
2002-08-28 21:04:11 +00:00
|
|
|
"Undissected Payload: %s",
|
|
|
|
tvb_format_text(tvb, offset,
|
2000-10-02 01:44:58 +00:00
|
|
|
tvb_length_remaining(tvb, offset)
|
|
|
|
)
|
|
|
|
);
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
return -1;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
offset += cc;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2000-09-12 02:24:19 +00:00
|
|
|
if (tvb_length_remaining(tvb, offset) > 0) { /* Dissect anything left over */
|
|
|
|
|
|
|
|
int pl_size = 0;
|
|
|
|
|
|
|
|
if (request_val) {
|
|
|
|
|
|
|
|
pl_size = MIN(request_val->size, tvb_length_remaining(tvb, offset));
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
if (pl_size == 0) { /* The whole of the rest must be payload */
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-09-12 02:24:19 +00:00
|
|
|
pl_size = tvb_length_remaining(tvb, offset); /* Right place ? */
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-09-12 02:24:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} else if (frame_data) {
|
|
|
|
pl_size = MIN(frame_data->pl_size, tvb_length_remaining(tvb, offset));
|
|
|
|
} else { /* Just in case */
|
|
|
|
pl_size = tvb_length_remaining(tvb, offset);
|
|
|
|
}
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/* Take care here to handle the payload correctly, and if there is
|
2000-09-12 02:24:19 +00:00
|
|
|
* another message here, then handle it correctly as well.
|
|
|
|
*/
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
/* If the pl_size == 0 and the offset == 0?, then we have not processed
|
2002-08-28 21:04:11 +00:00
|
|
|
* anything in this frame above, so we better treat all this data as
|
2001-12-08 01:45:36 +00:00
|
|
|
* payload to avoid recursion loops
|
2000-09-12 02:24:19 +00:00
|
|
|
*/
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
if (pl_size == 0 && offset == st_offset)
|
2000-09-12 02:24:19 +00:00
|
|
|
pl_size = tvb_length_remaining(tvb, offset);
|
|
|
|
|
|
|
|
if (pl_size > 0) {
|
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
if (tree) {
|
|
|
|
proto_tree_add_text(tree, tvb, offset, pl_size, "Payload: %s",
|
|
|
|
tvb_format_text(tvb, offset, pl_size));
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-09-12 02:24:19 +00:00
|
|
|
offset += pl_size; /* Advance past the payload */
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-09-12 02:24:19 +00:00
|
|
|
if (request_val){
|
|
|
|
request_val->size -= pl_size; /* Reduce payload by what we added */
|
|
|
|
if (request_val->size < 0) request_val->size = 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
frame_data->pl_size -= pl_size;
|
|
|
|
if (frame_data->pl_size < 0) frame_data->pl_size = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tvb_length_remaining(tvb, offset) > 0) {
|
2001-12-08 01:45:36 +00:00
|
|
|
offset += dissect_beep_tree(tvb, offset, pinfo, tree, request_val, frame_data);
|
2000-09-12 02:24:19 +00:00
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return offset - st_offset;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2001-12-08 01:45:36 +00:00
|
|
|
dissect_beep(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
2000-08-30 12:42:31 +00:00
|
|
|
{
|
2000-09-08 06:19:37 +00:00
|
|
|
int offset;
|
2001-12-08 01:45:36 +00:00
|
|
|
struct beep_proto_data *frame_data = NULL;
|
|
|
|
proto_tree *beep_tree = NULL, *ti = NULL;
|
2000-09-08 06:19:37 +00:00
|
|
|
conversation_t *conversation = NULL;
|
2001-12-08 01:45:36 +00:00
|
|
|
struct beep_request_key request_key, *new_request_key;
|
|
|
|
struct beep_request_val *request_val = NULL;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-09-08 06:19:37 +00:00
|
|
|
offset = 0;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-09-12 02:24:19 +00:00
|
|
|
/* If we have per frame data, use that, else, we must have lost the per-
|
|
|
|
* frame data, and we have to do a full dissect pass again.
|
|
|
|
*
|
|
|
|
* The per-frame data tells us how much of this frame is left over from a
|
|
|
|
* previous frame, so we dissect it as payload and then try to dissect the
|
|
|
|
* rest.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2000-09-12 02:24:19 +00:00
|
|
|
* We use the conversation to build up info on the first pass over the
|
2001-12-08 01:45:36 +00:00
|
|
|
* packets of type BEEP, and record anything that is needed if the user
|
2000-09-12 02:24:19 +00:00
|
|
|
* does random dissects of packets in per packet data.
|
|
|
|
*
|
2002-08-28 21:04:11 +00:00
|
|
|
* Once we have per-packet data, we don't need the conversation stuff
|
|
|
|
* anymore, but if per-packet data and conversation stuff gets deleted, as
|
|
|
|
* it does under some circumstances when a rescan is done, it all gets
|
2000-09-12 02:24:19 +00:00
|
|
|
* rebuilt.
|
2000-09-08 06:19:37 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* Find out what conversation this packet is part of ... but only
|
2002-08-28 21:04:11 +00:00
|
|
|
* if we have no information on this packet, so find the per-frame
|
2000-09-08 06:19:37 +00:00
|
|
|
* info first.
|
|
|
|
*/
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
frame_data = p_get_proto_data(pinfo->fd, proto_beep);
|
2000-09-08 06:19:37 +00:00
|
|
|
|
|
|
|
if (!frame_data) {
|
|
|
|
|
2001-07-03 04:56:46 +00:00
|
|
|
conversation = find_conversation(&pinfo->src, &pinfo->dst, pinfo->ptype,
|
2000-10-21 05:52:28 +00:00
|
|
|
pinfo->srcport, pinfo->destport, 0);
|
2000-09-08 06:19:37 +00:00
|
|
|
if (conversation == NULL) { /* No conversation, create one */
|
|
|
|
conversation = conversation_new(&pinfo->src, &pinfo->dst, pinfo->ptype,
|
2001-09-03 10:33:12 +00:00
|
|
|
pinfo->srcport, pinfo->destport, 0);
|
2000-09-08 06:19:37 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/*
|
2000-09-08 06:19:37 +00:00
|
|
|
* Check for and insert an entry in the request table if does not exist
|
|
|
|
*/
|
|
|
|
request_key.conversation = conversation->index;
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
request_val = (struct beep_request_val *)g_hash_table_lookup(beep_request_hash, &request_key);
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-09-08 06:19:37 +00:00
|
|
|
if (!request_val) { /* Create one */
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
new_request_key = g_mem_chunk_alloc(beep_request_keys);
|
2000-09-08 06:19:37 +00:00
|
|
|
new_request_key->conversation = conversation->index;
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
request_val = g_mem_chunk_alloc(beep_request_vals);
|
2000-09-08 06:19:37 +00:00
|
|
|
request_val->processed = 0;
|
|
|
|
request_val->size = 0;
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
g_hash_table_insert(beep_request_hash, new_request_key, request_val);
|
2000-09-08 06:19:37 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
}
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_PROTOCOL))
|
|
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "BEEP");
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-10 00:26:21 +00:00
|
|
|
if (check_col(pinfo->cinfo, COL_INFO)) { /* Check the type ... */
|
2000-08-30 12:42:31 +00:00
|
|
|
|
Remove more "CHECK_DISPLAY_AS_DATA()" calls and "pinfo->current_proto ="
statements.
Move the setting of the Protocol column in various dissectors before
anything is fetched from the packet, and also clear the Info column at
that point in those and some other dissectors, so that if an exception
is thrown, the columns don't reflect the previous protocol.
Don't use
col_add_fstr(..., "%s", string);
Use
col_add_str(..., string);
as it does the same thing, but doesn't drag all the heavy *printf
machinery in.
Fix the DDTP dissector to set the Info column regardless of whether
we're building a protocol tree or not, and to set it to "Encrypted
payload" if the payload is encrypted. Also fix a typo in a field name.
Register the FTP data dissector as being associated with the FTP data
protocol, not the FTP protocol (the removed "CHECK_DISPLAY_AS_DATA()"
call checked "proto_ftp_data", and the removed "pinfo->current_proto ="
line set it to "FTP-DATA", so it should be associated with
"proto_ftp_data").
Make the H1 dissector check whether the frame has at least 2 bytes in it
before checking the first two bytes; heuristic dissectors must not throw
exceptions until they've accepted the packet as one of theirs.
Use "tvb_format_text()" rather than "tvb_get_ptr()" and "format_text()"
in some dissectors where the result of "tvb_get_ptr()" is used only in
the "format_text()" call.
In the Quake dissector, don't check whether there are at least 4 bytes
in the packet - if we return, the packet won't be dissected at all (it's
not as if some other dissector will get to handle it), and, if we don't
return, we'll throw an exception if there aren't at least 4 bytes in the
packet, so the packet will be marked as short or malformed, as
appropriate.
In the RIPng dissector, associate the table of strings for the command
field with the command field, so that the dissector doesn't have to
format the string for the protocol tree entry itself, and so that the
filter construction dialog box can let you select "Request" or
"Response" from a list rather than requiring you to know the values for
"Request" and "Response".
Make "dissect_rpc()" static, as it's called only through a heuristic
dissector list.
Use "col_set_str()" to set the COL_PROTOCOL column for RPC protocols;
the string used is from a table provided by the dissector, and is a
string constant.
Don't format the Info column for WSP into a buffer and then format that
buffer into the column with "%s" - "col_add_fstr()" can do the
formatting for you, without having to allocate your own buffer (or run
through the *printf machinery twice).
Don't fetch fields from the WTP packet until you're ready to use them,
so that you don't throw an exception before you even set the Protocol
column or clear the Info column.
Use "pinfo->destport", not "pi.destport", in the Zebra dissector when
checking whether the packet is a request or reply, and do the check by
comparing with "pinfo->match_port" rather than TCP_PORT_ZEBRA (so that
if the dissector is ever registered on another port, it still correctly
determines whether the packet is a request or reply - the Network
Monitor HTTP dissector has port 80 wired into its brain, which is a bit
irritating if you're trying to get it to dissect HTTP proxy traffic on
port 3128 or proxy administration UI traffic on port 3132).
svn path=/trunk/; revision=2931
2001-01-22 08:03:46 +00:00
|
|
|
/* "tvb_format_text()" is passed a value that won't go past the end
|
|
|
|
* of the packet, so it won't throw an exception. */
|
2001-12-10 00:26:21 +00:00
|
|
|
col_add_str(pinfo->cinfo, COL_INFO, tvb_format_text(tvb, offset, tvb_length_remaining(tvb, offset)));
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/* Here, we parse the message so we can retrieve the info we need, which
|
|
|
|
* is that there is some payload left from a previous segment on the
|
2000-10-02 01:44:58 +00:00
|
|
|
* front of this segment ... This all depends on TCP segments not getting
|
2002-08-28 21:04:11 +00:00
|
|
|
* out of order ...
|
2000-10-02 01:44:58 +00:00
|
|
|
*
|
|
|
|
* As a huge kludge, we push the checking for the tree down into the code
|
|
|
|
* and process as if we were given a tree but not call the routines that
|
|
|
|
* adorn the protocol tree if they were NULL.
|
|
|
|
*/
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
if (tree) { /* Build the tree info ... */
|
2000-09-12 02:24:19 +00:00
|
|
|
|
2002-01-24 09:20:54 +00:00
|
|
|
ti = proto_tree_add_item(tree, proto_beep, tvb, offset, -1, FALSE);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
beep_tree = proto_item_add_subtree(ti, ett_beep);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
}
|
2002-08-28 21:04:11 +00:00
|
|
|
|
|
|
|
/* Check the per-frame data and the conversation for any left-over
|
|
|
|
* payload from the previous frame
|
2000-10-05 13:13:49 +00:00
|
|
|
*
|
|
|
|
* We check that per-frame data exists first, and if so, use it,
|
|
|
|
* else we use the conversation data.
|
|
|
|
*
|
|
|
|
* We create per-frame data here as well, but we must ensure we create it
|
|
|
|
* after we have done the check for per-frame or conversation data.
|
|
|
|
*
|
|
|
|
* We also depend on the first frame in a group having a pl_size of 0.
|
2000-10-02 01:44:58 +00:00
|
|
|
*/
|
2000-09-12 02:24:19 +00:00
|
|
|
|
2000-10-05 13:13:49 +00:00
|
|
|
if (frame_data && frame_data->pl_left > 0) {
|
2000-09-12 02:24:19 +00:00
|
|
|
|
2000-10-05 13:13:49 +00:00
|
|
|
int pl_left = frame_data->pl_left;
|
2000-09-12 02:24:19 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
pl_left = MIN(pl_left, tvb_length_remaining(tvb, offset));
|
2000-09-12 02:24:19 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
/* Add the payload bit, only if we have a tree */
|
|
|
|
if (tree) {
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_tree_add_text(beep_tree, tvb, offset, pl_left, "Payload: %s",
|
2000-09-12 02:24:19 +00:00
|
|
|
tvb_format_text(tvb, offset, pl_left));
|
|
|
|
}
|
2000-10-02 01:44:58 +00:00
|
|
|
offset += pl_left;
|
|
|
|
}
|
2000-10-05 13:13:49 +00:00
|
|
|
else if (request_val && request_val->size > 0) {
|
2000-09-12 02:24:19 +00:00
|
|
|
|
2000-10-05 13:13:49 +00:00
|
|
|
int pl_left = request_val->size;
|
2000-09-12 02:24:19 +00:00
|
|
|
|
2000-10-05 13:13:49 +00:00
|
|
|
request_val->size = 0;
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/* We create the frame data here for this case, and
|
2000-10-05 13:13:49 +00:00
|
|
|
* elsewhere for other frames
|
|
|
|
*/
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
frame_data = g_mem_chunk_alloc(beep_packet_infos);
|
2000-10-05 13:13:49 +00:00
|
|
|
|
|
|
|
frame_data->pl_left = pl_left;
|
|
|
|
frame_data->pl_size = 0;
|
|
|
|
frame_data->mime_hdr = 0;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
p_add_proto_data(pinfo->fd, proto_beep, frame_data);
|
2000-09-12 02:24:19 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
}
|
2000-09-12 02:24:19 +00:00
|
|
|
|
2000-10-05 13:13:49 +00:00
|
|
|
/* Set up the per-frame data here if not already done so
|
|
|
|
* This _must_ come after the checks above ...
|
|
|
|
*/
|
2000-09-12 02:24:19 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
if (frame_data == NULL) {
|
2000-09-12 02:24:19 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
frame_data = g_mem_chunk_alloc(beep_packet_infos);
|
2000-09-12 02:24:19 +00:00
|
|
|
|
2000-10-02 01:44:58 +00:00
|
|
|
frame_data->pl_left = 0;
|
|
|
|
frame_data->pl_size = 0;
|
2000-10-05 13:13:49 +00:00
|
|
|
frame_data->mime_hdr = 0;
|
2000-09-12 02:24:19 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
p_add_proto_data(pinfo->fd, proto_beep, frame_data);
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2000-08-30 12:42:31 +00:00
|
|
|
}
|
|
|
|
|
2000-10-05 13:13:49 +00:00
|
|
|
if (tvb_length_remaining(tvb, offset) > 0) {
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
offset += dissect_beep_tree(tvb, offset, pinfo, beep_tree, request_val, frame_data);
|
2000-10-05 13:13:49 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2000-08-30 12:42:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Register all the bits needed with the filtering engine */
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
void
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_register_beep(void)
|
2000-08-30 12:42:31 +00:00
|
|
|
{
|
|
|
|
static hf_register_info hf[] = {
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_proto_viol,
|
|
|
|
{ "Protocol Violation", "beep.violation", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
|
|
|
|
|
|
|
|
{ &hf_beep_req,
|
|
|
|
{ "Request", "beep.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
|
2000-10-02 01:44:58 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_req_chan,
|
|
|
|
{ "Request Channel Number", "beep.req.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_rsp,
|
|
|
|
{ "Response", "beep.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
|
2000-10-02 01:44:58 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_rsp_chan,
|
|
|
|
{ "Response Channel Number", "beep.rsp.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_seq,
|
|
|
|
{ "Sequence", "beep.seq", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
|
2000-10-02 01:44:58 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_seq_chan,
|
|
|
|
{ "Sequence Channel Number", "beep.seq.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_end,
|
|
|
|
{ "End", "beep.end", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
|
2000-10-02 01:44:58 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_complete,
|
|
|
|
{ "Complete", "beep.more.complete", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_intermediate,
|
|
|
|
{ "Intermediate", "beep.more.intermediate", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_msgno,
|
|
|
|
{ "Msgno", "beep.msgno", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_ansno,
|
|
|
|
{ "Ansno", "beep.ansno", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_seqno,
|
|
|
|
{ "Seqno", "beep.seqno", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_size,
|
|
|
|
{ "Size", "beep.size", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_channel,
|
|
|
|
{ "Channel", "beep.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_negative,
|
|
|
|
{ "Negative", "beep.status.negative", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_positive,
|
|
|
|
{ "Positive", "beep.status.positive", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_ackno,
|
|
|
|
{ "Ackno", "beep.seq.ackno", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
{ &hf_beep_window,
|
|
|
|
{ "Window", "beep.seq.window", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
};
|
|
|
|
static gint *ett[] = {
|
2001-12-08 01:45:36 +00:00
|
|
|
&ett_beep,
|
2000-08-30 12:42:31 +00:00
|
|
|
&ett_mime_header,
|
|
|
|
&ett_header,
|
|
|
|
&ett_trailer,
|
|
|
|
};
|
2002-08-28 21:04:11 +00:00
|
|
|
module_t *beep_module;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_beep = proto_register_protocol("Blocks Extensible Exchange Protocol",
|
|
|
|
"BEEP", "beep");
|
2001-01-03 06:56:03 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_register_field_array(proto_beep, hf, array_length(hf));
|
2001-01-03 06:56:03 +00:00
|
|
|
proto_register_subtree_array(ett, array_length(ett));
|
2001-12-08 01:45:36 +00:00
|
|
|
register_init_routine(&beep_init_protocol);
|
2001-01-03 06:56:03 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
/* Register our configuration options for BEEP, particularly our port */
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
beep_module = prefs_register_protocol(proto_beep, proto_reg_handoff_beep);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
prefs_register_uint_preference(beep_module, "tcp.port", "BEEP TCP Port",
|
|
|
|
"Set the port for BEEP messages (if other"
|
2000-08-30 12:42:31 +00:00
|
|
|
" than the default of 10288)",
|
2001-12-08 01:45:36 +00:00
|
|
|
10, &global_beep_tcp_port);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
prefs_register_bool_preference(beep_module, "strict_header_terminator",
|
|
|
|
"BEEP Header Requires CRLF",
|
2001-12-08 01:45:36 +00:00
|
|
|
"Specifies that BEEP requires CRLF as a "
|
2000-10-02 01:44:58 +00:00
|
|
|
"terminator, and not just CR or LF",
|
2001-12-08 01:45:36 +00:00
|
|
|
&global_beep_strict_term);
|
2000-08-30 12:42:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* The registration hand-off routine */
|
|
|
|
void
|
2001-12-08 01:45:36 +00:00
|
|
|
proto_reg_handoff_beep(void)
|
2000-08-30 12:42:31 +00:00
|
|
|
{
|
2001-12-08 01:45:36 +00:00
|
|
|
static int beep_prefs_initialized = FALSE;
|
|
|
|
static dissector_handle_t beep_handle;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
if (!beep_prefs_initialized) {
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
beep_handle = create_dissector_handle(dissect_beep, proto_beep);
|
2001-12-03 04:00:26 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
beep_prefs_initialized = TRUE;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
dissector_delete("tcp.port", tcp_port, beep_handle);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set our port number for future use */
|
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
tcp_port = global_beep_tcp_port;
|
2000-08-30 12:42:31 +00:00
|
|
|
|
2001-12-08 01:45:36 +00:00
|
|
|
dissector_add("tcp.port", global_beep_tcp_port, beep_handle);
|
2000-08-30 12:42:31 +00:00
|
|
|
|
|
|
|
}
|