/* packet-rsvd.c

 * Routines for RSVD dissection

 * Copyright 2015, Richard Sharpe <realrichardsharpe@gmail.com>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

/*

 * RSVD, documented in [MS-RSVD].pdf, by Microsoft, the Remote Shared Virtual

 * Disk protocol.

 */

#include "config.h"

#include <epan/conversation.h>

#include <epan/packet.h>

#if 0

#include "packet-smb-common.h"

#endif

#include "packet-windows-common.h"

#include "packet-scsi.h"

void proto_register_rsvd(void);

static int proto_rsvd;

static int hf_svhdx_protocol_id;

static int hf_svhdx_protocol_version;

static int hf_svhdx_operation_code;

static int hf_svhdx_status;

static int hf_svhdx_request_id;

static int hf_svhdx_tunnel_scsi_length;

static int hf_svhdx_tunnel_scsi_reserved1;

static int hf_svhdx_tunnel_scsi_cdb_length;

static int hf_svhdx_tunnel_scsi_sense_info_ex_length;

static int hf_svhdx_tunnel_scsi_data_in;

static int hf_svhdx_tunnel_scsi_reserved2;

static int hf_svhdx_tunnel_scsi_srb_flags;

static int hf_svhdx_tunnel_scsi_data_transfer_length;

static int hf_svhdx_tunnel_scsi_reserved3;

static int hf_svhdx_tunnel_scsi_cdb;

static int hf_svhdx_tunnel_scsi_cdb_padding;

static int hf_svhdx_tunnel_scsi_data;

static int hf_svhdx_tunnel_scsi_auto_generated_sense;

static int hf_svhdx_tunnel_scsi_srb_status;

static int hf_svhdx_tunnel_scsi_sense_data_ex;

static int hf_svhdx_tunnel_scsi_status;

static int hf_svhdx_tunnel_file_info_server_version;

static int hf_svhdx_tunnel_file_info_sector_size;

static int hf_svhdx_tunnel_file_info_physical_sector_size;

static int hf_svhdx_tunnel_file_info_reserved;

static int hf_svhdx_tunnel_file_info_virtual_size;

static int hf_svhdx_tunnel_disk_info_reserved1;

static int hf_svhdx_tunnel_disk_info_blocksize;

static int hf_svhdx_tunnel_disk_info_linkage_id;

static int hf_svhdx_tunnel_disk_info_disk_type;

static int hf_svhdx_tunnel_disk_info_disk_format;

static int hf_svhdx_tunnel_disk_info_is_mounted;

static int hf_svhdx_tunnel_disk_info_is_4k_aligned;

static int hf_svhdx_tunnel_disk_info_reserved;

static int hf_svhdx_tunnel_disk_info_file_size;

static int hf_svhdx_tunnel_disk_info_virtual_disk_id;

static int hf_svhdx_tunnel_validate_disk_reserved;

static int hf_svhdx_tunnel_validate_disk_is_valid_disk;

static int hf_svhdx_tunnel_srb_status_status_key;

static int hf_svhdx_tunnel_srb_status_reserved;

static int hf_svhdx_tunnel_srb_status_sense_info_auto_generated;

static int hf_svhdx_tunnel_srb_status_srb_status;

static int hf_svhdx_tunnel_srb_status_scsi_status;

static int hf_svhdx_tunnel_srb_status_sense_info_ex_length;

static int hf_svhdx_tunnel_srb_status_sense_data_ex;

static int hf_svhdx_tunnel_safe_virtual_size;

static int hf_svhdx_tunnel_transaction_id;

static int hf_svhdx_tunnel_meta_operation_type;

static int hf_svhdx_tunnel_padding;

static int hf_svhdx_tunnel_resize_new_size;

static int hf_svhdx_tunnel_resize_expand_only_flag;

static int hf_svhdx_tunnel_resize_allow_unsafe_virt_size_flag;

static int hf_svhdx_tunnel_resize_shrink_to_minimum_safe_size_flag;

static int hf_svhdx_tunnel_meta_operation_start_reserved;

static int hf_svhdx_tunnel_snapshot_type;

static int hf_svhdx_tunnel_snapshot_id;

static int hf_svhdx_tunnel_create_snapshot_flags;

static int hf_svhdx_tunnel_create_snapshot_flag_enable_change_tracking;

