/* packet-mpls-pm.c

 *

 * Routines for MPLS delay and loss measurement: it should conform

 * to RFC 6374.  'PM' stands for Performance Measurement.

 *

 * Copyright 2012 _FF_

 *

 * Francesco Fondelli <francesco dot fondelli, gmail dot com>

 *

 * 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/tfs.h>

#include <wsutil/array.h>

#include "packet-ip.h"

#include "packet-mpls.h"

void proto_register_mpls_pm(void);

void proto_reg_handoff_mpls_pm(void);

/* message control flags */

#define MPLS_PM_FLAGS_R     0x08

#define MPLS_PM_FLAGS_T     0x04

#define MPLS_PM_FLAGS_RES   0x03

#define MPLS_PM_FLAGS_MASK  0x0F

/* data format flags */

#define MPLS_PM_DFLAGS_X    0x80

#define MPLS_PM_DFLAGS_B    0x40

#define MPLS_PM_DFLAGS_RES  0x30

#define MPLS_PM_DFLAGS_MASK 0xF0

static int proto_mpls_pm_dlm;

static int proto_mpls_pm_ilm;

static int proto_mpls_pm_dm;

static int proto_mpls_pm_dlm_dm;

static int proto_mpls_pm_ilm_dm;

static int ett_mpls_pm;

static int ett_mpls_pm_flags;

static int ett_mpls_pm_dflags;

static int hf_mpls_pm_version;

static int hf_mpls_pm_flags;

static int hf_mpls_pm_flags_r;

static int hf_mpls_pm_flags_t;

static int hf_mpls_pm_flags_res;

static int hf_mpls_pm_query_ctrl_code;

static int hf_mpls_pm_response_ctrl_code;

static int hf_mpls_pm_length;

static int hf_mpls_pm_dflags;

static int hf_mpls_pm_dflags_x;

static int hf_mpls_pm_dflags_b;

static int hf_mpls_pm_dflags_res;

static int hf_mpls_pm_otf;

static int hf_mpls_pm_session_id;

static int hf_mpls_pm_ds;

static int hf_mpls_pm_origin_timestamp_null;

static int hf_mpls_pm_origin_timestamp_seq;

static int hf_mpls_pm_origin_timestamp_ntp;

static int hf_mpls_pm_origin_timestamp_ptp;

static int hf_mpls_pm_origin_timestamp_unk;

static int hf_mpls_pm_counter1;

static int hf_mpls_pm_counter2;

static int hf_mpls_pm_counter3;

static int hf_mpls_pm_counter4;

static int hf_mpls_pm_qtf;

static int hf_mpls_pm_qtf_combined;

static int hf_mpls_pm_rtf;

static int hf_mpls_pm_rtf_combined;

static int hf_mpls_pm_rptf;

static int hf_mpls_pm_rptf_combined;

static int hf_mpls_pm_timestamp1_q_null;

static int hf_mpls_pm_timestamp1_r_null;

static int hf_mpls_pm_timestamp1_q_seq;

static int hf_mpls_pm_timestamp1_r_seq;

static int hf_mpls_pm_timestamp1_q_ntp;

static int hf_mpls_pm_timestamp1_r_ntp;

static int hf_mpls_pm_timestamp1_q_ptp;

static int hf_mpls_pm_timestamp1_r_ptp;

static int hf_mpls_pm_timestamp1_unk;

static int hf_mpls_pm_timestamp2_q_null;

static int hf_mpls_pm_timestamp2_r_null;

static int hf_mpls_pm_timestamp2_q_seq;

static int hf_mpls_pm_timestamp2_r_seq;

static int hf_mpls_pm_timestamp2_q_ntp;

static int hf_mpls_pm_timestamp2_r_ntp;

static int hf_mpls_pm_timestamp2_q_ptp;

static int hf_mpls_pm_timestamp2_r_ptp;

static int hf_mpls_pm_timestamp2_unk;

static int hf_mpls_pm_timestamp3_null;

static int hf_mpls_pm_timestamp3_r_null;

static int hf_mpls_pm_timestamp3_r_seq;

static int hf_mpls_pm_timestamp3_r_ntp;

static int hf_mpls_pm_timestamp3_r_ptp;

static int hf_mpls_pm_timestamp3_unk;

static int hf_mpls_pm_timestamp4_null;

