epan/dissectors/packet-hicp.c

   1 /* packet-hicp.c
   2  * Routines for Host IP Configuration Protocol dissection
   3  * Copyright 2021, Filip Kågesson <exfik@hms.se>
   4  *
   5  * Wireshark - Network traffic analyzer
   6  * By Gerald Combs <gerald@wireshark.org>
   7  * Copyright 1998 Gerald Combs
   8  *
   9  * SPDX-License-Identifier: GPL-2.0-or-later
  10  */
  11
  12 #include <config.h>
  13
  14 #include <epan/packet.h>
  15 #include <epan/expert.h>
  16 #include <epan/strutil.h>
  17
  18 void proto_reg_handoff_hicp(void);
  19 void proto_register_hicp(void);
  20
  21 static dissector_handle_t hicp_handle;
  22
  23 /* Protocols and header fields. */
  24 static int proto_hicp;
  25 static int hf_hicp_cmd;
  26 static int hf_hicp_proto_version;
  27 static int hf_hicp_fb_type;
  28 static int hf_hicp_module_version;
  29 static int hf_hicp_mac;
  30 static int hf_hicp_ip;
  31 static int hf_hicp_sn;
  32 static int hf_hicp_gw;
  33 static int hf_hicp_dhcp;
  34 static int hf_hicp_pswd_required;
  35 static int hf_hicp_hn;
  36 static int hf_hicp_dns1;
  37 static int hf_hicp_dns2;
  38 static int hf_hicp_ext;
  39 static int hf_hicp_pswd;
  40 static int hf_hicp_new_pswd;
  41 static int hf_hicp_new_mac;
  42 static int hf_hicp_status;
  43 static int hf_hicp_error;
  44 static int hf_hicp_target;
  45 static int hf_hicp_src;
  46
  47 static expert_field ei_hicp_error;
  48
  49 static int ett_hicp;
  50
  51 #define HICP_PORT 3250
  52 #define HICP_MIN_LENGTH 2
  53 #define HICP_DELIMITER ";"
  54
  55 /* Values of the supported commands. */
  56 #define HICP_MODULE_SCAN_COMMAND "Module scan"
  57 #define HICP_CONFIG_COMMAND "Configure"
  58 #define HICP_WINK_COMMAND "Wink"
  59
  60 /* Values of the supported parameters. */
  61 #define HICP_PROTOCOL_VERSION "Protocol version"
  62 #define HICP_FB_TYPE "FB type"
  63 #define HICP_MODULE_VERSION "Module version"
  64 #define HICP_MAC "MAC"
  65 #define HICP_IP "IP"
  66 #define HICP_SN "SN"
  67 #define HICP_GW "GW"
  68 #define HICP_DHCP "DHCP"
  69 #define HICP_PSWD_REQUIRED "PSWD"
  70 #define HICP_HN "HN"
  71 #define HICP_DNS1 "DNS1"
  72 #define HICP_DNS2 "DNS2"
  73 #define HICP_EXT "EXT"
  74 #define HICP_PSWD "Password"
  75 #define HICP_NEW_PSWD "New Password"
  76 #define HICP_NEW_MAC "New MAC"
  77 #define HICP_RECONFIGURED "Reconfigured"
  78 #define HICP_INVALID_PSWD "Invalid Password"
  79 #define HICP_INVALID_CONFIG "Invalid Configuration"
  80 #define HICP_TO "To"
  81 #define HICP_EXECUTED "Executed"
  82
  83 static int
  84 dissect_hicp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
  85 {
  86     proto_item* ti;
  87     proto_item* error_pi;
  88     proto_tree* hicp_tree;
  89
  90     unsigned offset = 0;
  91     int lengthp = 0;
  92     double ext_value = 0;
  93
  94     const char* parameters_ptr = NULL;
  95     char** parameters = NULL;
  96     char* parameter_value = NULL;
  97
  98         /* Check that the packet does not start with the header of Secure Host IP Configuration Protocol (SHICP). */
  99     if ((tvb_get_uint16(tvb, offset, ENC_LITTLE_ENDIAN) & 0xFFFE) == 0xABC0) {
 100         return 0;
 101     }
 102
 103     col_set_str(pinfo->cinfo, COL_PROTOCOL, "HICP");
 104     col_clear(pinfo->cinfo, COL_INFO);
 105
 106     ti = proto_tree_add_item(tree, proto_hicp, tvb, offset, -1, ENC_NA);
 107
 108     hicp_tree = proto_item_add_subtree(ti, ett_hicp);
 109
 110     parameters_ptr = tvb_get_stringz_enc(pinfo->pool, tvb, offset, &lengthp, ENC_ASCII);
 111     parameters = wmem_strsplit(pinfo->pool, (const char*)parameters_ptr, HICP_DELIMITER, -1);
 112     for (unsigned i = 0; i < g_strv_length(parameters); i++) {
 113         if (g_strrstr(parameters[i], " = ") != NULL) {
 114             parameter_value = &(g_strrstr(parameters[i], " = "))[3];
 115         }
 116         else if (g_strrstr(parameters[i], ": ") != NULL) {
 117             parameter_value = &(g_strrstr(parameters[i], ": "))[2];
 118         }
 119         else {
 120             parameter_value = "";
 121         }
 122         if (g_ascii_strncasecmp(parameters[i], HICP_MODULE_SCAN_COMMAND, (size_t)strlen(HICP_MODULE_SCAN_COMMAND)) == 0) {
 123             proto_tree_add_string(hicp_tree, hf_hicp_cmd, tvb, offset, (int)strlen(parameters[i]), HICP_MODULE_SCAN_COMMAND);
 124             col_prepend_fstr(pinfo->cinfo, COL_INFO, "Request message, Command: %s", HICP_MODULE_SCAN_COMMAND);
 125         }
 126         else if (g_ascii_strncasecmp(parameters[i], HICP_CONFIG_COMMAND, (size_t)strlen(HICP_CONFIG_COMMAND)) == 0) {
 127             proto_tree_add_string(hicp_tree, hf_hicp_cmd, tvb, offset, (int)strlen(parameters[i]), HICP_CONFIG_COMMAND);
 128             proto_tree_add_string(hicp_tree, hf_hicp_target, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 129             col_prepend_fstr(pinfo->cinfo, COL_INFO, "Request message, Command: %s", HICP_CONFIG_COMMAND);
 130             col_append_fstr(pinfo->cinfo, COL_INFO, ", Module MAC address: %s", parameter_value);
 131         }
 132         else if (g_ascii_strncasecmp(parameters[i], HICP_WINK_COMMAND, (size_t)strlen(HICP_WINK_COMMAND)) == 0) {
 133             proto_tree_add_string(hicp_tree, hf_hicp_cmd, tvb, offset, (int)strlen(parameters[i]), HICP_WINK_COMMAND);
 134             col_prepend_fstr(pinfo->cinfo, COL_INFO, "Request message, Command: %s", HICP_WINK_COMMAND);
 135         }
 136         else if (g_ascii_strncasecmp(parameters[i], HICP_PROTOCOL_VERSION, (size_t)strlen(HICP_PROTOCOL_VERSION)) == 0) {
 137             proto_tree_add_string(hicp_tree, hf_hicp_cmd, tvb, offset, (int)strlen(parameters[i]), HICP_MODULE_SCAN_COMMAND);
 138             proto_tree_add_string(hicp_tree, hf_hicp_proto_version, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 139             col_prepend_fstr(pinfo->cinfo, COL_INFO, "Response message, Command: %s", HICP_MODULE_SCAN_COMMAND);
 140         }
 141         else if (g_ascii_strncasecmp(parameters[i], HICP_FB_TYPE, (size_t)strlen(HICP_FB_TYPE)) == 0) {
 142             proto_tree_add_string(hicp_tree, hf_hicp_fb_type, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 143         }
 144         else if (g_ascii_strncasecmp(parameters[i], HICP_MODULE_VERSION, (size_t)strlen(HICP_MODULE_VERSION)) == 0) {
 145             proto_tree_add_string(hicp_tree, hf_hicp_module_version, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 146         }
 147         else if (g_ascii_strncasecmp(parameters[i], HICP_MAC, (size_t)strlen(HICP_MAC)) == 0) {
 148             proto_tree_add_string(hicp_tree, hf_hicp_mac, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 149             col_append_fstr(pinfo->cinfo, COL_INFO, ", Module MAC address: %s", parameter_value);
 150         }
 151         else if (g_ascii_strncasecmp(parameters[i], HICP_IP, (size_t)strlen(HICP_IP)) == 0) {
 152             proto_tree_add_string(hicp_tree, hf_hicp_ip, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 153         }
 154         else if (g_ascii_strncasecmp(parameters[i], HICP_SN, (size_t)strlen(HICP_SN)) == 0) {
 155             proto_tree_add_string(hicp_tree, hf_hicp_sn, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 156         }
 157         else if (g_ascii_strncasecmp(parameters[i], HICP_GW, (size_t)strlen(HICP_GW)) == 0) {
 158             proto_tree_add_string(hicp_tree, hf_hicp_gw, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 159         }
 160         else if (g_ascii_strncasecmp(parameters[i], HICP_DHCP, (size_t)strlen(HICP_DHCP)) == 0) {
 161             proto_tree_add_string(hicp_tree,
 162                 hf_hicp_dhcp,
 163                 tvb,
 164                 offset,
 165                 (int)strlen(parameters[i]),
 166                 g_ascii_strcasecmp(parameter_value, "ON") == 0 ? "Enabled" : "Disabled");
 167         }
 168         else if (g_ascii_strncasecmp(parameters[i], HICP_PSWD_REQUIRED, (size_t)strlen(HICP_PSWD_REQUIRED)) == 0) {
 169             proto_tree_add_string(hicp_tree,
 170                 hf_hicp_pswd_required,
 171                 tvb,
 172                 offset,
 173                 (int)strlen(parameters[i]),
 174                 g_ascii_strcasecmp(parameter_value, "ON") == 0 ? "Required" : "Not required");
 175         }
 176         else if (g_ascii_strncasecmp(parameters[i], HICP_HN, (size_t)strlen(HICP_HN)) == 0) {
 177             proto_tree_add_string(hicp_tree, hf_hicp_hn, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 178         }
 179         else if (g_ascii_strncasecmp(parameters[i], HICP_DNS1, (size_t)strlen(HICP_DNS1)) == 0) {
 180             proto_tree_add_string(hicp_tree, hf_hicp_dns1, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 181         }
 182         else if (g_ascii_strncasecmp(parameters[i], HICP_DNS2, (size_t)strlen(HICP_DNS2)) == 0) {
 183             proto_tree_add_string(hicp_tree, hf_hicp_dns2, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 184         }
 185         else if (g_ascii_strncasecmp(parameters[i], HICP_EXT, (size_t)strlen(HICP_EXT)) == 0) {
 186             ext_value = g_ascii_strtod(parameter_value, NULL);
 187             if (ext_value == 1) {
 188                 parameter_value = HICP_WINK_COMMAND;
 189             }
 190             else if (ext_value == 0) {
 191                 parameter_value = "None";
 192             }
 193             proto_tree_add_string(hicp_tree, hf_hicp_ext, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 194         }
 195         else if (g_ascii_strncasecmp(parameters[i], HICP_PSWD, (size_t)strlen(HICP_PSWD)) == 0) {
 196             proto_tree_add_string(hicp_tree, hf_hicp_pswd, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 197         }
 198         else if (g_ascii_strncasecmp(parameters[i], HICP_NEW_PSWD, (size_t)strlen(HICP_NEW_PSWD)) == 0) {
 199             proto_tree_add_string(hicp_tree, hf_hicp_new_pswd, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 200         }
 201         else if (g_ascii_strncasecmp(parameters[i], HICP_NEW_MAC, (size_t)strlen(HICP_NEW_MAC)) == 0) {
 202             proto_tree_add_string(hicp_tree, hf_hicp_new_mac, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 203         }
 204         else if (g_ascii_strncasecmp(parameters[i], HICP_RECONFIGURED, (size_t)strlen(HICP_RECONFIGURED)) == 0) {
 205             proto_tree_add_string(hicp_tree, hf_hicp_status, tvb, offset, (int)strlen(parameters[i]), HICP_RECONFIGURED);
 206             proto_tree_add_string(hicp_tree, hf_hicp_src, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 207             col_prepend_fstr(pinfo->cinfo, COL_INFO, "Respond message, Command: %s", HICP_CONFIG_COMMAND);
 208             col_append_fstr(pinfo->cinfo, COL_INFO, ", Module MAC address: %s", parameter_value);
 209         }
 210         else if (g_ascii_strncasecmp(parameters[i], HICP_INVALID_PSWD, (size_t)strlen(HICP_INVALID_PSWD)) == 0) {
 211             proto_tree_add_string(hicp_tree, hf_hicp_src, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 212             error_pi = proto_tree_add_string(hicp_tree, hf_hicp_error, tvb, offset, (int)strlen(parameters[i]), HICP_INVALID_PSWD);
 213             expert_add_info(pinfo, error_pi, &ei_hicp_error);
 214             col_prepend_fstr(pinfo->cinfo, COL_INFO, "Error: %s", HICP_INVALID_PSWD);
 215             col_append_fstr(pinfo->cinfo, COL_INFO, ", Command: %s, Module MAC address: %s", HICP_CONFIG_COMMAND, parameter_value);
 216         }
 217         else if (g_ascii_strncasecmp(parameters[i], HICP_INVALID_CONFIG, (size_t)strlen(HICP_INVALID_CONFIG)) == 0) {
 218             proto_tree_add_string(hicp_tree, hf_hicp_src, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 219             error_pi = proto_tree_add_string(hicp_tree, hf_hicp_error, tvb, offset, (int)strlen(parameters[i]), HICP_INVALID_CONFIG);
 220             expert_add_info(pinfo, error_pi, &ei_hicp_error);
 221             col_prepend_fstr(pinfo->cinfo, COL_INFO, "Error: %s", HICP_INVALID_CONFIG);
 222             col_append_fstr(pinfo->cinfo, COL_INFO, ", Command: %s, Module MAC address: %s", HICP_CONFIG_COMMAND, parameter_value);
 223         }
 224         else if (g_ascii_strncasecmp(parameters[i], HICP_EXECUTED, (size_t)strlen(HICP_EXECUTED)) == 0) {
 225             proto_tree_add_string(hicp_tree, hf_hicp_status, tvb, offset, (int)strlen(parameters[i]), HICP_EXECUTED);
 226             proto_tree_add_string(hicp_tree, hf_hicp_src, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 227             col_prepend_fstr(pinfo->cinfo, COL_INFO, "Respond message, Command: %s", HICP_WINK_COMMAND);
 228             col_append_fstr(pinfo->cinfo, COL_INFO, ", Module MAC address: %s", parameter_value);
 229         }
 230         else if (g_ascii_strncasecmp(parameters[i], HICP_TO, (size_t)strlen(HICP_TO)) == 0) {
 231             proto_tree_add_string(hicp_tree, hf_hicp_target, tvb, offset, (int)strlen(parameters[i]), parameter_value);
 232             col_append_fstr(pinfo->cinfo, COL_INFO, ", Module MAC address: %s", parameter_value);
 233         }
 234         offset += (unsigned)strlen(parameters[i]) + (unsigned)strlen(HICP_DELIMITER);
 235     }
 236
 237     return tvb_captured_length(tvb);
 238 }
 239
 240 void
 241 proto_register_hicp(void)
 242 {
 243     expert_module_t* expert_hicp;
 244
 245     static hf_register_info hf[] = {
 246         { &hf_hicp_cmd,
 247           { "Command", "hicp.cmd",
 248             FT_STRINGZ, BASE_NONE,
 249             NULL, 0x0,
 250             NULL, HFILL }
 251         },
 252         { &hf_hicp_proto_version,
 253           { "Protocol version", "hicp.protoversion",
 254             FT_STRINGZ, BASE_NONE,
 255             NULL, 0x0,
 256             NULL, HFILL }
 257         },
 258         { &hf_hicp_fb_type,
 259           { "Fieldbus type", "hicp.fbtype",
 260             FT_STRINGZ, BASE_NONE,
 261             NULL, 0x0,
 262             NULL, HFILL }
 263         },
 264         { &hf_hicp_module_version,
 265           { "Module version", "hicp.moduleversion",
 266             FT_STRINGZ, BASE_NONE,
 267             NULL, 0x0,
 268             NULL, HFILL }
 269         },
 270         { &hf_hicp_mac,
 271           { "MAC address", "hicp.mac",
 272             FT_STRINGZ, BASE_NONE,
 273             NULL, 0x0,
 274             NULL, HFILL }
 275         },
 276         { &hf_hicp_ip,
 277           { "IP address", "hicp.ip",
 278             FT_STRINGZ, BASE_NONE,
 279             NULL, 0x0,
 280             NULL, HFILL }
 281         },
 282         { &hf_hicp_sn,
 283           { "Subnet mask", "hicp.sn",
 284             FT_STRINGZ, BASE_NONE,
 285             NULL, 0x0,
 286             NULL, HFILL }
 287         },
 288         { &hf_hicp_gw,
 289           { "Gateway address", "hicp.gw",
 290             FT_STRINGZ, BASE_NONE,
 291             NULL, 0x0,
 292             NULL, HFILL }
 293         },
 294         { &hf_hicp_dhcp,
 295           { "DHCP", "hicp.dhcp",
 296             FT_STRINGZ, BASE_NONE,
 297             NULL, 0x0,
 298             NULL, HFILL }
 299         },
 300         { &hf_hicp_pswd_required,
 301           { "Password", "hicp.pswdrequired",
 302             FT_STRINGZ, BASE_NONE,
 303             NULL, 0x0,
 304             NULL, HFILL }
 305         },
 306         { &hf_hicp_hn,
 307           { "Hostname", "hicp.hn",
 308             FT_STRINGZ, BASE_NONE,
 309             NULL, 0x0,
 310             NULL, HFILL }
 311         },
 312         { &hf_hicp_dns1,
 313           { "Primary DNS address", "hicp.dns1",
 314             FT_STRINGZ, BASE_NONE,
 315             NULL, 0x0,
 316             NULL, HFILL }
 317         },
 318         { &hf_hicp_dns2,
 319           { "Secondary DNS", "hicp.dns2",
 320             FT_STRINGZ, BASE_NONE,
 321             NULL, 0x0,
 322             NULL, HFILL }
 323         },
 324         { &hf_hicp_ext,
 325           { "Extended commands supported", "hicp.ext",
 326             FT_STRINGZ, BASE_NONE,
 327             NULL, 0x0,
 328             NULL, HFILL }
 329         },
 330         { &hf_hicp_pswd,
 331           { "Password", "hicp.pswd",
 332             FT_STRINGZ, BASE_NONE,
 333             NULL, 0x0,
 334             NULL, HFILL }
 335         },
 336         { &hf_hicp_new_pswd,
 337           { "New password", "hicp.newpswd",
 338             FT_STRINGZ, BASE_NONE,
 339             NULL, 0x0,
 340             NULL, HFILL }
 341         },
 342         { &hf_hicp_new_mac,
 343           { "New MAC address", "hicp.newmac",
 344             FT_STRINGZ, BASE_NONE,
 345             NULL, 0x0,
 346             NULL, HFILL }
 347         },
 348         { &hf_hicp_status,
 349           { "Status", "hicp.status",
 350             FT_STRINGZ, BASE_NONE,
 351             NULL, 0x0,
 352             NULL, HFILL }
 353         },
 354         { &hf_hicp_error,
 355           { "Error", "hicp.error",
 356             FT_STRINGZ, BASE_NONE,
 357             NULL, 0x0,
 358             NULL, HFILL }
 359         },
 360         { &hf_hicp_target,
 361           { "Target", "hicp.target",
 362             FT_STRINGZ, BASE_NONE,
 363             NULL, 0x0,
 364             NULL, HFILL }
 365         },
 366         { &hf_hicp_src,
 367           { "Source", "hicp.src",
 368             FT_STRINGZ, BASE_NONE,
 369             NULL, 0x0,
 370             NULL, HFILL }
 371         }
 372     };
 373
 374     static int *ett[] = {
 375         &ett_hicp
 376     };
 377
 378     static ei_register_info ei[] = {
 379         { &ei_hicp_error,
 380           { "hicp.error", PI_RESPONSE_CODE, PI_NOTE,
 381             "Message contains an error message.", EXPFILL }
 382         }
 383     };
 384
 385     proto_hicp = proto_register_protocol("Host IP Configuration Protocol", "HICP", "hicp");
 386
 387     proto_register_field_array(proto_hicp, hf, array_length(hf));
 388     proto_register_subtree_array(ett, array_length(ett));
 389
 390     expert_hicp = expert_register_protocol(proto_hicp);
 391     expert_register_field_array(expert_hicp, ei, array_length(ei));
 392
 393     hicp_handle = register_dissector("hicp", dissect_hicp, proto_hicp);
 394 }
 395
 396 void
 397 proto_reg_handoff_hicp(void)
 398 {
 399     dissector_add_uint("udp.port", HICP_PORT, hicp_handle);
 400 }
 401
 402 /*
 403  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 404  *
 405  * Local variables:
 406  * c-basic-offset: 4
 407  * tab-width: 8
 408  * indent-tabs-mode: nil
 409  * End:
 410  *
 411  * vi: set shiftwidth=4 tabstop=8 expandtab:
 412  * :indentSize=4:tabSize=8:noTabs=true:
 413  */