Example #1
0
    { DRDA_CP_RDB,          "Relational Database" },
    { DRDA_CP_FRCFIXROW,    "Force Fixed Row Query Protocol" },
    { DRDA_CP_SQLDARD,      "SQLDA Reply Data" },
    { DRDA_CP_SQLDTA,       "SQL Program Variable Data" },
    { DRDA_CP_SQLDTARD,     "SQL Data Reply Data" },
    { DRDA_CP_SQLSTT,       "SQL Statement" },
    { DRDA_CP_OUTOVR,       "Output Override Descriptor" },
    { DRDA_CP_LMTBLKPRC,    "Limited Block Protocol" },
    { DRDA_CP_FIXROWPRC,    "Fixed Row Query Protocol" },
    { DRDA_CP_SQLSTTVRB,    "SQL Statement Variable Descriptions" },
    { DRDA_CP_QRYDSC,       "Query Answer Set Description" },
    { DRDA_CP_QRYDTA,       "Query Answer Set Data" },
    { DRDA_CP_SQLATTR,      "SQL Statement Attributes" },
    { 0,          NULL }
};
static value_string_ext drda_opcode_vals_ext = VALUE_STRING_EXT_INIT(drda_opcode_vals);

static const value_string drda_opcode_abbr[] = {
    { DRDA_CP_DATA,         "DATA" },
    { DRDA_CP_CODPNT,       "CODPNT" },
    { DRDA_CP_FDODSC,       "FDODSC" },
    { DRDA_CP_TYPDEFNAM,    "TYPDEFNAM" },
    { DRDA_CP_TYPDEFOVR,    "TYPDEFOVR" },
    { DRDA_CP_CODPNTDR,     "CODPNTDR" },
    { DRDA_CP_EXCSAT,       "EXCSAT" },
    { DRDA_CP_SYNCCTL,      "SYNCCTL" },
    { DRDA_CP_SYNCRSY,      "SYNCRSY" },
    { DRDA_CP_ACCSEC,       "ACCSEC" },
    { DRDA_CP_SECCHK,       "SECCHK" },
    { DRDA_CP_SYNCLOG,      "SYNCLOG" },
    { DRDA_CP_RSCTYP,       "RSCTYP" },
Example #2
0
    {3,            "AMR 6,70 kbit/s (PDC-EFR)"},
    {4,            "AMR 7,40 kbit/s (TDMA-EFR)"},
    {5,            "AMR 7,95 kbit/s"},
    {6,            "AMR 10,2 kbit/s"},
    {7,            "AMR 12,2 kbit/s (GSM-EFR)"},
    {AMR_NB_SID,   "AMR SID (Comfort Noise Frame)"},
    {9,            "GSM-EFR SID"},
    {10,           "TDMA-EFR SID "},
    {11,           "PDC-EFR SID"},
    {12,           "Illegal Frametype - for future use"},
    {13,           "Illegal Frametype - for future use"},
    {14,           "Illegal Frametype - for future use"},
    {AMR_NO_TRANS, "No Data (No transmission/No reception)"},
    { 0,    NULL }
};
static value_string_ext amr_nb_codec_mode_vals_ext = VALUE_STRING_EXT_INIT(amr_nb_codec_mode_vals);

static const value_string amr_wb_codec_mode_vals[] = {
    {0,            "AMR-WB 6.60 kbit/s"},
    {1,            "AMR-WB 8.85 kbit/s"},
    {2,            "AMR-WB 12.65 kbit/s"},
    {3,            "AMR-WB 14.25 kbit/s"},
    {4,            "AMR-WB 15.85 kbit/s"},
    {5,            "AMR-WB 18.25 kbit/s"},
    {6,            "AMR-WB 19.85 kbit/s"},
    {7,            "AMR-WB 23.05 kbit/s"},
    {8,            "AMR-WB 23.85 kbit/s"},
    {AMR_WB_SID,   "AMR-WB SID (Comfort Noise Frame)"},
    {10,           "Illegal Frametype"},
    {11,           "Illegal Frametype"},
    {12,           "Illegal Frametype"},
Example #3
0
	{ RTP_COTSEND,			       "Continuity test send"},
	{ RTP_COTVERFD,			       "Continuity verified"},
	{ RTP_LOOPBACK,			       "Loopback"},
	{ RTP_MWATTTONE,		       "Old milliwatt tone (1000 Hz)"},
	{ RTP_NEWMWATTTN,		       "New milliwatt tone (1004 Hz)"},
	{ RTP_CISCO_NSE_FAX_PASSTHROUGH_IND,   "Cisco NSE: Shift to voiceband data mode"},
	{ RTP_CISCO_NSE_MODEM_PASSTHROUGH_IND, "Cisco NSE: Disable echo cancellation"},
	{ RTP_CISCO_NSE_VOICE_MODE_IND,        "Cisco NSE: Shift to voice mode"},
	{ RTP_CISCO_NSE_MODEM_RELAY_CAP_IND,   "Cisco NSE: Advertise Modem relay capability"},
	{ RTP_CISCO_NSE_FAX_RELAY_IND,         "Cisco NSE: Shift to fax relay mode"},
	{ RTP_CISCO_NSE_ACK,                   "Positive acknowledgement of Cisco NSE"},
	{ RTP_CISCO_NSE_NACK,                  "Negative acknowledgement of Cisco NSE"},
	{ RTP_CISCO_NSE_MODEM_RELAY_IND ,      "Cisco NSE: Shift to modem relay mode"},
	{ 0,               NULL },
};
value_string_ext rtp_event_type_values_ext = VALUE_STRING_EXT_INIT(rtp_event_type_values);

