/* packet-pcp.c

 * Routines for Performace Co-Pilot protocol dissection

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

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

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/expert.h>

#include <epan/tfs.h>

#include <wsutil/array.h>

#include "packet-tcp.h"

#include "packet-tls-utils.h"

void proto_register_pcp(void);

void proto_reg_handoff_pcp(void);

#define PCP_PORT 44321

#define PMPROXY_PORT 44322

#define PCP_HEADER_LEN 12

#define PM_ERR_NAME -12357

static dissector_handle_t pcp_handle;

static int proto_pcp;

static int hf_pcp_pdu_length;

static int hf_pcp_pdu_type;

static int hf_pcp_pdu_pid;

static int hf_pcp_pdu_error;

static int hf_pcp_pdu_padding;

static int hf_pcp_creds_number_of;

static int hf_pcp_creds_type;

static int hf_pcp_creds_version;

static int hf_pcp_start;

static int hf_pcp_start_status;

static int hf_pcp_start_zero;

static int hf_pcp_start_version;

static int hf_pcp_start_licensed;

static int hf_pcp_features_flags;

static int hf_pcp_features_flags_secure;

static int hf_pcp_features_flags_compress;

static int hf_pcp_features_flags_auth;

static int hf_pcp_features_flags_creds_reqd;

static int hf_pcp_features_flags_secure_ack;

static int hf_pcp_features_flags_no_nss_init;

static int hf_pcp_features_flags_container;

static int hf_pcp_features_flags_cert_reqd;

static int hf_pcp_features_flags_bad_label;

static int hf_pcp_features_flags_labels;

static int hf_pcp_pmns_traverse;

static int hf_pcp_pmns_subtype;

static int hf_pcp_pmns_namelen;

static int hf_pcp_pmns_name;

static int hf_pcp_pmns_names;

static int hf_pcp_pmns_names_nstrbytes;

static int hf_pcp_pmns_names_numstatus;

static int hf_pcp_pmns_names_numnames;

static int hf_pcp_pmns_names_nametree;

static int hf_pcp_pmns_names_nametree_status;

static int hf_pcp_pmns_names_nametree_namelen;

static int hf_pcp_pmns_names_nametree_name;

static int hf_pcp_pmns_ids;

static int hf_pcp_pmns_ids_status;

static int hf_pcp_pmns_ids_numids;

static int hf_pcp_pmns_child;

static int hf_pcp_pmid;

static int hf_pcp_pmid_flag;

static int hf_pcp_pmid_domain;

static int hf_pcp_pmid_cluster;

static int hf_pcp_pmid_item;

static int hf_pcp_pmid_type;

static int hf_pcp_pmid_sem;

static int hf_pcp_pmid_inst;

static int hf_pcp_profile;

static int hf_pcp_ctxnum;

static int hf_pcp_profile_g_state;

static int hf_pcp_profile_numprof;

static int hf_pcp_profile_profile;

static int hf_pcp_profile_profile_state;

static int hf_pcp_profile_profile_numinst;

static int hf_pcp_fetch;

static int hf_pcp_fetch_numpmid;

static int hf_pcp_when;

static int hf_pcp_when_sec;

static int hf_pcp_when_usec;

static int hf_pcp_desc;

static int hf_pcp_desc_req;

static int hf_pcp_units;

static int hf_pcp_units_dimspace;

static int hf_pcp_units_dimtime;

static int hf_pcp_units_dimcount;

static int hf_pcp_units_scalespace;

static int hf_pcp_units_scaletime;

static int hf_pcp_units_scalecount;

static int hf_pcp_instance;

static int hf_pcp_instance_req;

static int hf_pcp_instance_namelen;

static int hf_pcp_instance_name;

static int hf_pcp_instance_indom;

static int hf_pcp_instance_valoffset;

static int hf_pcp_instance_vallength;

static int hf_pcp_instance_value_insitu;

static int hf_pcp_instance_value_ptr;

static int hf_pcp_instance_value_int;

static int hf_pcp_instance_value_uint;

static int hf_pcp_instance_value_int64;

static int hf_pcp_instance_value_uint64;

static int hf_pcp_instance_value_float;

static int hf_pcp_instance_value_double;

static int hf_pcp_instance_value_aggr;

static int hf_pcp_instances;

static int hf_pcp_instances_numinst;

static int hf_pcp_results;

static int hf_pcp_results_numpmid;

static int hf_pcp_result;

static int hf_pcp_result_numval;

static int hf_pcp_result_valfmt;

static int hf_pcp_text_req;

static int hf_pcp_text_type;

static int hf_pcp_text_type_format;

static int hf_pcp_text_type_ident;

static int hf_pcp_text;

static int hf_pcp_text_ident;

static int hf_pcp_text_buflen;

static int hf_pcp_text_buffer;

static int hf_pcp_user_auth_payload;

static int hf_pcp_label_req;

static int hf_pcp_label;

static int hf_pcp_label_ident;

static int hf_pcp_label_type;

static int hf_pcp_label_padding;

static int hf_pcp_label_nsets;

static int hf_pcp_label_sets;

static int hf_pcp_label_sets_inst;

static int hf_pcp_label_sets_nlabels;

static int hf_pcp_label_sets_json;

static int hf_pcp_label_sets_jsonlen;

static int hf_pcp_label_sets_labels;

static int hf_pcp_label_sets_labels_nameoffset;

static int hf_pcp_label_sets_labels_namelen;

static int hf_pcp_label_sets_labels_flags;

static int hf_pcp_label_sets_labels_valueoffset;

static int hf_pcp_label_sets_labels_valuelen;

static int hf_pcp_label_sets_labels_name;

static int hf_pcp_label_sets_labels_value;

static int ett_pcp;

static int ett_pcp_pdu_length;

static int ett_pcp_pdu_type;

static int ett_pcp_pdu_pid;

static int ett_pcp_pdu_error;

static int ett_pcp_pdu_padding;

static int ett_pcp_creds_number_of;

static int ett_pcp_creds_type;

static int ett_pcp_creds_vala;

static int ett_pcp_creds_valb;

static int ett_pcp_creds_valc;

static int ett_pcp_start;

static int ett_pcp_start_status;

static int ett_pcp_start_zero;

static int ett_pcp_start_version;

static int ett_pcp_start_licensed;

static int ett_pcp_start_features;

static int ett_pcp_pmns_traverse;

static int ett_pcp_pmns_subtype;

static int ett_pcp_pmns_namelen;

static int ett_pcp_pmns_name;

static int ett_pcp_pmns_names;

static int ett_pcp_pmns_names_nstrbytes;

static int ett_pcp_pmns_names_numstatus;

static int ett_pcp_pmns_names_numnames;

static int ett_pcp_pmns_names_nametree;

static int ett_pcp_pmns_names_nametree_status;

static int ett_pcp_pmns_names_nametree_namelen;

static int ett_pcp_pmns_names_nametree_name;

static int ett_pcp_pmns_ids;

static int ett_pcp_pmns_ids_status;

static int ett_pcp_pmns_ids_numids;

static int ett_pcp_pmns_child;

static int ett_pcp_pmid;

static int ett_pcp_pmid_flag;

static int ett_pcp_pmid_domain;

static int ett_pcp_pmid_cluster;

static int ett_pcp_pmid_item;

static int ett_pcp_pmid_type;

static int ett_pcp_pmid_sem;

static int ett_pcp_profile;

static int ett_pcp_ctxnum;

static int ett_pcp_profile_g_state;

static int ett_pcp_profile_numprof;

static int ett_pcp_profile_profile;

static int ett_pcp_profile_profile_state;

static int ett_pcp_profile_profile_numinst;

static int ett_pcp_fetch;

static int ett_pcp_fetch_numpmid;

static int ett_pcp_when;

static int ett_pcp_when_sec;

static int ett_pcp_when_usec;

static int ett_pcp_desc_req;

static int ett_pcp_units;

static int ett_pcp_units_dimspace;

static int ett_pcp_units_dimtime;

static int ett_pcp_units_dimcount;

static int ett_pcp_units_scalespace;

static int ett_pcp_units_scaletime;

static int ett_pcp_units_scalecount;

static int ett_pcp_instance;

static int ett_pcp_instance_req;

static int ett_pcp_instance_namelen;

static int ett_pcp_instance_name;

static int ett_pcp_instance_inst;

static int ett_pcp_instance_indom;

static int ett_pcp_instance_valoffset;

static int ett_pcp_instance_vallength;

static int ett_pcp_instance_value_insitu;

static int ett_pcp_instance_value_ptr;

static int ett_pcp_instance_value_int;

static int ett_pcp_instance_value_uint;

static int ett_pcp_instance_value_int64;

static int ett_pcp_instance_value_uint64;

static int ett_pcp_instance_value_float;

static int ett_pcp_instance_value_double;

static int ett_pcp_instance_value_aggr;

static int ett_pcp_instances;

static int ett_pcp_instances_numinst;

static int ett_pcp_results;

static int ett_pcp_results_numpmid;

static int ett_pcp_result;

static int ett_pcp_result_numval;

static int ett_pcp_result_valfmt;

static int ett_pcp_text_req;

static int ett_pcp_text_type;

static int ett_pcp_text_type_format;

static int ett_pcp_text_type_ident;

static int ett_pcp_text;

static int ett_pcp_text_ident;

static int ett_pcp_text_buflen;

static int ett_pcp_text_buffer;

static expert_field ei_pcp_type_event_unimplemented;

static expert_field ei_pcp_type_nosupport_unsupported;

static expert_field ei_pcp_type_unknown_unknown_value;

static expert_field ei_pcp_unimplemented_value;

static expert_field ei_pcp_unimplemented_packet_type;

static expert_field ei_pcp_ssl_upgrade;

static expert_field ei_pcp_ssl_upgrade_failed;

static expert_field ei_pcp_label_error;

static expert_field ei_pcp_label_error_endianness;

/* Magic numbers */

