forked from osmocom/wireshark
be69cc2732
svn path=/trunk/; revision=26619
840 lines
29 KiB
C
840 lines
29 KiB
C
/* packet-rmt-norm.c
|
|
* Reliable Multicast Transport (RMT)
|
|
* NORM Protocol Instantiation dissector
|
|
* Copyright 2005, Stefano Pettini <spettini@users.sourceforge.net>
|
|
*
|
|
* Extensive changes to decode more information Julian Onions
|
|
*
|
|
* Negative-acknowledgment (NACK)-Oriented Reliable Multicast (NORM):
|
|
* ------------------------------------------------------------------
|
|
*
|
|
* This protocol is designed to provide end-to-end reliable transport of
|
|
* bulk data objects or streams over generic IP multicast routing and
|
|
* forwarding services. NORM uses a selective, negative acknowledgment
|
|
* mechanism for transport reliability and offers additional protocol
|
|
* mechanisms to allow for operation with minimal "a priori"
|
|
* coordination among senders and receivers.
|
|
*
|
|
* References:
|
|
* RFC 3940, Negative-acknowledgment (NACK)-Oriented Reliable Multicast (NORM) Protocol
|
|
*
|
|
* $Id$
|
|
*
|
|
* Wireshark - Network traffic analyzer
|
|
* By Gerald Combs <gerald@wireshark.org>
|
|
* Copyright 1998 Gerald Combs
|
|
*
|
|
* 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 <string.h>
|
|
|
|
#include <glib.h>
|
|
|
|
#include <epan/packet.h>
|
|
#include <epan/prefs.h>
|
|
#include <epan/strutil.h>
|
|
#include <epan/garrayfix.h>
|
|
|
|
#include "packet-rmt-norm.h"
|
|
#include <math.h>
|
|
|
|
/* String tables */
|
|
static const value_string string_norm_type[] =
|
|
{
|
|
{ NORM_INFO, "INFO" },
|
|
{ NORM_DATA, "DATA" },
|
|
{ NORM_CMD, "CMD" },
|
|
{ NORM_NACK, "NACK" },
|
|
{ NORM_ACK, "ACK" },
|
|
{ NORM_REPORT, "REPORT" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static const value_string string_norm_cmd_type[] =
|
|
{
|
|
{ NORM_CMD_FLUSH, "FLUSH" },
|
|
{ NORM_CMD_EOT, "EOT" },
|
|
{ NORM_CMD_SQUELCH, "SQUELCH" },
|
|
{ NORM_CMD_CC, "CC" },
|
|
{ NORM_CMD_REPAIR_ADV, "REPAIR_ADV" },
|
|
{ NORM_CMD_ACK_REQ, "ACK_REQ" },
|
|
{ NORM_CMD_APPLICATION, "APPLICATION" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static const value_string string_norm_ack_type[] =
|
|
{
|
|
{ NORM_ACK_CC, "ACK CC" },
|
|
{ NORM_ACK_FLUSH, "ACK FLUSH" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
static const value_string string_norm_nack_form[] =
|
|
{
|
|
{ NORM_NACK_ITEMS, "Items" },
|
|
{ NORM_NACK_RANGES, "Ranges" },
|
|
{ NORM_NACK_ERASURES, "Erasures" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
#define hdrlen2bytes(x) ((x)*4U)
|
|
|
|
/* Initialize the protocol and registered fields */
|
|
/* ============================================= */
|
|
|
|
static int proto = -1;
|
|
static gboolean global_norm_heur = FALSE;
|
|
|
|
static struct _norm_hf hf;
|
|
static struct _norm_ett ett;
|
|
|
|
static struct _norm_prefs preferences;
|
|
|
|
/* Preferences */
|
|
/* =========== */
|
|
|
|
/* Set/Reset preferences to default values */
|
|
static void norm_prefs_set_default(struct _norm_prefs *prefs)
|
|
{
|
|
fec_prefs_set_default(&prefs->fec);
|
|
}
|
|
|
|
/* Register preferences */
|
|
static void norm_prefs_register(struct _norm_prefs *prefs, module_t *module)
|
|
{
|
|
fec_prefs_register(&prefs->fec, module);
|
|
}
|
|
|
|
/* Save preferences to alc_prefs_old */
|
|
static void norm_prefs_save(struct _norm_prefs *p, struct _norm_prefs *p_old)
|
|
{
|
|
*p_old = *p;
|
|
}
|
|
|
|
static const double RTT_MIN = 1.0e-06;
|
|
static const double RTT_MAX = 1000;
|
|
|
|
static double UnquantizeRtt(unsigned char qrtt)
|
|
{
|
|
return ((qrtt <= 31) ? (((double)(qrtt+1))*(double)RTT_MIN) :
|
|
(RTT_MAX/exp(((double)(255-qrtt))/(double)13.0)));
|
|
}
|
|
|
|
static double UnquantizeGSize(guint8 gsize)
|
|
{
|
|
guint mant = (gsize & 0x8) ? 5 : 1;
|
|
guint exponent = gsize & 0x7;
|
|
exponent ++;
|
|
return mant * pow(10, exponent);
|
|
}
|
|
|
|
static double UnquantizeSendRate(guint16 send_rate)
|
|
{
|
|
return (send_rate >> 4) * 10.0 / 4096.0 * pow(10.0, (send_rate & 0x000f));
|
|
}
|
|
|
|
/* code to dissect fairly common sequence in NORM packets */
|
|
static guint dissect_grrtetc(proto_tree *tree, tvbuff_t *tvb, guint offset)
|
|
{
|
|
guint8 backoff;
|
|
double gsize;
|
|
double grtt;
|
|
proto_tree_add_item(tree, hf.instance_id, tvb, offset, 2, FALSE); offset+=2;
|
|
grtt = UnquantizeRtt(tvb_get_guint8(tvb, offset));
|
|
proto_tree_add_double(tree, hf.grtt, tvb, offset, 1, grtt); offset++;
|
|
backoff = hi_nibble(tvb_get_guint8(tvb, offset));
|
|
gsize = UnquantizeGSize((guint8)lo_nibble(tvb_get_guint8(tvb, offset)));
|
|
proto_tree_add_uint(tree, hf.backoff, tvb, offset, 1, backoff);
|
|
proto_tree_add_double(tree, hf.gsize, tvb, offset, 1, gsize);
|
|
offset++;
|
|
return offset;
|
|
}
|
|
|
|
/* split out some common FEC handling */
|
|
static guint dissect_feccode(struct _norm *norm, struct _fec_ptr *f, proto_tree *tree,
|
|
tvbuff_t *tvb, guint offset, packet_info *pinfo, gint reserved)
|
|
{
|
|
f->fec = &norm->fec;
|
|
f->hf = &hf.fec;
|
|
f->ett = &ett.fec;
|
|
f->prefs = &preferences.fec;
|
|
|
|
|
|
norm->fec.encoding_id = tvb_get_guint8(tvb, offset);
|
|
norm->fec.encoding_id_present = 1;
|
|
proto_tree_add_item(tree, hf.fec.encoding_id, tvb, offset, 1, FALSE); offset++;
|
|
if (reserved) {
|
|
proto_tree_add_item(tree, hf.reserved, tvb, offset, 1, FALSE); offset++;
|
|
}
|
|
proto_tree_add_item(tree, hf.object_transport_id, tvb, offset, 2, FALSE); offset+=2;
|
|
|
|
if (norm->fec.encoding_id_present &&
|
|
tvb_reported_length_remaining(tvb, offset) > 0) {
|
|
fec_dissector(*f, tvb, tree, &offset);
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
fec_info_column(f->fec, pinfo);
|
|
}
|
|
return offset;
|
|
}
|
|
|
|
static guint dissect_norm_hdrext(struct _norm *norm, struct _fec_ptr *f, proto_tree *tree,
|
|
tvbuff_t *tvb, guint offset, packet_info *pinfo _U_)
|
|
{
|
|
guint i;
|
|
proto_item *ti;
|
|
/* Allocate an array of _ext elements */
|
|
GArray *ext;
|
|
guint offset_old = offset;
|
|
proto_tree *ext_tree;
|
|
|
|
ext = g_array_new(FALSE, TRUE, sizeof(struct _ext));
|
|
|
|
rmt_ext_parse(ext, tvb, &offset, hdrlen2bytes(norm->hlen));
|
|
|
|
if (ext->len > 0)
|
|
{
|
|
struct _lct_prefs lctp;
|
|
memset(&lctp, 0, sizeof(lctp));
|
|
if (tree)
|
|
{
|
|
/* Add the extensions subtree */
|
|
ti = proto_tree_add_uint(tree, hf.extension,
|
|
tvb, offset_old,
|
|
offset - offset_old, ext->len);
|
|
ext_tree = proto_item_add_subtree(ti, ett.hdrext);
|
|
} else
|
|
ext_tree = NULL;
|
|
|
|
/* Add the extensions to the subtree */
|
|
for (i = 0; i < ext->len; i++) {
|
|
struct _ext *e = &g_array_index(ext, struct _ext, i);
|
|
|
|
lct_ext_decode(e, &lctp, tvb, ext_tree, ett.hdrext, *f);
|
|
/* fec_decode_ext_fti(e, tvb, ext_tree, ett.hdrext, *f); */
|
|
}
|
|
}
|
|
g_array_free(ext, TRUE);
|
|
return offset;
|
|
}
|
|
|
|
static guint dissect_nack_data(struct _norm *norm, proto_tree *tree,
|
|
tvbuff_t *tvb, guint offset, packet_info *pinfo)
|
|
{
|
|
proto_item *ti, *tif;
|
|
proto_tree *nack_tree, *flag_tree;
|
|
guint16 len;
|
|
ti = proto_tree_add_text(tree, tvb, offset, -1, "NACK Data");
|
|
nack_tree = proto_item_add_subtree(ti, ett.nackdata);
|
|
proto_tree_add_item(nack_tree, hf.nack_form, tvb, offset, 1, FALSE); offset += 1;
|
|
|
|
tif = proto_tree_add_item(nack_tree, hf.nack_flags, tvb, offset, 1, FALSE);
|
|
flag_tree = proto_item_add_subtree(tif, ett.flags);
|
|
proto_tree_add_item(flag_tree, hf.nack_flags_segment, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.nack_flags_block, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.nack_flags_info, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.nack_flags_object, tvb, offset, 1, FALSE);
|
|
offset += 1;
|
|
len = tvb_get_ntohs(tvb, offset);
|
|
proto_tree_add_item(nack_tree, hf.nack_length, tvb, offset, 2, FALSE); offset += 2;
|
|
proto_item_set_len(ti, 4+len);
|
|
if (len > 4) {
|
|
struct _fec_ptr f;
|
|
dissect_feccode(norm, &f, nack_tree, tvb, offset, pinfo, 1);
|
|
}
|
|
offset += len;
|
|
return offset;
|
|
}
|
|
|
|
|
|
/* code to dissect NORM data packets */
|
|
static void dissect_norm_data(struct _norm *norm, proto_tree *tree,
|
|
tvbuff_t *tvb, guint offset, packet_info *pinfo)
|
|
{
|
|
guint8 flags;
|
|
proto_item *ti;
|
|
proto_tree *flag_tree;
|
|
struct _fec_ptr f;
|
|
|
|
offset = dissect_grrtetc(tree, tvb, offset);
|
|
|
|
|
|
ti = proto_tree_add_item(tree, hf.flags, tvb, offset, 1, FALSE);
|
|
flags = tvb_get_guint8(tvb, offset);
|
|
flag_tree = proto_item_add_subtree(ti, ett.flags);
|
|
proto_tree_add_item(flag_tree, hf.flag.repair, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.flag.explicit, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.flag.info, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.flag.unreliable, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.flag.file, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.flag.stream, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.flag.msgstart, tvb, offset, 1, FALSE);
|
|
offset++;
|
|
|
|
offset = dissect_feccode(norm, &f, tree, tvb, offset, pinfo, 0);
|
|
|
|
if (offset < hdrlen2bytes(norm->hlen)) {
|
|
offset = dissect_norm_hdrext(norm, &f, tree, tvb, offset, pinfo);
|
|
}
|
|
if (flags & NORM_FLAG_STREAM) {
|
|
ti = proto_tree_add_text(tree, tvb, offset, 8, "Stream Data");
|
|
flag_tree = proto_item_add_subtree(ti, ett.streampayload);
|
|
proto_tree_add_item(flag_tree, hf.reserved, tvb, offset, 2, FALSE); offset+=2;
|
|
proto_tree_add_item(flag_tree, hf.payload_len, tvb, offset, 2, FALSE); offset+=2;
|
|
proto_tree_add_item(flag_tree, hf.payload_offset, tvb, offset, 4, FALSE); offset+=4;
|
|
|
|
}
|
|
if (tvb_reported_length_remaining(tvb, offset) > 0)
|
|
proto_tree_add_none_format(tree, hf.payload, tvb, offset, -1, "Payload (%u bytes)", tvb_reported_length_remaining(tvb, offset));
|
|
|
|
}
|
|
|
|
/* code to dissect NORM info packets */
|
|
static void dissect_norm_info(struct _norm *norm, proto_tree *tree,
|
|
tvbuff_t *tvb, guint offset, packet_info *pinfo _U_)
|
|
{
|
|
guint8 flags;
|
|
proto_item *ti;
|
|
proto_tree *flag_tree;
|
|
|
|
offset = dissect_grrtetc(tree, tvb, offset);
|
|
|
|
ti = proto_tree_add_item(tree, hf.flags, tvb, offset, 1, FALSE);
|
|
flags = tvb_get_guint8(tvb, offset);
|
|
flag_tree = proto_item_add_subtree(ti, ett.flags);
|
|
proto_tree_add_item(flag_tree, hf.flag.repair, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.flag.explicit, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.flag.info, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.flag.unreliable, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.flag.file, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.flag.stream, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.flag.msgstart, tvb, offset, 1, FALSE);
|
|
offset++;
|
|
|
|
norm->fec.encoding_id = tvb_get_guint8(tvb, offset);
|
|
norm->fec.encoding_id_present = 1;
|
|
proto_tree_add_item(tree, hf.fec.encoding_id, tvb, offset, 1, FALSE); offset++;
|
|
proto_tree_add_item(tree, hf.object_transport_id, tvb, offset, 2, FALSE); offset+=2;
|
|
|
|
if (offset < hdrlen2bytes(norm->hlen)) {
|
|
struct _fec_ptr f;
|
|
memset(&f, 0, sizeof f);
|
|
f.fec = &norm->fec;
|
|
f.hf = &hf.fec;
|
|
f.ett = &ett.fec;
|
|
f.prefs = &preferences.fec;
|
|
offset = dissect_norm_hdrext(norm, &f, tree, tvb, offset, pinfo);
|
|
}
|
|
if (tvb_reported_length_remaining(tvb, offset) > 0)
|
|
proto_tree_add_none_format(tree, hf.payload, tvb, offset, -1, "Payload (%u bytes)", tvb_reported_length_remaining(tvb, offset));
|
|
|
|
}
|
|
/* code to dissect NORM cmd(flush) packets */
|
|
static guint dissect_norm_cmd_flush(struct _norm *norm, proto_tree *tree,
|
|
tvbuff_t *tvb, guint offset, packet_info *pinfo)
|
|
{
|
|
struct _fec_ptr f;
|
|
offset = dissect_feccode(norm, &f, tree, tvb, offset, pinfo, 0);
|
|
if (offset < hdrlen2bytes(norm->hlen)) {
|
|
offset = dissect_norm_hdrext(norm, &f, tree, tvb, offset, pinfo);
|
|
}
|
|
return offset;
|
|
}
|
|
|
|
/* code to dissect NORM cmd(flush) packets */
|
|
static guint dissect_norm_cmd_repairadv(struct _norm *norm, proto_tree *tree,
|
|
tvbuff_t *tvb, guint offset, packet_info *pinfo)
|
|
{
|
|
proto_tree_add_item(tree, hf.flags, tvb, offset, 1, FALSE); offset ++;
|
|
proto_tree_add_item(tree, hf.reserved, tvb, offset, 2, FALSE); offset +=2;
|
|
|
|
if (offset < hdrlen2bytes(norm->hlen)) {
|
|
struct _fec_ptr f;
|
|
memset(&f, 0, sizeof f);
|
|
f.fec = &norm->fec;
|
|
f.hf = &hf.fec;
|
|
f.ett = &ett.fec;
|
|
f.prefs = &preferences.fec;
|
|
offset = dissect_norm_hdrext(norm, &f, tree, tvb, offset, pinfo);
|
|
}
|
|
while (tvb_reported_length_remaining(tvb, offset) > 0) {
|
|
offset = dissect_nack_data(norm, tree, tvb, offset, pinfo);
|
|
}
|
|
return offset;
|
|
}
|
|
|
|
/* code to dissect NORM cmd(cc) packets */
|
|
static guint dissect_norm_cmd_cc(struct _norm *norm, proto_tree *tree,
|
|
tvbuff_t *tvb, guint offset, packet_info *pinfo _U_)
|
|
{
|
|
proto_tree_add_item(tree, hf.reserved, tvb, offset, 1, FALSE); offset ++;
|
|
proto_tree_add_item(tree, hf.cc_sequence, tvb, offset, 2, FALSE); offset += 2;
|
|
|
|
proto_tree_add_item(tree, hf.cc_sts, tvb, offset, 4, FALSE); offset += 4;
|
|
proto_tree_add_item(tree, hf.cc_stus, tvb, offset, 4, FALSE); offset += 4;
|
|
if (offset < hdrlen2bytes(norm->hlen)) {
|
|
struct _fec_ptr f;
|
|
memset(&f, 0, sizeof f);
|
|
f.fec = &norm->fec;
|
|
f.hf = &hf.fec;
|
|
f.ett = &ett.fec;
|
|
f.prefs = &preferences.fec;
|
|
offset = dissect_norm_hdrext(norm, &f, tree, tvb, offset, pinfo);
|
|
}
|
|
while (tvb_reported_length_remaining(tvb, offset) > 0) {
|
|
proto_item *ti, *tif;
|
|
proto_tree *cc_tree, *flag_tree;
|
|
double grtt;
|
|
ti = proto_tree_add_text(tree, tvb, offset, 8, "Congestion Control");
|
|
cc_tree = proto_item_add_subtree(ti, ett.congestioncontrol);
|
|
proto_tree_add_item(cc_tree, hf.cc_node_id, tvb, offset, 4, FALSE); offset += 4;
|
|
tif = proto_tree_add_item(cc_tree, hf.cc_flags, tvb, offset, 1, FALSE);
|
|
flag_tree = proto_item_add_subtree(tif, ett.flags);
|
|
proto_tree_add_item(flag_tree, hf.cc_flags_clr, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.cc_flags_plr, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.cc_flags_rtt, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.cc_flags_start, tvb, offset, 1, FALSE);
|
|
proto_tree_add_item(flag_tree, hf.cc_flags_leave, tvb, offset, 1, FALSE);
|
|
offset += 1;
|
|
grtt = UnquantizeRtt(tvb_get_guint8(tvb, offset));
|
|
proto_tree_add_double(cc_tree, hf.cc_rtt, tvb, offset, 1, grtt); offset += 1;
|
|
grtt = UnquantizeSendRate(tvb_get_ntohs(tvb, offset));
|
|
proto_tree_add_double(cc_tree, hf.cc_rate, tvb, offset, 2, grtt); offset += 2;
|
|
}
|
|
return offset;
|
|
}
|
|
|
|
/* code to dissect NORM cmd(squelch) packets */
|
|
static guint dissect_norm_cmd_squelch(struct _norm *norm, proto_tree *tree,
|
|
tvbuff_t *tvb, guint offset, packet_info *pinfo)
|
|
{
|
|
struct _fec_ptr f;
|
|
offset = dissect_feccode(norm, &f, tree, tvb, offset, pinfo, 0);
|
|
|
|
while (tvb_reported_length_remaining(tvb, offset) > 0) {
|
|
proto_tree_add_item(tree, hf.cc_transport_id, tvb, offset, 4, FALSE); offset += 2;
|
|
}
|
|
return offset;
|
|
}
|
|
|
|
/* code to dissect NORM cmd(squelch) packets */
|
|
static guint dissect_norm_cmd_ackreq(struct _norm *norm _U_, proto_tree *tree,
|
|
tvbuff_t *tvb, guint offset, packet_info *pinfo _U_)
|
|
{
|
|
proto_tree_add_item(tree, hf.reserved, tvb, offset, 1, FALSE); offset ++;
|
|
proto_tree_add_item(tree, hf.ack_type, tvb, offset, 1, FALSE); offset += 1;
|
|
proto_tree_add_item(tree, hf.ack_id, tvb, offset, 1, FALSE); offset += 1;
|
|
return offset;
|
|
}
|
|
|
|
/* code to dissect NORM cmd packets */
|
|
static void dissect_norm_cmd(struct _norm *norm, proto_tree *tree,
|
|
tvbuff_t *tvb, guint offset, packet_info *pinfo)
|
|
{
|
|
guint8 flavor;
|
|
|
|
offset = dissect_grrtetc(tree, tvb, offset);
|
|
flavor = tvb_get_guint8(tvb, offset);
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
col_append_sep_str(pinfo->cinfo, COL_INFO, " ",
|
|
val_to_str(flavor, string_norm_cmd_type, "Unknown Cmd Type (0x%04x)"));
|
|
proto_tree_add_item(tree, hf.cmd_flavor, tvb, offset, 1, FALSE); offset ++;
|
|
switch(flavor) {
|
|
case NORM_CMD_CC:
|
|
offset = dissect_norm_cmd_cc(norm, tree, tvb, offset, pinfo);
|
|
break;
|
|
case NORM_CMD_FLUSH:
|
|
offset = dissect_norm_cmd_flush(norm, tree, tvb, offset, pinfo);
|
|
break;
|
|
case NORM_CMD_SQUELCH:
|
|
offset = dissect_norm_cmd_squelch(norm, tree, tvb, offset, pinfo);
|
|
break;
|
|
case NORM_CMD_REPAIR_ADV:
|
|
offset = dissect_norm_cmd_repairadv(norm, tree, tvb, offset, pinfo);
|
|
break;
|
|
case NORM_CMD_ACK_REQ:
|
|
offset = dissect_norm_cmd_ackreq(norm, tree, tvb, offset, pinfo);
|
|
break;
|
|
}
|
|
if (tvb_reported_length_remaining(tvb, offset) > 0)
|
|
proto_tree_add_none_format(tree, hf.payload, tvb, offset, -1, "Payload (%u bytes)", tvb_reported_length_remaining(tvb, offset));
|
|
}
|
|
|
|
/* code to dissect NORM ack packets */
|
|
static void dissect_norm_ack(struct _norm *norm, proto_tree *tree,
|
|
tvbuff_t *tvb, guint offset, packet_info *pinfo)
|
|
{
|
|
guint8 acktype;
|
|
|
|
proto_tree_add_item(tree, hf.ack_source, tvb, offset, 4, FALSE); offset += 4;
|
|
proto_tree_add_item(tree, hf.instance_id, tvb, offset, 2, FALSE); offset += 2;
|
|
acktype = tvb_get_guint8(tvb, offset);
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
col_append_sep_str(pinfo->cinfo, COL_INFO, " ",
|
|
val_to_str(acktype, string_norm_ack_type, "Unknown Ack Type (0x%04x)"));
|
|
proto_tree_add_item(tree, hf.ack_type, tvb, offset, 1, FALSE); offset += 1;
|
|
proto_tree_add_item(tree, hf.ack_id, tvb, offset, 1, FALSE); offset += 1;
|
|
proto_tree_add_item(tree, hf.ack_grtt_sec, tvb, offset, 4, FALSE); offset += 4;
|
|
proto_tree_add_item(tree, hf.ack_grtt_usec, tvb, offset, 4, FALSE); offset += 4;
|
|
if (offset < hdrlen2bytes(norm->hlen)) {
|
|
struct _fec_ptr f;
|
|
memset(&f, 0, sizeof f);
|
|
f.fec = &norm->fec;
|
|
f.hf = &hf.fec;
|
|
f.ett = &ett.fec;
|
|
f.prefs = &preferences.fec;
|
|
offset = dissect_norm_hdrext(norm, &f, tree, tvb, offset, pinfo);
|
|
}
|
|
|
|
if (tvb_reported_length_remaining(tvb, offset) > 0)
|
|
proto_tree_add_none_format(tree, hf.payload, tvb, offset, -1, "Payload (%u bytes)", tvb_reported_length_remaining(tvb, offset));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* code to dissect NORM nack packets */
|
|
static void dissect_norm_nack(struct _norm *norm, proto_tree *tree,
|
|
tvbuff_t *tvb, guint offset, packet_info *pinfo)
|
|
{
|
|
proto_tree_add_item(tree, hf.nack_server, tvb, offset, 4, FALSE); offset += 4;
|
|
proto_tree_add_item(tree, hf.instance_id, tvb, offset, 2, FALSE); offset += 2;
|
|
proto_tree_add_item(tree, hf.reserved, tvb, offset, 2, FALSE); offset += 2;
|
|
proto_tree_add_item(tree, hf.nack_grtt_sec, tvb, offset, 4, FALSE); offset += 4;
|
|
proto_tree_add_item(tree, hf.nack_grtt_usec, tvb, offset, 4, FALSE); offset += 4;
|
|
if (offset < hdrlen2bytes(norm->hlen)) {
|
|
struct _fec_ptr f;
|
|
memset(&f, 0, sizeof f);
|
|
f.fec = &norm->fec;
|
|
f.hf = &hf.fec;
|
|
f.ett = &ett.fec;
|
|
f.prefs = &preferences.fec;
|
|
offset = dissect_norm_hdrext(norm, &f, tree, tvb, offset, pinfo);
|
|
}
|
|
|
|
while (tvb_reported_length_remaining(tvb, offset) > 0) {
|
|
offset = dissect_nack_data(norm, tree, tvb, offset, pinfo);
|
|
}
|
|
if (tvb_reported_length_remaining(tvb, offset) > 0)
|
|
proto_tree_add_none_format(tree, hf.payload, tvb, offset, -1, "Payload (%u bytes)", tvb_reported_length_remaining(tvb, offset));
|
|
|
|
}
|
|
/* Code to actually dissect the packets */
|
|
/* ==================================== */
|
|
|
|
static void dissect_norm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
{
|
|
/* Logical packet representation */
|
|
struct _norm norm;
|
|
|
|
/* Offset for subpacket dissection */
|
|
guint offset;
|
|
|
|
/* Set up structures needed to add the protocol subtree and manage it */
|
|
proto_item *ti;
|
|
proto_tree *norm_tree;
|
|
|
|
/* Structures and variables initialization */
|
|
offset = 0;
|
|
memset(&norm, 0, sizeof(struct _norm));
|
|
|
|
/* Update packet info */
|
|
pinfo->current_proto = "NORM";
|
|
|
|
/* Make entries in Protocol column and Info column on summary display */
|
|
if (check_col(pinfo->cinfo, COL_PROTOCOL))
|
|
col_set_str(pinfo->cinfo, COL_PROTOCOL, "NORM");
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
col_clear(pinfo->cinfo, COL_INFO);
|
|
|
|
/* NORM header dissection, part 1 */
|
|
/* ------------------------------ */
|
|
|
|
norm.version = hi_nibble(tvb_get_guint8(tvb, offset));
|
|
|
|
if (tree)
|
|
{
|
|
/* Create subtree for the NORM protocol */
|
|
ti = proto_tree_add_item(tree, proto, tvb, offset, -1, FALSE);
|
|
norm_tree = proto_item_add_subtree(ti, ett.main);
|
|
|
|
/* Fill the NORM subtree */
|
|
proto_tree_add_uint(norm_tree, hf.version, tvb, offset, 1, norm.version);
|
|
|
|
} else
|
|
norm_tree = NULL;
|
|
|
|
/* This dissector supports only NORMv1 packets.
|
|
* If norm.version > 1 print only version field and quit.
|
|
*/
|
|
if (norm.version == 1) {
|
|
|
|
/* NORM header dissection, part 2 */
|
|
/* ------------------------------ */
|
|
|
|
norm.type = lo_nibble(tvb_get_guint8(tvb, offset));
|
|
norm.hlen = tvb_get_guint8(tvb, offset+1);
|
|
norm.sequence = tvb_get_ntohs(tvb, offset+2);
|
|
norm.source_id = tvb_get_ntohl(tvb, offset+4);
|
|
|
|
if (tree)
|
|
{
|
|
proto_tree_add_uint(norm_tree, hf.type, tvb, offset, 1, norm.type);
|
|
proto_tree_add_uint(norm_tree, hf.hlen, tvb, offset+1, 1, norm.hlen);
|
|
proto_tree_add_uint(norm_tree, hf.sequence, tvb, offset+2, 2, norm.sequence);
|
|
proto_tree_add_item(norm_tree, hf.source_id, tvb, offset+4, 4, FALSE);
|
|
}
|
|
|
|
offset += 8;
|
|
|
|
|
|
/* Complete entry in Info column on summary display */
|
|
/* ------------------------------------------------ */
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
col_append_sep_str(pinfo->cinfo, COL_INFO, " ",
|
|
val_to_str(norm.type, string_norm_type, "Unknown Type (0x%04x)"));
|
|
|
|
|
|
switch(norm.type) {
|
|
case NORM_INFO:
|
|
dissect_norm_info(&norm, norm_tree, tvb, offset, pinfo);
|
|
break;
|
|
case NORM_DATA:
|
|
dissect_norm_data(&norm, norm_tree, tvb, offset, pinfo);
|
|
break;
|
|
case NORM_CMD:
|
|
dissect_norm_cmd(&norm, norm_tree, tvb, offset, pinfo);
|
|
break;
|
|
case NORM_ACK:
|
|
dissect_norm_ack(&norm, norm_tree, tvb, offset, pinfo);
|
|
break;
|
|
case NORM_NACK:
|
|
dissect_norm_nack(&norm, norm_tree, tvb, offset, pinfo);
|
|
break;
|
|
default:
|
|
/* Add the Payload item */
|
|
if (tvb_reported_length_remaining(tvb, offset) > 0)
|
|
proto_tree_add_none_format(norm_tree, hf.payload, tvb, offset, -1, "Payload (%u bytes)", tvb_reported_length_remaining(tvb, offset));
|
|
break;
|
|
}
|
|
|
|
} else {
|
|
|
|
if (tree)
|
|
proto_tree_add_text(norm_tree, tvb, 0, -1, "Sorry, this dissector supports NORM version 1 only");
|
|
|
|
/* Complete entry in Info column on summary display */
|
|
if (check_col(pinfo->cinfo, COL_INFO))
|
|
col_add_fstr(pinfo->cinfo, COL_INFO, "Version: %u (not supported)", norm.version);
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
dissect_norm_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
|
{
|
|
guint8 byte1;
|
|
if (!global_norm_heur)
|
|
return FALSE;
|
|
if (tvb_length(tvb) < 2)
|
|
return FALSE; /* not enough to check */
|
|
byte1 = tvb_get_guint8(tvb, 0);
|
|
|
|
if (hi_nibble(byte1) != 1) return FALSE;
|
|
if (lo_nibble(byte1) < 1 || lo_nibble(byte1) > 6) return FALSE;
|
|
if (tvb_get_guint8(tvb, 1) > 20) return FALSE;
|
|
if (tvb_length(tvb) < 12)
|
|
return FALSE;
|
|
dissect_norm(tvb, pinfo, tree);
|
|
return TRUE; /* appears to be a NORM packet */
|
|
}
|
|
|
|
void proto_reg_handoff_norm(void)
|
|
{
|
|
static gboolean preferences_initialized = FALSE;
|
|
static dissector_handle_t handle;
|
|
static struct _norm_prefs preferences_old;
|
|
|
|
if (!preferences_initialized)
|
|
{
|
|
preferences_initialized = TRUE;
|
|
handle = create_dissector_handle(dissect_norm, proto);
|
|
dissector_add_handle("udp.port", handle);
|
|
heur_dissector_add("udp", dissect_norm_heur, proto);
|
|
}
|
|
|
|
norm_prefs_save(&preferences, &preferences_old);
|
|
}
|
|
|
|
void proto_register_norm(void)
|
|
{
|
|
/* Setup NORM header fields */
|
|
static hf_register_info hf_ptr[] = {
|
|
|
|
{ &hf.version,
|
|
{ "Version", "norm.version", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
|
|
{ &hf.type,
|
|
{ "Message Type", "norm.type", FT_UINT8, BASE_DEC, VALS(string_norm_type), 0x0, "", HFILL }},
|
|
{ &hf.hlen,
|
|
{ "Header length", "norm.hlen", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
|
|
{ &hf.sequence,
|
|
{ "Sequence", "norm.sequence", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
|
|
{ &hf.source_id,
|
|
{ "Source ID", "norm.source_id", FT_IPv4, BASE_NONE, NULL, 0x0, "", HFILL }},
|
|
{ &hf.instance_id,
|
|
{ "Instance", "norm.instance_id", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.grtt,
|
|
{ "grtt", "norm.grtt", FT_DOUBLE, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.backoff,
|
|
{ "Backoff", "norm.backoff", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.gsize,
|
|
{ "Group Size", "norm.gsize", FT_DOUBLE, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.flags,
|
|
{ "Flags", "norm.flags", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL}},
|
|
{ &hf.flag.repair,
|
|
{ "Repair Flag", "norm.flag.repair", FT_BOOLEAN, 8, NULL, NORM_FLAG_REPAIR, "", HFILL }},
|
|
{ &hf.flag.explicit,
|
|
{ "Explicit Flag", "norm.flag.explicit", FT_BOOLEAN, 8, NULL, NORM_FLAG_EXPLICIT, "", HFILL }},
|
|
{ &hf.flag.info,
|
|
{ "Info Flag", "norm.flag.info", FT_BOOLEAN, 8, NULL, NORM_FLAG_INFO, "", HFILL }},
|
|
{ &hf.flag.unreliable,
|
|
{ "Unreliable Flag", "norm.flag.unreliable", FT_BOOLEAN, 8, NULL, NORM_FLAG_UNRELIABLE, "", HFILL }},
|
|
{ &hf.flag.file,
|
|
{ "File Flag", "norm.flag.file", FT_BOOLEAN, 8, NULL, NORM_FLAG_FILE, "", HFILL }},
|
|
{ &hf.flag.stream,
|
|
{ "Stream Flag", "norm.flag.stream", FT_BOOLEAN, 8, NULL, NORM_FLAG_STREAM, "", HFILL }},
|
|
{ &hf.flag.msgstart,
|
|
{ "Msg Start Flag", "norm.flag.msgstart", FT_BOOLEAN, 8, NULL, NORM_FLAG_MSG_START, "", HFILL }},
|
|
{ &hf.object_transport_id,
|
|
{ "Object Transport ID", "norm.object_transport_id", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL}},
|
|
{ &hf.extension,
|
|
{ "Hdr Extension", "norm.hexext", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.reserved,
|
|
{ "Reserved", "norm.reserved", FT_NONE, BASE_NONE, NULL, 0x0, "", HFILL}},
|
|
{ &hf.payload_len,
|
|
{ "Payload Len", "norm.payload.len", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.payload_offset,
|
|
{ "Payload Offset", "norm.payload.offset", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
|
|
{ &hf.cmd_flavor,
|
|
{ "Flavor", "norm.flavor", FT_UINT8, BASE_DEC, VALS(string_norm_cmd_type), 0x0, "", HFILL}},
|
|
{ &hf.cc_sequence,
|
|
{ "CC Sequence", "norm.ccsequence", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.cc_sts,
|
|
{ "Send Time secs", "norm.cc_sts", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.cc_stus,
|
|
{ "Send Time usecs", "norm.cc_stus", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.cc_node_id,
|
|
{ "CC Node ID", "norm.cc_node_id", FT_IPv4, BASE_NONE, NULL, 0x0, "", HFILL}},
|
|
{ &hf.cc_flags,
|
|
{ "CC Flags", "norm.cc_flags", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.cc_flags_clr,
|
|
{ "CLR", "norm.cc_flags.clr", FT_BOOLEAN, 8, NULL, NORM_FLAG_CC_CLR, "", HFILL}},
|
|
{ &hf.cc_flags_plr,
|
|
{ "PLR", "norm.cc_flags.plr", FT_BOOLEAN, 8, NULL, NORM_FLAG_CC_PLR, "", HFILL}},
|
|
{ &hf.cc_flags_rtt,
|
|
{ "RTT", "norm.cc_flags.rtt", FT_BOOLEAN, 8, NULL, NORM_FLAG_CC_RTT, "", HFILL}},
|
|
{ &hf.cc_flags_start,
|
|
{ "Start", "norm.cc_flags.start", FT_BOOLEAN, 8, NULL, NORM_FLAG_CC_START, "", HFILL}},
|
|
{ &hf.cc_flags_leave,
|
|
{ "Leave", "norm.cc_flags.leave", FT_BOOLEAN, 8, NULL, NORM_FLAG_CC_LEAVE, "", HFILL}},
|
|
{ &hf.cc_rtt,
|
|
{ "CC RTT", "norm.cc_rtt", FT_DOUBLE, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.cc_rate,
|
|
{ "CC Rate", "norm.cc_rate", FT_DOUBLE, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.cc_transport_id,
|
|
{ "CC Transport ID", "norm.cc_transport_id", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
|
|
{ &hf.ack_source,
|
|
{ "Ack Source", "norm.ack.source", FT_IPv4, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.ack_type,
|
|
{ "Ack Type", "norm.ack.type", FT_UINT8, BASE_DEC, VALS(string_norm_ack_type), 0x0, "", HFILL}},
|
|
{ &hf.ack_id,
|
|
{ "Ack ID", "norm.ack.id", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.ack_grtt_sec,
|
|
{ "Ack GRTT Sec", "norm.ack.grtt_sec", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.ack_grtt_usec,
|
|
{ "Ack GRTT usec", "norm.ack.grtt_usec", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
|
|
{ &hf.nack_server,
|
|
{ "NAck Server", "norm.nack.server", FT_IPv4, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.nack_grtt_sec,
|
|
{ "NAck GRTT Sec", "norm.nack.grtt_sec", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.nack_grtt_usec,
|
|
{ "NAck GRTT usec", "norm.nack.grtt_usec", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.nack_form,
|
|
{ "NAck FORM", "norm.nack.form", FT_UINT8, BASE_DEC, VALS(string_norm_nack_form), 0x0, "", HFILL}},
|
|
{ &hf.nack_flags,
|
|
{ "NAck Flags", "norm.nack.flags", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
{ &hf.nack_flags_segment,
|
|
{ "Segment", "norm.nack.flags.segment", FT_BOOLEAN, 8, NULL, NORM_NACK_SEGMENT, "", HFILL}},
|
|
{ &hf.nack_flags_block,
|
|
{ "Block", "norm.nack.flags.block", FT_BOOLEAN, 8, NULL, NORM_NACK_BLOCK, "", HFILL}},
|
|
{ &hf.nack_flags_info,
|
|
{ "Info", "norm.nack.flags.info", FT_BOOLEAN, 8, NULL, NORM_NACK_INFO, "", HFILL}},
|
|
{ &hf.nack_flags_object,
|
|
{ "Object", "norm.nack.flags.object", FT_BOOLEAN, 8, NULL, NORM_NACK_OBJECT, "", HFILL}},
|
|
{ &hf.nack_length,
|
|
{ "NAck Length", "norm.nack.length", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL}},
|
|
|
|
|
|
FEC_FIELD_ARRAY(hf.fec, "NORM"),
|
|
|
|
{ &hf.payload,
|
|
{ "Payload", "norm.payload", FT_NONE, BASE_NONE, NULL, 0x0, "", HFILL }}
|
|
};
|
|
|
|
/* Setup protocol subtree array */
|
|
static gint *ett_ptr[] = {
|
|
&ett.main,
|
|
&ett.hdrext,
|
|
&ett.flags,
|
|
&ett.streampayload,
|
|
&ett.congestioncontrol,
|
|
&ett.nackdata,
|
|
FEC_SUBTREE_ARRAY(ett.fec)
|
|
};
|
|
|
|
module_t *module;
|
|
|
|
/* Clear hf and ett fields */
|
|
memset(&hf, 0xff, sizeof(struct _norm_hf));
|
|
memset(&ett, 0xff, sizeof(struct _norm_ett));
|
|
|
|
/* Register the protocol name and description */
|
|
proto = proto_register_protocol("Negative-acknowledgment Oriented Reliable Multicast", "NORM", "norm");
|
|
|
|
/* Register the header fields and subtrees used */
|
|
proto_register_field_array(proto, hf_ptr, array_length(hf_ptr));
|
|
proto_register_subtree_array(ett_ptr, array_length(ett_ptr));
|
|
|
|
/* Reset preferences */
|
|
norm_prefs_set_default(&preferences);
|
|
|
|
/* Register preferences */
|
|
module = prefs_register_protocol(proto, proto_reg_handoff_norm);
|
|
norm_prefs_register(&preferences, module);
|
|
prefs_register_bool_preference(module, "heuristic_norm",
|
|
"Try to decode UDP packets as NORM packets",
|
|
"Check this to decode NORM traffic between clients",
|
|
&global_norm_heur);
|
|
|
|
}
|