static int hf_svhdx_tunnel_create_snapshot_stage1;

static int hf_svhdx_tunnel_create_snapshot_stage2;

static int hf_svhdx_tunnel_create_snapshot_stage3;

static int hf_svhdx_tunnel_create_snapshot_stage4;

static int hf_svhdx_tunnel_create_snapshot_stage5;

static int hf_svhdx_tunnel_create_snapshot_stage6;

static int hf_svhdx_tunnel_create_snapshot_parameters_payload_size;

static int hf_svhdx_tunnel_convert_dst_vhdset_name_len;

static int hf_svhdx_tunnel_convert_dst_vhdset_name;

static int hf_svhdx_tunnel_delete_snapshot_persist_reference;

static int hf_svhdx_tunnel_meta_op_query_progress_current_progress;

static int hf_svhdx_tunnel_meta_op_query_progress_complete_value;

static int hf_svhdx_tunnel_vhdset_information_type;

static int hf_svhdx_tunnel_vhdset_snapshot_creation_time;

static int hf_svhdx_tunnel_vhdset_is_valid_snapshot;

static int hf_svhdx_tunnel_vhdset_parent_snapshot_id;

static int hf_svhdx_tunnel_vhdset_log_file_id;

static int ett_rsvd;

static int ett_svhdx_tunnel_op_header;

static int ett_svhdx_tunnel_scsi_request;

static int ett_rsvd_create_snapshot_flags;

static const value_string rsvd_operation_code_vals[] = {

        { 0x02001001, "RSVD_TUNNEL_GET_INITIAL_INFO" },

        { 0x02001002, "RSVD_TUNNEL_SCSI" },

        { 0x02001003, "RSVD_TUNNEL_CHECK_CONNECTION_STATUS" },

        { 0x02001004, "RSVD_TUNNEL_SRB_STATUS" },

        { 0x02001005, "RSVD_TUNNEL_GET_DISK_INFO" },

        { 0x02001006, "RSVD_TUNNEL_VALIDATE_DISK" },

        { 0x02002101, "RSVD_TUNNEL_META_OPERATION_START" },

        { 0x02002002, "RSVD_TUNNEL_META_OPERATION_QUERY_PROGRESS" },

        { 0x02002005, "RSVD_TUNNEL_VHDSET_QUERY_INFORMATION" },

        { 0x02002006, "RSVD_TUNNEL_DELETE_SNAPSHOT" },

        { 0x02002008, "RSVD_TUNNEL_CHANGE_TRACKING_GET_PARAMETERS" },

        { 0x02002009, "RSVD_TUNNEL_CHANGE_TRACKING_START" },

        { 0x0200200A, "RSVD_TUNNEL_CHANGE_TRACKING_STOP" },

        { 0x0200200C, "RSVD_TUNNEL_QUERY_VIRTUAL_DISK_CHANGES" },

        { 0x0200200D, "RSVD_TUNNEL_QUERY_SAFE_SIZE" },

        { 0, NULL }

};

static const value_string rsvd_sense_info_vals[] = {

        { 0x0, "Sense Info Not Auto Generated" },

        { 0x1, "Sense Info Auto Generated" },

        { 0, NULL }

};

static const value_string rsvd_disk_type_vals[] = {

        { 0x02, "VHD_TYPE_FIXED" },

        { 0x03, "VHD_TYPE_DYNAMIC" },

        { 0, NULL }

};

static const value_string rsvd_disk_format_vals[] = {

        { 0x03, "VIRTUAL_STORAGE_TYPE_DEVICE_VHDX" },

        { 0x04, "VIRTUAL_STORAGE_TYPE_DEVICE_VHDSET" },

        { 0, NULL }

};

/*

 * We need this data to handle SCSI requests and responses, I think

 */

typedef struct _rsvd_task_data_t {

        uint32_t request_frame;

        uint32_t response_frame;

        itlq_nexus_t *itlq;

} rsvd_task_data_t;

typedef struct _rsvd_conv_data_t {

        wmem_map_t *tasks;

        wmem_tree_t *itl;

        rsvd_task_data_t *task;

        conversation_t *conversation;

} rsvd_conv_data_t;

static rsvd_conv_data_t *rsvd_conv_data;

static proto_tree *top_tree;

