Logo Search packages:      
Sourcecode: ethereal version File versions

packet-ldp.c

/* packet-ldp.c
 * Routines for LDP (RFC 3036) packet disassembly
 *
 * $Id: packet-ldp.c 12241 2004-10-08 17:01:43Z guy $
 *
 * Copyright (c) November 2000 by Richard Sharpe <rsharpe@ns.aus.com>
 *
 * CRLDP (RFC3212) is now supported
 *   - (c) 2002 Michael Rozhavsky <mike[AT]tochna.technion.ac.il>
 *
 * Ethereal - Network traffic analyzer
 * By Gerald Combs <gerald@ethereal.com>
 * Copyright 1999 Gerald Combs
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>
#include <glib.h>
#include <string.h>
#include <epan/packet.h>
#include <epan/addr_resolv.h>
#include <epan/prefs.h>
#include <epan/afn.h>

#include "packet-frame.h"
#include "packet-diffserv-mpls-common.h"
#include "packet-ldp.h"

#define TCP_PORT_LDP 646
#define UDP_PORT_LDP 646

void proto_reg_handoff_ldp(void);

static int proto_ldp = -1;

/* Delete the following if you do not use it, or add to it if you need */
static int hf_ldp_req = -1;
static int hf_ldp_rsp = -1;
static int hf_ldp_version = -1;
static int hf_ldp_pdu_len = -1;
static int hf_ldp_lsr = -1;
static int hf_ldp_ls_id = -1;
static int hf_ldp_msg_ubit = -1;
static int hf_ldp_msg_type = -1;
static int hf_ldp_msg_len = -1;
static int hf_ldp_msg_id = -1;
static int hf_ldp_msg_vendor_id = -1;
static int hf_ldp_msg_experiment_id = -1;
static int hf_ldp_tlv_value = -1;
static int hf_ldp_tlv_type = -1;
static int hf_ldp_tlv_unknown = -1;
static int hf_ldp_tlv_len = -1;
static int hf_ldp_tlv_val_hold = -1;
static int hf_ldp_tlv_val_target = -1;
static int hf_ldp_tlv_val_request = -1;
static int hf_ldp_tlv_val_res = -1;
static int hf_ldp_tlv_ipv4_taddr = -1;
static int hf_ldp_tlv_config_seqno = -1;
static int hf_ldp_tlv_ipv6_taddr = -1;
static int hf_ldp_tlv_fec_wc = -1;
static int hf_ldp_tlv_fec_af = -1;
static int hf_ldp_tlv_fec_len = -1;
static int hf_ldp_tlv_fec_pfval = -1;
static int hf_ldp_tlv_fec_hoval = -1;
static int hf_ldp_tlv_addrl_addr_family = -1;
static int hf_ldp_tlv_addrl_addr = -1;
static int hf_ldp_tlv_hc_value = -1;
static int hf_ldp_tlv_pv_lsrid = -1;
static int hf_ldp_tlv_generic_label = -1;
static int hf_ldp_tlv_atm_label_vbits = -1;
static int hf_ldp_tlv_atm_label_vpi = -1;
static int hf_ldp_tlv_atm_label_vci = -1;
static int hf_ldp_tlv_fr_label_len = -1;
static int hf_ldp_tlv_fr_label_dlci = -1;
static int hf_ldp_tlv_ft_protect_sequence_num = -1;
static int hf_ldp_tlv_status_ebit = -1;
static int hf_ldp_tlv_status_fbit = -1;
static int hf_ldp_tlv_status_data = -1;
static int hf_ldp_tlv_status_msg_id = -1;
static int hf_ldp_tlv_status_msg_type = -1;
static int hf_ldp_tlv_extstatus_data = -1;
static int hf_ldp_tlv_returned_version = -1;
static int hf_ldp_tlv_returned_pdu_len = -1;
static int hf_ldp_tlv_returned_lsr = -1;
static int hf_ldp_tlv_returned_ls_id = -1;
static int hf_ldp_tlv_returned_msg_ubit = -1;
static int hf_ldp_tlv_returned_msg_type = -1;
static int hf_ldp_tlv_returned_msg_len = -1;
static int hf_ldp_tlv_returned_msg_id = -1;
static int hf_ldp_tlv_mac = -1;
static int hf_ldp_tlv_sess_ver = -1;
static int hf_ldp_tlv_sess_ka = -1;
static int hf_ldp_tlv_sess_advbit = -1;
static int hf_ldp_tlv_sess_ldetbit = -1;
static int hf_ldp_tlv_sess_pvlim = -1;
static int hf_ldp_tlv_sess_mxpdu = -1;
static int hf_ldp_tlv_sess_rxlsr = -1;
static int hf_ldp_tlv_sess_rxls = -1;
static int hf_ldp_tlv_sess_atm_merge = -1;
static int hf_ldp_tlv_sess_atm_lr = -1;
static int hf_ldp_tlv_sess_atm_dir = -1;
static int hf_ldp_tlv_sess_atm_minvpi = -1;
static int hf_ldp_tlv_sess_atm_maxvpi = -1;
static int hf_ldp_tlv_sess_atm_minvci = -1;
static int hf_ldp_tlv_sess_atm_maxvci = -1;
static int hf_ldp_tlv_sess_fr_merge = -1;
static int hf_ldp_tlv_sess_fr_lr = -1;
static int hf_ldp_tlv_sess_fr_dir = -1;
static int hf_ldp_tlv_sess_fr_len = -1;
static int hf_ldp_tlv_sess_fr_mindlci = -1;
static int hf_ldp_tlv_sess_fr_maxdlci = -1;
static int hf_ldp_tlv_ft_sess_flags = -1;
static int hf_ldp_tlv_ft_sess_flag_r = -1;
static int hf_ldp_tlv_ft_sess_flag_res = -1;
static int hf_ldp_tlv_ft_sess_flag_s = -1;
static int hf_ldp_tlv_ft_sess_flag_a = -1;
static int hf_ldp_tlv_ft_sess_flag_c = -1;
static int hf_ldp_tlv_ft_sess_flag_l = -1;
static int hf_ldp_tlv_ft_sess_res = -1;
static int hf_ldp_tlv_ft_sess_reconn_to = -1;
static int hf_ldp_tlv_ft_sess_recovery_time = -1;
static int hf_ldp_tlv_ft_ack_sequence_num = -1;
static int hf_ldp_tlv_lbl_req_msg_id = -1;
static int hf_ldp_tlv_vendor_id = -1;
static int hf_ldp_tlv_experiment_id = -1;
static int hf_ldp_tlv_fec_vc_controlword = -1;
static int hf_ldp_tlv_fec_vc_vctype = -1;
static int hf_ldp_tlv_fec_vc_infolength = -1;
static int hf_ldp_tlv_fec_vc_groupid = -1;
static int hf_ldp_tlv_fec_vc_vcid = -1;
static int hf_ldp_tlv_fec_vc_intparam_length = -1;
static int hf_ldp_tlv_fec_vc_intparam_mtu = -1;
static int hf_ldp_tlv_fec_vc_intparam_tdmbps = -1;
static int hf_ldp_tlv_fec_vc_intparam_id = -1;
static int hf_ldp_tlv_fec_vc_intparam_maxcatmcells = -1;
static int hf_ldp_tlv_fec_vc_intparam_desc = -1;
static int hf_ldp_tlv_fec_vc_intparam_cepbytes = -1;
static int hf_ldp_tlv_fec_vc_intparam_cepopt_ais = -1;
static int hf_ldp_tlv_fec_vc_intparam_cepopt_une = -1;
static int hf_ldp_tlv_fec_vc_intparam_cepopt_rtp = -1;
static int hf_ldp_tlv_fec_vc_intparam_cepopt_ebm = -1;
static int hf_ldp_tlv_fec_vc_intparam_cepopt_mah = -1;
static int hf_ldp_tlv_fec_vc_intparam_cepopt_res = -1;
static int hf_ldp_tlv_fec_vc_intparam_cepopt_ceptype = -1;
static int hf_ldp_tlv_fec_vc_intparam_cepopt_t3 = -1;
static int hf_ldp_tlv_fec_vc_intparam_cepopt_e3 = -1;
static int hf_ldp_tlv_fec_vc_intparam_vlanid = -1;
static int hf_ldp_tlv_fec_vc_intparam_dlcilen = -1;
static int hf_ldp_tlv_fec_vc_intparam_fcslen = -1;
static int hf_ldp_tlv_fec_vc_intparam_tdmopt_r = -1;
static int hf_ldp_tlv_fec_vc_intparam_tdmopt_d = -1;
static int hf_ldp_tlv_fec_vc_intparam_tdmopt_f = -1;
static int hf_ldp_tlv_fec_vc_intparam_tdmopt_res1 = -1;
static int hf_ldp_tlv_fec_vc_intparam_tdmopt_pt = -1;
static int hf_ldp_tlv_fec_vc_intparam_tdmopt_res2 = -1;
static int hf_ldp_tlv_fec_vc_intparam_tdmopt_freq = -1;
static int hf_ldp_tlv_fec_vc_intparam_tdmopt_ssrc = -1;
static int hf_ldp_tlv_fec_vc_intparam_vccv_cctype_cw = -1;
static int hf_ldp_tlv_fec_vc_intparam_vccv_cctype_mplsra = -1;
static int hf_ldp_tlv_fec_vc_intparam_vccv_cctype_ttl1 = -1;
static int hf_ldp_tlv_fec_vc_intparam_vccv_cvtype_icmpping = -1;
static int hf_ldp_tlv_fec_vc_intparam_vccv_cvtype_lspping = -1;
static int hf_ldp_tlv_fec_vc_intparam_vccv_cvtype_bfd = -1;
static int hf_ldp_tlv_lspid_act_flg = -1;
static int hf_ldp_tlv_lspid_cr_lsp = -1;
static int hf_ldp_tlv_lspid_ldpid = -1;
static int hf_ldp_tlv_er_hop_loose = -1;
static int hf_ldp_tlv_er_hop_prelen = -1;
static int hf_ldp_tlv_er_hop_prefix4 = -1;
static int hf_ldp_tlv_er_hop_prefix6 = -1;
static int hf_ldp_tlv_er_hop_as = -1;
static int hf_ldp_tlv_er_hop_cr_lsp = -1;
static int hf_ldp_tlv_er_hop_ldpid = -1;
static int hf_ldp_tlv_flags_reserv = -1;
static int hf_ldp_tlv_flags_weight = -1;
static int hf_ldp_tlv_flags_ebs = -1;
static int hf_ldp_tlv_flags_cbs = -1;
static int hf_ldp_tlv_flags_cdr = -1;
static int hf_ldp_tlv_flags_pbs = -1;
static int hf_ldp_tlv_flags_pdr = -1;
static int hf_ldp_tlv_frequency = -1;
static int hf_ldp_tlv_pdr = -1;
static int hf_ldp_tlv_pbs = -1;
static int hf_ldp_tlv_cdr = -1;
static int hf_ldp_tlv_cbs = -1;
static int hf_ldp_tlv_ebs = -1;
static int hf_ldp_tlv_weight = -1;
static int hf_ldp_tlv_set_prio = -1;
static int hf_ldp_tlv_hold_prio = -1;
static int hf_ldp_tlv_route_pinning = -1;
static int hf_ldp_tlv_resource_class = -1;
static int hf_ldp_tlv_diffserv = -1;
static int hf_ldp_tlv_diffserv_type = -1;
static int hf_ldp_tlv_diffserv_mapnb = -1;
static int hf_ldp_tlv_diffserv_map = -1;
static int hf_ldp_tlv_diffserv_map_exp = -1;
static int hf_ldp_tlv_diffserv_phbid = -1;
static int hf_ldp_tlv_diffserv_phbid_dscp = -1;
static int hf_ldp_tlv_diffserv_phbid_code = -1;
static int hf_ldp_tlv_diffserv_phbid_bit14 = -1;
static int hf_ldp_tlv_diffserv_phbid_bit15 = -1;
static int ett_ldp = -1;
static int ett_ldp_header = -1;
static int ett_ldp_ldpid = -1;
static int ett_ldp_message = -1;
static int ett_ldp_tlv = -1;
static int ett_ldp_tlv_val = -1;
static int ett_ldp_tlv_ft_flags = -1;
static int ett_ldp_fec = -1;
static int ett_ldp_fec_vc_interfaceparam = -1;
static int ett_ldp_fec_vc_interfaceparam_cepopt = -1;
static int ett_ldp_fec_vc_interfaceparam_vccvtype = -1;
static int ett_ldp_diffserv_map = -1;
static int ett_ldp_diffserv_map_phbid = -1;

static int tcp_port = 0;
static int udp_port = 0;

/* desegmentation of LDP over TCP */
static gboolean ldp_desegment = FALSE;

/* Add your functions here */

static guint32 global_ldp_tcp_port = TCP_PORT_LDP;
static guint32 global_ldp_udp_port = UDP_PORT_LDP;

/*
 * The following define all the TLV types I know about
 */

#define TLV_FEC                    0x0100
#define TLV_ADDRESS_LIST           0x0101
#define TLV_HOP_COUNT              0x0103
#define TLV_PATH_VECTOR            0x0104
#define TLV_GENERIC_LABEL          0x0200
#define TLV_ATM_LABEL              0x0201
#define TLV_FRAME_LABEL            0x0202
#define TLV_FT_PROTECTION          0x0203
#define TLV_STATUS                 0x0300
#define TLV_EXTENDED_STATUS        0x0301
#define TLV_RETURNED_PDU           0x0302
#define TLV_RETURNED_MESSAGE       0x0303
#define TLV_COMMON_HELLO_PARMS     0x0400
#define TLV_IPV4_TRANSPORT_ADDRESS 0x0401
#define TLV_CONFIGURATION_SEQNO    0x0402
#define TLV_IPV6_TRANSPORT_ADDRESS 0x0403
#define TLV_MAC                    0x0404
#define TLV_COMMON_SESSION_PARMS   0x0500
#define TLV_ATM_SESSION_PARMS      0x0501
#define TLV_FRAME_RELAY_SESSION_PARMS 0x0502
#define TLV_FT_SESSION             0x0503
#define TLV_FT_ACK                 0x0504
#define TLV_FT_CORK                0x0505
#define TLV_LABEL_REQUEST_MESSAGE_ID 0x0600
#define TLV_ER                     0x0800
#define TLV_ER_HOP_IPV4            0x0801
#define TLV_ER_HOP_IPV6            0x0802
#define TLV_ER_HOP_AS              0x0803
#define TLV_ER_HOP_LSPID           0x0804
#define TLV_TRAFFIC_PARAM          0x0810
#define TLV_PREEMPTION             0x0820
#define TLV_LSPID                  0x0821
#define TLV_RESOURCE_CLASS         0x0822
#define TLV_ROUTE_PINNING          0x0823
#define TLV_DIFFSERV               0x0901
#define TLV_VENDOR_PRIVATE_START   0x3E00
#define TLV_VENDOR_PRIVATE_END     0x3EFF
#define TLV_EXPERIMENTAL_START     0x3F00
#define TLV_EXPERIMENTAL_END       0x3FFF

static const value_string tlv_type_names[] = {
  { TLV_FEC,                       "Forwarding Equivalence Classes TLV" },
  { TLV_ADDRESS_LIST,              "Address List TLV"},
  { TLV_HOP_COUNT,                 "Hop Count TLV"},
  { TLV_PATH_VECTOR,               "Path Vector TLV"},
  { TLV_GENERIC_LABEL,             "Generic Label TLV"},
  { TLV_ATM_LABEL,                 "ATM Label TLV"},
  { TLV_FRAME_LABEL,               "Frame Label TLV"},
  { TLV_FT_PROTECTION,             "FT Protection TLV"},
  { TLV_STATUS,                    "Status TLV"},
  { TLV_EXTENDED_STATUS,           "Extended Status TLV"},
  { TLV_RETURNED_PDU,              "Returned PDU TLV"},
  { TLV_RETURNED_MESSAGE,          "Returned Message TLV"},
  { TLV_COMMON_HELLO_PARMS,        "Common Hello Parameters TLV"},
  { TLV_IPV4_TRANSPORT_ADDRESS,    "IPv4 Transport Address TLV"},
  { TLV_CONFIGURATION_SEQNO,       "Configuration Sequence Number TLV"},
  { TLV_IPV6_TRANSPORT_ADDRESS,    "IPv6 Transport Address TLV"},
  { TLV_MAC,                       "MAC TLV"},
  { TLV_COMMON_SESSION_PARMS,      "Common Session Parameters TLV"},
  { TLV_ATM_SESSION_PARMS,         "ATM Session Parameters TLV"},
  { TLV_FRAME_RELAY_SESSION_PARMS, "Frame Relay Session Parameters TLV"},
  { TLV_FT_SESSION,                "FT Session TLV"},
  { TLV_FT_ACK,                    "FT ACK TLV"},
  { TLV_FT_CORK,                   "FT Cork TLV"},
  { TLV_LABEL_REQUEST_MESSAGE_ID,  "Label Request Message ID TLV"},
  { TLV_LSPID,                     "LSP ID TLV"},
  { TLV_ER,                        "Explicit route TLV"},
  { TLV_ER_HOP_IPV4,               "ER hop IPv4 prefix TLV"},
  { TLV_ER_HOP_IPV6,               "ER hop IPv6 prefix TLV"},
  { TLV_ER_HOP_AS,                 "ER hop Autonomous system number prefix TLV"},
  { TLV_TRAFFIC_PARAM,             "Traffic parameters TLV"},
  { TLV_PREEMPTION,                "Preemption TLV"},
  { TLV_ER_HOP_LSPID,              "ER hop LSPID prefix TLV"},
  { TLV_RESOURCE_CLASS,            "Resource Class (Color) TLV"},
  { TLV_ROUTE_PINNING,             "Route Pinning TLV"},
  { TLV_DIFFSERV,                  "Diff-Serv TLV"},
  { TLV_VENDOR_PRIVATE_START, "Vendor Private TLV"},
  { TLV_EXPERIMENTAL_START,   "Experimental TLV"},
  { 0, NULL}
};

/*
 * The following define all the message types I know about
 */