/* RTP Events fields defining a subtree */

static gint ett_rtp_events           = -1;

static struct _rtp_event_info rtp_event_info;

static int
dissect_rtp_events( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_ )
{
	proto_item   *ti;
	proto_tree   *rtp_events_tree;
	unsigned int  offset = 0;

	struct _rtp_conversation_info *p_conv_data;
Example #4
0
    { 2095, "IBM01144" },
    { 2096, "IBM01145" },
    { 2097, "IBM01146" },
    { 2098, "IBM01147" },
    { 2099, "IBM01148" },
    { 2100, "IBM01149" },
    { 2101, "Big5-HKSCS" },
    { 2102, "IBM1047" },
    { 2103, "PTCP154" },
    { 2104, "Amiga-1251" },
    { 2105, "KOI7-switched" },
    { 2106, "BRF" },
    { 2107, "TSCII" },
    { 2108, "CP51932" },
    { 2109, "windows-874" },

    { 2250, "windows-1250" },
    { 2251, "windows-1251" },
    { 2252, "windows-1252" },
    { 2253, "windows-1253" },
    { 2254, "windows-1254" },
    { 2255, "windows-1255" },
    { 2256, "windows-1256" },
    { 2257, "windows-1257" },
    { 2258, "windows-1258" },
    { 2259, "TIS-620" },
    { 2260, "CP50220" },
    { 0, NULL }
};
value_string_ext wap_mib_enum_vals_character_sets_ext = VALUE_STRING_EXT_INIT(wap_mib_enum_vals_character_sets);
Example #5
0
static gint ett_dsi_open        = -1;
static gint ett_dsi_attn        = -1;
static gint ett_dsi_attn_flag   = -1;

static const value_string dsi_attn_flag_vals[] = {
	{0x0, "Reserved" },                                           /* 0000 */
	{0x1, "Reserved" },                                           /* 0001 */
	{0x2, "Server message" },                                     /* 0010 */
	{0x3, "Server notification, cf. extended bitmap" },           /* 0011 */
	{0x4, "Server is shutting down, internal error" },            /* 0100 */
	{0x8, "Server is shutting down" },                            /* 1000 */
	{0x9, "Server disconnects user" },                            /* 1001 */
	{0x10,"Server is shutting down, message" },                   /* 1010 */
	{0x11,"Server is shutting down, message,no reconnect"},       /* 1011 */
	{0,                   NULL } };
static value_string_ext dsi_attn_flag_vals_ext = VALUE_STRING_EXT_INIT(dsi_attn_flag_vals);

static const value_string dsi_open_type_vals[] = {
	{0,   "Server quantum" },
	{1,   "Attention quantum" },
	{2,   "Replay cache size" },
	{0,                   NULL } };

/* status stuff same for asp and afp */
static int hf_dsi_server_name = -1;
static int hf_dsi_utf8_server_name_len = -1;
static int hf_dsi_utf8_server_name = -1;
static int hf_dsi_server_type = -1;
static int hf_dsi_server_vers = -1;
static int hf_dsi_server_uams = -1;
static int hf_dsi_server_icon = -1;
Example #6
0
    {IMAGE_DATA_RES         , "IMAGE_DATA_RES"},
    {RESET_REQ              , "RESET_REQ"},
    {RESET_RES              , "RESET_RES"},
    {I_AM_UP_REQ            , "I_AM_UP_REQ"},
    {I_AM_UP_RES            , "I_AM_UP_RES"},
    {KEY_UPDATE_REQ         , "KEY_UPDATE_REQ"},
    {KEY_UPDATE_RES         , "KEY_UPDATE_RES"},
    {PRIMARY_DISCOVERY_REQ  , "PRIMARY_DISCOVERY_REQ"},
    {PRIMARY_DISCOVERY_RES  , "PRIMARY_DISCOVERY_RES"},
    {DATA_TRANSFER          , "DATA_TRANSFER"},
    {DATA_TRANSFER_RES      , "DATA_TRANSFER_RES"},
    {RESET_REQ_CLEAR_CONFIG , "RESET_REQ_CLEAR_CONFIG"},

    { 0, NULL}
};
static value_string_ext control_msg_vals_ext = VALUE_STRING_EXT_INIT(control_msg_vals);