static itl_nexus_t *

get_itl_nexus(packet_info *pinfo)

{

    itl_nexus_t *itl = NULL;

    if (!(itl = (itl_nexus_t *)wmem_tree_lookup32_le(rsvd_conv_data->itl, pinfo->num))) {

        itl = wmem_new(wmem_file_scope(), itl_nexus_t);

        itl->cmdset = 0xff;

        itl->conversation = rsvd_conv_data->conversation;

        wmem_tree_insert32(rsvd_conv_data->itl, pinfo->num, itl);

    }

    return itl;

}

static int

dissect_RSVD_GET_INITIAL_INFO(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)

{

    proto_tree *gfi_sub_tree;

    proto_item *gfi_sub_item;

    if (!request) {

        gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_GET_INITIAL_INFO_RESPONSE");

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_file_info_server_version, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_file_info_sector_size, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_file_info_physical_sector_size, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_file_info_reserved, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_file_info_virtual_size, tvb, offset, 8, ENC_LITTLE_ENDIAN);

        offset += 8;

    }

    return offset;

}

static const value_string rsvd_data_in_vals[] = {

        { 0x00, "Client is requesting data from the server" },

        { 0x01, "Client is sending data to the server" },

        { 0x02, "Client is neither sending nor requesting an additional data buffer" },

        { 0, NULL }

};

static void

dissect_scsi_payload_databuffer(tvbuff_t *tvb, packet_info *pinfo, int offset, uint32_t data_transfer_length, bool request)

{

    tvbuff_t *data_tvb = NULL;

    int tvb_rlen;

    tvb_rlen = tvb_reported_length_remaining(tvb, offset);

    if (tvb_rlen > (int)data_transfer_length)

        tvb_rlen = data_transfer_length;

    data_tvb = tvb_new_subset_length(tvb, offset, tvb_rlen);

    if (rsvd_conv_data->task && rsvd_conv_data->task->itlq) {

        rsvd_conv_data->task->itlq->task_flags = SCSI_DATA_READ |

                                                 SCSI_DATA_WRITE;

        rsvd_conv_data->task->itlq->data_length = data_transfer_length;

        rsvd_conv_data->task->itlq->bidir_data_length = data_transfer_length;

        dissect_scsi_payload(data_tvb, pinfo, top_tree, request,

                             rsvd_conv_data->task->itlq,

                             get_itl_nexus(pinfo), 0);

    }

}

/*

 * Dissect a tunnelled SCSI request and call the SCSI dissector where

 * needed.

 */

static int

dissect_RSVD_TUNNEL_SCSI(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset, int16_t len, bool request, uint64_t request_id)