static int hf_mpls_pm_timestamp4_r_null;

static int hf_mpls_pm_timestamp4_r_seq;

static int hf_mpls_pm_timestamp4_r_ntp;

static int hf_mpls_pm_timestamp4_r_ptp;

static int hf_mpls_pm_timestamp4_unk;

/*

 * FF: please keep this list in sync with

 * http://www.iana.org/assignments/mpls-lsp-ping-parameters

 * Registry Name: 'Loss/Delay Measurement Control Code: Query Codes'

 */

static const range_string mpls_pm_query_ctrl_code_rvals[] = {

    { 0x00, 0x00, "In-band Response Requested"     },

    { 0x01, 0x01, "Out-of-band Response Requested" },

    { 0x02, 0x02, "No Response Requested"          },

    { 0x03, 0xFF, "Unassigned"                     },

    { 0x00, 0x00, NULL                             }

};

/*

 * FF: please keep this list in sync with

 * http://www.iana.org/assignments/mpls-lsp-ping-parameters

 * Registry Name: 'Loss/Delay Measurement Control Code: Response Codes'

 */

static const range_string mpls_pm_response_ctrl_code_rvals[] = {

    { 0x00, 0x00, "Reserved"                            },

    { 0x01, 0x01, "Success"                             },

    { 0x02, 0x02, "Data Format Invalid"                 },

    { 0x03, 0x03, "Initialization in Progress"          },

    { 0x04, 0x04, "Data Reset Occurred"                 },

    { 0x05, 0x05, "Resource Temporarily Unavailable"    },

    { 0x06, 0x0F, "Unassigned"                          },

    { 0x10, 0x10, "Unspecified Error"                   },

    { 0x11, 0x11, "Unsupported Version"                 },

    { 0x12, 0x12, "Unsupported Control Code"            },

    { 0x13, 0x13, "Unsupported Data Format"             },

    { 0x14, 0x14, "Authentication Failure"              },

    { 0x15, 0x15, "Invalid Destination Node Identifier" },

    { 0x16, 0x16, "Connection Mismatch"                 },

    { 0x17, 0x17, "Unsupported Mandatory TLV Object"    },

    { 0x18, 0x18, "Unsupported Query Interval"          },

    { 0x19, 0x19, "Administrative Block"                },

    { 0x1A, 0x1A, "Resource Unavailable"                },

    { 0x1B, 0x1B, "Resource Released"                   },

    { 0x1C, 0x1C, "Invalid Message"                     },

    { 0x1D, 0x1D, "Protocol Error"                      },

    { 0x1E, 0xFF, "Unassigned"                          },

    { 0x00, 0x00, NULL                                  }

};

#define DLM 1

#define ILM 2

#define DM 3

#define DLMDM 4

#define ILMDM 5

/* FF: internal */

static const value_string pmt_vals[] = {

    { DLM,   "DLM"    },

    { ILM,   "ILM"    },

    { DM,    "DM"     },

    { DLMDM, "DLM+DM" },

    { ILMDM, "ILM+DM" },

    {     0, NULL     }

};

/*

 * FF: please keep this list in sync with

 * http://www.iana.org/assignments/mpls-lsp-ping-parameters

 * Registry Name: 'Loss/Delay Measurement Control Code: Response Codes'

 */

#define MPLS_PM_TSF_NULL 0

#define MPLS_PM_TSF_SEQ 1

#define MPLS_PM_TSF_NTP 2

#define MPLS_PM_TSF_PTP 3

static const range_string mpls_pm_time_stamp_format_rvals[] = {

    { MPLS_PM_TSF_NULL, MPLS_PM_TSF_NULL,

      "Null Timestamp"                                   },

    { MPLS_PM_TSF_SEQ, MPLS_PM_TSF_SEQ,

      "Sequence Number"                                  },

    { MPLS_PM_TSF_NTP, MPLS_PM_TSF_NTP,

      "Network Time Protocol version 4 64-bit Timestamp" },

    { MPLS_PM_TSF_PTP, MPLS_PM_TSF_PTP,

      "Truncated IEEE 1588v2 PTP Timestamp"              },

    { 4, 15, "Unassigned"                                },

    { 0,  0, NULL                                        }

};

static void

mpls_pm_dissect_counter(tvbuff_t *tvb, proto_tree *pm_tree,

                        uint32_t offset, bool query, bool bflag,

                        uint8_t i)