#define LDP_NOTIFICATION       0x0001
#define LDP_HELLO              0x0100
#define LDP_INITIALIZATION     0x0200
#define LDP_KEEPALIVE          0x0201
#define LDP_ADDRESS            0x0300
#define LDP_ADDRESS_WITHDRAWAL 0x0301
#define LDP_LABEL_MAPPING      0x0400
#define LDP_LABEL_REQUEST      0x0401
#define LDP_LABEL_WITHDRAWAL   0x0402
#define LDP_LABEL_RELEASE      0x0403
#define LDP_LABEL_ABORT_REQUEST 0x0404
#define LDP_VENDOR_PRIVATE_START 0x3E00
#define LDP_VENDOR_PRIVATE_END   0x3EFF
#define LDP_EXPERIMENTAL_MESSAGE_START 0x3F00
#define LDP_EXPERIMENTAL_MESSAGE_END   0x3FFF

static const value_string ldp_message_types[] = {
  {LDP_NOTIFICATION,             "Notification Message"},
  {LDP_HELLO,                    "Hello Message"},
  {LDP_INITIALIZATION,           "Initialization Message"},
  {LDP_KEEPALIVE,                "Keep Alive Message"},
  {LDP_ADDRESS,                  "Address Message"},
  {LDP_ADDRESS_WITHDRAWAL,       "Address Withdrawal Message"},
  {LDP_LABEL_MAPPING,            "Label Mapping Message"},
  {LDP_LABEL_REQUEST,            "Label Request Message"},
  {LDP_LABEL_WITHDRAWAL,         "Label Withdrawal Message"},
  {LDP_LABEL_RELEASE,            "Label Release Message"},
  {LDP_LABEL_ABORT_REQUEST,      "Label Abort Request Message"},
  {LDP_VENDOR_PRIVATE_START,     "Vendor-Private Message"},
  {LDP_EXPERIMENTAL_MESSAGE_START,     "Experimental Message"},
  {0, NULL}
};

static const true_false_string ldp_message_ubit = {
  "Unknown bit set",
  "Unknown bit not set"
};

static const true_false_string hello_targeted_vals = {
  "Targeted Hello",
  "Link Hello"
};

static const value_string tlv_unknown_vals[] = {
  {0, "Known TLV, do not Forward"},
  {1, "Known TLV, do Forward"},
  {2, "Unknown TLV, do not Forward"},
  {3, "Unknown TLV, do Forward"},
  {0, NULL}
};

#define     WILDCARD_FEC      1
#define     PREFIX_FEC  2
#define     HOST_FEC    3
#define CRLSP_FEC       4
#define VC_FEC          0x80  /* draft-martini-l2circuit-trans-mpls */

static const value_string fec_types[] = {
  {WILDCARD_FEC, "Wildcard FEC"},
  {PREFIX_FEC, "Prefix FEC"},
  {HOST_FEC, "Host Address FEC"},
  {CRLSP_FEC, "CR LSP FEC"},
  {VC_FEC, "Virtual Circuit FEC"},
  {0, NULL}
};


const value_string fec_vc_types_vals[] = {
  {0x0001, "Frame Relay DLCI"},
  {0x0002, "ATM AAL5 SDU VCC transport"},
  {0x0003, "ATM transparent cell transport"},
  {0x0004, "Ethernet VLAN"},
  {0x0005, "Ethernet"},
  {0x0006, "HDLC"},
  {0x0007, "PPP"},
  {0x0008, "SONET/SDH Circuit Emulation Service"},
  {0x0009, "ATM n-to-one VCC cell transport"},
  {0x000A, "ATM n-to-one VPC cell transport"},
  {0x000B, "IP layer2 transport"},
  {0x000C, "ATM one-to-one VCC Cell Mode"},
  {0x000D, "ATM one-to-one VPC Cell Mode"},
  {0x000E, "ATM AAL5 PDU VCC transport"},
  {0x000F, "Frame-Relay Port mode"},
  {0x0010, "SONET/SDH Circuit Emulation over Packet"},
  {0x0011, "Structure-agnostic E1 over Packet"},
  {0x0012, "Structure-agnostic T1 (DS1) over Packet"},
  {0x0013, "Structure-agnostic E3 over Packet"},
  {0x0014, "Structure-agnostic T3 (DS3) over Packet"},
  {0x0015, "CESoPSN basic mode"},
  {0x0016, "TDMoIP basic mode"},
  {0x0017, "CESoPSN TDM with CAS"},
  {0x0018, "TDMoIP TDM with CAS"},
  {0, NULL}
};


static const value_string fec_vc_ceptype_vals[] = {
  {0, "SPE mode (STS-1/STS-Mc)"},
  {1, "VT mode (VT1.5/VT2/VT3/VT6)"},
  {2, "Fractional SPE (STS-1/VC-3/VC-4)"},
  {0, NULL}
};

static const true_false_string fec_vc_tdmopt_r = {
  "Expects to receive RTP Header",
  "Does not expect to receive RTP Header"
};

static const true_false_string fec_vc_tdmopt_d = {
  "Expects the peer to use Differential timestamping",
  "Does not expect the peer to use Differential timestamping"
};

static const true_false_string fec_vc_tdmopt_f = {
  "Expects TDMoIP encapsulation",
  "Expects CESoPSN encapsulation"
};


#define FEC_VC_INTERFACEPARAM_MTU          0x01
#define FEC_VC_INTERFACEPARAM_MAXCATMCELLS 0x02
#define FEC_VC_INTERFACEPARAM_DESCRIPTION  0x03
#define FEC_VC_INTERFACEPARAM_CEPBYTES     0x04
#define FEC_VC_INTERFACEPARAM_CEPOPTIONS   0x05
#define FEC_VC_INTERFACEPARAM_VLANID       0x06
#define FEC_VC_INTERFACEPARAM_TDMBPS       0x07
#define FEC_VC_INTERFACEPARAM_FRDLCILEN    0x08
#define FEC_VC_INTERFACEPARAM_FRAGIND      0x09
#define FEC_VC_INTERFACEPARAM_FCSRETENT    0x0A
#define FEC_VC_INTERFACEPARAM_TDMOPTION    0x0B
#define FEC_VC_INTERFACEPARAM_VCCV         0x0C



static const value_string fec_vc_interfaceparm[] = {
  {FEC_VC_INTERFACEPARAM_MTU, "MTU"},
  {FEC_VC_INTERFACEPARAM_MAXCATMCELLS, "Max Concatenated ATM cells"},
  {FEC_VC_INTERFACEPARAM_DESCRIPTION, "Interface Description"},
  {FEC_VC_INTERFACEPARAM_CEPBYTES, "CEP/TDM Payload Bytes"},
  {FEC_VC_INTERFACEPARAM_CEPOPTIONS, "CEP options"},
  {FEC_VC_INTERFACEPARAM_VLANID, "Requested VLAN ID"},
  {FEC_VC_INTERFACEPARAM_TDMBPS, "CEP/TDM bit-rate"},
  {FEC_VC_INTERFACEPARAM_FRDLCILEN, "Frame-Relay DLCI Length"},
  {FEC_VC_INTERFACEPARAM_FRAGIND, "Fragmentation indicator"},
  {FEC_VC_INTERFACEPARAM_FCSRETENT, "FCS retention indicator"},
  {FEC_VC_INTERFACEPARAM_TDMOPTION, "TDM options"},
  {FEC_VC_INTERFACEPARAM_VCCV, "VCCV"},
  {0, NULL},
};

static const true_false_string fec_vc_cbit = {
  "Control Word Present",
  "Control Word NOT Present"
};



static const value_string tlv_atm_merge_vals[] = {
  {0, "Merge not supported"},
  {1, "VP merge supported"},
  {2, "VC merge supported"},
  {3, "VP & VC merge supported"},
  {0, NULL}
};

static const value_string tlv_atm_vbits_vals[] = {
  {0, "VPI & VCI Significant"},
  {1, "Only VPI Significant"},
  {2, "Only VCI Significant"},
  {3, "VPI & VCI not Significant, nonsense"},
  {0, NULL}
};

static const value_string tlv_fr_merge_vals[] = {
  {0, "Merge not supported"},
  {1, "Merge supported"},
  {2, "Unspecified"},
  {3, "Unspecified"},
  {0, NULL}
};

static const value_string tlv_fr_len_vals[] = {
  {0, "10 bits"},
  {1, "Reserved"},
  {2, "23 bits"},
  {3, "Reserved"},
  {0, NULL}
};

static const value_string tlv_ft_flags[] = {
  {0, "Invalid"},
  {1, "Using LDP Graceful Restart"},
  {2, "Check-Pointing of all labels"},
  {3, "Invalid"},
  {4, "Invalid"},
  {5, "Invalid"},
  {6, "Check-Pointing of all labels"},
  {7, "Invalid"},
  {8, "Full FT on selected labels"},
  {9, "Invalid"},
  {10, "Full FT on selected labels"},
  {11, "Invalid"},
  {12, "Full FT on all labels"},
  {13, "Invalid"},
  {14, "Full FT on all labels"},
  {15, "Invalid"},
  {0, NULL}
};

static const true_false_string tlv_ft_r = {
  "LSR has preserved state and resources for all FT-Labels",
  "LSR has not preserved state and resources for all FT-Labels"
};

static const true_false_string tlv_ft_s = {
  "FT Protection TLV supported on other than KeepAlive",
  "FT Protection TLV not supported on other than KeepAlive"
};

static const true_false_string tlv_ft_a = {
  "Treat all labels as Sequence Numbered FT Labels",
  "May treat some labels as FT and others as non-FT"
};

static const true_false_string tlv_ft_c = {
  "Check-Pointing procedures in use",
  "Check-Pointing procedures not in use"
};

static const true_false_string tlv_ft_l = {
  "Re-learn the state from the network",
  "Do not re-learn the state from the network"
};

static const value_string ldp_act_flg_vals[] = {
  {0, "indicates initial LSP setup"},
  {1, "indicates modify LSP"},
  {0, NULL}
};

static const value_string route_pinning_vals[] = {
  {0, "route pinning is not requested"},
  {1, "route pinning is requested"},
  {0, NULL}
};

static const value_string diffserv_type_vals[] = {
  {0, "E-LSP"},
  {1, "L-LSP"},
  {0, NULL}
};

static const value_string ldp_loose_vals[] = {
  {0, "strict hop"},
  {1, "loose hop"},
  {0, NULL}
};

static const true_false_string tlv_negotiable = {
  "Negotiable",
  "Not negotiable"
};

static const value_string freq_values[] = {
  {0, "Unspecified"},
  {1, "Frequent"},
  {2, "VeryFrequent"},
  {0, NULL}
};

static const true_false_string tlv_atm_dirbit = {
  "Bidirectional capability",
  "Unidirectional capability"
};

static const true_false_string hello_requested_vals = {
  "Source requests periodic hellos",
  "Source does not request periodic hellos"
};

static const true_false_string tlv_sess_advbit_vals = {
  "Downstream On Demand proposed",
  "Downstream Unsolicited proposed"
};

static const true_false_string tlv_sess_ldetbit_vals = {
  "Loop Detection Enabled",
  "Loop Detection Disabled"
};

static const true_false_string tlv_status_ebit = {
  "Fatal Error Notification",
  "Advisory Notification"
};

static const true_false_string tlv_status_fbit = {
  "Notification should be Forwarded",
  "Notification should NOT be Forwarded"
};

static const value_string tlv_status_data[] = {
  {0, "Success"},
  {1, "Bad LDP Identifier"},
  {2, "Bad Protocol Version"},
  {3, "Bad PDU Length"},
  {4, "Unknown Message Type"},
  {5, "Bad Message Length"},
  {6, "Unknown TLV"},
  {7, "Bad TLV Length"},
  {8, "Malformed TLV Value"},
  {9, "Hold Timer Expired"},
  {10, "Shutdown"},
  {11, "Loop Detected"},
  {12, "Unknown FEC"},
  {13, "No Route"},
  {14, "No Label Resources"},
  {15, "Label Resources / Available"},
  {16, "Session Rejected / No Hello"},
  {17, "Session Rejected / Parameters Advertisement Mode"},
  {18, "Session Rejected / Parameters Max PDU Length"},
  {19, "Session Rejected / Parameters Label Range"},
  {20, "KeepAlive Timer Expired"},
  {21, "Label Request Aborted"},
  {22, "Missing Message Parameters"},
  {23, "Unsoported Address Family"},
  {24, "Session Rejected / Bad KeepAlive Time"},
  {25, "Internal Error"},
  {26, "No LDP Session"},
  {27, "Zero FT seqnum"},
  {28, "Unexpected TLV / Session Not FT"},
  {29, "Unexpected TLV / Label Not FT"},
  {30, "Missing FT Protection TLV"},
  {31, "FT ACK sequence error"},
  {32, "Temporary Shutdown"},
  {33, "FT Seq Numbers Exhausted"},
  {34, "FT Session parameters / changed"},
  {35, "Unexpected FT Cork TLV"},
  {0x01000001,"Unexpected Diff-Serv TLV"},
  {0x01000002,"Unsupported PHB"},
  {0x01000003,"Invalid EXP<->PHB Mapping"},
  {0x01000004,"Unsupported PSC"},
  {0x01000005,"Per-LSP context allocation failure"},
  {0x04000001,"Bad Explicit Routing TLV Error"},
  {0x04000002,"Bad Strict Node Error"},
  {0x04000003,"Bad Strict Node Error"},
  {0x04000004,"Bad Initial ER-Hop Error"},
  {0x04000005,"Resource Unavailable"},
  {0x04000006,"Traffic Parameters Unavailable"},
  {0x04000007,"LSP Preempted"},
  {0x04000008,"Modify Request Not Supported"},
  {0x20000001,"Illegal C-Bit"},
  {0x20000002,"Wrong C-Bit"},
  {0, NULL}
};

/* Define storage class for a string handler function
 * with a const guint8 * argument, and returning a gchar *
 */
typedef gchar *(string_handler_func)(const guint8 *);

/* Default handler for address to string conversion */
static gchar *
default_str_handler(const guint8 * bytes _U_)
{
      return "<Support for this Address Family not implemented>";
}
      
/* Dissect FEC TLV */