#define PCP_SECURE_ACK_SUCCESSFUL 0

static const value_string pcp_feature_flags[] = {

#define PCP_PDU_FLAG_SECURE         0x0001

      { PCP_PDU_FLAG_SECURE,        "SECURE" },

#define PCP_PDU_FLAG_COMPRESS       0x0002

      { PCP_PDU_FLAG_COMPRESS,      "COMPRESS" },

#define PCP_PDU_FLAG_AUTH           0x0004

      { PCP_PDU_FLAG_AUTH,          "AUTH"},

#define PCP_PDU_FLAG_CREDS_REQD     0x0008

      { PCP_PDU_FLAG_CREDS_REQD,    "CREDS_REQD" },

#define PCP_PDU_FLAG_SECURE_ACK     0x0010

      { PCP_PDU_FLAG_SECURE_ACK,    "SECURE_ACK" },

#define PCP_PDU_FLAG_NO_NSS_INIT    0x0020

      { PCP_PDU_FLAG_NO_NSS_INIT,   "NO_NSS_INIT" },

#define PCP_PDU_FLAG_CONTAINER      0x0040

      { PCP_PDU_FLAG_CONTAINER,     "CONTAINER" },

#define PCP_PDU_FLAG_CERT_REQD      0x0080

      { PCP_PDU_FLAG_CERT_REQD,     "CERT_REQD" },

#define PCP_PDU_FLAG_BAD_LABEL      0x0100

      { PCP_PDU_FLAG_BAD_LABEL,     "BAD_LABEL" },

#define PCP_PDU_FLAG_LABELS         0x0200

      { PCP_PDU_FLAG_LABELS,        "LABELS" },

      { 0, NULL }

};

