/* packet-netsync.c

 * Routines for Monotone Netsync packet disassembly

 *

 * Copyright (c) 2005 by Erwin Rol <erwin@erwinrol.com>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1999 Gerald Combs

 *

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

 */

/* Include files */

#include "config.h"

#include <epan/packet.h>

#include <epan/prefs.h>

#include "packet-tcp.h"

void proto_register_netsync(void);

void proto_reg_handoff_netsync(void);

static dissector_handle_t netsync_handle;

/*

 * See

 *

 *  http://www.monotone.ca

 */

/* Define TCP ports for Monotone netsync */

#define TCP_PORT_NETSYNC 5253

#define NETSYNC_ROLE_SOURCE 1

#define NETSYNC_ROLE_SINK 2

#define NETSYNC_ROLE_BOTH 3

static const value_string netsync_role_vals[] = {

  { NETSYNC_ROLE_SOURCE,  "Source" },

  { NETSYNC_ROLE_SINK,  "Sink" },

  { NETSYNC_ROLE_BOTH,  "Both" },

  { 0,      NULL }

};

#define NETSYNC_CMD_ERROR 0

#define NETSYNC_CMD_BYE   1

#define NETSYNC_CMD_HELLO 2

#define NETSYNC_CMD_ANONYMOUS 3

#define NETSYNC_CMD_AUTH  4

#define NETSYNC_CMD_CONFIRM 5

#define NETSYNC_CMD_REFINE  6

#define NETSYNC_CMD_DONE  7

#define NETSYNC_CMD_SEND_DATA 8

#define NETSYNC_CMD_SEND_DELTA  9

#define NETSYNC_CMD_DATA  10

#define NETSYNC_CMD_DELTA 11

#define NETSYNC_CMD_NONEXISTENT 12

static const value_string netsync_cmd_vals[] = {

  { NETSYNC_CMD_ERROR,    "Error" },

  { NETSYNC_CMD_BYE,    "Bye" },

  { NETSYNC_CMD_HELLO,    "Hello" },

  { NETSYNC_CMD_ANONYMOUS,  "Anonymous" },

  { NETSYNC_CMD_AUTH,     "Auth" },

  { NETSYNC_CMD_CONFIRM,    "Confirm" },

  { NETSYNC_CMD_REFINE,     "Refine" },

  { NETSYNC_CMD_DONE,     "Done" },

  { NETSYNC_CMD_SEND_DATA,  "Send Data" },

  { NETSYNC_CMD_SEND_DELTA,   "Send Delta" },

  { NETSYNC_CMD_DATA,   "Data" },

  { NETSYNC_CMD_DELTA,    "Delta" },

  { NETSYNC_CMD_NONEXISTENT,  "Nonexistent" },

  { 0,        NULL }

};

#define NETSNYC_MERKLE_HASH_LENGTH 20

/* Define the monotone netsync proto */

static int proto_netsync;

static int hf_netsync_version;

static int hf_netsync_command;

static int hf_netsync_size;

static int hf_netsync_data;

static int hf_netsync_checksum;

static int hf_netsync_cmd_done_level;

static int hf_netsync_cmd_done_type;

static int hf_netsync_cmd_hello_keyname;

static int hf_netsync_cmd_hello_key;

static int hf_netsync_cmd_nonce;

static int hf_netsync_cmd_anonymous_role;

static int hf_netsync_cmd_anonymous_collection;

static int hf_netsync_cmd_send_data_type;

static int hf_netsync_cmd_send_data_id;

static int hf_netsync_cmd_error_msg;

static int hf_netsync_cmd_confirm_sig;

static int hf_netsync_cmd_auth_role;

static int hf_netsync_cmd_auth_collection;

static int hf_netsync_cmd_auth_id;

static int hf_netsync_cmd_auth_nonce1;

static int hf_netsync_cmd_auth_nonce2;

static int hf_netsync_cmd_auth_sig;

static int hf_netsync_cmd_data_type;

static int hf_netsync_cmd_data_id;

static int hf_netsync_cmd_data_compressed;

static int hf_netsync_cmd_data_payload;

static int hf_netsync_cmd_delta_type;

static int hf_netsync_cmd_delta_base_id;

