epan/dissectors/packet-dcp-etsi.c

   1 /* packet-dcp-etsi.c
   2  * Routines for ETSI Distribution & Communication Protocol
   3  * Copyright 2006, British Broadcasting Corporation
   4  *
   5  * $Id$
   6  *
   7  * Wireshark - Network traffic analyzer
   8  * By Gerald Combs <gerald@wireshark.org>
   9  * Copyright 1998 Gerald Combs
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  24  *
  25  * Protocol info
  26  * Ref: ETSI DCP (ETSI TS 102 821)
  27  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #include <epan/packet.h>
  34 #include <epan/reassemble.h>
  35 #include <wsutil/crcdrm.h>
  36 #include <epan/reedsolomon.h>
  37 #include <epan/emem.h>
  38 #include <string.h>
  39
  40 /* forward reference */
  41
  42 static gboolean dissect_dcp_etsi (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree);
  43 static void dissect_af (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree);
  44 static void dissect_pft (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree);
  45 static void dissect_tpl(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree);
  46
  47 static dissector_table_t dcp_dissector_table;
  48 static dissector_table_t af_dissector_table;
  49 static dissector_table_t tpl_dissector_table;
  50
  51 static int proto_dcp_etsi = -1;
  52 static int proto_af = -1;
  53 static int proto_pft = -1;
  54 static int proto_tpl = -1;
  55 static int hf_edcp_sync = -1;
  56 static int hf_edcp_len = -1;
  57 static int hf_edcp_seq = -1;
  58 static int hf_edcp_crcflag = -1;
  59 static int hf_edcp_maj = -1;
  60 static int hf_edcp_min = -1;
  61 static int hf_edcp_pt = -1;
  62 static int hf_edcp_crc = -1;
  63 static int hf_edcp_crc_ok = -1;
  64 static int hf_edcp_pft_pt = -1;
  65 static int hf_edcp_pseq = -1;
  66 static int hf_edcp_findex = -1;
  67 static int hf_edcp_fcount = -1;
  68 static int hf_edcp_fecflag = -1;
  69 static int hf_edcp_addrflag = -1;
  70 static int hf_edcp_plen = -1;
  71 static int hf_edcp_rsk = -1;
  72 static int hf_edcp_rsz = -1;
  73 static int hf_edcp_source = -1;
  74 static int hf_edcp_dest = -1;
  75 static int hf_edcp_hcrc = -1;
  76 static int hf_edcp_hcrc_ok = -1;
  77 static int hf_edcp_c_max = -1;
  78 static int hf_edcp_rx_min = -1;
  79 static int hf_edcp_rs_corrected = -1;
  80 static int hf_edcp_rs_ok = -1;
  81 static int hf_edcp_pft_payload = -1;
  82
  83 static int hf_tpl_tlv = -1;
  84 static int hf_tpl_ptr = -1;
  85
  86 static int hf_edcp_fragments = -1;
  87 static int hf_edcp_fragment = -1;
  88 static int hf_edcp_fragment_overlap = -1;
  89 static int hf_edcp_fragment_overlap_conflicts = -1;
  90 static int hf_edcp_fragment_multiple_tails = -1;
  91 static int hf_edcp_fragment_too_long_fragment = -1;
  92 static int hf_edcp_fragment_error = -1;
  93 static int hf_edcp_fragment_count = -1;
  94 static int hf_edcp_reassembled_in = -1;
  95 static int hf_edcp_reassembled_length = -1;
  96
  97 /* Initialize the subtree pointers */
  98 static gint ett_edcp = -1;
  99 static gint ett_af = -1;
 100 static gint ett_pft = -1;
 101 static gint ett_tpl = -1;
 102 static gint ett_edcp_fragment = -1;
 103 static gint ett_edcp_fragments = -1;
 104
 105 static GHashTable *dcp_fragment_table = NULL;
 106 static GHashTable *dcp_reassembled_table = NULL;
 107
 108 static const fragment_items dcp_frag_items = {
 109 /* Fragment subtrees */
 110   &ett_edcp_fragment,
 111   &ett_edcp_fragments,
 112 /* Fragment fields */
 113   &hf_edcp_fragments,
 114   &hf_edcp_fragment,
 115   &hf_edcp_fragment_overlap,
 116   &hf_edcp_fragment_overlap_conflicts,
 117   &hf_edcp_fragment_multiple_tails,
 118   &hf_edcp_fragment_too_long_fragment,
 119   &hf_edcp_fragment_error,
 120   &hf_edcp_fragment_count,
 121 /* Reassembled in field */
 122   &hf_edcp_reassembled_in,
 123 /* Reassembled length field */
 124   &hf_edcp_reassembled_length,
 125 /* Tag */
 126   "Message fragments"
 127 };
 128
 129 /** initialise the DCP protocol. Details follow
 130  *  here.
 131  */
 132 static void
 133 dcp_init_protocol(void)
 134 {
 135   fragment_table_init (&dcp_fragment_table);
 136   reassembled_table_init (&dcp_reassembled_table);
 137 }
 138
 139
 140 /** Dissect a DCP packet. Details follow
 141  *  here.
 142  *  \param[in,out] tvb The buffer containing the packet
 143  *  \param[in,out] pinfo The packet info structure
 144  *  \param[in,out] tree The structure containing the details which will be displayed, filtered, etc.
 145 static void
 146  */
 147 static gboolean
 148 dissect_dcp_etsi (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
 149 {
 150   guint8 *sync;
 151   proto_tree *dcp_tree = NULL;
 152
 153   /* 6.1 AF packet structure
 154    *
 155    * AF Header
 156    * SYNC               LEN             SEQ             AR              PT
 157    * 2 bytes    4 bytes 2 bytes 1 byte  1 byte
 158    *
 159    * SYNC: two-byte ASCII representation of "AF".
 160    * LEN: length of the payload, in bytes.
 161    * SEQ: sequence number
 162    * AR: AF protocol Revision - a field combining the CF, MAJ and MIN fields
 163    * CF: CRC Flag, 0 if the CRC field is not used
 164    * MAJ: major revision of the AF protocol in use, see clause 6.2.
 165    * MIN: minor revision of the AF protocol in use, see clause 6.2.
 166    * Protocol Type (PT): single byte encoding the protocol of the data carried in the payload. For TAG Packets, the value
 167    * shall be the ASCII representation of "T".
 168    *
 169    * 7.1 PFT fragment structure
 170    * PFT Header
 171    * 14, 16, 18 or 20 bytes (depending on options)                                                                              Optional present if FEC=1 Optional present if Addr = 1
 172    * Psync              Pseq            Findex          Fcount          FEC             HCRC            Addr    Plen    | RSk           RSz                     | Source        Dest
 173    * 16 bits    16 bits         24 bits         24 bits         1 bit   16 bits         1 bit   14 bits | 8 bits        8 bits          | 16 bits       16 bits
 174    *
 175    * Psync: the ASCII string "PF" is used as the synchronization word for the PFT Layer
 176    *
 177    * Don't accept this packet unless at least a full AF header present(10 bytes).
 178    * It should be possible to strengthen the heuristic further if need be.
 179    */
 180   if(tvb_length(tvb) < 11)
 181     return FALSE;
 182
 183   sync = tvb_get_ephemeral_string (tvb, 0, 2);
 184   if((sync[0]!='A' && sync[0]!='P') || sync[1]!='F')
 185     return FALSE;
 186
 187   pinfo->current_proto = "DCP (ETSI)";
 188
 189   /* Clear out stuff in the info column */
 190   col_clear(pinfo->cinfo, COL_INFO);
 191   col_set_str (pinfo->cinfo, COL_PROTOCOL, "DCP (ETSI)");
 192     /*col_append_fstr (pinfo->cinfo, COL_INFO, " tvb %d", tvb_length(tvb));*/
 193
 194   if(tree) {
 195     proto_item *ti = NULL;
 196     ti = proto_tree_add_item (tree, proto_dcp_etsi, tvb, 0, -1, ENC_NA);
 197     dcp_tree = proto_item_add_subtree (ti, ett_edcp);
 198   }
 199
 200   dissector_try_string(dcp_dissector_table, (char*)sync, tvb, pinfo, dcp_tree);
 201   return TRUE;
 202 }
 203
 204 #define PFT_RS_N_MAX 207
 205 #define PFT_RS_K 255
 206 #define PFT_RS_P (PFT_RS_K - PFT_RS_N_MAX)
 207
 208
 209 static
 210 void rs_deinterleave(const guint8 *input, guint8 *output, guint16 plen, guint32 fcount)
 211 {
 212   guint fidx;
 213   for(fidx=0; fidx<fcount; fidx++)
 214   {
 215     int r;
 216     for (r=0; r<plen; r++)
 217     {
 218       output[fidx+r*fcount] = input[fidx*plen+r];
 219     }
 220   }
 221 }
 222
 223 static
 224 gboolean rs_correct_data(guint8 *deinterleaved, guint8 *output,
 225  guint32 c_max, guint16 rsk, guint16 rsz _U_)
 226 {
 227   guint32 i, index_coded = 0, index_out = 0;
 228   int err_corr;
 229   for (i=0; i<c_max; i++)
 230   {
 231     memcpy(output+index_out, deinterleaved+index_coded, rsk);
 232     index_coded += rsk;
 233     memcpy(output+index_out+PFT_RS_N_MAX, deinterleaved+index_coded, PFT_RS_P);
 234     index_coded += PFT_RS_P;
 235     err_corr = eras_dec_rs(output+index_out, NULL, 0);
 236     if (err_corr<0) {
 237       return FALSE;
 238     }
 239     index_out += rsk;
 240   }
 241   return TRUE;
 242 }
 243
 244 /* Don't attempt reassembly if we have a huge number of fragments. */
 245 #define MAX_FRAGMENTS ((1 * 1024 * 1024) / sizeof(guint32))
 246
 247 static tvbuff_t *
 248 dissect_pft_fec_detailed(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree,
 249   guint32 findex _U_,
 250   guint32 fcount,
 251   guint16 seq,
 252   gint offset,
 253   guint16 plen,
 254   gboolean fec _U_,
 255   guint16 rsk,
 256   guint16 rsz,
 257   fragment_data *fdx
 258 )
 259 {
 260   guint16 decoded_size;
 261   guint32 c_max;
 262   guint32 rx_min;
 263   tvbuff_t *new_tvb=NULL;
 264
 265   if (fcount > MAX_FRAGMENTS) {
 266     if (tree)
 267       proto_tree_add_text(tree, tvb , 0, -1, "[Reassembly of %d fragments not attempted]", fcount);
 268     return NULL;
 269   }
 270
 271   decoded_size = fcount*plen;
 272   c_max = fcount*plen/(rsk+PFT_RS_P);  /* rounded down */
 273   rx_min = c_max*rsk/plen;
 274   if(rx_min*plen<c_max*rsk)
 275     rx_min++;
 276   if (fdx)
 277     new_tvb = process_reassembled_data (tvb, offset, pinfo,
 278                                         "Reassembled DCP (ETSI)",
 279                                         fdx, &dcp_frag_items,
 280                                         NULL, tree);
 281   else {
 282     guint fragments=0;
 283     guint32 *got;
 284     fragment_data *fd;
 285     fragment_data *fd_head;
 286
 287     if(tree)
 288       proto_tree_add_text (tree, tvb, 0, -1, "want %d, got %d need %d",
 289                            fcount, fragments, rx_min
 290         );
 291     got = ep_alloc(fcount*sizeof(guint32));
 292
 293     /* make a list of the findex (offset) numbers of the fragments we have */
 294     fd = fragment_get(pinfo, seq, dcp_fragment_table);
 295     for (fd_head = fd; fd_head != NULL; fd_head = fd_head->next) {
 296       if(fd_head->data) {
 297         got[fragments++] = fd_head->offset; /* this is the findex of the fragment */
 298       }
 299     }
 300     /* put a sentinel at the end */
 301     got[fragments++] = fcount;
 302     /* have we got enough for Reed Solomon to try to correct ? */
 303     if(fragments>=rx_min) { /* yes, in theory */
 304       guint i,current_findex;
 305       fragment_data *frag=NULL;
 306       guint8 *dummy_data = (guint8*) ep_alloc0 (plen);
 307       tvbuff_t *dummytvb = tvb_new_real_data(dummy_data, plen, plen);
 308       /* try and decode with missing fragments */
 309       if(tree)
 310           proto_tree_add_text (tree, tvb, 0, -1, "want %d, got %d need %d",
 311                                fcount, fragments, rx_min
 312             );
 313       /* fill the fragment table with empty fragments */
 314       current_findex = 0;
 315       for(i=0; i<fragments; i++) {
 316         guint next_fragment_we_have = got[i];
 317         if (next_fragment_we_have > MAX_FRAGMENTS) {
 318           if (tree)
 319             proto_tree_add_text(tree, tvb , 0, -1, "[Reassembly of %d fragments not attempted]", next_fragment_we_have);
 320           return NULL;
 321         }
 322         for(; current_findex<next_fragment_we_have; current_findex++) {
 323           frag = fragment_add_seq_check (dummytvb, 0, pinfo, seq,
 324                                          dcp_fragment_table, dcp_reassembled_table,
 325                                          current_findex, plen, (current_findex+1!=fcount));
 326         }
 327         current_findex++; /* skip over the fragment we have */
 328       }
 329       tvb_free(dummytvb);
 330
 331       if(frag)
 332         new_tvb = process_reassembled_data (tvb, offset, pinfo,
 333                                             "Reassembled DCP (ETSI)",
 334                                             frag, &dcp_frag_items,
 335                                             NULL, tree);
 336     }
 337   }
 338   if(new_tvb) {
 339     gboolean decoded = TRUE;
 340     tvbuff_t *dtvb = NULL;
 341     const guint8 *input = tvb_get_ptr(new_tvb, 0, -1);
 342     guint16 reassembled_size = tvb_length(new_tvb);
 343     guint8 *deinterleaved = (guint8*) g_malloc (reassembled_size);
 344     guint8 *output = (guint8*) g_malloc (decoded_size);
 345     rs_deinterleave(input, deinterleaved, plen, fcount);
 346
 347     dtvb = tvb_new_child_real_data(tvb, deinterleaved, reassembled_size, reassembled_size);
 348     add_new_data_source(pinfo, dtvb, "Deinterleaved");
 349     tvb_set_free_cb(dtvb, g_free);
 350
 351     decoded = rs_correct_data(deinterleaved, output, c_max, rsk, rsz);
 352     if(tree)
 353       proto_tree_add_boolean (tree, hf_edcp_rs_ok, tvb, offset, 2, decoded);
 354
 355     new_tvb = tvb_new_child_real_data(dtvb, output, decoded_size, decoded_size);
 356     add_new_data_source(pinfo, new_tvb, "RS Error Corrected Data");
 357     tvb_set_free_cb(new_tvb, g_free);
 358   }
 359   return new_tvb;
 360 }
 361
 362
 363 /** Handle a PFT packet which has the fragmentation header. This uses the
 364  * standard wireshark methods for reassembling fragments. If FEC is used,
 365  * the FEC is handled too. For the moment, all the fragments must be
 366  * available but this could be improved.
 367  *  \param[in,out] tvb The buffer containing the current fragment
 368  *  \param[in,out] pinfo The packet info structure
 369  *  \param[in,out] tree The structure containing the details which will be displayed, filtered, etc.
 370  *  \param[in] findex the fragment count
 371  *  \param[in] fcount the number of fragments
 372  *  \param[in] seq the sequence number of the reassembled packet
 373  *  \param[in] offset the offset into the tvb of the fragment
 374  *  \param[in] plen the length of each fragment
 375  *  \param[in] fec is fec used
 376  *  \param[in] rsk the number of useful bytes in each chunk
 377  *  \param[in] rsz the number of padding bytes in each chunk
 378  */
 379 static tvbuff_t *
 380 dissect_pft_fragmented(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree,
 381   guint32 findex,
 382   guint32 fcount,
 383   guint16 seq,
 384   gint offset,
 385   guint16 plen,
 386   gboolean fec,
 387   guint16 rsk,
 388   guint16 rsz
 389 )
 390 {
 391   gboolean first, last;
 392   tvbuff_t *new_tvb=NULL;
 393   fragment_data *frag_edcp = NULL;
 394   pinfo->fragmented = TRUE;
 395   first = findex == 0;
 396   last = fcount == (findex+1);
 397   frag_edcp = fragment_add_seq_check (
 398     tvb, offset, pinfo,
 399     seq,
 400     dcp_fragment_table, dcp_reassembled_table,
 401     findex,
 402     plen,
 403     !last);
 404   if(fec) {
 405     new_tvb = dissect_pft_fec_detailed(
 406       tvb, pinfo, tree, findex, fcount, seq, offset, plen, fec, rsk, rsz, frag_edcp
 407       );
 408   } else {
 409     new_tvb = process_reassembled_data (tvb, offset, pinfo,
 410                                         "Reassembled DCP (ETSI)",
 411                                         frag_edcp, &dcp_frag_items,
 412                                         NULL, tree);
 413   }
 414   if(new_tvb) {
 415     col_append_str (pinfo->cinfo, COL_INFO, " (Message Reassembled)");
 416   } else {
 417     if(last) {
 418       col_append_str (pinfo->cinfo, COL_INFO, " (Message Reassembly failure)");
 419     } else {
 420       col_append_fstr (pinfo->cinfo, COL_INFO, " (Message fragment %u)", findex);
 421     }
 422   }
 423   if(first)
 424     col_append_str (pinfo->cinfo, COL_INFO, " (first)");
 425   if(last)
 426    col_append_str (pinfo->cinfo, COL_INFO, " (last)");
 427   return new_tvb;
 428   }
 429
 430 /** Dissect a PFT packet. Details follow
 431  *  here.
 432  *  \param[in,out] tvb The buffer containing the packet
 433  *  \param[in,out] pinfo The packet info structure
 434  *  \param[in,out] tree The structure containing the details which will be displayed, filtered, etc.
 435  */
 436 static void
 437 dissect_pft(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
 438 {
 439   guint16 plen;
 440   gint offset = 0;
 441   guint16 seq, payload_len;
 442   guint32 findex, fcount;
 443   proto_tree *pft_tree = NULL;
 444   proto_item *ti = NULL, *li = NULL;
 445   tvbuff_t *next_tvb = NULL;
 446   gboolean fec = FALSE;
 447   guint16 rsk=0, rsz=0;
 448
 449   pinfo->current_proto = "DCP-PFT";
 450   col_set_str(pinfo->cinfo, COL_PROTOCOL, "DCP-PFT");
 451
 452   if (tree) {                   /* we are being asked for details */
 453     ti = proto_tree_add_item (tree, proto_pft, tvb, 0, -1, ENC_NA);
 454     pft_tree = proto_item_add_subtree (ti, ett_pft);
 455     proto_tree_add_item (pft_tree, hf_edcp_sync, tvb, offset, 2, ENC_ASCII|ENC_NA);
 456   }
 457   offset += 2;
 458   seq = tvb_get_ntohs (tvb, offset);
 459   if (tree) {
 460     proto_tree_add_item (pft_tree, hf_edcp_pseq, tvb, offset, 2, ENC_BIG_ENDIAN);
 461   }
 462   offset += 2;
 463   findex = tvb_get_ntoh24 (tvb, offset);
 464   if (tree) {
 465     proto_tree_add_item (pft_tree, hf_edcp_findex, tvb, offset, 3, ENC_BIG_ENDIAN);
 466   }
 467   offset += 3;
 468   fcount = tvb_get_ntoh24 (tvb, offset);
 469   if (tree) {
 470     proto_tree_add_item (pft_tree, hf_edcp_fcount, tvb, offset, 3, ENC_BIG_ENDIAN);
 471   }
 472   offset += 3;
 473   plen = tvb_get_ntohs (tvb, offset);
 474   payload_len = plen & 0x3fff;
 475   if (tree) {
 476     proto_tree_add_item (pft_tree, hf_edcp_fecflag, tvb, offset, 2, ENC_BIG_ENDIAN);
 477     proto_tree_add_item (pft_tree, hf_edcp_addrflag, tvb, offset, 2, ENC_BIG_ENDIAN);
 478     li = proto_tree_add_item (pft_tree, hf_edcp_plen, tvb, offset, 2, ENC_BIG_ENDIAN);
 479   }
 480   offset += 2;
 481   if (plen & 0x8000) {
 482     fec = TRUE;
 483     rsk = tvb_get_guint8 (tvb, offset);
 484     if (tree)
 485           proto_tree_add_item (pft_tree, hf_edcp_rsk, tvb, offset, 1, ENC_BIG_ENDIAN);
 486     offset += 1;
 487     rsz = tvb_get_guint8 (tvb, offset);
 488     if (tree)
 489           proto_tree_add_item (pft_tree, hf_edcp_rsz, tvb, offset, 1, ENC_BIG_ENDIAN);
 490     offset += 1;
 491   }
 492   if (plen & 0x4000) {
 493     if (tree)
 494       proto_tree_add_item (pft_tree, hf_edcp_source, tvb, offset, 2, ENC_BIG_ENDIAN);
 495     offset += 2;
 496     if (tree)
 497           proto_tree_add_item (pft_tree, hf_edcp_dest, tvb, offset, 2, ENC_BIG_ENDIAN);
 498     offset += 2;
 499   }
 500   if (tree) {
 501     proto_item *ci = NULL;
 502     guint header_len = offset+2;
 503     const char *crc_buf = (const char *) tvb_get_ptr(tvb, 0, header_len);
 504     unsigned long c = crc_drm(crc_buf, header_len, 16, 0x11021, 1);
 505     ci = proto_tree_add_item (pft_tree, hf_edcp_hcrc, tvb, offset, 2, ENC_BIG_ENDIAN);
 506     proto_item_append_text(ci, " (%s)", (c==0xe2f0)?"Ok":"bad");
 507     proto_tree_add_boolean(pft_tree, hf_edcp_hcrc_ok, tvb, offset, 2, c==0xe2f0);
 508   }
 509   offset += 2;
 510   if (fcount > 1) {             /* fragmented*/
 511     gboolean save_fragmented = pinfo->fragmented;
 512     guint16 real_len = tvb_length(tvb)-offset;
 513     proto_tree_add_item (pft_tree, hf_edcp_pft_payload, tvb, offset, real_len, ENC_NA);
 514     if(real_len != payload_len) {
 515       if(li)
 516         proto_item_append_text(li, " (length error (%d))", real_len);
 517     }
 518     next_tvb = dissect_pft_fragmented(tvb, pinfo, pft_tree,
 519                                       findex, fcount, seq, offset, real_len,
 520                                       fec, rsk, rsz
 521                                       );
 522     pinfo->fragmented = save_fragmented;
 523   } else {
 524     next_tvb = tvb_new_subset_remaining (tvb, offset);
 525   }
 526   if(next_tvb) {
 527     dissect_af(next_tvb, pinfo, tree);
 528   }
 529 }
 530
 531 /** Dissect an AF Packet. Parse an AF packet, checking the CRC if the CRC valid
 532  * flag is set and calling any registered sub dissectors on the payload type.
 533  * Currently only a payload type 'T' is defined which is the tag packet layer.
 534  * If any others are defined then they can register themselves.
 535  *  \param[in,out] tvb The buffer containing the packet
 536  *  \param[in,out] pinfo The packet info structure
 537  *  \param[in,out] tree The structure containing the details which will be displayed, filtered, etc.
 538  */
 539 static void
 540 dissect_af (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
 541 {
 542   gint offset = 0;
 543   proto_item *ti = NULL;
 544   proto_item *li = NULL;
 545   proto_item *ci = NULL;
 546   proto_tree *af_tree = NULL;
 547   guint8 ver, pt;
 548   guint32 payload_len;
 549   tvbuff_t *next_tvb = NULL;
 550
 551   pinfo->current_proto = "DCP-AF";
 552   col_set_str(pinfo->cinfo, COL_PROTOCOL, "DCP-AF");
 553
 554   if (tree) {                   /* we are being asked for details */
 555     ti = proto_tree_add_item (tree, proto_af, tvb, 0, -1, ENC_NA);
 556     af_tree = proto_item_add_subtree (ti, ett_af);
 557     proto_tree_add_item (af_tree, hf_edcp_sync, tvb, offset, 2, ENC_ASCII|ENC_NA);
 558   }
 559   offset += 2;
 560   payload_len = tvb_get_ntohl(tvb, offset);
 561   if (tree) {
 562     guint32 real_payload_len = tvb_length(tvb)-12;
 563     li = proto_tree_add_item (af_tree, hf_edcp_len, tvb, offset, 4, ENC_BIG_ENDIAN);
 564     if(real_payload_len < payload_len) {
 565       proto_item_append_text (li, " (wrong len claims %d is %d)",
 566       payload_len, real_payload_len
 567       );
 568     } else if(real_payload_len > payload_len) {
 569       proto_item_append_text (li, " (%d bytes in packet after end of AF frame)",
 570       real_payload_len-payload_len
 571       );
 572     }
 573   }
 574   offset += 4;
 575   if (tree)
 576     proto_tree_add_item (af_tree, hf_edcp_seq, tvb, offset, 2, ENC_BIG_ENDIAN);
 577   offset += 2;
 578   ver = tvb_get_guint8 (tvb, offset);
 579   if (tree) {
 580     proto_tree_add_item (af_tree, hf_edcp_crcflag, tvb, offset, 1, ENC_BIG_ENDIAN);
 581     proto_tree_add_item (af_tree, hf_edcp_maj, tvb, offset, 1, ENC_BIG_ENDIAN);
 582     proto_tree_add_item (af_tree, hf_edcp_min, tvb, offset, 1, ENC_BIG_ENDIAN);
 583   }
 584   offset += 1;
 585   pt = tvb_get_guint8 (tvb, offset);
 586   if (tree)
 587     proto_tree_add_item (af_tree, hf_edcp_pt, tvb, offset, 1, ENC_ASCII|ENC_NA);
 588   offset += 1;
 589   next_tvb = tvb_new_subset (tvb, offset, payload_len, -1);
 590   offset += payload_len;
 591   if (tree)
 592     ci = proto_tree_add_item (af_tree, hf_edcp_crc, tvb, offset, 2, ENC_BIG_ENDIAN);
 593   if (ver & 0x80) { /* crc valid */
 594     guint len = offset+2;
 595     const char *crc_buf = (const char *) tvb_get_ptr(tvb, 0, len);
 596     unsigned long c = crc_drm(crc_buf, len, 16, 0x11021, 1);
 597     if (tree) {
 598           proto_item_append_text(ci, " (%s)", (c==0xe2f0)?"Ok":"bad");
 599       proto_tree_add_boolean(af_tree, hf_edcp_crc_ok, tvb, offset, 2, c==0xe2f0);
 600     }
 601   }
 602   offset += 2;
 603   dissector_try_uint(af_dissector_table, pt, next_tvb, pinfo, tree);
 604 }
 605
 606 /** Dissect the Tag Packet Layer.
 607  *  Split the AF packet into its tag items. Each tag item has a 4 character
 608  *  tag, a length in bits and a value. The *ptr tag is dissected in the routine.
 609  *  All other tags are listed and may be handled by other dissectors.
 610  *  Child dissectors are tied to the parent tree, not to this tree, so that
 611  *  they appear at the same level as DCP.
 612  *  \param[in,out] tvb The buffer containing the packet
 613  *  \param[in,out] pinfo The packet info structure
 614  *  \param[in,out] tree The structure containing the details which will be displayed, filtered, etc.
 615  */
 616 static void
 617 dissect_tpl(tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
 618 {
 619   proto_tree *tpl_tree = NULL;
 620   guint offset=0;
 621   char *prot=NULL;
 622   guint16 maj, min;
 623
 624   pinfo->current_proto = "DCP-TPL";
 625   col_set_str(pinfo->cinfo, COL_PROTOCOL, "DCP-TPL");
 626
 627   if(tree) {
 628     proto_item *ti = NULL;
 629     ti = proto_tree_add_item (tree, proto_tpl, tvb, 0, -1, ENC_NA);
 630     tpl_tree = proto_item_add_subtree (ti, ett_tpl);
 631   }
 632   while(offset<tvb_length(tvb)) {
 633     guint32 bits;
 634     guint32 bytes;
 635     char *tag = (char*)tvb_get_ephemeral_string (tvb, offset, 4); offset += 4;
 636     bits = tvb_get_ntohl(tvb, offset); offset += 4;
 637     bytes = bits / 8;
 638     if(bits % 8)
 639       bytes++;
 640     if(tree) {
 641       if(strcmp(tag, "*ptr")==0) {
 642         prot = (char*)tvb_get_ephemeral_string (tvb, offset, 4);
 643         maj = tvb_get_ntohs(tvb, offset+4);
 644         min = tvb_get_ntohs(tvb, offset+6);
 645         proto_tree_add_bytes_format(tpl_tree, hf_tpl_tlv, tvb,
 646               offset-8, bytes+8, tvb_get_ptr(tvb, offset, bytes),
 647               "%s %s rev %d.%d", tag, prot, maj, min);
 648       } else {
 649         proto_tree_add_bytes_format(tpl_tree, hf_tpl_tlv, tvb,
 650               offset-8, bytes+8, tvb_get_ptr(tvb, offset, bytes),
 651               "%s (%u bits)", tag, bits);
 652       }
 653     }
 654     offset += bytes;
 655   }
 656   if(prot) {  /* prot is non-NULL only if we have our tree. */
 657     dissector_try_string(tpl_dissector_table, prot, tvb, pinfo, tree->parent);
 658   }
 659 }
 660
 661 void
 662 proto_reg_handoff_dcp_etsi (void)
 663 {
 664   dissector_handle_t af_handle;
 665   dissector_handle_t pft_handle;
 666   dissector_handle_t tpl_handle;
 667
 668   af_handle = create_dissector_handle(dissect_af, proto_af);
 669   pft_handle = create_dissector_handle(dissect_pft, proto_pft);
 670   tpl_handle = create_dissector_handle(dissect_tpl, proto_tpl);
 671   heur_dissector_add("udp", dissect_dcp_etsi, proto_dcp_etsi);
 672   dissector_add_string("dcp-etsi.sync", "AF", af_handle);
 673   dissector_add_string("dcp-etsi.sync", "PF", pft_handle);
 674   /* if there are ever other payload types ...*/
 675   dissector_add_uint("dcp-af.pt", 'T', tpl_handle);
 676 }
 677
 678 void
 679 proto_register_dcp_etsi (void)
 680 {
 681   static hf_register_info hf_edcp[] = {
 682     {&hf_edcp_sync,
 683      {"sync", "dcp-etsi.sync",
 684       FT_STRING, BASE_NONE, NULL, 0,
 685       "AF or PF", HFILL}
 686      }
 687     };
 688   static hf_register_info hf_af[] = {
 689     {&hf_edcp_len,
 690      {"length", "dcp-af.len",
 691       FT_UINT32, BASE_DEC, NULL, 0,
 692       "length in bytes of the payload", HFILL}
 693      },
 694     {&hf_edcp_seq,
 695      {"frame count", "dcp-af.seq",
 696       FT_UINT16, BASE_DEC, NULL, 0,
 697       "Logical Frame Number", HFILL}
 698      },
 699     {&hf_edcp_crcflag,
 700      {"crc flag", "dcp-af.crcflag",
 701       FT_BOOLEAN, 8, NULL, 0x80,
 702       "Frame is protected by CRC", HFILL}
 703      },
 704     {&hf_edcp_maj,
 705      {"Major Revision", "dcp-af.maj",
 706       FT_UINT8, BASE_DEC, NULL, 0x70,
 707       "Major Protocol Revision", HFILL}
 708      },
 709     {&hf_edcp_min,
 710      {"Minor Revision", "dcp-af.min",
 711       FT_UINT8, BASE_DEC, NULL, 0x0f,
 712       "Minor Protocol Revision", HFILL}
 713      },
 714     {&hf_edcp_pt,
 715      {"Payload Type", "dcp-af.pt",
 716       FT_STRING, BASE_NONE, NULL, 0,
 717       "T means Tag Packets, all other values reserved", HFILL}
 718      },
 719     {&hf_edcp_crc,
 720      {"CRC", "dcp-af.crc",
 721       FT_UINT16, BASE_HEX, NULL, 0,
 722       NULL, HFILL}
 723      },
 724     {&hf_edcp_crc_ok,
 725      {"CRC OK", "dcp-af.crc_ok",
 726       FT_BOOLEAN, BASE_NONE, NULL, 0x0,
 727       "AF CRC OK", HFILL}
 728      }
 729     };
 730
 731   static hf_register_info hf_pft[] = {
 732     {&hf_edcp_pft_pt,
 733      {"Sub-protocol", "dcp-pft.pt",
 734       FT_UINT8, BASE_DEC, NULL, 0,
 735       "Always AF", HFILL}
 736      },
 737     {&hf_edcp_pseq,
 738      {"Sequence No", "dcp-pft.seq",
 739       FT_UINT16, BASE_DEC, NULL, 0,
 740       "PFT Sequence No", HFILL}
 741      },
 742     {&hf_edcp_findex,
 743      {"Fragment Index", "dcp-pft.findex",
 744       FT_UINT24, BASE_DEC, NULL, 0,
 745       "Index of the fragment within one AF Packet", HFILL}
 746      },
 747     {&hf_edcp_fcount,
 748      {"Fragment Count", "dcp-pft.fcount",
 749       FT_UINT24, BASE_DEC, NULL, 0,
 750       "Number of fragments produced from this AF Packet", HFILL}
 751      },
 752     {&hf_edcp_fecflag,
 753      {"FEC", "dcp-pft.fec",
 754       FT_BOOLEAN, 16, NULL, 0x8000,
 755       "When set the optional RS header is present", HFILL}
 756      },
 757     {&hf_edcp_addrflag,
 758      {"Addr", "dcp-pft.addr",
 759       FT_BOOLEAN, 16, NULL, 0x4000,
 760       "When set the optional transport header is present", HFILL}
 761      },
 762     {&hf_edcp_plen,
 763      {"fragment length", "dcp-pft.len",
 764       FT_UINT16, BASE_DEC, NULL, 0x3fff,
 765       "length in bytes of the payload of this fragment", HFILL}
 766      },
 767     {&hf_edcp_rsk,
 768      {"RSk", "dcp-pft.rsk",
 769       FT_UINT8, BASE_DEC, NULL, 0,
 770       "The length of the Reed Solomon data word", HFILL}
 771      },
 772     {&hf_edcp_rsz,
 773      {"RSz", "dcp-pft.rsz",
 774       FT_UINT8, BASE_DEC, NULL, 0,
 775       "The number of padding bytes in the last Reed Solomon block", HFILL}
 776      },
 777     {&hf_edcp_source,
 778      {"source addr", "dcp-pft.source",
 779       FT_UINT16, BASE_DEC, NULL, 0,
 780       "PFT source identifier", HFILL}
 781      },
 782     {&hf_edcp_dest,
 783      {"dest addr", "dcp-pft.dest",
 784       FT_UINT16, BASE_DEC, NULL, 0,
 785       "PFT destination identifier", HFILL}
 786      },
 787     {&hf_edcp_hcrc,
 788      {"header CRC", "dcp-pft.crc",
 789       FT_UINT16, BASE_HEX, NULL, 0,
 790       "PFT Header CRC", HFILL}
 791      },
 792     {&hf_edcp_hcrc_ok,
 793      {"PFT CRC OK", "dcp-pft.crc_ok",
 794       FT_BOOLEAN, BASE_NONE, NULL, 0x0,
 795       "PFT Header CRC OK", HFILL}
 796      },
 797     {&hf_edcp_fragments,
 798      {"Message fragments", "dcp-pft.fragments",
 799       FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL}},
 800     {&hf_edcp_fragment,
 801      {"Message fragment", "dcp-pft.fragment",
 802       FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL}},
 803     {&hf_edcp_fragment_overlap,
 804      {"Message fragment overlap", "dcp-pft.fragment.overlap",
 805       FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL}},
 806     {&hf_edcp_fragment_overlap_conflicts,
 807      {"Message fragment overlapping with conflicting data",
 808       "dcp-pft.fragment.overlap.conflicts",
 809       FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL}},
 810     {&hf_edcp_fragment_multiple_tails,
 811      {"Message has multiple tail fragments",
 812       "dcp-pft.fragment.multiple_tails",
 813       FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL}},
 814     {&hf_edcp_fragment_too_long_fragment,
 815      {"Message fragment too long", "dcp-pft.fragment.too_long_fragment",
 816       FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL}},
 817     {&hf_edcp_fragment_error,
 818      {"Message defragmentation error", "dcp-pft.fragment.error",
 819       FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL}},
 820     {&hf_edcp_fragment_count,
 821      {"Message fragment count", "dcp-pft.fragment.count",
 822       FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL}},
 823     {&hf_edcp_reassembled_in,
 824      {"Reassembled in", "dcp-pft.reassembled.in",
 825       FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL}},
 826     {&hf_edcp_reassembled_length,
 827      {"Reassembled DCP (ETSI) length", "dcp-pft.reassembled.length",
 828       FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL}},
 829     {&hf_edcp_c_max,
 830      {"C max", "dcp-pft.cmax",
 831       FT_UINT16, BASE_DEC, NULL, 0,
 832       "Maximum number of RS chunks sent", HFILL}
 833      },
 834     {&hf_edcp_rx_min,
 835      {"Rx min", "dcp-pft.rxmin",
 836       FT_UINT16, BASE_DEC, NULL, 0,
 837       "Minimum number of fragments needed for RS decode", HFILL}
 838      },
 839     {&hf_edcp_rs_corrected,
 840      {"RS Symbols Corrected", "dcp-pft.rs_corrected",
 841       FT_INT16, BASE_DEC, NULL, 0,
 842       "Number of symbols corrected by RS decode or -1 for failure", HFILL}
 843      },
 844     {&hf_edcp_rs_ok,
 845      {"RS decode OK", "dcp-pft.rs_ok",
 846       FT_BOOLEAN, BASE_NONE, NULL, 0x0,
 847       "successfully decoded RS blocks", HFILL}
 848      },
 849     {&hf_edcp_pft_payload,
 850      {"payload", "dcp-pft.payload",
 851       FT_BYTES, BASE_NONE, NULL, 0,
 852       "PFT Payload", HFILL}
 853     }
 854   };
 855
 856   static hf_register_info hf_tpl[] = {
 857     {&hf_tpl_tlv,
 858      {"tag", "dcp-tpl.tlv",
 859       FT_BYTES, BASE_NONE, NULL, 0,
 860       "Tag Packet", HFILL}
 861      },
 862     {&hf_tpl_ptr,
 863      {"Type", "dcp-tpl.ptr",
 864       FT_STRING, BASE_NONE, NULL, 0,
 865       "Protocol Type & Revision", HFILL}
 866      }
 867     };
 868
 869 /* Setup protocol subtree array */
 870   static gint *ett[] = {
 871     &ett_edcp,
 872     &ett_af,
 873     &ett_pft,
 874     &ett_tpl,
 875     &ett_edcp_fragment,
 876     &ett_edcp_fragments
 877   };
 878
 879   proto_dcp_etsi = proto_register_protocol ("ETSI Distribution & Communication Protocol (for DRM)",     /* name */
 880                                             "DCP (ETSI)",       /* short name */
 881                                             "dcp-etsi"  /* abbrev */
 882     );
 883   proto_af = proto_register_protocol ("DCP Application Framing Layer", "DCP-AF", "dcp-af");
 884   proto_pft = proto_register_protocol ("DCP Protection, Fragmentation & Transport Layer", "DCP-PFT", "dcp-pft");
 885   proto_tpl = proto_register_protocol ("DCP Tag Packet Layer", "DCP-TPL", "dcp-tpl");
 886
 887   proto_register_field_array (proto_dcp_etsi, hf_edcp, array_length (hf_edcp));
 888   proto_register_field_array (proto_af, hf_af, array_length (hf_af));
 889   proto_register_field_array (proto_pft, hf_pft, array_length (hf_pft));
 890   proto_register_field_array (proto_tpl, hf_tpl, array_length (hf_tpl));
 891   proto_register_subtree_array (ett, array_length (ett));
 892
 893   /* subdissector code */
 894   dcp_dissector_table = register_dissector_table("dcp-etsi.sync",
 895             "DCP Sync", FT_STRING, BASE_NONE);
 896   af_dissector_table = register_dissector_table("dcp-af.pt",
 897             "AF Payload Type", FT_UINT8, BASE_DEC);
 898
 899   tpl_dissector_table = register_dissector_table("dcp-tpl.ptr",
 900             "AF Payload Type", FT_STRING, BASE_NONE);
 901
 902   register_init_routine(dcp_init_protocol);
 903
 904 }
 905
 906