/* packet types */

static const value_string packettypenames[] = {

#define PCP_PDU_START_OR_ERROR  0x7000

       {PCP_PDU_START_OR_ERROR, "START/ERROR" },

#define PCP_PDU_RESULT          0x7001

       {PCP_PDU_RESULT,         "RESULT" },

#define PCP_PDU_PROFILE         0x7002

       {PCP_PDU_PROFILE,        "PROFILE"},

#define PCP_PDU_FETCH           0x7003

       {PCP_PDU_FETCH,          "FETCH"},

#define PCP_PDU_DESC_REQ        0x7004

       {PCP_PDU_DESC_REQ,       "DESC_REQ"},

#define PCP_PDU_DESC            0x7005

       {PCP_PDU_DESC,           "DESC"},

#define PCP_PDU_INSTANCE_REQ    0x7006

       {PCP_PDU_INSTANCE_REQ,   "INSTANCE_REQ" },

#define PCP_PDU_INSTANCE        0x7007

       {PCP_PDU_INSTANCE,       "INSTANCE" },

#define PCP_PDU_TEXT_REQ        0x7008

       {PCP_PDU_TEXT_REQ,       "TEXT_REQ" },

#define PCP_PDU_TEXT            0x7009

       {PCP_PDU_TEXT,           "TEXT" },

#define PCP_PDU_CONTROL_REQ     0x700a

       {PCP_PDU_CONTROL_REQ,    "CONTROL_REQ" },  /* unimplemented (pmlc/pmlogger only) */

#define PCP_PDU_DATA_X          0x700b

       {PCP_PDU_DATA_X,         "DATA_X" },       /* unimplemented (pmlc/pmlogger only) */

#define PCP_PDU_CREDS           0x700c

       {PCP_PDU_CREDS,          "CREDS" },

#define PCP_PDU_PMNS_IDS        0x700d

       {PCP_PDU_PMNS_IDS,       "PMNS_IDS" },

#define PCP_PDU_PMNS_NAMES      0x700e

       {PCP_PDU_PMNS_NAMES,     "PMNS_NAMES" },

#define PCP_PDU_PMNS_CHILD      0x700f

       {PCP_PDU_PMNS_CHILD,     "PMNS_CHILD" },

#define PCP_PDU_PMNS_TRAVERSE   0x7010 /*also type FINISH as per pcp headers, but I can not see it used */

       {PCP_PDU_PMNS_TRAVERSE,  "PMNS_TRAVERSE" },

#define PCP_PDU_USER_AUTH       0x7011

       {PCP_PDU_USER_AUTH,      "USER_AUTH" },

#define PCP_PDU_LABEL_REQ       0x7012

       {PCP_PDU_LABEL_REQ,      "LABEL_REQ" },

#define PCP_PDU_LABEL           0x7013

       {PCP_PDU_LABEL,          "LABEL" },

       { 0, NULL }

};

static const value_string packettypenames_pm_units_space[] = {

    { 0, "PM_SPACE_BYTE" },

    { 1, "PM_SPACE_KBYTE" },

    { 2, "PM_SPACE_MBYTE" },

    { 3, "PM_SPACE_GBYTE" },

    { 4, "PM_SPACE_TBYTE" },

    { 5, "PM_SPACE_PBYTE" },

    { 6, "PM_SPACE_EBYTE" },

    { 0, NULL }

};

static const value_string packettypenames_pm_units_time[] = {

    { 0, "PM_TIME_NSEC" },

    { 1, "PM_TIME_USEC" },

    { 2, "PM_TIME_MSEC" },

    { 3, "PM_TIME_SEC" },

    { 4, "PM_TIME_MIN" },

    { 5, "PM_TIME_HOUR" },

    { 0, NULL }

};

static const value_string packettypenames_pm_types[] = {

    #define PM_TYPE_NOSUPPORT    -1

    {  -1, "PM_TYPE_NOSUPPORT" },

    #define PM_TYPE_32       0

    {   0, "PM_TYPE_32" },

    #define PM_TYPE_U32      1

    {   1, "PM_TYPE_U32" },

    #define PM_TYPE_64       2

    {   2, "PM_TYPE_64" },

    #define PM_TYPE_U64      3

    {   3, "PM_TYPE_U64" },

    #define PM_TYPE_FLOAT    4

    {   4, "PM_TYPE_FLOAT" },

    #define PM_TYPE_DOUBLE   5

    {   5, "PM_TYPE_DOUBLE" },

    #define PM_TYPE_STRING   6

    {   6, "PM_TYPE_STRING" },

    #define PM_TYPE_AGGREGATE 7

    {   7, "PM_TYPE_AGGREGATE" },

    #define PM_TYPE_AGGREGATE_STATIC 8

    {   8, "PM_TYPE_AGGREGATE_STATIC" },

    #define PM_TYPE_EVENT    9

    {   9, "PM_TYPE_EVENT" },

    #define PM_TYPE_UNKNOWN  255

    { 255, "PM_TYPE_UNKNOWN" },

    {   0, NULL }

};