static void
dissect_tlv_fec(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti=NULL, *val_tree=NULL, *fec_tree=NULL, *vcintparam_tree=NULL;
        proto_tree *cepopt_tree=NULL, *vccvtype_tree=NULL;
      guint16     family, ix=1, ax;
      guint8      addr_size=0, *addr, implemented, prefix_len_octets, prefix_len, host_len, vc_len;
      guint8  intparam_len;
      string_handler_func *str_handler = default_str_handler;
      char *str;

      if (tree) {
            ti=proto_tree_add_text(tree, tvb, offset, rem, "FEC Elements");
            val_tree=proto_item_add_subtree(ti, ett_ldp_tlv_val);
            if(val_tree == NULL) return;

            while (rem > 0){
                  switch (tvb_get_guint8(tvb, offset)) {
                  case WILDCARD_FEC:
                  case CRLSP_FEC:
                        ti = proto_tree_add_text(val_tree, tvb, offset, 1, "FEC Element %u", ix);
                        fec_tree = proto_item_add_subtree(ti, ett_ldp_fec);
                        if(fec_tree == NULL) return;
                        proto_tree_add_item(fec_tree, hf_ldp_tlv_fec_wc,tvb, offset, 1, FALSE);
                        rem -= 1;
                        offset += 1;
                        break;

                  case PREFIX_FEC:
                        if( rem < 4 ){/*not enough*/
                              proto_tree_add_text(val_tree, tvb, offset, rem, "Error in FEC Element %u", ix);
                              return;
                        }
                        family=tvb_get_ntohs(tvb, offset+1);
                        prefix_len=tvb_get_guint8(tvb, offset+3);
                        prefix_len_octets=(prefix_len+7)/8;

                        implemented=1;
                        switch(family) {
                              case AFNUM_INET: /*IPv4*/
                                    addr_size=4;
                                    str_handler=ip_to_str;
                                    break;
                              case AFNUM_INET6: /*IPv6*/
                                    addr_size=16;
                                    str_handler = (string_handler_func *) ip6_to_str;
                                    break;
                              default:
                                    implemented=0;
                                    break;
                        }

                        if( !implemented ) {
                              guint16 noctets;

                              noctets= rem>4+prefix_len_octets?4+prefix_len_octets:rem;
                              proto_tree_add_text(val_tree, tvb, offset, noctets,"Support for Address Family not implemented");
                              offset+=noctets;
                              rem-=noctets;
                              break;
                        }

                        if( rem < 4+MIN(addr_size, prefix_len_octets) ){
                              proto_tree_add_text(val_tree, tvb, offset, rem, "Error in FEC Element %u", ix);
                              return;
                        }

                        /*Add a subtree for this*/
                        ti = proto_tree_add_text(val_tree, tvb, offset, 4+MIN(addr_size, prefix_len_octets), "FEC Element %u", ix);
                        fec_tree = proto_item_add_subtree(ti, ett_ldp_fec);
                        if(fec_tree == NULL) return;
                        proto_tree_add_item(fec_tree, hf_ldp_tlv_fec_wc, tvb, offset, 1, FALSE);
                        offset += 1;

                        proto_tree_add_item(fec_tree, hf_ldp_tlv_fec_af, tvb, offset, 2, FALSE);
                        offset += 2;

                        proto_tree_add_item(fec_tree, hf_ldp_tlv_fec_len, tvb, offset, 1, FALSE);
                        offset += 1;


                        if( addr_size < prefix_len_octets) {
                              offset+=addr_size;
                              rem-=addr_size;
                              proto_tree_add_text(fec_tree, tvb, offset-1, 1, "Invalid prefix %u length for family %s", prefix_len, val_to_str(family, afn_vals, "Unknown Family"));
                              break;
                        }

                        if( (addr=g_malloc0(addr_size)) == NULL ){
                              /*big big trouble, no mem or bad addr_size*/
                              fprintf(stderr, "packet-ldp: dissect_tlv_fec() malloc failed\n");
                              return;
                        }

                        for(ax=0; ax+1 <= prefix_len_octets; ax++)
                              addr[ax]=tvb_get_guint8(tvb, offset+ax);
                        if( prefix_len % 8 )
                              addr[ax-1] = addr[ax-1]&(0xFF<<(8-prefix_len%8));

                        str = str_handler((const guint8 *)addr);
                        proto_tree_add_string_format(fec_tree, hf_ldp_tlv_fec_pfval, tvb, offset, prefix_len_octets, str, "Prefix: %s", str);

                        offset += prefix_len_octets;
                        rem -= 4+prefix_len_octets;
                        g_free(addr);
                        break;

                  case HOST_FEC:
                        if( rem < 4 ){/*not enough*/
                              proto_tree_add_text(val_tree, tvb, offset, rem, "Error in FEC Element %u", ix);
                              return;
                        }
                        family=tvb_get_ntohs(tvb, offset+1);
                        host_len=tvb_get_guint8(tvb, offset+3);

                        implemented=1;
                        switch(family) {
                              case AFNUM_INET: /*IPv4*/
                                    addr_size=4;
                                    str_handler=ip_to_str;
                                    break;
                              case AFNUM_INET6: /*IPv6*/
                                    addr_size=16;
                                    str_handler = (string_handler_func *) ip6_to_str;
                                    break;
                              default:
                                    implemented=0;
                                    break;
                        }

                        if( !implemented ) {
                              guint16 noctets;

                              noctets= rem>4+host_len?4+host_len:rem;
                              proto_tree_add_text(val_tree, tvb, offset, noctets,"Support for Address Family not implemented");
                              offset+=noctets;
                              rem-=noctets;
                              break;
                        }

                        if( rem < 4+addr_size ){
                              proto_tree_add_text(val_tree, tvb, offset, rem, "Error in FEC Element %u", ix);
                              return;
                        }

                        /*Add a subtree for this*/
                        ti = proto_tree_add_text(val_tree, tvb, offset, 4+addr_size, "FEC Element %u", ix);
                        fec_tree = proto_item_add_subtree(ti, ett_ldp_fec);
                        if(fec_tree == NULL) return;
                        proto_tree_add_item(fec_tree, hf_ldp_tlv_fec_wc, tvb, offset, 1, FALSE);
                        offset += 1;

                        proto_tree_add_item(fec_tree, hf_ldp_tlv_fec_af, tvb, offset, 2, FALSE);
                        offset += 2;

                        proto_tree_add_item(fec_tree, hf_ldp_tlv_fec_len, tvb, offset, 1, FALSE);
                        offset += 1;


                        if( addr_size != host_len) {
                              offset+=addr_size;
                              rem-=addr_size;
                              proto_tree_add_text(fec_tree, tvb, offset-1, 1, "Invalid address length %u length for family %s", host_len, val_to_str(family, afn_vals, "Unknown Family"));
                              break;
                        }

                        if( (addr=g_malloc0(addr_size)) == NULL ){
                              /*big big xtrouble, no mem or bad addr_size*/
                              fprintf(stderr, "packet-ldp: dissect_tlv_fec() malloc failed\n");
                              return;
                        }

                        for(ax=0; ax+1 <= host_len; ax++)
                              addr[ax]=tvb_get_guint8(tvb, offset+ax);

                        str = str_handler((const guint8 *)addr);
                        proto_tree_add_string_format(fec_tree, hf_ldp_tlv_fec_hoval, tvb, offset, host_len, str, "Address: %s", str);

                        offset += host_len;
                        rem -= 4+host_len;
                        g_free(addr);
                        break;

                  case VC_FEC:
                    if( rem < 8 ){/*not enough bytes for a minimal VC_FEC*/
                      proto_tree_add_text(val_tree, tvb, offset, rem, "Error in FEC Element %u", ix);
                      return;
                    }
                    vc_len = tvb_get_guint8 (tvb, offset+3);


                    ti = proto_tree_add_text(val_tree, tvb, offset, 8+vc_len, "FEC Element %u", ix);
                    fec_tree = proto_item_add_subtree(ti, ett_ldp_fec);
                    if(fec_tree == NULL) return;
                    proto_tree_add_item(fec_tree, hf_ldp_tlv_fec_wc, tvb, offset, 1, FALSE);
                    proto_tree_add_item(fec_tree, hf_ldp_tlv_fec_vc_controlword, tvb, offset+1, 1, FALSE);
                    proto_tree_add_item(fec_tree, hf_ldp_tlv_fec_vc_vctype, tvb, offset+1, 2, FALSE);
                    proto_tree_add_item(fec_tree, hf_ldp_tlv_fec_vc_infolength, tvb, offset+3,1,FALSE);
                    proto_tree_add_item(fec_tree, hf_ldp_tlv_fec_vc_groupid,tvb, offset +4, 4, FALSE);
                    rem -=8;
                    offset +=8;

                    if ( (vc_len > 3) && ( rem > 3 ) ) { /* there is enough room for vcid */
                      proto_tree_add_item(fec_tree, hf_ldp_tlv_fec_vc_vcid,tvb, offset, 4, FALSE);
                      proto_item_append_text (ti," VCID: %u",tvb_get_ntohl(tvb,offset));

                    } else {
                      proto_tree_add_text(val_tree,tvb,offset +4, 8 +vc_len, "VC FEC size format error");
                      return;
                    }
                    rem -= 4;
                    vc_len -= 4;
                    offset += 4;

                    while ( (vc_len > 1) && (rem > 1) ) {   /* enough to include id and length */
                      intparam_len = tvb_get_guint8(tvb, offset+1);
                      ti = proto_tree_add_text(fec_tree, tvb, offset, intparam_len, "Interface Parameter");
                      vcintparam_tree = proto_item_add_subtree(ti, ett_ldp_fec_vc_interfaceparam);
                      if(vcintparam_tree == NULL) return;
                      proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_id,tvb,offset,1,FALSE);
                      proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_length,tvb, offset+1, 1, FALSE);
                            if (intparam_len < 2){ /* At least Type and Len, protect against len = 0 */
                              proto_tree_add_text(vcintparam_tree, tvb, offset +1, 1, "malformed interface parameter");
                              return;
                            }

                      if ( (vc_len -intparam_len) <0 && (rem -intparam_len) <0 ) { /* error condition */
                        proto_tree_add_text(vcintparam_tree, tvb, offset +2, MIN(vc_len,rem), "malformed data");
                        return;
                      }
                      switch (tvb_get_guint8(tvb, offset)) {
                      case FEC_VC_INTERFACEPARAM_MTU:
                        proto_item_append_text(ti,": MTU %u", tvb_get_ntohs(tvb,offset+2));
                        proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_mtu,tvb, offset+2, 2, FALSE);
                        break;
                      case FEC_VC_INTERFACEPARAM_TDMBPS:
                              /* draft-ietf-pwe3-control-protocol-06.txt */
                        proto_item_append_text(ti,": BPS %u", tvb_get_ntohl(tvb,offset+2));
                        proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_tdmbps,tvb, offset+2, 4, FALSE);
                        break;
                      case FEC_VC_INTERFACEPARAM_MAXCATMCELLS:
                        proto_item_append_text(ti,": Max ATM Concat Cells %u", tvb_get_ntohs(tvb,offset+2));
                        proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_maxcatmcells,tvb, offset+2, 2, FALSE);
                        break;
                      case FEC_VC_INTERFACEPARAM_DESCRIPTION:
                        proto_item_append_text(ti,": Description");
                        proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_desc,tvb, offset+2, (intparam_len -2), FALSE);
                        break;
                      case FEC_VC_INTERFACEPARAM_CEPBYTES:
                        proto_item_append_text(ti,": CEP/TDM Payload Bytes %u", tvb_get_ntohs(tvb,offset+2));
                        proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_cepbytes,tvb, offset+2, 2, FALSE);
                        break;
                            case FEC_VC_INTERFACEPARAM_CEPOPTIONS:
                              /* draft-ietf-pwe3-sonet-05.txt */
                              proto_item_append_text(ti,": CEP Options");
                              ti = proto_tree_add_text(vcintparam_tree, tvb, offset + 2, 2, "CEP Options");
                              cepopt_tree = proto_item_add_subtree(ti, ett_ldp_fec_vc_interfaceparam_cepopt);
                              if(cepopt_tree == NULL) return;
                              proto_tree_add_item(cepopt_tree, hf_ldp_tlv_fec_vc_intparam_cepopt_ais, tvb, offset + 2, 2, FALSE);
                              proto_tree_add_item(cepopt_tree, hf_ldp_tlv_fec_vc_intparam_cepopt_une, tvb, offset + 2, 2, FALSE);
                              proto_tree_add_item(cepopt_tree, hf_ldp_tlv_fec_vc_intparam_cepopt_rtp, tvb, offset + 2, 2, FALSE);
                              proto_tree_add_item(cepopt_tree, hf_ldp_tlv_fec_vc_intparam_cepopt_ebm, tvb, offset + 2, 2, FALSE);
                              proto_tree_add_item(cepopt_tree, hf_ldp_tlv_fec_vc_intparam_cepopt_mah, tvb, offset + 2, 2, FALSE);
                              proto_tree_add_item(cepopt_tree, hf_ldp_tlv_fec_vc_intparam_cepopt_res, tvb, offset + 2, 2, FALSE);
                              proto_tree_add_item(cepopt_tree, hf_ldp_tlv_fec_vc_intparam_cepopt_ceptype, tvb, offset + 2, 2, FALSE);
                              proto_tree_add_item(cepopt_tree, hf_ldp_tlv_fec_vc_intparam_cepopt_t3, tvb, offset + 2, 2, FALSE);
                              proto_tree_add_item(cepopt_tree, hf_ldp_tlv_fec_vc_intparam_cepopt_e3, tvb, offset + 2, 2, FALSE);
                              break;
                      case FEC_VC_INTERFACEPARAM_VLANID:
                              proto_item_append_text(ti,": VLAN Id %u", tvb_get_ntohs(tvb,offset+2));
                        proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_vlanid, tvb, offset+2, 2, FALSE);
                        break;
                            case FEC_VC_INTERFACEPARAM_FRDLCILEN:
                              proto_item_append_text(ti,": DLCI Length %u", tvb_get_ntohs(tvb,offset+2));
                              proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_dlcilen, tvb, offset+2, 2, FALSE);
                              break;
                            case FEC_VC_INTERFACEPARAM_FRAGIND:
                              /* draft-ietf-pwe3-fragmentation-05.txt */
                              proto_item_append_text(ti,": Fragmentation");      
                              break;
                            case FEC_VC_INTERFACEPARAM_FCSRETENT:
                              /* draft-ietf-pwe3-fcs-retention-02.txt */
                              proto_item_append_text(ti,": FCS retention, FCS Length %u Bytes", tvb_get_ntohs(tvb,offset+2));      
                              proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_fcslen, tvb, offset+2, 2, FALSE);
                              break;
                            case FEC_VC_INTERFACEPARAM_TDMOPTION:
                              /* draft-vainshtein-pwe3-tdm-control-protocol-extensions */
                              proto_item_append_text(ti,": TDM Options");
                              proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_tdmopt_r, tvb, offset+2, 2, FALSE);
                              proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_tdmopt_d, tvb, offset+2, 2, FALSE);
                              proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_tdmopt_f, tvb, offset+2, 2, FALSE);
                              proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_tdmopt_res1, tvb, offset+2, 2, FALSE);
                              if (intparam_len >= 8){
                                proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_tdmopt_pt, tvb, offset+4, 1, FALSE);
                                proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_tdmopt_res2, tvb, offset+5, 1, FALSE);
                                proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_tdmopt_freq, tvb, offset+6, 2, FALSE);
                              }
                              if (intparam_len >= 12){
                                proto_tree_add_item(vcintparam_tree,hf_ldp_tlv_fec_vc_intparam_tdmopt_ssrc, tvb, offset+8, 4, FALSE);
                              }
                              break;
                            case FEC_VC_INTERFACEPARAM_VCCV:
                              /* draft-ietf-pwe3-vccv-03.txt */
                              proto_item_append_text(ti,": VCCV");
                              ti = proto_tree_add_text(vcintparam_tree, tvb, offset + 2, 1, "CC Type");
                              vccvtype_tree = proto_item_add_subtree(ti, ett_ldp_fec_vc_interfaceparam_vccvtype);
                              if(vccvtype_tree == NULL) return;
                              proto_tree_add_item(vccvtype_tree, hf_ldp_tlv_fec_vc_intparam_vccv_cctype_cw, tvb, offset+2, 1, FALSE);
                              proto_tree_add_item(vccvtype_tree, hf_ldp_tlv_fec_vc_intparam_vccv_cctype_mplsra, tvb, offset+2, 1, FALSE);
                              proto_tree_add_item(vccvtype_tree, hf_ldp_tlv_fec_vc_intparam_vccv_cctype_ttl1, tvb, offset+2, 1, FALSE);
                              ti = proto_tree_add_text(vcintparam_tree, tvb, offset + 3, 1, "CV Type");
                              vccvtype_tree = proto_item_add_subtree(ti, ett_ldp_fec_vc_interfaceparam_vccvtype);
                              if(vccvtype_tree == NULL) return;
                              proto_tree_add_item(vccvtype_tree, hf_ldp_tlv_fec_vc_intparam_vccv_cvtype_icmpping, tvb, offset+3, 1, FALSE);
                              proto_tree_add_item(vccvtype_tree, hf_ldp_tlv_fec_vc_intparam_vccv_cvtype_lspping, tvb, offset+3, 1, FALSE);
                              proto_tree_add_item(vccvtype_tree, hf_ldp_tlv_fec_vc_intparam_vccv_cvtype_bfd, tvb, offset+3, 1, FALSE);
                              break;
                      default: /* unknown */
                        proto_item_append_text(ti," unknown");
                        proto_tree_add_text(vcintparam_tree,tvb, offset+2, (intparam_len -2), "Unknown data");

                              break;
                      }
                      rem -= intparam_len;
                      vc_len -= intparam_len;
                      offset += intparam_len;
                    }
                    break;

                  default:  /* Unknown */
                  /* XXX - do all FEC's have a length that's a multiple of 4? */
                  /* Hmmm, don't think so. Will check. RJS. */
                  /* If we don't know its structure, we have to exit */
                        ti = proto_tree_add_text(val_tree, tvb, offset, 4, "FEC Element %u", ix);
                        fec_tree = proto_item_add_subtree(ti, ett_ldp_fec);
                        if(fec_tree == NULL) return;
                        proto_tree_add_text(fec_tree, tvb, offset, rem, "Unknown FEC TLV type");
                        return;
                  }
                  ix++;
            }
      }
}

/* Dissect Address List TLV */

static void
dissect_tlv_address_list(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;
      guint16     family, ix;
      guint8      addr_size, *addr;
      string_handler_func *str_handler = default_str_handler;
      char *str;

      if (tree) {
            if( rem < 2 ) {
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing Address List TLV: length is %d, should be >= 2",
                      rem);
                  return;
            }

            family=tvb_get_ntohs(tvb, offset);
            proto_tree_add_item(tree, hf_ldp_tlv_addrl_addr_family, tvb,
                               offset, 2, FALSE);
            switch(family) {
                  case AFNUM_INET: /*IPv4*/
                        addr_size=4;
                        str_handler=ip_to_str;
                        break;
                  case AFNUM_INET6: /*IPv6*/
                        addr_size=16;
                        str_handler = (string_handler_func *) ip6_to_str;
                        break;
                  default:
                        proto_tree_add_text(tree, tvb, offset+2, rem-2,
                         "Support for Address Family not implemented");
                        return;
            }

            offset+=2; rem-=2;
            ti=proto_tree_add_text(tree, tvb, offset, rem, "Addresses");
            val_tree=proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree == NULL) return;
            if( (addr=g_malloc(addr_size)) == NULL ){
                  /*big big trouble*/
                  fprintf(stderr, "packet-ldp: dissect_tlv_address_list() malloc failed\n");
                  return;
            }

            for(ix=1; rem >= addr_size; ix++, offset += addr_size,
                                           rem -= addr_size) {
                  if( (tvb_memcpy(tvb, addr, offset, addr_size))
                                           == NULL)
                        break;

                  str = str_handler((const guint8 *)addr);
                  proto_tree_add_string_format(val_tree,
                      hf_ldp_tlv_addrl_addr, tvb, offset, addr_size, str,
                      "Address %u: %s", ix, str);
            }
            if(rem)
                  proto_tree_add_text(val_tree, tvb, offset, rem,
                      "Error processing TLV: Extra data at end of address list");
            g_free(addr);
      }
}

/* Dissect Path Vector TLV */

static void
dissect_tlv_path_vector(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;
      guint8      ix;
      guint32 addr;

      if (tree) {
            ti=proto_tree_add_text(tree, tvb, offset, rem, "LSR IDs");
            val_tree=proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree == NULL) return;

            for(ix=1; rem >= 4; ix++, offset += 4, rem -= 4) {
                  tvb_memcpy(tvb, (guint8 *)&addr, offset, 4);
                  proto_tree_add_ipv4_format(val_tree,
                      hf_ldp_tlv_pv_lsrid, tvb, offset, 4,
                      addr, "LSR Id %u: %s", ix,
                      ip_to_str((guint8 *)&addr));
            }
            if(rem)
                  proto_tree_add_text(val_tree, tvb, offset, rem,
                      "Error processing TLV: Extra data at end of path vector");
      }
}

/* Dissect ATM Label TLV */

static void
dissect_tlv_atm_label(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;
      guint16     id;

      if(tree) {
            if(rem != 4){
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing ATM Label TLV: length is %d, should be 4",
                      rem);
                  return;
            }
            ti=proto_tree_add_text(tree, tvb, offset, rem, "ATM Label");
            val_tree=proto_item_add_subtree(ti, ett_ldp_tlv_val);
            if(val_tree == NULL) return;

            proto_tree_add_item(val_tree, hf_ldp_tlv_atm_label_vbits, tvb, offset, 1, FALSE);

            id=tvb_get_ntohs(tvb, offset)&0x0FFF;
            proto_tree_add_uint_format(val_tree, hf_ldp_tlv_atm_label_vpi, tvb, offset, 2, id, "VPI: %u", id);

            id=tvb_get_ntohs(tvb, offset+2);
            proto_tree_add_uint_format(val_tree, hf_ldp_tlv_atm_label_vci, tvb, offset+2, 2, id, "VCI: %u", id);
      }
}

/* Dissect FRAME RELAY Label TLV */

