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         if (check_col(pinfo->cinfo, COL_PROTOCOL))
 134                 col_set_str(pinfo->cinfo, COL_PROTOCOL, "ALC");
 135         if (check_col(pinfo->cinfo, COL_INFO))
 136                 col_clear(pinfo->cinfo, COL_INFO);
 137
 138         /* ALC header dissection */
 139         /* --------------------- */
 140
 141         alc.version = hi_nibble(tvb_get_guint8(tvb, offset));
 142
 143         if (tree)
 144         {
 145                 /* Create subtree for the ALC protocol */
 146                 ti = proto_tree_add_item(tree, proto, tvb, offset, -1, FALSE);
 147                 alc_tree = proto_item_add_subtree(ti, ett.main);
 148
 149                 /* Fill the ALC subtree */
 150                 proto_tree_add_uint(alc_tree, hf.version, tvb, offset, 1, alc.version);
 151
 152         } else
 153                 alc_tree = NULL;
 154
 155         /* This dissector supports only ALCv1 packets.
 156          * If alc.version > 1 print only version field and quit.
 157          */
 158         if (alc.version == 1) {
 159
 160                 struct _lct_ptr l;
 161                 struct _fec_ptr f;
 162
 163                 l.lct = &alc.lct;
 164                 l.hf = &hf.lct;
 165                 l.ett = &ett.lct;
 166                 l.prefs = &preferences.lct;
 167
 168                 f.fec = &alc.fec;
 169                 f.hf = &hf.fec;
 170                 f.ett = &ett.fec;
 171                 f.prefs = &preferences.fec;
 172
 173                 /* LCT header dissection */
 174                 /* --------------------- */
 175
 176                 is_flute = lct_dissector(l, f, tvb, alc_tree, &offset);
 177
 178                 /* FEC header dissection */
 179                 /* --------------------- */
 180
 181                 /* Only if it's present and if LCT dissector has determined FEC Encoding ID
 182                  * FEC dissector should be called with fec->encoding_id* and fec->instance_id* filled
 183                  */
 184                 if (alc.fec.encoding_id_present && tvb_length(tvb) > offset)
 185                         fec_dissector(f, tvb, alc_tree, &offset);
 186
 187                 /* Add the Payload item */
 188                 if (tvb_length(tvb) > offset){
 189                         if(is_flute){
 190                                 new_tvb = tvb_new_subset(tvb,offset,-1,-1);
 191                                 call_dissector(xml_handle, new_tvb, pinfo, alc_tree);
 192                         }else{
 193                                 proto_tree_add_none_format(alc_tree, hf.payload, tvb, offset, -1, "Payload (%u bytes)", tvb_length(tvb) - offset);
 194                         }
 195                 }
 196
 197                 /* Complete entry in Info column on summary display */
 198                 /* ------------------------------------------------ */
 199
 200                 if (check_col(pinfo->cinfo, COL_INFO))
 201                 {
 202                         lct_info_column(&alc.lct, pinfo);
 203                         fec_info_column(&alc.fec, pinfo);
 204                 }
 205
 206                 /* Free g_allocated memory */
 207                 lct_dissector_free(&alc.lct);
 208                 fec_dissector_free(&alc.fec);
 209
 210         } else {
 211
 212                 if (tree)
 213                         proto_tree_add_text(alc_tree, tvb, 0, -1, "Sorry, this dissector supports ALC version 1 only");
 214
 215                 /* Complete entry in Info column on summary display */
 216                 if (check_col(pinfo->cinfo, COL_INFO))
 217                         col_add_fstr(pinfo->cinfo, COL_INFO, "Version: %u (not supported)", alc.version);
 218         }
 219 }
 220
 221 void proto_reg_handoff_alc(void)
 222 {
 223         static dissector_handle_t handle;
 224         static gboolean preferences_initialized = FALSE;
 225         static struct _alc_prefs preferences_old;
 226
 227         if (!preferences_initialized)
 228         {
 229                 preferences_initialized = TRUE;
 230                 handle = create_dissector_handle(dissect_alc, proto);
 231                 dissector_add_handle("udp.port", handle);
 232                 xml_handle = find_dissector("xml");
 233
 234         } else {
 235
 236                 if (preferences_old.use_default_udp_port)
 237                         dissector_delete("udp.port", preferences_old.default_udp_port, handle);
 238         }
 239
 240         if (preferences.use_default_udp_port)
 241                 dissector_add("udp.port", preferences.default_udp_port, handle);
 242
 243         alc_prefs_save(&preferences, &preferences_old);
 244
 245 }
 246
 247 void proto_register_alc(void)
 248 {
 249         /* Setup ALC header fields */
 250         static hf_register_info hf_ptr[] = {
 251
 252                 { &hf.version,
 253                         { "Version", "alc.version", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
 254
 255                 LCT_FIELD_ARRAY(hf.lct, "alc"),
 256                 FEC_FIELD_ARRAY(hf.fec, "alc"),
 257
 258                 { &hf.payload,
 259                         { "Payload", "alc.payload", FT_NONE, BASE_NONE, NULL, 0x0, "", HFILL }}
 260         };
 261
 262         /* Setup protocol subtree array */
 263         static gint *ett_ptr[] = {
 264                 &ett.main,
 265
 266                 LCT_SUBTREE_ARRAY(ett.lct),
 267                 FEC_SUBTREE_ARRAY(ett.fec)
 268         };
 269
 270         module_t *module;
 271
 272         /* Clear hf and ett fields */
 273         memset(&hf, 0xff, sizeof(struct _alc_hf));
 274         memset(&ett, 0xff, sizeof(struct _alc_ett));
 275
 276         /* Register the protocol name and description */
 277         proto = proto_register_protocol("Asynchronous Layered Coding", "ALC", "alc");
 278
 279         /* Register the header fields and subtrees used */
 280         proto_register_field_array(proto, hf_ptr, array_length(hf_ptr));
 281         proto_register_subtree_array(ett_ptr, array_length(ett_ptr));
 282
 283         /* Reset preferences */
 284         alc_prefs_set_default(&preferences);
 285
 286         /* Register preferences */
 287         module = prefs_register_protocol(proto, proto_reg_handoff_alc);
 288         alc_prefs_register(&preferences, module);
 289
 290 }