static const value_string packettypenames_pm_types_sem[] = {

    {  1, "PM_SEM_COUNTER" },

    {  3, "PM_SEM_INSTANT" },

    {  4, "PM_SEM_DISCRETE" },

    {  0, NULL }

};

static const value_string packettypenames_text_type_format[] = {

    #define PM_TEXT_ONELINE 1

    { 1, "PM_TEXT_ONELINE" },

    #define PM_TEXT_HELP    2

    { 2, "PM_TEXT_HELP" },

    { 0, NULL }

};

static const value_string packettypenames_text_type_ident[] = {

    #define PM_TEXT_PMID    4

    { 1, "PM_TEXT_PMID" },

    #define PM_TEXT_INDOM   8

    { 2, "PM_TEXT_INDOM" },

    { 0, NULL }

};

static const value_string packettypenames_valfmt[] = {

    #define PM_VAL_INSITU   0

    { 0, "PM_VAL_INSITU" },

    #define PM_VAL_DPTR 1

    { 1, "PM_VAL_DPTR" },

    #define PM_VAL_SPTR 2

    { 2, "PM_VAL_SPTR" },

    { 0, NULL }

};

static const value_string packettypenames_errors[] = {

    { -12345, "PM_ERR_GENERIC" },

    { -12346, "PM_ERR_PMNS" },

    { -12347, "PM_ERR_NOPMNS" },

    { -12348, "PM_ERR_DUPPMNS" },

    { -12349, "PM_ERR_TEXT" },

    { -12350, "PM_ERR_APPVERSION" },

    { -12351, "PM_ERR_VALUE" },

    { -12352, "PM_ERR_LICENSE" },

    { -12353, "PM_ERR_TIMEOUT" },

    { -12354, "PM_ERR_NODATA" },

    { -12355, "PM_ERR_RESET" },

    { -12356, "PM_ERR_FILE" },

    { PM_ERR_NAME, "PM_ERR_NAME" },

    { -12358, "PM_ERR_PMID" },

    { -12359, "PM_ERR_INDOM" },

    { -12360, "PM_ERR_INST" },

    { -12361, "PM_ERR_UNIT" },

    { -12362, "PM_ERR_CONV" },

    { -12363, "PM_ERR_TRUNC" },

    { -12364, "PM_ERR_SIGN" },

    { -12365, "PM_ERR_PROFILE" },

    { -12366, "PM_ERR_IPC" },

    { -12367, "PM_ERR_NOASCII" },

    { -12368, "PM_ERR_EOF" },

    { -12369, "PM_ERR_NOTHOST" },

    { -12370, "PM_ERR_EOL" },

    { -12371, "PM_ERR_MODE" },

    { -12372, "PM_ERR_LABEL" },

    { -12373, "PM_ERR_LOGREC" },

    { -12374, "PM_ERR_NOTARCHIVE" },

    { -12375, "PM_ERR_LOGFILE" },

    { -12376, "PM_ERR_NOCONTEXT" },

    { -12377, "PM_ERR_PROFILESPEC" },

    { -12378, "PM_ERR_PMID_LOG" },

    { -12379, "PM_ERR_INDOM_LOG" },

    { -12380, "PM_ERR_INST_LOG" },

    { -12381, "PM_ERR_NOPROFILE" },

    { -12386, "PM_ERR_NOAGENT" },

    { -12387, "PM_ERR_PERMISSION" },

    { -12388, "PM_ERR_CONNLIMIT" },

    { -12389, "PM_ERR_AGAIN" },

    { -12390, "PM_ERR_ISCONN" },

    { -12391, "PM_ERR_NOTCONN" },

    { -12392, "PM_ERR_NEEDPORT" },

    { -12393, "PM_ERR_WANTACK" },

    { -12394, "PM_ERR_NONLEAF" },

    { -12395, "PM_ERR_OBJSTYLE" },

    { -12396, "PM_ERR_PMCDLICENSE" },

    { -12397, "PM_ERR_TYPE" },

    { -12442, "PM_ERR_CTXBUSY" },

    { -12443, "PM_ERR_TOOSMALL" },

    { -12444, "PM_ERR_TOOBIG" },

    { -13393, "PM_ERR_PMDAREADY" },

    { -13394, "PM_ERR_PMDANOTREADY" },

    { -21344, "PM_ERR_NYI" },

    {      0, NULL }

};

static const value_string packettypenames_creds[]= {

    { 1, "CVERSION" },

    { 2, "CAUTH" },

    { 0, NULL }

};

static const value_string packettypenames_label_req_type[]= {

    { 1,  "PM_LABEL_CONTEXT" },

    { 2,  "PM_LABEL_DOMAIN" },

    { 4,  "PM_LABEL_INDOM" },

    { 8,  "PM_LABEL_CLUSTER" },

    { 16, "PM_LABEL_ITEM" },

    { 32, "PM_LABEL_INSTANCES" },

    { 0,  NULL }

};

typedef struct pcp_conv_info_t {

    wmem_array_t *pmid_name_candidates;

    wmem_map_t *pmid_to_name;

    uint32_t last_pmns_names_frame;

    uint32_t last_processed_pmns_names_frame;

    bool using_good_labels;

} pcp_conv_info_t;

/* function prototypes */

static pcp_conv_info_t* get_pcp_conversation_info(packet_info *pinfo);

static int is_unvisited_pmns_names_frame(packet_info *pinfo);

static bool is_using_good_labels(packet_info *pinfo);

