epan/dissectors/packet-usb-hid.c

   1 /* packet-usb-hid.c
   2  *
   3  * USB HID dissector
   4  * By Adam Nielsen <a.nielsen@shikadi.net> 2009
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21
  22 #include "config.h"
  23
  24 #include <glib.h>
  25 #include <epan/packet.h>
  26 #include <string.h>
  27 #include "packet-usb.h"
  28 #include "packet-usb-hid.h"
  29
  30 void proto_register_usb_hid(void);
  31 void proto_reg_handoff_usb_hid(void);
  32
  33 /* protocols and header fields */
  34 static int proto_usb_hid = -1;
  35 static int hf_usb_hid_item_bSize = -1;
  36 static int hf_usb_hid_item_bType = -1;
  37 static int hf_usb_hid_mainitem_bTag = -1;
  38 static int hf_usb_hid_globalitem_bTag = -1;
  39 static int hf_usb_hid_localitem_bTag = -1;
  40 static int hf_usb_hid_longitem_bTag = -1;
  41 static int hf_usb_hid_item_bDataSize = -1;
  42 static int hf_usb_hid_item_bLongItemTag = -1;
  43 static int hf_usb_hid_item_unk_data = -1;
  44
  45 static int hf_usb_hid_mainitem_bit0 = -1;
  46 static int hf_usb_hid_mainitem_bit1 = -1;
  47 static int hf_usb_hid_mainitem_bit2 = -1;
  48 static int hf_usb_hid_mainitem_bit3 = -1;
  49 static int hf_usb_hid_mainitem_bit4 = -1;
  50 static int hf_usb_hid_mainitem_bit5 = -1;
  51 static int hf_usb_hid_mainitem_bit6 = -1;
  52 static int hf_usb_hid_mainitem_bit7 = -1;
  53 static int hf_usb_hid_mainitem_bit7_input = -1;
  54 static int hf_usb_hid_mainitem_bit8 = -1;
  55 static int hf_usb_hid_mainitem_colltype = -1;
  56
  57 static int hf_usb_hid_globalitem_usage = -1;
  58 static int hf_usb_hid_globalitem_log_min = -1;
  59 static int hf_usb_hid_globalitem_log_max = -1;
  60 static int hf_usb_hid_globalitem_phy_min = -1;
  61 static int hf_usb_hid_globalitem_phy_max = -1;
  62 static int hf_usb_hid_globalitem_unit_exp = -1;
  63 static int hf_usb_hid_globalitem_unit_sys = -1;
  64 static int hf_usb_hid_globalitem_unit_len = -1;
  65 static int hf_usb_hid_globalitem_unit_mass = -1;
  66 static int hf_usb_hid_globalitem_unit_time = -1;
  67 static int hf_usb_hid_globalitem_unit_temp = -1;
  68 static int hf_usb_hid_globalitem_unit_current = -1;
  69 static int hf_usb_hid_globalitem_unit_brightness = -1;
  70 static int hf_usb_hid_globalitem_report_size = -1;
  71 static int hf_usb_hid_globalitem_report_id = -1;
  72 static int hf_usb_hid_globalitem_report_count = -1;
  73 static int hf_usb_hid_globalitem_push = -1;
  74 static int hf_usb_hid_globalitem_pop = -1;
  75
  76 static int hf_usb_hid_localitem_usage = -1;
  77 static int hf_usb_hid_localitem_usage_min = -1;
  78 /* static int hf_usb_hid_localitem_usage_max = -1; */
  79 static int hf_usb_hid_localitem_desig_index = -1;
  80 static int hf_usb_hid_localitem_desig_min = -1;
  81 static int hf_usb_hid_localitem_desig_max = -1;
  82 static int hf_usb_hid_localitem_string_index = -1;
  83 static int hf_usb_hid_localitem_string_min = -1;
  84 static int hf_usb_hid_localitem_string_max = -1;
  85 static int hf_usb_hid_localitem_delimiter = -1;
  86
  87 static gint ett_usb_hid_report = -1;
  88 static gint ett_usb_hid_item_header = -1;
  89 static gint ett_usb_hid_wValue = -1;
  90 static gint ett_usb_hid_descriptor = -1;
  91
  92 static int hf_usb_hid_request = -1;
  93 static int hf_usb_hid_value = -1;
  94 static int hf_usb_hid_index = -1;
  95 static int hf_usb_hid_length = -1;
  96 static int hf_usb_hid_report_type = -1;
  97 static int hf_usb_hid_report_id = -1;
  98 static int hf_usb_hid_duration = -1;
  99 static int hf_usb_hid_zero = -1;
 100
 101 static int hf_usb_hid_bcdHID = -1;
 102 static int hf_usb_hid_bCountryCode = -1;
 103 static int hf_usb_hid_bNumDescriptors = -1;
 104 static int hf_usb_hid_bDescriptorType = -1;
 105 static int hf_usb_hid_wDescriptorLength = -1;
 106
 107 static const true_false_string tfs_mainitem_bit0 = {"Data", "Constant"};
 108 static const true_false_string tfs_mainitem_bit1 = {"Array", "Variable"};
 109 static const true_false_string tfs_mainitem_bit2 = {"Absolute", "Relative"};
 110 static const true_false_string tfs_mainitem_bit3 = {"No wrap", "Wrap"};
 111 static const true_false_string tfs_mainitem_bit4 = {"Linear", "Nonlinear"};
 112 static const true_false_string tfs_mainitem_bit5 = {"Preferred state", "No preferred state"};
 113 static const true_false_string tfs_mainitem_bit6 = {"No null position", "Null state"};
 114 static const true_false_string tfs_mainitem_bit7 = {"Non-volatile", "Volatile"};
 115 static const true_false_string tfs_mainitem_bit8 = {"Bit field", "Buffered bytes"};
 116
 117
 118 struct usb_hid_global_state {
 119     unsigned int usage_page;
 120 };
 121
 122
 123 /* HID class specific descriptor types */
 124 #define USB_DT_HID 33
 125 static const value_string hid_descriptor_type_vals[] = {
 126     {USB_DT_HID, "HID"},
 127     {0,NULL}
 128 };
 129 static value_string_ext hid_descriptor_type_vals_ext =
 130                VALUE_STRING_EXT_INIT(hid_descriptor_type_vals);
 131
 132
 133 #define USBHID_SIZE_MASK  0x03
 134 #define USBHID_TYPE_MASK  0x0C
 135 #define USBHID_TAG_MASK   0xF0
 136
 137 static const value_string usb_hid_item_bSize_vals[] = {
 138     {0, "0 bytes"},
 139     {1, "1 byte"},
 140     {2, "2 bytes"},
 141     {3, "4 bytes"},
 142     {0, NULL}
 143 };
 144
 145 #define USBHID_ITEMTYPE_MAIN    0
 146 #define USBHID_ITEMTYPE_GLOBAL  1
 147 #define USBHID_ITEMTYPE_LOCAL   2
 148 #define USBHID_ITEMTYPE_LONG    3
 149 static const value_string usb_hid_item_bType_vals[] = {
 150     {USBHID_ITEMTYPE_MAIN,   "Main"},
 151     {USBHID_ITEMTYPE_GLOBAL, "Global"},
 152     {USBHID_ITEMTYPE_LOCAL,  "Local"},
 153     {USBHID_ITEMTYPE_LONG,   "Long item"},
 154     {0, NULL}
 155 };
 156
 157 #define USBHID_MAINITEM_TAG_INPUT           8
 158 #define USBHID_MAINITEM_TAG_OUTPUT          9
 159 #define USBHID_MAINITEM_TAG_FEATURE        11
 160 #define USBHID_MAINITEM_TAG_COLLECTION     10
 161 #define USBHID_MAINITEM_TAG_ENDCOLLECTION  12
 162 static const value_string usb_hid_mainitem_bTag_vals[] = {
 163     {USBHID_MAINITEM_TAG_INPUT,         "Input"},
 164     {USBHID_MAINITEM_TAG_OUTPUT,        "Output"},
 165     {USBHID_MAINITEM_TAG_FEATURE,       "Feature"},
 166     {USBHID_MAINITEM_TAG_COLLECTION,    "Collection"},
 167     {USBHID_MAINITEM_TAG_ENDCOLLECTION, "End collection"},
 168     {0, NULL}
 169 };
 170 #define USBHID_GLOBALITEM_TAG_USAGE_PAGE    0
 171 #define USBHID_GLOBALITEM_TAG_LOG_MIN       1
 172 #define USBHID_GLOBALITEM_TAG_LOG_MAX       2
 173 #define USBHID_GLOBALITEM_TAG_PHY_MIN       3
 174 #define USBHID_GLOBALITEM_TAG_PHY_MAX       4
 175 #define USBHID_GLOBALITEM_TAG_UNIT_EXP      5
 176 #define USBHID_GLOBALITEM_TAG_UNIT          6
 177 #define USBHID_GLOBALITEM_TAG_REPORT_SIZE   7
 178 #define USBHID_GLOBALITEM_TAG_REPORT_ID     8
 179 #define USBHID_GLOBALITEM_TAG_REPORT_COUNT  9
 180 #define USBHID_GLOBALITEM_TAG_PUSH         10
 181 #define USBHID_GLOBALITEM_TAG_POP          11
 182 static const value_string usb_hid_globalitem_bTag_vals[] = {
 183     {USBHID_GLOBALITEM_TAG_USAGE_PAGE,   "Usage"},
 184     {USBHID_GLOBALITEM_TAG_LOG_MIN,      "Logical minimum"},
 185     {USBHID_GLOBALITEM_TAG_LOG_MAX,      "Logical maximum"},
 186     {USBHID_GLOBALITEM_TAG_PHY_MIN,      "Physical minimum"},
 187     {USBHID_GLOBALITEM_TAG_PHY_MAX,      "Physical maximum"},
 188     {USBHID_GLOBALITEM_TAG_UNIT_EXP,     "Unit exponent"},
 189     {USBHID_GLOBALITEM_TAG_UNIT,         "Units"},
 190     {USBHID_GLOBALITEM_TAG_REPORT_SIZE,  "Report size"},
 191     {USBHID_GLOBALITEM_TAG_REPORT_ID,    "Report ID"},
 192     {USBHID_GLOBALITEM_TAG_REPORT_COUNT, "Report count"},
 193     {USBHID_GLOBALITEM_TAG_PUSH,         "Push"},
 194     {USBHID_GLOBALITEM_TAG_POP,          "Pop"},
 195     {12, "[Reserved]"},
 196     {13, "[Reserved]"},
 197     {14, "[Reserved]"},
 198     {15, "[Reserved]"},
 199     {0, NULL}
 200 };
 201 #define USBHID_LOCALITEM_TAG_USAGE_PAGE     0
 202 #define USBHID_LOCALITEM_TAG_USAGE_MIN      1
 203 #define USBHID_LOCALITEM_TAG_USAGE_MAX      2
 204 #define USBHID_LOCALITEM_TAG_DESIG_INDEX    3
 205 #define USBHID_LOCALITEM_TAG_DESIG_MIN      4
 206 #define USBHID_LOCALITEM_TAG_DESIG_MAX      5
 207 /* No 6 in spec */
 208 #define USBHID_LOCALITEM_TAG_STRING_INDEX   7
 209 #define USBHID_LOCALITEM_TAG_STRING_MIN     8
 210 #define USBHID_LOCALITEM_TAG_STRING_MAX     9
 211 #define USBHID_LOCALITEM_TAG_DELIMITER     10 /* Also listed as reserved in spec! */
 212 static const value_string usb_hid_localitem_bTag_vals[] = {
 213     {USBHID_LOCALITEM_TAG_USAGE_PAGE,   "Usage"},
 214     {USBHID_LOCALITEM_TAG_USAGE_MIN,    "Usage minimum"},
 215     {USBHID_LOCALITEM_TAG_USAGE_MAX,    "Usage maximum"},
 216     {USBHID_LOCALITEM_TAG_DESIG_INDEX,  "Designator index"},
 217     {USBHID_LOCALITEM_TAG_DESIG_MIN,    "Designator minimum"},
 218     {USBHID_LOCALITEM_TAG_DESIG_MAX,    "Designator maximum"},
 219     {USBHID_LOCALITEM_TAG_STRING_INDEX, "String index"},
 220     {USBHID_LOCALITEM_TAG_STRING_MIN,   "String minimum"},
 221     {USBHID_LOCALITEM_TAG_STRING_MAX,   "String maximum"},
 222     {USBHID_LOCALITEM_TAG_DELIMITER,    "Delimiter"},
 223     {11, "[Reserved]"},
 224     {12, "[Reserved]"},
 225     {13, "[Reserved]"},
 226     {14, "[Reserved]"},
 227     {15, "[Reserved]"},
 228     {0, NULL}
 229 };
 230 static const value_string usb_hid_longitem_bTag_vals[] = {
 231     {15, "Long item"},
 232     {0, NULL}
 233 };
 234
 235 static const range_string usb_hid_mainitem_colltype_vals[] = {
 236     {0x00, 0x00, "Physical"},
 237     {0x01, 0x01, "Application"},
 238     {0x02, 0x02, "Logical"},
 239     {0x03, 0x03, "Report"},
 240     {0x04, 0x04, "Named array"},
 241     {0x05, 0x05, "Usage switch"},
 242     {0x06, 0x06, "Usage modifier"},
 243     {0x07, 0x7F, "[Reserved]"},
 244     {0x80, 0xFF, "[Vendor-defined]"},
 245     {0, 0, NULL}
 246 };
 247
 248 static const value_string usb_hid_globalitem_unit_exp_vals[] = {
 249     {0x0, "n^0"},
 250     {0x1, "n^1"},
 251     {0x2, "n^2"},
 252     {0x3, "n^3"},
 253     {0x4, "n^4"},
 254     {0x5, "n^5"},
 255     {0x6, "n^6"},
 256     {0x7, "n^7"},
 257     {0x8, "n^-8"},
 258     {0x9, "n^-7"},
 259     {0xA, "n^-6"},
 260     {0xB, "n^-5"},
 261     {0xC, "n^-4"},
 262     {0xD, "n^-3"},
 263     {0xE, "n^-2"},
 264     {0xF, "n^-1"},
 265     {0, NULL}
 266 };
 267 static const range_string usb_hid_item_usage_vals[] = {
 268     {0x00, 0x00, "Undefined"},
 269     {0x01, 0x01, "Generic desktop controls"},
 270     {0x02, 0x02, "Simulation controls"},
 271     {0x03, 0x03, "VR controls"},
 272     {0x04, 0x04, "Sport controls"},
 273     {0x05, 0x05, "Game controls"},
 274     {0x06, 0x06, "Generic device controls"},
 275     {0x07, 0x07, "Keyboard/keypad"},
 276     {0x08, 0x08, "LEDs"},
 277     {0x09, 0x09, "Button"},
 278     {0x0A, 0x0A, "Ordinal"},
 279     {0x0B, 0x0B, "Telephony"},
 280     {0x0C, 0x0C, "Consumer"},
 281     {0x0D, 0x0D, "Digitizer"},
 282     {0x0E, 0x0E, "[Reserved]"},
 283     {0x0F, 0x0F, "Physical Interface Device (PID) page"},
 284     {0x10, 0x10, "Unicode"},
 285     {0x11, 0x13, "[Reserved]"},
 286     {0x14, 0x14, "Alphanumeric display"},
 287     {0x15, 0x3F, "[Reserved]"},
 288     {0x40, 0x40, "Medical instruments"},
 289     {0x41, 0x7F, "[Reserved]"},
 290     {0x80, 0x83, "Monitor page"},
 291     {0x84, 0x87, "Power page"},
 292     {0x88, 0x8B, "[Reserved]"},
 293     {0x8C, 0x8C, "Bar code scanner page"},
 294     {0x8D, 0x8D, "Scale page"},
 295     {0x8E, 0x8E, "Magnetic Stripe Reading (MSR) devices"},
 296     {0x8F, 0x8F, "[Reserved Point of Sale page]"},
 297     {0x90, 0x90, "Camera control page"},
 298     {0x91, 0x91, "Arcade page"},
 299     {0x92, 0xFEFF, "[Reserved]"},
 300     {0xFF00, 0xFFFF, "[Vendor-defined]"},
 301     {0, 0, NULL}
 302 };
 303
 304 /* Dissector for the data in a HID main report. */
 305 static int
 306 dissect_usb_hid_report_mainitem_data(packet_info *pinfo _U_, proto_tree *tree, tvbuff_t *tvb, int offset, unsigned int bSize, unsigned int bTag)
 307 {
 308     switch (bTag) {
 309         case USBHID_MAINITEM_TAG_INPUT:
 310         case USBHID_MAINITEM_TAG_OUTPUT:
 311         case USBHID_MAINITEM_TAG_FEATURE:
 312             proto_tree_add_item(tree, hf_usb_hid_mainitem_bit0, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 313             proto_tree_add_item(tree, hf_usb_hid_mainitem_bit1, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 314             proto_tree_add_item(tree, hf_usb_hid_mainitem_bit2, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 315             proto_tree_add_item(tree, hf_usb_hid_mainitem_bit3, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 316             proto_tree_add_item(tree, hf_usb_hid_mainitem_bit4, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 317             proto_tree_add_item(tree, hf_usb_hid_mainitem_bit5, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 318             proto_tree_add_item(tree, hf_usb_hid_mainitem_bit6, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 319             if (bTag == USBHID_MAINITEM_TAG_INPUT) {
 320                 proto_tree_add_item(tree, hf_usb_hid_mainitem_bit7_input, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 321             } else {
 322                 proto_tree_add_item(tree, hf_usb_hid_mainitem_bit7, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 323             }
 324             if (bSize > 1) {
 325                 proto_tree_add_item(tree, hf_usb_hid_mainitem_bit8, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 326             } else {
 327                 proto_tree_add_text(tree, tvb, offset, 0, "Bits or bytes: Buffered bytes (default, no second byte present)");
 328             }
 329             break;
 330         case USBHID_MAINITEM_TAG_COLLECTION:
 331             proto_tree_add_item(tree, hf_usb_hid_mainitem_colltype, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 332             break;
 333         case USBHID_MAINITEM_TAG_ENDCOLLECTION:
 334             /* No item data */
 335             break;
 336         default:
 337             proto_tree_add_item(tree, hf_usb_hid_item_unk_data, tvb, offset, bSize, ENC_NA);
 338             break;
 339     }
 340     offset += bSize;
 341     return offset;
 342 }
 343
 344 /* Dissector for the data in a HID main report. */
 345 static int
 346 dissect_usb_hid_report_globalitem_data(packet_info *pinfo _U_, proto_tree *tree, tvbuff_t *tvb, int offset, unsigned int bSize, unsigned int bTag, struct usb_hid_global_state *global)
 347 {
 348     switch (bTag) {
 349         case USBHID_GLOBALITEM_TAG_USAGE_PAGE:
 350             switch (bSize) {
 351                 case 1: global->usage_page = tvb_get_guint8(tvb, offset); break;
 352                 case 2: global->usage_page = tvb_get_letohs(tvb, offset); break;
 353                 case 3: global->usage_page = tvb_get_letoh24(tvb, offset); break;
 354                 case 4: global->usage_page = tvb_get_letohl(tvb, offset); break;
 355                 default: global->usage_page = 0; break;
 356             }
 357             proto_tree_add_item(tree, hf_usb_hid_globalitem_usage, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 358             break;
 359         case USBHID_GLOBALITEM_TAG_LOG_MIN:
 360             proto_tree_add_item(tree, hf_usb_hid_globalitem_log_min, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 361             break;
 362         case USBHID_GLOBALITEM_TAG_LOG_MAX:
 363             proto_tree_add_item(tree, hf_usb_hid_globalitem_log_max, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 364             break;
 365         case USBHID_GLOBALITEM_TAG_PHY_MIN:
 366             proto_tree_add_item(tree, hf_usb_hid_globalitem_phy_min, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 367             break;
 368         case USBHID_GLOBALITEM_TAG_PHY_MAX:
 369             proto_tree_add_item(tree, hf_usb_hid_globalitem_phy_max, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 370             break;
 371         case USBHID_GLOBALITEM_TAG_UNIT_EXP:
 372             proto_tree_add_item(tree, hf_usb_hid_globalitem_unit_exp, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 373             break;
 374         case USBHID_GLOBALITEM_TAG_UNIT:
 375             proto_tree_add_item(tree, hf_usb_hid_globalitem_unit_sys, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 376             proto_tree_add_item(tree, hf_usb_hid_globalitem_unit_len, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 377             proto_tree_add_item(tree, hf_usb_hid_globalitem_unit_mass, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 378             proto_tree_add_item(tree, hf_usb_hid_globalitem_unit_time, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 379             proto_tree_add_item(tree, hf_usb_hid_globalitem_unit_temp, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 380             proto_tree_add_item(tree, hf_usb_hid_globalitem_unit_current, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 381             proto_tree_add_item(tree, hf_usb_hid_globalitem_unit_brightness, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 382             break;
 383         case USBHID_GLOBALITEM_TAG_REPORT_SIZE:
 384             proto_tree_add_item(tree, hf_usb_hid_globalitem_report_size, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 385             break;
 386         case USBHID_GLOBALITEM_TAG_REPORT_ID:
 387             proto_tree_add_item(tree, hf_usb_hid_globalitem_report_id, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 388             break;
 389         case USBHID_GLOBALITEM_TAG_REPORT_COUNT:
 390             proto_tree_add_item(tree, hf_usb_hid_globalitem_report_count, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 391             break;
 392         case USBHID_GLOBALITEM_TAG_PUSH:
 393             proto_tree_add_item(tree, hf_usb_hid_globalitem_push, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 394             break;
 395         case USBHID_GLOBALITEM_TAG_POP:
 396             proto_tree_add_item(tree, hf_usb_hid_globalitem_pop, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 397             break;
 398         default:
 399             proto_tree_add_item(tree, hf_usb_hid_item_unk_data, tvb, offset, bSize, ENC_NA);
 400             break;
 401     }
 402     offset += bSize;
 403     return offset;
 404 }
 405
 406 /* Dissector for the data in a HID main report. */
 407 static int
 408 dissect_usb_hid_report_localitem_data(packet_info *pinfo _U_, proto_tree *tree, tvbuff_t *tvb, int offset, unsigned int bSize, unsigned int bTag, struct usb_hid_global_state *global)
 409 {
 410     unsigned int usage_page = 0xffffffff; /* in case bSize == 0 */
 411
 412     switch (bTag) {
 413         case USBHID_LOCALITEM_TAG_USAGE_PAGE:
 414             if (bSize > 2) {
 415                 /* Full page ID */
 416                 proto_tree_add_item(tree, hf_usb_hid_localitem_usage, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 417             } else {
 418                 /* Only lower few bits given, need to combine with last global ID */
 419                 if (bSize == 1)
 420                     usage_page = (global->usage_page & 0xFFFFFF00) | tvb_get_guint8(tvb, offset);
 421                 else if (bSize == 2)
 422                     usage_page = (global->usage_page & 0xFFFF0000) | tvb_get_ntohs(tvb, offset);
 423                 proto_tree_add_text(tree, tvb, offset, bSize, "Usage: %s (0x%08x)",
 424                     rval_to_str(usage_page, usb_hid_item_usage_vals, "[Unknown page!]"),
 425                     usage_page);
 426             }
 427             break;
 428         case USBHID_LOCALITEM_TAG_USAGE_MIN:
 429             proto_tree_add_item(tree, hf_usb_hid_localitem_usage_min, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 430             break;
 431         case USBHID_LOCALITEM_TAG_USAGE_MAX:
 432             proto_tree_add_item(tree, hf_usb_hid_localitem_usage, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 433             break;
 434         case USBHID_LOCALITEM_TAG_DESIG_INDEX:
 435             proto_tree_add_item(tree, hf_usb_hid_localitem_desig_index, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 436             break;
 437         case USBHID_LOCALITEM_TAG_DESIG_MIN:
 438             proto_tree_add_item(tree, hf_usb_hid_localitem_desig_min, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 439             break;
 440         case USBHID_LOCALITEM_TAG_DESIG_MAX:
 441             proto_tree_add_item(tree, hf_usb_hid_localitem_desig_max, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 442             break;
 443         case USBHID_LOCALITEM_TAG_STRING_INDEX:
 444             proto_tree_add_item(tree, hf_usb_hid_localitem_string_index, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 445             break;
 446         case USBHID_LOCALITEM_TAG_STRING_MIN:
 447             proto_tree_add_item(tree, hf_usb_hid_localitem_string_min, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 448             break;
 449         case USBHID_LOCALITEM_TAG_STRING_MAX:
 450             proto_tree_add_item(tree, hf_usb_hid_localitem_string_max, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 451             break;
 452         case USBHID_LOCALITEM_TAG_DELIMITER:
 453             proto_tree_add_item(tree, hf_usb_hid_localitem_delimiter, tvb, offset, bSize, ENC_LITTLE_ENDIAN);
 454             break;
 455         default:
 456             proto_tree_add_item(tree, hf_usb_hid_item_unk_data, tvb, offset, bSize, ENC_NA);
 457             break;
 458     }
 459     offset += bSize;
 460     return offset;
 461 }
 462
 463 /* Dissector for individual HID report items.  Recursive. */
 464 static int
 465 dissect_usb_hid_report_item(packet_info *pinfo _U_, proto_tree *parent_tree, tvbuff_t *tvb, int offset, usb_trans_info_t *usb_trans_info _U_, usb_conv_info_t *usb_conv_info _U_, const struct usb_hid_global_state *global)
 466 {
 467     proto_item *subitem=NULL;
 468     proto_tree *tree=NULL, *subtree=NULL;
 469     int old_offset;
 470     unsigned int tmp;
 471     unsigned int bSize, bType, bTag;
 472     const value_string *usb_hid_cur_bTag_vals;
 473     int hf_usb_hid_curitem_bTag;
 474     struct usb_hid_global_state cur_global;
 475     memcpy(&cur_global, global, sizeof(struct usb_hid_global_state));
 476
 477     while (tvb_reported_length_remaining(tvb, offset) > 0)
 478     {
 479         old_offset=offset;
 480
 481         tmp = tvb_get_guint8(tvb, offset);
 482         bSize = tmp & USBHID_SIZE_MASK;
 483         if (bSize == 3) bSize++; /* 3 == four bytes */
 484         bType = (tmp & USBHID_TYPE_MASK) >> 2;
 485         bTag = (tmp & USBHID_TAG_MASK) >> 4;
 486
 487         switch (bType) {
 488             case USBHID_ITEMTYPE_MAIN:
 489                 hf_usb_hid_curitem_bTag = hf_usb_hid_mainitem_bTag;
 490                 usb_hid_cur_bTag_vals = usb_hid_mainitem_bTag_vals;
 491                 break;
 492             case USBHID_ITEMTYPE_GLOBAL:
 493                 hf_usb_hid_curitem_bTag = hf_usb_hid_globalitem_bTag;
 494                 usb_hid_cur_bTag_vals = usb_hid_globalitem_bTag_vals;
 495                 break;
 496             case USBHID_ITEMTYPE_LOCAL:
 497                 hf_usb_hid_curitem_bTag = hf_usb_hid_localitem_bTag;
 498                 usb_hid_cur_bTag_vals = usb_hid_localitem_bTag_vals;
 499                 break;
 500             default: /* Only USBHID_ITEMTYPE_LONG, but keep compiler happy */
 501                 hf_usb_hid_curitem_bTag = hf_usb_hid_longitem_bTag;
 502                 usb_hid_cur_bTag_vals = usb_hid_longitem_bTag_vals;
 503                 break;
 504         }
 505
 506         subtree = proto_tree_add_subtree_format(parent_tree, tvb, offset, bSize + 1,
 507             ett_usb_hid_item_header, NULL, "%s item (%s)",
 508             val_to_str(bType, usb_hid_item_bType_vals, "Unknown/%u"),
 509             val_to_str(bTag, usb_hid_cur_bTag_vals, "Unknown/%u tag")
 510         );
 511
 512         tree = proto_tree_add_subtree(subtree, tvb, offset, 1, ett_usb_hid_item_header, NULL, "Header");
 513         proto_tree_add_item(tree, hf_usb_hid_item_bSize, tvb, offset,   1, ENC_LITTLE_ENDIAN);
 514         proto_tree_add_item(tree, hf_usb_hid_item_bType, tvb, offset,   1, ENC_LITTLE_ENDIAN);
 515         proto_tree_add_item(tree, hf_usb_hid_curitem_bTag, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 516         offset++;
 517         if ((bType == 3) && (bTag == 16)) {
 518             /* Long item */
 519             bSize = tvb_get_guint8(tvb, offset);
 520             proto_tree_add_item(subtree, hf_usb_hid_item_bDataSize, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 521             offset++;
 522             proto_tree_add_item(subtree, hf_usb_hid_item_bLongItemTag, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 523             offset++;
 524             proto_tree_add_item(subtree, hf_usb_hid_item_unk_data, tvb, offset, bSize, ENC_NA);
 525             offset += bSize;
 526         } else {
 527             /* Short item */
 528             switch (bType) {
 529                 case USBHID_ITEMTYPE_MAIN:
 530                     offset = dissect_usb_hid_report_mainitem_data(pinfo, subtree, tvb, offset, bSize, bTag);
 531                     break;
 532                 case USBHID_ITEMTYPE_GLOBAL:
 533                     offset = dissect_usb_hid_report_globalitem_data(pinfo, subtree, tvb, offset, bSize, bTag, &cur_global);
 534                     break;
 535                 case USBHID_ITEMTYPE_LOCAL:
 536                     offset = dissect_usb_hid_report_localitem_data(pinfo, subtree, tvb, offset, bSize, bTag, &cur_global);
 537                     break;
 538                 default: /* Only USBHID_ITEMTYPE_LONG, but keep compiler happy */
 539                     proto_tree_add_item(subtree, hf_usb_hid_item_unk_data, tvb, offset, bSize, ENC_NA);
 540                     offset += bSize;
 541                     break;
 542             }
 543         }
 544
 545         if (bType == USBHID_ITEMTYPE_MAIN) {
 546             if (bTag == USBHID_MAINITEM_TAG_COLLECTION) {
 547                 /* Begin collection, nest following elements under us */
 548                 offset = dissect_usb_hid_report_item(pinfo, subtree, tvb, offset, usb_trans_info, usb_conv_info, &cur_global);
 549                 proto_item_set_len(subitem, offset-old_offset);
 550             } else if (bTag == USBHID_MAINITEM_TAG_ENDCOLLECTION) {
 551                 /* End collection, break out to parent tree item */
 552                 break;
 553             }
 554         }
 555     }
 556     return offset;
 557 }
 558
 559 /* Dissector for HID "GET DESCRIPTOR" subtype. */
 560 int
 561 dissect_usb_hid_get_report_descriptor(packet_info *pinfo _U_, proto_tree *parent_tree, tvbuff_t *tvb, int offset, usb_conv_info_t *usb_conv_info)
 562 {
 563     proto_item *item=NULL;
 564     proto_tree *tree=NULL;
 565     int old_offset=offset;
 566     struct usb_hid_global_state initial_global;
 567     usb_trans_info_t *usb_trans_info;
 568
 569     usb_trans_info = usb_conv_info->usb_trans_info;
 570
 571     memset(&initial_global, 0, sizeof(struct usb_hid_global_state));
 572
 573     if (parent_tree) {
 574         item = proto_tree_add_protocol_format(parent_tree, proto_usb_hid, tvb, offset,
 575                               -1, "HID Report");
 576         tree = proto_item_add_subtree(item, ett_usb_hid_report);
 577         offset = dissect_usb_hid_report_item(pinfo, tree, tvb, offset, usb_trans_info, usb_conv_info, &initial_global);
 578
 579         proto_item_set_len(item, offset-old_offset);
 580     }
 581
 582     return offset;
 583 }
 584
 585 /* Dissector for HID GET_REPORT request. See USBHID 1.11, Chapter 7.2.1 Get_Report Request */
 586 static void
 587 dissect_usb_hid_get_report(packet_info *pinfo _U_, proto_tree *tree, tvbuff_t *tvb, int offset, gboolean is_request, usb_trans_info_t *usb_trans_info _U_, usb_conv_info_t *usb_conv_info _U_)
 588 {
 589     proto_item *item = NULL;
 590     proto_tree *subtree = NULL;
 591
 592     if (is_request) {
 593         item = proto_tree_add_item(tree, hf_usb_hid_value, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 594         subtree = proto_item_add_subtree(item, ett_usb_hid_wValue);
 595
 596         /* Report Type in the high byte, Report ID in the low byte */
 597         proto_tree_add_item(subtree, hf_usb_hid_report_id, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 598         offset++;
 599         proto_tree_add_item(subtree, hf_usb_hid_report_type, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 600         offset++;
 601
 602         proto_tree_add_item(tree, hf_usb_hid_index, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 603         offset += 2;
 604
 605         proto_tree_add_item(tree, hf_usb_hid_length, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 606         /*offset += 2;*/
 607     } else {
 608     }
 609 }
 610
 611 /* Dissector for HID SET_REPORT request. See USBHID 1.11, Chapter 7.2.2 Set_Report Request */
 612 static void
 613 dissect_usb_hid_set_report(packet_info *pinfo _U_, proto_tree *tree, tvbuff_t *tvb, int offset, gboolean is_request, usb_trans_info_t *usb_trans_info _U_, usb_conv_info_t *usb_conv_info _U_)
 614 {
 615     proto_item *item = NULL;
 616     proto_tree *subtree = NULL;
 617
 618     if (is_request) {
 619         item = proto_tree_add_item(tree, hf_usb_hid_value, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 620         subtree = proto_item_add_subtree(item, ett_usb_hid_wValue);
 621
 622         proto_tree_add_item(subtree, hf_usb_hid_report_id, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 623         offset++;
 624         proto_tree_add_item(subtree, hf_usb_hid_report_type, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 625         offset++;
 626
 627         proto_tree_add_item(tree, hf_usb_hid_index, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 628         offset += 2;
 629
 630         proto_tree_add_item(tree, hf_usb_hid_length, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 631         /*offset += 2;*/
 632     } else {
 633     }
 634 }
 635
 636
 637 /* Dissector for HID GET_IDLE request. See USBHID 1.11, Chapter 7.2.3 Get_Idle Request */
 638 static void
 639 dissect_usb_hid_get_idle(packet_info *pinfo _U_, proto_tree *tree, tvbuff_t *tvb, int offset, gboolean is_request, usb_trans_info_t *usb_trans_info _U_, usb_conv_info_t *usb_conv_info _U_)
 640 {
 641     proto_item *item = NULL;
 642     proto_tree *subtree = NULL;
 643
 644     if (is_request) {
 645         item = proto_tree_add_item(tree, hf_usb_hid_value, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 646         subtree = proto_item_add_subtree(item, ett_usb_hid_wValue);
 647
 648         proto_tree_add_item(subtree, hf_usb_hid_report_id, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 649         offset++;
 650         proto_tree_add_item(subtree, hf_usb_hid_zero, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 651         offset++;
 652
 653         proto_tree_add_item(tree, hf_usb_hid_index, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 654         offset += 2;
 655
 656         proto_tree_add_item(tree, hf_usb_hid_length, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 657         /*offset += 2;*/
 658     } else {
 659     }
 660 }
 661
 662 /* Dissector for HID SET_IDLE request. See USBHID 1.11, Chapter 7.2.4 Set_Idle Request */
 663 static void
 664 dissect_usb_hid_set_idle(packet_info *pinfo _U_, proto_tree *tree, tvbuff_t *tvb, int offset, gboolean is_request, usb_trans_info_t *usb_trans_info _U_, usb_conv_info_t *usb_conv_info _U_)
 665 {
 666     proto_item *item = NULL;
 667     proto_tree *subtree = NULL;
 668
 669     if (is_request) {
 670         item = proto_tree_add_item(tree, hf_usb_hid_value, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 671         subtree = proto_item_add_subtree(item, ett_usb_hid_wValue);
 672
 673         /* Duration in the high byte, Report ID in the low byte */
 674         proto_tree_add_item(subtree, hf_usb_hid_report_id, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 675         offset++;
 676         proto_tree_add_item(subtree, hf_usb_hid_duration, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 677         offset++;
 678
 679         proto_tree_add_item(tree, hf_usb_hid_index, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 680         offset += 2;
 681
 682         proto_tree_add_item(tree, hf_usb_hid_length, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 683         /*offset += 2;*/
 684     } else {
 685     }
 686 }
 687
 688 /* Dissector for HID GET_PROTOCOL request. See USBHID 1.11, Chapter 7.2.5 Get_Protocol Request */
 689 static void
 690 dissect_usb_hid_get_protocol(packet_info *pinfo _U_, proto_tree *tree, tvbuff_t *tvb, int offset, gboolean is_request, usb_trans_info_t *usb_trans_info _U_, usb_conv_info_t *usb_conv_info _U_)
 691 {
 692     if (is_request) {
 693         proto_tree_add_item(tree, hf_usb_hid_value, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 694         offset += 2;
 695
 696         proto_tree_add_item(tree, hf_usb_hid_index, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 697         offset += 2;
 698
 699         proto_tree_add_item(tree, hf_usb_hid_length, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 700         /*offset += 2;*/
 701     } else {
 702     }
 703 }
 704
 705 /* Dissector for HID SET_PROTOCOL request. See USBHID 1.11, Chapter 7.2.6 Set_Protocol Request */
 706 static void
 707 dissect_usb_hid_set_protocol(packet_info *pinfo _U_, proto_tree *tree, tvbuff_t *tvb, int offset, gboolean is_request, usb_trans_info_t *usb_trans_info _U_, usb_conv_info_t *usb_conv_info _U_)
 708 {
 709     if (is_request) {
 710         proto_tree_add_item(tree, hf_usb_hid_value, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 711         offset += 2;
 712
 713         proto_tree_add_item(tree, hf_usb_hid_index, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 714         offset += 2;
 715
 716         proto_tree_add_item(tree, hf_usb_hid_length, tvb, offset, 2, ENC_LITTLE_ENDIAN);
 717         /*offset += 2;*/
 718     } else {
 719     }
 720 }
 721
 722
 723 typedef void (*usb_setup_dissector)(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int offset, gboolean is_request, usb_trans_info_t *usb_trans_info, usb_conv_info_t *usb_conv_info);
 724
 725 typedef struct _usb_setup_dissector_table_t {
 726     guint8 request;
 727     usb_setup_dissector dissector;
 728 } usb_setup_dissector_table_t;
 729
 730
 731 /* USBHID 1.11, Chapter 7.2 Class-Specific Requests */
 732 #define USB_HID_SETUP_GET_REPORT      0x01
 733 #define USB_HID_SETUP_GET_IDLE        0x02
 734 #define USB_HID_SETUP_GET_PROTOCOL    0x03
 735 /* 0x04..0x08: Reserved */
 736 #define USB_HID_SETUP_SET_REPORT      0x09
 737 #define USB_HID_SETUP_SET_IDLE        0x0A
 738 #define USB_HID_SETUP_SET_PROTOCOL    0x0B
 739
 740 static const usb_setup_dissector_table_t setup_dissectors[] = {
 741     { USB_HID_SETUP_GET_REPORT,   dissect_usb_hid_get_report },
 742     { USB_HID_SETUP_GET_IDLE,     dissect_usb_hid_get_idle },
 743     { USB_HID_SETUP_GET_PROTOCOL, dissect_usb_hid_get_protocol },
 744     { USB_HID_SETUP_SET_REPORT,   dissect_usb_hid_set_report },
 745     { USB_HID_SETUP_SET_IDLE,     dissect_usb_hid_set_idle },
 746     { USB_HID_SETUP_SET_PROTOCOL, dissect_usb_hid_set_protocol },
 747     { 0, NULL }
 748 };
 749
 750 static const value_string setup_request_names_vals[] = {
 751     { USB_HID_SETUP_GET_REPORT,   "GET_REPORT" },
 752     { USB_HID_SETUP_GET_IDLE,     "GET_IDLE" },
 753     { USB_HID_SETUP_GET_PROTOCOL, "GET_PROTOCOL" },
 754     { USB_HID_SETUP_SET_REPORT,   "SET_REPORT" },
 755     { USB_HID_SETUP_SET_IDLE,     "SET_IDLE" },
 756     { USB_HID_SETUP_SET_PROTOCOL, "SET_PROTOCOL" },
 757     { 0, NULL }
 758 };
 759
 760 static const value_string usb_hid_report_type_vals[] = {
 761     { 1, "Input" },
 762     { 2, "Output" },
 763     { 3, "Feature" },
 764     { 0, NULL }
 765 };
 766
 767 /* Dissector for HID class-specific control request as defined in
 768  * USBHID 1.11, Chapter 7.2.
 769  * Returns tvb_length(tvb) if a class specific dissector was found
 770  * and 0 otherwise.
 771  */
 772 static gint
 773 dissect_usb_hid_control(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
 774 {
 775     gboolean is_request;
 776     usb_conv_info_t *usb_conv_info;
 777     usb_trans_info_t *usb_trans_info;
 778     int offset = 0;
 779     usb_setup_dissector dissector;
 780     const usb_setup_dissector_table_t *tmp;
 781
 782     /* Reject the packet if data or usb_trans_info are NULL */
 783     if (data == NULL || ((usb_conv_info_t *)data)->usb_trans_info == NULL)
 784         return 0;
 785     usb_conv_info = (usb_conv_info_t *)data;
 786     usb_trans_info = usb_conv_info->usb_trans_info;
 787
 788     is_request = (pinfo->srcport==NO_ENDPOINT);
 789
 790     /* See if we can find a class specific dissector for this request */
 791     dissector = NULL;
 792
 793     /* Check valid values for bmRequestType. See Chapter 7.2 in USBHID 1.11 */
 794     if ((usb_trans_info->setup.requesttype & 0x7F) ==
 795         ((RQT_SETUP_TYPE_CLASS << 5) | RQT_SETUP_RECIPIENT_INTERFACE)) {
 796         for (tmp = setup_dissectors; tmp->dissector; tmp++) {
 797             if (tmp->request == usb_trans_info->setup.request) {
 798                 dissector = tmp->dissector;
 799                 break;
 800             }
 801         }
 802     }
 803     /* No, we could not find any class specific dissector for this request
 804      * return 0 and let USB try any of the standard requests.
 805      */
 806     if (!dissector) {
 807         return 0;
 808     }
 809
 810     col_set_str(pinfo->cinfo, COL_PROTOCOL, "USBHID");
 811
 812     col_add_fstr(pinfo->cinfo, COL_INFO, "%s %s",
 813     val_to_str(usb_trans_info->setup.request, setup_request_names_vals, "Unknown type %x"),
 814         is_request ? "Request" : "Response");
 815
 816     if (is_request) {
 817         proto_tree_add_item(tree, hf_usb_hid_request, tvb, offset, 1, ENC_LITTLE_ENDIAN);
 818         offset += 1;
 819     }
 820
 821     dissector(pinfo, tree, tvb, offset, is_request, usb_trans_info, usb_conv_info);
 822     return tvb_length(tvb);
 823 }
 824
 825 /* dissect a descriptor that is specific to the HID class */
 826 static gint
 827 dissect_usb_hid_class_descriptors(tvbuff_t *tvb, packet_info *pinfo _U_,
 828         proto_tree *tree, void *data _U_)
 829 {
 830     guint8      type;
 831     gint        offset = 0;
 832     proto_item *ti;
 833     proto_tree *desc_tree;
 834     guint8      num_desc;
 835     guint       i;
 836
 837     type = tvb_get_guint8(tvb, 1);
 838
 839     /* for now, we only handle the HID descriptor here */
 840     if (type != USB_DT_HID)
 841         return 0;
 842
 843     desc_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_usb_hid_descriptor, &ti, "HID DESCRIPTOR");
 844
 845     dissect_usb_descriptor_header(desc_tree, tvb, offset,
 846             &hid_descriptor_type_vals_ext);
 847     offset += 2;
 848     proto_tree_add_item(desc_tree, hf_usb_hid_bcdHID,
 849             tvb, offset, 2, ENC_LITTLE_ENDIAN);
 850     offset += 2;
 851     proto_tree_add_item(desc_tree, hf_usb_hid_bCountryCode,
 852             tvb, offset, 1, ENC_LITTLE_ENDIAN);
 853     offset++;
 854     num_desc = tvb_get_guint8(tvb, offset);
 855     proto_tree_add_item(desc_tree, hf_usb_hid_bNumDescriptors,
 856             tvb, offset, 1, ENC_LITTLE_ENDIAN);
 857     offset++;
 858     for (i=0;i<num_desc;i++) {
 859         proto_tree_add_item(desc_tree, hf_usb_hid_bDescriptorType,
 860                 tvb, offset, 1, ENC_LITTLE_ENDIAN);
 861         offset++;
 862         proto_tree_add_item(desc_tree, hf_usb_hid_wDescriptorLength,
 863                 tvb, offset, 2, ENC_LITTLE_ENDIAN);
 864         offset += 2;
 865     }
 866
 867     proto_item_set_len(ti, offset);
 868     return offset;
 869 }
 870
 871
 872 void
 873 proto_register_usb_hid(void)
 874 {
 875     static hf_register_info hf[] = {
 876         { &hf_usb_hid_item_bSize,
 877             { "bSize", "usbhid.item.bSize", FT_UINT8, BASE_DEC,
 878                 VALS(usb_hid_item_bSize_vals), USBHID_SIZE_MASK, NULL, HFILL }},
 879
 880         { &hf_usb_hid_item_bType,
 881             { "bType", "usbhid.item.bType", FT_UINT8, BASE_DEC,
 882                 VALS(usb_hid_item_bType_vals), USBHID_TYPE_MASK, NULL, HFILL }},
 883
 884         { &hf_usb_hid_mainitem_bTag,
 885             { "bTag", "usbhid.item.bTag", FT_UINT8, BASE_HEX,
 886                 VALS(usb_hid_mainitem_bTag_vals), USBHID_TAG_MASK, NULL, HFILL }},
 887
 888         { &hf_usb_hid_globalitem_bTag,
 889             { "bTag", "usbhid.item.bTag", FT_UINT8, BASE_HEX,
 890                 VALS(usb_hid_globalitem_bTag_vals), USBHID_TAG_MASK, NULL, HFILL }},
 891
 892         { &hf_usb_hid_localitem_bTag,
 893             { "bTag", "usbhid.item.bTag", FT_UINT8, BASE_HEX,
 894                 VALS(usb_hid_localitem_bTag_vals), USBHID_TAG_MASK, NULL, HFILL }},
 895
 896         { &hf_usb_hid_longitem_bTag,
 897             { "bTag", "usbhid.item.bTag", FT_UINT8, BASE_HEX,
 898                 VALS(usb_hid_longitem_bTag_vals), USBHID_TAG_MASK, NULL, HFILL }},
 899
 900         { &hf_usb_hid_item_bDataSize,
 901             { "bDataSize", "usbhid.item.bDataSize", FT_UINT8, BASE_DEC,
 902                 NULL, 0, NULL, HFILL }},
 903
 904         { &hf_usb_hid_item_bLongItemTag,
 905             { "bTag", "usbhid.item.bLongItemTag", FT_UINT8, BASE_HEX,
 906                 NULL, 0, NULL, HFILL }},
 907
 908         /* Main-report item data */
 909
 910         { &hf_usb_hid_mainitem_bit0,
 911             { "Data/constant", "usbhid.item.main.readonly", FT_BOOLEAN, 9,
 912                 TFS(&tfs_mainitem_bit0), 1<<0, NULL, HFILL }},
 913
 914         { &hf_usb_hid_mainitem_bit1,
 915             { "Data type", "usbhid.item.main.variable", FT_BOOLEAN, 9,
 916                 TFS(&tfs_mainitem_bit1), 1<<1, NULL, HFILL }},
 917
 918         { &hf_usb_hid_mainitem_bit2,
 919             { "Coordinates", "usbhid.item.main.relative", FT_BOOLEAN, 9,
 920                 TFS(&tfs_mainitem_bit2), 1<<2, NULL, HFILL }},
 921
 922         { &hf_usb_hid_mainitem_bit3,
 923             { "Min/max wraparound", "usbhid.item.main.wrap", FT_BOOLEAN, 9,
 924                 TFS(&tfs_mainitem_bit3), 1<<3, NULL, HFILL }},
 925
 926         { &hf_usb_hid_mainitem_bit4,
 927             { "Physical relationship to data", "usbhid.item.main.nonlinear", FT_BOOLEAN, 9,
 928                 TFS(&tfs_mainitem_bit4), 1<<4, NULL, HFILL }},
 929
 930         { &hf_usb_hid_mainitem_bit5,
 931             { "Preferred state", "usbhid.item.main.no_preferred_state", FT_BOOLEAN, 9,
 932                 TFS(&tfs_mainitem_bit5), 1<<5, NULL, HFILL }},
 933
 934         { &hf_usb_hid_mainitem_bit6,
 935             { "Has null position", "usbhid.item.main.nullstate", FT_BOOLEAN, 9,
 936                 TFS(&tfs_mainitem_bit6), 1<<6, NULL, HFILL }},
 937
 938         { &hf_usb_hid_mainitem_bit7,
 939             { "(Non)-volatile", "usbhid.item.main.volatile", FT_BOOLEAN, 9,
 940                 TFS(&tfs_mainitem_bit7), 1<<7, NULL, HFILL }},
 941
 942         { &hf_usb_hid_mainitem_bit7_input,
 943             { "[Reserved]", "usbhid.item.main.volatile", FT_BOOLEAN, 9,
 944                 NULL, 1<<7, NULL, HFILL }},
 945
 946         { &hf_usb_hid_mainitem_bit8,
 947             { "Bits or bytes", "usbhid.item.main.buffered_bytes", FT_BOOLEAN, 9,
 948                 TFS(&tfs_mainitem_bit8), 1<<8, NULL, HFILL }},
 949
 950         { &hf_usb_hid_mainitem_colltype,
 951             { "Collection type", "usbhid.item.main.colltype", FT_UINT8, BASE_RANGE_STRING|BASE_HEX,
 952                 RVALS(usb_hid_mainitem_colltype_vals), 0, NULL, HFILL }},
 953
 954         /* Global-report item data */
 955
 956         { &hf_usb_hid_globalitem_usage,
 957             { "Usage page", "usbhid.item.global.usage", FT_UINT8, BASE_RANGE_STRING|BASE_HEX,
 958                 RVALS(usb_hid_item_usage_vals), 0, NULL, HFILL }},
 959
 960         { &hf_usb_hid_globalitem_log_min,
 961             { "Logical minimum", "usbhid.item.global.log_min", FT_UINT8, BASE_DEC,
 962                 NULL, 0, NULL, HFILL }},
 963
 964         { &hf_usb_hid_globalitem_log_max,
 965             { "Logical maximum", "usbhid.item.global.log_max", FT_UINT8, BASE_DEC,
 966                 NULL, 0, NULL, HFILL }},
 967
 968         { &hf_usb_hid_globalitem_phy_min,
 969             { "Physical minimum", "usbhid.item.global.phy_min", FT_UINT8, BASE_DEC,
 970                 NULL, 0, NULL, HFILL }},
 971
 972         { &hf_usb_hid_globalitem_phy_max,
 973             { "Physical maximum", "usbhid.item.global.phy_max", FT_UINT8, BASE_DEC,
 974                 NULL, 0, NULL, HFILL }},
 975
 976         { &hf_usb_hid_globalitem_unit_exp,
 977             { "Unit exponent", "usbhid.item.global.unit_exp", FT_UINT8, BASE_DEC,
 978                 NULL, 0, NULL, HFILL }},
 979
 980         { &hf_usb_hid_globalitem_unit_sys,
 981             { "System", "usbhid.item.global.unit.system", FT_UINT32, BASE_HEX,
 982                 VALS(usb_hid_globalitem_unit_exp_vals), 0x0000000F, NULL, HFILL }},
 983
 984         { &hf_usb_hid_globalitem_unit_len,
 985             { "Length", "usbhid.item.global.unit.length", FT_UINT32, BASE_HEX,
 986                 VALS(usb_hid_globalitem_unit_exp_vals), 0x000000F0, NULL, HFILL }},
 987
 988         { &hf_usb_hid_globalitem_unit_mass,
 989             { "Mass", "usbhid.item.global.unit.mass", FT_UINT32, BASE_HEX,
 990                 VALS(usb_hid_globalitem_unit_exp_vals), 0x00000F00, NULL, HFILL }},
 991
 992         { &hf_usb_hid_globalitem_unit_time,
 993             { "Time", "usbhid.item.global.unit.time", FT_UINT32, BASE_HEX,
 994                 VALS(usb_hid_globalitem_unit_exp_vals), 0x0000F000, NULL, HFILL }},
 995
 996         { &hf_usb_hid_globalitem_unit_temp,
 997             { "Temperature", "usbhid.item.global.unit.temperature", FT_UINT32, BASE_HEX,
 998                 VALS(usb_hid_globalitem_unit_exp_vals), 0x000F0000, NULL, HFILL }},
 999
1000         { &hf_usb_hid_globalitem_unit_current,
1001             { "Current", "usbhid.item.global.unit.current", FT_UINT32, BASE_HEX,
1002                 VALS(usb_hid_globalitem_unit_exp_vals), 0x00F00000, NULL, HFILL }},
1003
1004         { &hf_usb_hid_globalitem_unit_brightness,
1005             { "Luminous intensity", "usbhid.item.global.unit.brightness", FT_UINT32, BASE_HEX,
1006                 VALS(usb_hid_globalitem_unit_exp_vals), 0x0F000000, NULL, HFILL }},
1007
1008         { &hf_usb_hid_globalitem_report_size,
1009             { "Report size", "usbhid.item.global.report_size", FT_UINT8, BASE_DEC,
1010                 NULL, 0, NULL, HFILL }},
1011
1012         { &hf_usb_hid_globalitem_report_id,
1013             { "Report ID", "usbhid.item.global.report_id", FT_UINT8, BASE_HEX,
1014                 NULL, 0, NULL, HFILL }},
1015
1016         { &hf_usb_hid_globalitem_report_count,
1017             { "Report count", "usbhid.item.global.report_count", FT_UINT8, BASE_DEC,
1018                 NULL, 0, NULL, HFILL }},
1019
1020         { &hf_usb_hid_globalitem_push,
1021             { "Push", "usbhid.item.global.push", FT_UINT8, BASE_HEX,
1022                 NULL, 0, NULL, HFILL }},
1023
1024         { &hf_usb_hid_globalitem_pop,
1025             { "Pop", "usbhid.item.global.pop", FT_UINT8, BASE_HEX,
1026                 NULL, 0, NULL, HFILL }},
1027
1028         /* Local-report item data */
1029
1030         { &hf_usb_hid_localitem_usage,
1031             { "Usage", "usbhid.item.local.usage", FT_UINT8, BASE_RANGE_STRING|BASE_HEX,
1032                 RVALS(usb_hid_item_usage_vals), 0, NULL, HFILL }},
1033
1034         { &hf_usb_hid_localitem_usage_min,
1035             { "Usage minimum", "usbhid.item.local.usage_min", FT_UINT8, BASE_HEX,
1036                 NULL, 0, NULL, HFILL }},
1037
1038 #if 0
1039         { &hf_usb_hid_localitem_usage_max,
1040             { "Usage maximum", "usbhid.item.local.usage_max", FT_UINT8, BASE_HEX,
1041                 NULL, 0, NULL, HFILL }},
1042 #endif
1043
1044         { &hf_usb_hid_localitem_desig_index,
1045             { "Designator index", "usbhid.item.local.desig_index", FT_UINT8, BASE_HEX,
1046                 NULL, 0, NULL, HFILL }},
1047
1048         { &hf_usb_hid_localitem_desig_min,
1049             { "Designator minimum", "usbhid.item.local.desig_min", FT_UINT8, BASE_HEX,
1050                 NULL, 0, NULL, HFILL }},
1051
1052         { &hf_usb_hid_localitem_desig_max,
1053             { "Designator maximum", "usbhid.item.local.desig_max", FT_UINT8, BASE_HEX,
1054                 NULL, 0, NULL, HFILL }},
1055
1056         { &hf_usb_hid_localitem_string_index,
1057             { "String index", "usbhid.item.local.string_index", FT_UINT8, BASE_HEX,
1058                 NULL, 0, NULL, HFILL }},
1059
1060         { &hf_usb_hid_localitem_string_min,
1061             { "String minimum", "usbhid.item.local.string_min", FT_UINT8, BASE_HEX,
1062                 NULL, 0, NULL, HFILL }},
1063
1064         { &hf_usb_hid_localitem_string_max,
1065             { "String maximum", "usbhid.item.local.string_max", FT_UINT8, BASE_HEX,
1066                 NULL, 0, NULL, HFILL }},
1067
1068         { &hf_usb_hid_localitem_delimiter,
1069             { "Delimiter", "usbhid.item.local.delimiter", FT_UINT8, BASE_HEX,
1070                 NULL, 0, NULL, HFILL }},
1071
1072
1073         { &hf_usb_hid_item_unk_data,
1074             { "Item data", "usbhid.item.data", FT_BYTES, BASE_NONE,
1075                 NULL, 0, NULL, HFILL }},
1076
1077         /* USB HID specific requests */
1078         { &hf_usb_hid_request,
1079         { "bRequest", "usbhid.setup.bRequest", FT_UINT8, BASE_HEX, VALS(setup_request_names_vals), 0x0,
1080           NULL, HFILL }},
1081
1082         { &hf_usb_hid_value,
1083         { "wValue", "usbhid.setup.wValue", FT_UINT16, BASE_HEX, NULL, 0x0,
1084           NULL, HFILL }},
1085
1086         { &hf_usb_hid_index,
1087         { "wIndex", "usbhid.setup.wIndex", FT_UINT16, BASE_DEC, NULL, 0x0,
1088           NULL, HFILL }},
1089
1090         { &hf_usb_hid_length,
1091         { "wLength", "usbhid.setup.wLength", FT_UINT16, BASE_DEC, NULL, 0x0,
1092           NULL, HFILL }},
1093
1094         { &hf_usb_hid_report_type,
1095         { "ReportType", "usbhid.setup.ReportType", FT_UINT8, BASE_DEC,
1096           VALS(usb_hid_report_type_vals), 0x0,
1097           NULL, HFILL }},
1098
1099         { &hf_usb_hid_report_id,
1100         { "ReportID", "usbhid.setup.ReportID", FT_UINT8, BASE_DEC, NULL, 0x0,
1101           NULL, HFILL }},
1102
1103         { &hf_usb_hid_duration,
1104         { "Duration", "usbhid.setup.Duration", FT_UINT8, BASE_DEC, NULL, 0x0,
1105           NULL, HFILL }},
1106
1107         { &hf_usb_hid_zero,
1108         { "(zero)", "usbhid.setup.zero", FT_UINT8, BASE_DEC, NULL, 0x0,
1109           NULL, HFILL }},
1110
1111         /* components of the HID descriptor */
1112         { &hf_usb_hid_bcdHID,
1113         { "bcdHID", "usbhid.descriptor.hid.bcdHID", FT_UINT16, BASE_HEX, NULL, 0x0,
1114           NULL, HFILL }},
1115
1116         { &hf_usb_hid_bCountryCode,
1117         { "bCountryCode", "usbhid.descriptor.hid.bCountryCode", FT_UINT8,
1118             BASE_HEX, NULL, 0x0, NULL, HFILL }},
1119
1120         { &hf_usb_hid_bNumDescriptors,
1121         { "bNumDescriptors", "usbhid.descriptor.hid.bNumDescriptors", FT_UINT8,
1122             BASE_DEC, NULL, 0x0, NULL, HFILL }},
1123
1124         { &hf_usb_hid_bDescriptorType,
1125         { "bDescriptorType", "usbhid.descriptor.hid.bDescriptorType", FT_UINT8,
1126             BASE_HEX, NULL, 0x0, NULL, HFILL }},
1127
1128         { &hf_usb_hid_wDescriptorLength,
1129         { "wDescriptorLength", "usbhid.descriptor.hid.wDescriptorLength", FT_UINT16,
1130             BASE_DEC, NULL, 0x0, NULL, HFILL }}
1131     };
1132
1133     static gint *usb_hid_subtrees[] = {
1134         &ett_usb_hid_report,
1135         &ett_usb_hid_item_header,
1136         &ett_usb_hid_wValue,
1137         &ett_usb_hid_descriptor
1138     };
1139
1140     proto_usb_hid = proto_register_protocol("USB HID", "USBHID", "usbhid");
1141     proto_register_field_array(proto_usb_hid, hf, array_length(hf));
1142     proto_register_subtree_array(usb_hid_subtrees, array_length(usb_hid_subtrees));
1143 }
1144
1145 void
1146 proto_reg_handoff_usb_hid(void)
1147 {
1148     dissector_handle_t usb_hid_control_handle, usb_hid_descr_handle;
1149
1150     usb_hid_control_handle = new_create_dissector_handle(dissect_usb_hid_control, proto_usb_hid);
1151     dissector_add_uint("usb.control", IF_CLASS_HID, usb_hid_control_handle);
1152
1153     usb_hid_descr_handle = new_create_dissector_handle(
1154                         dissect_usb_hid_class_descriptors, proto_usb_hid);
1155     dissector_add_uint("usb.descriptor", IF_CLASS_HID, usb_hid_descr_handle);
1156 }
1157
1158 /*
1159  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
1160  *
1161  * Local variables:
1162  * c-basic-offset: 4
1163  * tab-width: 8
1164  * indent-tabs-mode: nil
1165  * End:
1166  *
1167  * vi: set shiftwidth=4 tabstop=8 expandtab:
1168  * :indentSize=4:tabSize=8:noTabs=true:
1169  */