{

    proto_tree *sub_tree;

    proto_item *sub_item;

    uint32_t length;

    uint32_t cdb_length;

    uint8_t data_in;

    uint32_t data_transfer_length;

    uint32_t sense_info_ex_length;

    conversation_t *conversation;

    conversation = find_or_create_conversation(pinfo);

    rsvd_conv_data = (rsvd_conv_data_t *)conversation_get_proto_data(conversation, proto_rsvd);

    if (!rsvd_conv_data) {

        rsvd_conv_data = wmem_new(wmem_file_scope(), rsvd_conv_data_t);

        rsvd_conv_data->tasks = wmem_map_new(wmem_file_scope(),

                                             wmem_int64_hash,

                                             g_int64_equal);

        rsvd_conv_data->itl   = wmem_tree_new(wmem_file_scope());

        rsvd_conv_data->conversation = conversation;

        conversation_add_proto_data(conversation, proto_rsvd, rsvd_conv_data);

    }

    rsvd_conv_data->task = NULL;

    rsvd_conv_data->task = (rsvd_task_data_t *)wmem_map_lookup(rsvd_conv_data->tasks, (const void *)&request_id);

    if (!pinfo->fd->visited) {

        if (rsvd_conv_data->task == NULL) {

            uint64_t *key_copy = wmem_new(wmem_file_scope(), uint64_t);

            *key_copy = request_id;

            rsvd_conv_data->task = wmem_new0(wmem_file_scope(), rsvd_task_data_t);

            rsvd_conv_data->task->itlq = wmem_new0(wmem_file_scope(),

                                                  itlq_nexus_t);

            rsvd_conv_data->task->itlq->lun = 0xffff;

            rsvd_conv_data->task->itlq->scsi_opcode = 0xffff;

            rsvd_conv_data->task->itlq->fc_time = pinfo->abs_ts;

            wmem_map_insert(rsvd_conv_data->tasks, (const void *)key_copy,

                            rsvd_conv_data->task);

        }

        if (request) {

            rsvd_conv_data->task->request_frame = pinfo->num;

            rsvd_conv_data->task->itlq->first_exchange_frame = pinfo->num;

        } else {

            rsvd_conv_data->task->response_frame = pinfo->num;

            rsvd_conv_data->task->itlq->last_exchange_frame = pinfo->num;

        }

    }

    sub_tree = proto_tree_add_subtree_format(parent_tree, tvb, offset, len, ett_svhdx_tunnel_scsi_request, &sub_item, "SVHDX_TUNNEL_SCSI_%s", (request ? "REQUEST" : "RESPONSE"));

    if (request) {

        tvbuff_t *scsi_cdb = NULL;

        /* Length */

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_length, tvb, offset, 2, ENC_LITTLE_ENDIAN);

        offset += 2;

        /* Reserved1 */

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_reserved1, tvb, offset, 2, ENC_LITTLE_ENDIAN);

        offset += 2;

        /* CDBLength */

        cdb_length = tvb_get_uint8(tvb, offset);

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_cdb_length, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset++;

        /* SensInfoExLength */

        /* You'll notice that there is no SenseDataEx field in the request.

         * This field is pointless and ignored. In some versions Microsoft

         * said that this field MUST be set to zero; recent versions say

         * that it SHOULD be set to 20 (which is the size of the CDBBuffer

         * plus Reserved3.) */

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_sense_info_ex_length, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset++;

        /* DataIn */

        data_in = tvb_get_uint8(tvb, offset);

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_data_in, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset++;

        /* Reserved2 */

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_reserved2, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset++;

        /* SrbFlags */

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_srb_flags, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        /* DataTransferLength */

        data_transfer_length = tvb_get_letohl(tvb, offset);

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_data_transfer_length, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        /* CDBBuffer */

        scsi_cdb = tvb_new_subset_length(tvb,

                                  offset,

                                  cdb_length);

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_cdb, tvb, offset, cdb_length, ENC_NA);

        offset += cdb_length;

        if (cdb_length < 16) {

            /*

             * CDBBuffer is always 16 bytes - see MS-RSVD section 2.2.4.7

             * "SVHDX_TUNNEL_SCSI_REQUEST Structure":

             *

             *     https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rsvd/e8bcb003-97b3-41ef-9689-cd2d1668a9cc

             *

             * If CDB is actually smaller, we need to define padding bytes

             */

            uint32_t cdb_padding_length = 16 - cdb_length;

            proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_cdb_padding, tvb, offset, cdb_padding_length, ENC_NA);

            offset += cdb_padding_length;

        }

        /* Reserved3 */

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_reserved3, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        /* DataBuffer */

        if (data_transfer_length) {

            proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_data, tvb, offset, data_transfer_length, ENC_NA);

        }

        /*

         * Now the SCSI Request

         */

        if (rsvd_conv_data->task && rsvd_conv_data->task->itlq) {

            dissect_scsi_cdb(scsi_cdb, pinfo, top_tree, SCSI_DEV_SMC, rsvd_conv_data->task->itlq, get_itl_nexus(pinfo));

            if (data_in == 0) { /* Only OUT operations have meaningful SCSI payload in request packet */

                dissect_scsi_payload_databuffer(tvb, pinfo, offset, data_transfer_length, request);

            }

        }

        /* increment after DataBuffer */

        offset += data_transfer_length;

    } else {

        uint8_t scsi_status = 0;

        /* Length */

        proto_tree_add_item_ret_uint(sub_tree, hf_svhdx_tunnel_scsi_length, tvb, offset, 2, ENC_LITTLE_ENDIAN, &length);

        offset += 2;

        /* A */

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_auto_generated_sense, tvb, offset, 1, ENC_BIG_ENDIAN);

        /* SrbStatus */

        proto_tree_add_bits_item(sub_tree, hf_svhdx_tunnel_scsi_srb_status, tvb, offset * 8 + 1, 7, ENC_BIG_ENDIAN);

        offset++;

        /* ScsiStatus */

        scsi_status = tvb_get_uint8(tvb, offset);

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_status, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset++;

        /* CdbLength */

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_cdb_length, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset++;

        /* SensInfoExLength */

        sense_info_ex_length = tvb_get_uint8(tvb, offset);

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_sense_info_ex_length, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset++;

        /* DataIn */

        data_in = tvb_get_uint8(tvb, offset);

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_data_in, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset++;

        /* Reserved */

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_reserved2, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset++;

        /* SrbFlags */

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_srb_flags, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        /* DataTransferLength */

        data_transfer_length = tvb_get_letohl(tvb, offset);

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_data_transfer_length, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        /* SenseDataEx */

        /* Microsoft kept going back and forth with this field. Up through

         * version 6.0 of the MS-RSVD specification, SenseInfoExLength had

         * the length of SenseDataEx, a variable length fields. In 7.0,

         * it was changed so that SenseDataEx was a fixed length 20 byte

         * field, and SenseInfoExLength had the number of bytes, of the

         * data actually contained in the field, which had to be 20 or fewer.

         * Then in 11.0 it was changed back.

         * In the 7.0-10.0 case, the 20 byte field seemed to actually

         * contain the CDB + padding + Reserved3 from the Request copied back.

         * Luckily there's also a Length field that measures the size of

         * the structure excluding the DataBuffer. In the versions with the

         * 20 byte fixed SenseDataEx field, the protocol notes that it MUST

         * MUST be set to the appropriate value of 36. (DataBuffer is the

         * only other possibly variable length field.)

         */

        if (length == 36 && sense_info_ex_length < 20) {

            sense_info_ex_length = 20;

        }

        proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_sense_data_ex, tvb, offset, sense_info_ex_length, ENC_NA);

        offset += sense_info_ex_length;

        /* DataBuffer */

        if (data_transfer_length) {

            proto_tree_add_item(sub_tree, hf_svhdx_tunnel_scsi_data, tvb, offset, data_transfer_length, ENC_NA);

            if (data_in == 1) { /* Only IN operations have meaningful SCSI payload in reply packet */

                dissect_scsi_payload_databuffer(tvb, pinfo, offset, data_transfer_length, request);

            }

            offset += data_transfer_length;

        }

        /*

         * Now, the SCSI response

         */

        if (rsvd_conv_data->task && rsvd_conv_data->task->itlq) {

            dissect_scsi_rsp(tvb, pinfo, top_tree, rsvd_conv_data->task->itlq, get_itl_nexus(pinfo), scsi_status);

        }

    }

    return offset;

}

