epan/dissectors/packet-opsi.c

   1 /* packet-opsi.c
   2  * Routines for OPSI protocol dissection
   3  * Copyright 2004, Laurent Rabret (France Telecom R&D) <laurent.rabret@i.hate.spams.org>
   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
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <stdlib.h>
  31
  32 #include <glib.h>
  33
  34 #include <epan/packet.h>
  35 #include <epan/dissectors/packet-tcp.h>
  36 #include <epan/prefs.h>
  37
  38 /* TCP destination port dedicated to the OPSI protocol */
  39 #define TCP_PORT_OPSI           4002
  40
  41 /* Information position in OPSI header */
  42 #define MAJOR_VERSION_OFFSET    0
  43 #define MINOR_VERSION_OFFSET    1
  44 #define CODE_OFFSET             2
  45 #define HOOK_ID_OFFSET          3
  46 #define PACKET_LENGTH_OFFSET    4
  47 #define SESSION_OFFSET          6
  48
  49 #define HEADER_LENGTH           8
  50
  51
  52 /* Valid OPSI code values */
  53 #define DISCOVER_REQUEST        1
  54 #define DISCOVER_RESPONSE       2
  55 #define SERVICE_REQUEST         3
  56 #define SERVICE_ACCEPT          4
  57 #define SERVICE_REJECT          5
  58 #define TERMINATE_REQUEST       6
  59
  60 /* Internal structure to dissect attributes */
  61 typedef struct {
  62         guint16         attribute_type;         /* attribute code */
  63         const char      *tree_text;             /* text for fold out */
  64         gint            *tree_id;               /* id for add_item */
  65         int*            hf_type_attribute;      /* id for seach option */
  66         void            (*dissect)(tvbuff_t *tvb, proto_tree *tree, int* hfValue, int offset, int length);
  67 } opsi_attribute_handle_t;
  68
  69
  70 /* Attributes codes */
  71 #define USER_NAME_ATTRIBUTE             1
  72 #define USER_PASSWD_ATTRIBUTE           2
  73 #define CHAP_PASSWD_ATTRIBUTE           3
  74 #define NAS_IP_ADDRESS_ATTRIBUTE        4
  75 #define NAS_PORT_ATTRIBUTE              5
  76 #define SERVICE_TYPE_ATTRIBUTE          6
  77 #define FRAMED_PROTOCOL_ATTRIBUTE       7
  78 #define FRAMED_ADDRESS_ATTRIBUTE        8
  79 #define FRAMED_NETMASK_ATTRIBUTE        9
  80 #define FRAMED_ROUTING_ATTRIBUTE        10
  81 #define FRAMED_FILTER_ATTRIBUTE         11
  82 #define FRAMED_MTU_ATTRIBUTE            12
  83 #define FRAMED_COMPRESSION_ATTRIBUTE    13
  84 #define CALLED_STATION_ID_ATTRIBUTE     30
  85 #define CALLING_STATION_ID_ATTRIBUTE    31
  86 #define NAS_IDENTIFIER                  32
  87 #define ACCOUNTING_40_ATTRIBUTE         40
  88 #define ACCOUNTING_41_ATTRIBUTE         41
  89 #define ACCOUNTING_42_ATTRIBUTE         42
  90 #define ACCOUNTING_43_ATTRIBUTE         43
  91 #define ACCOUNTING_SESSION_ID_ATTRIBUTE 44
  92 #define ACCOUNTING_45_ATTRIBUTE         45
  93 #define ACCOUNTING_46_ATTRIBUTE         46
  94 #define ACCOUNTING_47_ATTRIBUTE         47
  95 #define ACCOUNTING_48_ATTRIBUTE         48
  96 #define ACCOUNTING_49_ATTRIBUTE         49
  97 #define ACCOUNTING_50_ATTRIBUTE         50
  98 #define ACCOUNTING_51_ATTRIBUTE         51
  99 #define ACCOUNTING_52_ATTRIBUTE         52
 100 #define ACCOUNTING_53_ATTRIBUTE         53
 101 #define ACCOUNTING_54_ATTRIBUTE         54
 102 #define ACCOUNTING_55_ATTRIBUTE         55
 103 #define ACCOUNTING_56_ATTRIBUTE         56
 104 #define ACCOUNTING_57_ATTRIBUTE         57
 105 #define ACCOUNTING_58_ATTRIBUTE         58
 106 #define ACCOUNTING_59_ATTRIBUTE         59
 107 #define CHAP_CHALLENGE_ATTRIBUTE        60
 108 #define NAS_PORT_TYPE_ATTRIBUTE         61
 109 #define DESIGNATION_NUMBER_ATTRIBUTE    77
 110 #define NAS_PORT_ID_ATTRIBUTE           87
 111
 112 #define SMC_AAAID_ATTRIBUTE             651
 113 #define SMC_VPNID_ATTRIBUTE             652
 114 #define SMC_VPNNAME_ATTRIBUTE           653
 115 #define SMC_RANID_ATTRIBUTE             654
 116 #define SMC_RANIP_ATTRIBUTE             655
 117 #define SMC_RANNAME_ATTRIBUTE           656
 118 #define SMC_POPID_ATTRIBUTE             657
 119 #define SMC_POPNAME_ATTRIBUTE           658
 120 #define SMC_SMCID_ATTRIBUTE             659
 121 #define SMC_RECEIVE_TIME_ATTRIBUTE      660
 122 #define SMC_STAT_TIME_ATTRIBUTE         661
 123
 124 #define OPSI_FLAGS_ATTRIBUTE            674
 125 #define OPSI_APPLICATION_NAME_ATTRIBUTE 675
 126
 127 /*
 128  * Published API functions.  NOTE, "local" API functions
 129  * only valid from the packet-opsi file.
 130  */
 131 static void decode_string_attribute(tvbuff_t *tvb, proto_tree *tree, int* hfValue, int offset, int length);
 132 static void decode_ipv4_attribute(tvbuff_t *tvb, proto_tree *tree, int* hfValue, int offset, int length);
 133 static void decode_longint_attribute(tvbuff_t *tvb, proto_tree *tree, int* hfValue, int offset, int length);
 134 static void decode_value_string_attribute(tvbuff_t *tvb, proto_tree *tree, int* hfValue, int offset, int length);
 135 static void decode_time_attribute(tvbuff_t *tvb, proto_tree *tree, int* hfValue, int offset, int length);
 136 /******* *******/
 137
 138 /* Initialize the protocol and registered fields */
 139 static int proto_opsi                   = -1;
 140 static int hf_opsi_major_version        = -1;
 141 static int hf_opsi_minor_version        = -1;
 142 static int hf_opsi_opcode               = -1;
 143 static int hf_opsi_hook_id              = -1;
 144 static int hf_opsi_length               = -1;
 145 static int hf_opsi_session_id           = -1;
 146 static int hf_user_name_att             = -1;
 147 static int hf_password_att              = -1;
 148 static int hf_chap_password_att         = -1;
 149 static int hf_nas_ip_add_att            = -1;
 150 static int hf_nas_port_att              = -1;
 151 static int hf_service_type_att          = -1;
 152 static int hf_framed_protocol_att       = -1;
 153 static int hf_framed_address_att        = -1;
 154 static int hf_framed_netmask_att        = -1;
 155 static int hf_framed_routing_att        = -1;
 156 static int hf_framed_filter_att         = -1;
 157 static int hf_framed_mtu_att            = -1;
 158 static int hf_framed_compression_att    = -1;
 159 static int hf_called_station_att        = -1;
 160 static int hf_calling_station_att       = -1;
 161 static int hf_nas_identifier_att        = -1;
 162 static int hf_accounting_att            = -1;
 163 static int hf_acct_session_id_att       = -1;
 164 static int hf_chap_challenge_att        = -1;
 165 static int hf_nas_port_type_att         = -1;
 166 static int hf_designation_num_att       = -1;
 167 static int hf_nas_port_id_att           = -1;
 168 static int hf_smc_aaa_id_att            = -1;
 169 static int hf_smc_vpn_id_att            = -1;
 170 static int hf_smc_vpn_name_att          = -1;
 171 static int hf_smc_ran_id_att            = -1;
 172 static int hf_smc_ran_ip_att            = -1;
 173 static int hf_smc_ran_name_att          = -1;
 174 static int hf_smc_pop_id_att            = -1;
 175 static int hf_smc_pop_name_att          = -1;
 176 static int hf_smc_id_att                = -1;
 177 static int hf_smc_receive_time_att      = -1;
 178 static int hf_smc_stat_time_att         = -1;
 179 static int hf_opsi_flags_att            = -1;
 180 static int hf_opsi_application_name_att = -1;
 181
 182 /* Initialize the subtree pointers */
 183 static gint ett_opsi                    = -1;
 184 static gint ett_opsi_user_name          = -1;
 185 static gint ett_opsi_user_password      = -1;
 186 static gint ett_opsi_chap_password      = -1;
 187 static gint ett_opsi_nas_ip_address     = -1;
 188 static gint ett_opsi_nas_port           = -1;
 189 static gint ett_opsi_service_type       = -1;
 190 static gint ett_opsi_framed_protocol    = -1;
 191 static gint ett_opsi_framed_address     = -1;
 192 static gint ett_opsi_framed_netmask     = -1;
 193 static gint ett_opsi_framed_routing     = -1;
 194 static gint ett_opsi_framed_filter      = -1;
 195 static gint ett_opsi_framed_mtu         = -1;
 196 static gint ett_opsi_framed_compression = -1;
 197 static gint ett_opsi_called_station_id  = -1;
 198 static gint ett_opsi_calling_station_id = -1;
 199 static gint ett_opsi_nas_identifier     = -1;
 200 static gint ett_opsi_accounting         = -1;
 201 static gint ett_opsi_acct_session_id    = -1;
 202 static gint ett_opsi_chap_challenge     = -1;
 203 static gint ett_opsi_nas_port_type      = -1;
 204 static gint ett_opsi_designation_number = -1;
 205 static gint ett_opsi_nas_port_id        = -1;
 206 static gint ett_opsi_smc_aaa_id         = -1;
 207 static gint ett_opsi_smc_vpn_id         = -1;
 208 static gint ett_opsi_smc_vpn_name       = -1;
 209 static gint ett_opsi_smc_ran_id         = -1;
 210 static gint ett_opsi_smc_ran_ip         = -1;
 211 static gint ett_opsi_smc_ran_name       = -1;
 212 static gint ett_opsi_smc_pop_id         = -1;
 213 static gint ett_opsi_smc_pop_name       = -1;
 214 static gint ett_opsi_smc_id             = -1;
 215 static gint ett_opsi_smc_receive_time   = -1;
 216 static gint ett_opsi_smc_stat_time      = -1;
 217 static gint ett_opsi_flags              = -1;
 218 static gint ett_opsi_application_name   = -1;
 219
 220
 221 /* Code mapping */
 222 static const value_string opsi_opcode[] = {
 223                 { DISCOVER_REQUEST,     "Discover Request" },
 224                 { DISCOVER_RESPONSE,    "Discover Response" },
 225                 { SERVICE_REQUEST,      "Service Request" },
 226                 { SERVICE_ACCEPT,       "Service Accept" },
 227                 { SERVICE_REJECT,       "Service Reject" },
 228                 { TERMINATE_REQUEST,    "Terminate Request" },
 229                 { 0,                    NULL }
 230         };
 231
 232 static const value_string opsi_service_type_code[] = {
 233                 { 1, "Login" },
 234                 { 2, "Framed" },
 235                 { 3, "Callback Login" },
 236                 { 4, "Callback Framed" },
 237                 { 5, "Outbound" },
 238                 { 6, "Administrative" },
 239                 { 7, "NAS Prompt" },
 240                 { 8, "Authenticate Only" },
 241                 { 9, "Callback NAS Prompt" },
 242                 { 0,                    NULL }
 243         };
 244
 245 static const value_string opsi_framed_protocol_code[] = {
 246                 { 1,    "PPP" },
 247                 { 2,    "SLIP" },
 248                 { 3,    "AppleTalk Remote Access Protocol (ARAP)" },
 249                 { 4,    "Gandalf proprietary SingleLink/MultiLink protocol" },
 250                 { 5,    "Xylogics proprietary IPX/SLIP" },
 251                 { 255,  "Ascend ARA" },
 252                 { 256,  "MPP" },
 253                 { 257,  "EURAW" },
 254                 { 258,  "EUUI" },
 255                 { 259,  "X25" },
 256                 { 260,  "COMB" },
 257                 { 261,  "FR" },
 258                 { 262,  "MP" },
 259                 { 263,  "FR-CIR"},
 260                 { 0,                    NULL }
 261         };
 262
 263 static const value_string opsi_framed_routing_code[] = {
 264                 { 0,    "None" },
 265                 { 1,    "Broadcast" },
 266                 { 2,    "Listen" },
 267                 { 3,    "Broadcast-Listen" },
 268                 { 4,    "Broadcast V2" },
 269                 { 5,    "Listen V2" },
 270                 { 6,    "Broadcast-Listen V2" },
 271                 { 0,    NULL },
 272         };
 273
 274 static const value_string opsi_framed_compression_code[] = {
 275                 { 0,    "None" },
 276                 { 1,    "Van Jacobsen TCP/IP" },
 277                 { 2,    "IPX header compression" },
 278                 { 0,    NULL }
 279         };
 280
 281 static const value_string opsi_nas_port_type_code[] = {
 282                 { 0, "Async" },
 283                 { 1, "Sync" },
 284                 { 2, "ISDN Sync" },
 285                 { 3, "ISDN Async V.120" },
 286                 { 4, "ISDN Async V.110" },
 287                 { 5, "Virtual" },
 288                 { 6, "PIAFS" },
 289                 { 7, "HDLC Clear Channel" },
 290                 { 8, "X.25" },
 291                 { 9, "X.75" },
 292                 { 10, "G.3 Fax" },
 293                 { 11, "SDSL - Symmetric DSL" },
 294                 { 12, "ADSL-CAP - Asymmetric DSL, Carrierless Amplitude Phase Modulation" },
 295                 { 13, "ADSL-DMT - Asymmetric DSL, Discrete Multi-Tone" },
 296                 { 14, "IDSL - ISDN Digital Subscriber Line" },
 297                 { 15, "Ethernet" },
 298                 { 16, "xDSL - Digital Subscriber Line of unknown type" },
 299                 { 17, "Cable" },
 300                 { 18, "Wireless - Other" },
 301                 { 19, "Wireless - IEEE 802.11" },
 302                 { 201,"Voice over IP" },
 303                 { 0,                    NULL }
 304         };
 305
 306
 307 /* Structure used to decode OPSI frame attributes       */
 308 /* CAUTION : it is compulsory to sort this array        */
 309 /* (first argument of the opsi_attribute_handle_t)      */
 310 /* in ascending order                                   */
 311 /*                                                      */
 312 static opsi_attribute_handle_t opsi_attributes[] = {
 313         { USER_NAME_ATTRIBUTE,          /* 1 */
 314         "User name attribute", &ett_opsi_user_name, &hf_user_name_att, decode_string_attribute },
 315         { USER_PASSWD_ATTRIBUTE,        /* 2 */
 316         "User password attribute" , &ett_opsi_user_password, &hf_password_att, decode_string_attribute },
 317         { CHAP_PASSWD_ATTRIBUTE,        /* 3 */
 318         "CHAP password attribute", &ett_opsi_chap_password, &hf_chap_password_att, decode_string_attribute },
 319         { NAS_IP_ADDRESS_ATTRIBUTE,     /* 4 */
 320         "NAS IP address attribute", &ett_opsi_nas_ip_address, &hf_nas_ip_add_att, decode_ipv4_attribute },
 321         {NAS_PORT_ATTRIBUTE,            /* 5 */
 322         "NAS port attribute", &ett_opsi_nas_port, &hf_nas_port_att, decode_longint_attribute },
 323         {SERVICE_TYPE_ATTRIBUTE,        /* 6 */
 324         "Service type attribute", &ett_opsi_service_type, &hf_service_type_att, decode_value_string_attribute },
 325         {FRAMED_PROTOCOL_ATTRIBUTE,     /* 7 */
 326         "Framed protocol attribute", &ett_opsi_framed_protocol, &hf_framed_protocol_att, decode_value_string_attribute },
 327         {FRAMED_ADDRESS_ATTRIBUTE,      /* 8 */
 328         "Framed address attribute", &ett_opsi_framed_address, &hf_framed_address_att, decode_ipv4_attribute },
 329         {FRAMED_NETMASK_ATTRIBUTE,      /* 9 */
 330         "Framed netmask attribute", &ett_opsi_framed_netmask, &hf_framed_netmask_att, decode_ipv4_attribute },
 331         {FRAMED_ROUTING_ATTRIBUTE,      /* 10 */
 332         "Framed routing attribute", &ett_opsi_framed_routing, &hf_framed_routing_att, decode_value_string_attribute },
 333         {FRAMED_FILTER_ATTRIBUTE,       /* 11 */
 334         "Framed filter attribute", &ett_opsi_framed_filter, &hf_framed_filter_att, decode_string_attribute },
 335         {FRAMED_MTU_ATTRIBUTE,          /* 12 */
 336         "Framed MTU attribute", &ett_opsi_framed_mtu, &hf_framed_mtu_att, decode_longint_attribute },
 337         {FRAMED_COMPRESSION_ATTRIBUTE,  /* 13 */
 338         "Framed compression attribute", &ett_opsi_framed_compression, &hf_framed_compression_att, decode_value_string_attribute },
 339         {CALLED_STATION_ID_ATTRIBUTE,   /* 30 */
 340         "Called station ID attribute", &ett_opsi_called_station_id, &hf_called_station_att, decode_string_attribute },
 341         {CALLING_STATION_ID_ATTRIBUTE,  /* 31 */
 342         "Calling station ID attribute", &ett_opsi_calling_station_id, &hf_calling_station_att, decode_string_attribute },
 343         {NAS_IDENTIFIER,                /* 32 */
 344         "NAS Identifier attribute", &ett_opsi_nas_identifier, &hf_nas_identifier_att, decode_string_attribute },
 345         {ACCOUNTING_40_ATTRIBUTE,       /* 40 */
 346         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 347         {ACCOUNTING_41_ATTRIBUTE,       /* 41 */
 348         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 349         {ACCOUNTING_42_ATTRIBUTE,       /* 42 */
 350         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 351         {ACCOUNTING_43_ATTRIBUTE,       /* 43 */
 352         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 353         {ACCOUNTING_SESSION_ID_ATTRIBUTE,       /* 44 */
 354         "Accounting session ID attribute", &ett_opsi_acct_session_id, &hf_acct_session_id_att, decode_string_attribute },
 355         {ACCOUNTING_45_ATTRIBUTE,       /* 45 */
 356         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 357         {ACCOUNTING_46_ATTRIBUTE,       /* 46 */
 358         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 359         {ACCOUNTING_47_ATTRIBUTE,       /* 47 */
 360         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 361         {ACCOUNTING_48_ATTRIBUTE,       /* 48 */
 362         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 363         {ACCOUNTING_49_ATTRIBUTE,       /* 49 */
 364         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 365         {ACCOUNTING_50_ATTRIBUTE,       /* 50 */
 366         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 367         {ACCOUNTING_51_ATTRIBUTE,       /* 51 */
 368         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 369         {ACCOUNTING_52_ATTRIBUTE,       /* 52 */
 370         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 371         {ACCOUNTING_53_ATTRIBUTE,       /* 53 */
 372         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 373         {ACCOUNTING_54_ATTRIBUTE,       /* 54 */
 374         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 375         {ACCOUNTING_55_ATTRIBUTE,       /* 55 */
 376         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 377         {ACCOUNTING_56_ATTRIBUTE,       /* 56 */
 378         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 379         {ACCOUNTING_57_ATTRIBUTE,       /* 57 */
 380         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 381         {ACCOUNTING_58_ATTRIBUTE,       /* 58 */
 382         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 383         {ACCOUNTING_59_ATTRIBUTE,       /* 59 */
 384         "Accounting attribute", &ett_opsi_accounting, &hf_accounting_att, decode_string_attribute },
 385         {CHAP_CHALLENGE_ATTRIBUTE,      /* 60 */
 386         "CHAP challenge",       &ett_opsi_chap_challenge, &hf_chap_challenge_att, decode_string_attribute },
 387         {NAS_PORT_TYPE_ATTRIBUTE,       /* 61 */
 388         "NAS port type attribute", &ett_opsi_nas_port_type, &hf_nas_port_type_att, decode_value_string_attribute },
 389         {DESIGNATION_NUMBER_ATTRIBUTE,  /* 77 */
 390         "Designation number attribute", &ett_opsi_designation_number, &hf_designation_num_att, decode_string_attribute },
 391         {NAS_PORT_ID_ATTRIBUTE,         /* 87 */
 392         "NAS port ID attribute", &ett_opsi_nas_port_id, &hf_nas_port_id_att, decode_string_attribute },
 393         {SMC_AAAID_ATTRIBUTE,           /* 651 */
 394         "SMC AAA ID attribute", &ett_opsi_smc_aaa_id, &hf_smc_aaa_id_att, decode_longint_attribute },
 395         {SMC_VPNID_ATTRIBUTE,           /* 652 */
 396         "SMC VPN ID attribute", &ett_opsi_smc_vpn_id, &hf_smc_vpn_id_att, decode_longint_attribute },
 397         {SMC_VPNNAME_ATTRIBUTE,         /* 653 */
 398         "SMC VPN name attribute", &ett_opsi_smc_vpn_name, &hf_smc_vpn_name_att, decode_string_attribute },
 399         {SMC_RANID_ATTRIBUTE,           /* 654 */
 400         "SMC RAN ID attribute", &ett_opsi_smc_ran_id, &hf_smc_ran_id_att, decode_longint_attribute },
 401         {SMC_RANIP_ATTRIBUTE,           /* 655 */
 402         "SMC RAN IP attribute", &ett_opsi_smc_ran_ip, &hf_smc_ran_ip_att, decode_ipv4_attribute },
 403         {SMC_RANNAME_ATTRIBUTE,         /* 656 */
 404         "SMC RAN name attribute", &ett_opsi_smc_ran_name, &hf_smc_ran_name_att, decode_string_attribute },
 405         {SMC_POPID_ATTRIBUTE,           /* 657 */
 406         "SMC POP ID attribute", &ett_opsi_smc_pop_id, &hf_smc_pop_id_att, decode_longint_attribute },
 407         {SMC_POPNAME_ATTRIBUTE,         /* 658 */
 408         "SMC POP name attribute", &ett_opsi_smc_pop_name, &hf_smc_pop_name_att, decode_string_attribute },
 409         {SMC_SMCID_ATTRIBUTE,           /* 659 */
 410         "SMC ID attribute", &ett_opsi_smc_id, &hf_smc_id_att, decode_longint_attribute },
 411         {SMC_RECEIVE_TIME_ATTRIBUTE,    /* 660 */
 412         "SMC receive time attribute", &ett_opsi_smc_receive_time, &hf_smc_receive_time_att, decode_time_attribute },
 413         {SMC_STAT_TIME_ATTRIBUTE,       /* 661 */
 414         "SMC stat time attribute", &ett_opsi_smc_stat_time, &hf_smc_stat_time_att, decode_longint_attribute },
 415         {OPSI_FLAGS_ATTRIBUTE,          /* 674 */
 416         "OPSI flags attribute", &ett_opsi_flags, &hf_opsi_flags_att, decode_longint_attribute },
 417         {OPSI_APPLICATION_NAME_ATTRIBUTE,/* 675 */
 418         "OPSI application name attribute", &ett_opsi_application_name, &hf_opsi_application_name_att, decode_string_attribute },
 419
 420 };
 421 #define OPSI_ATTRIBUTES_COUNT (sizeof(opsi_attributes)/sizeof(opsi_attribute_handle_t))
 422
 423 /* Desegmentation of OPSI (over TCP) */
 424 static gboolean opsi_desegment = TRUE;
 425 /* To check if we must create or update the information column  */
 426 static gboolean opsi_first;
 427
 428 static void
 429 decode_string_attribute(tvbuff_t *tvb, proto_tree *tree, int* hfValue, int offset, int length)
 430 {
 431         guint8* pbuffer;
 432         if (length < 4) {
 433                 proto_tree_add_text(tree, tvb, offset, length, "Too short attribute!");
 434                 return;
 435         }
 436
 437         pbuffer=tvb_get_ephemeral_string(tvb, offset+4, length-4);
 438         proto_tree_add_string(tree, *hfValue, tvb, offset+4, length-4, pbuffer);
 439 }
 440
 441
 442 static void
 443 decode_ipv4_attribute(tvbuff_t *tvb, proto_tree *tree, int* hfValue, int offset, int length)
 444 {
 445         guint32 ip_address;
 446         if (length < 8) {
 447                 proto_tree_add_text(tree, tvb, offset, length, "Too short attribute!");
 448                 return;
 449         }
 450         ip_address = tvb_get_ipv4(tvb, offset+4);
 451         proto_tree_add_ipv4(tree, *hfValue, tvb, offset+4, 4, ip_address);
 452 }
 453
 454 static void
 455 decode_longint_attribute(tvbuff_t *tvb, proto_tree *tree, int* hfValue, int offset, int length)
 456 {
 457         if (length < 8) {
 458                 proto_tree_add_text(tree, tvb, offset, length, "Too short attribute!");
 459                 return;
 460         }
 461         proto_tree_add_uint(tree, *hfValue, tvb, offset+4, 4, tvb_get_ntohl(tvb, offset+4));
 462 }
 463
 464 static void
 465 decode_value_string_attribute(tvbuff_t *tvb, proto_tree *tree, int* hfValue, int offset, int length)
 466 {
 467         if (length < 8) {
 468                 proto_tree_add_text(tree, tvb, offset, length, "Too short attribute!");
 469                 return;
 470         }
 471         proto_tree_add_item(tree, *hfValue, tvb, offset+4, 4, FALSE);
 472 }
 473
 474 static void
 475 decode_time_attribute(tvbuff_t *tvb, proto_tree *tree, int* hfValue, int offset, int length)
 476 {
 477         nstime_t ns;
 478
 479         if (length < 8) {
 480                 proto_tree_add_text(tree, tvb, offset, length, "Too short attribute!");
 481                 return;
 482         }
 483       ns.secs  = tvb_get_ntohl(tvb, offset+4);
 484       ns.nsecs = 0;
 485       proto_tree_add_time(tree, *hfValue, tvb, offset+4, 4, &ns);
 486 }
 487
 488 /****************************************************************************/
 489 /********** End of attribute decoding ***************************************/
 490 /****************************************************************************/
 491
 492 /* To find the correct size of the PDU. Needed by the desegmentation feature*/
 493 static guint
 494 get_opsi_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset)
 495 {
 496   /*
 497    * Get the length of the OPSI packet.
 498    * We are guaranteed there're enough chars in tvb in order to
 499    * extract the length value. No exception thrown !!
 500    */
 501   return tvb_get_ntohs(tvb, offset + 4);
 502 }
 503
 504 static int
 505 get_opsi_attribute_index(int min, int max, int attribute_type)
 506 {
 507         int middle, at;
 508
 509         middle = (min+max)/2;
 510         at = opsi_attributes[middle].attribute_type;
 511         if (at == attribute_type) return middle;
 512         if (attribute_type > at) {
 513                 return (middle == max) ? -1 : get_opsi_attribute_index(middle+1, max, attribute_type);
 514         }
 515         return (middle == min) ? -1 : get_opsi_attribute_index(min, middle-1, attribute_type);
 516 }
 517
 518
 519 static void
 520 dissect_attributes(tvbuff_t *tvb, proto_tree *opsi_tree, int offset, int length)
 521 {
 522         int i;
 523         int attribute_type;
 524         int attribute_length;
 525         proto_item *ti;
 526         proto_tree *ntree = NULL;
 527
 528         while (length >= 4) {
 529                 attribute_type          = tvb_get_ntohs(tvb, offset);
 530                 attribute_length        = tvb_get_ntohs(tvb, offset+2);
 531                 if (attribute_length > length) break;
 532                 /* We perform a standard log(n) lookup */
 533                 i = get_opsi_attribute_index(0, OPSI_ATTRIBUTES_COUNT-1, attribute_type);
 534                 if (i == -1) {
 535                         proto_tree_add_text(opsi_tree, tvb, offset, attribute_length, "Unknown attribute (%d)", attribute_type);
 536                 }
 537                 else {
 538                         ti = proto_tree_add_text(opsi_tree, tvb, offset, attribute_length, "%s (%d)", opsi_attributes[i].tree_text, attribute_type);
 539                         ntree = proto_item_add_subtree(ti, *opsi_attributes[i].tree_id);
 540                         proto_tree_add_text(ntree, tvb, offset+2, 2, "Length (%d)", attribute_length);
 541                         opsi_attributes[i].dissect(tvb, ntree, opsi_attributes[i].hf_type_attribute, offset, attribute_length);
 542                 }
 543                 if (attribute_length < 4) {
 544                         /* Length must be at least 4, for the type and length. */
 545                         break;
 546                 }
 547                 offset += attribute_length;
 548                 length -= attribute_length;
 549         }
 550         if (length) {
 551                 proto_tree_add_text(opsi_tree, tvb, offset, -1, "Short frame");
 552         }
 553 }
 554
 555 static void
 556 dissect_opsi_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 557 {
 558         proto_item *ti;
 559         proto_tree *opsi_tree;
 560
 561         if (opsi_first == TRUE) {
 562                 opsi_first = FALSE;
 563
 564                 col_set_str(pinfo->cinfo, COL_PROTOCOL, "OPSI");
 565
 566                 if (check_col(pinfo->cinfo, COL_INFO)) {
 567                         col_clear(pinfo->cinfo, COL_INFO);
 568                         if (tvb_length(tvb) < CODE_OFFSET+1) {
 569                                 col_set_str(pinfo->cinfo, COL_INFO, "Open Policy Service Interface");
 570                         }
 571                         else {
 572                                 col_add_fstr(pinfo->cinfo, COL_INFO, "Open Policy Service Interface, %s",
 573                                         val_to_str(tvb_get_guint8(tvb, CODE_OFFSET), opsi_opcode,
 574                                      "<Unknown opcode %d>"));
 575                         }
 576                 }
 577         }
 578         else if (check_col(pinfo->cinfo, COL_INFO) && (tvb_length(tvb) > CODE_OFFSET)) {
 579                 col_append_fstr(pinfo->cinfo, COL_INFO, ", %s",
 580                           val_to_str(tvb_get_guint8(tvb, CODE_OFFSET), opsi_opcode,
 581                                      "<Unknown opcode %d>"));
 582         }
 583
 584         if (tree) {
 585                 ti = proto_tree_add_item(tree, proto_opsi, tvb, 0, -1, ENC_NA);
 586                 opsi_tree = proto_item_add_subtree(ti, ett_opsi);
 587                 if (tvb_length(tvb) < 8 ) {
 588                         proto_tree_add_text(opsi_tree, tvb, 0, -1, "Too short OPSI packet!");
 589                         return;
 590                 }
 591
 592                 proto_tree_add_item(opsi_tree, hf_opsi_major_version, tvb, MAJOR_VERSION_OFFSET, 1, ENC_BIG_ENDIAN);
 593                 proto_tree_add_item(opsi_tree, hf_opsi_minor_version, tvb, MINOR_VERSION_OFFSET, 1, ENC_BIG_ENDIAN);
 594                 proto_tree_add_item(opsi_tree, hf_opsi_opcode, tvb, CODE_OFFSET, 1, ENC_BIG_ENDIAN);
 595                 proto_tree_add_item(opsi_tree, hf_opsi_hook_id, tvb, HOOK_ID_OFFSET, 1, ENC_BIG_ENDIAN);
 596                 proto_tree_add_item(opsi_tree, hf_opsi_length, tvb, PACKET_LENGTH_OFFSET, 2, ENC_BIG_ENDIAN);
 597                 proto_tree_add_item(opsi_tree, hf_opsi_session_id, tvb, SESSION_OFFSET, 2, ENC_BIG_ENDIAN);
 598
 599                 dissect_attributes(tvb, opsi_tree, HEADER_LENGTH, MIN(((int)tvb_length(tvb)-HEADER_LENGTH), (tvb_get_ntohs(tvb, PACKET_LENGTH_OFFSET)-HEADER_LENGTH)));
 600         }
 601 }
 602
 603
 604 static void
 605 dissect_opsi(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 606 {
 607         opsi_first = TRUE;
 608         /* we need at least 6 bytes to get the payload size ! */
 609         tcp_dissect_pdus(tvb, pinfo, tree, opsi_desegment, 6, get_opsi_pdu_len,
 610                 dissect_opsi_pdu);
 611 }
 612
 613
 614 void
 615 proto_register_opsi(void)
 616 {
 617
 618 /* Setup list of header fields  See Section 1.6.1 for details*/
 619         static hf_register_info hf[] = {
 620                 { &hf_opsi_major_version,
 621                         { "Major version",           "opsi.major",
 622                         FT_UINT8, BASE_DEC, NULL, 0x0,
 623                         NULL, HFILL }
 624                 },
 625                 { &hf_opsi_minor_version,
 626                         { "Minor version",           "opsi.minor",
 627                         FT_UINT8, BASE_DEC, NULL, 0x0,
 628                         NULL, HFILL }
 629                 },
 630                 { &hf_opsi_opcode,
 631                         { "Operation code",             "opsi.opcode",
 632                         FT_UINT8, BASE_DEC, VALS(opsi_opcode), 0x0,
 633                         NULL, HFILL }
 634                 },
 635                 { &hf_opsi_hook_id,
 636                         { "Hook ID",                    "opsi.hook",
 637                         FT_UINT8, BASE_DEC, NULL, 0x0,
 638                         NULL, HFILL }
 639                 },
 640                 { &hf_opsi_length,
 641                         { "Message length",             "opsi.length",
 642                         FT_UINT16, BASE_DEC, NULL, 0x0,
 643                         NULL, HFILL }
 644                 },
 645                 { &hf_opsi_session_id,
 646                         { "Session ID",                 "opsi.session_id",
 647                         FT_UINT16, BASE_DEC, NULL, 0x0,
 648                         NULL, HFILL }
 649                 },
 650                 { &hf_user_name_att,
 651                         { "User name",                  "opsi.attr.user_name",
 652                         FT_STRING, BASE_NONE, NULL, 0x00,
 653                         NULL, HFILL }
 654                 },
 655                 { &hf_password_att,
 656                         { "User password",              "opsi.attr.password",
 657                         FT_STRING, BASE_NONE, NULL, 0x00,
 658                         NULL, HFILL }
 659                 },
 660                 { &hf_chap_password_att,
 661                         { "CHAP password attribute",    "opsi.attr.chap_password",
 662                         FT_STRING, BASE_NONE, NULL, 0x00,
 663                         NULL, HFILL }
 664                 },
 665                 { &hf_nas_ip_add_att,
 666                         { "NAS IP address",             "opsi.attr.nas_ip_addr",
 667                         FT_IPv4, BASE_NONE, NULL, 0x00,
 668                         NULL, HFILL }
 669                 },
 670                 { &hf_nas_port_att,
 671                         { "NAS port",                   "opsi.attr.nas_port",
 672                         FT_UINT32, BASE_HEX, NULL, 0x00,
 673                         NULL, HFILL }
 674                 },
 675                 { &hf_service_type_att,
 676                         { "Service type",               "opsi.attr.service_type",
 677                         FT_UINT32, BASE_DEC, VALS(opsi_service_type_code), 0x0,
 678                         NULL, HFILL }
 679                 },
 680                 { &hf_framed_protocol_att,
 681                         { "Framed protocol",            "opsi.attr.framed_protocol",
 682                         FT_UINT32, BASE_DEC, VALS(opsi_framed_protocol_code), 0x0,
 683                         NULL, HFILL }
 684                 },
 685                 { &hf_framed_address_att,
 686                         { "Framed address",             "opsi.attr.framed_address",
 687                         FT_IPv4, BASE_NONE, NULL, 0x00,
 688                         NULL, HFILL }
 689                 },
 690                 { &hf_framed_netmask_att,
 691                         { "Framed netmask",             "opsi.attr.framed_netmask",
 692                         FT_IPv4, BASE_NONE, NULL, 0x00,
 693                         NULL, HFILL }
 694                 },
 695                 { &hf_framed_routing_att,
 696                         { "Framed routing",             "opsi.attr.framed_routing",
 697                         FT_UINT32, BASE_DEC, VALS(opsi_framed_routing_code), 0x0,
 698                         NULL, HFILL }
 699                 },
 700                 { &hf_framed_filter_att,
 701                         { "Framed filter",              "opsi.attr.framed_filter",
 702                         FT_STRING, BASE_NONE, NULL, 0x00,
 703                         NULL, HFILL }
 704                 },
 705                 { &hf_framed_mtu_att,
 706                         { "Framed MTU",         "opsi.attr.framed_mtu",
 707                         FT_UINT32, BASE_DEC, NULL, 0x00,
 708                         NULL, HFILL }
 709                 },
 710                 { &hf_framed_compression_att,
 711                         { "Framed compression",         "opsi.attr.framed_compression",
 712                         FT_UINT32, BASE_DEC, VALS(opsi_framed_compression_code), 0x0,
 713                         NULL, HFILL }
 714                 },
 715                 { &hf_called_station_att,
 716                         { "Called station ID",          "opsi.attr.called_station_id",
 717                         FT_STRING, BASE_NONE, NULL, 0x00,
 718                         NULL, HFILL }
 719                 },
 720                 { &hf_calling_station_att,
 721                         { "Calling station ID",         "opsi.attr.calling_station_id",
 722                         FT_STRING, BASE_NONE, NULL, 0x00,
 723                         NULL, HFILL }
 724                 },
 725                 { &hf_nas_identifier_att,
 726                         { "NAS ID",                     "opsi.attr.nas_id",
 727                         FT_STRING, BASE_NONE, NULL, 0x00,
 728                         NULL, HFILL }
 729                 },
 730                 { &hf_accounting_att,
 731                         { "Accounting",                 "opsi.attr.accounting",
 732                         FT_STRING, BASE_NONE, NULL, 0x00,
 733                         NULL, HFILL }
 734                 },
 735                 { &hf_acct_session_id_att,
 736                         { "Accounting session ID",      "opsi.attr.acct.session_id",
 737                         FT_STRING, BASE_NONE, NULL, 0x00,
 738                         NULL, HFILL }
 739                 },
 740                 { &hf_chap_challenge_att,
 741                         { "CHAP challenge",             "opsi.attr.chap_challenge",
 742                         FT_STRING, BASE_NONE, NULL, 0x00,
 743                         NULL, HFILL }
 744                 },
 745                 { &hf_nas_port_type_att,
 746                         { "NAS port type",              "opsi.attr.nas_port_type",
 747                         FT_UINT32, BASE_DEC, VALS(opsi_nas_port_type_code), 0x0,
 748                         NULL, HFILL }
 749                 },
 750                 { &hf_designation_num_att,
 751                         { "Designation number",         "opsi.attr.designation_number",
 752                         FT_STRING, BASE_NONE, NULL, 0x00,
 753                         NULL, HFILL }
 754                 },
 755                 { &hf_nas_port_id_att,
 756                         { "NAS port ID",                "opsi.attr.nas_port_id",
 757                         FT_STRING, BASE_NONE, NULL, 0x00,
 758                         NULL, HFILL }
 759                 },
 760                 { &hf_smc_aaa_id_att,
 761                         { "SMC AAA ID",                 "opsi.attr.smc_aaa_id",
 762                         FT_UINT32, BASE_DEC, NULL, 0x00,
 763                         NULL, HFILL }
 764                 },
 765                 { &hf_smc_vpn_id_att,
 766                         { "SMC VPN ID",                 "opsi.attr.smc_vpn_id",
 767                         FT_UINT32, BASE_DEC, NULL, 0x00,
 768                         NULL, HFILL }
 769                 },
 770                 { &hf_smc_vpn_name_att,
 771                         { "SMC VPN name",               "opsi.attr.smc_vpn_name",
 772                         FT_STRING, BASE_NONE, NULL, 0x00,
 773                         NULL, HFILL }
 774                 },
 775                 { &hf_smc_ran_id_att,
 776                         { "SMC RAN ID",                 "opsi.attr.smc_ran_id",
 777                         FT_UINT32, BASE_DEC, NULL, 0x00,
 778                         NULL, HFILL }
 779                 },
 780                 { &hf_smc_ran_ip_att,
 781                         { "SMC RAN IP address",         "opsi.attr.smc_ran_ip",
 782                         FT_IPv4, BASE_NONE, NULL, 0x00,
 783                         NULL, HFILL }
 784                 },
 785                 { &hf_smc_ran_name_att,
 786                         { "SMC RAN name",               "opsi.attr.smc_ran_name",
 787                         FT_STRING, BASE_NONE, NULL, 0x00,
 788                         NULL, HFILL }
 789                 },
 790                 { &hf_smc_pop_id_att,
 791                         { "SMC POP id",                 "opsi.attr.smc_pop_id",
 792                         FT_UINT32, BASE_DEC, NULL, 0x00,
 793                         NULL, HFILL }
 794                 },
 795                 { &hf_smc_pop_name_att,
 796                         { "SMC POP name",               "opsi.attr.smc_pop_name",
 797                         FT_STRING, BASE_NONE, NULL, 0x00,
 798                         NULL, HFILL }
 799                 },
 800                 { &hf_smc_id_att,
 801                         { "SMC ID",                     "opsi.attr.smc_id",
 802                         FT_UINT32, BASE_DEC, NULL, 0x00,
 803                         NULL, HFILL }
 804                 },
 805                 { &hf_smc_receive_time_att,
 806                         { "SMC receive time",           "opsi.attr.smc_receive_time",
 807                         FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x00,
 808                         NULL, HFILL }
 809                 },
 810                 { &hf_smc_stat_time_att,
 811                         { "SMC stat time",              "opsi.attr.smc_stat_time",
 812                         FT_UINT32, BASE_DEC, NULL, 0x00,
 813                         NULL, HFILL }
 814                 },
 815                 { &hf_opsi_flags_att,
 816                         { "OPSI flags",                 "opsi.attr.flags",
 817                         FT_UINT32, BASE_DEC, NULL, 0x00,
 818                         NULL, HFILL }
 819                 },
 820                 { &hf_opsi_application_name_att,
 821                         { "OPSI application name",      "opsi.attr.application_name",
 822                         FT_STRING, BASE_NONE, NULL, 0x00,
 823                         NULL, HFILL }
 824                 },
 825         };
 826
 827 /* Setup protocol subtree array */
 828         static gint *ett[] = {
 829                 &ett_opsi,
 830                 &ett_opsi_user_name,
 831                 &ett_opsi_user_password,
 832                 &ett_opsi_chap_password,
 833                 &ett_opsi_nas_ip_address,
 834                 &ett_opsi_nas_port,
 835                 &ett_opsi_service_type,
 836                 &ett_opsi_framed_protocol,
 837                 &ett_opsi_framed_address,
 838                 &ett_opsi_framed_netmask,
 839                 &ett_opsi_framed_routing,
 840                 &ett_opsi_framed_filter,
 841                 &ett_opsi_framed_mtu,
 842                 &ett_opsi_framed_compression,
 843                 &ett_opsi_called_station_id,
 844                 &ett_opsi_calling_station_id,
 845                 &ett_opsi_nas_identifier,
 846                 &ett_opsi_accounting,
 847                 &ett_opsi_acct_session_id,
 848                 &ett_opsi_chap_challenge,
 849                 &ett_opsi_nas_port_type,
 850                 &ett_opsi_designation_number,
 851                 &ett_opsi_nas_port_id,
 852                 &ett_opsi_smc_aaa_id,
 853                 &ett_opsi_smc_vpn_id,
 854                 &ett_opsi_smc_vpn_name,
 855                 &ett_opsi_smc_ran_id,
 856                 &ett_opsi_smc_ran_ip,
 857                 &ett_opsi_smc_ran_name,
 858                 &ett_opsi_smc_pop_id,
 859                 &ett_opsi_smc_pop_name,
 860                 &ett_opsi_smc_id,
 861                 &ett_opsi_smc_receive_time,
 862                 &ett_opsi_smc_stat_time,
 863                 &ett_opsi_flags,
 864                 &ett_opsi_application_name,
 865         };
 866
 867 /* For desegmentation / reassembly */
 868         module_t *opsi_module;
 869
 870 /* Register the protocol name and description */
 871         proto_opsi = proto_register_protocol("Open Policy Service Interface",
 872             "OPSI", "opsi");
 873
 874 /* Required function calls to register the header fields and subtrees used */
 875         proto_register_field_array(proto_opsi, hf, array_length(hf));
 876         proto_register_subtree_array(ett, array_length(ett));
 877
 878 /* We activate the desegmentation / reassembly feature */
 879         opsi_module = prefs_register_protocol(proto_opsi, NULL);
 880         prefs_register_bool_preference(opsi_module, "desegment_opsi_messages",
 881                 "Reassemble OPSI messages spanning multiple TCP segments",
 882                 "Whether the OPSI dissector should desegment all messages spanning multiple TCP segments",
 883                 &opsi_desegment);
 884 }
 885
 886
 887 void
 888 proto_reg_handoff_opsi(void)
 889 {
 890         dissector_handle_t opsi_handle;
 891         opsi_handle = create_dissector_handle(dissect_opsi, proto_opsi);
 892         dissector_add_uint("tcp.port", TCP_PORT_OPSI, opsi_handle);
 893 }