static int hf_netsync_cmd_delta_ident_id;

static int hf_netsync_cmd_delta_compressed;

static int hf_netsync_cmd_delta_payload;

static int hf_netsync_cmd_refine_tree_node;

static int hf_netsync_cmd_send_delta_type;

static int hf_netsync_cmd_send_delta_base_id;

static int hf_netsync_cmd_send_delta_ident_id;

static int hf_netsync_cmd_nonexistent_type;

static int hf_netsync_cmd_nonexistent_id;

/* Define the tree for netsync */

static int ett_netsync;

/*

 * Here are the global variables associated with the preferences

 * for monotone netsync

 */

static bool netsync_desegment = true;

static int dissect_netsync_cmd_error( tvbuff_t *tvb,  int offset, proto_tree *tree, unsigned size _U_)

{

  uint64_t len = 0;

  offset += tvb_get_varint( tvb, offset, FT_VARINT_MAX_LEN, &len, ENC_VARINT_PROTOBUF );

  proto_tree_add_item(tree, hf_netsync_cmd_error_msg, tvb,

        offset, (int)len, ENC_ASCII );

  offset += (int)len;

  return offset;

}

static int dissect_netsync_cmd_bye(tvbuff_t *tvb _U_,  int offset, proto_tree *tree _U_, unsigned size _U_)

{

  return offset;

}

static int dissect_netsync_cmd_hello(tvbuff_t *tvb,  int offset, proto_tree *tree, unsigned size _U_)

{

  uint64_t len = 0;

  offset += tvb_get_varint( tvb, offset, FT_VARINT_MAX_LEN, &len, ENC_VARINT_PROTOBUF );

  proto_tree_add_item(tree, hf_netsync_cmd_hello_keyname, tvb,

        offset, (int)len, ENC_ASCII );

  offset += (int)len;

  offset += tvb_get_varint( tvb, offset, FT_VARINT_MAX_LEN, &len, ENC_VARINT_PROTOBUF );

  proto_tree_add_item(tree, hf_netsync_cmd_hello_key, tvb,

        offset, (int)len, ENC_NA );

  offset += (int)len;

  proto_tree_add_item(tree, hf_netsync_cmd_nonce, tvb,

        offset, NETSNYC_MERKLE_HASH_LENGTH, ENC_NA );

  offset += NETSNYC_MERKLE_HASH_LENGTH;

  return offset;

}

static int dissect_netsync_cmd_anonymous(tvbuff_t *tvb,  int offset, proto_tree *tree, unsigned size _U_)

{

  uint64_t len = 0;

  proto_tree_add_item(tree, hf_netsync_cmd_anonymous_role, tvb,

        offset, 1, ENC_BIG_ENDIAN );

  offset += 1;

  offset += tvb_get_varint( tvb, offset, FT_VARINT_MAX_LEN, &len, ENC_VARINT_PROTOBUF );

  proto_tree_add_item(tree, hf_netsync_cmd_anonymous_collection, tvb,

        offset, (int)len, ENC_ASCII );

  offset += (int)len;

  proto_tree_add_item(tree, hf_netsync_cmd_nonce, tvb,

        offset, NETSNYC_MERKLE_HASH_LENGTH, ENC_NA );

  offset += NETSNYC_MERKLE_HASH_LENGTH;

  return offset;

}

static int dissect_netsync_cmd_auth(tvbuff_t *tvb,  int offset, proto_tree *tree, unsigned size _U_)