static int

dissect_RSVD_SRB_STATUS(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)

{

    proto_tree *gfi_sub_tree;

    proto_item *gfi_sub_item;

    if (request) {

        gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_SRB_STATUS_REQUEST");

        /* StatusKey */

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_status_key, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset += 1;

        /* Reserved */

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_reserved, tvb, offset, 1, ENC_NA);

        offset += 27;

    } else {

        uint8_t sense_info_length;

        gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_SRB_STATUS_RESPONSE");

        /* StatusKey */

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_status_key, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset += 1;

        /* SenseInfoAutoGenerated and SrbStatus */

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_sense_info_auto_generated, tvb, offset, 1, ENC_BIG_ENDIAN);

        proto_tree_add_bits_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_srb_status, tvb, offset * 8 + 1, 7, ENC_BIG_ENDIAN);

        offset += 1;

        /* ScsiStatus */

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_scsi_status, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset += 1;

        /* SenseInfoExLength */

        sense_info_length = tvb_get_uint8(tvb, offset);

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_sense_info_ex_length, tvb, offset, 1, ENC_NA);

        offset += 1;

        /* SenseDataEx */

        /* For the same reasons as discussed in RSVD_TUNNEL_SCSI, in some

         * versions this field is a fixed 20 octets, and the length just

         * indicates the number of bytes of real sense data in it.

         * At least it's at the end; we'll just ignore the padding.

         */

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_srb_status_sense_data_ex, tvb, offset, sense_info_length, ENC_NA);

        offset += sense_info_length;

    }

    return offset;

}

static int

dissect_RSVD_GET_DISK_INFO(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)