#if 0
static const value_string control_tag_vals[] = {

    {RESULT_CODE                     , "RESULT_CODE"},
    {MWAR_ADDR_PAYLOAD               , "MWAR_ADDR_PAYLOAD"},
    {RAD_PAYLOAD                     , "RAD_PAYLOAD"},
    {RAD_SLOT_PAYLOAD                , "RAD_SLOT_PAYLOAD"},
    {RAD_NAME_PAYLOAD                , "RAD_NAME_PAYLOAD"},
    {MWAR_PAYLOAD                    , "MWAR_PAYLOAD"},
    {VAP_PAYLOAD                     , "VAP_PAYLOAD"},
    {STATION_CFG_PAYLOAD             , "STATION_CFG_PAYLOAD"},
    {OPERATION_RATE_SET_PAYLOAD      , "OPERATION_RATE_SET_PAYLOAD"},
    {MULTI_DOMAIN_CAPABILITY_PAYLOAD , "MULTI_DOMAIN_CAPABILITY_PAYLOAD"},
    {MAC_OPERATION_PAYLOAD           , "MAC_OPERATION_PAYLOAD"},
Example #7
0
    { 0xE0, "Pitch Bender" },
    { 0xF0, "System Exclusive Begin" },
    { 0xF1, "MTC Quarter Frame" },
    { 0xF2, "Song Position" },
    { 0xF3, "Song Select" },
    { 0xF6, "Tune Request" },
    { 0xF8, "Clock" },
    { 0xFA, "Start" },
    { 0xFB, "Continue" },
    { 0xFC, "Stop" },
    { 0xFE, "Active Sensing" },
    { 0xFF, "Reset" },

    {0, NULL }
};
static value_string_ext MIDI_status_ext = VALUE_STRING_EXT_INIT(MIDI_status);

/* Standard MIDI Controller Numbers */
static const value_string MIDI_control [] = {
    { 0x00, "Bank Selection" },
    { 0x01, "Modulation" },
    { 0x02, "Breath" },
    { 0x04, "Foot" },
    { 0x05, "Portamento Time" },
    { 0x06, "Data Entry" },
    { 0x07, "Main Volume" },
    { 0x08, "Balance" },
    { 0x0A, "Panpot" },
    { 0x0B, "Expression" },
    { 0x0C, "Effect1" },
    { 0x0D, "Effect2" },
	{  DE_BLAP_LAC,	"Location Area Code" },
	{  DE_BLAP_FREQ_LIST,	"Frequency List" },
	{  DE_BLAP_MS_POW,	"MS Power" },
	{  DE_BLAP_DELTA_TIME,	"Delta Timer" },
	{  DE_BLAP_SERV_CELL_ID,	"Serving Cell Identifier" },
	{  DE_BLAP_ENC_KEY,	"Encryption Key (Kc)" },
	{  DE_BLAP_CIP_M_SET,	"Cipher Mode Setting" },
	{  DE_BLAP_CH_MODE,	"Channel Mode" },
	{  DE_BLAP_POLL_REP,	"Polling Repetition" },
	{  DE_BLAP_PKT_CH_DESC,	"Packet Channel Description" },
	{  DE_BLAP_TLLI,	"TLLI" },
	{  DE_BLAP_TFI,	"TFI" },
	{  DE_BLAP_START_TIME,	"Starting Time" },
	{ 0,		NULL },
};
value_string_ext gsm_bsslap_elem_strings_ext = VALUE_STRING_EXT_INIT(gsm_bsslap_elem_strings);

/*
 *	NOTE: These values of the codepoints shall not be used as they were used in an earlier version of the
 *	protocol.
 *	All unassigned codes are spare.
 */