{

  uint64_t len = 0;

  proto_tree_add_item(tree, hf_netsync_cmd_auth_role, tvb,

        offset, 1, ENC_BIG_ENDIAN );

  offset += 1;

  offset += tvb_get_varint( tvb, offset, FT_VARINT_MAX_LEN, &len, ENC_VARINT_PROTOBUF );

  proto_tree_add_item(tree, hf_netsync_cmd_auth_collection, tvb,

        offset, (int)len, ENC_ASCII );

  offset += (int)len;

  proto_tree_add_item(tree, hf_netsync_cmd_auth_id, tvb,

        offset, NETSNYC_MERKLE_HASH_LENGTH, ENC_NA );

  offset += NETSNYC_MERKLE_HASH_LENGTH;

  offset += (int)len;

  proto_tree_add_item(tree, hf_netsync_cmd_auth_nonce1, tvb,

        offset, NETSNYC_MERKLE_HASH_LENGTH, ENC_NA );

  offset += NETSNYC_MERKLE_HASH_LENGTH;

  offset += (int)len;

  proto_tree_add_item(tree, hf_netsync_cmd_auth_nonce2, tvb,

        offset, NETSNYC_MERKLE_HASH_LENGTH, ENC_NA );

  offset += NETSNYC_MERKLE_HASH_LENGTH;

  offset += tvb_get_varint( tvb, offset, FT_VARINT_MAX_LEN, &len, ENC_VARINT_PROTOBUF );

  proto_tree_add_item(tree, hf_netsync_cmd_auth_sig, tvb,

        offset, (int)len, ENC_NA );

  offset += (int)len;

  return offset;

}

static int dissect_netsync_cmd_confirm(tvbuff_t *tvb,  int offset, proto_tree *tree, unsigned size _U_)

{

  uint64_t len = 0;

  offset += tvb_get_varint( tvb, offset, FT_VARINT_MAX_LEN, &len, ENC_VARINT_PROTOBUF );

  proto_tree_add_item(tree, hf_netsync_cmd_confirm_sig, tvb,

        offset, (int)len, ENC_NA );

  offset += (int)len;

  return offset;

}

static int dissect_netsync_cmd_refine(tvbuff_t *tvb,  int offset, proto_tree *tree, unsigned size)

{

  proto_tree_add_item(tree, hf_netsync_cmd_refine_tree_node, tvb,

        offset, size, ENC_NA );

  offset += size;

  return offset;

}

static int dissect_netsync_cmd_done(tvbuff_t *tvb,  int offset, proto_tree *tree, unsigned size _U_)

{

  int bytes = 0;

  proto_tree_add_item_ret_length(tree, hf_netsync_cmd_done_level, tvb,

          offset, -1, ENC_LITTLE_ENDIAN|ENC_VARINT_PROTOBUF, &bytes);

  offset += bytes;

  proto_tree_add_item(tree, hf_netsync_cmd_done_type, tvb,

        offset, 1, ENC_BIG_ENDIAN );

  offset += 1;

  return offset;

}

static int dissect_netsync_cmd_send_data(tvbuff_t *tvb,  int offset, proto_tree *tree, unsigned size _U_)

{

  proto_tree_add_item(tree, hf_netsync_cmd_send_data_type, tvb,

          offset, 1, ENC_BIG_ENDIAN );

  offset += 1;

  proto_tree_add_item(tree, hf_netsync_cmd_send_data_id, tvb,

        offset, NETSNYC_MERKLE_HASH_LENGTH, ENC_NA );

  offset += NETSNYC_MERKLE_HASH_LENGTH;

  return offset;

}

static int dissect_netsync_cmd_send_delta(tvbuff_t *tvb,  int offset, proto_tree *tree, unsigned size _U_)

{

  proto_tree_add_item(tree, hf_netsync_cmd_send_delta_type, tvb,

          offset, 1, ENC_BIG_ENDIAN );

  offset += 1;

  proto_tree_add_item(tree, hf_netsync_cmd_send_delta_base_id, tvb,

        offset, NETSNYC_MERKLE_HASH_LENGTH, ENC_NA );

  offset += NETSNYC_MERKLE_HASH_LENGTH;

  proto_tree_add_item(tree, hf_netsync_cmd_send_delta_ident_id, tvb,

        offset, NETSNYC_MERKLE_HASH_LENGTH, ENC_NA );

  offset += NETSNYC_MERKLE_HASH_LENGTH;

  return offset;

}

static int dissect_netsync_cmd_data(tvbuff_t *tvb,  int offset, proto_tree *tree, unsigned size _U_)