static void
dissect_tlv_frame_label(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;
      guint8      len;
      guint32     id;

      if(tree) {
            if(rem != 4){
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing Frame Relay Label TLV: length is %d, should be 4",
                      rem);
                  return;
            }
            ti=proto_tree_add_text(tree, tvb, offset, rem, "Frame Relay Label");
            val_tree=proto_item_add_subtree(ti, ett_ldp_tlv_val);
            if(val_tree == NULL) return;

            len=(guint8)(tvb_get_ntohs(tvb, offset)>>7) & 0x03;
            proto_tree_add_uint_format(val_tree, hf_ldp_tlv_fr_label_len, tvb, offset, 2, len, "Number of DLCI bits: %s (%u)", val_to_str(len, tlv_fr_len_vals, "Unknown Length"), len);

            id=tvb_get_ntoh24(tvb, offset+1)&0x7FFFFF;
            proto_tree_add_uint_format(val_tree,
            hf_ldp_tlv_fr_label_dlci, tvb, offset+1, 3, id, "DLCI: %u", id);
      }
}

/* Dissect STATUS TLV */

static void
dissect_tlv_status(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;
      guint32     data;

      if(tree) {
            if(rem != 10){
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing Status TLV: length is %d, should be 10",
                      rem);
                  return;
            }

            ti=proto_tree_add_text(tree, tvb, offset, rem, "Status");
            val_tree=proto_item_add_subtree(ti, ett_ldp_tlv_val);
            if(val_tree == NULL) return;

            proto_tree_add_item(val_tree, hf_ldp_tlv_status_ebit, tvb, offset, 1, FALSE);
            proto_tree_add_item(val_tree, hf_ldp_tlv_status_fbit, tvb, offset, 1, FALSE);

            data=tvb_get_ntohl(tvb, offset)&0x3FFFFFFF;
            proto_tree_add_uint_format(val_tree, hf_ldp_tlv_status_data, tvb, offset, 4, data, "Status Data: %s (0x%X)", val_to_str(data, tlv_status_data, "Unknown Status Data"), data);

            proto_tree_add_item(val_tree, hf_ldp_tlv_status_msg_id, tvb, offset+4, 4, FALSE);
            proto_tree_add_item(val_tree, hf_ldp_tlv_status_msg_type, tvb, offset+8, 2, FALSE);
      }
}

/* Dissect Returned PDU TLV */

static void
dissect_tlv_returned_pdu(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;

      if(tree) {
            if(rem < 10){
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing Returned PDU TLV: length is %d, should be >= 10",
                      rem);
                  return;
            }
            ti=proto_tree_add_text(tree, tvb, offset, rem, "Returned PDU");
            val_tree=proto_item_add_subtree(ti, ett_ldp_tlv_val);
            if(val_tree == NULL) return;

            proto_tree_add_item(val_tree, hf_ldp_tlv_returned_version, tvb, offset, 2, FALSE);
            proto_tree_add_item(val_tree, hf_ldp_tlv_returned_pdu_len, tvb, offset+2, 2, FALSE);
            proto_tree_add_item(val_tree, hf_ldp_tlv_returned_lsr, tvb, offset+4, 4, FALSE);
            proto_tree_add_item(val_tree, hf_ldp_tlv_returned_ls_id, tvb, offset+8, 2, FALSE);
            offset += 10;
            rem -= 10;

            if( rem > 0 ) {
            /*XXX - dissect returned pdu data*/
                  proto_tree_add_text(val_tree, tvb, offset, rem, "Returned PDU Data");
            }
      }
}

/* Dissect Returned MESSAGE TLV */

static void
dissect_tlv_returned_message(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;
      guint16     type;

      if(tree) {
            if(rem < 4){
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing Returned Message TLV: length is %d, should be >= 4",
                      rem);
                  return;
            }
            ti=proto_tree_add_text(tree, tvb, offset, rem, "Returned Message");
            val_tree=proto_item_add_subtree(ti, ett_ldp_tlv_val);
            if(val_tree == NULL) return;

            proto_tree_add_item(val_tree, hf_ldp_tlv_returned_msg_ubit, tvb, offset, 1, FALSE);

            type=tvb_get_ntohs(tvb, offset)&0x7FFF;
            proto_tree_add_uint_format(val_tree, hf_ldp_tlv_returned_msg_type, tvb, offset, 2, type, "Message Type: %s (0x%X)", val_to_str(type, ldp_message_types,"Unknown Message Type"), type);

            proto_tree_add_item(val_tree, hf_ldp_tlv_returned_msg_len, tvb, offset+2, 2, FALSE);
            offset += 4;
            rem -= 4;

            if( rem >= 4  ) { /*have msg_id*/
                  proto_tree_add_item(val_tree, hf_ldp_tlv_returned_msg_id, tvb, offset, 4, FALSE);
                  offset += 4;
                  rem -= 4;
            }

            if( rem > 0 ) {
            /*XXX - dissect returned msg parameters*/
                  proto_tree_add_text(val_tree, tvb, offset, rem, "Returned Message Parameters");
            }
      }
}

/* Dissect the common hello params */

static void
#if 0
dissect_tlv_common_hello_parms(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
#else
dissect_tlv_common_hello_parms(tvbuff_t *tvb, guint offset, proto_tree *tree)
#endif
{
#if 0
      proto_tree *ti = NULL;
#endif
      proto_tree *val_tree = NULL;

      if (tree) {
#if 0
            ti = proto_tree_add_item(tree, hf_ldp_tlv_value, tvb, offset, rem, FALSE);
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);
            if(val_tree == NULL) return;
#else
            val_tree=tree;
#endif
            proto_tree_add_item(val_tree, hf_ldp_tlv_val_hold, tvb, offset, 2, FALSE);
            proto_tree_add_item(val_tree, hf_ldp_tlv_val_target, tvb, offset + 2, 2, FALSE);
            proto_tree_add_item(val_tree, hf_ldp_tlv_val_request, tvb, offset + 2, 2, FALSE);
            proto_tree_add_item(val_tree, hf_ldp_tlv_val_res, tvb, offset + 2, 2, FALSE);
      }
}

/* Dissect MAC TLV */

static void
dissect_tlv_mac(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;
      guint8      ix;
      const guint8 *mac;

      if (tree) {
            ti=proto_tree_add_text(tree, tvb, offset, rem, "MAC addresses");
            val_tree=proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree == NULL) return;

            for(ix=1; rem >= 6; ix++, offset += 6, rem -= 6) {
                  mac = tvb_get_ptr(tvb, offset, 6);
                  proto_tree_add_ether(val_tree,
                       hf_ldp_tlv_mac, tvb, offset, 6, mac);
            }
            if(rem)
                  proto_tree_add_text(val_tree, tvb, offset, rem,
                      "Error processing TLV: Extra data at end of path vector");
      }
}



/* Dissect the common session params */

static void
dissect_tlv_common_session_parms(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;

      if (tree != NULL) {
            if( rem != 14) { /*length of Comm Sess Parms tlv*/
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing Common Session Parameters TLV: length is %d, should be 14",
                      rem);
                  return;
            }
            ti = proto_tree_add_text(tree, tvb, offset, rem, "Parameters");
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree != NULL) {
                  /*Protocol Version*/
                  proto_tree_add_item(val_tree, hf_ldp_tlv_sess_ver, tvb,offset, 2, FALSE);

                  /*KeepAlive Time*/
                  proto_tree_add_item(val_tree, hf_ldp_tlv_sess_ka, tvb,offset + 2, 2, FALSE);

                  /*A bit*/
                  proto_tree_add_item(val_tree, hf_ldp_tlv_sess_advbit,tvb, offset + 4, 1, FALSE);

                  /*D bit*/
                  proto_tree_add_item(val_tree, hf_ldp_tlv_sess_ldetbit,tvb, offset + 4, 1, FALSE);

                  /*Path Vector Limit*/
                  proto_tree_add_item(val_tree, hf_ldp_tlv_sess_pvlim,tvb, offset + 5, 1, FALSE);

                  /*Max PDU Length*/
                  proto_tree_add_item(val_tree, hf_ldp_tlv_sess_mxpdu,tvb, offset + 6, 2, FALSE);

                  /*Rx LSR*/
                  proto_tree_add_item(val_tree, hf_ldp_tlv_sess_rxlsr,tvb, offset + 8, 4, FALSE);

                  /*Rx LS*/
                  proto_tree_add_item(val_tree, hf_ldp_tlv_sess_rxls,tvb, offset + 12, 2, FALSE);
            }
      }
}

/* Dissect the atm session params */

static void
dissect_tlv_atm_session_parms(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL, *lbl_tree = NULL;
      guint8 numlr, ix;
      guint16 id;

      if (tree != NULL) {
            if(rem < 4) {
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing ATM Parameters TLV: length is %d, should be >= 4",
                      rem);
                  return;
            }

            ti = proto_tree_add_text(tree, tvb, offset, rem,"ATM Parameters");
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree != NULL) {
                  proto_tree_add_item(val_tree, hf_ldp_tlv_sess_atm_merge,tvb, offset, 1, FALSE);

                  /*get the number of label ranges*/
                  numlr=(tvb_get_guint8(tvb, offset)>>2) & 0x0F;
                  proto_tree_add_uint_format(val_tree, hf_ldp_tlv_sess_atm_lr,
                  tvb, offset, 1, numlr, "Number of Label Range components: %u",
                  numlr);

                  proto_tree_add_item(val_tree, hf_ldp_tlv_sess_atm_dir,tvb, offset, 1, FALSE);

                  /*move into range components*/
                  offset += 4;
                  rem -= 4;
                  ti = proto_tree_add_text(val_tree, tvb, offset, rem,"ATM Label Range Components");

                  if(numlr) {
                        val_tree=proto_item_add_subtree(ti,ett_ldp_tlv_val);
                        if( ! val_tree ) return;
                  }
                  /*now dissect ranges*/
                  for(ix=1; numlr > 0 && rem >= 8; ix++, rem-=8, numlr--) {
                        ti=proto_tree_add_text(val_tree, tvb, offset, 8,
                         "ATM Label Range Component %u", ix);
                        lbl_tree=proto_item_add_subtree(ti, ett_ldp_tlv_val);

                        if( lbl_tree == NULL ) break;

                        id=tvb_get_ntohs(tvb, offset)&0x0FFF;
                        proto_tree_add_uint_format(lbl_tree,
                            hf_ldp_tlv_sess_atm_minvpi,
                            tvb, offset, 2,
                            id, "Minimum VPI: %u", id);
                        id=tvb_get_ntohs(tvb, offset+4)&0x0FFF;
                        proto_tree_add_uint_format(lbl_tree,
                            hf_ldp_tlv_sess_atm_maxvpi,
                            tvb, (offset+4), 2, id,
                            "Maximum VPI: %u", id);

                        id=tvb_get_ntohs(tvb, offset+2);
                        proto_tree_add_uint_format(lbl_tree,
                            hf_ldp_tlv_sess_atm_minvci,
                            tvb, offset+2, 2,
                            id, "Minimum VCI: %u", id);
                        id=tvb_get_ntohs(tvb, offset+6);
                        proto_tree_add_uint_format(lbl_tree,
                            hf_ldp_tlv_sess_atm_maxvci,
                            tvb, offset+6, 2,
                            id, "Maximum VCI: %u", id);

                        offset += 8;
                  }
                  if( rem || numlr)
                        proto_tree_add_text(val_tree, tvb, offset, rem,
                            "Error processing TLV: Extra data at end of TLV");
            }
      }
}

/* Dissect the frame relay session params */

static void
dissect_tlv_frame_relay_session_parms(tvbuff_t *tvb, guint offset,proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL, *lbl_tree = NULL;
      guint8 numlr, ix, len;
      guint32     id;

      if (tree != NULL) {
            if(rem < 4) {
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing Frame Relay Parameters TLV: length is %d, should be >= 4",
                      rem);
                  return;
            }

            ti = proto_tree_add_text(tree, tvb, offset, rem,
                                     "Frame Relay Parameters");
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree != NULL) {
                  proto_tree_add_item(val_tree, hf_ldp_tlv_sess_fr_merge,
                        tvb, offset, 1, FALSE);

                  /*get the number of label ranges*/
                  numlr=(tvb_get_guint8(tvb, offset)>>2) & 0x0F;
                  proto_tree_add_uint_format(val_tree, hf_ldp_tlv_sess_fr_lr,
                  tvb, offset, 1, numlr, "Number of Label Range components: %u",
                  numlr);

                  proto_tree_add_item(val_tree, hf_ldp_tlv_sess_fr_dir,
                         tvb, offset, 1, FALSE);

                  /*move into range components*/
                  offset += 4;
                  rem -= 4;
                  ti = proto_tree_add_text(val_tree, tvb, offset, rem,
                         "Frame Relay Label Range Components");

                  if(numlr) {
                        val_tree=proto_item_add_subtree(ti,
                                           ett_ldp_tlv_val);
                        if( ! val_tree ) return;
                  }

                  /*now dissect ranges*/
                  for(ix=1; numlr > 0 && rem >= 8; ix++, rem-=8, numlr--) {
                        ti=proto_tree_add_text(val_tree, tvb, offset, 8,
                        "Frame Relay Label Range Component %u", ix);
                        lbl_tree=proto_item_add_subtree(ti, ett_ldp_tlv_val);

                        if( lbl_tree == NULL ) break;

                        len=(guint8)(tvb_get_ntohs(tvb, offset)>>7) & 0x03;
                        proto_tree_add_uint_format(lbl_tree, hf_ldp_tlv_sess_fr_len, tvb, offset, 2, len, "Number of DLCI bits: %s (%u)", val_to_str(len, tlv_fr_len_vals, "Unknown Length"), len);

                        id=tvb_get_ntoh24(tvb, offset+1)&0x7FFFFF;
                        proto_tree_add_uint_format(lbl_tree,
                  hf_ldp_tlv_sess_fr_mindlci, tvb, offset+1, 3, id, "Minimum DLCI %u", id);
                        id=tvb_get_ntoh24(tvb, offset+5)&0x7FFFFF;
                        proto_tree_add_uint_format(lbl_tree,
                  hf_ldp_tlv_sess_fr_maxdlci, tvb, offset+5, 3, id, "Maximum DLCI %u", id);

                        offset += 8;
                  }

                  if( rem || numlr)
                        proto_tree_add_text(val_tree, tvb, offset, rem,
                         "Error processing TLV: Extra data at end of TLV");
            }
      }
}

/* Dissect the Fault Tolerant (FT) Session TLV */

static void
dissect_tlv_ft_session(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
        proto_tree *ti = NULL, *val_tree = NULL, *flags_tree = NULL;
        guint16 flags = 0;

        if (tree != NULL) {
                if(rem != 12){
                        /* error, length must be 12 bytes */
                        proto_tree_add_text(tree, tvb, offset, rem,
                            "Error processing FT Session TLV: length is %d, should be 12",
                            rem);
                        return;
                }

                ti = proto_tree_add_text(tree, tvb, offset, rem, "FT Session Parameters");
                val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

                if(val_tree != NULL) {
                        /* Flags */
                        ti = proto_tree_add_item(val_tree, hf_ldp_tlv_ft_sess_flags, tvb, offset, 2, FALSE);
                        flags_tree = proto_item_add_subtree(ti,  ett_ldp_tlv_ft_flags);
                        if (flags_tree == NULL)
                                return;

                        flags = tvb_get_ntohs(tvb, offset);
                        proto_item_append_text(ti, " (%s%s)", (flags & 0x8000) ? "R, " : "",
                            val_to_str(flags & 0xF, tlv_ft_flags, "Invalid"));
                        proto_tree_add_item(flags_tree, hf_ldp_tlv_ft_sess_flag_r, tvb, offset, 2, FALSE);
                        proto_tree_add_item(flags_tree, hf_ldp_tlv_ft_sess_flag_res, tvb, offset, 2, FALSE);
                        proto_tree_add_item(flags_tree, hf_ldp_tlv_ft_sess_flag_s, tvb, offset, 2, FALSE);
                        proto_tree_add_item(flags_tree, hf_ldp_tlv_ft_sess_flag_a, tvb, offset, 2, FALSE);
                        proto_tree_add_item(flags_tree, hf_ldp_tlv_ft_sess_flag_c, tvb, offset, 2, FALSE);
                        proto_tree_add_item(flags_tree, hf_ldp_tlv_ft_sess_flag_l, tvb, offset, 2, FALSE);

                        /* Reserved */
                        proto_tree_add_item(val_tree, hf_ldp_tlv_ft_sess_res, tvb, offset + 2, 2, FALSE);

                        /* FT Reconnect TO */
                        proto_tree_add_item(val_tree, hf_ldp_tlv_ft_sess_reconn_to, tvb, offset + 4,
                            4, FALSE);

                        /* Recovery Time */
                        proto_tree_add_item(val_tree, hf_ldp_tlv_ft_sess_recovery_time, tvb, offset + 8,
                            4, FALSE);
                }
        }

}

static void
dissect_tlv_lspid(tvbuff_t *tvb, guint offset,proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;

      if (tree != NULL) {
            if(rem != 8) {
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing LSP ID TLV: length is %d, should be 8",
                      rem);
                  return;
            }

            ti = proto_tree_add_text(tree, tvb, offset, rem,
                                    "LSP ID");
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree != NULL) {
                  proto_tree_add_item(val_tree, hf_ldp_tlv_lspid_act_flg,
                                 tvb, offset, 2, FALSE);
                  offset += 2;
                  proto_tree_add_item(val_tree, hf_ldp_tlv_lspid_cr_lsp,
                                 tvb, offset, 2, FALSE);
                  offset += 2;
                  proto_tree_add_item(val_tree, hf_ldp_tlv_lspid_ldpid,
                                 tvb, offset, 4, FALSE);
            }
      }
}

static void
dissect_tlv_er_hop_ipv4(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;


      if (tree != NULL) {
            if(rem != 8) {
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing ER HOP IPv4 TLV: length is %d, should be 8",
                      rem);
                  return;
            }
            ti = proto_tree_add_text(tree, tvb, offset, rem, "ER HOP IPv4");
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree != NULL) {
                  proto_tree_add_item(val_tree, hf_ldp_tlv_er_hop_loose,
                                 tvb, offset, 3, FALSE);
                  offset += 3;
                  proto_tree_add_item(val_tree, hf_ldp_tlv_er_hop_prelen,
                                 tvb, offset, 1, FALSE);
                  offset ++;
                  proto_tree_add_item(val_tree, hf_ldp_tlv_er_hop_prefix4,
                                 tvb, offset, 4, FALSE);
            }
      }
}