static bool label_value_length_looks_like_wrong_endianness(tvbuff_t *tvb, uint16_t value_offset, uint16_t value_length);

static void add_candidate_name_for_pmid_resolution(packet_info *pinfo, tvbuff_t *tvb, int offset, int name_len);

static void mark_this_frame_as_last_pmns_names_frame(packet_info *pinfo);

static inline int has_unprocessed_pmns_names_frame(pcp_conv_info_t *pcp_conv_info);

static void create_pmid_to_name_map_from_candidates(pcp_conv_info_t *pcp_conv_info, tvbuff_t *tvb, int offset, uint32_t num_ids);

static void populate_pmids_to_names(packet_info *pinfo, tvbuff_t *tvb, int offset, uint32_t num_ids);

static inline int client_to_server(packet_info *pinfo);

static inline int server_to_client(packet_info *pinfo);

static uint8_t* get_name_from_pmid(uint32_t pmid, packet_info *pinfo);

static unsigned get_pcp_message_len(packet_info *pinfo, tvbuff_t *tvb, int offset, void *data);

static const char *get_pcp_features_to_string(wmem_allocator_t *pool, uint16_t feature_flags);

static int dissect_pcp_message_creds(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_error(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_start(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_pmns_traverse(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_pmns_names(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_pmns_child(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_pmns_ids(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_profile(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_fetch(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_result(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_desc_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_desc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_instance_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_instance(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_text_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_text(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_message_user_auth(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_partial_pmid(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_partial_when(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_partial_features(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset);

static int dissect_pcp_partial_label(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, uint32_t json_start_offset);

static int dissect_pcp_partial_labelset(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, int offset);

/* message length for dissect_tcp */

static unsigned get_pcp_message_len(packet_info *pinfo _U_, tvbuff_t *tvb,

                                 int offset, void *data _U_)

{

    /* length is at the very start of the packet, after tcp header */

    return (unsigned)tvb_get_ntohl(tvb, offset);

}

static void mark_this_frame_as_last_pmns_names_frame(packet_info *pinfo) {

    pcp_conv_info_t *pcp_conv_info;

    pcp_conv_info = get_pcp_conversation_info(pinfo);

    if(pinfo->num > pcp_conv_info->last_pmns_names_frame) {

        pcp_conv_info->last_pmns_names_frame = pinfo->num;

    }

}

static inline int has_unprocessed_pmns_names_frame(pcp_conv_info_t *pcp_conv_info) {

    return pcp_conv_info->last_pmns_names_frame > pcp_conv_info->last_processed_pmns_names_frame;

}

static inline int client_to_server(packet_info *pinfo) {

    return pinfo->destport == PCP_PORT || pinfo->destport == PMPROXY_PORT;

}

static inline int server_to_client(packet_info *pinfo) {

    return !client_to_server(pinfo);

}

static uint8_t* get_name_from_pmid(uint32_t pmid, packet_info *pinfo) {

    uint8_t *name;

    wmem_map_t *pmid_to_name;

    pmid_to_name = get_pcp_conversation_info(pinfo)->pmid_to_name;

    name = (uint8_t*)wmem_map_lookup(pmid_to_name, GINT_TO_POINTER(pmid));

    if(!name) {

        name = (uint8_t*)wmem_strdup(pinfo->pool, "Metric name unknown");

    }

    return name;

}

static const char *get_pcp_features_to_string(wmem_allocator_t *pool, uint16_t feature_flags)

{

    const value_string *flag_under_test;

    wmem_strbuf_t *string_buffer;

    size_t string_length;

    string_buffer = wmem_strbuf_new(pool, "");

    /* Build the comma-separated list of feature flags as a string. EG 'SECURE, COMPRESS, AUTH, ' */

    flag_under_test = &pcp_feature_flags[0];

    while (flag_under_test->value) {

        if (feature_flags & flag_under_test->value) {

            wmem_strbuf_append_printf(string_buffer, "%s, ", flag_under_test->strptr);

        }

        flag_under_test++;

    }

    /* Cleanup the last remaining ', ' from the string */

    string_length = wmem_strbuf_get_len(string_buffer);

    if (string_length > 2) {

        wmem_strbuf_truncate(string_buffer, string_length - 2);

    }

    return wmem_strbuf_get_str(string_buffer);

}

static pcp_conv_info_t* get_pcp_conversation_info(packet_info *pinfo) {

    conversation_t  *conversation;

    pcp_conv_info_t *pcp_conv_info;

    conversation = find_conversation_pinfo(pinfo, 0);

    /* Conversation setup is done in the main dissecting routine so it should never be null */

    DISSECTOR_ASSERT(conversation);

    pcp_conv_info = (pcp_conv_info_t *)conversation_get_proto_data(conversation, proto_pcp);

    /* Conversation data is initialized when creating the conversation so should never be null */

    DISSECTOR_ASSERT(pcp_conv_info);

    return pcp_conv_info;

}

static void add_candidate_name_for_pmid_resolution(packet_info *pinfo, tvbuff_t *tvb, int offset, int name_len) {

    pcp_conv_info_t *pcp_conv_info;

    uint8_t *name;

    pcp_conv_info = get_pcp_conversation_info(pinfo);

    if(is_unvisited_pmns_names_frame(pinfo)) {

        name = tvb_get_string_enc(wmem_file_scope(), tvb, offset, name_len, ENC_ASCII);

        wmem_array_append_one(pcp_conv_info->pmid_name_candidates, name);

    }

}

static int is_unvisited_pmns_names_frame(packet_info *pinfo) {

    pcp_conv_info_t *pcp_conv_info;

    pcp_conv_info = get_pcp_conversation_info(pinfo);

    return pinfo->num > pcp_conv_info->last_processed_pmns_names_frame && pinfo->num > pcp_conv_info->last_pmns_names_frame;

}

static void populate_pmids_to_names(packet_info *pinfo, tvbuff_t *tvb, int offset, uint32_t num_ids) {

    pcp_conv_info_t *pcp_conv_info;

    unsigned number_of_name_candidates;

    pcp_conv_info = get_pcp_conversation_info(pinfo);

    number_of_name_candidates = wmem_array_get_count(pcp_conv_info->pmid_name_candidates);

    if(number_of_name_candidates == num_ids && has_unprocessed_pmns_names_frame(pcp_conv_info)) {

        create_pmid_to_name_map_from_candidates(pcp_conv_info, tvb, offset, num_ids);

        /* Set this frame to the one that we processed */

        pcp_conv_info->last_processed_pmns_names_frame = pcp_conv_info->last_pmns_names_frame;

    }

    pcp_conv_info->pmid_name_candidates = wmem_array_new(wmem_file_scope(), sizeof(uint8_t *));

}

static void create_pmid_to_name_map_from_candidates(pcp_conv_info_t *pcp_conv_info, tvbuff_t *tvb, int offset, uint32_t num_ids) {

    uint32_t i;

    for(i=0; i<num_ids; i++) {

        uint32_t pmid;

        uint8_t *pmid_name;

        pmid = tvb_get_ntohl(tvb, offset);

        pmid_name = *(uint8_t **)wmem_array_index(pcp_conv_info->pmid_name_candidates, i);

        if(wmem_map_lookup(pcp_conv_info->pmid_to_name, GINT_TO_POINTER(pmid)) == NULL) {

            wmem_map_insert(pcp_conv_info->pmid_to_name, GINT_TO_POINTER(pmid), pmid_name);

        }

        offset += 4;

    }

}

static int dissect_pcp_message_creds(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)

{

    uint32_t creds_length;

    uint32_t i;

    /* append the type of packet */

    col_append_fstr(pinfo->cinfo, COL_INFO, "[%s]",

                    val_to_str(PCP_PDU_CREDS, packettypenames, "Unknown Type:0x%02x"));

    /* first is the number of creds */

    proto_tree_add_item(tree, hf_pcp_creds_number_of, tvb, offset, 4, ENC_BIG_ENDIAN);

    /* store the number of creds so we know how long to interate for */

    creds_length = tvb_get_ntohl(tvb, offset);

    offset += 4;

    /* go through each __pmVersionCred struct */

    for (i = 0; i < creds_length; i++) {

        /* __pmVersionCred.c_type */

        proto_tree_add_item(tree, hf_pcp_creds_type, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        /* __pmVersionCred.c_version */

        proto_tree_add_item(tree, hf_pcp_creds_version, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        /* __pmVersionCred.c_flags */

        offset = dissect_pcp_partial_features(tvb, pinfo, tree, offset);

    }

    return offset;

}

/* ERROR packet format:

    signed int error

 */

static int dissect_pcp_message_error(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)

{

    int32_t error_num;

    pcp_conv_info_t *pcp_conv_info;

    /* append the type of packet, we can't look this up as it clashes with START */

    col_append_str(pinfo->cinfo, COL_INFO, "[ERROR] ");

    /* add the error item to the tree and column */

    proto_tree_add_item(tree, hf_pcp_pdu_error, tvb, offset, 4, ENC_BIG_ENDIAN);

    error_num = tvb_get_ntohl(tvb, offset);

    col_append_fstr(pinfo->cinfo, COL_INFO, "error=%s ",

                    val_to_str(error_num, packettypenames_errors, "Unknown Error:%i"));

    offset += 4;

    /* Clean out candidate names if we got an error from a PMNS_NAMES lookup. This will allow subsequent PMNS_NAMES

       lookups to work in the same conversation

     */

    if(error_num == PM_ERR_NAME) {

        pcp_conv_info = get_pcp_conversation_info(pinfo);

        pcp_conv_info->pmid_name_candidates = wmem_array_new(wmem_file_scope(), sizeof(uint8_t *));

    }

    return offset;

}

/* START packet format:

    unsigned int    sts,

    struct          __pmPDUInfo

     |

     |> unsigned int    zero : 1 bit

        unsigned int    version : 7 bits

        unsigned int    licensed : 8 bits

        unsigned int    features : 16 bits

*/

static int dissect_pcp_message_start(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)

{

    /* create a start tree to hold the information*/

    proto_item *pcp_start_item;

    proto_tree *pcp_start_tree;

    uint32_t    status;

    pcp_start_item = proto_tree_add_item(tree, hf_pcp_start, tvb, 0, -1, ENC_NA);

    pcp_start_tree = proto_item_add_subtree(pcp_start_item, ett_pcp);

    /* append the type of packet, we can't look this up as it clashes with ERROR */

    col_append_str(pinfo->cinfo, COL_INFO, "[START]");

    /* status */

    status = tvb_get_ntohl(tvb, offset);

    proto_tree_add_item(pcp_start_tree, hf_pcp_start_status, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    if(tvb_reported_length_remaining(tvb, offset) == 0){

        /* Most likely we're in a SSL upgrade if this is the end of the start packet */

        if(status == PCP_SECURE_ACK_SUCCESSFUL) {

            expert_add_info(pinfo, tree, &ei_pcp_ssl_upgrade);

            ssl_starttls_ack(find_dissector("tls"), pinfo, pcp_handle);

        }

        else {

            expert_add_info(pinfo, tree, &ei_pcp_ssl_upgrade_failed);

        }

    }

    else {

        /* zero bit and version bits */

        proto_tree_add_item(pcp_start_tree, hf_pcp_start_zero, tvb, offset, 1, ENC_BIG_ENDIAN);

        proto_tree_add_item(pcp_start_tree, hf_pcp_start_version, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        /* licensed */

        proto_tree_add_item(pcp_start_tree, hf_pcp_start_licensed, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        /* features */

        offset = dissect_pcp_partial_features(tvb, pinfo, pcp_start_tree, offset);

    }

    return offset;

}

/* PMNS_TRAVERSE packet format:

    uint32_t subtype

    uint32_t namelen

    char name[sizeof(namelen)] + padding

*/

static int dissect_pcp_message_pmns_traverse(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)

{

    proto_item *pcp_pmns_traverse_item;

    proto_tree *pcp_pmns_traverse_tree;

    uint32_t    name_len;

    uint32_t    padding;

    /* append the type of packet */

    col_append_fstr(pinfo->cinfo, COL_INFO, "[%s]",

                    val_to_str(PCP_PDU_PMNS_TRAVERSE, packettypenames, "Unknown Type:0x%02x"));

    pcp_pmns_traverse_item = proto_tree_add_item(tree, hf_pcp_pmns_traverse, tvb, offset, -1, ENC_NA);

    pcp_pmns_traverse_tree = proto_item_add_subtree(pcp_pmns_traverse_item, ett_pcp);

    /* subtype */

    proto_tree_add_item(pcp_pmns_traverse_tree, hf_pcp_pmns_subtype, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    /* namelen */

    proto_tree_add_item(pcp_pmns_traverse_tree, hf_pcp_pmns_namelen, tvb, offset, 4, ENC_BIG_ENDIAN);

    name_len = tvb_get_ntohl(tvb, offset); /* get the actual length out so we can use it in the next item */

    offset += 4;

    /* name */

    proto_tree_add_item(pcp_pmns_traverse_tree, hf_pcp_pmns_name, tvb, offset, name_len, ENC_ASCII);

    offset += name_len; /* increment by whatever the length of the name string was */

    /* "padding" (not really padding, just what is left over in the old buffer) */

    padding = name_len % 4; /* names are padded to the nearest 4 byte boundary */

    if (padding != 0) { /* if there is padding, keep going till the remainder of mod 4 */

        padding = 4 - padding; /* we want the inverse of the remainder */

        proto_tree_add_item(pcp_pmns_traverse_tree, hf_pcp_pdu_padding, tvb, offset, padding, ENC_NA);

        offset += padding;

    }

    return offset;

}

/* PMNS_NAMES packet format:

    uint32_t    nstrbytes (number of str bytes)

    uint32_t    numstatus (0 if no status. Also, if 0, use name_t, otherwise use name_status_t )

    uint32_t    numnames

    __pmPDU     names (if numstatus = 0, filled with name_t, otherwise name_status_t)

    | |

    | |> -- name_t --

    |    int namelen

    |    char name[sizeof(namelen)]

    |

    |>  -- name_status_t --

        int status

        int namelen

        char name[sizeof(namelen)]

*/

static int dissect_pcp_message_pmns_names(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)

{

    proto_item *pcp_pmns_names_item;

    proto_tree *pcp_pmns_names_tree;

    proto_item *pcp_pmns_names_name_item;

    proto_tree *pcp_pmns_names_name_tree;

    uint32_t    is_pmns_names_status;

    uint32_t    num_names;

    uint32_t    name_len;

    uint32_t    full_name_len;

    uint32_t    padding;

    uint32_t    i;

    /* append the type of packet */

    col_append_fstr(pinfo->cinfo, COL_INFO, "[%s]", val_to_str(PCP_PDU_PMNS_NAMES, packettypenames, "Unknown Type:0x%02x"));

    pcp_pmns_names_item = proto_tree_add_item(tree, hf_pcp_pmns_names, tvb, offset, -1, ENC_NA);

    pcp_pmns_names_tree = proto_item_add_subtree(pcp_pmns_names_item, ett_pcp);

    /* nstrbytes */

    proto_tree_add_item(pcp_pmns_names_tree, hf_pcp_pmns_names_nstrbytes, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    /* numstatus */

    proto_tree_add_item(pcp_pmns_names_tree, hf_pcp_pmns_names_numstatus, tvb, offset, 4, ENC_BIG_ENDIAN);

    is_pmns_names_status = tvb_get_ntohl(tvb, offset); /* is the status also present in this PDU? */

    offset += 4;

    /* numnames */

    proto_tree_add_item(pcp_pmns_names_tree, hf_pcp_pmns_names_numnames, tvb, offset, 4, ENC_BIG_ENDIAN);

    num_names = tvb_get_ntohl(tvb, offset); /* get the number of names to iterate through */

    offset += 4;

    /* nametrees */

    for (i=0; i < num_names; i++) {

        /* find out the size of the name_t/name_status_t before we create the tree */

        if (is_pmns_names_status) {

            name_len = tvb_get_ntohl(tvb, offset+4);

            full_name_len = name_len + 8;

        } else {

            name_len = tvb_get_ntohl(tvb, offset);

            full_name_len = name_len + 4;

        }

        /* add a new subtree for each name */

        pcp_pmns_names_name_item = proto_tree_add_item(pcp_pmns_names_tree, hf_pcp_pmns_names_nametree,

                                                       tvb, offset, full_name_len, ENC_NA);

        pcp_pmns_names_name_tree = proto_item_add_subtree(pcp_pmns_names_name_item, ett_pcp);

        if (is_pmns_names_status) {

            /* print out the name status and increment if we're supposed to have it */

            proto_tree_add_item(pcp_pmns_names_name_tree, hf_pcp_pmns_names_nametree_status,

                                tvb, offset, 4, ENC_BIG_ENDIAN);

            offset += 4;

        }

        /* namelen */

        proto_tree_add_item(pcp_pmns_names_name_tree, hf_pcp_pmns_names_nametree_namelen,

                            tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        /* name */

        if(client_to_server(pinfo)) {

            add_candidate_name_for_pmid_resolution(pinfo, tvb, offset, name_len);

        }

        proto_tree_add_item(pcp_pmns_names_name_tree, hf_pcp_pmns_names_nametree_name,

                            tvb, offset, name_len, ENC_ASCII);

        offset += name_len;

        /* padding */

        padding = name_len % 4; /* names are padded to the nearest 4 byte boundary */

        if (padding != 0) {

            padding = 4 - padding; /* we want the inverse of the remainder */

            /* if there is padding, keep going till the remainder of mod 8 */

            proto_tree_add_item(pcp_pmns_names_name_tree, hf_pcp_pdu_padding, tvb, offset, padding, ENC_NA);

            offset += padding;

        }

    }

    if(client_to_server(pinfo)) {

        mark_this_frame_as_last_pmns_names_frame(pinfo);

    }

    return offset;

}

/* PMNS_CHILD packet format:

    uint32_t subtype

    uint32_t namelen

    char name[namelen]

*/

static int dissect_pcp_message_pmns_child(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)

{

    proto_item *pcp_pmns_child_item;

    proto_tree *pcp_pmns_child_tree;

    uint32_t    name_len;

    pcp_pmns_child_item = proto_tree_add_item(tree, hf_pcp_pmns_child, tvb, offset, -1, ENC_NA);

    pcp_pmns_child_tree = proto_item_add_subtree(pcp_pmns_child_item, ett_pcp);

    /* append the type of packet */

    col_append_fstr(pinfo->cinfo, COL_INFO, "[%s]", val_to_str(PCP_PDU_PMNS_CHILD, packettypenames, "Unknown Type:0x%02x"));

    /* subtype */

    proto_tree_add_item(pcp_pmns_child_tree, hf_pcp_pmns_subtype, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    /* namelen */

    proto_tree_add_item(pcp_pmns_child_tree, hf_pcp_pmns_namelen, tvb, offset, 4, ENC_BIG_ENDIAN);

    name_len = tvb_get_ntohl(tvb, offset); /* length of the next value */

    offset += 4;

    /* name */

    proto_tree_add_item(pcp_pmns_child_tree, hf_pcp_pmns_name, tvb, offset, name_len, ENC_ASCII);

    offset += 4;

    return offset;

}

/* PMNS_IDS packet format

    uint32_t status

    uint32_t numids

    pmID    idlist[numids] (where pmID = uint32)

*/

static int dissect_pcp_message_pmns_ids(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)

{

    proto_item *pcp_pmns_ids_item;

    proto_tree *pcp_pmns_ids_tree;

    uint32_t    num_ids;

    uint32_t    i;

    /* append the type of packet */

    col_append_fstr(pinfo->cinfo, COL_INFO, "[%s]",

                    val_to_str(PCP_PDU_PMNS_IDS, packettypenames, "Unknown Type:0x%02x"));

    pcp_pmns_ids_item = proto_tree_add_item(tree, hf_pcp_pmns_ids, tvb, offset, -1, ENC_NA);

    pcp_pmns_ids_tree = proto_item_add_subtree(pcp_pmns_ids_item, ett_pcp);

    /* status */

    proto_tree_add_item(pcp_pmns_ids_tree, hf_pcp_pmns_ids_status, tvb, offset, 4, ENC_BIG_ENDIAN);

    offset += 4;

    /* numids */

    proto_tree_add_item(pcp_pmns_ids_tree, hf_pcp_pmns_ids_numids, tvb, offset, 4, ENC_BIG_ENDIAN);

    num_ids = tvb_get_ntohl(tvb, offset);

    offset += 4;

    /* Populate the PMID to name mapping */

    populate_pmids_to_names(pinfo, tvb, offset, num_ids);

    /* pmIDs */

    for (i=0; i<num_ids; i++) {

        /* pmID */

        offset = dissect_pcp_partial_pmid(tvb, pinfo, pcp_pmns_ids_tree, offset);

    }

    return offset;

}

/*  PROFILE packet format

    uint32_t    ctxnum;

    uint32_t    g_state;

    uint32_t    numprof;

    uint32_t    pad;

    pmProfile   profiles[numprof]

      |

      |> pmInDom indom;

         int     state;

         int     numinst;

         int     pad;

*/

static int dissect_pcp_message_profile(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)

{

    proto_item *pcp_profile_item;

    proto_tree *pcp_profile_tree;

    proto_item *pcp_profile_profile_item;

    proto_tree *pcp_profile_profile_tree;

    uint32_t    num_prof;

    uint32_t    i;

    /* append the type of packet */

    col_append_fstr(pinfo->cinfo, COL_INFO, "[%s]", val_to_str(PCP_PDU_PROFILE, packettypenames, "Unknown Type:0x%02x"));

    pcp_profile_item = proto_tree_add_item(tree, hf_pcp_profile, tvb, offset, -1, ENC_NA);

    pcp_profile_tree = proto_item_add_subtree(pcp_profile_item, ett_pcp);