{

  uint64_t len = 0;

  proto_tree_add_item(tree, hf_netsync_cmd_data_type, tvb,

        offset, 1, ENC_BIG_ENDIAN );

  offset += 1;

  proto_tree_add_item(tree, hf_netsync_cmd_data_id, tvb,

        offset, NETSNYC_MERKLE_HASH_LENGTH, ENC_NA );

  offset += NETSNYC_MERKLE_HASH_LENGTH;

  proto_tree_add_item(tree, hf_netsync_cmd_data_compressed, tvb,

        offset, 1, ENC_BIG_ENDIAN );

  offset += 1;

  offset += tvb_get_varint( tvb, offset, FT_VARINT_MAX_LEN, &len, ENC_VARINT_PROTOBUF );

  proto_tree_add_item(tree, hf_netsync_cmd_data_payload, tvb,

        offset, (int)len, ENC_NA );

  offset += (int)len;

  return offset;

}

static int dissect_netsync_cmd_delta(tvbuff_t *tvb,  int offset, proto_tree *tree, unsigned size _U_)

{

  uint64_t len = 0;

  proto_tree_add_item(tree, hf_netsync_cmd_delta_type, tvb,

        offset, 1, ENC_BIG_ENDIAN );

  offset += 1;

  proto_tree_add_item(tree, hf_netsync_cmd_delta_base_id, tvb,

        offset, NETSNYC_MERKLE_HASH_LENGTH, ENC_NA );

  offset += NETSNYC_MERKLE_HASH_LENGTH;

  proto_tree_add_item(tree, hf_netsync_cmd_delta_ident_id, tvb,

        offset, NETSNYC_MERKLE_HASH_LENGTH, ENC_NA );

  offset += NETSNYC_MERKLE_HASH_LENGTH;

  proto_tree_add_item(tree, hf_netsync_cmd_delta_compressed, tvb,

        offset, 1, ENC_BIG_ENDIAN );

  offset += 1;

  offset += tvb_get_varint( tvb, offset, FT_VARINT_MAX_LEN, &len, ENC_VARINT_PROTOBUF );

  proto_tree_add_item(tree, hf_netsync_cmd_delta_payload, tvb,

        offset, (int)len, ENC_NA );

  offset += (int)len;

  return offset;

}

static int dissect_netsync_cmd_nonexistent(tvbuff_t *tvb,  int offset, proto_tree *tree, unsigned size _U_)

{

  proto_tree_add_item(tree, hf_netsync_cmd_nonexistent_type, tvb,

        offset, 1, ENC_BIG_ENDIAN );

  offset += 1;

  proto_tree_add_item(tree, hf_netsync_cmd_nonexistent_id, tvb,

        offset, NETSNYC_MERKLE_HASH_LENGTH, ENC_NA );

  offset += NETSNYC_MERKLE_HASH_LENGTH;

  return offset;

}

static unsigned

get_netsync_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset, void *data _U_)

{

  uint64_t size = 0;

  unsigned   size_bytes;

  /* skip version and command */

  offset += 2;

  size_bytes = tvb_get_varint( tvb, offset, FT_VARINT_MAX_LEN, &size, ENC_VARINT_PROTOBUF );

  /* the calculated size if for the data only, this doesn't

   * include the version (1 byte), command (1 byte),

   * length (size_bytes bytes) and checksum (4 bytes)

   */

  return 1 + 1 + size_bytes + (unsigned)size + 4;

}

static int

dissect_netsync_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)