static void
dissect_tlv_er_hop_ipv6(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;

      if (tree != NULL) {
            if(rem != 20) {
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing ER HOP IPv6 TLV: length is %d, should be 20",
                      rem);
                  return;
            }
            ti = proto_tree_add_text(tree, tvb, offset, rem, "ER HOP IPv6");
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree != NULL) {
                  proto_tree_add_item(val_tree, hf_ldp_tlv_er_hop_loose,
                                 tvb, offset, 3, FALSE);
                  offset += 3;
                  proto_tree_add_item(val_tree, hf_ldp_tlv_er_hop_prelen,
                                tvb, offset, 1, FALSE);
                  offset ++;
                  proto_tree_add_item(val_tree, hf_ldp_tlv_er_hop_prefix6,
                                 tvb, offset, 16, FALSE);
            }
      }
}

static void
dissect_tlv_er_hop_as(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;

      if (tree != NULL) {
            if(rem != 4) {
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing ER HOP AS TLV: length is %d, should be 4",
                      rem);
                  return;
            }
            ti = proto_tree_add_text(tree, tvb, offset, rem, "ER HOP AS");
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree != NULL) {
                  proto_tree_add_item(val_tree, hf_ldp_tlv_er_hop_loose,
                                 tvb, offset, 2, FALSE);
                  offset += 2;
                  proto_tree_add_item(val_tree, hf_ldp_tlv_er_hop_as,
                                 tvb, offset, 2, FALSE);
            }
      }
}

static void
dissect_tlv_er_hop_lspid(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;

      if (tree != NULL) {
            if(rem != 8) {
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing ER HOP LSPID TLV: length is %d, should be 8",
                      rem);
                  return;
            }
            ti = proto_tree_add_text(tree, tvb, offset, rem, "ER HOP LSPID");
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree != NULL) {
                  proto_tree_add_item(val_tree, hf_ldp_tlv_er_hop_loose,
                                 tvb, offset, 2, FALSE);
                  offset += 2;
                  proto_tree_add_item(val_tree, hf_ldp_tlv_er_hop_cr_lsp,
                                 tvb, offset, 2, FALSE);
                  offset += 2;
                  proto_tree_add_item(val_tree, hf_ldp_tlv_er_hop_ldpid,
                                 tvb, offset, 4, FALSE);
            }
      }
}

static void
dissect_tlv_traffic(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;
      guint8  val_8;
      float   val_f;
      proto_item *pi;

      if (tree != NULL) {
            if(rem != 24) {
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing Traffic Parameters TLV: length is %d, should be 24",
                      rem);
                  return;
            }
            ti = proto_tree_add_text(tree, tvb, offset, rem, "Traffic parameters");
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree != NULL) {
                  /* flags */
                  proto_tree_add_item(val_tree, hf_ldp_tlv_flags_reserv, tvb, offset, 1, FALSE);
                  proto_tree_add_item(val_tree, hf_ldp_tlv_flags_weight, tvb, offset, 1, FALSE);
                  proto_tree_add_item(val_tree, hf_ldp_tlv_flags_ebs, tvb, offset, 1, FALSE);
                  proto_tree_add_item(val_tree, hf_ldp_tlv_flags_cbs, tvb, offset, 1, FALSE);
                  proto_tree_add_item(val_tree, hf_ldp_tlv_flags_cdr, tvb, offset, 1, FALSE);
                  proto_tree_add_item(val_tree, hf_ldp_tlv_flags_pbs, tvb, offset, 1, FALSE);
                  proto_tree_add_item(val_tree, hf_ldp_tlv_flags_pdr, tvb, offset, 1, FALSE);

                  offset ++;
                  /* frequency */
                  proto_tree_add_item(val_tree, hf_ldp_tlv_frequency, tvb, offset, 1, FALSE);
                  offset ++;

                  /* reserver byte */
                  offset ++;

                  /* weight */
                  pi = proto_tree_add_item(val_tree, hf_ldp_tlv_weight, tvb, offset, 1, FALSE);
                  val_8 = tvb_get_guint8(tvb, offset);
                  if (val_8 == 0)
                        proto_item_set_text(pi, "Weight: Not applicable");
                  offset ++;

                  /* PDR */
                  val_f = tvb_get_ntohieee_float (tvb, offset);
                  proto_tree_add_double_format(val_tree, hf_ldp_tlv_pdr, tvb, offset,
                                        4, val_f, "PDR: %.10g Bps", val_f);
                  offset += 4;
                  /* PBS */
                  val_f = tvb_get_ntohieee_float (tvb, offset);
                  proto_tree_add_double_format(val_tree, hf_ldp_tlv_pbs, tvb, offset,
                                        4, val_f, "PBS: %.10g Bytes", val_f);
                  offset += 4;

                  /* CDR */
                  val_f = tvb_get_ntohieee_float (tvb, offset);
                  proto_tree_add_double_format(val_tree, hf_ldp_tlv_cdr, tvb, offset,
                                        4, val_f, "CDR: %.10g Bps", val_f);
                  offset += 4;

                  /* CBS */
                  val_f = tvb_get_ntohieee_float (tvb, offset);
                  proto_tree_add_double_format(val_tree, hf_ldp_tlv_cbs, tvb, offset,
                                        4, val_f, "CBS: %.10g Bytes", val_f);
                  offset += 4;

                  /* EBS */
                  val_f = tvb_get_ntohieee_float (tvb, offset);
                  proto_tree_add_double_format(val_tree, hf_ldp_tlv_ebs, tvb, offset,
                                        4, val_f, "EBS: %.10g Bytes", val_f);

            }
      }
}

static void
dissect_tlv_route_pinning(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;

      if (tree != NULL) {
            if(rem != 4) {
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing Route Pinning TLV: length is %d, should be 4",
                      rem);
                  return;
            }
            ti = proto_tree_add_text(tree, tvb, offset, rem, "Route Pinning");
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree != NULL) {
                  proto_tree_add_item(val_tree, hf_ldp_tlv_route_pinning,
                                 tvb, offset, 4, FALSE);
            }
      }
}


static void
dissect_tlv_resource_class(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;

      if (tree != NULL) {
            if(rem != 4) {
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing Resource Class TLV: length is %d, should be 4",
                      rem);
                  return;
            }
            ti = proto_tree_add_text(tree, tvb, offset, rem, "Resource Class");
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree != NULL) {
                  proto_tree_add_item(val_tree, hf_ldp_tlv_resource_class,
                                 tvb, offset, 4, FALSE);
            }
      }
}


static void
dissect_tlv_preemption(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;

      if (tree != NULL) {
            if(rem != 4) {
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing Preemption TLV: length is %d, should be 4",
                      rem);
                  return;
            }
            ti = proto_tree_add_text(tree, tvb, offset, rem, "Preemption");
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree != NULL) {
                  proto_tree_add_item(val_tree, hf_ldp_tlv_set_prio,
                                 tvb, offset, 1, FALSE);
                  offset += 1;
                  proto_tree_add_item(val_tree, hf_ldp_tlv_hold_prio,
                                 tvb, offset, 1, FALSE);
            }
      }
}


static void
dissect_tlv_diffserv(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
    int type, mapnb, count;
    int *hfindexes[] = {
      &hf_ldp_tlv_diffserv_map,
      &hf_ldp_tlv_diffserv_map_exp,
      &hf_ldp_tlv_diffserv_phbid,
      &hf_ldp_tlv_diffserv_phbid_dscp,
      &hf_ldp_tlv_diffserv_phbid_code,
      &hf_ldp_tlv_diffserv_phbid_bit14,
      &hf_ldp_tlv_diffserv_phbid_bit15
    };
    gint *etts[] = {
      &ett_ldp_diffserv_map,
      &ett_ldp_diffserv_map_phbid
    };

    if (rem < 4) {
      proto_tree_add_text(tree, tvb, offset, rem,
          "Error processing Diff-Serv TLV: length is %d, should be >= 4", rem);
      return;
    }
    proto_tree_add_uint(tree, hf_ldp_tlv_diffserv_type, tvb, offset, 1,
                  type = tvb_get_guint8(tvb, offset));
    type = (type >> 7) + 1;
    if (type == 1) {
        /* E-LSP */
      offset += 3;
      proto_tree_add_uint(tree, hf_ldp_tlv_diffserv_mapnb, tvb, offset,
                      1, mapnb = tvb_get_guint8(tvb, offset) & 15);
      offset += 1;
      for (count = 0; count < mapnb; count++) {
          dissect_diffserv_mpls_common(tvb, tree, type, offset, hfindexes, etts);
          offset += 4;
      }
    }
    else if (type == 2) {
        /* L-LSP */
      dissect_diffserv_mpls_common(tvb, tree, type, offset + 2, hfindexes, etts);
    }
}


static int
dissect_tlv(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem);

static void
dissect_tlv_er(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      proto_tree *ti = NULL, *val_tree = NULL;
      int len;

      if (tree != NULL) {
            ti = proto_tree_add_text(tree, tvb, offset, rem, "Explicit route");
            val_tree = proto_item_add_subtree(ti, ett_ldp_tlv_val);

            if(val_tree != NULL) {
                  len = 0;
                  while (rem > 0) {
                        len = dissect_tlv (tvb, offset, val_tree, rem);
                        offset += len;
                        rem -= len;
                  }
            }
      }
}


/* Dissect a TLV and return the number of bytes consumed ... */

