packet-wtp.c

   1 /* packet-wtp.c
   2  *
   3  * Routines to dissect WTP component of WAP traffic.
   4  *
   5  * $Id: packet-wtp.c,v 1.26 2002/01/21 07:36:47 guy Exp $
   6  *
   7  * Ethereal - Network traffic analyzer
   8  * By Gerald Combs <gerald@ethereal.com>
   9  * Copyright 1998 Gerald Combs
  10  *
  11  * WAP dissector based on original work by Ben Fowler
  12  * Updated by Neil Hunter <neil.hunter@energis-squared.com>
  13  * WTLS support by Alexandre P. Ferreira (Splice IP)
  14  *
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License
  17  * as published by the Free Software Foundation; either version 2
  18  * of the License, or (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  28  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 # include "config.h"
  32 #endif
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36
  37 #ifdef HAVE_SYS_TYPES_H
  38 # include <sys/types.h>
  39 #endif
  40
  41 #ifdef HAVE_NETINET_IN_H
  42 # include <netinet/in.h>
  43 #endif
  44
  45 #ifdef NEED_SNPRINTF_H
  46 # ifdef HAVE_STDARG_H
  47 #  include <stdarg.h>
  48 # else
  49 #  include <varargs.h>
  50 # endif
  51 # include "snprintf.h"
  52 #endif
  53
  54 #include <string.h>
  55 #include <glib.h>
  56 #include <epan/packet.h>
  57 #include "reassemble.h"
  58 #include "packet-wap.h"
  59 #include "packet-wtp.h"
  60 #include "packet-wsp.h"
  61
  62 static const true_false_string continue_truth = {
  63         "TPI Present" ,
  64         "No TPI"
  65 };
  66
  67 static const true_false_string RID_truth = {
  68         "Re-Transmission",
  69         "First transmission"
  70 };
  71
  72 static const true_false_string TIDNew_truth = {
  73         "TID is new" ,
  74         "TID is valid"
  75 };
  76
  77 static const true_false_string tid_response_truth = {
  78         "Response" ,
  79         "Original"
  80 };
  81
  82 static const true_false_string UP_truth = {
  83         "User Acknowledgement required" ,
  84         "User Acknowledgement optional"
  85 };
  86
  87 static const true_false_string TVETOK_truth = {
  88         "True",
  89         "False"
  90 };
  91
  92 static const value_string vals_pdu_type[] = {
  93         { 0, "Not Allowed" },
  94         { 1, "Invoke" },
  95         { 2, "Result" },
  96         { 3, "Ack" },
  97         { 4, "Abort" },
  98         { 5, "Segmented Invoke" },
  99         { 6, "Segmented Result" },
 100         { 7, "Negative Ack" },
 101         { 0, NULL }
 102 };
 103
 104 static const value_string vals_transaction_trailer[] = {
 105         { 0, "Not last packet" },
 106         { 1, "Last packet of message" },
 107         { 2, "Last packet of group" },
 108         { 3, "Re-assembly not supported" },
 109         { 0, NULL }
 110 };
 111
 112 static const value_string vals_version[] = {
 113         { 0, "Current" },
 114         { 1, "Undefined" },
 115         { 2, "Undefined" },
 116         { 3, "Undefined" },
 117         { 0, NULL }
 118 };
 119
 120 static const value_string vals_abort_type[] = {
 121         { 0, "Provider" },
 122         { 1, "User (WSP)" },
 123         { 0, NULL }
 124 };
 125
 126 static const value_string vals_abort_reason_provider[] = {
 127         { 0x00, "Unknown" },
 128         { 0x01, "Protocol Error" },
 129         { 0x02, "Invalid TID" },
 130         { 0x03, "Not Implemented Class 2" },
 131         { 0x04, "Not Implemented SAR" },
 132         { 0x05, "Not Implemented User Acknowledgement" },
 133         { 0x06, "WTP Version Zero" },
 134         { 0x07, "Capacity Temporarily Exceeded" },
 135         { 0x08, "No Response" },
 136         { 0x09, "Message Too Large" },
 137         { 0x00, NULL }
 138 };
 139
 140 static const value_string vals_transaction_classes[] = {
 141         { 0x00, "Unreliable Invoke without Result" },
 142         { 0x01, "Reliable Invoke without Result" },
 143         { 0x02, "Reliable Invoke with Reliable Result" },
 144         { 0x00, NULL }
 145 };
 146
 147 /* File scoped variables for the protocol and registered fields */
 148 static int proto_wtp                                    = HF_EMPTY;
 149
 150 /* These fields used by fixed part of header */
 151 static int hf_wtp_header_fixed_part                     = HF_EMPTY;
 152 static int hf_wtp_header_sub_pdu_size                   = HF_EMPTY;
 153 static int hf_wtp_header_flag_continue                  = HF_EMPTY;
 154 static int hf_wtp_header_pdu_type                       = HF_EMPTY;
 155 static int hf_wtp_header_flag_Trailer                   = HF_EMPTY;
 156 static int hf_wtp_header_flag_RID                       = HF_EMPTY;
 157 static int hf_wtp_header_flag_TID                       = HF_EMPTY;
 158 static int hf_wtp_header_flag_TID_response              = HF_EMPTY;
 159
 160 /* These fields used by Invoke packets */
 161 static int hf_wtp_header_Inv_version                    = HF_EMPTY;
 162 static int hf_wtp_header_Inv_flag_TIDNew                = HF_EMPTY;
 163 static int hf_wtp_header_Inv_flag_UP                    = HF_EMPTY;
 164 static int hf_wtp_header_Inv_Reserved                   = HF_EMPTY;
 165 static int hf_wtp_header_Inv_TransactionClass           = HF_EMPTY;
 166
 167
 168 static int hf_wtp_header_variable_part                  = HF_EMPTY;
 169 static int hf_wtp_data                                  = HF_EMPTY;
 170
 171 static int hf_wtp_header_Ack_flag_TVETOK                = HF_EMPTY;
 172 static int hf_wtp_header_Abort_type                     = HF_EMPTY;
 173 static int hf_wtp_header_Abort_reason_provider          = HF_EMPTY;
 174 static int hf_wtp_header_Abort_reason_user              = HF_EMPTY;
 175 static int hf_wtp_header_sequence_number                = HF_EMPTY;
 176 static int hf_wtp_header_missing_packets                = HF_EMPTY;
 177
 178 /* Initialize the subtree pointers */
 179 static gint ett_wtp                                     = ETT_EMPTY;
 180 static gint ett_header                                  = ETT_EMPTY;
 181
 182 /* Handle for WSP dissector */
 183 static dissector_handle_t wsp_handle;
 184
 185 /*
 186  * reassembly of WSP
 187  */
 188 static GHashTable       *wtp_fragment_table = NULL;
 189
 190 static void
 191 wtp_defragment_init(void)
 192 {
 193         fragment_table_init(&wtp_fragment_table);
 194 }
 195
 196 /*
 197  * Extract some bitfields
 198  */
 199 #define pdu_type(octet)                 (((octet) >> 3) & 0x0F) /* Note pdu type must not be 0x00 */
 200 #define transaction_class(octet)        ((octet) & 0x03)        /* ......XX */
 201 #define transmission_trailer(octet)     (((octet) >> 1) & 0x01) /* ......X. */
 202
 203 static char retransmission_indicator(unsigned char octet)
 204 {
 205         switch ( pdu_type(octet) ) {
 206                 case INVOKE:
 207                 case RESULT:
 208                 case ACK:
 209                 case SEGMENTED_INVOKE:
 210                 case SEGMENTED_RESULT:
 211                 case NEGATIVE_ACK:
 212                         return octet & 0x01;    /* .......X */
 213                 default:
 214                         return 0;
 215         }
 216 }
 217
 218 /* Code to actually dissect the packets */
 219 static void
 220 dissect_wtp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 221 {
 222         char            szInfo[ 50 ];
 223         int             offCur          = 0; /* current offset from start of WTP data */
 224
 225         /* bytes at offset 0 - 3 */
 226         /*
 227         unsigned char  b0 = pd[offset + 0];
 228         unsigned char  b3 = pd[offset + 3];
 229         */
 230         unsigned char  b0;
 231
 232         /* continuation flag */
 233         unsigned char   fCon;                   /* Continue flag        */
 234         unsigned char   fRID;                   /* Re-transmission indicator    */
 235         unsigned char   fTTR = '\0';            /* Transmission trailer */
 236         guint           cbHeader        = 0;
 237         guint           vHeader         = 0;
 238         int             abortType       = 0;
 239
 240 /* Set up structures we will need to add the protocol subtree and manage it */
 241         proto_item      *ti;
 242         proto_tree      *wtp_tree = NULL;
 243         proto_tree      *wtp_header_fixed;
 244
 245         char            pdut;
 246         char            clsTransaction  = ' ';
 247         int             cchInfo;
 248         int             numMissing = 0;         /* Number of missing packets in a negative ack */
 249         int             i;
 250         tvbuff_t        *wsp_tvb = NULL;
 251         fragment_data   *fd_head = NULL;
 252         guint8          psn = 0;                /* Packet sequence number       */
 253         guint16         TID = 0;                /* Transaction-Id       */
 254
 255         b0 = tvb_get_guint8 (tvb, offCur + 0);
 256         /* Discover Concatenated PDUs */
 257         if (b0 == 0) {
 258                 if (tree) {
 259                         wtp_tree = proto_tree_add_item(tree, proto_wtp, tvb, offCur, 1, bo_little_endian);
 260                 }
 261                 offCur = 1;
 262                 i = 1;
 263                 while (offCur < (int) tvb_reported_length (tvb)) {
 264                         b0 = tvb_get_guint8 (tvb, offCur + 0);
 265                         if (b0 & 0x80) {
 266                                 vHeader = 2;
 267                                 cbHeader = ((b0 & 0x7f) << 8) |
 268                                             tvb_get_guint8 (tvb, offCur + 1);
 269                         } else {
 270                                 vHeader = 1;
 271                                 cbHeader = b0;
 272                         }
 273                         if (tree) {
 274                                 proto_tree_add_item(wtp_tree, hf_wtp_header_sub_pdu_size, tvb, offCur, vHeader, bo_big_endian);
 275                         }
 276                         if (i > 1 && check_col(pinfo->cinfo, COL_INFO)) {
 277                                 col_append_str (pinfo->cinfo, COL_INFO, ", ");
 278                         }
 279                         wsp_tvb = tvb_new_subset(tvb, offCur + vHeader, -1, cbHeader);
 280                         dissect_wtp_common (wsp_tvb, pinfo, wtp_tree);
 281                         offCur += vHeader + cbHeader;
 282                         i++;
 283                 }
 284                 return;
 285         }
 286         fCon = b0 & 0x80;
 287         fRID = retransmission_indicator( b0 );
 288         pdut = pdu_type( b0 );
 289
 290         /* Develop the string to put in the Info column */
 291         cchInfo = snprintf( szInfo, sizeof( szInfo ), "WTP %s",
 292                     val_to_str(pdut, vals_pdu_type, "Unknown PDU type 0x%x"));
 293
 294         switch( pdut ) {
 295                 case INVOKE:
 296                         fTTR = transmission_trailer( b0 );
 297                         TID = tvb_get_ntohs(tvb, offCur + 1);
 298                         psn = 0;
 299                         clsTransaction = transaction_class( tvb_get_guint8 (tvb, offCur + 3) );
 300                         snprintf( szInfo + cchInfo, sizeof( szInfo ) - cchInfo, " Class %d", clsTransaction  );
 301                         cbHeader = 4;
 302                         break;
 303
 304                 case SEGMENTED_INVOKE:
 305                 case SEGMENTED_RESULT:
 306                         fTTR = transmission_trailer( b0 );
 307                         TID = tvb_get_ntohs(tvb, offCur + 1);
 308                         psn = tvb_get_guint8(tvb, offCur + 3);
 309                         cbHeader = 4;
 310                         break;
 311
 312                 case ABORT:
 313                         cbHeader = 4;
 314                         break;
 315
 316                 case RESULT:
 317                         fTTR = transmission_trailer( b0 );
 318                         TID = tvb_get_ntohs(tvb, offCur + 1);
 319                         psn = 0;
 320                         cbHeader = 3;
 321                         break;
 322
 323                 case ACK:
 324                         cbHeader = 3;
 325                         break;
 326
 327                 case NEGATIVE_ACK:
 328                         /* Variable number of missing packets */
 329                         numMissing = tvb_get_guint8 (tvb, offCur + 3);
 330                         cbHeader = numMissing + 4;
 331                         break;
 332
 333                 default:
 334                         break;
 335         };
 336
 337         if( fRID ) {
 338                 strcat( szInfo, " R" );
 339         };
 340         if( fCon ) {                    /* Scan variable part (TPI's)   */
 341                 unsigned char   tCon;
 342                 unsigned char   tByte;
 343
 344                 do {
 345                         tByte = tvb_get_guint8(tvb, offCur + cbHeader + vHeader);
 346                         tCon = tByte & 0x80;
 347                         if (tByte & 0x04)
 348                                 vHeader = vHeader + tvb_get_guint8(tvb,
 349                                         offCur + cbHeader + vHeader + 1) + 2;
 350                         else
 351                                 vHeader = vHeader + (tByte & 0x03) + 1;
 352                 } while (tCon);
 353         }
 354
 355 #ifdef DEBUG
 356         fprintf( stderr, "dissect_wtp: cbHeader = %d\n", cbHeader );
 357 #endif
 358
 359         /* This field shows up as the "Info" column in the display; you should make
 360            it, if possible, summarize what's in the packet, so that a user looking
 361            at the list of packets can tell what type of packet it is. */
 362         if (check_col(pinfo->cinfo, COL_INFO) &&
 363             (tvb_length_remaining(tvb, offCur + cbHeader + vHeader) <= 0)) {
 364 #ifdef DEBUG
 365                 fprintf( stderr, "dissect_wtp: (6) About to set info_col header to %s\n", szInfo );
 366 #endif
 367                 col_append_str(pinfo->cinfo, COL_INFO, szInfo );
 368         };
 369         /* In the interest of speed, if "tree" is NULL, don't do any work not
 370            necessary to generate protocol tree items. */
 371         if (tree) {
 372 #ifdef DEBUG
 373                 fprintf( stderr, "dissect_wtp: cbHeader = %d\n", cbHeader );
 374 #endif
 375                 ti = proto_tree_add_item(tree, proto_wtp, tvb, offCur, cbHeader + vHeader, bo_little_endian);
 376 #ifdef DEBUG
 377                 fprintf( stderr, "dissect_wtp: (7) Returned from proto_tree_add_item\n" );
 378 #endif
 379                 wtp_tree = proto_item_add_subtree(ti, ett_wtp);
 380
 381 /* Code to process the packet goes here */
 382                 {
 383 #ifdef DEBUG
 384                         fprintf( stderr, "dissect_wtp: cbHeader = %d\n", cbHeader );
 385                         fprintf( stderr, "dissect_wtp: offCur = %d\n", offCur );
 386                         fprintf( stderr, "dissect_wtp: About to call proto_tree_add_item with %p %d %p %d %d %d\n",
 387                                         wtp_tree, hf_wtp_header_fixed_part, tvb, offCur, cbHeader, bo_little_endian );
 388                         ti = proto_tree_add_item( wtp_tree, hf_wtp_header_fixed_part, tvb, offCur, cbHeader, bo_little_endian );
 389                         fprintf( stderr, "dissect_wtp: (6) Returned from proto_tree_add_item\n" );
 390 #endif
 391                         wtp_header_fixed = proto_item_add_subtree(ti, ett_header);
 392
 393                         /* Add common items: only CON and PDU Type */
 394                         ti = proto_tree_add_item(
 395                                         wtp_header_fixed,               /* tree */
 396                                         hf_wtp_header_flag_continue,    /* id */
 397                                         tvb,
 398                                         offCur,                         /* start of high light */
 399                                         1,                              /* length of high light */
 400                                         b0                              /* value */
 401                              );
 402                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_pdu_type, tvb, offCur, 1, bo_little_endian );
 403
 404                         switch( pdut ) {
 405                                 case INVOKE:
 406                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_Trailer, tvb, offCur, 1, bo_little_endian );
 407                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_RID, tvb, offCur, 1, bo_little_endian );
 408                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID_response, tvb, offCur + 1, 2, bo_big_endian );
 409                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID, tvb, offCur + 1, 2, bo_big_endian );
 410
 411                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_Inv_version , tvb, offCur + 3, 1, bo_little_endian );
 412                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_Inv_flag_TIDNew, tvb, offCur + 3, 1, bo_little_endian );
 413                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_Inv_flag_UP, tvb, offCur + 3, 1, bo_little_endian );
 414                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_Inv_Reserved, tvb, offCur + 3, 1, bo_little_endian );
 415                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_Inv_TransactionClass, tvb, offCur + 3, 1, bo_little_endian );
 416                                         break;
 417
 418                                 case RESULT:
 419                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_Trailer, tvb, offCur, 1, bo_little_endian );
 420                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_RID, tvb, offCur, 1, bo_little_endian );
 421                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID_response, tvb, offCur + 1, 2, bo_big_endian );
 422                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID, tvb, offCur + 1, 2, bo_big_endian );
 423                                         break;
 424
 425                                 case ACK:
 426                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_Ack_flag_TVETOK, tvb, offCur, 1, bo_big_endian );
 427
 428                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_RID, tvb, offCur, 1, bo_little_endian );
 429                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID_response, tvb, offCur + 1, 2, bo_big_endian );
 430                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID, tvb, offCur + 1, 2, bo_big_endian );
 431                                         break;
 432
 433                                 case ABORT:
 434                                         abortType = tvb_get_guint8 (tvb, offCur) & 0x07;
 435                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_Abort_type , tvb, offCur , 1, bo_little_endian );
 436                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID_response, tvb, offCur + 1, 2, bo_big_endian );
 437                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID, tvb, offCur + 1, 2, bo_big_endian );
 438
 439                                         if (abortType == PROVIDER)
 440                                         {
 441                                                 ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_Abort_reason_provider , tvb, offCur + 3 , 1, bo_little_endian );
 442                                         }
 443                                         else if (abortType == USER)
 444                                         {
 445                                                 ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_Abort_reason_user , tvb, offCur + 3 , 1, bo_little_endian );
 446                                         }
 447                                         break;
 448
 449                                 case SEGMENTED_INVOKE:
 450                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_Trailer, tvb, offCur, 1, bo_little_endian );
 451                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_RID, tvb, offCur, 1, bo_little_endian );
 452                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID_response, tvb, offCur + 1, 2, bo_big_endian );
 453                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID, tvb, offCur + 1, 2, bo_big_endian );
 454
 455                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_sequence_number , tvb, offCur + 3, 1, bo_little_endian );
 456                                         break;
 457
 458                                 case SEGMENTED_RESULT:
 459                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_Trailer, tvb, offCur, 1, bo_little_endian );
 460                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_RID, tvb, offCur, 1, bo_little_endian );
 461                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID_response, tvb, offCur + 1, 2, bo_big_endian );
 462                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID, tvb, offCur + 1, 2, bo_big_endian );
 463
 464                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_sequence_number , tvb, offCur + 3, 1, bo_little_endian );
 465                                         break;
 466
 467                                 case NEGATIVE_ACK:
 468                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_RID, tvb, offCur, 1, bo_little_endian );
 469                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID_response, tvb, offCur + 1, 2, bo_big_endian );
 470                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_flag_TID, tvb, offCur + 1, 2, bo_big_endian );
 471
 472                                         ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_missing_packets , tvb, offCur + 3, 1, bo_little_endian );
 473                                         /* Iterate through missing packets */
 474                                         for (i=0; i<numMissing; i++)
 475                                         {
 476                                                 ti = proto_tree_add_item( wtp_header_fixed, hf_wtp_header_sequence_number , tvb, offCur + i, 1, bo_little_endian );
 477                                         }
 478                                         break;
 479
 480                                 default:
 481                                         break;
 482                         };
 483
 484                         if( fCon ) {
 485                                 /* There is a variable part if the Con flag is set */
 486                                 ti = proto_tree_add_bytes_format(
 487                                                 wtp_tree,                       /* tree */
 488                                                 hf_wtp_header_variable_part,    /* id */
 489                                                 tvb,
 490                                                 offCur + cbHeader,              /* start */
 491                                                 vHeader,                        /* length */
 492                                                 "What should go here!",         /* value */
 493                                                 "Header (Variable part) %02X %02X %02X %02X",   /* format */
 494                                                 0, 1, 2, 3
 495                                     );
 496                         } else {
 497                                 /* There is no variable part */
 498                         }       /* End of variable part of header */
 499                 }
 500         } else {
 501 #ifdef DEBUG
 502                 fprintf( stderr, "dissect_wtp: (4) tree was %p\n", tree );
 503 #endif
 504         }
 505         /*
 506          * Any remaining data ought to be WSP data,
 507          * so hand off (defragmented) to the WSP dissector
 508          */
 509         if (tvb_length_remaining(tvb, offCur + cbHeader + vHeader) > 0)
 510         {
 511                 int     dataOffset = offCur + cbHeader + vHeader;
 512                 guint32 dataLen = tvb_length_remaining(tvb, offCur + cbHeader + vHeader);
 513                 gboolean save_fragmented;
 514
 515                 if ((pdut == SEGMENTED_INVOKE) || (pdut == SEGMENTED_RESULT) ||
 516                     (((pdut == INVOKE) || (pdut == RESULT)) && (!fTTR)))        /* 1st part of segment  */
 517                 {
 518                         save_fragmented = pinfo->fragmented;
 519                         pinfo->fragmented = TRUE;
 520                         fd_head = fragment_add_seq(tvb, dataOffset, pinfo, TID,
 521                                         wtp_fragment_table, psn, dataLen, !fTTR);
 522                         if (fd_head != NULL)            /* Reassembled  */
 523                         {
 524                                 wsp_tvb = tvb_new_real_data(fd_head->data,
 525                                                         fd_head->len,
 526                                                         fd_head->len,
 527                                                         "Reassembled");
 528                                 tvb_set_child_real_data_tvbuff(tvb, wsp_tvb);
 529                                 pinfo->fd->data_src = g_slist_append(pinfo->fd->data_src, wsp_tvb);
 530                                 pinfo->fragmented = FALSE;
 531                                 call_dissector(wsp_handle, wsp_tvb, pinfo, tree);
 532                         }
 533                         else
 534                         {
 535                                 if (check_col(pinfo->cinfo, COL_INFO))          /* Won't call WSP so display */
 536                                         col_append_str(pinfo->cinfo, COL_INFO, szInfo );
 537                         }
 538                         pinfo->fragmented = save_fragmented;
 539                 }
 540                 else                            /* Normal packet, call next dissector   */
 541                 {
 542                         wsp_tvb = tvb_new_subset(tvb, dataOffset, -1, dataLen);
 543                         call_dissector(wsp_handle, wsp_tvb, pinfo, tree);
 544                 }
 545         }
 546 }
 547
 548 /*
 549  * Called directly from UDP.
 550  * Put "WTP+WSP" into the "Protocol" column.
 551  */
 552 static void
 553 dissect_wtp_fromudp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 554 {
 555         if (check_col(pinfo->cinfo, COL_PROTOCOL))
 556                 col_set_str(pinfo->cinfo, COL_PROTOCOL, "WTP+WSP" );
 557         if (check_col(pinfo->cinfo, COL_INFO)) {
 558                 col_clear(pinfo->cinfo, COL_INFO);
 559         }
 560
 561         dissect_wtp_common(tvb, pinfo, tree);
 562 }
 563
 564 /*
 565  * Called from a higher-level WAP dissector, presumably WTLS.
 566  * Put "WTLS+WSP+WTP" to the "Protocol" column.
 567  *
 568  * XXX - is this supposed to be called from WTLS?  If so, we're not
 569  * calling it....
 570  *
 571  * XXX - can this be called from any other dissector?
 572  */
 573 static void
 574 dissect_wtp_fromwap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 575 {
 576         if (check_col(pinfo->cinfo, COL_PROTOCOL))
 577                 col_set_str(pinfo->cinfo, COL_PROTOCOL, "WTLS+WTP+WSP" );
 578         if (check_col(pinfo->cinfo, COL_INFO)) {
 579                 col_clear(pinfo->cinfo, COL_INFO);
 580         }
 581
 582         dissect_wtp_common(tvb, pinfo, tree);
 583 }
 584
 585 /* Register the protocol with Ethereal */
 586 void
 587 proto_register_wtp(void)
 588 {
 589
 590 /* Setup list of header fields */
 591         static hf_register_info hf[] = {
 592                 { &hf_wtp_header_fixed_part,
 593                         {       "Header",
 594                                 "wtp.header_fixed_part",
 595                                 FT_BYTES, BASE_HEX, NULL, 0x0,
 596                                 "Fixed part of the header", HFILL
 597                         }
 598                 },
 599                 { &hf_wtp_header_sub_pdu_size,
 600                         {       "Sub PDU size",
 601                                 "wtp.sub_pdu_size",
 602                                 FT_BYTES, BASE_HEX, NULL, 0x0,
 603                                 "Size of Sub-PDU", HFILL
 604                         }
 605                 },
 606                 { &hf_wtp_header_flag_continue,
 607                         {       "Continue Flag",
 608                                 "wtp.continue_flag",
 609                                 FT_BOOLEAN, 8, TFS( &continue_truth ), 0x80,
 610                                 "Continue Flag", HFILL
 611                         }
 612                 },
 613                 { &hf_wtp_header_pdu_type,
 614                         {       "PDU Type",
 615                                 "wtp.pdu_type",
 616                                  FT_UINT8, BASE_HEX, VALS( vals_pdu_type ), 0x78,
 617                                 "PDU Type", HFILL
 618                         }
 619                 },
 620                 { &hf_wtp_header_flag_Trailer,
 621                         {       "Trailer Flags",
 622                                 "wtp.trailer_flags",
 623                                  FT_UINT8, BASE_HEX, VALS( vals_transaction_trailer ), 0x06,
 624                                 "Trailer Flags", HFILL
 625                         }
 626                 },
 627                 { &hf_wtp_header_flag_RID,
 628                         {       "Re-transmission Indicator",
 629                                 "wtp.RID",
 630                                  FT_BOOLEAN, 8, TFS( &RID_truth ), 0x01,
 631                                 "Re-transmission Indicator", HFILL
 632                         }
 633                 },
 634                 { &hf_wtp_header_flag_TID_response,
 635                         {       "TID Response",
 636                                 "wtp.TID.response",
 637                                 FT_BOOLEAN, 16, TFS( &tid_response_truth ), 0x8000,
 638                                 "TID Response", HFILL
 639                         }
 640                 },
 641                 { &hf_wtp_header_flag_TID,
 642                         {       "Transaction ID",
 643                                 "wtp.TID",
 644                                  FT_UINT16, BASE_HEX, NULL, 0x7FFF,
 645                                 "Transaction ID", HFILL
 646                         }
 647                 },
 648                 { &hf_wtp_header_Inv_version,
 649                         {       "Version",
 650                                 "wtp.header.version",
 651                                  FT_UINT8, BASE_HEX, VALS( vals_version ), 0xC0,
 652                                 "Version", HFILL
 653                         }
 654                 },
 655                 { &hf_wtp_header_Inv_flag_TIDNew,
 656                         {       "TIDNew",
 657                                 "wtp.header.TIDNew",
 658                                  FT_BOOLEAN, 8, TFS( &TIDNew_truth ), 0x20,
 659                                 "TIDNew", HFILL
 660                         }
 661                 },
 662                 { &hf_wtp_header_Inv_flag_UP,
 663                         {       "U/P flag",
 664                                 "wtp.header.UP",
 665                                  FT_BOOLEAN, 8, TFS( &UP_truth ), 0x10,
 666                                 "U/P Flag", HFILL
 667                         }
 668                 },
 669                 { &hf_wtp_header_Inv_Reserved,
 670                         {       "Reserved",
 671                                 "wtp.inv.reserved",
 672                                  FT_UINT8, BASE_HEX, NULL, 0x0C,
 673                                 "Reserved", HFILL
 674                         }
 675                 },
 676                 { &hf_wtp_header_Inv_TransactionClass,
 677                         {       "Transaction Class",
 678                                 "wtp.inv.transaction_class",
 679                                  FT_UINT8, BASE_HEX, VALS( vals_transaction_classes ), 0x03,
 680                                 "Transaction Class", HFILL
 681                         }
 682                 },
 683                 { &hf_wtp_header_Ack_flag_TVETOK,
 684                         {       "Tve/Tok flag",
 685                                 "wtp.ack.tvetok",
 686                                  FT_BOOLEAN, 8, TFS( &TVETOK_truth ), 0x04,
 687                                 "Tve/Tok flag", HFILL
 688                         }
 689                 },
 690                 { &hf_wtp_header_Abort_type,
 691                         {       "Abort Type",
 692                                 "wtp.abort.type",
 693                                  FT_UINT8, BASE_HEX, VALS ( vals_abort_type ), 0x07,
 694                                 "Abort Type", HFILL
 695                         }
 696                 },
 697                 { &hf_wtp_header_Abort_reason_provider,
 698                         {       "Abort Reason",
 699                                 "wtp.abort.reason.provider",
 700                                  FT_UINT8, BASE_HEX, VALS ( vals_abort_reason_provider ), 0x00,
 701                                 "Abort Reason", HFILL
 702                         }
 703                 },
 704                 /* Assume WSP is the user and use its reason codes */
 705                 { &hf_wtp_header_Abort_reason_user,
 706                         {       "Abort Reason",
 707                                 "wtp.abort.reason.user",
 708                                  FT_UINT8, BASE_HEX, VALS ( vals_wsp_reason_codes ), 0x00,
 709                                 "Abort Reason", HFILL
 710                         }
 711                 },
 712                 { &hf_wtp_header_sequence_number,
 713                         {       "Packet Sequence Number",
 714                                 "wtp.header.sequence",
 715                                  FT_UINT8, BASE_HEX, NULL, 0x00,
 716                                 "Packet Sequence Number", HFILL
 717                         }
 718                 },
 719                 { &hf_wtp_header_missing_packets,
 720                         {       "Missing Packets",
 721                                 "wtp.header.missing_packets",
 722                                  FT_UINT8, BASE_HEX, NULL, 0x00,
 723                                 "Missing Packets", HFILL
 724                         }
 725                 },
 726                 { &hf_wtp_header_variable_part,
 727                         {       "Header: Variable part",
 728                                 "wtp.header_variable_part",
 729                                 FT_BYTES, BASE_HEX, NULL, 0x0,
 730                                 "Variable part of the header", HFILL
 731                         }
 732                 },
 733                 { &hf_wtp_data,
 734                         {       "Data",
 735                                 "wtp.header_data",
 736                                 FT_BYTES, BASE_HEX, NULL, 0x0,
 737                                 "Data", HFILL
 738                         }
 739                 },
 740         };
 741
 742 /* Setup protocol subtree array */
 743         static gint *ett[] = {
 744                 &ett_wtp,
 745                 &ett_header,
 746         };
 747
 748 /* Register the protocol name and description */
 749         proto_wtp = proto_register_protocol(
 750                 "Wireless Transaction Protocol",   /* protocol name for use by ethereal */
 751                 "WTP",                             /* short version of name */
 752                 "wap-wsp-wtp"                      /* Abbreviated protocol name, should Match IANA
 753                                                     < URL:http://www.isi.edu/in-notes/iana/assignments/port-numbers/ >
 754                                                   */
 755         );
 756
 757 /* Required function calls to register the header fields and subtrees used */
 758         proto_register_field_array(proto_wtp, hf, array_length(hf));
 759         proto_register_subtree_array(ett, array_length(ett));
 760
 761         register_dissector("wtp", dissect_wtp_fromwap, proto_wtp);
 762         register_dissector("wtp-udp", dissect_wtp_fromudp, proto_wtp);
 763         register_init_routine(wtp_defragment_init);
 764 };
 765
 766 void
 767 proto_reg_handoff_wtp(void)
 768 {
 769         dissector_handle_t wtp_fromudp_handle;
 770
 771         /*
 772          * Get a handle for the connection-oriented WSP dissector - if WTP
 773          * PDUs have data, it is WSP.
 774          */
 775         wsp_handle = find_dissector("wsp-co");
 776
 777         wtp_fromudp_handle = find_dissector("wtp-udp");
 778         dissector_add("udp.port", UDP_PORT_WTP_WSP, wtp_fromudp_handle);
 779 }