epan/dissectors/packet-iuup.c

   1 /* packet-iuup.c
   2  * IuUP Protocol 3GPP TS 25.415 V6.2.0 (2005-03)
   3  *
   4  * (c) 2005 Luis E. Garcia Ontanon <luis@ontanon.org>
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  23  */
  24
  25
  26 /*
  27    Patch by Polystar (Peter Vestman, Petter Edblom):
  28       Corrected rfci handling in rate control messages
  29       Added crc6 and crc10 checks for header and payload
  30 */
  31
  32 #include "config.h"
  33
  34 #include <glib.h>
  35 #include <epan/packet.h>
  36 #include <epan/prefs.h>
  37 #include <epan/wmem/wmem.h>
  38 #include <epan/expert.h>
  39 #include <epan/crc10-tvb.h>
  40 #include <wsutil/crc10.h>
  41 #include <wsutil/crc6.h>
  42
  43 void proto_reg_handoff_iuup(void);
  44 void proto_register_iuup(void);
  45
  46 typedef struct _iuup_rfci_t {
  47     guint id;
  48     guint sum_len;
  49     guint num_of_subflows;
  50     struct {
  51         guint len;
  52     } subflow[8];
  53     struct _iuup_rfci_t* next;
  54 } iuup_rfci_t;
  55
  56 typedef struct {
  57     guint32 id;
  58     guint num_of_subflows;
  59     iuup_rfci_t* rfcis;
  60     iuup_rfci_t* last_rfci;
  61 } iuup_circuit_t;
  62
  63 static int proto_iuup = -1;
  64
  65 static int hf_iuup_direction = -1;
  66 static int hf_iuup_circuit_id = -1;
  67
  68 static int hf_iuup_pdu_type = -1;
  69 static int hf_iuup_frame_number = -1;
  70 static int hf_iuup_fqc = -1;
  71 static int hf_iuup_rfci = -1;
  72 static int hf_iuup_hdr_crc = -1;
  73 static int hf_iuup_payload_crc = -1;
  74
  75 static int hf_iuup_ack_nack = -1;
  76 static int hf_iuup_frame_number_t14 = -1;
  77 static int hf_iuup_mode_version = -1;
  78 static int hf_iuup_procedure_indicator = -1;
  79 static int hf_iuup_error_cause_val = -1;
  80
  81 static int hf_iuup_init_ti = -1;
  82 static int hf_iuup_init_subflows_per_rfci = -1;
  83 static int hf_iuup_init_chain_ind = -1;
  84
  85 static int hf_iuup_error_distance = -1;
  86 static int hf_iuup_errorevt_cause_val = -1;
  87
  88 static int hf_iuup_time_align = -1;
  89 static int hf_iuup_spare_bytes = -1;
  90 static int hf_iuup_spare_03 = -1;
  91 /* static int hf_iuup_spare_0f = -1; */
  92 /* static int hf_iuup_spare_c0 = -1; */
  93 static int hf_iuup_spare_e0 = -1;
  94 static int hf_iuup_spare_ff = -1;
  95
  96 static int hf_iuup_delay = -1;
  97 static int hf_iuup_advance = -1;
  98 static int hf_iuup_delta = -1;
  99
 100 static int hf_iuup_mode_versions = -1;
 101 static int hf_iuup_mode_versions_a[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
 102
 103
 104 static int hf_iuup_data_pdu_type = -1;
 105
 106 static int hf_iuup_num_rfci_ind = -1;
 107
 108 static int hf_iuup_payload = -1;
 109
 110 static int hf_iuup_init_rfci_ind = -1;
 111 static int hf_iuup_init_rfci[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
 112
 113 static int hf_iuup_init_rfci_flow_len[64][8] = {
 114     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 115     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 116     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 117     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 118     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 119     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 120     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 121     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1}
 122 };
 123
 124 static int hf_iuup_init_rfci_li[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
 125 static int hf_iuup_init_rfci_lri[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
 126 static int hf_iuup_init_ipti[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
 127
 128 static int hf_iuup_rfci_subflow[64][8] = {
 129     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 130     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 131     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 132     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 133     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 134     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 135     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},
 136     {-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1}
 137 };
 138
 139 static int hf_iuup_rfci_ratectl[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
 140
 141
 142 static gint ett_iuup = -1;
 143 static gint ett_rfci = -1;
 144 static gint ett_ipti = -1;
 145 static gint ett_support = -1;
 146 static gint ett_time = -1;
 147 static gint ett_rfciinds = -1;
 148 static gint ett_payload = -1;
 149 static gint ett_payload_subflows = -1;
 150
 151 static expert_field ei_iuup_hdr_crc_bad = EI_INIT;
 152 static expert_field ei_iuup_payload_crc_bad = EI_INIT;
 153 static expert_field ei_iuup_payload_undecoded = EI_INIT;
 154 static expert_field ei_iuup_error_response = EI_INIT;
 155 static expert_field ei_iuup_ack_nack = EI_INIT;
 156 static expert_field ei_iuup_time_align = EI_INIT;
 157 static expert_field ei_iuup_procedure_indicator = EI_INIT;
 158 static expert_field ei_iuup_pdu_type = EI_INIT;
 159
 160 static GHashTable* circuits = NULL;
 161
 162 static dissector_handle_t data_handle = NULL;
 163 static gboolean dissect_fields = FALSE;
 164 static gboolean two_byte_pseudoheader = FALSE;
 165 static guint global_dynamic_payload_type = 0;
 166
 167
 168 #define PDUTYPE_DATA_WITH_CRC 0
 169 #define PDUTYPE_DATA_NO_CRC 1
 170 #define PDUTYPE_DATA_CONTROL_PROC 14
 171
 172 static const value_string iuup_pdu_types[] = {
 173     {PDUTYPE_DATA_WITH_CRC,"Data with CRC"},
 174     {PDUTYPE_DATA_NO_CRC,"Data without CRC"},
 175     {PDUTYPE_DATA_CONTROL_PROC,"Control Procedure"},
 176     {0,NULL}
 177 };
 178
 179 static const value_string iuup_colinfo_pdu_types[] = {
 180     {PDUTYPE_DATA_WITH_CRC,"Data (CRC)"},
 181     {PDUTYPE_DATA_NO_CRC,"Data (no CRC)"},
 182     {PDUTYPE_DATA_CONTROL_PROC,""},
 183     {0,NULL}
 184 };
 185
 186 #define ACKNACK_ACK 0x4
 187 #define ACKNACK_NACK 0x8
 188 #define ACKNACK_RESERVED 0xc
 189 #define ACKNACK_PROC 0x0
 190
 191 static const value_string iuup_acknack_vals[] = {
 192     {ACKNACK_PROC >> 2,"Procedure"},
 193     {ACKNACK_ACK >> 2,"ACK"},
 194     {ACKNACK_NACK  >> 2,"NACK"},
 195     {ACKNACK_RESERVED  >> 2,"Reserved"},
 196     {0,NULL}
 197 };
 198
 199 static const value_string iuup_colinfo_acknack_vals[] = {
 200     {ACKNACK_PROC,""},
 201     {ACKNACK_ACK,"ACK "},
 202     {ACKNACK_NACK,"NACK "},
 203     {ACKNACK_RESERVED,"Reserved "},
 204     {0,NULL}
 205 };
 206
 207 #define PROC_INIT 0
 208 #define PROC_RATE 1
 209 #define PROC_TIME 2
 210 #define PROC_ERROR 3
 211
 212 static const value_string iuup_procedures[] = {
 213     {PROC_INIT,"Initialization"},
 214     {PROC_RATE,"Rate Control"},
 215     {PROC_TIME,"Time Alignment"},
 216     {PROC_ERROR,"Error Event"},
 217     {4,"Reserved(4)"},
 218     {5,"Reserved(5)"},
 219     {6,"Reserved(6)"},
 220     {7,"Reserved(7)"},
 221     {8,"Reserved(8)"},
 222     {9,"Reserved(9)"},
 223     {10,"Reserved(10)"},
 224     {11,"Reserved(11)"},
 225     {12,"Reserved(12)"},
 226     {13,"Reserved(13)"},
 227     {14,"Reserved(14)"},
 228     {15,"Reserved(15)"},
 229     {0,NULL}
 230 };
 231
 232 static const value_string iuup_colinfo_procedures[] = {
 233     {PROC_INIT,"Initialization "},
 234     {PROC_RATE,"Rate Control "},
 235     {PROC_TIME,"Time Alignment "},
 236     {PROC_ERROR,"Error Event "},
 237     {0,NULL}
 238 };
 239
 240
 241 static const value_string iuup_error_distances[] = {
 242     {0, "Reporting local error"},
 243     {1, "First forwarding of error event report"},
 244     {2, "Second forwarding of error event report"},
 245     {3, "Reserved"},
 246     {0,NULL}
 247 };
 248
 249 static const value_string iuup_error_causes[] = {
 250     {0, "CRC error of frame header"},
 251     {1, "CRC error of frame payload"},
 252     {2, "Unexpected frame number"},
 253     {3, "Frame loss"},
 254     {4, "PDU type unknown"},
 255     {5, "Unknown procedure"},
 256     {6, "Unknown reserved value"},
 257     {7, "Unknown field"},
 258     {8, "Frame too short"},
 259     {9, "Missing fields"},
 260     {16, "Unexpected PDU type"},
 261     {18, "Unexpected procedure"},
 262     {19, "Unexpected RFCI"},
 263     {20, "Unexpected value"},
 264     {42, "Initialisation failure"},
 265     {43, "Initialisation failure (network error, timer expiry)"},
 266     {44, "Initialisation failure (Iu UP function error, repeated NACK)"},
 267     {45, "Rate control failure"},
 268     {46, "Error event failure"},
 269     {47, "Time Alignment not supported"},
 270     {48, "Requested Time Alignment not possible"},
 271     {49, "Iu UP Mode version not supported"},
 272     {0,NULL}
 273 };
 274
 275 static const value_string iuup_rfci_indicator[] = {
 276     {0, "RFCI allowed"},
 277     {1, "RFCI barred"},
 278     {0,NULL}
 279 };
 280
 281
 282 static const value_string iuup_ti_vals[] = {
 283     {0, "IPTIs not present"},
 284     {1, "IPTIs present in frame"},
 285     {0,NULL}
 286 };
 287
 288 static const value_string iuup_mode_version_support[] = {
 289     {0, "not supported"},
 290     {1, "supported"},
 291     {0,NULL}
 292 };
 293
 294 static const value_string iuup_init_rfci_li_vals[] = {
 295     {0, "one octet used"},
 296     {1, "two octets used"},
 297     {0,NULL}
 298 };
 299
 300 static const value_string iuup_init_chain_ind_vals[] = {
 301     {0, "this frame is the last frame for the procedure"},
 302     {1, "additional frames will be sent for the procedure"},
 303     {0,NULL}
 304 };
 305
 306 static const value_string iuup_init_lri_vals[] = {
 307     {0, "Not last RFCI"},
 308     {1, "Last RFCI in current frame"},
 309     {0,NULL}
 310 };
 311
 312 static const value_string iuup_payload_pdu_type[] = {
 313     {0, "PDU type 0"},
 314     {1, "PDU type 1"},
 315     {0,NULL}
 316 };
 317
 318 static const value_string iuup_fqcs[] = {
 319     {0, "Frame Good"},
 320     {1, "Frame BAD"},
 321     {2, "Frame bad due to radio"},
 322     {3, "spare"},
 323     {0,NULL}
 324 };
 325
 326
 327 static proto_item*
 328 iuup_proto_tree_add_bits(proto_tree* tree, int hf, tvbuff_t* tvb, int offset, int bit_offset, guint bits, guint8** buf) {
 329     static const guint8 masks[] = {0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe};
 330     int len = (bits + bit_offset)/8 + (((bits + bit_offset)%8) ? 0 : 1);
 331     guint8* shifted_buffer;
 332     proto_item* pi;
 333     int i;
 334
 335     DISSECTOR_ASSERT(bit_offset < 8);
 336
 337     shifted_buffer = (guint8 *)tvb_memdup(wmem_packet_scope(),tvb,offset,len+1);
 338
 339     for(i = 0; i < len; i++) {
 340         shifted_buffer[i] <<= bit_offset;
 341         shifted_buffer[i] |= (shifted_buffer[i+1] & masks[bit_offset]) >> (8 - bit_offset);
 342     }
 343
 344     shifted_buffer[len] <<=  bit_offset;
 345     shifted_buffer[len] &= masks[(bits + bit_offset)%8];
 346
 347     if (buf)
 348         *buf = shifted_buffer;
 349
 350     pi = proto_tree_add_bytes(tree, hf, tvb, offset, len + (((bits + bit_offset)%8) ? 1 : 0) , shifted_buffer);
 351     proto_item_append_text(pi, " (%i Bits)", bits);
 352
 353     return pi;
 354 }
 355
 356 static void dissect_iuup_payload(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, guint rfci_id _U_, int offset) {
 357     iuup_circuit_t* iuup_circuit;
 358     iuup_rfci_t *rfci;
 359     int last_offset = tvb_length(tvb) - 1;
 360     guint bit_offset = 0;
 361     proto_item* pi;
 362
 363     pi = proto_tree_add_item(tree,hf_iuup_payload,tvb,offset,-1,ENC_NA);
 364
 365     if ( ! dissect_fields ) {
 366         return;
 367     } else if ( ! pinfo->circuit_id
 368                 || ! ( iuup_circuit  = (iuup_circuit_t *)g_hash_table_lookup(circuits,GUINT_TO_POINTER(pinfo->circuit_id)) ) ) {
 369         expert_add_info(pinfo, pi, &ei_iuup_payload_undecoded);
 370         return;
 371     }
 372
 373     for(rfci = iuup_circuit->rfcis; rfci; rfci = rfci->next)
 374         if ( rfci->id == rfci_id )
 375             break;
 376
 377     if (!rfci) {
 378         expert_add_info(pinfo, pi, &ei_iuup_payload_undecoded);
 379         return;
 380     }
 381
 382     tree = proto_item_add_subtree(pi,ett_payload);
 383
 384
 385     do {
 386         guint i;
 387         guint subflows = rfci->num_of_subflows;
 388         proto_tree* flow_tree;
 389
 390         flow_tree = proto_tree_add_subtree(tree,tvb,offset,-1,ett_payload_subflows,NULL,"Payload Frame");
 391
 392         bit_offset = 0;
 393
 394         for(i = 0; i < subflows; i++) {
 395
 396             if (! rfci->subflow[i].len)
 397                 continue;
 398
 399             iuup_proto_tree_add_bits(flow_tree, hf_iuup_rfci_subflow[rfci->id][i], tvb,
 400                                 offset + (bit_offset/8),
 401                                 bit_offset % 8,
 402                                 rfci->subflow[i].len,
 403                                 NULL);
 404
 405             bit_offset += rfci->subflow[i].len;
 406         }
 407
 408         offset += (bit_offset / 8) + ((bit_offset % 8) ? 1 : 0);
 409
 410     } while (offset <= last_offset);
 411 }
 412
 413 static guint dissect_rfcis(tvbuff_t* tvb, packet_info* pinfo _U_, proto_tree* tree, int* offset, iuup_circuit_t* iuup_circuit) {
 414     proto_item* pi;
 415     proto_tree* pt;
 416     guint8 oct;
 417     guint c = 0;
 418     guint i;
 419
 420     do {
 421         iuup_rfci_t *rfci = wmem_new0(wmem_file_scope(), iuup_rfci_t);
 422         guint len = 0;
 423
 424         DISSECTOR_ASSERT(c < 64);
 425
 426         pi = proto_tree_add_item(tree,hf_iuup_init_rfci_ind,tvb,*offset,-1,ENC_NA);
 427         pt = proto_item_add_subtree(pi,ett_rfci);
 428
 429         proto_tree_add_item(pt,hf_iuup_init_rfci_lri[c],tvb,*offset,1,ENC_BIG_ENDIAN);
 430         proto_tree_add_item(pt,hf_iuup_init_rfci_li[c],tvb,*offset,1,ENC_BIG_ENDIAN);
 431         proto_tree_add_item(pt,hf_iuup_init_rfci[c],tvb,*offset,1,ENC_BIG_ENDIAN);
 432
 433         oct = tvb_get_guint8(tvb,*offset);
 434         rfci->id = oct & 0x3f;
 435         rfci->num_of_subflows = iuup_circuit->num_of_subflows;
 436
 437         len = (oct & 0x40) ? 2 : 1;
 438         proto_item_set_text(pi,"RFCI %i Initialization",rfci->id);
 439         proto_item_set_len(pi,(len*iuup_circuit->num_of_subflows)+1);
 440
 441         (*offset)++;
 442
 443         for(i = 0; i < iuup_circuit->num_of_subflows; i++) {
 444             guint subflow_len;
 445
 446             if (len == 2) {
 447                 subflow_len = tvb_get_ntohs(tvb,*offset);
 448             } else {
 449                 subflow_len = tvb_get_guint8(tvb,*offset);
 450             }
 451
 452             rfci->subflow[i].len = subflow_len;
 453             rfci->sum_len += subflow_len;
 454
 455             proto_tree_add_uint(pt,hf_iuup_init_rfci_flow_len[c][i],tvb,*offset,len,subflow_len);
 456
 457             (*offset) += len;
 458         }
 459
 460
 461         if (iuup_circuit->last_rfci) {
 462             iuup_circuit->last_rfci = iuup_circuit->last_rfci->next = rfci;
 463         } else {
 464             iuup_circuit->last_rfci = iuup_circuit->rfcis = rfci;
 465         }
 466
 467         c++;
 468     } while ( ! (oct & 0x80) );
 469
 470     return c - 1;
 471 }
 472
 473 static void dissect_iuup_init(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree) {
 474     int offset = 4;
 475     guint8 oct = tvb_get_guint8(tvb,offset);
 476     guint n = (oct & 0x0e) >> 1;
 477     gboolean ti = oct & 0x10;
 478     guint i;
 479     guint rfcis;
 480     proto_item* pi;
 481     proto_tree* support_tree = NULL;
 482     proto_tree* iptis_tree;
 483     iuup_circuit_t* iuup_circuit = NULL;
 484
 485     if (pinfo->circuit_id) {
 486         iuup_circuit = (iuup_circuit_t *)g_hash_table_lookup(circuits,GUINT_TO_POINTER(pinfo->circuit_id));
 487
 488         if (iuup_circuit) {
 489             g_hash_table_remove(circuits,GUINT_TO_POINTER(pinfo->circuit_id));
 490         }
 491
 492         iuup_circuit = wmem_new0(wmem_file_scope(), iuup_circuit_t);
 493     } else {
 494         iuup_circuit = wmem_new0(wmem_packet_scope(), iuup_circuit_t);
 495     }
 496
 497     iuup_circuit->id = pinfo->circuit_id;
 498     iuup_circuit->num_of_subflows = n;
 499     iuup_circuit->rfcis = NULL;
 500     iuup_circuit->last_rfci = NULL;
 501
 502     if (pinfo->circuit_id) {
 503         g_hash_table_insert(circuits,GUINT_TO_POINTER(iuup_circuit->id),iuup_circuit);
 504     }
 505
 506     if (tree) {
 507         proto_tree_add_item(tree,hf_iuup_spare_e0,tvb,offset,1,ENC_BIG_ENDIAN);
 508         proto_tree_add_item(tree,hf_iuup_init_ti,tvb,offset,1,ENC_BIG_ENDIAN);
 509         proto_tree_add_item(tree,hf_iuup_init_subflows_per_rfci,tvb,offset,1,ENC_BIG_ENDIAN);
 510         proto_tree_add_item(tree,hf_iuup_init_chain_ind,tvb,offset,1,ENC_BIG_ENDIAN);
 511     }
 512
 513     offset++;
 514
 515     rfcis = dissect_rfcis(tvb, pinfo, tree, &offset, iuup_circuit);
 516
 517     if (!tree) return;
 518
 519     if (ti) {
 520         iptis_tree = proto_tree_add_subtree(tree,tvb,offset,(rfcis/2)+(rfcis%2),ett_ipti,NULL,"IPTIs");
 521
 522         for (i = 0; i <= rfcis; i++) {
 523             proto_tree_add_item(iptis_tree,hf_iuup_init_ipti[i],tvb,offset,1,ENC_BIG_ENDIAN);
 524             if ((i%2)) {
 525                 offset++;
 526             }
 527         }
 528
 529         if ((i%2)) {
 530             offset++;
 531         }
 532     }
 533
 534     if (tree) {
 535         pi = proto_tree_add_item(tree,hf_iuup_mode_versions,tvb,offset,2,ENC_BIG_ENDIAN);
 536         support_tree = proto_item_add_subtree(pi,ett_support);
 537
 538         for (i = 0; i < 16; i++) {
 539             proto_tree_add_item(support_tree,hf_iuup_mode_versions_a[i],tvb,offset,2,ENC_BIG_ENDIAN);
 540         }
 541
 542     }
 543
 544     offset += 2;
 545
 546     proto_tree_add_item(tree,hf_iuup_data_pdu_type,tvb,offset,1,ENC_BIG_ENDIAN);
 547
 548 }
 549
 550 static void dissect_iuup_ratectl(tvbuff_t* tvb, packet_info* pinfo _U_, proto_tree* tree) {
 551     guint num = tvb_get_guint8(tvb,4) & 0x3f;
 552     guint i;
 553     proto_item* pi;
 554     proto_tree* inds_tree;
 555     int offset = 4;
 556
 557     pi = proto_tree_add_item(tree,hf_iuup_num_rfci_ind,tvb,4,1,ENC_BIG_ENDIAN);
 558     inds_tree = proto_item_add_subtree(pi,ett_rfciinds);
 559
 560     for (i = 0; i < num; i++) {
 561         if (! (i % 8) ) offset++;
 562         proto_tree_add_item(inds_tree,hf_iuup_rfci_ratectl[i],tvb,offset,1,ENC_BIG_ENDIAN);
 563     }
 564
 565 }
 566
 567 static void add_hdr_crc(tvbuff_t* tvb, packet_info* pinfo, proto_item* iuup_tree, guint16 crccheck)
 568 {
 569     proto_item *crc_item;
 570
 571     crc_item = proto_tree_add_item(iuup_tree,hf_iuup_hdr_crc,tvb,2,1,ENC_BIG_ENDIAN);
 572     if (crccheck) {
 573         proto_item_append_text(crc_item, "%s", " [incorrect]");
 574         expert_add_info(pinfo, crc_item, &ei_iuup_hdr_crc_bad);
 575     }
 576 }
 577
 578 guint16
 579 update_crc10_by_bytes_iuup(tvbuff_t *tvb, int offset, int length)
 580 {
 581     guint16 crc10;
 582     guint16 extra_16bits;
 583     guint8 extra_8bits[2];
 584
 585     crc10 = update_crc10_by_bytes_tvb(0, tvb, offset + 2, length);
 586     extra_16bits = tvb_get_ntohs(tvb, offset) & 0x3FF;
 587     extra_8bits[0] = extra_16bits >> 2;
 588     extra_8bits[1] = (extra_16bits << 6) & 0xFF;
 589     crc10 = update_crc10_by_bytes(crc10, extra_8bits, 2);
 590     return crc10;
 591 }
 592
 593 static void add_payload_crc(tvbuff_t* tvb, packet_info* pinfo, proto_item* iuup_tree)
 594 {
 595     proto_item *crc_item;
 596     int length = tvb_length(tvb);
 597     guint16 crccheck = update_crc10_by_bytes_iuup(tvb, 2, length - 4);
 598
 599     crc_item = proto_tree_add_item(iuup_tree,hf_iuup_payload_crc,tvb,2,2,ENC_BIG_ENDIAN);
 600     if (crccheck) {
 601         proto_item_append_text(crc_item, "%s", " [incorrect]");
 602         expert_add_info(pinfo, crc_item, &ei_iuup_payload_crc_bad);
 603     }
 604 }
 605
 606 #define ACKNACK_MASK  0x0c
 607 #define PROCEDURE_MASK  0x0f
 608 #define FQC_MASK 0xc0
 609 #define PDUTYPE_MASK 0xf0
 610 static void dissect_iuup(tvbuff_t* tvb_in, packet_info* pinfo, proto_tree* tree) {
 611     proto_item* pi;
 612     proto_item* iuup_item = NULL;
 613     proto_item* pdutype_item = NULL;
 614     proto_tree* iuup_tree = NULL;
 615     proto_item* proc_item = NULL;
 616     proto_item* ack_item = NULL;
 617     guint8 first_octet;
 618     guint8 second_octet;
 619     guint8 pdutype;
 620     guint phdr = 0;
 621     guint16  hdrcrc6;
 622     guint16  crccheck;
 623     tvbuff_t* tvb = tvb_in;
 624
 625     col_set_str(pinfo->cinfo, COL_PROTOCOL, "IuUP");
 626
 627     if (two_byte_pseudoheader) {
 628         int len = tvb_length(tvb_in) - 2;
 629
 630         phdr = tvb_get_ntohs(tvb,0);
 631
 632         proto_tree_add_item(tree,hf_iuup_direction,tvb,0,2,ENC_BIG_ENDIAN);
 633         proto_tree_add_item(tree,hf_iuup_circuit_id,tvb,0,2,ENC_BIG_ENDIAN);
 634
 635         phdr &= 0x7fff;
 636
 637         pinfo->circuit_id = phdr;
 638
 639         tvb = tvb_new_subset_length(tvb_in,2,len);
 640     }
 641
 642     first_octet =  tvb_get_guint8(tvb,0);
 643     second_octet =  tvb_get_guint8(tvb,1);
 644     hdrcrc6 = tvb_get_guint8(tvb, 2) >> 2;
 645     crccheck = update_crc6_by_bytes(hdrcrc6, first_octet, second_octet);
 646
 647     pdutype = ( first_octet & PDUTYPE_MASK ) >> 4;
 648
 649     if (tree) {
 650         iuup_item = proto_tree_add_item(tree,proto_iuup,tvb,0,-1,ENC_NA);
 651         iuup_tree = proto_item_add_subtree(iuup_item,ett_iuup);
 652
 653         pdutype_item = proto_tree_add_item(iuup_tree,hf_iuup_pdu_type,tvb,0,1,ENC_BIG_ENDIAN);
 654     }
 655
 656     col_add_str(pinfo->cinfo, COL_INFO, val_to_str(pdutype, iuup_colinfo_pdu_types, "Unknown PDU Type(%u) "));
 657
 658     switch(pdutype) {
 659         case PDUTYPE_DATA_WITH_CRC:
 660             col_append_fstr(pinfo->cinfo, COL_INFO,"FN: %x RFCI: %u", (guint)(first_octet & 0x0f) ,(guint)(second_octet & 0x3f));
 661
 662             proto_tree_add_item(iuup_tree,hf_iuup_frame_number,tvb,0,1,ENC_BIG_ENDIAN);
 663             pi = proto_tree_add_item(iuup_tree,hf_iuup_fqc,tvb,1,1,ENC_BIG_ENDIAN);
 664
 665             if (first_octet & FQC_MASK) {
 666                 expert_add_info(pinfo, pi, &ei_iuup_error_response);
 667             }
 668
 669             if (!tree) return;
 670             proto_tree_add_item(iuup_tree,hf_iuup_rfci,tvb,1,1,ENC_BIG_ENDIAN);
 671             add_hdr_crc(tvb, pinfo, iuup_tree, crccheck);
 672             add_payload_crc(tvb, pinfo, iuup_tree);
 673             dissect_iuup_payload(tvb,pinfo,iuup_tree,second_octet & 0x3f,4);
 674             return;
 675         case PDUTYPE_DATA_NO_CRC:
 676             col_append_fstr(pinfo->cinfo, COL_INFO," RFCI %u", (guint)(second_octet & 0x3f));
 677
 678             proto_tree_add_item(iuup_tree,hf_iuup_frame_number,tvb,0,1,ENC_BIG_ENDIAN);
 679             pi = proto_tree_add_item(iuup_tree,hf_iuup_fqc,tvb,1,1,ENC_BIG_ENDIAN);
 680
 681             if (first_octet & FQC_MASK) {
 682                 expert_add_info(pinfo, pi, &ei_iuup_error_response);
 683             }
 684
 685             if (!tree)
 686                 return;
 687             proto_tree_add_item(iuup_tree,hf_iuup_rfci,tvb,1,1,ENC_BIG_ENDIAN);
 688             add_hdr_crc(tvb, pinfo, iuup_tree, crccheck);
 689             dissect_iuup_payload(tvb,pinfo,iuup_tree,second_octet & 0x3f,3);
 690             return;
 691         case PDUTYPE_DATA_CONTROL_PROC:
 692             if (tree) {
 693                 ack_item = proto_tree_add_item(iuup_tree,hf_iuup_ack_nack,tvb,0,1,ENC_BIG_ENDIAN);
 694                 proto_tree_add_item(iuup_tree,hf_iuup_frame_number_t14,tvb,0,1,ENC_BIG_ENDIAN);
 695                 proto_tree_add_item(iuup_tree,hf_iuup_mode_version,tvb,1,1,ENC_BIG_ENDIAN);
 696                 proc_item = proto_tree_add_item(iuup_tree,hf_iuup_procedure_indicator,tvb,1,1,ENC_BIG_ENDIAN);
 697                 add_hdr_crc(tvb, pinfo, iuup_tree, crccheck);
 698             }
 699
 700             col_append_str(pinfo->cinfo, COL_INFO,
 701                            val_to_str(first_octet & ACKNACK_MASK,
 702                                       iuup_colinfo_acknack_vals, "[action:%u] "));
 703
 704             col_append_str(pinfo->cinfo, COL_INFO,
 705                            val_to_str(second_octet & PROCEDURE_MASK,
 706                                       iuup_colinfo_procedures, "[proc:%u] "));
 707
 708             switch ( first_octet & ACKNACK_MASK ) {
 709                 case ACKNACK_ACK:
 710                     switch(second_octet & PROCEDURE_MASK) {
 711                         case PROC_INIT:
 712                             if (!tree) return;
 713                             proto_tree_add_item(iuup_tree,hf_iuup_spare_03,tvb,2,1,ENC_BIG_ENDIAN);
 714                             proto_tree_add_item(iuup_tree,hf_iuup_spare_ff,tvb,3,1,ENC_BIG_ENDIAN);
 715                             return;
 716                         case PROC_RATE:
 717                             if (!tree) return;
 718                             dissect_iuup_ratectl(tvb,pinfo,iuup_tree);
 719                             return;
 720                         case PROC_TIME:
 721                         case PROC_ERROR:
 722                             break;
 723                         default:
 724                             expert_add_info(pinfo, proc_item, &ei_iuup_procedure_indicator);
 725                             return;
 726                     }
 727                     break;
 728                 case ACKNACK_NACK:
 729                     pi = proto_tree_add_item(iuup_tree,hf_iuup_error_cause_val,tvb,4,1,ENC_BIG_ENDIAN);
 730                     expert_add_info(pinfo, pi, &ei_iuup_error_response);
 731                     return;
 732                 case ACKNACK_RESERVED:
 733                     expert_add_info(pinfo, ack_item, &ei_iuup_ack_nack);
 734                     return;
 735                 case ACKNACK_PROC:
 736                     break;
 737             }
 738
 739             switch( second_octet & PROCEDURE_MASK ) {
 740                 case PROC_INIT:
 741                     if (tree) add_payload_crc(tvb, pinfo, iuup_tree);
 742                     dissect_iuup_init(tvb,pinfo,iuup_tree);
 743                     return;
 744                 case PROC_RATE:
 745                     if (!tree) return;
 746                     add_payload_crc(tvb, pinfo, iuup_tree);
 747                     dissect_iuup_ratectl(tvb,pinfo,iuup_tree);
 748                     return;
 749                 case PROC_TIME:
 750                 {
 751                     proto_tree* time_tree;
 752                     guint ta;
 753
 754                     ta = tvb_get_guint8(tvb,4);
 755
 756                     pi = proto_tree_add_item(iuup_tree,hf_iuup_time_align,tvb,4,1,ENC_BIG_ENDIAN);
 757                     time_tree = proto_item_add_subtree(pi,ett_time);
 758
 759                     if (ta >= 1 && ta <= 80) {
 760                         pi = proto_tree_add_uint(time_tree,hf_iuup_delay,tvb,4,1,ta * 500);
 761                         PROTO_ITEM_SET_GENERATED(pi);
 762                         pi = proto_tree_add_float(time_tree,hf_iuup_delta,tvb,4,1,((gfloat)((gint)(ta) * 500))/(gfloat)1000000.0);
 763                         PROTO_ITEM_SET_GENERATED(pi);
 764                     } else if (ta >= 129 && ta <= 208) {
 765                         pi = proto_tree_add_uint(time_tree,hf_iuup_advance,tvb,4,1,(ta-128) * 500);
 766                         PROTO_ITEM_SET_GENERATED(pi);
 767                         pi = proto_tree_add_float(time_tree,hf_iuup_delta,tvb,4,1,((gfloat)((gint)(-(((gint)ta)-128))) * 500)/(gfloat)1000000.0);
 768                         PROTO_ITEM_SET_GENERATED(pi);
 769                     } else {
 770                         expert_add_info(pinfo, pi, &ei_iuup_time_align);
 771                     }
 772
 773                     proto_tree_add_item(iuup_tree,hf_iuup_spare_bytes,tvb,5,-1,ENC_NA);
 774                     return;
 775                 }
 776                 case PROC_ERROR:
 777                     col_append_str(pinfo->cinfo, COL_INFO, val_to_str(tvb_get_guint8(tvb,4) & 0x3f,iuup_error_causes,"Unknown (%u)"));
 778
 779                     proto_tree_add_item(iuup_tree,hf_iuup_error_distance,tvb,4,1,ENC_BIG_ENDIAN);
 780                     pi = proto_tree_add_item(iuup_tree,hf_iuup_errorevt_cause_val,tvb,4,1,ENC_BIG_ENDIAN);
 781                     expert_add_info(pinfo, pi, &ei_iuup_error_response);
 782                     proto_tree_add_item(iuup_tree,hf_iuup_spare_bytes,tvb,5,-1,ENC_NA);
 783                     return;
 784                 default: /* bad */
 785                     expert_add_info(pinfo, proc_item, &ei_iuup_procedure_indicator);
 786                     return;
 787             }
 788         default:
 789             expert_add_info(pinfo, pdutype_item, &ei_iuup_pdu_type);
 790             return;
 791     }
 792 }
 793
 794
 795 static gboolean dissect_iuup_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
 796     int len = tvb_length(tvb);
 797
 798     guint8 first_octet =  tvb_get_guint8(tvb,0);
 799     guint8 second_octet =  tvb_get_guint8(tvb,1);
 800     guint16 hdrcrc6 = tvb_get_guint8(tvb, 2) >> 2;
 801
 802     if (update_crc6_by_bytes(hdrcrc6, first_octet, second_octet)) return FALSE;
 803
 804     switch ( first_octet & 0xf0 ) {
 805         case 0x00: {
 806             if (len<7) return FALSE;
 807             if (update_crc10_by_bytes_iuup(tvb, 4, len-4) ) return FALSE;
 808             break;
 809         }
 810         case 0x10:
 811             /* a FALSE positive factory */
 812             if (len<5) return FALSE;
 813             break;
 814         case 0xe0:
 815             if (len<5) return FALSE;
 816             if( (second_octet & 0x0f) > 3) return FALSE;
 817             break;
 818         default:
 819             return FALSE;
 820     }
 821
 822     dissect_iuup(tvb, pinfo, tree);
 823     return TRUE;
 824 }
 825
 826
 827 static void find_iuup(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
 828     int len = tvb_length(tvb);
 829     int offset = 0;
 830
 831     while (len > 3) {
 832         if ( dissect_iuup_heur(tvb_new_subset_remaining(tvb,offset), pinfo, tree) )
 833             return;
 834
 835         offset++;
 836         len--;
 837     }
 838
 839     call_dissector(data_handle, tvb, pinfo, tree);
 840 }
 841
 842 static void init_iuup(void) {
 843     if (circuits)
 844         g_hash_table_destroy(circuits);
 845     circuits = g_hash_table_new(g_direct_hash,g_direct_equal);
 846 }
 847
 848
 849 void proto_reg_handoff_iuup(void) {
 850     static gboolean iuup_prefs_initialized = FALSE;
 851     static dissector_handle_t iuup_handle;
 852     static guint saved_dynamic_payload_type = 0;
 853
 854     if (!iuup_prefs_initialized) {
 855         iuup_handle = find_dissector("iuup");
 856         dissector_add_string("rtp_dyn_payload_type","VND.3GPP.IUFP", iuup_handle);
 857         data_handle = find_dissector("data");
 858         iuup_prefs_initialized = TRUE;
 859     } else {
 860         if ( saved_dynamic_payload_type > 95 ) {
 861             dissector_delete_uint("rtp.pt", saved_dynamic_payload_type, iuup_handle);
 862         }
 863     }
 864
 865     saved_dynamic_payload_type = global_dynamic_payload_type;
 866
 867     if ( global_dynamic_payload_type > 95 ) {
 868         dissector_add_uint("rtp.pt", global_dynamic_payload_type, iuup_handle);
 869     }
 870 }
 871
 872
 873 #define HFS_RFCI(i) \
 874 { &hf_iuup_rfci_ratectl[i], { "RFCI " #i, "iuup.rfci." #i, FT_UINT8, BASE_DEC, VALS(iuup_rfci_indicator),0x80>>(i%8),NULL,HFILL}}, \
 875 { &hf_iuup_init_rfci[i], { "RFCI " #i, "iuup.rfci." #i, FT_UINT8, BASE_DEC, NULL,0x3f,NULL,HFILL}}, \
 876 { &hf_iuup_init_rfci_flow_len[i][0], { "RFCI " #i " Flow 0 Len", "iuup.rfci."#i".flow.0.len", FT_UINT16, BASE_DEC, NULL,0x0,NULL,HFILL}}, \
 877 { &hf_iuup_init_rfci_flow_len[i][1], { "RFCI " #i " Flow 1 Len", "iuup.rfci."#i".flow.1.len", FT_UINT16, BASE_DEC, NULL,0x0,NULL,HFILL}}, \
 878 { &hf_iuup_init_rfci_flow_len[i][2], { "RFCI " #i " Flow 2 Len", "iuup.rfci."#i".flow.2.len", FT_UINT16, BASE_DEC, NULL,0x0,NULL,HFILL}}, \
 879 { &hf_iuup_init_rfci_flow_len[i][3], { "RFCI " #i " Flow 3 Len", "iuup.rfci."#i".flow.3.len", FT_UINT16, BASE_DEC, NULL,0x0,NULL,HFILL}}, \
 880 { &hf_iuup_init_rfci_flow_len[i][4], { "RFCI " #i " Flow 4 Len", "iuup.rfci."#i".flow.4.len", FT_UINT16, BASE_DEC, NULL,0x0,NULL,HFILL}}, \
 881 { &hf_iuup_init_rfci_flow_len[i][5], { "RFCI " #i " Flow 5 Len", "iuup.rfci."#i".flow.5.len", FT_UINT16, BASE_DEC, NULL,0x0,NULL,HFILL}}, \
 882 { &hf_iuup_init_rfci_flow_len[i][6], { "RFCI " #i " Flow 6 Len", "iuup.rfci."#i".flow.6.len", FT_UINT16, BASE_DEC, NULL,0x0,NULL,HFILL}}, \
 883 { &hf_iuup_init_rfci_flow_len[i][7], { "RFCI " #i " Flow 7 Len", "iuup.rfci."#i".flow.7.len", FT_UINT16, BASE_DEC, NULL,0x0,NULL,HFILL}}, \
 884 { &hf_iuup_init_rfci_li[i], { "RFCI " #i " LI", "iuup.rfci."#i".li", FT_UINT8, BASE_HEX, VALS(iuup_init_rfci_li_vals),0x40,"Length Indicator",HFILL}}, \
 885 { &hf_iuup_init_rfci_lri[i], { "RFCI " #i " LRI", "iuup.rfci."#i".lri", FT_UINT8, BASE_HEX, VALS(iuup_init_lri_vals),0x80,"Last Record Indicator",HFILL}}, \
 886 { &hf_iuup_rfci_subflow[i][0], { "RFCI " #i " Flow 0", "iuup.rfci."#i".flow.0", FT_BYTES, BASE_NONE, NULL,0x0,NULL,HFILL}}, \
 887 { &hf_iuup_rfci_subflow[i][1], { "RFCI " #i " Flow 1", "iuup.rfci."#i".flow.1", FT_BYTES, BASE_NONE, NULL,0x0,NULL,HFILL}}, \
 888 { &hf_iuup_rfci_subflow[i][2], { "RFCI " #i " Flow 2", "iuup.rfci."#i".flow.2", FT_BYTES, BASE_NONE, NULL,0x0,NULL,HFILL}}, \
 889 { &hf_iuup_rfci_subflow[i][3], { "RFCI " #i " Flow 3", "iuup.rfci."#i".flow.3", FT_BYTES, BASE_NONE, NULL,0x0,NULL,HFILL}}, \
 890 { &hf_iuup_rfci_subflow[i][4], { "RFCI " #i " Flow 4", "iuup.rfci."#i".flow.4", FT_BYTES, BASE_NONE, NULL,0x0,NULL,HFILL}}, \
 891 { &hf_iuup_rfci_subflow[i][5], { "RFCI " #i " Flow 5", "iuup.rfci."#i".flow.5", FT_BYTES, BASE_NONE, NULL,0x0,NULL,HFILL}}, \
 892 { &hf_iuup_rfci_subflow[i][6], { "RFCI " #i " Flow 6", "iuup.rfci."#i".flow.6", FT_BYTES, BASE_NONE, NULL,0x0,NULL,HFILL}}, \
 893 { &hf_iuup_rfci_subflow[i][7], { "RFCI " #i " Flow 7", "iuup.rfci."#i".flow.7", FT_BYTES, BASE_NONE, NULL,0x0,NULL,HFILL}}, \
 894 { &hf_iuup_init_ipti[i], { "RFCI " #i " IPTI", "iuup.rfci."#i".ipti", FT_UINT8, BASE_HEX, NULL,i%2 ? 0x0F : 0xF0,NULL,HFILL}}
 895
 896
 897
 898 void proto_register_iuup(void) {
 899     static hf_register_info hf[] = {
 900         { &hf_iuup_direction, { "Frame Direction", "iuup.direction", FT_UINT16, BASE_DEC, NULL,0x8000,NULL,HFILL}},
 901         { &hf_iuup_circuit_id, { "Circuit ID", "iuup.circuit_id", FT_UINT16, BASE_DEC, NULL,0x7fff,NULL,HFILL}},
 902         { &hf_iuup_pdu_type, { "PDU Type", "iuup.pdu_type", FT_UINT8, BASE_DEC, VALS(iuup_pdu_types),0xf0,NULL,HFILL}},
 903         { &hf_iuup_frame_number, { "Frame Number", "iuup.framenum", FT_UINT8, BASE_DEC, NULL,0x0F,NULL,HFILL}},
 904         { &hf_iuup_fqc, { "FQC", "iuup.fqc", FT_UINT8, BASE_DEC, VALS(iuup_fqcs),0xc0,"Frame Quality Classification",HFILL}},
 905         { &hf_iuup_rfci, { "RFCI", "iuup.rfci", FT_UINT8, BASE_HEX, NULL, 0x3f, "RAB sub-Flow Combination Indicator",HFILL}},
 906         { &hf_iuup_hdr_crc, { "Header CRC", "iuup.header_crc", FT_UINT8, BASE_HEX, NULL,0xfc,NULL,HFILL}},
 907         { &hf_iuup_payload_crc, { "Payload CRC", "iuup.payload_crc", FT_UINT16, BASE_HEX, NULL,0x03FF,NULL,HFILL}},
 908         { &hf_iuup_ack_nack, { "Ack/Nack", "iuup.ack", FT_UINT8, BASE_DEC, VALS(iuup_acknack_vals),0x0c,NULL,HFILL}},
 909         { &hf_iuup_frame_number_t14, { "Frame Number", "iuup.framenum_t14", FT_UINT8, BASE_DEC, NULL,0x03,NULL,HFILL}},
 910         { &hf_iuup_mode_version, { "Mode Version", "iuup.mode", FT_UINT8, BASE_HEX, NULL,0xf0,NULL,HFILL}},
 911         { &hf_iuup_procedure_indicator, { "Procedure", "iuup.procedure", FT_UINT8, BASE_DEC, VALS(iuup_procedures),0x0f,NULL,HFILL}},
 912         { &hf_iuup_error_cause_val, { "Error Cause", "iuup.error_cause", FT_UINT8, BASE_DEC, VALS(iuup_error_causes),0xfc,NULL,HFILL}},
 913         { &hf_iuup_error_distance, { "Error DISTANCE", "iuup.error_distance", FT_UINT8, BASE_DEC, VALS(iuup_error_distances),0xc0,NULL,HFILL}},
 914         { &hf_iuup_errorevt_cause_val, { "Error Cause", "iuup.errorevt_cause", FT_UINT8, BASE_DEC, NULL,0x3f,NULL,HFILL}},
 915         { &hf_iuup_time_align, { "Time Align", "iuup.time_align", FT_UINT8, BASE_HEX, NULL,0x0,NULL,HFILL}},
 916         { &hf_iuup_data_pdu_type, { "RFCI Data Pdu Type", "iuup.data_pdu_type", FT_UINT8, BASE_HEX, VALS(iuup_payload_pdu_type),0xF0,NULL,HFILL}},
 917
 918         { &hf_iuup_spare_03, { "Spare", "iuup.spare", FT_UINT8, BASE_HEX, NULL,0x03,NULL,HFILL}},
 919 #if 0
 920         { &hf_iuup_spare_0f, { "Spare", "iuup.spare", FT_UINT8, BASE_HEX, NULL,0x0f,NULL,HFILL}},
 921 #endif
 922 #if 0
 923         { &hf_iuup_spare_c0, { "Spare", "iuup.spare", FT_UINT8, BASE_HEX, NULL,0xc0,NULL,HFILL}},
 924 #endif
 925         { &hf_iuup_spare_e0, { "Spare", "iuup.spare", FT_UINT8, BASE_HEX, NULL,0xe0,NULL,HFILL}},
 926         { &hf_iuup_spare_ff, { "Spare", "iuup.spare", FT_UINT8, BASE_HEX, NULL,0xff,NULL,HFILL}},
 927         { &hf_iuup_spare_bytes, { "Spare", "iuup.spare_bytes", FT_BYTES, BASE_NONE, NULL,0x0,NULL,HFILL}},
 928
 929         { &hf_iuup_delay, { "Delay", "iuup.delay", FT_UINT32, BASE_HEX, NULL,0x0,NULL,HFILL}},
 930         { &hf_iuup_advance, { "Advance", "iuup.advance", FT_UINT32, BASE_HEX, NULL,0x0,NULL,HFILL}},
 931         { &hf_iuup_delta, { "Delta Time", "iuup.delta", FT_FLOAT, BASE_NONE, NULL,0x0,NULL,HFILL}},
 932
 933         { &hf_iuup_init_ti, { "TI", "iuup.ti", FT_UINT8, BASE_DEC, VALS(iuup_ti_vals),0x10,"Timing Information",HFILL}},
 934         { &hf_iuup_init_subflows_per_rfci, { "Subflows", "iuup.subflows", FT_UINT8, BASE_DEC, NULL,0x0e,"Number of Subflows",HFILL}},
 935         { &hf_iuup_init_chain_ind, { "Chain Indicator", "iuup.chain_ind", FT_UINT8, BASE_DEC, VALS(iuup_init_chain_ind_vals),0x01,NULL,HFILL}},
 936         { &hf_iuup_payload, { "Payload Data", "iuup.payload_data", FT_BYTES, BASE_NONE, NULL,0x00,NULL,HFILL}},
 937
 938
 939         { &hf_iuup_mode_versions, { "Iu UP Mode Versions Supported", "iuup.support_mode", FT_UINT16, BASE_HEX, NULL,0x0,NULL,HFILL}},
 940
 941         { &hf_iuup_mode_versions_a[ 0], { "Version 16", "iuup.support_mode.version16", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x8000,NULL,HFILL}},
 942         { &hf_iuup_mode_versions_a[ 1], { "Version 15", "iuup.support_mode.version15", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x4000,NULL,HFILL}},
 943         { &hf_iuup_mode_versions_a[ 2], { "Version 14", "iuup.support_mode.version14", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x2000,NULL,HFILL}},
 944         { &hf_iuup_mode_versions_a[ 3], { "Version 13", "iuup.support_mode.version13", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x1000,NULL,HFILL}},
 945         { &hf_iuup_mode_versions_a[ 4], { "Version 12", "iuup.support_mode.version12", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x0800,NULL,HFILL}},
 946         { &hf_iuup_mode_versions_a[ 5], { "Version 11", "iuup.support_mode.version11", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x0400,NULL,HFILL}},
 947         { &hf_iuup_mode_versions_a[ 6], { "Version 10", "iuup.support_mode.version10", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x0200,NULL,HFILL}},
 948         { &hf_iuup_mode_versions_a[ 7], { "Version  9", "iuup.support_mode.version9", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x0100,NULL,HFILL}},
 949         { &hf_iuup_mode_versions_a[ 8], { "Version  8", "iuup.support_mode.version8", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x0080,NULL,HFILL}},
 950         { &hf_iuup_mode_versions_a[ 9], { "Version  7", "iuup.support_mode.version7", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x0040,NULL,HFILL}},
 951         { &hf_iuup_mode_versions_a[10], { "Version  6", "iuup.support_mode.version6", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x0020,NULL,HFILL}},
 952         { &hf_iuup_mode_versions_a[11], { "Version  5", "iuup.support_mode.version5", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x0010,NULL,HFILL}},
 953         { &hf_iuup_mode_versions_a[12], { "Version  4", "iuup.support_mode.version4", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x0008,NULL,HFILL}},
 954         { &hf_iuup_mode_versions_a[13], { "Version  3", "iuup.support_mode.version3", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x0004,NULL,HFILL}},
 955         { &hf_iuup_mode_versions_a[14], { "Version  2", "iuup.support_mode.version2", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x0002,NULL,HFILL}},
 956         { &hf_iuup_mode_versions_a[15], { "Version  1", "iuup.support_mode.version1", FT_UINT16, BASE_HEX, VALS(iuup_mode_version_support),0x0001,NULL,HFILL}},
 957
 958         { &hf_iuup_num_rfci_ind, { "Number of RFCI Indicators", "iuup.p", FT_UINT8, BASE_HEX, NULL,0x3f,NULL,HFILL}},
 959         { &hf_iuup_init_rfci_ind, { "RFCI Initialization", "iuup.rfci.init", FT_BYTES, BASE_NONE, NULL,0x0,NULL,HFILL}},
 960
 961         HFS_RFCI(0),HFS_RFCI(1),HFS_RFCI(2),HFS_RFCI(3),HFS_RFCI(4),HFS_RFCI(5),HFS_RFCI(6),HFS_RFCI(7),
 962         HFS_RFCI(8),HFS_RFCI(9),HFS_RFCI(10),HFS_RFCI(11),HFS_RFCI(12),HFS_RFCI(13),HFS_RFCI(14),HFS_RFCI(15),
 963         HFS_RFCI(16),HFS_RFCI(17),HFS_RFCI(18),HFS_RFCI(19),HFS_RFCI(20),HFS_RFCI(21),HFS_RFCI(22),HFS_RFCI(23),
 964         HFS_RFCI(24),HFS_RFCI(25),HFS_RFCI(26),HFS_RFCI(27),HFS_RFCI(28),HFS_RFCI(29),HFS_RFCI(30),HFS_RFCI(31),
 965         HFS_RFCI(32),HFS_RFCI(33),HFS_RFCI(34),HFS_RFCI(35),HFS_RFCI(36),HFS_RFCI(37),HFS_RFCI(38),HFS_RFCI(39),
 966         HFS_RFCI(40),HFS_RFCI(41),HFS_RFCI(42),HFS_RFCI(43),HFS_RFCI(44),HFS_RFCI(45),HFS_RFCI(46),HFS_RFCI(47),
 967         HFS_RFCI(48),HFS_RFCI(49),HFS_RFCI(50),HFS_RFCI(51),HFS_RFCI(52),HFS_RFCI(53),HFS_RFCI(54),HFS_RFCI(55),
 968         HFS_RFCI(56),HFS_RFCI(57),HFS_RFCI(58),HFS_RFCI(59),HFS_RFCI(60),HFS_RFCI(61),HFS_RFCI(62),HFS_RFCI(63)
 969
 970     };
 971
 972
 973     gint* ett[] = {
 974         &ett_iuup,
 975         &ett_rfci,
 976         &ett_ipti,
 977         &ett_support,
 978         &ett_time,
 979         &ett_rfciinds,
 980         &ett_payload,
 981         &ett_payload_subflows
 982     };
 983
 984     static ei_register_info ei[] = {
 985         { &ei_iuup_hdr_crc_bad, { "iuup.hdr.crc.bad", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }},
 986         { &ei_iuup_payload_crc_bad, { "iuup.payload.crc.bad", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }},
 987         { &ei_iuup_payload_undecoded, { "iuup.payload.undecoded", PI_UNDECODED, PI_WARN, "Undecoded payload", EXPFILL }},
 988         { &ei_iuup_error_response, { "iuup.error_response", PI_RESPONSE_CODE, PI_ERROR, "Error response", EXPFILL }},
 989         { &ei_iuup_ack_nack, { "iuup.ack.malformed", PI_MALFORMED, PI_ERROR, "Malformed Ack/Nack", EXPFILL }},
 990         { &ei_iuup_time_align, { "iuup.time_align.malformed", PI_MALFORMED, PI_ERROR, "Malformed Time Align", EXPFILL }},
 991         { &ei_iuup_procedure_indicator, { "iuup.procedure.malformed", PI_MALFORMED, PI_ERROR, "Malformed Procedure", EXPFILL }},
 992         { &ei_iuup_pdu_type, { "iuup.pdu_type.malformed", PI_MALFORMED, PI_ERROR, "Malformed PDU Type", EXPFILL }},
 993     };
 994
 995     module_t *iuup_module;
 996     expert_module_t* expert_iuup;
 997
 998     proto_iuup = proto_register_protocol("IuUP", "IuUP", "iuup");
 999     proto_register_field_array(proto_iuup, hf, array_length(hf));
1000     proto_register_subtree_array(ett, array_length(ett));
1001     expert_iuup = expert_register_protocol(proto_iuup);
1002     expert_register_field_array(expert_iuup, ei, array_length(ei));
1003     register_dissector("iuup", dissect_iuup, proto_iuup);
1004     register_dissector("find_iuup", find_iuup, proto_iuup);
1005
1006     register_init_routine(&init_iuup);
1007
1008     iuup_module = prefs_register_protocol(proto_iuup, proto_reg_handoff_iuup);
1009
1010     prefs_register_bool_preference(iuup_module, "dissect_payload",
1011                                    "Dissect IuUP Payload bits",
1012                                    "Whether IuUP Payload bits should be dissected",
1013                                    &dissect_fields);
1014
1015     prefs_register_bool_preference(iuup_module, "two_byte_pseudoheader",
1016                                    "Two byte pseudoheader",
1017                                    "The payload contains a two byte pseudoheader indicating direction and circuit_id",
1018                                    &two_byte_pseudoheader);
1019
1020     prefs_register_uint_preference(iuup_module, "dynamic.payload.type",
1021                                    "IuUP dynamic payload type",
1022                                    "The dynamic payload type which will be interpreted as IuUP",
1023                                    10,
1024                                    &global_dynamic_payload_type);
1025 }
1026