static int
dissect_tlv(tvbuff_t *tvb, guint offset, proto_tree *tree, int rem)
{
      guint16 type, typebak;
      int length;
      proto_tree *ti = NULL, *tlv_tree = NULL;

      length=tvb_reported_length_remaining(tvb, offset);
      rem=MIN(rem, length);

      if( rem < 4 ) {/*chk for minimum header*/
            if(tree)
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing TLV: length is %d, should be >= 4",
                      rem);
            return rem;
      }
      type = tvb_get_ntohs(tvb, offset) & 0x3FFF;

      length = tvb_get_ntohs(tvb, offset + 2),
      rem -= 4; /*do not count header*/
      length = MIN(length, rem);  /* Don't go haywire if a problem ... */

      if (tree != NULL) {
            /*chk for vendor-private*/
            if(type>=TLV_VENDOR_PRIVATE_START && type<=TLV_VENDOR_PRIVATE_END){
                  typebak=type;           /*keep type*/
                  type=TLV_VENDOR_PRIVATE_START;

            /*chk for experimental*/
            } else if(type>=TLV_EXPERIMENTAL_START && type<=TLV_EXPERIMENTAL_END){
                  typebak=type;           /*keep type*/
                  type=TLV_EXPERIMENTAL_START;
            }

            ti = proto_tree_add_text(tree, tvb, offset, length + 4, "%s",
                  val_to_str(type, tlv_type_names, "Unknown TLV type (0x%04X)"));
            tlv_tree = proto_item_add_subtree(ti, ett_ldp_tlv);
            if(tlv_tree == NULL) return length+4;

            proto_tree_add_item(tlv_tree, hf_ldp_tlv_unknown, tvb, offset, 1, FALSE);

            proto_tree_add_uint_format(tlv_tree, hf_ldp_tlv_type, tvb, offset, 2, type, "TLV Type: %s (0x%X)", val_to_str(type, tlv_type_names, "Unknown TLV type"), type );

            proto_tree_add_item(tlv_tree, hf_ldp_tlv_len, tvb, offset + 2, 2, FALSE);

            switch (type) {

            case TLV_FEC:
                  dissect_tlv_fec(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_ADDRESS_LIST:
                  dissect_tlv_address_list(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_HOP_COUNT:
                  if( length != 1 ) /*error, only one byte*/
                        proto_tree_add_text(tlv_tree, tvb, offset + 4,length,
                            "Error processing Hop Count TLV: length is %d, should be 1",
                            length);
                  else
                        proto_tree_add_item(tlv_tree, hf_ldp_tlv_hc_value, tvb,offset + 4, length, FALSE);
                  break;

            case TLV_PATH_VECTOR:
                  dissect_tlv_path_vector(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_GENERIC_LABEL:
                  if( length != 4 ) /*error, need only label*/
                        proto_tree_add_text(tlv_tree, tvb, offset + 4, length,
                            "Error processing Generic Label TLV: length is %d, should be 4",
                            length);
                  else {
                        guint32 label=tvb_get_ntohl(tvb, offset+4) & 0x000FFFFF;

                        proto_tree_add_uint_format(tlv_tree, hf_ldp_tlv_generic_label,
                              tvb, offset+4, length, label, "Generic Label: %u", label);
                  }
                  break;

            case TLV_ATM_LABEL:
                  dissect_tlv_atm_label(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_FRAME_LABEL:
                  dissect_tlv_frame_label(tvb, offset + 4, tlv_tree, length);
                  break;

                case TLV_FT_PROTECTION:
                        if( length != 4 ) /* Length must be 4 bytes */
                                proto_tree_add_text(tlv_tree, tvb, offset + 4, length,
                                    "Error processing FT Protection TLV: length is %d, should be 4",
                                    length);
                        else
                                proto_tree_add_item(tlv_tree, hf_ldp_tlv_ft_protect_sequence_num, tvb,
                                    offset + 4,length, FALSE);
                        break;

            case TLV_STATUS:
                  dissect_tlv_status(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_EXTENDED_STATUS:
                  if( length != 4 ) /*error, need only status_code(guint32)*/
                        proto_tree_add_text(tlv_tree, tvb, offset + 4, length,
                            "Error processing Extended Status TLV: length is %d, should be 4",
                            length);
                  else {
                        proto_tree_add_item(tlv_tree, hf_ldp_tlv_extstatus_data, tvb, offset + 4, length, FALSE);
                  }
                  break;

            case TLV_RETURNED_PDU:
                  dissect_tlv_returned_pdu(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_RETURNED_MESSAGE:
                  dissect_tlv_returned_message(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_COMMON_HELLO_PARMS:
#if 0
                  dissect_tlv_common_hello_parms(tvb, offset + 4, tlv_tree, length);
#else
                  dissect_tlv_common_hello_parms(tvb, offset + 4, tlv_tree);
#endif
                  break;

            case TLV_IPV4_TRANSPORT_ADDRESS:
                  if( length != 4 ) /*error, need only ipv4*/
                        proto_tree_add_text(tlv_tree, tvb, offset + 4, length,
                            "Error processing IPv4 Transport Address TLV: length is %d, should be 4",
                            length);
                  else {
                        proto_tree_add_item(tlv_tree, hf_ldp_tlv_ipv4_taddr, tvb, offset + 4, 4, FALSE);
                  }
                  break;

            case TLV_CONFIGURATION_SEQNO:
                  if( length != 4 ) /*error, need only seq_num(guint32)*/
                        proto_tree_add_text(tlv_tree, tvb, offset + 4, length,
                            "Error processing Configuration Sequence Number TLV: length is %d, should be 4",
                            length);
                  else {
                        proto_tree_add_item(tlv_tree, hf_ldp_tlv_config_seqno, tvb, offset + 4, 4, FALSE);
                  }
                  break;

            case TLV_IPV6_TRANSPORT_ADDRESS:
                  if( length != 16 ) /*error, need only ipv6*/
                        proto_tree_add_text(tlv_tree, tvb, offset + 4, length,
                            "Error processing IPv6 Transport Address TLV: length is %d, should be 16",
                            length);
                  else {
                        proto_tree_add_item(tlv_tree, hf_ldp_tlv_ipv6_taddr, tvb, offset + 4, 16, FALSE);
                  }
                  break;

            case TLV_MAC: /* draft-lasserre-vkompella-ppvpn-vpls-02.txt */
                  dissect_tlv_mac(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_COMMON_SESSION_PARMS:
                  dissect_tlv_common_session_parms(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_ATM_SESSION_PARMS:
                  dissect_tlv_atm_session_parms(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_FRAME_RELAY_SESSION_PARMS:
                  dissect_tlv_frame_relay_session_parms(tvb, offset + 4, tlv_tree, length);
                  break;

                case TLV_FT_SESSION:
                        /* Used in RFC3478 LDP Graceful Restart */
                        dissect_tlv_ft_session(tvb, offset + 4, tlv_tree, length);
                        break;

                case TLV_FT_ACK:
                        if( length != 4 ) /* Length must be 4 bytes */
                                proto_tree_add_text(tlv_tree, tvb, offset + 4, length,
                                    "Error processing FT ACK TLV: length is %d, should be 4",
                                    length);
                        else
                                proto_tree_add_item(tlv_tree, hf_ldp_tlv_ft_ack_sequence_num, tvb,
                                    offset + 4,length, FALSE);
                        break;

                case TLV_FT_CORK:
                        if( length != 0 ) /* Length must be 0 bytes */
                                proto_tree_add_text(tlv_tree, tvb, offset + 4, length,
                                    "Error processing FT Cork TLV: length is %d, should be 0",      
                                    length);
                        break;

            case TLV_LABEL_REQUEST_MESSAGE_ID:
                  if( length != 4 ) /*error, need only one msgid*/
                        proto_tree_add_text(tlv_tree, tvb, offset + 4, length,
                            "Error processing Label Request Message ID TLV: length is %d, should be 4",
                            length);
                  else
                        proto_tree_add_item(tlv_tree, hf_ldp_tlv_lbl_req_msg_id, tvb,offset + 4,length, FALSE);
                  break;

            case TLV_LSPID:
                  dissect_tlv_lspid(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_ER:
                  dissect_tlv_er(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_ER_HOP_IPV4:
                  dissect_tlv_er_hop_ipv4(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_ER_HOP_IPV6:
                  dissect_tlv_er_hop_ipv6(tvb, offset +4, tlv_tree, length);
                  break;

            case TLV_ER_HOP_AS:
                  dissect_tlv_er_hop_as(tvb, offset + 4, tlv_tree, length);
                  break;

            case TLV_ER_HOP_LSPID:
                  dissect_tlv_er_hop_lspid(tvb, offset +4, tlv_tree, length);
                  break;

            case TLV_TRAFFIC_PARAM:
                  dissect_tlv_traffic(tvb, offset +4, tlv_tree, length);
                  break;

            case TLV_PREEMPTION:
                  dissect_tlv_preemption(tvb, offset +4, tlv_tree, length);
                  break;

            case TLV_RESOURCE_CLASS:
                  dissect_tlv_resource_class(tvb, offset +4, tlv_tree, length);
                  break;

            case TLV_ROUTE_PINNING:
                  dissect_tlv_route_pinning(tvb, offset +4, tlv_tree, length);
                  break;

            case TLV_DIFFSERV:
                  dissect_tlv_diffserv(tvb, offset +4, tlv_tree, length);
                  break;

            case TLV_VENDOR_PRIVATE_START:
                  if( length < 4 ) /*error, at least Vendor ID*/
                        proto_tree_add_text(tlv_tree, tvb, offset + 4, length,
                            "Error processing Vendor Private Start TLV: length is %d, should be >= 4",
                            length);
                  else {
                        proto_tree_add_item(tlv_tree, hf_ldp_tlv_vendor_id, tvb,offset + 4, 4, FALSE);
                        if( length > 4 )  /*have data*/
                              proto_tree_add_text(tlv_tree, tvb, offset + 8, length-4,"Data");
                  }
                  break;

            case TLV_EXPERIMENTAL_START:
                  if( length < 4 ) /*error, at least Experiment ID*/
                        proto_tree_add_text(tlv_tree, tvb, offset + 4, length,
                            "Error processing Experimental Start TLV: length is %d, should be >= 4",
                            length);
                  else {
                        proto_tree_add_item(tlv_tree, hf_ldp_tlv_experiment_id, tvb,offset + 4, 4, FALSE);
                        if( length > 4 )  /*have data*/
                              proto_tree_add_text(tlv_tree, tvb, offset + 8, length-4,"Data");
                  }
                  break;

            default:
                  proto_tree_add_item(tlv_tree, hf_ldp_tlv_value, tvb, offset + 4, length, FALSE);
                  break;
            }
      }

      return length + 4;  /* Length of the value field + header */
}


/* Dissect a Message and return the number of bytes consumed ... */

static int
dissect_msg(tvbuff_t *tvb, guint offset, packet_info *pinfo, proto_tree *tree)
{
      guint16 type, typebak;
      guint8      extra=0;
      int length, rem, ao=0, co;
      proto_tree *ti = NULL, *msg_tree = NULL;

      rem=tvb_reported_length_remaining(tvb, offset);

      if( rem < 8 ) {/*chk for minimum header = type + length + msg_id*/
            if( check_col(pinfo->cinfo, COL_INFO) )
                  col_append_fstr(pinfo->cinfo, COL_INFO, "Bad Message");
            if(tree)
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing Message: length is %d, should be >= 8",
                      rem);
            return rem;
      }
      type = tvb_get_ntohs(tvb, offset) & 0x7FFF;

      /*chk for vendor-private*/
      if(type>=LDP_VENDOR_PRIVATE_START && type<=LDP_VENDOR_PRIVATE_END){
            typebak=type;           /*keep type*/
            type=LDP_VENDOR_PRIVATE_START;
            extra=4;
      /*chk for experimental*/
      } else if(type>=LDP_EXPERIMENTAL_MESSAGE_START && type<=LDP_EXPERIMENTAL_MESSAGE_END){
            typebak=type;           /*keep type*/
            type=LDP_EXPERIMENTAL_MESSAGE_START;
            extra=4;
      }

      if( (length = tvb_get_ntohs(tvb, offset + 2)) < (4+extra) ) {/*not enough data for type*/
            if( check_col(pinfo->cinfo, COL_INFO) )
                  col_append_fstr(pinfo->cinfo, COL_INFO, "Bad Message Length ");
            if(tree)
                  proto_tree_add_text(tree, tvb, offset, rem,
                      "Error processing Message Length: length is %d, should be >= %u",
                      length, 4+extra);
            return rem;
      }
      rem -= 4;
      length = MIN(length, rem);  /* Don't go haywire if a problem ... */

      if( check_col(pinfo->cinfo, COL_INFO) ){
            col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", val_to_str(type, ldp_message_types, "Unknown Message (0x%04X)"));
      }

      if( tree ){
            ti = proto_tree_add_text(tree, tvb, offset, length + 4, "%s",
                  val_to_str(type, ldp_message_types, "Unknown Message type (0x%04X)"));
            msg_tree = proto_item_add_subtree(ti, ett_ldp_message);
            if(msg_tree == NULL) return length+4;

            proto_tree_add_item(msg_tree, hf_ldp_msg_ubit, tvb, offset, 1, FALSE);

            type=tvb_get_ntohs(tvb, offset)&0x7FFF;
            proto_tree_add_uint_format(msg_tree, hf_ldp_msg_type, tvb, offset, 2, type, "Message Type: %s (0x%X)", val_to_str(type, ldp_message_types,"Unknown Message Type"), type);

            proto_tree_add_item(msg_tree, hf_ldp_msg_len, tvb, offset+2, 2, FALSE);
            proto_tree_add_item(msg_tree, hf_ldp_msg_id, tvb, offset+4, 4, FALSE);
            if(extra){
                  int hf_tmp=0;

                  switch(type){
                        case LDP_VENDOR_PRIVATE_START:
                              hf_tmp=hf_ldp_msg_vendor_id;
                              break;
                        case LDP_EXPERIMENTAL_MESSAGE_START:
                              hf_tmp=hf_ldp_msg_experiment_id;
                              break;
                  }
                  proto_tree_add_item(msg_tree, hf_tmp, tvb, offset+8, extra, FALSE);
            }
      }

      offset += (8+extra);
      length -= (4+extra);

      if( tree )
            while( (length-ao) > 0 ) {
                  co=dissect_tlv(tvb, offset, msg_tree, length-ao);
                  offset += co;
                  ao += co;
            }

      return length+8+extra;
}

/* Dissect a PDU */
static void
dissect_ldp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
      int offset = 0, co;
      int rem, length;
      proto_tree *ti=NULL, *pdu_tree = NULL;

      if (check_col(pinfo->cinfo, COL_PROTOCOL))
            col_set_str(pinfo->cinfo, COL_PROTOCOL, "LDP");

      if (check_col(pinfo->cinfo, COL_INFO))
            col_clear(pinfo->cinfo, COL_INFO);

      if( tree ){
            ti=proto_tree_add_item(tree, proto_ldp, tvb, 0, -1, FALSE);
            pdu_tree = proto_item_add_subtree(ti, ett_ldp);

            proto_tree_add_item(pdu_tree, hf_ldp_version, tvb, offset, 2, FALSE);
      }

      length = tvb_get_ntohs(tvb, offset+2);
      if( tree )
            proto_tree_add_uint(pdu_tree, hf_ldp_pdu_len, tvb, offset+2, 2, length);

      length += 4;      /* add the version and type sizes */
      rem = tvb_reported_length_remaining(tvb, offset);
      if (length < rem)
            tvb_set_reported_length(tvb, length);

      if( tree ){
            proto_tree_add_item(pdu_tree, hf_ldp_lsr, tvb, offset+4, 4, FALSE);
            proto_tree_add_item(pdu_tree, hf_ldp_ls_id, tvb, offset+8, 2, FALSE);
      }
      offset += 10;

      while( tvb_reported_length_remaining(tvb, offset) > 0 ) {
            co=dissect_msg(tvb, offset, pinfo, pdu_tree);
            offset += co;
      }
}

static int
dissect_ldp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
      /*
       * Make sure the first PDU has a version number of 1;
       * if not, reject this, so we don't get confused by
       * packets that happen to be going to or from the
       * LDP port but that aren't LDP packets.
       */
      if (!tvb_bytes_exist(tvb, 0, 2)) {
            /*
             * Not enough information to tell.
             */
            return 0;
      }
      if (tvb_get_ntohs(tvb, 0) != 1) {
            /*
             * Not version 1.
             */
            return 0;
      }

      dissect_ldp_pdu(tvb, pinfo, tree);

      /*
       * XXX - return minimum of this and the length of the PDU?
       */
      return tvb_length(tvb);
}

static int
dissect_ldp_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
      volatile gboolean first = TRUE;
      volatile int offset = 0;
      int length_remaining;
      guint16 plen;
      int length;
      tvbuff_t *next_tvb;

      while (tvb_reported_length_remaining(tvb, offset) != 0) {
            length_remaining = tvb_length_remaining(tvb, offset);

            /*
             * Make sure the first PDU has a version number of 1;
             * if not, reject this, so we don't get confused by
             * packets that happen to be going to or from the
             * LDP port but that aren't LDP packets.
             *
             * XXX - this means we can't handle an LDP PDU of which
             * only one byte appears in a TCP segment.  If that's
             * a problem, we'll either have to completely punt on
             * rejecting non-LDP packets, or will have to assume
             * that if we have only one byte, it's an LDP packet.
             */
            if (first) {
                  if (length_remaining < 2) {
                        /*
                         * Not enough information to tell.
                         */
                        return 0;
                  }
                  if (tvb_get_ntohs(tvb, offset) != 1) {
                        /*
                         * Not version 1.
                         */
                        return 0;
                  }
                  first = FALSE;
            }

            /*
             * Can we do reassembly?
             */
            if (ldp_desegment && pinfo->can_desegment) {
                  /*
                   * Yes - is the LDP header split across segment
                   * boundaries?
                   */
                  if (length_remaining < 4) {
                        /*
                         * Yes.  Tell the TCP dissector where
                         * the data for this message starts in
                         * the data it handed us, and how many
                         * more bytes we need, and return.
                         */
                        pinfo->desegment_offset = offset;
                        pinfo->desegment_len = 4 - length_remaining;
                        return -((gint32) pinfo->desegment_len);
                  }
            }

            /*
             * Get the length of the rest of the LDP packet.
             * XXX - check for a version of 1 first?
             */
            plen = tvb_get_ntohs(tvb, offset + 2);

            /*
             * Can we do reassembly?
             */
            if (ldp_desegment && pinfo->can_desegment) {
                  /*
                   * Yes - is the LDP packet split across segment
                   * boundaries?
                   */
                  if (length_remaining < plen + 4) {
                        /*
                         * Yes.  Tell the TCP dissector where the
                         * data for this message starts in the data
                         * it handed us, and how many more bytes we
                         * need, and return.
                         */
                        pinfo->desegment_offset = offset;
                        pinfo->desegment_len =
                            (plen + 4) - length_remaining;
                        return -((gint32) pinfo->desegment_len);
                  }
            }

            /*
             * Construct a tvbuff containing the amount of the payload
             * we have available.  Make its reported length the
             * amount of data in the DNS-over-TCP packet.
             *
             * XXX - if reassembly isn't enabled. the subdissector
             * will throw a BoundsError exception, rather than a
             * ReportedBoundsError exception.  We really want
             * a tvbuff where the length is "length", the reported
             * length is "plen + 4", and the "if the snapshot length
             * were infinite" length is the minimum of the
             * reported length of the tvbuff handed to us and "plen+4",
             * with a new type of exception thrown if the offset is
             * within the reported length but beyond that third length,
             * with that exception getting the "Unreassembled Packet"
             * error.
             */
            length = length_remaining;
            if (length > plen + 4)
                  length = plen + 4;
            next_tvb = tvb_new_subset(tvb, offset, length, plen + 4);

            /*
             * Dissect the LDP packet.
             *
             * Catch the ReportedBoundsError exception; if this
             * particular message happens to get a ReportedBoundsError
             * exception, that doesn't mean that we should stop
             * dissecting LDP messages within this frame or chunk of
             * reassembled data.
             *
             * If it gets a BoundsError, we can stop, as there's nothing
             * more to see, so we just re-throw it.
             */
            TRY {
                  dissect_ldp_pdu(next_tvb, pinfo, tree);
            }
            CATCH(BoundsError) {
                  RETHROW;
            }
            CATCH(ReportedBoundsError) {
                  show_reported_bounds_error(tvb, pinfo, tree);
            }
            ENDTRY;

            /*
             * Skip the LDP header and the payload.
             */
            offset += plen + 4;
      }
      return tvb_length(tvb);
}

/* Register all the bits needed with the filtering engine */

void
proto_register_ldp(void)
{
  static hf_register_info hf[] = {
    { &hf_ldp_req,
      /* Change the following to the type you need */
      { "Request", "ldp.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},

    { &hf_ldp_rsp,
      { "Response", "ldp.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},

    { &hf_ldp_version,
      { "Version", "ldp.hdr.version", FT_UINT16, BASE_DEC, NULL, 0x0, "LDP Version Number", HFILL }},

    { &hf_ldp_pdu_len,
      { "PDU Length", "ldp.hdr.pdu_len", FT_UINT16, BASE_DEC, NULL, 0x0, "LDP PDU Length", HFILL }},

    { &hf_ldp_lsr,
      { "LSR ID", "ldp.hdr.ldpid.lsr", FT_IPv4, BASE_HEX, NULL, 0x0, "LDP Label Space Router ID", HFILL }},

    { &hf_ldp_ls_id,
      { "Label Space ID", "ldp.hdr.ldpid.lsid", FT_UINT16, BASE_DEC, NULL, 0, "LDP Label Space ID", HFILL }},

    { &hf_ldp_msg_ubit,
      { "U bit", "ldp.msg.ubit", FT_BOOLEAN, 8, TFS(&ldp_message_ubit), 0x80, "Unknown Message Bit", HFILL }},

    { &hf_ldp_msg_type,
      { "Message Type", "ldp.msg.type", FT_UINT16, BASE_HEX, VALS(ldp_message_types), 0x7FFF, "LDP message type", HFILL }},

    { &hf_ldp_msg_len,
      { "Message Length", "ldp.msg.len", FT_UINT16, BASE_DEC, NULL, 0x0, "LDP Message Length (excluding message type and len)", HFILL }},

    { &hf_ldp_msg_id,
      { "Message ID", "ldp.msg.id", FT_UINT32, BASE_HEX, NULL, 0x0, "LDP Message ID", HFILL }},

    { &hf_ldp_msg_vendor_id,
      { "Vendor ID", "ldp.msg.vendor.id", FT_UINT32, BASE_HEX, NULL, 0x0, "LDP Vendor-private Message ID", HFILL }},

    { &hf_ldp_msg_experiment_id,
      { "Experiment ID", "ldp.msg.experiment.id", FT_UINT32, BASE_HEX, NULL, 0x0, "LDP Experimental Message ID", HFILL }},

    { &hf_ldp_tlv_unknown,
      { "TLV Unknown bits", "ldp.msg.tlv.unknown", FT_UINT8, BASE_HEX, VALS(tlv_unknown_vals), 0xC0, "TLV Unknown bits Field", HFILL }},

    { &hf_ldp_tlv_type,
      { "TLV Type", "ldp.msg.tlv.type", FT_UINT16, BASE_HEX, VALS(tlv_type_names), 0x3FFF, "TLV Type Field", HFILL }},

    { &hf_ldp_tlv_len,
      {"TLV Length", "ldp.msg.tlv.len", FT_UINT16, BASE_DEC, NULL, 0x0, "TLV Length Field", HFILL }},

    { &hf_ldp_tlv_value,
      { "TLV Value", "ldp.msg.tlv.value", FT_BYTES, BASE_NONE, NULL, 0x0, "TLV Value Bytes", HFILL }},

    { &hf_ldp_tlv_val_hold,
      { "Hold Time", "ldp.msg.tlv.hello.hold", FT_UINT16, BASE_DEC, NULL, 0x0, "Hello Common Parameters Hold Time", HFILL }},

    { &hf_ldp_tlv_val_target,
      { "Targeted Hello", "ldp.msg.tlv.hello.targeted", FT_BOOLEAN, 16, TFS(&hello_targeted_vals), 0x8000, "Hello Common Parameters Targeted Bit", HFILL }},

    { &hf_ldp_tlv_val_request,
      { "Hello Requested", "ldp.msg.tlv.hello.requested", FT_BOOLEAN, 16, TFS(&hello_requested_vals), 0x4000, "Hello Common Parameters Hello Requested Bit", HFILL }},

    { &hf_ldp_tlv_val_res,
      { "Reserved", "ldp.msg.tlv.hello.res", FT_UINT16, BASE_HEX, NULL, 0x3FFF, "Hello Common Parameters Reserved Field", HFILL }},

    { &hf_ldp_tlv_ipv4_taddr,
      { "IPv4 Transport Address", "ldp.msg.tlv.ipv4.taddr", FT_IPv4, BASE_DEC, NULL, 0x0, "IPv4 Transport Address", HFILL }},

    { &hf_ldp_tlv_config_seqno,
      { "Configuration Sequence Number", "ldp.msg.tlv.hello.cnf_seqno", FT_UINT32, BASE_DEC, NULL, 0x0, "Hello Configuration Sequence Number", HFILL }},

    { &hf_ldp_tlv_ipv6_taddr,
      { "IPv6 Transport Address", "ldp.msg.tlv.ipv6.taddr", FT_IPv6, BASE_DEC, NULL, 0x0, "IPv6 Transport Address", HFILL }},

    { &hf_ldp_tlv_fec_wc,
      { "FEC Element Type", "ldp.msg.tlv.fec.type", FT_UINT8, BASE_DEC, VALS(fec_types), 0x0, "Forwarding Equivalence Class Element Types", HFILL }},

    { &hf_ldp_tlv_fec_af,
      { "FEC Element Address Type", "ldp.msg.tlv.fec.af", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, "Forwarding Equivalence Class Element Address Family", HFILL }},

    { &hf_ldp_tlv_fec_len,
      { "FEC Element Length", "ldp.msg.tlv.fec.len", FT_UINT8, BASE_DEC, NULL, 0x0, "Forwarding Equivalence Class Element Length", HFILL }},

    { &hf_ldp_tlv_fec_pfval,
      { "FEC Element Prefix Value", "ldp.msg.tlv.fec.pfval", FT_STRING, BASE_NONE, NULL, 0x0, "Forwarding Equivalence Class Element Prefix", HFILL }},

    { &hf_ldp_tlv_fec_hoval,
      { "FEC Element Host Address Value", "ldp.msg.tlv.fec.hoval", FT_STRING, BASE_NONE, NULL, 0x0, "Forwarding Equivalence Class Element Address", HFILL }},

    { &hf_ldp_tlv_addrl_addr_family,
      { "Address Family", "ldp.msg.tlv.addrl.addr_family", FT_UINT16, BASE_DEC, VALS(afn_vals), 0x0, "Address Family List", HFILL }},

    { &hf_ldp_tlv_addrl_addr,
      { "Address", "ldp.msg.tlv.addrl.addr", FT_STRING, BASE_NONE, NULL, 0x0, "Address", HFILL }},

    { &hf_ldp_tlv_hc_value,
      { "Hop Count Value", "ldp.msg.tlv.hc.value", FT_UINT8, BASE_DEC, NULL, 0x0, "Hop Count", HFILL }},

    { &hf_ldp_tlv_pv_lsrid,
      { "LSR Id", "ldp.msg.tlv.pv.lsrid", FT_IPv4, BASE_DEC, NULL, 0x0, "Path Vector LSR Id", HFILL }},

    { &hf_ldp_tlv_sess_ver,
      { "Session Protocol Version", "ldp.msg.tlv.sess.ver", FT_UINT16, BASE_DEC, NULL, 0x0, "Common Session Parameters Protocol Version", HFILL }},

    { &hf_ldp_tlv_sess_ka,
      { "Session KeepAlive Time", "ldp.msg.tlv.sess.ka", FT_UINT16, BASE_DEC, NULL, 0x0, "Common Session Parameters KeepAlive Time", HFILL }},

    { &hf_ldp_tlv_sess_advbit,
      { "Session Label Advertisement Discipline", "ldp.msg.tlv.sess.advbit",
 FT_BOOLEAN, 8, TFS(&tlv_sess_advbit_vals), 0x80,
      "Common Session Parameters Label Advertisement Discipline", HFILL }},

    { &hf_ldp_tlv_sess_ldetbit,
      { "Session Loop Detection", "ldp.msg.tlv.sess.ldetbit", FT_BOOLEAN, 8, TFS(&tlv_sess_ldetbit_vals), 0x40, "Common Session Parameters Loop Detection", HFILL }},

    { &hf_ldp_tlv_sess_pvlim,
      { "Session Path Vector Limit", "ldp.msg.tlv.sess.pvlim", FT_UINT8, BASE_DEC, NULL, 0x0, "Common Session Parameters Path Vector Limit", HFILL }},

    { &hf_ldp_tlv_sess_mxpdu,
      { "Session Max PDU Length", "ldp.msg.tlv.sess.mxpdu", FT_UINT16, BASE_DEC, NULL, 0x0, "Common Session Parameters Max PDU Length", HFILL }},

    { &hf_ldp_tlv_sess_rxlsr,
      { "Session Receiver LSR Identifier", "ldp.msg.tlv.sess.rxlsr", FT_IPv4, BASE_DEC, NULL, 0x0, "Common Session Parameters LSR Identifier", HFILL }},

    { &hf_ldp_tlv_sess_rxls,
      { "Session Receiver Label Space Identifier", "ldp.msg.tlv.sess.rxlsr", FT_UINT16, BASE_DEC, NULL, 0x0, "Common Session Parameters Receiver Label Space Identifier", HFILL }},

    { &hf_ldp_tlv_sess_atm_merge,
      { "Session ATM Merge Parameter", "ldp.msg.tlv.sess.atm.merge", FT_UINT8, BASE_DEC, VALS(tlv_atm_merge_vals), 0xC0, "Merge ATM Session Parameters", HFILL }},

    { &hf_ldp_tlv_sess_atm_lr,
      { "Number of ATM Label Ranges", "ldp.msg.tlv.sess.atm.lr", FT_UINT8, BASE_DEC, NULL, 0x3C, "Number of Label Ranges", HFILL }},

    { &hf_ldp_tlv_sess_atm_dir,
      { "Directionality", "ldp.msg.tlv.sess.atm.dir", FT_BOOLEAN, 8, TFS(&tlv_atm_dirbit), 0x02, "Label Directionality", HFILL }},

    { &hf_ldp_tlv_sess_atm_minvpi,
      { "Minimum VPI", "ldp.msg.tlv.sess.atm.minvpi", FT_UINT16, BASE_DEC, NULL, 0x0FFF, "Minimum VPI", HFILL }},

    { &hf_ldp_tlv_sess_atm_minvci,
      { "Minimum VCI", "ldp.msg.tlv.sess.atm.minvci", FT_UINT16, BASE_DEC, NULL, 0x0, "Minimum VCI", HFILL }},

    { &hf_ldp_tlv_sess_atm_maxvpi,
      { "Maximum VPI", "ldp.msg.tlv.sess.atm.maxvpi", FT_UINT16, BASE_DEC, NULL, 0x0FFF, "Maximum VPI", HFILL }},

    { &hf_ldp_tlv_sess_atm_maxvci,
      { "Maximum VCI", "ldp.msg.tlv.sess.atm.maxvci", FT_UINT16, BASE_DEC, NULL, 0x0, "Maximum VCI", HFILL }},

    { &hf_ldp_tlv_sess_fr_merge,
      { "Session Frame Relay Merge Parameter", "ldp.msg.tlv.sess.fr.merge", FT_UINT8, BASE_DEC, VALS(tlv_fr_merge_vals), 0xC0, "Merge Frame Relay Session Parameters", HFILL }},

    { &hf_ldp_tlv_sess_fr_lr,
      { "Number of Frame Relay Label Ranges", "ldp.msg.tlv.sess.fr.lr", FT_UINT8, BASE_DEC, NULL, 0x3C, "Number of Label Ranges", HFILL }},

    { &hf_ldp_tlv_sess_fr_dir,
      { "Directionality", "ldp.msg.tlv.sess.fr.dir", FT_BOOLEAN, 8, TFS(&tlv_atm_dirbit), 0x02, "Label Directionality", HFILL }},

    { &hf_ldp_tlv_sess_fr_len,
      { "Number of DLCI bits", "ldp.msg.tlv.sess.fr.len", FT_UINT16, BASE_DEC, VALS(tlv_fr_len_vals), 0x0180, "DLCI Number of bits", HFILL }},

    { &hf_ldp_tlv_sess_fr_mindlci,
      { "Minimum DLCI", "ldp.msg.tlv.sess.fr.mindlci", FT_UINT24, BASE_DEC, NULL, 0x7FFFFF, "Minimum DLCI", HFILL }},

    { &hf_ldp_tlv_sess_fr_maxdlci,
      { "Maximum DLCI", "ldp.msg.tlv.sess.fr.maxdlci", FT_UINT24, BASE_DEC, NULL, 0x7FFFFF, "Maximum DLCI", HFILL }},

    { &hf_ldp_tlv_ft_sess_flags,
      { "Flags", "ldp.msg.tlv.ft_sess.flags", FT_UINT16, BASE_HEX, NULL, 0x0, "FT Session Flags", HFILL }},

    { &hf_ldp_tlv_ft_sess_flag_r,
      { "R bit", "ldp.msg.tlv.ft_sess.flag_r", FT_BOOLEAN, 16, TFS(&tlv_ft_r), 0x8000, "FT Reconnect Flag", HFILL }},

    { &hf_ldp_tlv_ft_sess_flag_res,
      { "Reserved", "ldp.msg.tlv.ft_sess.flag_res", FT_UINT16, BASE_HEX, NULL, 0x7FF0, "Reserved bits", HFILL }},

    { &hf_ldp_tlv_ft_sess_flag_s,
      { "S bit", "ldp.msg.tlv.ft_sess.flag_s", FT_BOOLEAN, 16, TFS(&tlv_ft_s), 0x8, "Save State Flag", HFILL }},

    { &hf_ldp_tlv_ft_sess_flag_a,
      { "A bit", "ldp.msg.tlv.ft_sess.flag_a", FT_BOOLEAN, 16, TFS(&tlv_ft_a), 0x4, "All-Label protection Required", HFILL }},

    { &hf_ldp_tlv_ft_sess_flag_c,
      { "C bit", "ldp.msg.tlv.ft_sess.flag_c", FT_BOOLEAN, 16, TFS(&tlv_ft_c), 0x2, "Check-Pointint Flag", HFILL }},

    { &hf_ldp_tlv_ft_sess_flag_l,
      { "L bit", "ldp.msg.tlv.ft_sess.flag_l", FT_BOOLEAN, 16, TFS(&tlv_ft_l), 0x1, "Learn From network Flag", HFILL }},

    { &hf_ldp_tlv_ft_sess_res,
      { "Reserved", "ldp.msg.tlv.ft_sess.res", FT_UINT16, BASE_HEX, NULL, 0x0, "Reserved", HFILL }},

    { &hf_ldp_tlv_ft_sess_reconn_to,
      { "Reconnect Timeout", "ldp.msg.tlv.ft_sess.reconn_to", FT_UINT32, BASE_DEC, NULL, 0x0, "FT Reconnect Timeout", HFILL }},

    { &hf_ldp_tlv_ft_sess_recovery_time,
      { "Recovery Time", "ldp.msg.tlv.ft_sess.recovery_time", FT_UINT32, BASE_DEC, NULL, 0x0, "Recovery Time", HFILL }},

    { &hf_ldp_tlv_ft_ack_sequence_num,
      { "FT ACK Sequence Number", "ldp.msg.tlv.ft_ack.sequence_num", FT_UINT32, BASE_HEX, NULL, 0x0, "FT ACK Sequence Number", HFILL }},

    { &hf_ldp_tlv_lbl_req_msg_id,
      { "Label Request Message ID", "ldp.tlv.lbl_req_msg_id", FT_UINT32, BASE_HEX, NULL, 0x0, "Label Request Message to be aborted", HFILL }},

    { &hf_ldp_tlv_vendor_id,
      { "Vendor ID", "ldp.msg.tlv.vendor_id", FT_UINT32, BASE_HEX, NULL, 0, "IEEE 802 Assigned Vendor ID", HFILL }},

    { &hf_ldp_tlv_experiment_id,
      { "Experiment ID", "ldp.msg.tlv.experiment_id", FT_UINT32, BASE_HEX, NULL, 0, "Experiment ID", HFILL }},

    { &hf_ldp_tlv_generic_label,
      { "Generic Label", "ldp.msg.tlv.generic.label", FT_UINT32, BASE_HEX, NULL, 0x000FFFFF, "Generic Label", HFILL }},

    { &hf_ldp_tlv_atm_label_vbits,
      { "V-bits", "ldp.msg.tlv.atm.label.vbits", FT_UINT8, BASE_HEX, VALS(tlv_atm_vbits_vals), 0x30, "ATM Label V Bits", HFILL }},

    { &hf_ldp_tlv_atm_label_vpi,
      { "VPI", "ldp.msg.tlv.atm.label.vpi", FT_UINT16, BASE_DEC, NULL, 0x0FFF, "ATM Label VPI", HFILL }},

    { &hf_ldp_tlv_atm_label_vci,
      { "VCI", "ldp.msg.tlv.atm.label.vci", FT_UINT16, BASE_DEC, NULL, 0, "ATM Label VCI", HFILL }},

    { &hf_ldp_tlv_fr_label_len,
      { "Number of DLCI bits", "ldp.msg.tlv.fr.label.len", FT_UINT16, BASE_DEC, VALS(tlv_fr_len_vals), 0x0180, "DLCI Number of bits", HFILL }},

    { &hf_ldp_tlv_fr_label_dlci,
      { "DLCI", "ldp.msg.tlv.fr.label.dlci", FT_UINT24, BASE_DEC, NULL, 0x7FFFFF, "FRAME RELAY Label DLCI", HFILL }},

    { &hf_ldp_tlv_ft_protect_sequence_num,
      { "FT Sequence Number", "ldp.msg.tlv.ft_protect.sequence_num", FT_UINT32, BASE_HEX, NULL, 0x0, "FT Sequence Number", HFILL }},

    { &hf_ldp_tlv_status_ebit,
      { "E Bit", "ldp.msg.tlv.status.ebit", FT_BOOLEAN, 8, TFS(&tlv_status_ebit), 0x80, "Fatal Error Bit", HFILL }},

    { &hf_ldp_tlv_status_fbit,
      { "F Bit", "ldp.msg.tlv.status.fbit", FT_BOOLEAN, 8, TFS(&tlv_status_fbit), 0x40, "Forward Bit", HFILL }},

    { &hf_ldp_tlv_status_data,
      { "Status Data", "ldp.msg.tlv.status.data", FT_UINT32, BASE_HEX, VALS(tlv_status_data), 0x3FFFFFFF, "Status Data", HFILL }},

    { &hf_ldp_tlv_status_msg_id,
      { "Message ID", "ldp.msg.tlv.status.msg.id", FT_UINT32, BASE_HEX, NULL, 0x0, "Identifies peer message to which Status TLV refers", HFILL }},

    { &hf_ldp_tlv_status_msg_type,
      { "Message Type", "ldp.msg.tlv.status.msg.type", FT_UINT16, BASE_HEX, VALS(ldp_message_types), 0x0, "Type of peer message to which Status TLV refers", HFILL }},

    { &hf_ldp_tlv_extstatus_data,
      { "Extended Status Data", "ldp.msg.tlv.extstatus.data", FT_UINT32, BASE_HEX, NULL, 0x0, "Extended Status Data", HFILL }},

    { &hf_ldp_tlv_returned_version,
      { "Returned PDU Version", "ldp.msg.tlv.returned.version", FT_UINT16, BASE_DEC, NULL, 0x0, "LDP Version Number", HFILL }},

    { &hf_ldp_tlv_returned_pdu_len,
      { "Returned PDU Length", "ldp.msg.tlv.returned.pdu_len", FT_UINT16, BASE_DEC, NULL, 0x0, "LDP PDU Length", HFILL }},

    { &hf_ldp_tlv_returned_lsr,
      { "Returned PDU LSR ID", "ldp.msg.tlv.returned.ldpid.lsr", FT_IPv4, BASE_DEC, NULL, 0x0, "LDP Label Space Router ID", HFILL }},

    { &hf_ldp_tlv_returned_ls_id,
      { "Returned PDU Label Space ID", "ldp.msg.tlv.returned.ldpid.lsid", FT_UINT16, BASE_HEX, NULL, 0x0, "LDP Label Space ID", HFILL }},

    { &hf_ldp_tlv_returned_msg_ubit,
      { "Returned Message Unknown bit", "ldp.msg.tlv.returned.msg.ubit", FT_BOOLEAN, BASE_HEX, TFS(&ldp_message_ubit), 0x80, "Message Unknown bit", HFILL }},

    { &hf_ldp_tlv_returned_msg_type,
      { "Returned Message Type", "ldp.msg.tlv.returned.msg.type", FT_UINT16, BASE_HEX, VALS(ldp_message_types), 0x7FFF, "LDP message type", HFILL }},

    { &hf_ldp_tlv_returned_msg_len,
      { "Returned Message Length", "ldp.msg.tlv.returned.msg.len", FT_UINT16, BASE_DEC, NULL, 0x0, "LDP Message Length (excluding message type and len)", HFILL }},

    { &hf_ldp_tlv_returned_msg_id,
      { "Returned Message ID", "ldp.msg.tlv.returned.msg.id", FT_UINT32, BASE_HEX, NULL, 0x0, "LDP Message ID", HFILL }},

    { &hf_ldp_tlv_mac,
      { "MAC address", "ldp.msg.tlv.mac", FT_ETHER, BASE_NONE, NULL, 0x0, "MAC address", HFILL}},

    {&hf_ldp_tlv_fec_vc_controlword,
     {"C-bit", "ldp.msg.tlv.fec.vc.controlword", FT_BOOLEAN, 8, TFS(&fec_vc_cbit), 0x80, "Control Word Present", HFILL }},

    {&hf_ldp_tlv_fec_vc_vctype,
     {"VC Type", "ldp.msg.tlv.fec.vc.vctype", FT_UINT16, BASE_HEX, VALS(fec_vc_types_vals), 0x7FFF, "Virtual Circuit Type", HFILL }},

    {&hf_ldp_tlv_fec_vc_infolength,
     {"VC Info Length", "ldp.msg.tlv.fec.vc.infolength", FT_UINT8, BASE_DEC, NULL, 0x0, "VC FEC Info Length", HFILL }},

    {&hf_ldp_tlv_fec_vc_groupid,
     {"Group ID", "ldp.msg.tlv.fec.vc.groupid", FT_UINT32, BASE_DEC, NULL, 0x0, "VC FEC Group ID", HFILL }},

    {&hf_ldp_tlv_fec_vc_vcid,
     {"VC ID", "ldp.msg.tlv.fec.vc.vcid", FT_UINT32, BASE_DEC, NULL, 0x0, "VC FEC VCID", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_length,
     {"Length", "ldp.msg.tlv.fec.vc.intparam.length", FT_UINT8, BASE_DEC, NULL, 0x0, "VC FEC Interface Paramater Length", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_mtu,
     {"MTU", "ldp.msg.tlv.fec.vc.intparam.mtu", FT_UINT16, BASE_DEC, NULL, 0x0, "VC FEC Interface Paramater MTU", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_tdmbps,
     {"BPS", "ldp.msg.tlv.fec.vc.intparam.tdmbps", FT_UINT32, BASE_DEC, NULL, 0x0, "VC FEC Interface Parameter CEP/TDM bit-rate", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_id,
     {"ID", "ldp.msg.tlv.fec.vc.intparam.id", FT_UINT8, BASE_HEX, VALS(fec_vc_interfaceparm), 0x0, "VC FEC Interface Paramater ID", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_maxcatmcells,
     {"Number of Cells", "ldp.msg.tlv.fec.vc.intparam.maxatm", FT_UINT16, BASE_DEC, NULL, 0x0, "VC FEC Interface Param Max ATM Concat Cells", HFILL }},

    { &hf_ldp_tlv_fec_vc_intparam_desc,
      { "Description", "ldp.msg.tlv.fec.vc.intparam.desc", FT_STRING, BASE_DEC, NULL, 0, "VC FEC Interface Description", HFILL }},

    { &hf_ldp_tlv_fec_vc_intparam_cepbytes,
     {"Payload Bytes", "ldp.msg.tlv.fec.vc.intparam.cepbytes", FT_UINT16, BASE_DEC, NULL, 0x0, "VC FEC Interface Param CEP/TDM Payload Bytes", HFILL }},

    { &hf_ldp_tlv_fec_vc_intparam_cepopt_ais,
     {"AIS", "ldp.msg.tlv.fec.vc.intparam.cepopt_ais", FT_BOOLEAN, 16, NULL, 0x8000, "VC FEC Interface Param CEP Option AIS", HFILL }},

    { &hf_ldp_tlv_fec_vc_intparam_cepopt_une,
     {"UNE", "ldp.msg.tlv.fec.vc.intparam.cepopt_une", FT_BOOLEAN, 16, NULL, 0x4000, "VC FEC Interface Param CEP Option Unequipped", HFILL }},

    { &hf_ldp_tlv_fec_vc_intparam_cepopt_rtp,
     {"RTP", "ldp.msg.tlv.fec.vc.intparam.cepopt_rtp", FT_BOOLEAN, 16, NULL, 0x2000, "VC FEC Interface Param CEP Option RTP Header", HFILL }},

    { &hf_ldp_tlv_fec_vc_intparam_cepopt_ebm,
     {"EBM", "ldp.msg.tlv.fec.vc.intparam.cepopt_ebm", FT_BOOLEAN, 16, NULL, 0x1000, "VC FEC Interface Param CEP Option EBM Header", HFILL }},

    { &hf_ldp_tlv_fec_vc_intparam_cepopt_mah,
     {"MAH", "ldp.msg.tlv.fec.vc.intparam.cepopt_mah", FT_BOOLEAN, 16, NULL, 0x0800, "VC FEC Interface Param CEP Option MPLS Adaptation header", HFILL }},

    { &hf_ldp_tlv_fec_vc_intparam_cepopt_res,
     {"Reserved", "ldp.msg.tlv.fec.vc.intparam.cepopt_res", FT_UINT16, BASE_HEX, NULL , 0x07E0, "VC FEC Interface Param CEP Option Reserved", HFILL }},

    { &hf_ldp_tlv_fec_vc_intparam_cepopt_ceptype,
     {"CEP Type", "ldp.msg.tlv.fec.vc.intparam.cepopt_ceptype", FT_UINT16, BASE_HEX, VALS(fec_vc_ceptype_vals), 0x001C, "VC FEC Interface Param CEP Option CEP Type", HFILL }},

    { &hf_ldp_tlv_fec_vc_intparam_cepopt_t3,
     {"Async T3", "ldp.msg.tlv.fec.vc.intparam.cepopt_t3", FT_BOOLEAN, 16, NULL, 0x0002, "VC FEC Interface Param CEP Option Async T3", HFILL }},

    { &hf_ldp_tlv_fec_vc_intparam_cepopt_e3,
     {"Async E3", "ldp.msg.tlv.fec.vc.intparam.cepopt_e3", FT_BOOLEAN, 16, NULL, 0x0001, "VC FEC Interface Param CEP Option Async E3", HFILL }},

    { &hf_ldp_tlv_fec_vc_intparam_vlanid,
      { "VLAN Id", "ldp.msg.tlv.fec.vc.intparam.vlanid", FT_UINT16, BASE_DEC, NULL, 0x0, "VC FEC Interface Param VLAN Id", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_dlcilen,
     {"DLCI Length", "ldp.msg.tlv.fec.vc.intparam.dlcilen", FT_UINT16, BASE_DEC, NULL, 0x0, "VC FEC Interface Parameter Frame-Relay DLCI Length", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_fcslen,
     {"FCS Length", "ldp.msg.tlv.fec.vc.intparam.fcslen", FT_UINT16, BASE_DEC, NULL, 0x0, "VC FEC Interface Paramater FCS Length", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_tdmopt_r,
     {"R Bit", "ldp.msg.tlv.fec.vc.intparam.tdmopt_r", FT_BOOLEAN, 16, TFS(&fec_vc_tdmopt_r), 0x8000, "VC FEC Interface Param TDM Options RTP Header", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_tdmopt_d,
     {"D Bit", "ldp.msg.tlv.fec.vc.intparam.tdmopt_d", FT_BOOLEAN, 16, TFS(&fec_vc_tdmopt_d), 0x4000, "VC FEC Interface Param TDM Options Dynamic Timestamp", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_tdmopt_f,
     {"F Bit", "ldp.msg.tlv.fec.vc.intparam.tdmopt_f", FT_BOOLEAN, 16, TFS(&fec_vc_tdmopt_f), 0x2000, "VC FEC Interface Param TDM Options Flavor bit", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_tdmopt_res1,
     {"RSVD-1", "ldp.msg.tlv.fec.vc.intparam.tdmopt_res1", FT_UINT16, BASE_HEX, NULL, 0x1FFF, "VC FEC Interface Param TDM Options Reserved", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_tdmopt_pt,
     {"PT", "ldp.msg.tlv.fec.vc.intparam.tdmopt_pt", FT_UINT8, BASE_DEC, NULL, 0x7F, "VC FEC Interface Param TDM Options Payload Type", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_tdmopt_res2,
     {"RSVD-2", "ldp.msg.tlv.fec.vc.intparam.tdmopt_res2", FT_UINT8, BASE_HEX, NULL, 0x00, "VC FEC Interface Param TDM Options Reserved", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_tdmopt_freq,
     {"FREQ", "ldp.msg.tlv.fec.vc.intparam.tdmopt_freq", FT_UINT16, BASE_DEC, NULL, 0x00, "VC FEC Interface Param TDM Options Frequency", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_tdmopt_ssrc,
     {"SSRC", "ldp.msg.tlv.fec.vc.intparam.tdmopt_ssrc", FT_UINT32, BASE_HEX, NULL, 0x00, "VC FEC Interface Param TDM Options SSRC", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_vccv_cctype_cw,
     {"PWE3 Control Word", "ldp.msg.tlv.fec.vc.intparam.vccv.cctype_cw", FT_BOOLEAN, 8, NULL, 0x01, "VC FEC Interface Param VCCV CC Type PWE3 CW", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_vccv_cctype_mplsra,
     {"MPLS Router Alert", "ldp.msg.tlv.fec.vc.intparam.vccv.cctype_mplsra", FT_BOOLEAN, 8, NULL, 0x02, "VC FEC Interface Param VCCV CC Type MPLS Router Alert", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_vccv_cctype_ttl1,
     {"MPLS Inner Label TTL = 1", "ldp.msg.tlv.fec.vc.intparam.vccv.cctype_ttl1", FT_BOOLEAN, 8, NULL, 0x04, "VC FEC Interface Param VCCV CC Type Inner Label TTL 1", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_vccv_cvtype_icmpping,
     {"ICMP Ping", "ldp.msg.tlv.fec.vc.intparam.vccv.cvtype_icmpping", FT_BOOLEAN, 8, NULL, 0x01, "VC FEC Interface Param VCCV CV Type ICMP Ping", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_vccv_cvtype_lspping,
     {"LSP Ping", "ldp.msg.tlv.fec.vc.intparam.vccv.cvtype_lspping", FT_BOOLEAN, 8, NULL, 0x02, "VC FEC Interface Param VCCV CV Type LSP Ping", HFILL }},

    {&hf_ldp_tlv_fec_vc_intparam_vccv_cvtype_bfd,
     {"BFD", "ldp.msg.tlv.fec.vc.intparam.vccv.cvtype_bfd", FT_BOOLEAN, 8, NULL, 0x04, "VC FEC Interface Param VCCV CV Type BFD", HFILL }},


    { &hf_ldp_tlv_lspid_act_flg,
      { "Action Indicator Flag", "ldp.msg.tlv.lspid.actflg", FT_UINT16, BASE_HEX, VALS(ldp_act_flg_vals), 0x000F, "Action Indicator Flag", HFILL}},

    { &hf_ldp_tlv_lspid_cr_lsp,
      { "Local CR-LSP ID", "ldp.msg.tlv.lspid.locallspid", FT_UINT16, BASE_HEX, NULL, 0x0, "Local CR-LSP ID", HFILL}},

    { &hf_ldp_tlv_lspid_ldpid,
      { "Ingress LSR Router ID", "ldp.msg.tlv.lspid.lsrid", FT_IPv4, BASE_DEC, NULL, 0x0, "Ingress LSR Router ID", HFILL}},

    { &hf_ldp_tlv_er_hop_loose,
      { "Loose route bit", "ldp.msg.tlv.er_hop.loose", FT_UINT24, BASE_HEX, VALS(ldp_loose_vals), 0x800000, "Loose route bit", HFILL}},

    { &hf_ldp_tlv_er_hop_prelen,
      { "Prefix length", "ldp.msg.tlv.er_hop.prefixlen", FT_UINT8, BASE_DEC, NULL, 0x0, "Prefix len", HFILL}},

    { &hf_ldp_tlv_er_hop_prefix4,
      { "IPv4 Address", "ldp.msg.tlv.er_hop.prefix4", FT_IPv4, BASE_DEC, NULL, 0x0, "IPv4 Address", HFILL}},
   { &hf_ldp_tlv_er_hop_prefix6,
     { "IPv6 Address", "ldp.msg.tlv.er_hop.prefix6", FT_IPv6, BASE_DEC, NULL, 0x0, "IPv6 Address", HFILL}},

    { &hf_ldp_tlv_er_hop_as,
      { "AS Number", "ldp.msg.tlv.er_hop.as", FT_UINT16, BASE_DEC, NULL, 0x0, "AS Number", HFILL}},

    { &hf_ldp_tlv_er_hop_cr_lsp,
      { "Local CR-LSP ID", "ldp.msg.tlv.er_hop.locallspid", FT_UINT16, BASE_DEC, NULL, 0x0, "Local CR-LSP ID", HFILL}},

    { &hf_ldp_tlv_er_hop_ldpid,
      { "Local CR-LSP ID", "ldp.msg.tlv.er_hop.lsrid", FT_IPv4, BASE_DEC, NULL, 0x0, "Local CR-LSP ID", HFILL}},

    { &hf_ldp_tlv_flags_reserv,
      { "Reserved", "ldp.msg.tlv.flags_reserv", FT_UINT8, BASE_HEX, NULL, 0xC0, "Reserved", HFILL}},

    { &hf_ldp_tlv_flags_pdr,
      { "PDR", "ldp.msg.tlv.flags_pdr", FT_BOOLEAN, 8, TFS(&tlv_negotiable), 0x1, "PDR negotiability flag", HFILL}},

    { &hf_ldp_tlv_flags_pbs,
      { "PBS", "ldp.msg.tlv.flags_pbs", FT_BOOLEAN, 8, TFS(&tlv_negotiable), 0x2, "PBS negotiability flag", HFILL}},

    { &hf_ldp_tlv_flags_cdr,
      { "CDR", "ldp.msg.tlv.flags_cdr", FT_BOOLEAN, 8, TFS(&tlv_negotiable), 0x4, "CDR negotiability flag", HFILL}},

    { &hf_ldp_tlv_flags_cbs,
      { "CBS", "ldp.msg.tlv.flags_cbs", FT_BOOLEAN, 8, TFS(&tlv_negotiable), 0x8, "CBS negotiability flag", HFILL}},

    { &hf_ldp_tlv_flags_ebs,
      { "EBS", "ldp.msg.tlv.flags_ebs", FT_BOOLEAN, 8, TFS(&tlv_negotiable), 0x10, "EBS negotiability flag", HFILL}},

    { &hf_ldp_tlv_flags_weight,
      { "Weight", "ldp.msg.tlv.flags_weight", FT_BOOLEAN, 8, TFS(&tlv_negotiable), 0x20, "Weight negotiability flag", HFILL}},

    { &hf_ldp_tlv_frequency,
      { "Frequency", "ldp.msg.tlv.frequency", FT_UINT8, BASE_DEC, VALS(freq_values), 0, "Frequency", HFILL}},

    { &hf_ldp_tlv_weight,
      { "Weight", "ldp.msg.tlv.weight", FT_UINT8, BASE_DEC, NULL, 0, "Weight of the CR-LSP", HFILL}},

    { &hf_ldp_tlv_pdr,
      { "PDR", "ldp.msg.tlv.pdr", FT_DOUBLE, BASE_NONE, NULL, 0, "Peak Data Rate", HFILL}},

    { &hf_ldp_tlv_pbs,
      { "PBS", "ldp.msg.tlv.pbs", FT_DOUBLE, BASE_NONE, NULL, 0, "Peak Burst Size", HFILL}},

    { &hf_ldp_tlv_cdr,
      { "CDR", "ldp.msg.tlv.cdr", FT_DOUBLE, BASE_NONE, NULL, 0, "Committed Data Rate", HFILL}},

    { &hf_ldp_tlv_cbs,
      { "CBS", "ldp.msg.tlv.cbs", FT_DOUBLE, BASE_NONE, NULL, 0, "Committed Burst Size", HFILL}},

    { &hf_ldp_tlv_ebs,
      { "EBS", "ldp.msg.tlv.ebs", FT_DOUBLE, BASE_NONE, NULL, 0, "Excess Burst Size", HFILL}},

    { &hf_ldp_tlv_set_prio,
      { "Set Prio", "ldp.msg.tlv.set_prio", FT_UINT8, BASE_DEC, NULL, 0, "LSP setup priority", HFILL}},

    { &hf_ldp_tlv_hold_prio,
      { "Hold Prio", "ldp.msg.tlv.hold_prio", FT_UINT8, BASE_DEC, NULL, 0, "LSP hold priority", HFILL}},

    { &hf_ldp_tlv_route_pinning,
      { "Route Pinning", "ldp.msg.tlv.route_pinning", FT_UINT32, BASE_DEC, VALS(route_pinning_vals), 0x80000000, "Route Pinning", HFILL}},

    { &hf_ldp_tlv_resource_class,
      { "Resource Class", "ldp.msg.tlv.resource_class", FT_UINT32, BASE_HEX, NULL, 0, "Resource Class (Color)", HFILL}},

    { &hf_ldp_tlv_diffserv,
      { "Diff-Serv TLV", "ldp.msg.tlv.diffserv", FT_NONE, BASE_NONE, NULL,
      0, "Diffserv TLV", HFILL}},

    { &hf_ldp_tlv_diffserv_type,
      { "LSP Type", "ldp.msg.tlv.diffserv.type", FT_UINT8, BASE_DEC,
      VALS(diffserv_type_vals), 0x80, "LSP Type", HFILL}},

    { &hf_ldp_tlv_diffserv_mapnb,
      { "MAPnb", "ldp.msg.tlv.diffserv.mapnb", FT_UINT8, BASE_DEC, NULL,
      0, MAPNB_DESCRIPTION, HFILL}},

    { &hf_ldp_tlv_diffserv_map,
      { "MAP", "ldp.msg.tlv.diffserv.map", FT_NONE, BASE_NONE, NULL,
      0, MAP_DESCRIPTION, HFILL}},

    { &hf_ldp_tlv_diffserv_map_exp,
      { "EXP", "ldp.msg.tlv.diffserv.map.exp", FT_UINT8, BASE_DEC, NULL,
      0, EXP_DESCRIPTION, HFILL}},

    { &hf_ldp_tlv_diffserv_phbid,
      { "PHBID", "ldp.msg.tlv.diffserv.phbid", FT_NONE, BASE_NONE, NULL,
      0, PHBID_DESCRIPTION, HFILL}},

    { &hf_ldp_tlv_diffserv_phbid_dscp,
      { "DSCP", "ldp.msg.tlv.diffserv.phbid.dscp", FT_UINT16, BASE_DEC,
      NULL, PHBID_DSCP_MASK, PHBID_DSCP_DESCRIPTION, HFILL}},

    { &hf_ldp_tlv_diffserv_phbid_code,
      { "PHB id code", "ldp.msg.tlv.diffserv.phbid.code", FT_UINT16, BASE_DEC,
      NULL, PHBID_CODE_MASK, PHBID_CODE_DESCRIPTION, HFILL}},

    { &hf_ldp_tlv_diffserv_phbid_bit14,
      { "Bit 14", "ldp.msg.tlv.diffserv.phbid.bit14", FT_UINT16, BASE_DEC,
      VALS(phbid_bit14_vals), PHBID_BIT14_MASK, PHBID_BIT14_DESCRIPTION, HFILL}},

    { &hf_ldp_tlv_diffserv_phbid_bit15,
      { "Bit 15", "ldp.msg.tlv.diffserv.phbid.bit15", FT_UINT16, BASE_DEC,
      VALS(phbid_bit15_vals), PHBID_BIT15_MASK, PHBID_BIT15_DESCRIPTION, HFILL}}

  };

  static gint *ett[] = {
    &ett_ldp,
    &ett_ldp_header,
    &ett_ldp_ldpid,
    &ett_ldp_message,
    &ett_ldp_tlv,
    &ett_ldp_tlv_val,
    &ett_ldp_tlv_ft_flags,
    &ett_ldp_fec,
    &ett_ldp_fec_vc_interfaceparam,
    &ett_ldp_fec_vc_interfaceparam_cepopt,
    &ett_ldp_fec_vc_interfaceparam_vccvtype,
    &ett_ldp_diffserv_map,
    &ett_ldp_diffserv_map_phbid
  };
  module_t *ldp_module;

  proto_ldp = proto_register_protocol("Label Distribution Protocol",
                               "LDP", "ldp");

  proto_register_field_array(proto_ldp, hf, array_length(hf));
  proto_register_subtree_array(ett, array_length(ett));

  /* Register our configuration options for , particularly our port */

  ldp_module = prefs_register_protocol(proto_ldp, proto_reg_handoff_ldp);

  prefs_register_uint_preference(ldp_module, "tcp.port", "LDP TCP Port",
                         "Set the TCP port for messages (if other"
                         " than the default of 646)",
                         10, &global_ldp_tcp_port);

  prefs_register_uint_preference(ldp_module, "udp.port", "LDP UDP Port",
                         "Set the UDP port for messages (if other"
                         " than the default of 646)",
                         10, &global_ldp_udp_port);

  prefs_register_bool_preference(ldp_module, "desegment_ldp_messages",
    "Reassemble LDP messages spanning multiple TCP segments",
    "Whether the LDP 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.",
    &ldp_desegment);
}

/* The registration hand-off routine */
void
proto_reg_handoff_ldp(void)
{
  static gboolean ldp_prefs_initialized = FALSE;
  static dissector_handle_t ldp_tcp_handle, ldp_handle;

  if (!ldp_prefs_initialized) {

    ldp_tcp_handle = new_create_dissector_handle(dissect_ldp_tcp, proto_ldp);
    ldp_handle = new_create_dissector_handle(dissect_ldp, proto_ldp);

    ldp_prefs_initialized = TRUE;

  }
  else {

    dissector_delete("tcp.port", tcp_port, ldp_tcp_handle);
    dissector_delete("udp.port", udp_port, ldp_handle);

  }

  /* Set our port number for future use */

  tcp_port = global_ldp_tcp_port;
  udp_port = global_ldp_udp_port;

  dissector_add("tcp.port", global_ldp_tcp_port, ldp_tcp_handle);
  dissector_add("udp.port", global_ldp_udp_port, ldp_handle);

}

Generated by  Doxygen 1.6.0   Back to index