{

    proto_item *ti;

    /*

     *  FF: when bflag is true, indicates that the Counter 1-4

     *  fields represent octet counts.  Otherwise Counter 1-4 fields

     *  represent packet counts

     */

    const char *unit = bflag ? "octets" : "packets";

    if (query) {

        switch (i) {

        case 1:

            ti = proto_tree_add_item(pm_tree, hf_mpls_pm_counter1, tvb,

                                     offset, 8, ENC_BIG_ENDIAN);

            proto_item_append_text(ti, " %s (A_Tx)", unit);

            break;

        case 2:

            proto_tree_add_item(pm_tree, hf_mpls_pm_counter2, tvb,

                                offset, 8, ENC_BIG_ENDIAN);

            break;

        case 3:

            proto_tree_add_item(pm_tree, hf_mpls_pm_counter3, tvb,

                                offset, 8, ENC_BIG_ENDIAN);

            break;

        case 4:

            proto_tree_add_item(pm_tree, hf_mpls_pm_counter4, tvb,

                                offset, 8, ENC_BIG_ENDIAN);

            break;

        default:

            /* never here */

            break;

        }

    } else {

        /* response */

        switch (i) {

        case 1:

            ti = proto_tree_add_item(pm_tree, hf_mpls_pm_counter1, tvb,

                                     offset, 8, ENC_BIG_ENDIAN);

            proto_item_append_text(ti, " %s (B_Tx)", unit);

            break;

        case 2:

            proto_tree_add_item(pm_tree, hf_mpls_pm_counter2, tvb,

                                offset, 8, ENC_BIG_ENDIAN);

            break;

        case 3:

            ti = proto_tree_add_item(pm_tree, hf_mpls_pm_counter3, tvb,

                                         offset, 8, ENC_BIG_ENDIAN);

            proto_item_append_text(ti, " %s (A_Tx)", unit);

            break;

        case 4:

            ti = proto_tree_add_item(pm_tree, hf_mpls_pm_counter4, tvb,

                                         offset, 8, ENC_BIG_ENDIAN);

            proto_item_append_text(ti, " %s (B_Rx)", unit);

            break;

        default:

            /* never here */

            break;

        }

    }

}

static void

mpls_pm_dissect_timestamp(tvbuff_t *tvb, proto_tree *pm_tree,

                          uint32_t offset, uint8_t qtf, uint8_t rtf,

                          bool query, uint8_t i)