{

  int offset = 0;

  uint8_t tmp;

  uint8_t cmd, version;

  uint32_t size, size_bytes, shift;

  proto_tree *ti,*netsync_tree=NULL;

  /* Set the protocol column */

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

  if (tree == NULL)

    return tvb_captured_length(tvb);

  while (tvb_reported_length_remaining(tvb, offset)  > 0) {

    ti = proto_tree_add_item(tree, proto_netsync, tvb, offset, -1, ENC_NA);

    netsync_tree = proto_item_add_subtree(ti, ett_netsync);

    version = tvb_get_uint8(tvb, offset);

    proto_tree_add_item(netsync_tree, hf_netsync_version, tvb,

          offset, 1, ENC_BIG_ENDIAN );

    offset += 1;

    cmd = tvb_get_uint8(tvb, offset);

    proto_tree_add_item(netsync_tree, hf_netsync_command, tvb,

          offset, 1, ENC_BIG_ENDIAN );

    offset += 1;

    /* get size */

    size = 0;

    size_bytes = 0;

    shift = 0;

    do {

      tmp = tvb_get_uint8(tvb, offset + size_bytes);

      size_bytes += 1;

      size |= (tmp & 0x7F) << shift;

      shift += 7;

    } while ((tmp & 0x80) && (shift < 32));

    proto_tree_add_uint(netsync_tree, hf_netsync_size, tvb,

            offset, size_bytes, size );

    offset += size_bytes;

    switch (cmd) {

      case NETSYNC_CMD_DONE:

        dissect_netsync_cmd_done( tvb, offset, netsync_tree, size );

        break;

      case NETSYNC_CMD_ERROR:

        dissect_netsync_cmd_error( tvb, offset, netsync_tree, size );

        break;

      case NETSYNC_CMD_BYE:

        dissect_netsync_cmd_bye( tvb, offset, netsync_tree, size );

        break;

      case NETSYNC_CMD_HELLO:

        dissect_netsync_cmd_hello( tvb, offset, netsync_tree, size );

        break;

      case NETSYNC_CMD_ANONYMOUS:

        dissect_netsync_cmd_anonymous( tvb, offset, netsync_tree, size );

        break;

      case NETSYNC_CMD_AUTH:

        dissect_netsync_cmd_auth( tvb, offset, netsync_tree, size );

        break;

      case NETSYNC_CMD_CONFIRM:

        dissect_netsync_cmd_confirm( tvb, offset, netsync_tree, size );

        break;

      case NETSYNC_CMD_REFINE:

        dissect_netsync_cmd_refine( tvb, offset, netsync_tree, size );

        break;

      case NETSYNC_CMD_SEND_DATA:

        dissect_netsync_cmd_send_data( tvb, offset, netsync_tree, size );

        break;

      case NETSYNC_CMD_SEND_DELTA:

        dissect_netsync_cmd_send_delta( tvb, offset, netsync_tree, size );

        break;

      case NETSYNC_CMD_DATA:

        dissect_netsync_cmd_data( tvb, offset, netsync_tree, size );

        break;

      case NETSYNC_CMD_DELTA:

        dissect_netsync_cmd_delta( tvb, offset, netsync_tree, size );

        break;

      case NETSYNC_CMD_NONEXISTENT:

        dissect_netsync_cmd_nonexistent( tvb, offset, netsync_tree, size );

        break;

      default:

        proto_tree_add_item(netsync_tree, hf_netsync_data, tvb,

          offset, size, ENC_NA );

        break;

    }

    offset += size;

    proto_tree_add_checksum(netsync_tree, tvb, offset, hf_netsync_checksum,

          -1, NULL, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS );

    offset += 4;

    proto_item_append_text(netsync_tree, " V%d, Cmd: %s (%d), Size: %d",

          version, val_to_str(pinfo->pool, cmd, netsync_cmd_vals, "(0x%x)"), cmd, size );

    proto_item_set_len(netsync_tree, 1+1+size_bytes+size+4);

  }

  return tvb_captured_length(tvb);

}

static int

dissect_netsync(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)

{

  tcp_dissect_pdus(tvb, pinfo, tree, netsync_desegment, 7, get_netsync_pdu_len,

          dissect_netsync_pdu, data);

  return tvb_captured_length(tvb);

}

void

proto_register_netsync(void)