{

    proto_tree *gfi_sub_tree;

    proto_item *gfi_sub_item;

    if (request) {

        gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_GET_DISK_INFO_REQUEST");

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_reserved1, tvb, offset, 8, ENC_LITTLE_ENDIAN);

        offset += 8;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_blocksize, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_linkage_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);

        offset += 16;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_is_mounted, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset += 1;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_is_4k_aligned, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset += 1;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_reserved, tvb, offset, 2, ENC_LITTLE_ENDIAN);

        offset += 2;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_file_size, tvb, offset, 8, ENC_LITTLE_ENDIAN);

        offset += 8;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_virtual_disk_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);

        offset += 16;

    } else {

        gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_GET_DISK_INFO_RESPONSE");

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_disk_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_disk_format, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_blocksize, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_linkage_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);

        offset += 16;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_is_mounted, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset += 1;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_is_4k_aligned, tvb, offset, 1, ENC_LITTLE_ENDIAN);

        offset += 1;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_reserved, tvb, offset, 2, ENC_LITTLE_ENDIAN);

        offset += 2;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_file_size, tvb, offset, 8, ENC_LITTLE_ENDIAN);

        offset += 8;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_disk_info_virtual_disk_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);

        offset += 16;

    }

    return offset;

}

static int

dissect_RSVD_VALIDATE_DISK(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)

{

    proto_tree *gfi_sub_tree;

    proto_item *gfi_sub_item;

    if (request) {

        gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_VALIDATE_DISK_REQUEST");

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_validate_disk_reserved, tvb, offset, 56, ENC_NA);

        offset += 56;

    } else {

        gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_VALIDATE_DISK_RESPONSE");

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_validate_disk_is_valid_disk, tvb, offset, 1, ENC_NA);

        offset += 1;

    }

    return offset;

}

static const value_string rsvd_meta_operation_type_vals[] = {

        { 0x00, "SvhdxMetaOperationTypeResize" },

        { 0x01, "SvhdxMetaOperationTypeCreateSnapshot" },

        { 0x02, "SvhdxMetaOperationTypeOptimize" },

        { 0x03, "SvhdxMetaOperationTypeExtractVHD" },

        { 0x04, "SvhdxMetaOperationTypeConvertToVHDSet" },

        { 0x05, "SvhdxMetaOperationTypeApplySnapshot" },

        { 0, NULL }

};

static const value_string svhdx_snapshot_type_vals[] = {

        { 0x01, "SvhdxSnapshotTypeVM" },

        { 0x03, "SvhdxSnapshotTypeCDP" },

        { 0x04, "SvhdxSnapshotTypeWriteable" },

        { 0, NULL }

};

static const value_string svhdx_snapshot_stage_vals[] = {

        { 0x00, "SvhdxSnapshotStageInvalid" },

        { 0x01, "SvhdxSnapshotStageInitialize" },

        { 0x02, "SvhdxSnapshotStageBlockIO" },

        { 0x03, "SvhdxSnapshotStageSwitchObjectStore" },

        { 0x04, "SvhdxSnapshotStageUnblockIO" },

        { 0x05, "SvhdxSnapshotStageFinalize" },

        { 0, NULL }

};

#define SVHDX_SNAPSHOT_DISK_FLAG_ENABLE_CHANGE_TRACKING 0x00000001

static int

dissect_RSVD2_META_OPERATION_START(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)