{

    if (query) {

        /*

         * FF: when a query is sent from A, Timestamp 1 is set to T1 and the

         * other timestamp fields are set to 0.  Moreover, it might be useful

         * to decode Timestamp 2 (set to T2) as well because data can be captured

         * somewhere at the responder box after the timestamp has been taken.

         */

        switch (i) {

        case 1:

            switch (qtf) {

                /*

                 * FF: the actual formats of the timestamp fields written by A

                 * are indicated by the Querier Timestamp Format.

                 */

            case MPLS_PM_TSF_NULL:

                proto_tree_add_item(pm_tree,

                                    hf_mpls_pm_timestamp1_q_null, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_SEQ:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp1_q_seq, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_NTP:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp1_q_ntp, tvb,

                                    offset, 8, ENC_TIME_NTP|ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_PTP:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp1_q_ptp, tvb,

                                    offset, 8, ENC_TIME_SECS_NSECS|ENC_BIG_ENDIAN);

                break;

            default:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp1_unk, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            }

            break;

        case 2:

            switch (qtf) {

            case MPLS_PM_TSF_NULL:

                proto_tree_add_item(pm_tree,

                                    hf_mpls_pm_timestamp2_q_null, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_SEQ:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp2_q_seq, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_NTP:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp2_q_ntp, tvb,

                                    offset, 8, ENC_TIME_NTP|ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_PTP:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp2_q_ptp, tvb,

                                    offset, 8, ENC_TIME_SECS_NSECS|ENC_BIG_ENDIAN);

                break;

            default:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp2_unk, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            }

            break;

        case 3:

            proto_tree_add_item(pm_tree,

                                hf_mpls_pm_timestamp3_null, tvb,

                                offset, 8, ENC_BIG_ENDIAN);

            break;

        case 4:

            proto_tree_add_item(pm_tree,

                                hf_mpls_pm_timestamp4_null, tvb,

                                offset, 8, ENC_BIG_ENDIAN);

            break;

        default:

            /* never here */

            break;

        } /* end of switch (i) */

    } else {

        /*

         * FF: when B transmits the response, Timestamp 1 is set to T3,

         * Timestamp 3 is set to T1 and Timestamp 4 is set to T2.  Timestamp 2

         * is set to 0.  Moreover, it might be useful to decode Timestamp 2

         * (set to T4) as well because data can be captured somewhere at the

         * querier box after the timestamp has been taken.

         */

        switch (i) {

        case 1:

            switch (rtf) {

                /*

                 * FF: the actual formats of the timestamp fields written by B

                 * are indicated by the Responder Timestamp Format.

                 */

            case MPLS_PM_TSF_NULL:

                proto_tree_add_item(pm_tree,

                                    hf_mpls_pm_timestamp1_r_null, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_SEQ:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp1_r_seq, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_NTP:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp1_r_ntp, tvb,

                                    offset, 8, ENC_TIME_NTP|ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_PTP:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp1_r_ptp, tvb,

                                    offset, 8, ENC_TIME_SECS_NSECS|ENC_BIG_ENDIAN);

                break;

            default:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp1_unk, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            }

            break;

        case 2:

            switch (rtf) {

            case MPLS_PM_TSF_NULL:

                proto_tree_add_item(pm_tree,

                                    hf_mpls_pm_timestamp2_r_null, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_SEQ:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp2_r_seq, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_NTP:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp2_r_ntp, tvb,

                                    offset, 8, ENC_TIME_NTP|ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_PTP:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp2_r_ptp, tvb,

                                    offset, 8, ENC_TIME_SECS_NSECS|ENC_BIG_ENDIAN);

                break;

            default:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp2_unk, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            }

            break;

        case 3:

            switch (rtf) {

            case MPLS_PM_TSF_NULL:

                proto_tree_add_item(pm_tree,

                                    hf_mpls_pm_timestamp3_r_null, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_SEQ:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp3_r_seq, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_NTP:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp3_r_ntp, tvb,

                                    offset, 8, ENC_TIME_NTP|ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_PTP:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp3_r_ptp, tvb,

                                    offset, 8, ENC_TIME_SECS_NSECS|ENC_BIG_ENDIAN);

                break;

            default:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp3_unk, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            }

            break;

        case 4:

            switch (rtf) {

            case MPLS_PM_TSF_NULL:

                proto_tree_add_item(pm_tree,

                                    hf_mpls_pm_timestamp4_r_null, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_SEQ:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp4_r_seq, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_NTP:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp4_r_ntp, tvb,

                                    offset, 8, ENC_TIME_NTP|ENC_BIG_ENDIAN);

                break;

            case MPLS_PM_TSF_PTP:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp4_r_ptp, tvb,

                                    offset, 8, ENC_TIME_SECS_NSECS|ENC_BIG_ENDIAN);

                break;

            default:

                proto_tree_add_item(pm_tree, hf_mpls_pm_timestamp4_unk, tvb,

                                    offset, 8, ENC_BIG_ENDIAN);

                break;

            }

            break;

        default:

            /* never here */

            break;

        } /* end of switch (i) */

    }

}

static void

mpls_pm_build_cinfo(tvbuff_t *tvb, packet_info *pinfo, const char *str_pmt,

                    bool *query, bool *response,

                    bool *class_specific,

                    uint32_t *sid, uint8_t *code)

{

    col_add_fstr(pinfo->cinfo, COL_PROTOCOL, "MPLS PM (%s)", str_pmt);

    col_clear(pinfo->cinfo, COL_INFO);

    *response = (tvb_get_uint8(tvb, 0) & 0x08) ? true : false;

    *class_specific = (tvb_get_uint8(tvb, 0) & 0x04) ? true : false;

    *query = !(*response);

    *code = tvb_get_uint8(tvb, 1);

    if (!(*class_specific)) {

        /*

         * FF: when the T flag is set to 0 the DS field can be considered

         * part of the Session Identifier.

         */

        *sid = tvb_get_ntohl(tvb, 8);

    } else {

        *sid = tvb_get_ntohl(tvb, 8) >> 6;

    }

    if (*query) {

        col_add_fstr(pinfo->cinfo, COL_INFO,

                     "Query, sid: %u", *sid);

    } else {

        col_add_fstr(pinfo->cinfo, COL_INFO,

                     "Response, sid: %u, code: %s (%u)",

                     *sid,

                     rval_to_str_const(*code,

                                       mpls_pm_response_ctrl_code_rvals,

                                       "Unknown"),

                     *code);

    }

}