#define BSSLAP_TA_REQUEST	1
#define BSSLAP_TA_RESPONSE	2
#define BSSLAP_REJECT		10
#define BSSLAP_RESET		11
#define BSSLAP_ABORT		12
#define BSSLAP_TA_LAYER3	13
#define BSSLAP_MS_POS_CMD	15
Example #9
0
    { 0xDC,   "Keypad Decimal" },
    { 0xDD,   "Keypad Hexadecimal" },
    /* 0xDE..0xDF - reserved,  */
    { 0xE0,   "LeftControl" },
    { 0xE1,   "LeftShift" },
    { 0xE2,   "LeftAlt" },
    { 0xE3,   "LeftGUI" },
    { 0xE4,   "RightControl" },
    { 0xE5,   "RightShift" },
    { 0xE6,   "RightAlt" },
    { 0xE7,   "RightGUI" },

    { 0, NULL }
};

value_string_ext keycode_vals_ext = VALUE_STRING_EXT_INIT(keycode_vals);

void proto_register_bthid(void);
void proto_reg_handoff_bthid(void);

static gint
dissect_hid_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
        gint offset, guint report_type)
{
    gboolean     shortcut_helper = FALSE;
    unsigned int protocol_code;
    unsigned int modifier;
    unsigned int keycode;
    unsigned int leds;
    unsigned int buttons;
Example #10
0
    guint32  command_frame_number;
    gint32   block_number;
} command_data_t;


static const value_string command_vals[] = {
    { 0x00,  "Detach" },
    { 0x01,  "Download" },
    { 0x02,  "Upload" },
    { 0x03,  "Get Status" },
    { 0x04,  "Clear Status" },
    { 0x05,  "Get State" },
    { 0x06,  "Abort" },
    { 0x00, NULL }
};
static value_string_ext(command_vals_ext) = VALUE_STRING_EXT_INIT(command_vals);

static const value_string state_vals[] = {
    {  0,  "appIdle" },
    {  1,  "appDetach" },
    {  2,  "dfuIdle" },
    {  3,  "dfuDownloadSync" },
    {  4,  "dfuDownloadBusy" },
    {  5,  "dfuDownloadIdle" },
    {  6,  "dfuManifestSync" },
    {  7,  "dfuManifest" },
    {  8,  "dfuManifestWaitReset" },
    {  9,  "dfuUploadIdle" },
    { 10,  "dfuError" },
    { 0x00, NULL }
};
Example #11
0
  { 20, "Spatial streams: 3, Modulation type: 16-QAM, Codingrate: 3/4" },
  { 21, "Spatial streams: 3, Modulation type: 64-QAM, Codingrate: 2/3" },
  { 22, "Spatial streams: 3, Modulation type: 64-QAM, Codingrate: 3/4" },
  { 23, "Spatial streams: 3, Modulation type: 64-QAM, Codingrate: 5/6" },
  { 24, "Spatial streams: 4, Modulation type: BPSK, Codingrate: 1/2" },
  { 25, "Spatial streams: 4, Modulation type: QPSK, Codingrate: 1/2" },
  { 26, "Spatial streams: 4, Modulation type: QPSK, Codingrate: 3/4" },
  { 27, "Spatial streams: 4, Modulation type: 16-QAM, Codingrate: 1/2" },
  { 28, "Spatial streams: 4, Modulation type: 16-QAM, Codingrate: 3/4" },
  { 29, "Spatial streams: 4, Modulation type: 64-QAM, Codingrate: 2/3" },
  { 30, "Spatial streams: 4, Modulation type: 64-QAM, Codingrate: 3/4" },
  { 31, "Spatial streams: 4, Modulation type: 64-QAM, Codingrate: 5/6" },
  { 0, NULL }
};

static value_string_ext peekremote_mcs_index_vals_ext = VALUE_STRING_EXT_INIT(peekremote_mcs_index_vals);

static const value_string peekremote_mcs_index_vals_ac[] = {
  { 0, "Modulation type: BPSK, Codingrate: 1/2" },
  { 1, "Modulation type: QPSK, Codingrate: 1/2" },
  { 2, "Modulation type: QPSK, Codingrate: 3/4" },
  { 3, "Modulation type: 16-QAM, Codingrate: 1/2" },
  { 4, "Modulation type: 16-QAM, Codingrate: 3/4" },
  { 5, "Modulation type: 64-QAM, Codingrate: 2/3" },
  { 6, "Modulation type: 64-QAM, Codingrate: 3/4" },
  { 7, "Modulation type: 64-QAM, Codingrate: 5/6" },
  { 8, "Modulation type: 256-QAM, Codingrate: 3/4" },
  { 9, "Modulation type: 256-QAM, Codingrate: 5/6" },
  { 0, NULL }
};
/* Standardised Bulk In message types */
#define RDR_PC_DATA_BLOCK      0x80
#define RDR_PC_SLOT_STATUS     0x81
#define RDR_PC_PARAMS          0x82
#define RDR_PC_ESCAPE          0x83
#define RDR_PC_DATA_CLOCK      0x84

