diff options
Diffstat (limited to 'epan/dissectors/packet-dlm3.c')
| -rw-r--r-- | epan/dissectors/packet-dlm3.c | 1840 |
1 files changed, 1840 insertions, 0 deletions
diff --git a/epan/dissectors/packet-dlm3.c b/epan/dissectors/packet-dlm3.c new file mode 100644 index 00000000..bb00265a --- /dev/null +++ b/epan/dissectors/packet-dlm3.c @@ -0,0 +1,1840 @@ +/* packet-dlm3.c + * Routines for dlm3 dissection + * Copyright 2007, Masatake YAMATO <jet@gyve.org> + * + * Wireshark - Network traffic analyzer + * By Gerald Combs <gerald@wireshark.org> + * Copyright 1998 Gerald Combs + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ + +/* This dissector supports version 3.0 of the dlm(Distributed Lock Manager) + protocol + + Actual implementation for the protocol is in linux kernel. + See files under linux/fs/dlm/ */ + +/* + * #defines are mostly copied from + * *.[ch] files in linux/fs/dlm/ and linux/include/linux/dlm.h + * + * dlm_internal.h: + * ----------------------------------------------------------------------- + ** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. + ** Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved. + ** + ** This copyrighted material is made available to anyone wishing to use, + ** modify, copy, or redistribute it subject to the terms and conditions + ** of the GNU General Public License v.2. + * ----------------------------------------------------------------------- + */ + + +#include "config.h" + +#include <epan/packet.h> +#include <epan/prefs.h> + +#include "packet-tcp.h" + +#define TCP_PORT_DLM3 21064 /* Not IANA registered */ +#define SCTP_PORT_DLM3 TCP_PORT_DLM3 + +#define DLM3_MAJOR_VERSION 0x00030000 +#define DLM3_MINOR_VERSION_MAX 0x00000002 + +#define DLM_VERSION_3_1 0x00030001 +#define DLM_VERSION_3_2 0x00030002 + +#define DLM3_MSG 1 +#define DLM3_RCOM 2 +#define DLM3_OPTS 3 +#define DLM3_ACK 4 +#define DLM3_FIN 5 + +#define DLM3_MSG_REQUEST 1 +#define DLM3_MSG_CONVERT 2 +#define DLM3_MSG_UNLOCK 3 +#define DLM3_MSG_CANCEL 4 +#define DLM3_MSG_REQUEST_REPLY 5 +#define DLM3_MSG_CONVERT_REPLY 6 +#define DLM3_MSG_UNLOCK_REPLY 7 +#define DLM3_MSG_CANCEL_REPLY 8 +#define DLM3_MSG_GRANT 9 +#define DLM3_MSG_BAST 10 +#define DLM3_MSG_LOOKUP 11 +#define DLM3_MSG_REMOVE 12 +#define DLM3_MSG_LOOKUP_REPLY 13 +#define DLM3_MSG_PURGE 14 + +#define DLM3_LKF_NOQUEUE 0x00000001 +#define DLM3_LKF_CANCEL 0x00000002 +#define DLM3_LKF_CONVERT 0x00000004 +#define DLM3_LKF_VALBLK 0x00000008 +#define DLM3_LKF_QUECVT 0x00000010 +#define DLM3_LKF_IVVALBLK 0x00000020 +#define DLM3_LKF_CONVDEADLK 0x00000040 +#define DLM3_LKF_PERSISTENT 0x00000080 +#define DLM3_LKF_NODLCKWT 0x00000100 +#define DLM3_LKF_NODLCKBLK 0x00000200 +#define DLM3_LKF_EXPEDITE 0x00000400 +#define DLM3_LKF_NOQUEUEBAST 0x00000800 +#define DLM3_LKF_HEADQUE 0x00001000 +#define DLM3_LKF_NOORDER 0x00002000 +#define DLM3_LKF_ORPHAN 0x00004000 +#define DLM3_LKF_ALTPR 0x00008000 +#define DLM3_LKF_ALTCW 0x00010000 +#define DLM3_LKF_FORCEUNLOCK 0x00020000 +#define DLM3_LKF_TIMEOUT 0x00040000 + +#define DLM3_SBF_DEMOTED 0x01 +#define DLM3_SBF_VALNOTVALID 0x02 +#define DLM3_SBF_ALTMODE 0x04 + +#define DLM3_IFL_USER 0x00000001 +#define DLM3_IFL_ORPHAN 0x00000002 +/* They may not be used in receiver side. + -------------------------------------- + #define DLM3_IFL_MSTCPY 0x00010000 + #define DLM3_IFL_RESEND 0x00020000 + #define DLM3_IFL_DEAD 0x00040000 + #define DLM3_IFL_OVERLAP_UNLOCK 0x00080000 + #define DLM3_IFL_OVERLAP_CANCEL 0x00100000 + #define DLM3_IFL_ENDOFLIFE 0x00200000 + #define DLM3_IFL_WATCH_TIMEWARN 0x00400000 + #define DLM3_IFL_TIMEOUT_CANCEL 0x00800000 + #define DLM3_IFL_DEADLOCK_CANCEL 0x01000000 */ + +#define DLM3_LKSTS_WAITING 1 +#define DLM3_LKSTS_GRANTED 2 +#define DLM3_LKSTS_CONVERT 3 + +#define DLM3_LOCK_IV -1 +#define DLM3_LOCK_NL 0 +#define DLM3_LOCK_CR 1 +#define DLM3_LOCK_CW 2 +#define DLM3_LOCK_PR 3 +#define DLM3_LOCK_PW 4 +#define DLM3_LOCK_EX 5 + +#define DLM3_AST_COMP 1 +#define DLM3_AST_BAST 2 + + +/* see asm-generic/errno-base.h about LINUX_* */ +#define LINUX_EAGAIN 11 +#define LINUX_ENOMEM 12 +#define LINUX_INVAL 22 + +#define DLM3_ERRNO_EDEADLK 35 +#define DLM3_ERRNO_EBADR 53 +#define DLM3_ERRNO_EBADSLT 57 +#define DLM3_ERRNO_EPROTO 71 +#define DLM3_ERRNO_EOPNOTSUPP 95 +#define DLM3_ERRNO_ETIMEDOUT 110 +#define DLM3_ERRNO_EINPROGRESS 115 + +#define DLM3_ECANCEL 0x10001 +#define DLM3_EUNLOCK 0x10002 + + +#define DLM3_RCOM_STATUS 1 +#define DLM3_RCOM_NAMES 2 +#define DLM3_RCOM_LOOKUP 3 +#define DLM3_RCOM_LOCK 4 +#define DLM3_RCOM_STATUS_REPLY 5 +#define DLM3_RCOM_NAMES_REPLY 6 +#define DLM3_RCOM_LOOKUP_REPLY 7 +#define DLM3_RCOM_LOCK_REPLY 8 + +#define DLM_RSF_NEED_SLOTS 0x00000001 + +#define DLM3_RS_NODES 0x00000001 +#define DLM3_RS_NODES_ALL 0x00000002 +#define DLM3_RS_DIR 0x00000004 +#define DLM3_RS_DIR_ALL 0x00000008 +#define DLM3_RS_LOCKS 0x00000010 +#define DLM3_RS_LOCKS_ALL 0x00000020 +#define DLM3_RS_DONE 0x00000040 +#define DLM3_RS_DONE_ALL 0x00000080 + +#define DLM3_RESNAME_MAXLEN 64 + +#define DLM_HEADER_LEN (4 + 4 + 4 + 2 + 1 + 1) +#define DLM_RCOM_LEN (DLM_HEADER_LEN + 4 + 4 + 8 + 8 + 8) +#define DLM_MSG_LEN (DLM_HEADER_LEN + ((4 * 12) + (4 * 6))) +#define DLM_OPTS_LEN (DLM_HEADER_LEN + 1 + 1 + 2 + 4) + +/* Forward declaration we need below */ +void proto_register_dlm3(void); +void proto_reg_handoff_dlm3(void); + +static dissector_handle_t dlm3_tcp_handle; +static dissector_handle_t dlm3_sctp_handle; + + +/* Initialize the protocol and registered fields */ +static int proto_dlm3 = -1; + +/* fields for struct dlm_header(h) */ +static int hf_dlm3_h_version = -1; +static int hf_dlm3_h_major_version = -1; +static int hf_dlm3_h_minor_version = -1; +static int hf_dlm3_h_lockspace = -1; +static int hf_dlm3_h_seq = -1; +static int hf_dlm3_h_nodeid = -1; +static int hf_dlm3_h_length = -1; +static int hf_dlm3_h_cmd = -1; +static int hf_dlm3_h_pad = -1; + +/* fields for struct dlm_opts(o) */ +static int hf_dlm3_o_nextcmd = -1; +static int hf_dlm3_o_pad = -1; +static int hf_dlm3_o_optlen = -1; +static int hf_dlm3_o_pad2 = -1; +static int hf_dlm3_o_opts = -1; + +/* fields for struct dlm_opt_header(t) */ +static int hf_dlm3_t_type = -1; +static int hf_dlm3_t_length = -1; +static int hf_dlm3_t_pad = -1; +static int hf_dlm3_t_value = -1; + +/* fields for struct dlm_message(m) */ +static int hf_dlm3_m_type = -1; +static int hf_dlm3_m_nodeid = -1; +static int hf_dlm3_m_pid = -1; +static int hf_dlm3_m_lkid = -1; +static int hf_dlm3_m_remid = -1; +static int hf_dlm3_m_parent_lkid = -1; +static int hf_dlm3_m_parent_remid = -1; + +/* bit fields for dlm_message::exflags */ + +static int hf_dlm3_m_exflags = -1; +static int hf_dlm3_m_exflags_noqueue = -1; +static int hf_dlm3_m_exflags_cancel = -1; +static int hf_dlm3_m_exflags_convert = -1; +static int hf_dlm3_m_exflags_valblk = -1; +static int hf_dlm3_m_exflags_quecvt = -1; +static int hf_dlm3_m_exflags_ivvalblk = -1; +static int hf_dlm3_m_exflags_convdeadlk = -1; +static int hf_dlm3_m_exflags_persistent = -1; +static int hf_dlm3_m_exflags_nodlckwt = -1; +static int hf_dlm3_m_exflags_nodlckblk = -1; +static int hf_dlm3_m_exflags_expedite = -1; +static int hf_dlm3_m_exflags_noqueuebast = -1; +static int hf_dlm3_m_exflags_headque = -1; +static int hf_dlm3_m_exflags_noorder = -1; +static int hf_dlm3_m_exflags_orphan = -1; +static int hf_dlm3_m_exflags_altpr = -1; +static int hf_dlm3_m_exflags_altcw = -1; +static int hf_dlm3_m_exflags_forceunlock = -1; +static int hf_dlm3_m_exflags_timeout = -1; + +/* bit fields for dlm_message::sbflags */ +static int hf_dlm3_m_sbflags = -1; +static int hf_dlm3_m_sbflags_demoted = -1; +static int hf_dlm3_m_sbflags_valnotvalid = -1; +static int hf_dlm3_m_sbflags_altmode = -1; + +/* bit fields for dlm_message::flags */ + +static int hf_dlm3_m_flags = -1; +static int hf_dlm3_m_flags_user = -1; +static int hf_dlm3_m_flags_orphan = -1; + +static int hf_dlm3_m_lvbseq = -1; +static int hf_dlm3_m_hash = -1; +static int hf_dlm3_m_status = -1; +static int hf_dlm3_m_grmode = -1; +static int hf_dlm3_m_rqmode = -1; +static int hf_dlm3_m_bastmode = -1; + +/* bit fields for dlm_message::asts */ +static int hf_dlm3_m_asts = -1; +static int hf_dlm3_m_asts_comp = -1; +static int hf_dlm3_m_asts_bast = -1; + +static int hf_dlm3_m_result = -1; +static int hf_dlm3_m_extra = -1; + +/* fields for struct dlm_rcom(rc) */ +static int hf_dlm3_rc_type = -1; +static int hf_dlm3_rc_result = -1; +static int hf_dlm3_rc_id = -1; +static int hf_dlm3_rc_seq = -1; +static int hf_dlm3_rc_seq_reply = -1; +static int hf_dlm3_rc_buf = -1; + +/* fields for struct rcom_config(rf) */ +static int hf_dlm3_rf_lvblen = -1; +static int hf_dlm3_rf_lsflags = -1; +static int hf_dlm3_rf_lsflags_noqueue = -1; +static int hf_dlm3_rf_lsflags_cancel = -1; +static int hf_dlm3_rf_lsflags_convert = -1; +static int hf_dlm3_rf_lsflags_valblk = -1; +static int hf_dlm3_rf_lsflags_quecvt = -1; +static int hf_dlm3_rf_lsflags_ivvalblk = -1; +static int hf_dlm3_rf_lsflags_convdeadlk = -1; +static int hf_dlm3_rf_lsflags_persistent = -1; +static int hf_dlm3_rf_lsflags_nodlckwt = -1; +static int hf_dlm3_rf_lsflags_nodlckblk = -1; +static int hf_dlm3_rf_lsflags_expedite = -1; +static int hf_dlm3_rf_lsflags_noqueuebast = -1; +static int hf_dlm3_rf_lsflags_headque = -1; +static int hf_dlm3_rf_lsflags_noorder = -1; +static int hf_dlm3_rf_lsflags_orphan = -1; +static int hf_dlm3_rf_lsflags_altpr = -1; +static int hf_dlm3_rf_lsflags_altcw = -1; +static int hf_dlm3_rf_lsflags_forceunlock = -1; +static int hf_dlm3_rf_lsflags_timeout = -1; +static int hf_dlm3_rf_unused = -1; + +/* fields for struct rcom_status(rs) */ +static int hf_dlm3_rs_flags = -1; +static int hf_dlm3_rs_flags_need_slots = -1; +static int hf_dlm3_rs_unused1 = -1; +static int hf_dlm3_rs_unused2 = -1; + +/* fields for struct rcom_lock(rl) */ +static int hf_dlm3_rl_ownpid = -1; +static int hf_dlm3_rl_lkid = -1; +static int hf_dlm3_rl_remid = -1; +static int hf_dlm3_rl_parent_lkid = -1; +static int hf_dlm3_rl_parent_remid = -1; +static int hf_dlm3_rl_exflags = -1; +static int hf_dlm3_rl_exflags_noqueue = -1; +static int hf_dlm3_rl_exflags_cancel = -1; +static int hf_dlm3_rl_exflags_convert = -1; +static int hf_dlm3_rl_exflags_valblk = -1; +static int hf_dlm3_rl_exflags_quecvt = -1; +static int hf_dlm3_rl_exflags_ivvalblk = -1; +static int hf_dlm3_rl_exflags_convdeadlk = -1; +static int hf_dlm3_rl_exflags_persistent = -1; +static int hf_dlm3_rl_exflags_nodlckwt = -1; +static int hf_dlm3_rl_exflags_nodlckblk = -1; +static int hf_dlm3_rl_exflags_expedite = -1; +static int hf_dlm3_rl_exflags_noqueuebast = -1; +static int hf_dlm3_rl_exflags_headque = -1; +static int hf_dlm3_rl_exflags_noorder = -1; +static int hf_dlm3_rl_exflags_orphan = -1; +static int hf_dlm3_rl_exflags_altpr = -1; +static int hf_dlm3_rl_exflags_altcw = -1; +static int hf_dlm3_rl_exflags_forceunlock = -1; +static int hf_dlm3_rl_exflags_timeout = -1; +static int hf_dlm3_rl_flags = -1; +static int hf_dlm3_rl_flags_user = -1; +static int hf_dlm3_rl_flags_orphan = -1; +static int hf_dlm3_rl_lvbseq = -1; +static int hf_dlm3_rl_result = -1; +static int hf_dlm3_rl_rqmode = -1; +static int hf_dlm3_rl_grmode = -1; +static int hf_dlm3_rl_status = -1; +static int hf_dlm3_rl_asts = -1; +static int hf_dlm3_rl_asts_comp = -1; +static int hf_dlm3_rl_asts_bast = -1; +static int hf_dlm3_rl_wait_type = -1; +static int hf_dlm3_rl_namelen = -1; +static int hf_dlm3_rl_name = -1; +static int hf_dlm3_rl_name_contents = -1; +static int hf_dlm3_rl_name_padding = -1; +static int hf_dlm3_rl_lvb = -1; + +/* Initialize the subtree pointers */ +static gint ett_dlm3 = -1; +static gint ett_dlm3_version = -1; + +static gint ett_dlm3_opts = -1; +static gint ett_dlm3_options = -1; +static gint ett_dlm3_next_cmd = -1; + +static gint ett_dlm3_msg = -1; +static gint ett_dlm3_m_exflags = -1; +static gint ett_dlm3_sbflags = -1; +static gint ett_dlm3_m_flags = -1; +static gint ett_dlm3_m_asts = -1; + +static gint ett_dlm3_rcom = -1; +static gint ett_dlm3_rcom_status = -1; +static gint ett_dlm3_rcom_lock = -1; +static gint ett_dlm3_rcom_config = -1; + +static gint ett_dlm3_rs_flags = -1; + +static gint ett_dlm3_rf_lsflags = -1; +static gint ett_dlm3_rl_exflags = -1; +static gint ett_dlm3_rl_flags = -1; +static gint ett_dlm3_rl_asts = -1; +static gint ett_dlm3_rl_name = -1; + + +/* + * Value strings + */ +static const value_string dlm3_cmd[] = { + { DLM3_MSG, "message" }, + { DLM3_RCOM, "recovery command" }, + { DLM3_OPTS, "options" }, + { DLM3_ACK, "acknowledge" }, + { DLM3_FIN, "fin" }, + { 0, NULL } +}; + +static const value_string dlm3_msg[] = { + { DLM3_MSG_REQUEST, "request message" }, + { DLM3_MSG_CONVERT, "conversion message" }, + { DLM3_MSG_UNLOCK, "unlock message" }, + { DLM3_MSG_CANCEL, "cancel message" }, + { DLM3_MSG_REQUEST_REPLY, "request reply" }, + { DLM3_MSG_CONVERT_REPLY, "conversion reply" }, + { DLM3_MSG_UNLOCK_REPLY, "unlock reply" }, + { DLM3_MSG_CANCEL_REPLY, "cancel reply" }, + { DLM3_MSG_GRANT, "grant message" }, + { DLM3_MSG_BAST, "bast message" }, + { DLM3_MSG_LOOKUP, "lookup message" }, + { DLM3_MSG_REMOVE, "remove message" }, + { DLM3_MSG_LOOKUP_REPLY, "lookup reply" }, + { DLM3_MSG_PURGE, "purge orphans" }, + { 0, NULL } +}; + +static const value_string dlm3_status[] = { + { DLM3_LKSTS_WAITING, "waiting" }, + { DLM3_LKSTS_GRANTED, "granted" }, + { DLM3_LKSTS_CONVERT, "convert" }, + { 0, NULL } +}; + +static const value_string dlm3_mode[] = { + { DLM3_LOCK_IV, "invalid" }, + { DLM3_LOCK_NL, "null" }, + { DLM3_LOCK_CR, "concurrent read" }, + { DLM3_LOCK_CW, "concurrent write" }, + { DLM3_LOCK_PR, "protected read" }, + { DLM3_LOCK_PW, "protected write" }, + { DLM3_LOCK_EX, "exclusive" }, + { 0, NULL } +}; + +static const value_string dlm3_result[] = { + { -LINUX_EAGAIN, "blocked" }, + { -LINUX_ENOMEM, "no memory" }, + { -LINUX_INVAL, "invalid parameters" }, + { -DLM3_ERRNO_EDEADLK, "Resource deadlock avoided" }, + { -DLM3_ERRNO_EBADR, "Invalid request descriptor" }, + { -DLM3_ERRNO_EBADSLT, "Invalid slot" }, + { -DLM3_ERRNO_EPROTO, "Protocol error" }, + { -DLM3_ERRNO_EOPNOTSUPP, "Operation not supported" }, + { -DLM3_ERRNO_ETIMEDOUT, "Connection timed out" }, + { -DLM3_ERRNO_EINPROGRESS, "Operation now in progress" }, + { -DLM3_ECANCEL, "cancel completed successfully" }, + { -DLM3_EUNLOCK, "unlock request was successful" }, + { 0, "successful" }, + { 0, NULL } +}; + +static const value_string dlm3_rcom[] = { + { DLM3_RCOM_STATUS, "status command" }, + { DLM3_RCOM_NAMES, "names command" }, + { DLM3_RCOM_LOOKUP, "lookup command" }, + { DLM3_RCOM_LOCK, "lock command" }, + { DLM3_RCOM_STATUS_REPLY, "status reply" }, + { DLM3_RCOM_NAMES_REPLY, "names reply" }, + { DLM3_RCOM_LOOKUP_REPLY, "lookup reply" }, + { DLM3_RCOM_LOCK_REPLY, "lock reply" }, + { 0, NULL } +}; + +static const value_string dlm3_rs[] = { + { DLM3_RS_NODES, "recovering nodes" }, + { DLM3_RS_NODES_ALL, "recovering all nodes" }, + { DLM3_RS_DIR, "recovering resource directory" }, + { DLM3_RS_DIR_ALL, "recovering all resource directories" }, + { DLM3_RS_LOCKS, "recovering lock" }, + { DLM3_RS_LOCKS_ALL, "recovering all locks" }, + { DLM3_RS_DONE, "recovering is done" }, + { DLM3_RS_DONE_ALL, "all recovering is done" }, + { 0, NULL } +}; + +/* + * Fields + */ + +static int * const m_exflags_fields[] = { + &hf_dlm3_m_exflags_timeout, + &hf_dlm3_m_exflags_forceunlock, + &hf_dlm3_m_exflags_altcw, + &hf_dlm3_m_exflags_altpr, + &hf_dlm3_m_exflags_orphan, + &hf_dlm3_m_exflags_noorder, + &hf_dlm3_m_exflags_headque, + &hf_dlm3_m_exflags_noqueuebast, + &hf_dlm3_m_exflags_expedite, + &hf_dlm3_m_exflags_nodlckblk, + &hf_dlm3_m_exflags_nodlckwt, + &hf_dlm3_m_exflags_persistent, + &hf_dlm3_m_exflags_convdeadlk, + &hf_dlm3_m_exflags_ivvalblk, + &hf_dlm3_m_exflags_quecvt, + &hf_dlm3_m_exflags_valblk, + &hf_dlm3_m_exflags_convert, + &hf_dlm3_m_exflags_cancel, + &hf_dlm3_m_exflags_noqueue, + NULL +}; + +static int * const rs_flags_fields[] = { + &hf_dlm3_rs_flags_need_slots, + NULL +}; + +static int * const m_sbflags_fields[] = { + &hf_dlm3_m_sbflags_altmode, + &hf_dlm3_m_sbflags_valnotvalid, + &hf_dlm3_m_sbflags_demoted, + NULL +}; + +static int * const m_flags_fields[] = { + &hf_dlm3_m_flags_orphan, + &hf_dlm3_m_flags_user, + NULL +}; + +static int * const m_asts_fields[] = { + &hf_dlm3_m_asts_bast, + &hf_dlm3_m_asts_comp, + NULL +}; + +static int * const rf_lsflags_fields[] = { + &hf_dlm3_rf_lsflags_timeout, + &hf_dlm3_rf_lsflags_forceunlock, + &hf_dlm3_rf_lsflags_altcw, + &hf_dlm3_rf_lsflags_altpr, + &hf_dlm3_rf_lsflags_orphan, + &hf_dlm3_rf_lsflags_noorder, + &hf_dlm3_rf_lsflags_headque, + &hf_dlm3_rf_lsflags_noqueuebast, + &hf_dlm3_rf_lsflags_expedite, + &hf_dlm3_rf_lsflags_nodlckblk, + &hf_dlm3_rf_lsflags_nodlckwt, + &hf_dlm3_rf_lsflags_persistent, + &hf_dlm3_rf_lsflags_convdeadlk, + &hf_dlm3_rf_lsflags_ivvalblk, + &hf_dlm3_rf_lsflags_quecvt, + &hf_dlm3_rf_lsflags_valblk, + &hf_dlm3_rf_lsflags_convert, + &hf_dlm3_rf_lsflags_cancel, + &hf_dlm3_rf_lsflags_noqueue, + NULL +}; + +static int * const rl_exflags_fields[] = { + &hf_dlm3_rl_exflags_timeout, + &hf_dlm3_rl_exflags_forceunlock, + &hf_dlm3_rl_exflags_altcw, + &hf_dlm3_rl_exflags_altpr, + &hf_dlm3_rl_exflags_orphan, + &hf_dlm3_rl_exflags_noorder, + &hf_dlm3_rl_exflags_headque, + &hf_dlm3_rl_exflags_noqueuebast, + &hf_dlm3_rl_exflags_expedite, + &hf_dlm3_rl_exflags_nodlckblk, + &hf_dlm3_rl_exflags_nodlckwt, + &hf_dlm3_rl_exflags_persistent, + &hf_dlm3_rl_exflags_convdeadlk, + &hf_dlm3_rl_exflags_ivvalblk, + &hf_dlm3_rl_exflags_quecvt, + &hf_dlm3_rl_exflags_valblk, + &hf_dlm3_rl_exflags_convert, + &hf_dlm3_rl_exflags_cancel, + &hf_dlm3_rl_exflags_noqueue, + NULL +}; + +static int * const rl_flags_fields[] = { + &hf_dlm3_rl_flags_orphan, + &hf_dlm3_rl_flags_user, + NULL +}; + +static int * const rl_asts_fields[] = { + &hf_dlm3_rl_asts_bast, + &hf_dlm3_rl_asts_comp, + NULL +}; + +/* Code to actually dissect the packets */ +static void +dissect_dlm3_msg(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint length, int offset) +{ + guint32 m_type; + + m_type = tvb_get_letohl(tvb, offset); + proto_tree_add_uint(tree, + hf_dlm3_m_type, tvb, offset, 4, m_type); + col_append_fstr(pinfo->cinfo, COL_INFO, + ": %s", + val_to_str_const(m_type, + dlm3_msg, + "Unknown")); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_m_nodeid, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_m_pid, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_m_lkid, tvb, offset, 4, ENC_LITTLE_ENDIAN); + /* TODO: See `create_lkb' + lkid has some structure. We dissect more. */ + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_m_remid, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_m_parent_lkid, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_m_parent_remid, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_bitmask(tree, tvb, offset, + hf_dlm3_m_exflags, ett_dlm3_m_exflags, + m_exflags_fields, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_bitmask(tree, tvb, offset, + hf_dlm3_m_sbflags, ett_dlm3_sbflags, + m_sbflags_fields, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_bitmask(tree, tvb, offset, + hf_dlm3_m_flags, ett_dlm3_m_flags, + m_flags_fields, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_m_lvbseq, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_m_hash, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_m_status, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_m_grmode, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_m_rqmode, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_m_bastmode, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + + offset += 4; + proto_tree_add_bitmask(tree, tvb, offset, + hf_dlm3_m_asts, ett_dlm3_m_asts, + m_asts_fields, ENC_LITTLE_ENDIAN); + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_m_result, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + if ((length - offset) > 0) { + proto_tree_add_item(tree, + hf_dlm3_m_extra, + tvb, + offset, + -1, + ENC_NA); + } +} + + +static void +dissect_dlm3_rcom_status(tvbuff_t *tvb, proto_tree *tree, + guint length, int offset) +{ + if ((length - offset) < ( 4 * 2 + 8 )) + return; + + + proto_tree_add_bitmask(tree, tvb, offset, + hf_dlm3_rs_flags, ett_dlm3_rs_flags, + rs_flags_fields, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_rs_unused1, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_rs_unused2, tvb, offset, 8, ENC_LITTLE_ENDIAN); +} + + +static void +dissect_dlm3_rcom_lock(tvbuff_t *tvb, proto_tree *tree, + guint length, int offset) +{ + proto_item *sub_item; + proto_tree *sub_tree; + int sub_offset; + guint16 namelen; + guint32 exflags; + + + if ((length - offset) < ( 4 * 8 + 4 + 1 * 4 + 2 * 2 + + DLM3_RESNAME_MAXLEN )) + return; + + + proto_tree_add_item(tree, + hf_dlm3_rl_ownpid, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_rl_lkid, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_rl_remid, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_rl_parent_lkid, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_rl_parent_remid, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_bitmask(tree, tvb, offset, + hf_dlm3_rl_exflags, ett_dlm3_rl_exflags, + rl_exflags_fields, ENC_LITTLE_ENDIAN); + exflags = tvb_get_letohl(tvb, offset); + + + offset += 4; + proto_tree_add_bitmask(tree, tvb, offset, + hf_dlm3_rl_flags, ett_dlm3_rl_flags, + rl_flags_fields, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_rl_lvbseq, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_rl_result, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_rl_rqmode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + + offset += 1; + proto_tree_add_item(tree, + hf_dlm3_rl_grmode, tvb, offset, 1, ENC_LITTLE_ENDIAN); + + offset += 1; + proto_tree_add_item(tree, + hf_dlm3_rl_status, tvb, offset, 1, ENC_LITTLE_ENDIAN); + + offset += 1; + proto_tree_add_bitmask(tree, tvb, offset, + hf_dlm3_rl_asts, ett_dlm3_rl_asts, + rl_asts_fields, ENC_LITTLE_ENDIAN); + + offset += 1; + proto_tree_add_item(tree, + hf_dlm3_rl_wait_type, tvb, offset, 2, ENC_LITTLE_ENDIAN); + + offset += 2; + namelen = tvb_get_letohs(tvb, offset); + proto_tree_add_uint(tree, + hf_dlm3_rl_namelen, tvb, offset, 2, + namelen); + + offset += 2; + if (namelen <= DLM3_RESNAME_MAXLEN) { + sub_item = proto_tree_add_item(tree, + hf_dlm3_rl_name, tvb, offset, + DLM3_RESNAME_MAXLEN, ENC_NA); + + sub_tree = proto_item_add_subtree(sub_item, + ett_dlm3_rl_name); + sub_offset = offset; + proto_tree_add_item(sub_tree, + hf_dlm3_rl_name_contents, tvb, sub_offset, + namelen, ENC_ASCII); + + sub_offset += namelen; + proto_tree_add_item(sub_tree, + hf_dlm3_rl_name_padding, tvb, sub_offset, + DLM3_RESNAME_MAXLEN - namelen, ENC_NA); + } else { + /* XXX - report an error */ + } + + offset += DLM3_RESNAME_MAXLEN; + if (((length - offset) > 0) && (exflags & DLM3_LKF_VALBLK)) + proto_tree_add_item(tree, + hf_dlm3_rl_lvb, tvb, offset, + -1, + ENC_NA); +} + + +static void +dissect_dlm3_rcom_config(tvbuff_t *tvb, proto_tree *tree, + guint length, int offset) +{ + if ((length - offset) < ( 4 + 4 + 8 )) + return; + + proto_tree_add_item(tree, + hf_dlm3_rf_lvblen, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_bitmask(tree, tvb, offset, + hf_dlm3_rf_lsflags, ett_dlm3_rf_lsflags, + rf_lsflags_fields, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_rf_unused, tvb, offset, 8, ENC_LITTLE_ENDIAN); + + + /*offset += 8;*/ + /* END */ +} + +static void +dissect_dlm3_rcom(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, + guint length, int offset, guint32 h_version) +{ + guint32 rc_type; + + proto_item *sub_item; + proto_tree *sub_tree; + + + rc_type = tvb_get_letohl(tvb, offset); + proto_tree_add_uint(tree, + hf_dlm3_rc_type, tvb, offset, 4, rc_type); + col_append_fstr(pinfo->cinfo, COL_INFO, + ": %s", + val_to_str_const(rc_type, + dlm3_rcom, + "Unknown")); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_rc_result, tvb, offset, 4, ENC_LITTLE_ENDIAN); + + offset += 4; + proto_tree_add_item(tree, + hf_dlm3_rc_id, tvb, offset, 8, ENC_LITTLE_ENDIAN); + + offset += 8; + proto_tree_add_item(tree, + hf_dlm3_rc_seq, tvb, offset, 8, ENC_LITTLE_ENDIAN); + + offset += 8; + proto_tree_add_item(tree, + hf_dlm3_rc_seq_reply, tvb, offset, 8, ENC_LITTLE_ENDIAN); + + offset += 8; + if ((length - offset) == 0) { + /* No rc_buf: Just return */ + return; + } + + /* Decode rc_buf */ + sub_item = proto_tree_add_item(tree, + hf_dlm3_rc_buf, + tvb, + offset, + -1, + ENC_NA); + + offset += 0; + if (rc_type == DLM3_RCOM_STATUS && (h_version & 0xffff) > 0) { + sub_tree = proto_item_add_subtree(sub_item, + ett_dlm3_rcom_status); + dissect_dlm3_rcom_status(tvb, sub_tree, length, offset); + } else if (rc_type == DLM3_RCOM_LOCK) { + sub_tree = proto_item_add_subtree(sub_item, + ett_dlm3_rcom_lock); + dissect_dlm3_rcom_lock(tvb, sub_tree, length, offset); + } else if (rc_type == DLM3_RCOM_STATUS_REPLY) { + sub_tree = proto_item_add_subtree(sub_item, + ett_dlm3_rcom_config); + dissect_dlm3_rcom_config(tvb, sub_tree, length, offset); + } + +} + +static int +dissect_dlm3_1(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_, + guint8 h_cmd, guint32 h_version, guint length, int offset) +{ + proto_item *sub_item; + proto_tree *sub_tree; + + switch (h_cmd) { + case DLM3_MSG: + case DLM3_RCOM: + break; + default: + return 0; + } + + sub_item = proto_tree_add_uint(tree, + hf_dlm3_h_version, tvb, offset, 4, + h_version); + sub_tree = proto_item_add_subtree(sub_item, ett_dlm3_version); + proto_tree_add_uint(sub_tree, + hf_dlm3_h_major_version, tvb, offset + 0, 2, + (h_version & 0xFFFF0000) >> 16); + proto_tree_add_uint(sub_tree, + hf_dlm3_h_minor_version, tvb, offset + 2, 2, + (h_version & 0x0000FFFF)); + offset += 4; + + proto_tree_add_item(tree, + hf_dlm3_h_lockspace, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(tree, + hf_dlm3_h_nodeid, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(tree, + hf_dlm3_h_length, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + + sub_item = proto_tree_add_uint(tree, + hf_dlm3_h_cmd, tvb, offset, 1, h_cmd); + offset += 1; + + proto_tree_add_item(tree, + hf_dlm3_h_pad, tvb, offset, 1, ENC_LITTLE_ENDIAN); + offset += 1; + + switch (h_cmd) { + case DLM3_MSG: + if (length < DLM_MSG_LEN) + return 0; + + sub_tree = proto_item_add_subtree(sub_item, ett_dlm3_msg); + dissect_dlm3_msg(tvb, pinfo, sub_tree, length, offset); + break; + case DLM3_RCOM: + if (length < DLM_RCOM_LEN) + return 0; + + sub_tree = proto_item_add_subtree(sub_item, ett_dlm3_rcom); + dissect_dlm3_rcom(tvb, pinfo, sub_tree, length, offset, h_version); + break; + default: + break; + } + + return tvb_captured_length(tvb); +} + +static int +dissect_dlm3_2(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_, + guint8 h_cmd, guint32 h_version, guint length) +{ + proto_item *sub_item, *opts_item; + proto_tree *sub_tree, *opts_tree; + int offset, tlv_offset; + guint o_nextcmd; + guint16 o_optlen, tmp, t_len; + + switch (h_cmd) { + case DLM3_MSG: + case DLM3_RCOM: + case DLM3_OPTS: + case DLM3_ACK: + case DLM3_FIN: + break; + default: + return 0; + } + + offset = 0; + + sub_item = proto_tree_add_uint(tree, + hf_dlm3_h_version, tvb, offset, 4, + h_version); + sub_tree = proto_item_add_subtree(sub_item, ett_dlm3_version); + proto_tree_add_uint(sub_tree, + hf_dlm3_h_major_version, tvb, offset + 0, 2, + (h_version & 0xFFFF0000) >> 16); + proto_tree_add_uint(sub_tree, + hf_dlm3_h_minor_version, tvb, offset + 2, 2, + (h_version & 0x0000FFFF)); + offset += 4; + + proto_tree_add_item(tree, + hf_dlm3_h_seq, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(tree, + hf_dlm3_h_nodeid, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + proto_tree_add_item(tree, + hf_dlm3_h_length, tvb, offset, 2, ENC_LITTLE_ENDIAN); + offset += 2; + + sub_item = proto_tree_add_uint(tree, + hf_dlm3_h_cmd, tvb, offset, 1, h_cmd); + offset += 1; + + proto_tree_add_item(tree, + hf_dlm3_h_pad, tvb, offset, 1, ENC_LITTLE_ENDIAN); + offset += 1; + + switch (h_cmd) { + case DLM3_OPTS: + if (length < DLM_OPTS_LEN) + return 0; + + sub_tree = proto_item_add_subtree(sub_item, ett_dlm3_opts); + o_nextcmd = tvb_get_guint8(tvb, offset); + col_append_fstr(pinfo->cinfo, COL_INFO, + ": %s", val_to_str_const(o_nextcmd, + dlm3_cmd, + "Unknown")); + sub_item = proto_tree_add_uint(sub_tree, hf_dlm3_o_nextcmd, tvb, offset, 1, o_nextcmd); + offset += 1; + + proto_tree_add_item(sub_tree, hf_dlm3_o_pad, tvb, offset, 1, ENC_LITTLE_ENDIAN); + offset += 1; + + o_optlen = tvb_get_letohs(tvb, offset); + tmp = DLM_OPTS_LEN + o_optlen; + if (length < tmp) + return 0; + + proto_tree_add_uint(sub_tree, hf_dlm3_o_optlen, tvb, offset, 2, o_optlen); + offset += 2; + + proto_tree_add_item(sub_tree, hf_dlm3_o_pad2, tvb, offset, 4, ENC_LITTLE_ENDIAN); + offset += 4; + + tmp = o_optlen; + if (tmp) { + opts_item = proto_tree_add_item(sub_tree, hf_dlm3_o_opts, tvb, offset, tmp, ENC_NA); + opts_tree = proto_item_add_subtree(opts_item, ett_dlm3_options); + + tlv_offset = 0; + while (tmp > 0) { + proto_tree_add_item(opts_tree, hf_dlm3_t_type, tvb, offset, 2, ENC_LITTLE_ENDIAN); + tlv_offset += 2; + + t_len = tvb_get_letohs(tvb, offset); + if (t_len > o_optlen - tlv_offset) + return 0; + proto_tree_add_uint(opts_tree, hf_dlm3_t_length, tvb, offset, 2, t_len); + tlv_offset += 2; + + proto_tree_add_item(opts_tree, hf_dlm3_t_pad, tvb, offset, 4, ENC_LITTLE_ENDIAN); + tlv_offset += 4; + + proto_tree_add_item(opts_tree, hf_dlm3_t_value, tvb, offset, t_len, ENC_NA); + tlv_offset += t_len; + tmp -= t_len; + } + offset += tlv_offset; + } + + switch (o_nextcmd) { + case DLM3_MSG: + tmp = DLM_OPTS_LEN + o_optlen + DLM_RCOM_LEN; + if (length < tmp) + return 0; + + sub_tree = proto_item_add_subtree(sub_item, ett_dlm3_next_cmd); + dissect_dlm3_1(tvb, pinfo, sub_tree, data, o_nextcmd, h_version, length, offset); + break; + case DLM3_RCOM: + tmp = DLM_OPTS_LEN + o_optlen + DLM_RCOM_LEN; + if (length < tmp) + return 0; + + sub_tree = proto_item_add_subtree(sub_item, ett_dlm3_next_cmd); + dissect_dlm3_1(tvb, pinfo, sub_tree, data, o_nextcmd, h_version, length, offset); + break; + default: + return 0; + } + break; + case DLM3_MSG: + if (length < DLM_MSG_LEN) + return 0; + + dissect_dlm3_1(tvb, pinfo, sub_tree, data, h_cmd, h_version, length, offset); + break; + case DLM3_RCOM: + if (length < DLM_RCOM_LEN) + return 0; + + dissect_dlm3_1(tvb, pinfo, sub_tree, data, h_cmd, h_version, length, offset); + break; + default: + break; + } + + return tvb_captured_length(tvb); +} + +static int +dissect_dlm3(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void *data _U_) +{ + proto_item *item; + proto_tree *tree; + guint length; + guint32 h_version; + guint8 h_cmd; + int ret = 0; + + + /* Check that there's enough data */ + length = tvb_captured_length(tvb); + if (length < DLM_HEADER_LEN) + return 0; + + /* Check the protocol version */ + h_version = tvb_get_letohl(tvb, 0); + if ((h_version & 0xffff0000) != DLM3_MAJOR_VERSION || + (h_version & 0xffff) > DLM3_MINOR_VERSION_MAX) + return 0; + + col_set_str(pinfo->cinfo, COL_PROTOCOL, "DLM3"); + + + col_set_str(pinfo->cinfo, COL_INFO, "DLM3"); + + h_cmd = tvb_get_guint8(tvb, DLM_HEADER_LEN - 1 - 1); + col_set_str(pinfo->cinfo, COL_INFO, + val_to_str_const(h_cmd, + dlm3_cmd, + "packet-dlm3.c internal bug")); + + item = proto_tree_add_item(parent_tree, proto_dlm3, tvb, 0, + -1, ENC_NA); + tree = proto_item_add_subtree(item, ett_dlm3); + + switch (h_version) { + case DLM_VERSION_3_1: + ret = dissect_dlm3_1(tvb, pinfo, tree, data, h_cmd, h_version, length, 0); + break; + case DLM_VERSION_3_2: + ret = dissect_dlm3_2(tvb, pinfo, tree, data, h_cmd, h_version, length); + break; + default: + break; + } + + return ret; +} + +/* This method dissects fully reassembled messages */ +static int +dissect_dlm3_message(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) +{ + dissect_dlm3(tvb, pinfo, tree, data); + return tvb_captured_length(tvb); +} + +/* determine PDU length of protocol foo */ +static guint +get_dlm3_message_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset, void *data _U_) +{ + return tvb_get_letohs(tvb, offset + DLM_HEADER_LEN - 2 - 1 - 1); +} + +static int +dissect_tcp_dlm3(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data) +{ + tcp_dissect_pdus(tvb, pinfo, tree, TRUE, DLM_HEADER_LEN - 1 - 1, + get_dlm3_message_len, dissect_dlm3_message, data); + return tvb_captured_length(tvb); +} + +/* Register the protocol with Wireshark */ + +void +proto_register_dlm3(void) +{ + + static hf_register_info hf[] = { + /* dlm_header */ + { &hf_dlm3_h_version, + { "Version", "dlm3.h.version", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_h_major_version, + { "Major Version", "dlm3.h.major_version", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_h_minor_version, + { "Minor Version", "dlm3.h.minor_version", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_h_lockspace, + { "Lockspace Global ID", "dlm3.h.lockspac", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_h_seq, + { "Sequence Number", "dlm3.h.seq", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_h_nodeid, + { "Sender Node ID", "dlm3.h.nodeid", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_h_length, + { "Length", "dlm3.h.length", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_h_cmd, + { "Command", "dlm3.h.cmd", + FT_UINT8, BASE_DEC, VALS(dlm3_cmd), 0x0, + NULL, HFILL }}, + { &hf_dlm3_h_pad, + { "Padding", "dlm3.h.pad", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + + /* dlm_opts */ + { &hf_dlm3_o_nextcmd, + { "Next Command", "dlm3.o.nextcmd", + FT_UINT8, BASE_DEC, VALS(dlm3_cmd), 0x0, + NULL, HFILL }}, + { &hf_dlm3_o_pad, + { "Padding", "dlm3.o.pad", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_o_optlen, + { "Options Length", "dlm3.o.optlen", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_o_pad2, + { "Padding", "dlm3.o.pad2", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_o_opts, + { "Options", "dlm3.o.opts", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + /* dlm_opt_header */ + { &hf_dlm3_t_type, + { "Type", "dlm3.t.type", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_t_length, + { "Length", "dlm3.t.length", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_t_pad, + { "Padding", "dlm3.t.pad", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_t_value, + { "Value", "dlm3.t.value", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + + /* dlm_message */ + { &hf_dlm3_m_type, + { "Message Type", "dlm3.m.type", + FT_UINT32, BASE_DEC, VALS(dlm3_msg), 0x0, + NULL, HFILL }}, + { &hf_dlm3_m_nodeid, + { "Receiver Node ID", "dlm3.m.nodeid", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_m_pid, + { "Process ID of Lock Owner", "dlm3.m.pid", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_m_lkid, + { "Lock ID on Sender", "dlm3.m.lkid", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_m_remid, + { "Lock ID on Receiver", "dlm3.m.remid", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_m_parent_lkid, + { "Parent Lock ID on Sender", "dlm3.m.parent_lkid", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_m_parent_remid, + { "Parent Lock ID on Receiver", "dlm3.m.parent_remid", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL}}, + /* dlm_message::exflags */ + { &hf_dlm3_m_exflags, + { "External Flags", "dlm3.m.exflags", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_noqueue, + { "Don't queue", "dlm3.m.exflags.noqueue", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NOQUEUE, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_cancel, + { "Cancel", "dlm3.m.exflags.cancel", + FT_BOOLEAN, 32, NULL, DLM3_LKF_CANCEL, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_convert, + { "Convert", "dlm3.m.exflags.convert", + FT_BOOLEAN, 32, NULL, DLM3_LKF_CONVERT, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_valblk, + { "Return the contents of the lock value block", "dlm3.m.exflags.valblk", + FT_BOOLEAN, 32, NULL, DLM3_LKF_VALBLK, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_quecvt, + { "Force a conversion request to be queued", "dlm3.m.exflags.quecvt", + FT_BOOLEAN, 32, NULL, DLM3_LKF_QUECVT, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_ivvalblk, + { "Invalidate the lock value block", "dlm3.m.exflags.ivvalblk", + FT_BOOLEAN, 32, NULL, DLM3_LKF_IVVALBLK, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_convdeadlk, + { "Forced down to NL to resolve a conversion deadlock", "dlm3.m.exflags.convdeadlk", + FT_BOOLEAN, 32, NULL, DLM3_LKF_CONVDEADLK, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_persistent, + { "Persistent", "dlm3.m.exflags.persistent", + FT_BOOLEAN, 32, NULL, DLM3_LKF_PERSISTENT, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_nodlckwt, + { "Don't cancel the lock if it gets into conversion deadlock", "dlm3.m.exflags.nodlckwt", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NODLCKWT, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_nodlckblk, + { "Nodlckblk", "dlm3.m.exflags.nodlckblk", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NODLCKBLK, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_expedite, + { "Grant a NL lock immediately", "dlm3.m.exflags.expedite", + FT_BOOLEAN, 32, NULL, DLM3_LKF_EXPEDITE, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_noqueuebast, + { "Send blocking ASTs even for NOQUEUE operations", "dlm3.m.exflags.noqueuebast", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NOQUEUEBAST, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_headque, + { "Add a lock to the head of the queue", "dlm3.m.exflags.headque", + FT_BOOLEAN, 32, NULL, DLM3_LKF_HEADQUE, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_noorder, + { "Disregard the standard grant order rules", "dlm3.m.exflags.noorder", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NOORDER, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_orphan, + { "Orphan", "dlm3.m.exflags.orphan", + FT_BOOLEAN, 32, NULL, DLM3_LKF_ORPHAN, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_altpr, + { "Try to grant the lock in `protected read' mode", "dlm3.m.exflags.altpr", + FT_BOOLEAN, 32, NULL, DLM3_LKF_ALTPR, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_altcw, + { "Try to grant the lock in `concurrent read' mode", "dlm3.m.exflags.altcw", + FT_BOOLEAN, 32, NULL, DLM3_LKF_ALTCW, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_forceunlock, + { "Force unlock", "dlm3.m.exflags.forceunlock", + FT_BOOLEAN, 32, NULL, DLM3_LKF_FORCEUNLOCK, + NULL, HFILL}}, + { &hf_dlm3_m_exflags_timeout, + { "Timeout", "dlm3.m.exflags.timeout", + FT_BOOLEAN, 32, NULL, DLM3_LKF_TIMEOUT, + NULL, HFILL}}, + /* dlm_message::sbflags */ + { &hf_dlm3_m_sbflags, + { "Status Block Flags", "dlm3.m.sbflags", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_m_sbflags_demoted, + { "Demoted for deadlock resolution", "dlm3.m.sbflags.demoted", + FT_BOOLEAN, 32, NULL, DLM3_SBF_DEMOTED, + NULL, HFILL}}, + { &hf_dlm3_m_sbflags_valnotvalid, + { "Lock Value Block Is Invalid", "dlm3.m.sbflags.valnotvalid", + FT_BOOLEAN, 32, NULL, DLM3_SBF_VALNOTVALID, + NULL, HFILL}}, + { &hf_dlm3_m_sbflags_altmode, + { "Try to Grant in Alternative Mode", "dlm3.m.sbflags.altmode", + FT_BOOLEAN, 32, NULL, DLM3_SBF_ALTMODE, + NULL, HFILL}}, + + /* dlm_message::flags */ + { &hf_dlm3_m_flags, + { "Internal Flags", "dlm3.m.flags", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_m_flags_user, + { "User space lock related", "dlm3.m.flags.user", + FT_BOOLEAN, 32, NULL, DLM3_IFL_USER, + NULL, HFILL}}, + { &hf_dlm3_m_flags_orphan, + { "Orphaned lock", "dlm3.m.flags.orphan", + FT_BOOLEAN, 32, NULL, DLM3_IFL_ORPHAN, + NULL, HFILL}}, + + { &hf_dlm3_m_lvbseq, + { "Lock Value Block Sequence Number", "dlm3.m.lvbseq", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL}}, + + { &hf_dlm3_m_hash, + { "Hash value", "dlm3.m.hash", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL}}, + + { &hf_dlm3_m_status, + { "Status", "dlm3.m.status", + FT_INT32, BASE_DEC, VALS(dlm3_status), 0x0, + NULL, HFILL}}, + + { &hf_dlm3_m_grmode, + { "Granted Mode", "dlm3.m.grmode", + FT_INT32, BASE_DEC, VALS(dlm3_mode), 0x0, + NULL, HFILL}}, + { &hf_dlm3_m_rqmode, + { "Request Mode", "dlm3.m.rqmode", + FT_INT32, BASE_DEC, VALS(dlm3_mode), 0x0, + NULL, HFILL}}, + { &hf_dlm3_m_bastmode, + { "Mode requested by another node", "dlm3.m.bastmode", + FT_INT32, BASE_DEC, VALS(dlm3_mode), 0x0, + NULL, HFILL}}, + + /* dlm_message::asts */ + { &hf_dlm3_m_asts, + { "Asynchronous Traps", "dlm3.m.asts", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_m_asts_comp, + { "Completion", "dlm3.m.asts.comp", + FT_BOOLEAN, 32, NULL, DLM3_AST_COMP, + NULL, HFILL }}, + { &hf_dlm3_m_asts_bast, + { "Blocking", "dlm3.m.asts.bast", + FT_BOOLEAN, 32, NULL, DLM3_AST_BAST, + NULL, HFILL }}, + + { &hf_dlm3_m_result, + { "Message Result(errno)", "dlm3.m.result", + FT_INT32, BASE_DEC, VALS(dlm3_result), 0x0, + NULL, HFILL}}, + { &hf_dlm3_m_extra, + { "Extra Message", "dlm3.m.extra", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL}}, + + /* dlm_rcom */ + { &hf_dlm3_rc_type, + { "Recovery Command Type", "dlm3.rc.type", + FT_UINT32, BASE_DEC, VALS(dlm3_rcom), 0x0, + NULL, HFILL}}, + { &hf_dlm3_rc_result, + { "Recovery Command Result", "dlm3.rc.result", + FT_INT32, BASE_DEC, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rc_id, + { "Recovery Command ID", "dlm3.rc.id", + FT_UINT64, BASE_DEC, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rc_seq, + { "Recovery Command Sequence Number of Sender", "dlm3.rc.seq", + FT_UINT64, BASE_DEC, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rc_seq_reply, + { "Recovery Command Sequence Number of Receiver", "dlm3.rc.seq_reply", + FT_UINT64, BASE_DEC, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rc_buf, + { "Recovery Buffer", "dlm3.rc.buf", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL}}, + + /* rcom_config */ + { &hf_dlm3_rf_lvblen, + { "Lock Value Block Length", "dlm3.rf.lvblen", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL}}, + + /* rcom_config::rf_lsflags */ + { &hf_dlm3_rf_lsflags, + { "External Flags", "dlm3.rf.lsflags", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_noqueue, + { "Don't queue", "dlm3.rf.lsflags.noqueue", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NOQUEUE, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_cancel, + { "Cancel", "dlm3.rf.lsflags.cancel", + FT_BOOLEAN, 32, NULL, DLM3_LKF_CANCEL, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_convert, + { "Convert", "dlm3.rf.lsflags.convert", + FT_BOOLEAN, 32, NULL, DLM3_LKF_CONVERT, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_valblk, + { "Return the contents of the lock value block", "dlm3.rf.lsflags.valblk", + FT_BOOLEAN, 32, NULL, DLM3_LKF_VALBLK, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_quecvt, + { "Force a conversion request to be queued", "dlm3.rf.lsflags.quecvt", + FT_BOOLEAN, 32, NULL, DLM3_LKF_QUECVT, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_ivvalblk, + { "Invalidate the lock value block", "dlm3.rf.lsflags.ivvalblk", + FT_BOOLEAN, 32, NULL, DLM3_LKF_IVVALBLK, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_convdeadlk, + { "Forced down to NL to resolve a conversion deadlock", "dlm3.rf.lsflags.convdeadlk", + FT_BOOLEAN, 32, NULL, DLM3_LKF_CONVDEADLK, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_persistent, + { "Persistent", "dlm3.rf.lsflags.persistent", + FT_BOOLEAN, 32, NULL, DLM3_LKF_PERSISTENT, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_nodlckwt, + { "Don't cancel the lock if it gets into conversion deadlock", "dlm3.rf.lsflags.nodlckwt", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NODLCKWT, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_nodlckblk, + { "Nodlckblk", "dlm3.rf.lsflags.nodlckblk", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NODLCKBLK, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_expedite, + { "Grant a NL lock immediately", "dlm3.rf.lsflags.expedite", + FT_BOOLEAN, 32, NULL, DLM3_LKF_EXPEDITE, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_noqueuebast, + { "Send blocking ASTs even for NOQUEUE operations", "dlm3.rf.lsflags.noqueuebast", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NOQUEUEBAST, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_headque, + { "Add a lock to the head of the queue", "dlm3.rf.lsflags.headque", + FT_BOOLEAN, 32, NULL, DLM3_LKF_HEADQUE, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_noorder, + { "Disregard the standard grant order rules", "dlm3.rf.lsflags.noorder", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NOORDER, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_orphan, + { "Orphan", "dlm3.rf.lsflags.orphan", + FT_BOOLEAN, 32, NULL, DLM3_LKF_ORPHAN, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_altpr, + { "Try to grant the lock in `protected read' mode", "dlm3.rf.lsflags.altpr", + FT_BOOLEAN, 32, NULL, DLM3_LKF_ALTPR, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_altcw, + { "Try to grant the lock in `concurrent read' mode", "dlm3.rf.lsflags.altcw", + FT_BOOLEAN, 32, NULL, DLM3_LKF_ALTCW, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_forceunlock, + { "Force unlock", "dlm3.rf.lsflags.forceunlock", + FT_BOOLEAN, 32, NULL, DLM3_LKF_FORCEUNLOCK, + NULL, HFILL}}, + { &hf_dlm3_rf_lsflags_timeout, + { "Timeout", "dlm3.rf.lsflags.timeout", + FT_BOOLEAN, 32, NULL, DLM3_LKF_TIMEOUT, + NULL, HFILL}}, + + { &hf_dlm3_rf_unused, + { "Unused area", "dlm3.rf.lsflags.unused", + FT_UINT64, BASE_HEX, NULL, 0x0, + NULL, HFILL}}, + + /* rcom_status */ + { &hf_dlm3_rs_flags, + { "Recovery Command Status Flags", "dlm3.rs.flags", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rs_flags_need_slots, + { "Need slots", "dlm3.rs.flags.need_slots", + FT_UINT32, BASE_HEX, NULL, DLM_RSF_NEED_SLOTS, + NULL, HFILL}}, + { &hf_dlm3_rs_unused1, + { "Unused area", "dlm3.rs.unused1", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rs_unused2, + { "Unused area", "dlm3.rs.unused2", + FT_UINT64, BASE_HEX, NULL, 0x0, + NULL, HFILL}}, + + /* rcom_lock */ + { &hf_dlm3_rl_ownpid, + { "Process ID of Lock Owner", "dlm3.rl.ownpid", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rl_lkid, + { "Lock ID on Sender", "dlm3.rl.lkid", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rl_remid, + { "Lock ID on Receiver", "dlm3.rl.remid", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rl_parent_lkid, + { "Parent Lock ID on Sender", "dlm3.rl.parent_lkid", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rl_parent_remid, + { "Parent Lock ID on Receiver", "dlm3.rl.parent_remid", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL}}, + + { &hf_dlm3_rl_exflags, + { "External Flags", "dlm3.rl.exflags", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_noqueue, + { "Don't queue", "dlm3.rl.exflags.noqueue", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NOQUEUE, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_cancel, + { "Cancel", "dlm3.rl.exflags.cancel", + FT_BOOLEAN, 32, NULL, DLM3_LKF_CANCEL, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_convert, + { "Convert", "dlm3.rl.exflags.convert", + FT_BOOLEAN, 32, NULL, DLM3_LKF_CONVERT, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_valblk, + { "Return the contents of the lock value block", "dlm3.rl.exflags.valblk", + FT_BOOLEAN, 32, NULL, DLM3_LKF_VALBLK, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_quecvt, + { "Force a conversion request to be queued", "dlm3.rl.exflags.quecvt", + FT_BOOLEAN, 32, NULL, DLM3_LKF_QUECVT, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_ivvalblk, + { "Invalidate the lock value block", "dlm3.rl.exflags.ivvalblk", + FT_BOOLEAN, 32, NULL, DLM3_LKF_IVVALBLK, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_convdeadlk, + { "Forced down to NL to resolve a conversion deadlock", "dlm3.rl.exflags.convdeadlk", + FT_BOOLEAN, 32, NULL, DLM3_LKF_CONVDEADLK, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_persistent, + { "Persistent", "dlm3.rl.exflags.persistent", + FT_BOOLEAN, 32, NULL, DLM3_LKF_PERSISTENT, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_nodlckwt, + { "Don't cancel the lock if it gets into conversion deadlock", "dlm3.rl.exflags.nodlckwt", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NODLCKWT, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_nodlckblk, + { "Nodlckblk", "dlm3.rl.exflags.nodlckblk", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NODLCKBLK, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_expedite, + { "Grant a NL lock immediately", "dlm3.rl.exflags.expedite", + FT_BOOLEAN, 32, NULL, DLM3_LKF_EXPEDITE, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_noqueuebast, + { "Send blocking ASTs even for NOQUEUE operations", "dlm3.rl.exflags.noqueuebast", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NOQUEUEBAST, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_headque, + { "Add a lock to the head of the queue", "dlm3.rl.exflags.headque", + FT_BOOLEAN, 32, NULL, DLM3_LKF_HEADQUE, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_noorder, + { "Disregard the standard grant order rules", "dlm3.rl.exflags.noorder", + FT_BOOLEAN, 32, NULL, DLM3_LKF_NOORDER, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_orphan, + { "Orphan", "dlm3.rl.exflags.orphan", + FT_BOOLEAN, 32, NULL, DLM3_LKF_ORPHAN, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_altpr, + { "Try to grant the lock in `protected read' mode", "dlm3.rl.exflags.altpr", + FT_BOOLEAN, 32, NULL, DLM3_LKF_ALTPR, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_altcw, + { "Try to grant the lock in `concurrent read' mode", "dlm3.rl.exflags.altcw", + FT_BOOLEAN, 32, NULL, DLM3_LKF_ALTCW, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_forceunlock, + { "Force unlock", "dlm3.rl.exflags.forceunlock", + FT_BOOLEAN, 32, NULL, DLM3_LKF_FORCEUNLOCK, + NULL, HFILL}}, + { &hf_dlm3_rl_exflags_timeout, + { "Timeout", "dlm3.rl.exflags.timeout", + FT_BOOLEAN, 32, NULL, DLM3_LKF_TIMEOUT, + NULL, HFILL}}, + { &hf_dlm3_rl_flags, + { "Internal Flags", "dlm3.rl.flags", + FT_UINT32, BASE_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rl_flags_user, + { "User space lock related", "dlm3.rl.flags.user", + FT_BOOLEAN, 32, NULL, DLM3_IFL_USER, + NULL, HFILL}}, + { &hf_dlm3_rl_flags_orphan, + { "Orphaned lock", "dlm3.rl.flags.orphan", + FT_BOOLEAN, 32, NULL, DLM3_IFL_ORPHAN, + NULL, HFILL}}, + + { &hf_dlm3_rl_lvbseq, + { "Lock Value Block Sequence Number", "dlm3.rl.lvbseq", + FT_UINT32, BASE_DEC_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rl_result, + { "Result of Recovering master copy", "dlm3.rl.result", + FT_INT32, BASE_DEC, VALS(dlm3_result), 0x0, + NULL, HFILL}}, + { &hf_dlm3_rl_rqmode, + { "Request Mode", "dlm3.rl.rqmode", + FT_INT8, BASE_DEC, VALS(dlm3_mode), 0x0, + NULL, HFILL}}, + { &hf_dlm3_rl_grmode, + { "Granted Mode", "dlm3.rl.grmode", + FT_INT8, BASE_DEC, VALS(dlm3_mode), 0x0, + NULL, HFILL}}, + { &hf_dlm3_rl_status, + { "Status", "dlm3.rl.status", + FT_INT8, BASE_DEC, VALS(dlm3_rs), 0x0, + NULL, HFILL}}, + { &hf_dlm3_rl_asts, + { "Asynchronous Traps", "dlm3.rl.asts", + FT_UINT8, BASE_HEX, NULL, 0x0, + NULL, HFILL}}, + { &hf_dlm3_rl_asts_comp, + { "Completion", "dlm3.rl.asts.comp", + FT_BOOLEAN, 8, NULL, DLM3_AST_COMP, + NULL, HFILL }}, + { &hf_dlm3_rl_asts_bast, + { "Blocking", "dlm3.rl.asts.bast", + FT_BOOLEAN, 8, NULL, DLM3_AST_BAST, + NULL, HFILL }}, + + { &hf_dlm3_rl_wait_type, + { "Message Type the waiter is waiting for", "dlm3.rl.wait_type", + FT_UINT16, BASE_DEC, VALS(dlm3_msg), 0x0, + NULL, HFILL }}, + + { &hf_dlm3_rl_namelen, + { "Length of `name' field", "dlm3.rl.namelen", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_rl_name, + { "Name of Resource", "dlm3.rl.name", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_rl_name_contents, + { "Contents actually occupying `name' field", "dlm3.rl.name_contents", + FT_STRING, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_rl_name_padding, + { "Padding", "dlm3.rl.name_padding", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }}, + { &hf_dlm3_rl_lvb, + { "Lock Value Block", "dlm3.rl.lvb", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL }} + }; + + static gint *ett[] = { + &ett_dlm3, + &ett_dlm3_version, + + &ett_dlm3_opts, + &ett_dlm3_options, + &ett_dlm3_next_cmd, + + &ett_dlm3_msg, + &ett_dlm3_m_exflags, + &ett_dlm3_sbflags, + &ett_dlm3_m_flags, + &ett_dlm3_m_asts, + + &ett_dlm3_rcom, + &ett_dlm3_rcom_status, + &ett_dlm3_rcom_lock, + &ett_dlm3_rcom_config, + + &ett_dlm3_rs_flags, + + &ett_dlm3_rf_lsflags, + &ett_dlm3_rl_exflags, + &ett_dlm3_rl_flags, + &ett_dlm3_rl_asts, + &ett_dlm3_rl_name + }; + + proto_dlm3 = proto_register_protocol("Distributed Lock Manager", + "DLM3", "dlm3"); + proto_register_field_array(proto_dlm3, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + + /* dlm3_module = prefs_register_protocol(proto_dlm3, NULL); */ + + dlm3_sctp_handle = register_dissector("dlm3", dissect_dlm3, proto_dlm3); + dlm3_tcp_handle = register_dissector("dlm3.tcp", dissect_tcp_dlm3, proto_dlm3); + +} + + +void +proto_reg_handoff_dlm3(void) +{ + dissector_add_uint_with_preference("tcp.port", TCP_PORT_DLM3, dlm3_tcp_handle); + dissector_add_uint_with_preference("sctp.port", SCTP_PORT_DLM3, dlm3_sctp_handle); +} + +/* packet-dlm3.c ends here. */ + +/* + * Editor modelines - https://www.wireshark.org/tools/modelines.html + * + * Local Variables: + * c-basic-offset: 2 + * tab-width: 8 + * indent-tabs-mode: nil + * End: + * + * ex: set shiftwidth=2 tabstop=8 expandtab: + * :indentSize=2:tabSize=8:noTabs=true: + */ |