/* FF: the message formats for direct and inferred LM are identical */

static void

dissect_mpls_pm_loss(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                     uint8_t pmt)

{

    proto_item *ti             = NULL;

    proto_tree *pm_tree;

    proto_tree *pm_tree_flags;

    proto_tree *pm_tree_dflags;

    uint32_t    offset         = 0;

    bool        query          = 0;

    bool        response       = 0;

    bool        class_specific = 0;

    uint32_t    sid            = 0;

    uint8_t     code           = 0;

    uint8_t     otf;

    bool        bflag;

    uint8_t     i;

    mpls_pm_build_cinfo(tvb, pinfo,

                        val_to_str_const(pmt, pmt_vals, ""),

                        &query, &response, &class_specific, &sid, &code);

    if (!tree) {

        return;

    }

    /* create display subtree for the protocol */

    if (pmt == DLM) {

        ti = proto_tree_add_item(tree, proto_mpls_pm_dlm, tvb, 0, -1, ENC_NA);

    } else {

        ti = proto_tree_add_item(tree, proto_mpls_pm_ilm, tvb, 0, -1, ENC_NA);

    }

    pm_tree = proto_item_add_subtree(ti, ett_mpls_pm);

    /* add version to the subtree */

    proto_tree_add_item(pm_tree, hf_mpls_pm_version, tvb, offset, 1, ENC_BIG_ENDIAN);

    /* ctrl flags subtree */

    ti = proto_tree_add_item(pm_tree, hf_mpls_pm_flags, tvb,

                             offset, 1, ENC_BIG_ENDIAN);

    pm_tree_flags = proto_item_add_subtree(ti, ett_mpls_pm_flags);

    proto_tree_add_item(pm_tree_flags, hf_mpls_pm_flags_r, tvb,

                        offset, 1, ENC_NA);

    proto_tree_add_item(pm_tree_flags, hf_mpls_pm_flags_t, tvb,

                        offset, 1, ENC_NA);

    proto_tree_add_item(pm_tree_flags, hf_mpls_pm_flags_res, tvb,

                        offset, 1, ENC_NA);

    offset += 1;

    if (query) {

        proto_tree_add_item(pm_tree, hf_mpls_pm_query_ctrl_code,

                            tvb, offset, 1, ENC_BIG_ENDIAN);

    } else {

        proto_tree_add_item(pm_tree, hf_mpls_pm_response_ctrl_code,

                            tvb, offset, 1, ENC_BIG_ENDIAN);

    }

    offset += 1;

    proto_tree_add_item(pm_tree, hf_mpls_pm_length, tvb,

                        offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    /* data flags subtree */

    ti = proto_tree_add_item(pm_tree, hf_mpls_pm_dflags, tvb,

                             offset, 1, ENC_BIG_ENDIAN);

    pm_tree_dflags = proto_item_add_subtree(ti, ett_mpls_pm_dflags);

    proto_tree_add_item(pm_tree_dflags, hf_mpls_pm_dflags_x, tvb,

                        offset, 1, ENC_NA);

    bflag = (tvb_get_uint8(tvb, offset) & 0x40) ? true : false;

    proto_tree_add_item(pm_tree_dflags, hf_mpls_pm_dflags_b, tvb,

                        offset, 1, ENC_NA);

    proto_tree_add_item(pm_tree_dflags, hf_mpls_pm_dflags_res, tvb,

                        offset, 1, ENC_NA);

    otf = tvb_get_uint8(tvb, offset) & 0x0F;

    proto_tree_add_item(pm_tree, hf_mpls_pm_otf, tvb,

                        offset, 1, ENC_BIG_ENDIAN);

    offset += 1;

    /* skip 3 reserved bytes */

    offset += 3;

    proto_tree_add_uint(pm_tree, hf_mpls_pm_session_id, tvb, offset, 4, sid);

    if (class_specific) {

        proto_tree_add_item(pm_tree, hf_mpls_pm_ds, tvb, offset + 3, 1, ENC_BIG_ENDIAN);

    }

    offset += 4;

    switch (otf) {

    case MPLS_PM_TSF_NULL:

        proto_tree_add_item(pm_tree, hf_mpls_pm_origin_timestamp_null, tvb,

                            offset, 8, ENC_BIG_ENDIAN);

        break;

    case MPLS_PM_TSF_SEQ:

        proto_tree_add_item(pm_tree, hf_mpls_pm_origin_timestamp_seq, tvb,

                            offset, 8, ENC_BIG_ENDIAN);

        break;

    case MPLS_PM_TSF_NTP:

        proto_tree_add_item(pm_tree, hf_mpls_pm_origin_timestamp_ntp, tvb,

                            offset, 8, ENC_TIME_NTP|ENC_BIG_ENDIAN);

        break;

    case MPLS_PM_TSF_PTP:

        proto_tree_add_item(pm_tree, hf_mpls_pm_origin_timestamp_ptp, tvb,

                            offset, 8, ENC_TIME_SECS_NSECS|ENC_BIG_ENDIAN);

        break;

    default:

        proto_tree_add_item(pm_tree, hf_mpls_pm_origin_timestamp_unk, tvb,

                            offset, 8, ENC_BIG_ENDIAN);

        break;

    }

    offset += 8;

    /* counters 1..4 */

    for (i = 1; i <= 4; i++) {

        mpls_pm_dissect_counter(tvb, pm_tree, offset, query, bflag, i);

        offset += 8;

    }

}

static int

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

{

    /* the message formats for direct and inferred LM are identical */

    dissect_mpls_pm_loss(tvb, pinfo, tree, DLM);

    return tvb_captured_length(tvb);

}

static int

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

{

    /* the message formats for direct and inferred LM are identical */

    dissect_mpls_pm_loss(tvb, pinfo, tree, ILM);

    return tvb_captured_length(tvb);

}

static int

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

{

    proto_item *ti;

    proto_tree *pm_tree;

    proto_tree *pm_tree_flags;

    uint32_t    offset         = 0;

    bool        query          = 0;

    bool        response       = 0;

    bool        class_specific = 0;

    uint32_t    sid            = 0;

    uint8_t     code           = 0;

    uint8_t     qtf;

    uint8_t     rtf;

    uint8_t     i;

    mpls_pm_build_cinfo(tvb, pinfo,

                        "DM",

                        &query, &response, &class_specific, &sid, &code);

    /* create display subtree for the protocol */

    ti = proto_tree_add_item(tree, proto_mpls_pm_dm, tvb, 0, -1, ENC_NA);

    pm_tree = proto_item_add_subtree(ti, ett_mpls_pm);

    /* add version to the subtree */

    proto_tree_add_item(pm_tree, hf_mpls_pm_version, tvb, offset, 1, ENC_BIG_ENDIAN);

    /* ctrl flags subtree */

    ti = proto_tree_add_item(pm_tree, hf_mpls_pm_flags, tvb, offset, 1, ENC_BIG_ENDIAN);

    pm_tree_flags = proto_item_add_subtree(ti, ett_mpls_pm_flags);

    proto_tree_add_item(pm_tree_flags, hf_mpls_pm_flags_r, tvb,

                        offset, 1, ENC_NA);

    proto_tree_add_item(pm_tree_flags, hf_mpls_pm_flags_t, tvb,

                        offset, 1, ENC_NA);

    proto_tree_add_item(pm_tree_flags, hf_mpls_pm_flags_res, tvb,

                        offset, 1, ENC_NA);

    offset += 1;

    if (query) {

        proto_tree_add_item(pm_tree, hf_mpls_pm_query_ctrl_code,

                            tvb, offset, 1, ENC_BIG_ENDIAN);

    } else {

        proto_tree_add_item(pm_tree, hf_mpls_pm_response_ctrl_code,

                            tvb, offset, 1, ENC_BIG_ENDIAN);

    }

    offset += 1;

    proto_tree_add_item(pm_tree, hf_mpls_pm_length, tvb,

                        offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    /* qtf, rtf */

    qtf = (tvb_get_uint8(tvb, offset) & 0xF0) >> 4;

    proto_tree_add_item(pm_tree, hf_mpls_pm_qtf, tvb,

                        offset, 1, ENC_BIG_ENDIAN);

    rtf = tvb_get_uint8(tvb, offset) & 0x0F;

    proto_tree_add_item(pm_tree, hf_mpls_pm_rtf, tvb,

                        offset, 1, ENC_BIG_ENDIAN);

    offset += 1;

    /* rptf */

    proto_tree_add_item(pm_tree, hf_mpls_pm_rptf, tvb,

                        offset, 1, ENC_BIG_ENDIAN);

    /* skip 20 reserved bits */

    offset += 3;

    proto_tree_add_uint(pm_tree, hf_mpls_pm_session_id, tvb, offset, 4, sid);

    if (class_specific) {

        proto_tree_add_item(pm_tree, hf_mpls_pm_ds, tvb, offset + 3, 1, ENC_BIG_ENDIAN);

    }

    offset += 4;

    /* timestamps 1..4 */

    for (i = 1; i <= 4; i++) {

        mpls_pm_dissect_timestamp(tvb, pm_tree, offset, qtf, rtf, query, i);

        offset += 8;

    }

    return tvb_captured_length(tvb);

}

static void

dissect_mpls_pm_combined(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,

                         uint8_t pmt)

{

    proto_item *ti             = NULL;

    proto_tree *pm_tree;

    proto_tree *pm_tree_flags;

    proto_tree *pm_tree_dflags;

    uint32_t    offset         = 0;

    bool        query          = 0;

    bool        response       = 0;

    bool        class_specific = 0;

    uint32_t    sid            = 0;

    uint8_t     code           = 0;

    uint8_t     qtf;

    uint8_t     rtf;

    bool        bflag;

    uint8_t     i;

    mpls_pm_build_cinfo(tvb, pinfo,

                        val_to_str_const(pmt, pmt_vals, ""),

                        &query, &response, &class_specific, &sid, &code);

    if (!tree) {

        return;

    }

    /* create display subtree for the protocol */

    if (pmt == DLMDM) {

        ti = proto_tree_add_item(tree, proto_mpls_pm_dlm_dm,

                                 tvb, 0, -1, ENC_NA);

    } else {

        ti = proto_tree_add_item(tree, proto_mpls_pm_ilm_dm,

                                 tvb, 0, -1, ENC_NA);

    }

    pm_tree = proto_item_add_subtree(ti, ett_mpls_pm);

    /* add version to the subtree */

    proto_tree_add_item(pm_tree, hf_mpls_pm_version, tvb, offset, 1, ENC_BIG_ENDIAN);

    /* ctrl flags subtree */

    ti = proto_tree_add_item(pm_tree, hf_mpls_pm_flags, tvb, offset, 1, ENC_BIG_ENDIAN);

    pm_tree_flags = proto_item_add_subtree(ti, ett_mpls_pm_flags);

    proto_tree_add_item(pm_tree_flags, hf_mpls_pm_flags_r, tvb,

                        offset, 1, ENC_NA);

    proto_tree_add_item(pm_tree_flags, hf_mpls_pm_flags_t, tvb,

                        offset, 1, ENC_NA);

    proto_tree_add_item(pm_tree_flags, hf_mpls_pm_flags_res, tvb,

                        offset, 1, ENC_NA);

    offset += 1;

    if (query) {

        proto_tree_add_item(pm_tree, hf_mpls_pm_query_ctrl_code,

                            tvb, offset, 1, ENC_BIG_ENDIAN);

    } else {

        proto_tree_add_item(pm_tree, hf_mpls_pm_response_ctrl_code,

                            tvb, offset, 1, ENC_BIG_ENDIAN);

    }

    offset += 1;

    proto_tree_add_item(pm_tree, hf_mpls_pm_length, tvb,

                        offset, 2, ENC_BIG_ENDIAN);

    offset += 2;

    /* data flags subtree */

    ti = proto_tree_add_item(pm_tree, hf_mpls_pm_dflags, tvb,

                             offset, 1, ENC_BIG_ENDIAN);

    pm_tree_dflags = proto_item_add_subtree(ti, ett_mpls_pm_dflags);

    proto_tree_add_item(pm_tree_dflags, hf_mpls_pm_dflags_x, tvb,

                        offset, 1, ENC_NA);

    bflag = (tvb_get_uint8(tvb, offset) & 0x40) ? true : false;

    proto_tree_add_item(pm_tree_dflags, hf_mpls_pm_dflags_b, tvb,

                        offset, 1, ENC_NA);

    proto_tree_add_item(pm_tree_dflags, hf_mpls_pm_dflags_res, tvb,

                        offset, 1, ENC_NA);

    /*

     * FF: the roles of the OTF and Origin Timestamp fields for LM are

     * here played by the QTF and Timestamp 1 fields, respectively.

     */

    qtf = tvb_get_uint8(tvb, offset) & 0x0F;

    proto_tree_add_item(pm_tree, hf_mpls_pm_qtf_combined, tvb,

                        offset, 1, ENC_BIG_ENDIAN);

    offset += 1;

    /* rtf, rptf */

    rtf = tvb_get_uint8(tvb, offset) & 0xF0 >> 4;

    proto_tree_add_item(pm_tree, hf_mpls_pm_rtf_combined, tvb,

                        offset, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(pm_tree, hf_mpls_pm_rptf_combined, tvb,

                        offset, 1, ENC_BIG_ENDIAN);

    offset += 1;

    /* skip 2 reserved bytes */

    offset += 2;

    proto_tree_add_uint(pm_tree, hf_mpls_pm_session_id, tvb, offset, 4, sid);

    if (class_specific) {

        proto_tree_add_item(pm_tree, hf_mpls_pm_ds, tvb, offset + 3, 1, ENC_BIG_ENDIAN);

    }

    offset += 4;

    /* timestamps 1..4 */

    for (i = 1; i <= 4; i++) {

        mpls_pm_dissect_timestamp(tvb, pm_tree, offset, qtf, rtf, query, i);

        offset += 8;

    }

    /* counters 1..4 */

    for (i = 1; i <= 4; i++) {

        mpls_pm_dissect_counter(tvb, pm_tree, offset, query, bflag, i);

        offset += 8;

    }

}

static int

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

{

    /* the formats of the DLM+DM and ILM+DM messages are also identical */

    dissect_mpls_pm_combined(tvb, pinfo, tree, DLMDM);

    return tvb_captured_length(tvb);

}

static int

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

{

    /* the formats of the DLM+DM and ILM+DM messages are also identical */

    dissect_mpls_pm_combined(tvb, pinfo, tree, ILMDM);

    return tvb_captured_length(tvb);

}

void

proto_register_mpls_pm(void)

{

    static hf_register_info hf[] = {

        {

            &hf_mpls_pm_version,

            {

                "Version", "mpls_pm.version", FT_UINT8, BASE_DEC, NULL,

                0xF0, NULL, HFILL

            }

        },

        {

            &hf_mpls_pm_flags,

            {

                "Flags", "mpls_pm.flags", FT_UINT8,

                BASE_HEX, NULL, MPLS_PM_FLAGS_MASK, NULL, HFILL

            }

        },

        {

            &hf_mpls_pm_flags_r,

            {

                "Response indicator (R)", "mpls_pm.flags.r",

                FT_BOOLEAN, 8, TFS(&tfs_set_notset), MPLS_PM_FLAGS_R,

                NULL, HFILL

            }

        },

        {

            &hf_mpls_pm_flags_t,

            {

                "Traffic-class-specific measurement indicator (T)",

                "mpls_pm.flags.t",

                FT_BOOLEAN, 8, TFS(&tfs_set_notset), MPLS_PM_FLAGS_T,

                NULL, HFILL

            }

        },

        {

            &hf_mpls_pm_flags_res,

            {

                "Reserved",

                "mpls_pm.flags.res",

                FT_BOOLEAN, 8, TFS(&tfs_set_notset), MPLS_PM_FLAGS_RES,

                NULL, HFILL

            }

        },

        {

            &hf_mpls_pm_query_ctrl_code,

            {

                "Control Code",

                "mpls_pm.ctrl.code",

                FT_UINT8, BASE_RANGE_STRING | BASE_HEX,

                RVALS(mpls_pm_query_ctrl_code_rvals), 0x0,

                "Code identifying the query type", HFILL

            }

        },

        {

            &hf_mpls_pm_response_ctrl_code,

            {

                "Control Code",

                "mpls_pm.ctrl.code",

                FT_UINT8, BASE_RANGE_STRING | BASE_HEX,

                RVALS(mpls_pm_response_ctrl_code_rvals), 0x0,