{

    static int * const meta_operation_create_snapshot_flags[] = {

        &hf_svhdx_tunnel_create_snapshot_flag_enable_change_tracking,

        NULL

    };

    uint32_t operation_type = 0;

    uint32_t length = 0;

    proto_tree *gfi_sub_tree;

    proto_item *gfi_sub_item;

    if (request) {

        gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_META_OPERATION_START_REQUEST");

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_transaction_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);

        offset += 16;

        operation_type = tvb_get_letohl(tvb, offset);

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_meta_operation_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_padding, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        switch (operation_type) {

        case 0x00: /* SvhdxMetaOperationTypeResize */

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_resize_new_size, tvb, offset, 8, ENC_LITTLE_ENDIAN);

            offset += 8;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_resize_expand_only_flag, tvb, offset, 1, ENC_LITTLE_ENDIAN);

            offset += 1;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_resize_allow_unsafe_virt_size_flag, tvb, offset, 1, ENC_LITTLE_ENDIAN);

            offset += 1;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_resize_shrink_to_minimum_safe_size_flag, tvb, offset, 1, ENC_LITTLE_ENDIAN);

            offset += 1;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_meta_operation_start_reserved, tvb, offset, 1, ENC_LITTLE_ENDIAN);

            offset += 1;

            break;

        case 0x01: /* SvhdxMetaOperationTypeCreateSnapshot */

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_bitmask(gfi_sub_tree, tvb, offset, hf_svhdx_tunnel_create_snapshot_flags,

                                   ett_rsvd_create_snapshot_flags, meta_operation_create_snapshot_flags, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_stage1, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_stage2, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_stage3, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_stage4, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_stage5, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_stage6, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);

            offset += 16;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_create_snapshot_parameters_payload_size, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            break;

        case 0x02: /* SvhdxMetaOperationTypeOptimize */

            /* No Data, field MUST be empty */

            break;

        case 0x03: /* SvhdxMetaOperationTypeExtractVHD */

            /* TODO */

            break;

        case 0x04: /* SvhdxMetaOperationTypeConvertToVHDSet */

            length = tvb_get_letohl(tvb, offset);

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_convert_dst_vhdset_name_len, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            if (length) {

                proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_convert_dst_vhdset_name, tvb, offset, length, ENC_UTF_16|ENC_LITTLE_ENDIAN);

            }

            break;

        case 0x05: /* SvhdxMetaOperationTypeApplySnapshot */

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);

            offset += 16;

            break;

        }

    }

    return offset;

}

static int

dissect_RSVD2_META_OPERATION_QUERY_PROGRESS(tvbuff_t *tvb,

            proto_tree *parent_tree, int offset, int16_t len, bool request, uint32_t status)

{

    proto_tree *gfi_sub_tree;

    proto_item *gfi_sub_item;

    if (request) {

        gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_META_OPERATION_QUERY_PROGRESS_REQUEST");

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_transaction_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);

        offset += 16;

    } else {

        if (status == 0) { /* If status is not successful, RSVD response buffer is filled by data from request buffer and we should not parse output structure */

            gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_META_OPERATION_QUERY_PROGRESS_RESPONSE");

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_meta_op_query_progress_current_progress, tvb, offset, 8, ENC_LITTLE_ENDIAN);

            offset += 8;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_meta_op_query_progress_complete_value, tvb, offset, 8, ENC_LITTLE_ENDIAN);

            offset += 8;

        }

    }

    return offset;

}

static const value_string svhdx_vhdset_information_type_vals[] = {

        { 0x02, "SvhdxVHDSetInformationTypeSnapshotList" },

        { 0x05, "SvhdxVHDSetInformationTypeSnapshotEntry" },

        { 0x08, "SvhdxVHDSetInformationTypeOptimizeNeeded" },

        { 0x09, "SvhdxVHDSetInformationTypeCdpSnapshotRoot" },

        { 0x0A, "SvhdxVHDSetInformationTypeCdpSnapshotActiveList" },

        { 0x0C, "SvhdxVHDSetInformationTypeCdpSnapshotInactiveList" },

        { 0, NULL }

};

static int

dissect_RSVD2_VHDSET_QUERY_INFORMATION(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)

{

    proto_tree *gfi_sub_tree;

    proto_item *gfi_sub_item;

    if (request) {

        gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_VHDSET_QUERY_INFORMATION_REQUEST");

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_vhdset_information_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);

        offset += 16;

    } else {

        uint32_t vhdset_info_type = tvb_get_letohl(tvb, offset);

        switch (vhdset_info_type) {

        case 0x02: /* SvhdxVHDSetInformationTypeSnapshotList */

            gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_VHDSET_QUERY_INFORMATION_SNAPSHOT_LIST_RESPONSE");

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_vhdset_information_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            /* TODO: make full dissection */

            break;

        case 0x05: /* SvhdxVHDSetInformationTypeSnapshotEntry */

            gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_VHDSET_QUERY_INFORMATION_SNAPSHOT_ENTRY_RESPONSE");

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_vhdset_information_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_padding, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            dissect_nttime(tvb, gfi_sub_tree, offset, hf_svhdx_tunnel_vhdset_snapshot_creation_time, ENC_LITTLE_ENDIAN);

            offset += 8;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_vhdset_is_valid_snapshot, tvb, offset, 4, ENC_LITTLE_ENDIAN);

            offset += 4;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);

            offset += 16;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_vhdset_parent_snapshot_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);

            offset += 16;

            proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_vhdset_log_file_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);

            offset += 16;

            break;

        }

    }

    return offset;

}