void proto_register_ccid(void);
void proto_reg_handoff_ccid(void);

static const value_string ccid_descriptor_type_vals[] = {
        {USB_DESC_TYPE_SMARTCARD, "smart card"},
        {0,NULL}
};
static value_string_ext ccid_descriptor_type_vals_ext =
    VALUE_STRING_EXT_INIT(ccid_descriptor_type_vals);

static const value_string ccid_opcode_vals[] = {
    /* Standardised Bulk Out message types */
    {PC_RDR_SET_PARAMS      , "PC_to_RDR_SetParameters"},
    {PC_RDR_ICC_ON          , "PC_to_RDR_IccPowerOn"},
    {PC_RDR_ICC_OFF         , "PC_to_RDR_IccPowerOff"},
    {PC_RDR_GET_SLOT_STATUS , "PC_to_RDR_GetSlotStatus"},
    {PC_RDR_SECURE          , "PC_to_RDR_Secure"},
    {PC_RDR_T0APDU          , "PC_to_RDR_T0APDU"},
    {PC_RDR_ESCAPE          , "PC_to_RDR_Escape"},
    {PC_RDR_GET_PARAMS      , "PC_to_RDR_GetParameters"},
    {PC_RDR_RESET_PARAMS    , "PC_to_RDR_ResetParameters"},
    {PC_RDR_ICC_CLOCK       , "PC_to_RDR_IccClock"},
    {PC_RDR_XFR_BLOCK       , "PC_to_RDR_XfrBlock"},
    {PC_RDR_MECH            , "PC_to_RDR_Mechanical"},
Example #13
0
static const value_string meta_proto_vals[] = {
    { META_PROTO_DXT_ETHERNET,      "Ethernet without FCS" },
    { META_PROTO_DXT_ETHERNET_CRC,  "Ethernet with FCS" },
    { META_PROTO_DXT_ATM,           "ATM" },
    { META_PROTO_DXT_ERF_AAL5,      "ERF AAL5" },
    /* XXX: META_PROTO_DXT_M3UA ? */
    /* XXX: META_PROTO_DXT_NBAP ? */
    { META_PROTO_DXT_ATM_AAL2,      "ATM AAL2" },
    { META_PROTO_DXT_FP_HINT,       "FP Hint" },
    { META_PROTO_DXT_HDLC,          "HDLC" },
    { META_PROTO_DXT_CONTAINER,     "DXT CONTAINER" },
    { META_PROTO_DXT_FP_CAPTURE,    "FP CAPTURE" },
    { META_PROTO_DXT_UTRAN_CAPSULE, "UTRAN CAPSULE" },
    { 0, NULL }
};
static value_string_ext meta_proto_vals_ext = VALUE_STRING_EXT_INIT(meta_proto_vals);

static const value_string meta_type_vals[] = {
    { META_TYPE_NONE,       "NONE" },
    { META_TYPE_BOOLEAN,    "BOOLEAN" },
    { META_TYPE_UINT8,      "UINT8" },
    { META_TYPE_UINT16,     "UINT16" },
    { META_TYPE_UINT32,     "UINT32" },
    { META_TYPE_UINT64,     "UINT64" },
    { META_TYPE_STRING,     "STRING" },
    { 0, NULL }
};

/* TODO: this must be on a per-schema basis! */
static const value_string meta_id_vals[] = {
    { META_ID_NULL,         "NULL" },
Example #14
0
/* Initialize the subtree pointers */
static gint ett_wtls = ETT_EMPTY;
static gint ett_wtls_rec = ETT_EMPTY;
static gint ett_wtls_msg_type = ETT_EMPTY;
static gint ett_wtls_msg_type_item = ETT_EMPTY;
static gint ett_wtls_msg_type_item_sub = ETT_EMPTY;
static gint ett_wtls_msg_type_item_sub_sub = ETT_EMPTY;

static const value_string wtls_vals_record_type[] = {
	{ 1, "change_cipher_data" },
	{ 2, "alert" },
	{ 3, "handshake" },
	{ 4, "application_data" },
	{ 0, NULL }
};
static value_string_ext wtls_vals_record_type_ext = VALUE_STRING_EXT_INIT(wtls_vals_record_type);

static const value_string wtls_vals_cipher_bulk[] = {
	{ 0, "Null" },
	{ 1, "RC5 CBC 40" },
	{ 2, "RC5 CBC 56" },
	{ 3, "RC5 CBC" },
	{ 4, "DES CBC 40" },
	{ 5, "DES CBC" },
	{ 6, "3DES CBC cwEDE40" },
	{ 7, "IDEA CBC 40" },
	{ 8, "IDEA CBC 56" },
	{ 9, "IDEA CBC" },
	{ 0, NULL }
};
static value_string_ext wtls_vals_cipher_bulk_ext = VALUE_STRING_EXT_INIT(wtls_vals_cipher_bulk);
Example #15
0
static const value_string wai_subtype_names[] = {
    {  WAI_SUB_PRE_AUTHENTICATION,      "Pre-Authentication start" },
    {  WAI_SUB_STAKEY_REQ,              "STAKey request" },
    {  WAI_SUB_AUTH_ACTIVATION,         "Authentication activation" },
    {  WAI_SUB_ACCESS_AUTH_REQ,         "Access authentication request" },
    {  WAI_SUB_ACCESS_AUTH_RESP,        "Access authentication response" },
    {  WAI_SUB_CERT_AUTH_REQ,           "Certificate authentication request" },
    {  WAI_SUB_CERT_AUTH_RESP,          "Certificate authentication response" },
    {  WAI_SUB_UNICAST_KEY_REQ,         "Unicast key negotiation request" },
    {  WAI_SUB_UNICAST_KEY_RESP,        "Unicast key negotiation response" },
    {  WAI_SUB_UNICAST_KEY_CONFIRM,     "Unicast key negotiation confirmation" },
    {  WAI_SUB_MULTICAST_ANNOUNCE,      "Multicast key/STAKey announcement" },
    {  WAI_SUB_MULTICAST_ANNOUNCE_RESP, "Multicast key/STAKey announcement response" },
    { 0, NULL }
};
static value_string_ext wai_subtype_names_ext = VALUE_STRING_EXT_INIT(wai_subtype_names);

static const true_false_string wai_bk_rekeying_flag = {
    "Packet is a BK rekeying packet",
    "Packet is not a BK rekeying packet"
};

static const true_false_string wai_preauthentication_flag = {
    "Packet is a pre-authentication packet",
    "Packet is not a pre-authentication packet"
};

static const true_false_string  wai_certificate_flag = {
    "STA requires to verify the peers certificate",
    "STA doesn't require to verify the peers certificate"
};
Example #16
0
    &hf_msg_reassembled_in,
    /* Reassembled length field */
    &hf_msg_reassembled_length,
    /* Reassembled data field */
    NULL,
    /* Tag */
    "Message fragments"
};

static const value_string request_vals[] = {
    { 0x00,  "Primary Controller Function" },
    { 0x2B,  "AMP Controller Function" },
    { 0xE0,  "Primary Controller Function (Historical)" },
    { 0x00, NULL }
};
static value_string_ext(request_vals_ext) = VALUE_STRING_EXT_INIT(request_vals);


void proto_register_hci_usb(void);
void proto_reg_handoff_hci_usb(void);

static gint
dissect_hci_usb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
{
    proto_item        *ttree = NULL;
    proto_tree        *titem = NULL;
    proto_item        *pitem = NULL;
    gint               offset = 0;
    usb_conv_info_t   *usb_conv_info;
    tvbuff_t          *next_tvb = NULL;
    bluetooth_data_t  *bluetooth_data;
/* operating systems */
#define OS_WINDOWS                  0x00
#define OS_LINUX                    0x10
#define OS_JAVA                     0x20
#define OS_DOT_NET                  0x40
#define OS_GENERIC                  0x80
static const value_string osys_mapping[] = {
	{ OS_WINDOWS, "Windows"},
	{ OS_LINUX,   "Linux"},
	{ OS_JAVA,    "Java"},
	{ OS_DOT_NET, ".Net"},
	{ OS_GENERIC, "Generic TCP/IP Driver"},
	{ 0,          NULL },
};
static value_string_ext osys_mapping_ext = VALUE_STRING_EXT_INIT(osys_mapping);

/* error codes */
#define EC_OK                          0
#define EC_TIMEOUT_TO_LINK             1
#define EC_TIMEOUT_FROM_LINK           2
#define EC_TIMEOUT_FAST_TO_LINK        3
#define EC_TIMEOUT_FAST_FROM_LINK      4
#define	EC_TIMEOUT                     5
#define EC_MEMORY_ERROR             -100
#define EC_RETRY_UNKNOWN             -41
#define EC_ALREADY_PROCESSED         -40
#define EC_WRONG_BINARY_FILE         -35
#define EC_INVALID_PACKET_ORDER      -33
#define EC_FIFO_NOT_ENOUGH_DATA      -32
#define EC_DATA_TOO_SMALL            -31
	{    MAC_MGMT_MSG_MOB_BSHO_REQ,	   "MOB-BSHO-REQ" },
	{    MAC_MGMT_MSG_MOB_MSHO_REQ,	   "MOB-MSHO-REQ" },
	{    MAC_MGMT_MSG_MOB_BSHO_RSP,	   "MOB-BSHO-RSP" },
	{    MAC_MGMT_MSG_MOB_HO_IND,	   "MOB-HO-IND" },
	{    MAC_MGMT_MSG_MOB_SCN_REP,	   "MOB-SCN-REP" },
	{    MAC_MGMT_MSG_MOB_PAG_ADV,	   "MOB-PAG-ADV" },
	{    MAC_MGMT_MSG_MBS_MAP,	   "MBS-MAP" },
	{    MAC_MGMT_MSG_PMC_REQ,	   "PMC-REQ" },
	{    MAC_MGMT_MSG_PMC_RSP,	   "PMC-RSP" },
	{    MAC_MGMT_MSG_PRC_LT_CTRL,	   "PRC-LT-CTRL" },
	{    MAC_MGMT_MSG_MOB_ASC_REP,	   "MOB-ASC-REP" },

	{ 0, NULL }
};

static value_string_ext mgt_msg_abbrv_vals_ext = VALUE_STRING_EXT_INIT(mgt_msg_abbrv_vals);

static int dissect_mac_mgmt_msg_decoder(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
	guint offset = 0;
	guint message_type;
	proto_item *message_item;
	proto_tree *message_tree;
	const char* mgt_msg_str;

	message_item = proto_tree_add_protocol_format(tree, proto_mac_mgmt_msg_decoder, tvb, offset, -1,
					"MAC Management Message Type (%u bytes)", tvb_reported_length(tvb));
	message_tree = proto_item_add_subtree(message_item, ett_mac_mgmt_msg_decoder);

	if (tvb_reported_length(tvb) == 0)
	{
	{ 0xC4, "OEM" },
	{ 0xC5, "OEM" },
	{ 0xC6, "OEM" },
	{ 0xC7, "OEM" },
	{ 0xC8, "OEM" },
	{ 0xC9, "OEM" },
	{ 0xCA, "OEM" },
	{ 0xCB, "OEM" },
	{ 0xCC, "OEM" },
	{ 0xCD, "OEM" },
	{ 0xCE, "OEM" },
	{ 0xCF, "OEM" },
	{ 0, NULL }
};

static value_string_ext str_vita_site_types_ext = VALUE_STRING_EXT_INIT(str_vita_site_types);

static const value_string str_vita_fru_controls[] = {
	{ 0x00, "Cold Reset" },
	{ 0x01, "Warm Reset" },
	{ 0x02, "Graceful Reboot" },
	{ 0x03, "Diagnostic Interrupt" },
	{ 0, NULL }
};

static const value_string str_vita_led_colors[] = {
	{ 0x00, "Reserved (Control not supported)" },
	{ 0x01, "BLUE" },
	{ 0x02, "RED" },
	{ 0x03, "GREEN" },
	{ 0x04, "AMBER" },
Example #20
0
    { 532, "Need account for storing files" },
    { 533, "Command protection level denied for policy reasons" },
    { 534, "Request denied for policy reasons" },
    { 535, "Failed security check (hash, sequence, etc)" },
    { 536, "Requested PROT level not supported by mechanism" },
    { 537, "Command protection level not supported by security mechanism" },
    { 550, "Requested action not taken: File unavailable" },
    { 551, "Requested action aborted: page type unknown" },
    { 552, "Requested file action aborted: Exceeded storage allocation" },
    { 553, "Requested action not taken: File name not allowed" },
    { 631, "Integrity protected reply" },
    { 632, "Confidentiality and integrity protected reply" },
    { 633, "Confidentiality protected reply" },
    { 0,   NULL }
};
static value_string_ext response_table_ext = VALUE_STRING_EXT_INIT(response_table);

#define EPRT_AF_IPv4 1
#define EPRT_AF_IPv6 2
static const value_string eprt_af_vals[] = {
    { EPRT_AF_IPv4, "IPv4" },
    { EPRT_AF_IPv6, "IPv6" },
    { 0, NULL }
};


/*
 * Parse the address and port information in a PORT command or in the
 * response to a PASV command.  Return TRUE if we found an address and
 * port, and supply the address and port; return FALSE if we didn't find
 * them.
Example #21
0
    { 0x4c, "Precondition Failed" },
    { 0x4d, "Requested Entity Too Large" },
    { 0x4e, "Requested URL Too Large" },
    { 0x4f, "Unsupported Media Type" },
    { 0x50, "Internal Server Error" },
    { 0x51, "Not Implemented" },
    { 0x52, "Bad Gateway" },
    { 0x53, "Service Unavailable" },
    { 0x54, "Gateway Timeout" },
    { 0x55, "HTTP Version Not Supported" },
    { 0x60, "Database Full" },
    { 0x61, "Database Locked" },
    { BTOBEX_CODE_VALS_ABORT, "Abort" },
    { 0,      NULL }
};
static value_string_ext(code_vals_ext) = VALUE_STRING_EXT_INIT(code_vals);

static const value_string header_id_vals[] = {
    { 0x01, "Name" },
    { 0x05, "Description" },
    { 0x30, "User Defined" },
    { 0x31, "User Defined" },
    { 0x32, "User Defined" },
    { 0x33, "User Defined" },
    { 0x34, "User Defined" },
    { 0x35, "User Defined" },
    { 0x36, "User Defined" },
    { 0x37, "User Defined" },
    { 0x38, "User Defined" },
    { 0x39, "User Defined" },
    { 0x3a, "User Defined" },
Example #22
0
    { MQTTSN_SUBSCRIBE,           "Subscribe Request" },
    { MQTTSN_SUBACK,              "Subscribe Ack" },
    { MQTTSN_UNSUBSCRIBE,         "Unsubscribe Request" },
    { MQTTSN_UNSUBACK,            "Unsubscribe Ack" },
    { MQTTSN_PINGREQ,             "Ping Request" },
    { MQTTSN_PINGRESP,            "Ping Response" },
    { MQTTSN_DISCONNECT,          "Disconnect Req" },
    { MQTTSN_RESERVED_19,         "Reserved_19" },
    { MQTTSN_WILLTOPICUPD,        "Will Topic Update" },
    { MQTTSN_WILLTOPICRESP,       "Will Topic Response" },
    { MQTTSN_WILLMSGUPD,          "Will Message Update" },
    { MQTTSN_WILLMSGRESP,         "Will Message Response" },
    { MQTTSN_ENCAPSULATED_MSG,    "Encapsulated Message" },
    { 0,                          NULL }
};
static value_string_ext mqttsn_msgtype_vals_ext = VALUE_STRING_EXT_INIT(mqttsn_msgtype_vals);

/* MQTT-SN QoS level values. */
static const value_string mqttsn_qos_vals[] = {
    { MQTTSN_QOS_ATMOST_ONCE,         "Fire and Forget" },
    { MQTTSN_QOS_ATLEAST_ONCE,        "Acknowledged deliver" },
    { MQTTSN_QOS_EXACTLY_ONCE,        "Assured Delivery" },
    { MQTTSN_QOS_NO_CONNECTION,       "No Connection required" },
    { 0,                              NULL }
};

/* MQTT-SN topic type values. */
static const value_string mqttsn_typeid_vals[] = {
    { MQTTSN_TOPIC_NORMAL_ID,         "Normal ID" },
    { MQTTSN_TOPIC_PREDEF_ID,         "Pre-defined ID" },
    { MQTTSN_TOPIC_SHORT_NAME,        "Short Topic Name" },
Example #23
0
	{ WS_NETLINK_AUDIT,	     "Auditing" },
	{ WS_NETLINK_FIB_LOOKUP,     "FIB lookup" },
	{ WS_NETLINK_CONNECTOR,	     "Kernel connector" },
	{ WS_NETLINK_NETFILTER,	     "Netfilter" },
	{ WS_NETLINK_IP6_FW,	     "Unused (formerly: ip6_queue)" },
	{ WS_NETLINK_DNRTMSG,	     "DECnet routing messages" },
	{ WS_NETLINK_KOBJECT_UEVENT, "Kernel messages" },
	{ WS_NETLINK_GENERIC,	     "Generic" },
	{ WS_NETLINK_SCSITRANSPORT,  "SCSI Transports" },
	{ WS_NETLINK_ECRYPTFS,	     "ecryptfs" },
	{ WS_NETLINK_RDMA,	     "RDMA" },
	{ WS_NETLINK_CRYPTO,	     "Crypto layer" },
	{ 0, NULL }
};

value_string_ext netlink_family_vals_ext = VALUE_STRING_EXT_INIT(netlink_family_vals);

static const value_string type_vals[] = {
	{ WS_NLMSG_NOOP,    "nothing" },
	{ WS_NLMSG_ERROR,   "error" },
	{ WS_NLMSG_DONE,    "end of a dump" },
	{ WS_NLMSG_OVERRUN, "data lost" },
	{ 0, NULL }
};

static const value_string ha_types[] = {
	{ ARPHRD_NETLINK,    "Netlink" },
	{ 0, NULL }
};

static dissector_handle_t netlink_handle;