{

  static hf_register_info hf[] = {

    /* General */

    { &hf_netsync_version,

      { "Version", "netsync.version",

        FT_UINT8, BASE_DEC, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_command,

      { "Command", "netsync.command",

        FT_UINT8, BASE_HEX, VALS(netsync_cmd_vals), 0x0,

        NULL, HFILL } },

    { &hf_netsync_size,

      { "Size", "netsync.size",

        FT_UINT32, BASE_DEC, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_data,

      { "Data", "netsync.data",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_checksum,

      { "Checksum", "netsync.checksum",

        FT_UINT32, BASE_HEX, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_hello_keyname,

      { "Key Name", "netsync.cmd.hello.keyname",

        FT_STRING, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_hello_key,

      { "Key", "netsync.cmd.hello.key",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_nonce,

      { "Nonce", "netsync.cmd.nonce",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_anonymous_role,

      { "Role", "netsync.cmd.anonymous.role",

        FT_UINT8, BASE_DEC, VALS(netsync_role_vals), 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_anonymous_collection,

      { "Collection", "netsync.cmd.anonymous.collection",

        FT_STRING, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_confirm_sig,

      { "Signature", "netsync.cmd.confirm.signature",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_send_data_type,

      { "Type", "netsync.cmd.send_data.type",

        FT_UINT8, BASE_DEC, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_send_data_id,

      { "ID", "netsync.cmd.send_data.id",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_error_msg,

      { "Message", "netsync.cmd.error.msg",

        FT_STRING, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_done_level,

      { "Level", "netsync.cmd.done.level",

        FT_UINT32, BASE_DEC, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_auth_role,

      { "Role", "netsync.cmd.auth.role",

        FT_UINT8, BASE_DEC, VALS(netsync_role_vals), 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_auth_collection,

      { "Collection", "netsync.cmd.auth.collection",

        FT_STRING, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_auth_id,

      { "ID", "netsync.cmd.auth.id",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_auth_nonce1,

      { "Nonce 1", "netsync.cmd.auth.nonce1",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_auth_nonce2,

      { "Nonce 2", "netsync.cmd.auth.nonce2",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_auth_sig,

      { "Signature", "netsync.cmd.auth.sig",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_data_type,

      { "Type", "netsync.cmd.data.type",

        FT_UINT8, BASE_DEC, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_data_id,

      { "ID", "netsync.cmd.data.id",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_data_compressed,

      { "Compressed", "netsync.cmd.data.compressed",

        FT_UINT8, BASE_DEC, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_data_payload,

      { "Payload", "netsync.cmd.data.payload",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_delta_type,

      { "Type", "netsync.cmd.delta.type",

        FT_UINT8, BASE_DEC, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_delta_base_id,

      { "Base ID", "netsync.cmd.delta.base_id",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_delta_ident_id,

      { "Ident ID", "netsync.cmd.delta.ident_id",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_delta_compressed,

      { "Compressed", "netsync.cmd.delta.compressed",

        FT_UINT8, BASE_DEC, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_delta_payload,

      { "Payload", "netsync.cmd.delta.payload",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_refine_tree_node,

      { "Tree Node", "netsync.cmd.refine.tree_node",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_send_delta_type,

      { "Type", "netsync.cmd.send_delta.type",

        FT_UINT8, BASE_DEC, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_send_delta_base_id,

      { "Base ID", "netsync.cmd.send_delta.base_id",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_send_delta_ident_id,

      { "Ident ID", "netsync.cmd.send_delta.ident_id",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_nonexistent_id,

      { "ID", "netsync.cmd.nonexistent.id",

        FT_BYTES, BASE_NONE, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_nonexistent_type,

      { "Type", "netsync.cmd.nonexistent.type",

        FT_UINT8, BASE_DEC, NULL, 0x0,

        NULL, HFILL } },

    { &hf_netsync_cmd_done_type,

      { "Type", "netsync.cmd.done.type",

        FT_UINT8, BASE_DEC, NULL, 0x0,

        NULL, HFILL } }

  };

  static int *ett[] = {

    &ett_netsync,

  };

  module_t *netsync_module;

  proto_netsync = proto_register_protocol("Monotone Netsync", "Netsync", "netsync");

  proto_register_field_array(proto_netsync, hf, array_length(hf));

  proto_register_subtree_array(ett, array_length(ett));

  netsync_module = prefs_register_protocol(proto_netsync, NULL);

  prefs_register_bool_preference(netsync_module, "desegment_netsync_messages",

    "Reassemble Netsync messages spanning multiple TCP segments",

    "Whether the Netsync dissector should reassemble messages spanning multiple TCP segments."

    " To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.",

    &netsync_desegment);

  netsync_handle = register_dissector("netsync", dissect_netsync, proto_netsync);

}

void

proto_reg_handoff_netsync(void)

{

  dissector_add_uint_with_preference("tcp.port", TCP_PORT_NETSYNC, netsync_handle);

}

/*

 * Editor modelines  -  https://www.wireshark.org/tools/modelines.html

 *

 * Local variables:

 * c-basic-offset: 8

 * tab-width: 8

 * indent-tabs-mode: t

 * End:

 *

 * vi: set shiftwidth=8 tabstop=8 noexpandtab:

 * :indentSize=8:tabSize=8:noTabs=false:

 */