static int

dissect_RSVD2_DELETE_SNAPSHOT(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)

{

    proto_tree *gfi_sub_tree;

    proto_item *gfi_sub_item;

    if (request) {

        gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_DELETE_SNAPSHOT_REQUEST");

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_id, tvb, offset, 16, ENC_LITTLE_ENDIAN);

        offset += 16;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_delete_snapshot_persist_reference, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_snapshot_type, tvb, offset, 4, ENC_LITTLE_ENDIAN);

        offset += 4;

    }

    return offset;

}

static int

dissect_RSVD2_QUERY_SAFE_SIZE(tvbuff_t *tvb, proto_tree *parent_tree, int offset, int16_t len, bool request)

{

    proto_tree *gfi_sub_tree;

    proto_item *gfi_sub_item;

    if (!request) {

        gfi_sub_tree = proto_tree_add_subtree(parent_tree, tvb, offset, len, ett_svhdx_tunnel_op_header, &gfi_sub_item, "RSVD_TUNNEL_QUERY_SAFE_SIZE_RESPONSE");

        proto_tree_add_item(gfi_sub_tree, hf_svhdx_tunnel_safe_virtual_size, tvb, offset, 8, ENC_LITTLE_ENDIAN);

        offset += 8;

    }

    return offset;

}

static int

dissect_rsvd(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void *data)

{

    uint32_t header_bytes = 0;

    unsigned proto_id = 0;

    unsigned proto_version = 0;

    uint32_t operation_code = 0;

    uint32_t status;

    proto_item *ti;

    proto_tree *rsvd_tree;

    proto_item *sub_item;

    proto_tree *sub_tree;

    unsigned    offset = 0;

    uint16_t len;

    uint64_t request_id = 0;

    char* str_operation_code;

    bool request = *(bool *)data;

    top_tree = parent_tree;

    len = tvb_reported_length(tvb);

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "RSVD");

    col_clear(pinfo->cinfo, COL_INFO);

    /*

     * The header bytes need to be pulled in as a 32bit LE value. And the

     * header is the same in a request or a response ...

     */

    header_bytes = tvb_get_letohl(tvb, 0); /* Get the header bytes */

    proto_id = header_bytes >> 24;

    proto_version = (header_bytes >> 12) & 0x0FFF;

    operation_code = header_bytes;

    ti = proto_tree_add_item(parent_tree, proto_rsvd, tvb, offset, -1, ENC_NA);

    rsvd_tree = proto_item_add_subtree(ti, ett_rsvd);

    sub_tree = proto_tree_add_subtree(rsvd_tree, tvb, offset, (len>16) ? 16 : len, ett_svhdx_tunnel_op_header, &sub_item, "SVHDX_TUNNEL_OPERATION_HEADER");

    /* ProtocolID */

    proto_tree_add_uint(sub_tree, hf_svhdx_protocol_id, tvb, offset, 4, proto_id);

    /* ProtocolVersion */

    proto_tree_add_uint(sub_tree, hf_svhdx_protocol_version, tvb, offset, 4, proto_version);

    /* Operation Code */

    proto_tree_add_uint(sub_tree, hf_svhdx_operation_code, tvb, offset, 4, operation_code);

    offset += 4;

    /* Status */

    status = tvb_get_letohl(tvb, offset);

    proto_tree_add_item(sub_tree, hf_svhdx_status, tvb, offset, 4, ENC_LITTLE_ENDIAN);

    offset += 4;

    /* RequestId */

    proto_tree_add_item_ret_uint64(sub_tree, hf_svhdx_request_id, tvb, offset, 8, ENC_LITTLE_ENDIAN, &request_id);

    str_operation_code = val_to_str(pinfo->pool, operation_code, rsvd_operation_code_vals, "Unknown Operation Code (0x%08X)");

    offset += 8;

    col_append_fstr(pinfo->cinfo, COL_INFO, "%s %s", str_operation_code, request ? "Request" : "Response");