epan/dissectors/packet-rmt-alc.c

   1 /* packet-rmt-alc.c
   2  * Reliable Multicast Transport (RMT)
   3  * ALC Protocol Instantiation dissector
   4  * Copyright 2005, Stefano Pettini <spettini@users.sourceforge.net>
   5  *
   6  * Asynchronous Layered Coding (ALC):
   7  * ----------------------------------
   8  *
   9  * A massively scalable reliable content delivery protocol.
  10  * Asynchronous Layered Coding combines the Layered Coding Transport
  11  * (LCT) building block, a multiple rate congestion control building
  12  * block and the Forward Error Correction (FEC) building block to
  13  * provide congestion controlled reliable asynchronous delivery of
  14  * content to an unlimited number of concurrent receivers from a single
  15  * sender.
  16  *
  17  * References:
  18  *     RFC 3450, Asynchronous Layered Coding protocol instantiation
  19  *
  20  * $Id$
  21  *
  22  * Wireshark - Network traffic analyzer
  23  * By Gerald Combs <gerald@wireshark.org>
  24  * Copyright 1998 Gerald Combs
  25  *
  26  * This program is free software; you can redistribute it and/or
  27  * modify it under the terms of the GNU General Public License
  28  * as published by the Free Software Foundation; either version 2
  29  * of the License, or (at your option) any later version.
  30  *
  31  * This program is distributed in the hope that it will be useful,
  32  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  33  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  34  * GNU General Public License for more details.
  35  *
  36  * You should have received a copy of the GNU General Public License
  37  * along with this program; if not, write to the Free Software
  38  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  39  */
  40
  41 #ifdef HAVE_CONFIG_H
  42 # include "config.h"
  43 #endif
  44
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48
  49 #include <glib.h>
  50
  51 #include <epan/packet.h>
  52 #include <epan/prefs.h>
  53
  54 #include "packet-rmt-alc.h"
  55
  56 /* Initialize the protocol and registered fields */
  57 /* ============================================= */
  58
  59 static int proto = -1;
  60
  61 static struct _alc_hf hf;
  62 static struct _alc_ett ett;
  63
  64 static struct _alc_prefs preferences;
  65 dissector_handle_t xml_handle;
  66
  67
  68 /* Preferences */
  69 /* =========== */
  70
  71 /* Set/Reset preferences to default values */
  72 static void alc_prefs_set_default(struct _alc_prefs *prefs)
  73 {
  74         prefs->use_default_udp_port = FALSE;
  75         prefs->default_udp_port = 4001;
  76
  77         lct_prefs_set_default(&prefs->lct);
  78         fec_prefs_set_default(&prefs->fec);
  79 }
  80
  81 /* Register preferences */
  82 static void alc_prefs_register(struct _alc_prefs *prefs, module_t *module)
  83 {
  84         prefs_register_bool_preference(module,
  85                 "default.udp_port.enabled",
  86                 "Use default UDP port",
  87                 "Whether that payload of UDP packets with a specific destination port should be automatically dissected as ALC packets",
  88                  &prefs->use_default_udp_port);
  89
  90         prefs_register_uint_preference(module,
  91                 "default.udp_port",
  92                 "Default UDP destination port",
  93                 "Specifies the UDP destination port for automatic dissection of ALC packets",
  94                  10, &prefs->default_udp_port);
  95
  96         lct_prefs_register(&prefs->lct, module);
  97         fec_prefs_register(&prefs->fec, module);
  98 }
  99
 100 /* Save preferences to alc_prefs_old */
 101 static void alc_prefs_save(struct _alc_prefs *p, struct _alc_prefs *p_old)
 102 {
 103         *p_old = *p;
 104 }
 105
 106 /* Code to actually dissect the packets */
 107 /* ==================================== */
 108
 109 static void dissect_alc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 110 {
 111         /* Logical packet representation */
 112         struct _alc alc;
 113
 114         /* Offset for subpacket dissection */
 115         guint offset;
 116
 117         /* Set up structures needed to add the protocol subtree and manage it */
 118         proto_item *ti;
 119         proto_tree *alc_tree;
 120
 121         /* Flute or not */
 122         tvbuff_t *new_tvb;
 123         gboolean is_flute = FALSE;
 124
 125         /* Structures and variables initialization */
 126         offset = 0;
 127         memset(&alc, 0, sizeof(struct _alc));
 128
 129         /* Update packet info */
 130         pinfo->current_proto = "ALC";
 131
 132         /* Make entries in Protocol column and Info column on summary display */
 133         col_set_str(pinfo->cinfo, COL_PROTOCOL, "ALC");
 134         col_clear(pinfo->cinfo, COL_INFO);
 135
 136         /* ALC header dissection */
 137         /* --------------------- */
 138
 139         alc.version = hi_nibble(tvb_get_guint8(tvb, offset));
 140
 141         if (tree)
 142         {
 143                 /* Create subtree for the ALC protocol */
 144                 ti = proto_tree_add_item(tree, proto, tvb, offset, -1, FALSE);
 145                 alc_tree = proto_item_add_subtree(ti, ett.main);
 146
 147                 /* Fill the ALC subtree */
 148                 proto_tree_add_uint(alc_tree, hf.version, tvb, offset, 1, alc.version);
 149
 150         } else
 151                 alc_tree = NULL;
 152
 153         /* This dissector supports only ALCv1 packets.
 154          * If alc.version > 1 print only version field and quit.
 155          */
 156         if (alc.version == 1) {
 157
 158                 struct _lct_ptr l;
 159                 struct _fec_ptr f;
 160
 161                 l.lct = &alc.lct;
 162                 l.hf = &hf.lct;
 163                 l.ett = &ett.lct;
 164                 l.prefs = &preferences.lct;
 165
 166                 f.fec = &alc.fec;
 167                 f.hf = &hf.fec;
 168                 f.ett = &ett.fec;
 169                 f.prefs = &preferences.fec;
 170
 171                 /* LCT header dissection */
 172                 /* --------------------- */
 173
 174                 is_flute = lct_dissector(l, f, tvb, alc_tree, &offset);
 175
 176                 /* FEC header dissection */
 177                 /* --------------------- */
 178
 179                 /* Only if it's present and if LCT dissector has determined FEC Encoding ID
 180                  * FEC dissector should be called with fec->encoding_id* and fec->instance_id* filled
 181                  */
 182                 if (alc.fec.encoding_id_present && tvb_length(tvb) > offset)
 183                         fec_dissector(f, tvb, alc_tree, &offset);
 184
 185                 /* Add the Payload item */
 186                 if (tvb_length(tvb) > offset){
 187                         if(is_flute){
 188                                 new_tvb = tvb_new_subset(tvb,offset,-1,-1);
 189                                 call_dissector(xml_handle, new_tvb, pinfo, alc_tree);
 190                         }else{
 191                                 proto_tree_add_none_format(alc_tree, hf.payload, tvb, offset, -1, "Payload (%u bytes)", tvb_length(tvb) - offset);
 192                         }
 193                 }
 194
 195                 /* Complete entry in Info column on summary display */
 196                 /* ------------------------------------------------ */
 197
 198                 if (check_col(pinfo->cinfo, COL_INFO))
 199                 {
 200                         lct_info_column(&alc.lct, pinfo);
 201                         fec_info_column(&alc.fec, pinfo);
 202                 }
 203
 204                 /* Free g_allocated memory */
 205                 lct_dissector_free(&alc.lct);
 206                 fec_dissector_free(&alc.fec);
 207
 208         } else {
 209
 210                 if (tree)
 211                         proto_tree_add_text(alc_tree, tvb, 0, -1, "Sorry, this dissector supports ALC version 1 only");
 212
 213                 /* Complete entry in Info column on summary display */
 214                 if (check_col(pinfo->cinfo, COL_INFO))
 215                         col_add_fstr(pinfo->cinfo, COL_INFO, "Version: %u (not supported)", alc.version);
 216         }
 217 }
 218
 219 void proto_reg_handoff_alc(void)
 220 {
 221         static dissector_handle_t handle;
 222         static gboolean preferences_initialized = FALSE;
 223         static struct _alc_prefs preferences_old;
 224
 225         if (!preferences_initialized)
 226         {
 227                 preferences_initialized = TRUE;
 228                 handle = create_dissector_handle(dissect_alc, proto);
 229                 dissector_add_handle("udp.port", handle);
 230                 xml_handle = find_dissector("xml");
 231
 232         } else {
 233
 234                 if (preferences_old.use_default_udp_port)
 235                         dissector_delete("udp.port", preferences_old.default_udp_port, handle);
 236         }
 237
 238         if (preferences.use_default_udp_port)
 239                 dissector_add("udp.port", preferences.default_udp_port, handle);
 240
 241         alc_prefs_save(&preferences, &preferences_old);
 242
 243 }
 244
 245 void proto_register_alc(void)
 246 {
 247         /* Setup ALC header fields */
 248         static hf_register_info hf_ptr[] = {
 249
 250                 { &hf.version,
 251                         { "Version", "alc.version", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
 252
 253                 LCT_FIELD_ARRAY(hf.lct, "alc"),
 254                 FEC_FIELD_ARRAY(hf.fec, "alc"),
 255
 256                 { &hf.payload,
 257                         { "Payload", "alc.payload", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL }}
 258         };
 259
 260         /* Setup protocol subtree array */
 261         static gint *ett_ptr[] = {
 262                 &ett.main,
 263
 264                 LCT_SUBTREE_ARRAY(ett.lct),
 265                 FEC_SUBTREE_ARRAY(ett.fec)
 266         };
 267
 268         module_t *module;
 269
 270         /* Clear hf and ett fields */
 271         memset(&hf, 0xff, sizeof(struct _alc_hf));
 272         memset(&ett, 0xff, sizeof(struct _alc_ett));
 273
 274         /* Register the protocol name and description */
 275         proto = proto_register_protocol("Asynchronous Layered Coding", "ALC", "alc");
 276
 277         /* Register the header fields and subtrees used */
 278         proto_register_field_array(proto, hf_ptr, array_length(hf_ptr));
 279         proto_register_subtree_array(ett_ptr, array_length(ett_ptr));
 280
 281         /* Reset preferences */
 282         alc_prefs_set_default(&preferences);
 283
 284         /* Register preferences */
 285         module = prefs_register_protocol(proto, proto_reg_handoff_alc);
 286         alc_prefs_register(&preferences, module);
 287
 288 }