path: root/epan/dissectors/packet-nisplus.c

/* packet-nisplus.c
 * 2001  Ronnie Sahlberg   <See AUTHORS for email>
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#include "config.h"


#include "packet-rpc.h"
#include "packet-nisplus.h"

void proto_register_nis(void);
void proto_reg_handoff_nis(void);
void proto_register_niscb(void);
void proto_reg_handoff_niscb(void);

static int proto_nisplus;
static int hf_nisplus_procedure_v3;
static int hf_nisplus_object;
static int hf_nisplus_oid;
static int hf_nisplus_object_ctime;
static int hf_nisplus_object_mtime;
static int hf_nisplus_object_name;
static int hf_nisplus_object_owner;
static int hf_nisplus_object_group;
static int hf_nisplus_object_domain;
static int hf_nisplus_object_ttl;
static int hf_nisplus_object_type;
static int hf_nisplus_object_private;
static int hf_nisplus_directory;
static int hf_nisplus_directory_name;
static int hf_nisplus_directory_type;
static int hf_nisplus_directory_ttl;
static int hf_nisplus_directory_mask;
static int hf_nisplus_directory_mask_list;
static int hf_nisplus_access_mask;
static int hf_nisplus_mask_world_read;
static int hf_nisplus_mask_world_modify;
static int hf_nisplus_mask_world_create;
static int hf_nisplus_mask_world_destroy;
static int hf_nisplus_mask_group_read;
static int hf_nisplus_mask_group_modify;
static int hf_nisplus_mask_group_create;
static int hf_nisplus_mask_group_destroy;
static int hf_nisplus_mask_owner_read;
static int hf_nisplus_mask_owner_modify;
static int hf_nisplus_mask_owner_create;
static int hf_nisplus_mask_owner_destroy;
static int hf_nisplus_mask_nobody_read;
static int hf_nisplus_mask_nobody_modify;
static int hf_nisplus_mask_nobody_create;
static int hf_nisplus_mask_nobody_destroy;
static int hf_nisplus_server_name;
static int hf_nisplus_key_type;
static int hf_nisplus_key_data;
static int hf_nisplus_servers;
static int hf_nisplus_cbservers;
static int hf_nisplus_server;
static int hf_nisplus_endpoints;
static int hf_nisplus_endpoint;
static int hf_nisplus_endpoint_uaddr;
static int hf_nisplus_endpoint_family;
static int hf_nisplus_endpoint_proto;
static int hf_nisplus_link;
static int hf_nisplus_attrs_array;
static int hf_nisplus_attr;
static int hf_nisplus_attr_name;
static int hf_nisplus_attr_val;
static int hf_nisplus_entry;
static int hf_nisplus_entry_type;
static int hf_nisplus_entry_cols;
static int hf_nisplus_entry_col;
/* static int hf_nisplus_entry_flags; */
static int hf_nisplus_entry_val;
static int hf_nisplus_entry_mask;
static int hf_nisplus_entry_mask_binary;
static int hf_nisplus_entry_mask_crypt;
static int hf_nisplus_entry_mask_xdr;
static int hf_nisplus_entry_mask_modified;
static int hf_nisplus_entry_mask_asn;
static int hf_nisplus_table;
static int hf_nisplus_table_type;
static int hf_nisplus_table_maxcol;
static int hf_nisplus_table_sep;
static int hf_nisplus_table_cols;
static int hf_nisplus_table_col;
static int hf_nisplus_table_path;
static int hf_nisplus_table_col_name;
static int hf_nisplus_table_col_mask;
static int hf_nisplus_table_col_mask_binary;
static int hf_nisplus_table_col_mask_encrypted;
static int hf_nisplus_table_col_mask_xdr;
static int hf_nisplus_table_col_mask_searchable;
static int hf_nisplus_table_col_mask_casesensitive;
static int hf_nisplus_table_col_mask_modified;
static int hf_nisplus_table_col_mask_asn;
static int hf_nisplus_group;
static int hf_nisplus_group_flags;
static int hf_nisplus_grps;
static int hf_nisplus_group_name;
static int hf_nisplus_ib_flags;
static int hf_nisplus_ib_bufsize;
static int hf_nisplus_cookie;
static int hf_nisplus_fd_dirname;
static int hf_nisplus_fd_requester;
static int hf_nisplus_taglist;
static int hf_nisplus_tag;
static int hf_nisplus_tag_type;
static int hf_nisplus_tag_val;
static int hf_nisplus_dump_dir;
static int hf_nisplus_dump_time;
static int hf_nisplus_dummy;
static int hf_nisplus_ping_dir;
static int hf_nisplus_ping_time;
static int hf_nisplus_error;
static int hf_nisplus_dir_data;
static int hf_nisplus_signature;
static int hf_nisplus_log_entries;
static int hf_nisplus_log_entry;
static int hf_nisplus_log_type;
static int hf_nisplus_log_time;
static int hf_nisplus_log_principal;
static int hf_nisplus_callback_status;
static int hf_nisplus_cp_status;
static int hf_nisplus_cp_zticks;
static int hf_nisplus_cp_dticks;
static int hf_nisplus_zticks;
static int hf_nisplus_dticks;
static int hf_nisplus_aticks;
static int hf_nisplus_cticks;

static int ett_nisplus;
static int ett_nisplus_object;
static int ett_nisplus_oid;
static int ett_nisplus_directory;
static int ett_nisplus_directory_mask;
static int ett_nisplus_access_mask;
static int ett_nisplus_server;
static int ett_nisplus_endpoint;
static int ett_nisplus_link;
static int ett_nisplus_attr;
static int ett_nisplus_entry;
static int ett_nisplus_entry_col;
static int ett_nisplus_entry_mask;
static int ett_nisplus_table;
static int ett_nisplus_table_col;
static int ett_nisplus_table_col_mask;
static int ett_nisplus_group;
static int ett_nisplus_grps;
static int ett_nisplus_tag;
static int ett_nisplus_log_entry;


#define NIS_MASK_TABLE_BINARY   0x00000001
#define NIS_MASK_TABLE_CRYPT    0x00000002
#define NIS_MASK_TABLE_XDR      0x00000004
#define NIS_MASK_TABLE_SRCH     0x00000008
#define NIS_MASK_TABLE_CASE     0x00000010
#define NIS_MASK_TABLE_MODIFIED 0x00000020
#define NIS_MASK_TABLE_ASN      0x00000040


#define NIS_MASK_ENTRY_BINARY   0x00000001
#define NIS_MASK_ENTRY_CRYPT    0x00000002
#define NIS_MASK_ENTRY_XDR      0x00000004
#define NIS_MASK_ENTRY_MODIFIED 0x00000008
#define NIS_MASK_ENTRY_ASN      0x00000040


#define NIS_MASK_WORLD_READ     0x00000001
#define NIS_MASK_WORLD_MODIFY   0x00000002
#define NIS_MASK_WORLD_CREATE   0x00000004
#define NIS_MASK_WORLD_DESTROY  0x00000008
#define NIS_MASK_GROUP_READ     0x00000010
#define NIS_MASK_GROUP_MODIFY   0x00000020
#define NIS_MASK_GROUP_CREATE   0x00000040
#define NIS_MASK_GROUP_DESTROY  0x00000080
#define NIS_MASK_OWNER_READ     0x00000100
#define NIS_MASK_OWNER_MODIFY   0x00000200
#define NIS_MASK_OWNER_CREATE   0x00000400
#define NIS_MASK_OWNER_DESTROY  0x00000800
#define NIS_MASK_NOBODY_READ    0x00001000
#define NIS_MASK_NOBODY_MODIFY  0x00002000
#define NIS_MASK_NOBODY_CREATE  0x00004000
#define NIS_MASK_NOBODY_DESTROY 0x00008000


static const value_string key_type[] = {
#define NIS_KEY_NONE		0
	{	NIS_KEY_NONE,		"No Public Key (unix/sys auth)"	},
#define NIS_KEY_DH		1
	{	NIS_KEY_DH,		"Diffie-Hellman"	},
#define NIS_KEY_RSA		2
	{	NIS_KEY_RSA,		"RSA"	},
#define NIS_KEY_KERB		3
	{	NIS_KEY_KERB,		"Kerberos"	},
#define NIS_KEY_DHEXT		4
	{	NIS_KEY_DHEXT,		"Extended Diffie-Hellman for RPC-GSS"	},
	{	0,	NULL	},
};

static const value_string obj_type[] = {
#define NIS_BOGUS_OBJ		0
	{	NIS_BOGUS_OBJ,		"Bogus Object"	},
#define NIS_NO_OBJ		1
	{	NIS_NO_OBJ,		"NULL Object"	},
#define NIS_DIRECTORY_OBJ	2
	{	NIS_DIRECTORY_OBJ,	"Directory Object"	},
#define NIS_GROUP_OBJ		3
	{	NIS_GROUP_OBJ,		"Group Object"	},
#define NIS_TABLE_OBJ		4
	{	NIS_TABLE_OBJ,		"Table Object"	},
#define NIS_ENTRY_OBJ		5
	{	NIS_ENTRY_OBJ,		"Entry Object"	},
#define NIS_LINK_OBJ		6
	{	NIS_LINK_OBJ,		"Link Object"	},
#define NIS_PRIVATE_OBJ		7
	{	NIS_PRIVATE_OBJ,	"Private Object"	},
	{	0,	NULL	},
};

static const value_string ns_type[] = {
#define NIS_TYPE_UNKNOWN	0
	{	NIS_TYPE_UNKNOWN,	"UNKNOWN"	},
#define NIS_TYPE_NIS		1
	{	NIS_TYPE_NIS,	"NIS Plus Service"	},
#define NIS_TYPE_SUNYP		2
	{	NIS_TYPE_SUNYP,	"Old NIS Service (YP)"	},
#define NIS_TYPE_IVY		3
	{	NIS_TYPE_IVY,	"NIS Plus Plus Service"	},
#define NIS_TYPE_DNS		4
	{	NIS_TYPE_DNS,	"Domain Name Service (DNS)"	},
#define NIS_TYPE_X500		5
	{	NIS_TYPE_X500,	"ISO/CCITT X.500 Service"	},
#define NIS_TYPE_DNANS		6
	{	NIS_TYPE_DNANS,	"Digital DECNet Name Service"	},
#define NIS_TYPE_XCHS		7
	{	NIS_TYPE_XCHS,	"Xerox ClearingHouse Service"	},
#define NIS_TYPE_CDS		8
	{	NIS_TYPE_CDS,	"CDS"	},
	{	0,	NULL	},
};




static int
dissect_nisplus_time(tvbuff_t *tvb, int offset, proto_tree *tree, int hfindex)
{
	nstime_t ts;

	ts.nsecs = 0;
	ts.secs = tvb_get_ntohl(tvb, offset);
	offset += 4;

	proto_tree_add_time(tree, hfindex, tvb, offset, 4, &ts);

	return offset;
}

static int
dissect_group(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	offset = dissect_rpc_string(tvb, tree,
			hf_nisplus_group_name, offset, NULL);

	return offset;
}


static int
dissect_group_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
	proto_item* lock_item = NULL;
	proto_tree* lock_tree = NULL;
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nisplus_group,
			tvb, offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_group);

	offset = dissect_rpc_uint32(tvb, lock_tree,
			hf_nisplus_group_flags, offset);

	offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
			dissect_group, hf_nisplus_grps);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}


static int
dissect_access_rights(tvbuff_t *tvb, int offset, proto_tree *tree)
{
	static int * const flags[] = {
		&hf_nisplus_mask_world_read,
		&hf_nisplus_mask_world_modify,
		&hf_nisplus_mask_world_create,
		&hf_nisplus_mask_world_destroy,
		&hf_nisplus_mask_group_read,
		&hf_nisplus_mask_group_modify,
		&hf_nisplus_mask_group_create,
		&hf_nisplus_mask_group_destroy,
		&hf_nisplus_mask_owner_read,
		&hf_nisplus_mask_owner_modify,
		&hf_nisplus_mask_owner_create,
		&hf_nisplus_mask_owner_destroy,
		&hf_nisplus_mask_nobody_read,
		&hf_nisplus_mask_nobody_modify,
		&hf_nisplus_mask_nobody_create,
		&hf_nisplus_mask_nobody_destroy,
		NULL
	};

	proto_tree_add_bitmask(tree, tvb, offset, hf_nisplus_access_mask, ett_nisplus_access_mask, flags, ENC_BIG_ENDIAN);
	offset += 4;

	return offset;
}

static int
dissect_table(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	proto_item* lock_item;
	proto_tree* lock_tree;
	int old_offset = offset;
	static int * const flags[] = {
		&hf_nisplus_table_col_mask_binary,
		&hf_nisplus_table_col_mask_encrypted,
		&hf_nisplus_table_col_mask_xdr,
		&hf_nisplus_table_col_mask_searchable,
		&hf_nisplus_table_col_mask_casesensitive,
		&hf_nisplus_table_col_mask_modified,
		&hf_nisplus_table_col_mask_asn,
		NULL
	};

	lock_item = proto_tree_add_item(tree, hf_nisplus_table_col,
			tvb, offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_table_col);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_table_col_name, offset, NULL);

	proto_tree_add_bitmask(lock_tree, tvb, offset, hf_nisplus_table_col_mask, ett_nisplus_table_col_mask, flags, ENC_BIG_ENDIAN);
	offset += 4;

	offset = dissect_access_rights(tvb, offset, lock_tree);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}

static int
dissect_table_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
	proto_item* lock_item = NULL;
	proto_tree* lock_tree = NULL;
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nisplus_table,
			tvb, offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_table);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_table_type, offset, NULL);

	offset = dissect_rpc_uint32(tvb, lock_tree,
			hf_nisplus_table_maxcol, offset);

	offset = dissect_rpc_uint32(tvb, lock_tree,
			hf_nisplus_table_sep, offset);

	offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
			dissect_table, hf_nisplus_table_cols);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_table_path, offset, NULL);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}

static int
dissect_entry(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	proto_item* lock_item;
	proto_tree* lock_tree;
	int old_offset = offset;
	static int * const flags[] = {
		&hf_nisplus_entry_mask_binary,
		&hf_nisplus_entry_mask_crypt,
		&hf_nisplus_entry_mask_xdr,
		&hf_nisplus_entry_mask_modified,
		&hf_nisplus_entry_mask_asn,
		NULL
	};

	lock_item = proto_tree_add_item(tree, hf_nisplus_entry_col,
			tvb, offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_entry_col);

	proto_tree_add_bitmask(lock_tree, tvb, offset, hf_nisplus_entry_mask, ett_nisplus_entry_mask, flags, ENC_BIG_ENDIAN);
	offset += 4;

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_entry_val, offset, NULL);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}

static int
dissect_entry_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
	proto_item* lock_item = NULL;
	proto_tree* lock_tree = NULL;
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nisplus_entry,
			tvb, offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_entry);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_entry_type, offset, NULL);

	offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
			dissect_entry, hf_nisplus_entry_cols);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}

static int
dissect_attr(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	proto_item* lock_item = NULL;
	proto_tree* lock_tree = NULL;
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nisplus_attr,
			tvb, offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_attr);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_attr_name, offset, NULL);

	offset = dissect_rpc_data(tvb, lock_tree,
			hf_nisplus_attr_val, offset);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}

static int
dissect_link_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
	proto_item* lock_item = NULL;
	proto_tree* lock_tree = NULL;
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nisplus_link,
			tvb, offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_link);

	offset = dissect_rpc_uint32(tvb, lock_tree,
			hf_nisplus_object_type, offset);

	offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
			dissect_attr, hf_nisplus_attrs_array);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_object_name,	offset, NULL);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}


static int
dissect_endpoint(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	proto_item* lock_item = NULL;
	proto_tree* lock_tree = NULL;
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nisplus_endpoint,
			tvb, offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_endpoint);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_endpoint_uaddr, offset, NULL);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_endpoint_family, offset, NULL);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_endpoint_proto, offset, NULL);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}


static int
dissect_directory_server(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
	proto_item* lock_item = NULL;
	proto_tree* lock_tree = NULL;
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nisplus_server,
			tvb, offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_server);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_server_name, offset, NULL);

	offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
			dissect_endpoint, hf_nisplus_endpoints);

	offset = dissect_rpc_uint32(tvb, lock_tree,
			hf_nisplus_key_type, offset);

	offset = dissect_rpc_data(tvb, lock_tree,
			hf_nisplus_key_data, offset);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}


static int
dissect_directory_mask(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	proto_item* lock_item = NULL;
	proto_tree* lock_tree = NULL;
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nisplus_directory_mask,
			tvb, offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_directory_mask);

	offset = dissect_access_rights(tvb, offset, lock_tree);

	offset = dissect_rpc_uint32(tvb, lock_tree,
			hf_nisplus_object_type, offset);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}

static int
dissect_directory_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
	proto_item* lock_item = NULL;
	proto_tree* lock_tree = NULL;
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nisplus_directory,
			tvb, offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_directory);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_directory_name, offset, NULL);

	offset = dissect_rpc_uint32(tvb, lock_tree,
			hf_nisplus_directory_type, offset);

	offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
			dissect_directory_server, hf_nisplus_servers);

	offset = dissect_rpc_uint32(tvb, lock_tree,
			hf_nisplus_directory_ttl, offset);

	offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
			dissect_directory_mask, hf_nisplus_directory_mask_list);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}

static int
dissect_nisplus_oid(tvbuff_t *tvb, int offset, proto_tree *tree)
{
	proto_item* lock_item = NULL;
	proto_tree* lock_tree = NULL;
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nisplus_oid, tvb,
			offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_oid);

	offset = dissect_nisplus_time(tvb, offset, lock_tree,
			hf_nisplus_object_ctime);

	offset = dissect_nisplus_time(tvb, offset, lock_tree,
			hf_nisplus_object_mtime);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}

static int
dissect_nisplus_object(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
	proto_item* lock_item = NULL;
	proto_tree* lock_tree = NULL;
	int32_t	type;
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nisplus_object, tvb,
			offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_object);

	offset = dissect_nisplus_oid(tvb, offset, lock_tree);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_object_name,	offset, NULL);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_object_owner, offset, NULL);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_object_group, offset, NULL);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_object_domain, offset, NULL);

	offset = dissect_access_rights(tvb, offset, lock_tree);

	offset = dissect_rpc_uint32(tvb, lock_tree,
			hf_nisplus_object_ttl, offset);

	type = tvb_get_ntohl(tvb, offset);
	offset = dissect_rpc_uint32(tvb, lock_tree,
			hf_nisplus_object_type, offset);
	switch (type) {
	case	NIS_DIRECTORY_OBJ:
		offset = dissect_directory_obj(tvb, offset, pinfo, lock_tree);
		break;
	case	NIS_GROUP_OBJ:
		offset = dissect_group_obj(tvb, offset, pinfo, lock_tree);
		break;
	case	NIS_TABLE_OBJ:
		offset = dissect_table_obj(tvb, offset, pinfo, lock_tree);
		break;
	case	NIS_ENTRY_OBJ:
		offset = dissect_entry_obj(tvb, offset, pinfo, lock_tree);
		break;
	case	NIS_LINK_OBJ:
		offset = dissect_link_obj(tvb, offset, pinfo, lock_tree);
		break;
	case	NIS_PRIVATE_OBJ:
		offset = dissect_rpc_data(tvb, lock_tree,
				hf_nisplus_object_private, offset);
		break;
	case	NIS_NO_OBJ:
		break;
	case	NIS_BOGUS_OBJ:
		break;
	default:
		break;
	};

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}
/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
	end of nis object, that's right, all this was the definition of
	ONE SINGLE struct.
*/



static int
dissect_ns_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
	int offset = 0;
	offset = dissect_rpc_string(tvb, tree,
			hf_nisplus_object_name, offset, NULL);

	offset = dissect_rpc_array(tvb, pinfo, tree, offset,
			dissect_nisplus_object, hf_nisplus_object);

	return offset;
}

static int
dissect_ib_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
	int offset = 0;

	offset = dissect_rpc_string(tvb, tree,
			hf_nisplus_object_name, offset, NULL);

	offset = dissect_rpc_array(tvb, pinfo, tree, offset,
			dissect_attr, hf_nisplus_attrs_array);

	offset = dissect_rpc_uint32(tvb, tree,
			hf_nisplus_ib_flags, offset);

	offset = dissect_rpc_array(tvb, pinfo, tree, offset,
			dissect_nisplus_object, hf_nisplus_object);

	offset = dissect_rpc_array(tvb, pinfo, tree, offset,
			dissect_directory_server, hf_nisplus_cbservers);

	offset = dissect_rpc_uint32(tvb, tree,
			hf_nisplus_ib_bufsize, offset);

	offset = dissect_rpc_data(tvb, tree,
			hf_nisplus_cookie, offset);

	return offset;
}

static int
dissect_fd_args(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	int offset = 0;

	offset = dissect_rpc_string(tvb, tree,
			hf_nisplus_fd_dirname, offset, NULL);

	offset = dissect_rpc_string(tvb, tree,
			hf_nisplus_fd_requester, offset, NULL);

	return offset;
}

static int
dissect_nisplus_tag(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	proto_item* lock_item = NULL;
	proto_tree* lock_tree = NULL;
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nisplus_tag, tvb,
			offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_tag);

	offset = dissect_rpc_uint32(tvb, lock_tree,
			hf_nisplus_tag_type, offset);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_tag_val, offset, NULL);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}

static int
dissect_nisplus_taglist(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
	return dissect_rpc_array(tvb, pinfo, tree, 0,
			dissect_nisplus_tag, hf_nisplus_taglist);
}

static int
dissect_dump_args(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
	int offset = 0;

	offset = dissect_rpc_string(tvb, tree,
			hf_nisplus_dump_dir, offset, NULL);

	offset = dissect_nisplus_time(tvb, offset, tree,
			hf_nisplus_dump_time);

	offset = dissect_rpc_array(tvb, pinfo, tree, offset,
			dissect_directory_server, hf_nisplus_cbservers);

	return offset;
}

static int
dissect_netobj(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	return dissect_rpc_data(tvb, tree, hf_nisplus_dummy, 0);
}

static int
dissect_nisname(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	return dissect_rpc_string(tvb, tree,
			hf_nisplus_object_name, 0, NULL);
}

static int
dissect_ping_args(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	int offset = 0;

	offset = dissect_rpc_string(tvb, tree,
			hf_nisplus_ping_dir, offset, NULL);

	offset = dissect_nisplus_time(tvb, offset, tree,
			hf_nisplus_ping_time);

	return offset;
}


static const value_string nis_error[] = {
#define NIS_SUCCESS		0
	{	NIS_SUCCESS,		"A-ok, let's rock n roll"	},
#define NIS_S_SUCCESS		1
	{	NIS_S_SUCCESS,		"Name found (maybe)"	},
#define NIS_NOTFOUND		2
	{	NIS_NOTFOUND,		"Name definitely not found"	},
#define NIS_S_NOTFOUND		3
	{	NIS_S_NOTFOUND,		"Name maybe not found"	},
#define NIS_CACHEEXPIRED	4
	{	NIS_CACHEEXPIRED,	"Name exists but cache out of date"	},
#define NIS_NAMEUNREACHABLE	5
	{	NIS_NAMEUNREACHABLE,	"Can't get there from here"	},
#define NIS_UNKNOWNOBJ		6
	{	NIS_UNKNOWNOBJ,		"Object type is bogus"	},
#define NIS_TRYAGAIN		7
	{	NIS_TRYAGAIN,		"I'm busy, call back"	},
#define NIS_SYSTEMERROR		8
	{	NIS_SYSTEMERROR,	"Generic system error"	},
#define NIS_CHAINBROKEN		9
	{	NIS_CHAINBROKEN,	"First/Next warning"	},
#define NIS_PERMISSION		10
	{	NIS_PERMISSION,		"Not enough permission to access"	},
#define NIS_NOTOWNER		11
	{	NIS_NOTOWNER,		"You don't own it, sorry"	},
#define NIS_NOT_ME		12
	{	NIS_NOT_ME,		"I don't serve this name"	},
#define NIS_NOMEMORY		13
	{	NIS_NOMEMORY,		"Outta VM! Help!"	},
#define NIS_NAMEEXISTS		14
	{	NIS_NAMEEXISTS,		"Can't create over another name"	},
#define NIS_NOTMASTER		15
	{	NIS_NOTMASTER,		"I'm just a secondary, don't ask me"	},
#define NIS_INVALIDOBJ		16
	{	NIS_INVALIDOBJ,		"Object is broken somehow"	},
#define NIS_BADNAME		17
	{	NIS_BADNAME,		"Unparsable name"	},
#define NIS_NOCALLBACK		18
	{	NIS_NOCALLBACK,		"Couldn't talk to call back proc"	},
#define NIS_CBRESULTS		19
	{	NIS_CBRESULTS,		"Results being called back to you"	},
#define NIS_NOSUCHNAME		20
	{	NIS_NOSUCHNAME,		"Name unknown"	},
#define NIS_NOTUNIQUE		21
	{	NIS_NOTUNIQUE,		"Value is not unique (entry)"	},
#define NIS_IBMODERROR		22
	{	NIS_IBMODERROR,		"Inf. Base. Modify error."	},
#define NIS_NOSUCHTABLE		23
	{	NIS_NOSUCHTABLE,	"Name for table was wrong"	},
#define NIS_TYPEMISMATCH	24
	{	NIS_TYPEMISMATCH,	"Entry and table type mismatch"	},
#define NIS_LINKNAMEERROR	25
	{	NIS_LINKNAMEERROR,	"Link points to bogus name"	},
#define NIS_PARTIAL		26
	{	NIS_PARTIAL,		"Partial success, found table"	},
#define NIS_TOOMANYATTRS	27
	{	NIS_TOOMANYATTRS,	"Too many attributes"	},
#define NIS_RPCERROR		28
	{	NIS_RPCERROR,		"RPC error encountered"	},
#define NIS_BADATTRIBUTE	29
	{	NIS_BADATTRIBUTE,	"Bad or invalid attribute"	},
#define NIS_NOTSEARCHABLE	30
	{	NIS_NOTSEARCHABLE,	"Non-searchable object searched"	},
#define NIS_CBERROR		31
	{	NIS_CBERROR,		"Error during callback (svc crash)"	},
#define NIS_FOREIGNNS		32
	{	NIS_FOREIGNNS,		"Foreign Namespace"	},
#define NIS_BADOBJECT		33
	{	NIS_BADOBJECT,		"Malformed object structure"	},
#define NIS_NOTSAMEOBJ		34
	{	NIS_NOTSAMEOBJ,		"Object swapped during deletion"	},
#define NIS_MODFAIL		35
	{	NIS_MODFAIL,		"Failure during a Modify."	},
#define NIS_BADREQUEST		36
	{	NIS_BADREQUEST,		"Illegal query for table"	},
#define NIS_NOTEMPTY		37
	{	NIS_NOTEMPTY,		"Attempt to remove a non-empty tbl"	},
#define NIS_COLDSTART_ERR	38
	{	NIS_COLDSTART_ERR,	"Error accessing the cold start file"	},
#define NIS_RESYNC		39
	{	NIS_RESYNC,		"Transaction log too far out of date"	},
#define NIS_FAIL		40
	{	NIS_FAIL,		"NIS operation failed."	},
#define NIS_UNAVAIL		41
	{	NIS_UNAVAIL,		"NIS+ service is unavailable (client)"	},
#define NIS_RES2BIG		42
	{	NIS_RES2BIG,		"NIS+ result too big for datagram"	},
#define NIS_SRVAUTH		43
	{	NIS_SRVAUTH,		"NIS+ server wasn't authenticated."	},
#define NIS_CLNTAUTH		44
	{	NIS_CLNTAUTH,		"NIS+ Client wasn't authenticated."	},
#define NIS_NOFILESPACE		45
	{	NIS_NOFILESPACE,	"NIS+ server ran out of disk space"	},
#define NIS_NOPROC		46
	{	NIS_NOPROC,		"NIS+ server couldn't create new proc"	},
#define NIS_DUMPLATER		47
	{	NIS_DUMPLATER,		"NIS+ server already has dump child"	},
	{	0,	NULL	},
};

static int
dissect_nisplus_result(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
	int offset = 0;

	offset = dissect_rpc_uint32(tvb, tree,
			hf_nisplus_error, offset);

	offset = dissect_rpc_array(tvb, pinfo, tree, offset,
			dissect_nisplus_object, hf_nisplus_object);

	offset = dissect_rpc_data(tvb, tree,
			hf_nisplus_cookie, offset);

	offset = dissect_rpc_uint32(tvb, tree,
			hf_nisplus_zticks, offset);

	offset = dissect_rpc_uint32(tvb, tree,
			hf_nisplus_dticks, offset);

	offset = dissect_rpc_uint32(tvb, tree,
			hf_nisplus_aticks, offset);

	offset = dissect_rpc_uint32(tvb, tree,
			hf_nisplus_cticks, offset);

	return offset;
}

static int
dissect_fd_result(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	int offset = 0;

	offset = dissect_rpc_uint32(tvb, tree,
			hf_nisplus_error, offset);

	offset = dissect_rpc_string(tvb, tree,
			hf_nisplus_fd_dirname, offset, NULL);

	offset = dissect_rpc_data(tvb, tree,
			hf_nisplus_dir_data, offset);

	offset = dissect_rpc_data(tvb, tree,
			hf_nisplus_signature, offset);

	return offset;
}

static const value_string entry_type[] = {
#define LOG_NOP		0
	{	LOG_NOP,		"NOP"	},
#define LOG_ADD_NAME		1
	{	LOG_ADD_NAME,		"Name Was Added"	},
#define LOG_REM_NAME		2
	{	LOG_REM_NAME,		"Name Was Removed"	},
#define LOG_MOD_NAME_OLD	3
	{	LOG_MOD_NAME_OLD,	"Name Was Modified"	},
#define LOG_MOD_NAME_NEW	4
	{	LOG_MOD_NAME_NEW,	"Name Was Modified"	},
#define LOG_ADD_IBASE		5
	{	LOG_ADD_IBASE,		"Entry Added To Information Base"	},
#define LOG_REM_IBASE		6
	{	LOG_REM_IBASE,		"Entry Removed From Information Base"	},
#define LOG_MOD_IBASE		7
	{	LOG_MOD_IBASE,		"Entry Modified In Information Base"	},
#define LOG_UPD_STAMP		8
	{	LOG_UPD_STAMP,		"Update Timestamp"	},
	{	0,	NULL	},
};
static int
dissect_log_entry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
	proto_item* lock_item = NULL;
	proto_tree* lock_tree = NULL;
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nisplus_log_entry,
			tvb, offset, -1, ENC_NA);

	lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_log_entry);

	offset = dissect_nisplus_time(tvb, offset, lock_tree,
			hf_nisplus_log_time);

	offset = dissect_rpc_uint32(tvb, lock_tree,
			hf_nisplus_log_type, offset);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_log_principal, offset, NULL);

	offset = dissect_rpc_string(tvb, lock_tree,
			hf_nisplus_directory_name, offset, NULL);

	offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
			dissect_attr, hf_nisplus_attrs_array);

	offset = dissect_nisplus_object(tvb, offset, pinfo, lock_tree, data);

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}

static int
dissect_log_result(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
	int offset = 0;

	offset = dissect_rpc_uint32(tvb, tree,
			hf_nisplus_error, offset);

	offset = dissect_rpc_data(tvb, tree,
			hf_nisplus_cookie, offset);

	offset = dissect_rpc_array(tvb, pinfo, tree, offset,
			dissect_log_entry, hf_nisplus_log_entries);

	return offset;
}

static int
dissect_callback_result(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	return dissect_rpc_bool(tvb, tree, hf_nisplus_callback_status, 0);
}

static int
dissect_change_time(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	return dissect_nisplus_time(tvb, 0, tree, hf_nisplus_log_time);
}

static int
dissect_cp_result(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	int offset = 0;

	offset = dissect_rpc_uint32(tvb, tree,
			hf_nisplus_cp_status, offset);

	offset = dissect_rpc_uint32(tvb, tree,
			hf_nisplus_cp_zticks, offset);

	offset = dissect_rpc_uint32(tvb, tree,
			hf_nisplus_cp_dticks, offset);

	return offset;
}

static int
dissect_nisplus_error(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	return dissect_rpc_uint32(tvb, tree, hf_nisplus_error, 0);
}

/* proc number, "proc name", dissect_request, dissect_reply */
static const vsff nisplus3_proc[] = {
	{ NISPROC_NULL,			"NULL",
		dissect_rpc_void,	dissect_rpc_void },
	{ NISPROC_LOOKUP,		"LOOKUP",
		dissect_ns_request,	dissect_nisplus_result },
	{ NISPROC_ADD,			"ADD",
		dissect_ns_request,	dissect_nisplus_result },
	{ NISPROC_MODIFY,		"MODIFY",
		dissect_ns_request,	dissect_nisplus_result },
	{ NISPROC_REMOVE,		"REMOVE",
		dissect_ns_request,	dissect_nisplus_result },
	{ NISPROC_IBLIST,		"IBLIST",
		dissect_ib_request,	dissect_nisplus_result },
	{ NISPROC_IBADD,		"IBADD",
		dissect_ib_request,	dissect_nisplus_result },
	{ NISPROC_IBMODIFY,		"IBMODIFY",
		dissect_ib_request,	dissect_nisplus_result },
	{ NISPROC_IBREMOVE,		"IBREMOVE",
		dissect_ib_request,	dissect_nisplus_result },
	{ NISPROC_IBFIRST,		"IBFIRST",
		dissect_ib_request,	dissect_nisplus_result },
	{ NISPROC_IBNEXT,		"IBNEXT",
		dissect_ib_request,	dissect_nisplus_result },
	{ NISPROC_FINDDIRECTORY,	"FINDDIRECTORY",
		dissect_fd_args,	dissect_fd_result },
	{ NISPROC_STATUS,		"STATUS",
		dissect_nisplus_taglist, dissect_nisplus_taglist },
	{ NISPROC_DUMPLOG,		"DUMPLOG",
		dissect_dump_args,	dissect_log_result },
	{ NISPROC_DUMP,			"DUMP",
		dissect_dump_args,	dissect_log_result },
	{ NISPROC_CALLBACK,		"CALLBACK",
		dissect_netobj,		dissect_callback_result },
	{ NISPROC_CPTIME,		"CPTIME",
		dissect_nisname,	dissect_change_time },
	{ NISPROC_CHECKPOINT,		"CHECKPOINT",
		dissect_nisname,	dissect_cp_result },
	{ NISPROC_PING,			"PING",
		dissect_ping_args,	dissect_rpc_void },
	{ NISPROC_SERVSTATE,		"SERVSTATE",
		dissect_nisplus_taglist, dissect_nisplus_taglist },
	{ NISPROC_MKDIR,		"MKDIR",
		dissect_nisname,	dissect_nisplus_error },
	{ NISPROC_RMDIR,		"RMDIR",
		dissect_nisname,	dissect_nisplus_error },
	{ NISPROC_UPDKEYS,		"UPDKEYS",
		dissect_nisname,	dissect_nisplus_error },
	{ 0,	NULL,		NULL,				NULL }
};
static const value_string nisplus3_proc_vals[] = {
	{ NISPROC_NULL,			"NULL" },
	{ NISPROC_LOOKUP,		"LOOKUP" },
	{ NISPROC_ADD,			"ADD" },
	{ NISPROC_MODIFY,		"MODIFY" },
	{ NISPROC_REMOVE,		"REMOVE" },
	{ NISPROC_IBLIST,		"IBLIST" },
	{ NISPROC_IBADD,		"IBADD" },
	{ NISPROC_IBMODIFY,		"IBMODIFY" },
	{ NISPROC_IBREMOVE,		"IBREMOVE" },
	{ NISPROC_IBFIRST,		"IBFIRST" },
	{ NISPROC_IBNEXT,		"IBNEXT" },
	{ NISPROC_FINDDIRECTORY,	"FINDDIRECTORY" },
	{ NISPROC_STATUS,		"STATUS" },
	{ NISPROC_DUMPLOG,		"DUMPLOG" },
	{ NISPROC_DUMP,			"DUMP" },
	{ NISPROC_CALLBACK,		"CALLBACK" },
	{ NISPROC_CPTIME,		"CPTIME" },
	{ NISPROC_CHECKPOINT,		"CHECKPOINT" },
	{ NISPROC_PING,			"PING" },
	{ NISPROC_SERVSTATE,		"SERVSTATE" },
	{ NISPROC_MKDIR,		"MKDIR" },
	{ NISPROC_RMDIR,		"RMDIR" },
	{ NISPROC_UPDKEYS,		"UPDKEYS" },
	{ 0,	NULL }
};
static const rpc_prog_vers_info nisplus_vers_info[] = {
	{ 3, nisplus3_proc, &hf_nisplus_procedure_v3 },
};



void
proto_register_nis(void)
{
	static const true_false_string tfs_col_binary = {
		"column is binary",
		"column is NOT binary"
	};
	static const true_false_string tfs_col_encrypted = {
		"column is encrypted",
		"column is NOT encrypted"
	};
	static const true_false_string tfs_col_xdr = {
		"column is xdr encoded",
		"column is NOT xdr encoded"
	};
	static const true_false_string tfs_col_searchable = {
		"column is searchable",
		"column is NOT searchable"
	};
	static const true_false_string tfs_col_casesensitive = {
		"column is case sensitive",
		"column is NOT case sensitive"
	};
	static const true_false_string tfs_col_modified = {
		"column is modified",
		"column is NOT modified"
	};
	static const true_false_string tfs_col_asn = {
		"column is asn.1 encoded",
		"column is NOT asn.1 encoded"
	};

	static const true_false_string tfs_entry_binary = {
		"entry is binary",
		"entry is NOT binary"
	};

	static const true_false_string tfs_entry_crypt = {
		"entry is encrypted",
		"entry is NOT encrypted"
	};

	static const true_false_string tfs_entry_xdr = {
		"entry is xdr encoded",
		"entry is NOT xdr encoded"
	};

	static const true_false_string tfs_entry_modified = {
		"entry is modified",
		"entry is NOT modified"
	};

	static const true_false_string tfs_entry_asn = {
		"entry is asn.1 encoded",
		"entry is NOT asn.1 encoded"
	};

	static const true_false_string tfs_world_read = {
		"world can read",
		"world can NOT read"
	};

	static const true_false_string tfs_world_modify = {
		"world can modify",
		"world can NOT modify"
	};

	static const true_false_string tfs_world_create = {
		"world can create",
		"world can NOT create"
	};

	static const true_false_string tfs_world_destroy = {
		"world can destroy",
		"world can NOT destroy"
	};

	static const true_false_string tfs_group_read = {
		"group can read",
		"group can NOT read"
	};

	static const true_false_string tfs_group_modify = {
		"group can modify",
		"group can NOT modify"
	};

	static const true_false_string tfs_group_create = {
		"group can create",
		"group can NOT create"
	};

	static const true_false_string tfs_group_destroy = {
		"group can destroy",
		"group can NOT destroy"
	};

	static const true_false_string tfs_owner_read = {
		"owner can read",
		"owner can NOT read"
	};

	static const true_false_string tfs_owner_modify = {
		"owner can modify",
		"owner can NOT modify"
	};

	static const true_false_string tfs_owner_create = {
		"owner can create",
		"owner can NOT create"
	};

	static const true_false_string tfs_owner_destroy = {
		"owner can destroy",
		"owner can NOT destroy"
	};

	static const true_false_string tfs_nobody_read = {
		"nobody can read",
		"nobody can NOT read"
	};

	static const true_false_string tfs_nobody_modify = {
		"nobody can modify",
		"nobody can NOT modify"
	};

	static const true_false_string tfs_nobody_create = {
		"nobody can create",
		"nobody can NOT create"
	};

	static const true_false_string tfs_nobody_destroy = {
		"nobody can destroy",
		"nobody can NOT destroy"
	};

	static const true_false_string tfs_callback_status = {
		"callback is running",
		"callback is not running"
	};




	static hf_register_info hf[] = {
		{ &hf_nisplus_procedure_v3, {
			"V3 Procedure", "nisplus.procedure_v3", FT_UINT32, BASE_DEC,
			VALS(nisplus3_proc_vals), 0, NULL, HFILL }},
		{ &hf_nisplus_object, {
			"NIS Object", "nisplus.object", FT_NONE, BASE_NONE,
			NULL, 0, NULL, HFILL }},

		{ &hf_nisplus_oid, {
			"Object Identity Verifier", "nisplus.object.oid", FT_NONE, BASE_NONE,
			NULL, 0, "NIS Object Identity Verifier", HFILL }},

		{ &hf_nisplus_object_name, {
			"name", "nisplus.object.name", FT_STRING, BASE_NONE,
			NULL, 0, "NIS Name For This Object", HFILL }},

		{ &hf_nisplus_object_owner, {
			"owner", "nisplus.object.owner", FT_STRING, BASE_NONE,
			NULL, 0, "NIS Name Of Object Owner", HFILL }},

		{ &hf_nisplus_object_group, {
			"group", "nisplus.object.group", FT_STRING, BASE_NONE,
			NULL, 0, "NIS Name Of Access Group", HFILL }},

		{ &hf_nisplus_object_domain, {
			"domain", "nisplus.object.domain", FT_STRING, BASE_NONE,
			NULL, 0, "NIS Administrator For This Object", HFILL }},

		{ &hf_nisplus_object_ttl, {
			"ttl", "nisplus.object.ttl", FT_UINT32, BASE_DEC,
			NULL, 0, "NIS Time To Live For This Object", HFILL }},

		{ &hf_nisplus_object_private, {
			"private", "nisplus.object.private", FT_BYTES, BASE_NONE,
			NULL, 0, "NIS Private Object", HFILL }},

		{ &hf_nisplus_directory, {
			"directory", "nisplus.directory", FT_NONE, BASE_NONE,
			NULL, 0, "NIS Directory Object", HFILL }},

		{ &hf_nisplus_directory_name, {
			"directory name", "nisplus.directory.name", FT_STRING, BASE_NONE,
			NULL, 0, "Name Of Directory Being Served", HFILL }},

		{ &hf_nisplus_directory_type, {
			"type", "nisplus.directory.type", FT_UINT32, BASE_DEC,
			VALS(ns_type), 0, "NIS Type Of Name Service", HFILL }},

		{ &hf_nisplus_directory_ttl, {
			"ttl", "nisplus.directory.ttl", FT_UINT32, BASE_DEC,
			NULL, 0, "Time To Live", HFILL }},

		{ &hf_nisplus_directory_mask, {
			"mask", "nisplus.directory.mask", FT_NONE, BASE_NONE,
			NULL, 0, "NIS Directory Create/Destroy Rights", HFILL }},

		{ &hf_nisplus_directory_mask_list, {
			"mask list", "nisplus.directory.mask_list", FT_NONE, BASE_NONE,
			NULL, 0, "List Of Directory Create/Destroy Rights", HFILL }},

		{ &hf_nisplus_mask_world_read, {
			"WORLD READ", "nisplus.directory.mask.world_read",
			FT_BOOLEAN, 32, TFS(&tfs_world_read),
			NIS_MASK_WORLD_READ, "World Read Flag", HFILL }},

		{ &hf_nisplus_mask_world_modify, {
			"WORLD MODIFY", "nisplus.directory.mask.world_modify",
			FT_BOOLEAN, 32, TFS(&tfs_world_modify),
			NIS_MASK_WORLD_MODIFY, "World Modify Flag", HFILL }},

		{ &hf_nisplus_mask_world_create, {
			"WORLD CREATE", "nisplus.directory.mask.world_create",
			FT_BOOLEAN, 32, TFS(&tfs_world_create),
			NIS_MASK_WORLD_CREATE, "World Create Flag", HFILL }},

		{ &hf_nisplus_mask_world_destroy, {
			"WORLD DESTROY", "nisplus.directory.mask.world_destroy",
			FT_BOOLEAN, 32, TFS(&tfs_world_destroy),
			NIS_MASK_WORLD_DESTROY, "World Destroy Flag", HFILL }},

		{ &hf_nisplus_mask_group_read, {
			"GROUP READ", "nisplus.directory.mask.group_read",
			FT_BOOLEAN, 32, TFS(&tfs_group_read),
			NIS_MASK_GROUP_READ, "Group Read Flag", HFILL }},

		{ &hf_nisplus_mask_group_modify, {
			"GROUP MODIFY", "nisplus.directory.mask.group_modify",
			FT_BOOLEAN, 32, TFS(&tfs_group_modify),
			NIS_MASK_GROUP_MODIFY, "Group Modify Flag", HFILL }},

		{ &hf_nisplus_mask_group_create, {
			"GROUP CREATE", "nisplus.directory.mask.group_create",
			FT_BOOLEAN, 32, TFS(&tfs_group_create),
			NIS_MASK_GROUP_CREATE, "Group Create Flag", HFILL }},

		{ &hf_nisplus_mask_group_destroy, {
			"GROUP DESTROY", "nisplus.directory.mask.group_destroy",
			FT_BOOLEAN, 32, TFS(&tfs_group_destroy),
			NIS_MASK_GROUP_DESTROY, "Group Destroy Flag", HFILL }},

		{ &hf_nisplus_mask_owner_read, {
			"OWNER READ", "nisplus.directory.mask.owner_read",
			FT_BOOLEAN, 32, TFS(&tfs_owner_read),
			NIS_MASK_OWNER_READ, "Owner Read Flag", HFILL }},

		{ &hf_nisplus_mask_owner_modify, {
			"OWNER MODIFY", "nisplus.directory.mask.owner_modify",
			FT_BOOLEAN, 32, TFS(&tfs_owner_modify),
			NIS_MASK_OWNER_MODIFY, "Owner Modify Flag", HFILL }},

		{ &hf_nisplus_mask_owner_create, {
			"OWNER CREATE", "nisplus.directory.mask.owner_create",
			FT_BOOLEAN, 32, TFS(&tfs_owner_create),
			NIS_MASK_OWNER_CREATE, "Owner Create Flag", HFILL }},

		{ &hf_nisplus_mask_owner_destroy, {
			"OWNER DESTROY", "nisplus.directory.mask.owner_destroy",
			FT_BOOLEAN, 32, TFS(&tfs_owner_destroy),
			NIS_MASK_OWNER_DESTROY, "Owner Destroy Flag", HFILL }},

		{ &hf_nisplus_mask_nobody_read, {
			"NOBODY READ", "nisplus.directory.mask.nobody_read",
			FT_BOOLEAN, 32, TFS(&tfs_nobody_read),
			NIS_MASK_NOBODY_READ, "Nobody Read Flag", HFILL }},

		{ &hf_nisplus_mask_nobody_modify, {
			"NOBODY MODIFY", "nisplus.directory.mask.nobody_modify",
			FT_BOOLEAN, 32, TFS(&tfs_nobody_modify),
			NIS_MASK_NOBODY_MODIFY, "Nobody Modify Flag", HFILL }},

		{ &hf_nisplus_mask_nobody_create, {
			"NOBODY CREATE", "nisplus.directory.mask.nobody_create",
			FT_BOOLEAN, 32, TFS(&tfs_nobody_create),
			NIS_MASK_NOBODY_CREATE, "Nobody Create Flag", HFILL }},

		{ &hf_nisplus_mask_nobody_destroy, {
			"NOBODY DESTROY", "nisplus.directory.mask.nobody_destroy",
			FT_BOOLEAN, 32, TFS(&tfs_nobody_destroy),
			NIS_MASK_NOBODY_DESTROY, "Nobody Destroy Flag", HFILL }},

		{ &hf_nisplus_access_mask, {
			"access mask", "nisplus.access.mask", FT_UINT32, BASE_HEX,
			NULL, 0, "NIS Access Mask", HFILL }},

		{ &hf_nisplus_object_type, {
			"type", "nisplus.object.type", FT_UINT32, BASE_DEC,
			VALS(obj_type), 0, "NIS Type Of Object", HFILL }},

		{ &hf_nisplus_servers, {
			"nis servers", "nisplus.servers", FT_NONE, BASE_NONE,
			NULL, 0, "NIS Servers For This Directory", HFILL }},

		{ &hf_nisplus_cbservers, {
			"nis servers", "nisplus.servers", FT_NONE, BASE_NONE,
			NULL, 0, "Optional Callback Server", HFILL }},

		{ &hf_nisplus_server, {
			"server", "nisplus.server", FT_NONE, BASE_NONE,
			NULL, 0, "NIS Server For This Directory", HFILL }},

		{ &hf_nisplus_server_name, {
			"name", "nisplus.server.name", FT_STRING, BASE_NONE,
			NULL, 0, "Name Of NIS Server", HFILL }},

		{ &hf_nisplus_key_type, {
			"type", "nisplus.key.type", FT_UINT32, BASE_DEC,
			VALS(key_type), 0, "Type Of Key", HFILL }},

		{ &hf_nisplus_key_data, {
			"key data", "nisplus.key.data", FT_BYTES, BASE_NONE,
			NULL, 0, "Encryption Key", HFILL }},

		{ &hf_nisplus_endpoints, {
			"nis endpoints", "nisplus.endpoints", FT_NONE, BASE_NONE,
			NULL, 0, "Endpoints For This NIS Server", HFILL }},

		{ &hf_nisplus_endpoint, {
			"endpoint", "nisplus.endpoint", FT_NONE, BASE_NONE,
			NULL, 0, "Endpoint For This NIS Server", HFILL }},

		{ &hf_nisplus_endpoint_uaddr, {
			"addr", "nisplus.endpoint.uaddr", FT_STRING, BASE_NONE,
			NULL, 0, "Address", HFILL }},

		{ &hf_nisplus_endpoint_family, {
			"family", "nisplus.endpoint.family", FT_STRING, BASE_NONE,
			NULL, 0, "Transport Family", HFILL }},

		{ &hf_nisplus_endpoint_proto, {
			"proto", "nisplus.endpoint.proto", FT_STRING, BASE_NONE,
			NULL, 0, "Protocol", HFILL }},

		{ &hf_nisplus_link, {
			"link", "nisplus.link", FT_NONE, BASE_NONE,
			NULL, 0, "NIS Link Object", HFILL }},

		{ &hf_nisplus_attrs_array, {
			"Attributes", "nisplus.attributes", FT_NONE, BASE_NONE,
			NULL, 0, "List Of Attributes", HFILL }},

		{ &hf_nisplus_attr, {
			"Attribute", "nisplus.attr", FT_NONE, BASE_NONE,
			NULL, 0, NULL, HFILL }},

		{ &hf_nisplus_attr_name, {
			"name", "nisplus.attr.name", FT_STRING, BASE_NONE,
			NULL, 0, "Attribute Name", HFILL }},

		{ &hf_nisplus_attr_val, {
			"val", "nisplus.attr.val", FT_BYTES, BASE_NONE,
			NULL, 0, "Attribute Value", HFILL }},

		{ &hf_nisplus_entry, {
			"entry", "nisplus.entry", FT_NONE, BASE_NONE,
			NULL, 0, "Entry Object", HFILL }},

		{ &hf_nisplus_entry_type, {
			"type", "nisplus.entry.type", FT_STRING, BASE_NONE,
			NULL, 0, "Entry Type", HFILL }},

		{ &hf_nisplus_entry_cols, {
			"columns", "nisplus.entry.cols", FT_NONE, BASE_NONE,
			NULL, 0, "Entry Columns", HFILL }},

		{ &hf_nisplus_entry_col, {
			"column", "nisplus.entry.col", FT_NONE, BASE_NONE,
			NULL, 0, "Entry Column", HFILL }},

#if 0
		{ &hf_nisplus_entry_flags, {
			"flags", "nisplus.entry.flags", FT_UINT32, BASE_HEX,
			NULL, 0, "Entry Col Flags", HFILL }},
#endif

		{ &hf_nisplus_entry_val, {
			"val", "nisplus.entry.val", FT_STRING, BASE_NONE,
			NULL, 0, "Entry Value", HFILL }},

		{ &hf_nisplus_entry_mask, {
			"mask", "nisplus.entry.mask", FT_UINT32, BASE_HEX,
			NULL, 0, "Entry Col Mask", HFILL }},

		{ &hf_nisplus_entry_mask_binary, {
			"BINARY", "nisplus.entry.mask.binary",
			FT_BOOLEAN, 32, TFS(&tfs_entry_binary),
			NIS_MASK_ENTRY_BINARY, "Is This Entry BINARY Flag", HFILL }},

		{ &hf_nisplus_entry_mask_crypt, {
			"ENCRYPTED", "nisplus.entry.mask.encrypted",
			FT_BOOLEAN, 32, TFS(&tfs_entry_crypt),
			NIS_MASK_ENTRY_CRYPT, "Is This Entry ENCRYPTED Flag", HFILL }},

		{ &hf_nisplus_entry_mask_xdr, {
			"XDR", "nisplus.entry.mask.xdr",
			FT_BOOLEAN, 32, TFS(&tfs_entry_xdr),
			NIS_MASK_ENTRY_XDR, "Is This Entry XDR Encoded Flag", HFILL }},

		{ &hf_nisplus_entry_mask_modified, {
			"MODIFIED", "nisplus.entry.mask.modified",
			FT_BOOLEAN, 32, TFS(&tfs_entry_modified),
			NIS_MASK_ENTRY_MODIFIED, "Is This Entry MODIFIED Flag", HFILL }},

		{ &hf_nisplus_entry_mask_asn, {
			"ASN.1", "nisplus.entry.mask.asn",
			FT_BOOLEAN, 32, TFS(&tfs_entry_asn),
			NIS_MASK_ENTRY_ASN, "Is This Entry ASN.1 Encoded Flag", HFILL }},

		{ &hf_nisplus_table, {
			"table", "nisplus.table", FT_NONE, BASE_NONE,
			NULL, 0, "Table Object", HFILL }},

		{ &hf_nisplus_table_type, {
			"type", "nisplus.table.type", FT_STRING, BASE_NONE,
			NULL, 0, "Table Type", HFILL }},

		{ &hf_nisplus_table_maxcol, {
			"max columns", "nisplus.table.maxcol", FT_UINT16, BASE_DEC,
			NULL, 0, "Maximum Number Of Columns For Table", HFILL }},

		{ &hf_nisplus_table_sep, {
			"separator", "nisplus.table.separator", FT_UINT8, BASE_HEX,
			NULL, 0, "Separator Character", HFILL }},

		{ &hf_nisplus_table_cols, {
			"columns", "nisplus.table.cols", FT_NONE, BASE_NONE,
			NULL, 0, "Table Columns", HFILL }},

		{ &hf_nisplus_table_col, {
			"column", "nisplus.table.col", FT_NONE, BASE_NONE,
			NULL, 0, "Table Column", HFILL }},

		{ &hf_nisplus_table_path, {
			"path", "nisplus.table.path", FT_STRING, BASE_NONE,
			NULL, 0, "Table Path", HFILL }},

		{ &hf_nisplus_table_col_name, {
			"column name", "nisplus.table.col.name", FT_STRING, BASE_NONE,
			NULL, 0, NULL, HFILL }},

		{ &hf_nisplus_table_col_mask, {
			"flags", "nisplus.table.col.flags", FT_UINT32, BASE_HEX,
			NULL, 0, "Flags For This Column", HFILL }},

		{ &hf_nisplus_table_col_mask_binary, {
			"binary", "nisplus.table.flags.binary",
			FT_BOOLEAN, 32, TFS(&tfs_col_binary),
			NIS_MASK_TABLE_BINARY, "Is This Column BINARY", HFILL }},

		{ &hf_nisplus_table_col_mask_encrypted, {
			"encrypted", "nisplus.table.flags.encrypted",
			FT_BOOLEAN, 32, TFS(&tfs_col_encrypted),
			NIS_MASK_TABLE_CRYPT, "Is This Column ENCRYPTED", HFILL }},

		{ &hf_nisplus_table_col_mask_xdr, {
			"xdr", "nisplus.table.flags.xdr",
			FT_BOOLEAN, 32, TFS(&tfs_col_xdr),
			NIS_MASK_TABLE_XDR, "Is This Column XDR Encoded", HFILL }},

		{ &hf_nisplus_table_col_mask_searchable, {
			"searchable", "nisplus.table.flags.searchable",
			FT_BOOLEAN, 32, TFS(&tfs_col_searchable),
			NIS_MASK_TABLE_SRCH, "Is This Column SEARCHABLE", HFILL }},

		{ &hf_nisplus_table_col_mask_casesensitive, {
			"casesensitive", "nisplus.table.flags.casesensitive",
			FT_BOOLEAN, 32, TFS(&tfs_col_casesensitive),
			NIS_MASK_TABLE_CASE, "Is This Column CASESENSITIVE", HFILL }},

		{ &hf_nisplus_table_col_mask_modified, {
			"modified", "nisplus.table.flags.modified",
			FT_BOOLEAN, 32, TFS(&tfs_col_modified),
			NIS_MASK_TABLE_MODIFIED, "Is This Column MODIFIED", HFILL }},

		{ &hf_nisplus_table_col_mask_asn, {
			"asn", "nisplus.table.flags.asn",
			FT_BOOLEAN, 32, TFS(&tfs_col_asn),
			NIS_MASK_TABLE_ASN, "Is This Column ASN.1 Encoded", HFILL }},

		{ &hf_nisplus_group, {
			"Group", "nisplus.group", FT_NONE, BASE_NONE,
			NULL, 0, "Group Object", HFILL }},

		{ &hf_nisplus_grps, {
			"Groups", "nisplus.grps", FT_NONE, BASE_NONE,
			NULL, 0, "List Of Groups", HFILL }},

		{ &hf_nisplus_group_flags, {
			"flags", "nisplus.group.flags", FT_UINT32, BASE_HEX,
			NULL, 0, "Group Object Flags", HFILL }},

		{ &hf_nisplus_group_name, {
			"group name", "nisplus.group.name", FT_STRING, BASE_NONE,
			NULL, 0, "Name Of Group Member", HFILL }},

		{ &hf_nisplus_object_ctime, {
			"ctime", "nisplus.ctime", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL,
			NULL, 0, "Time Of Creation", HFILL }},

		{ &hf_nisplus_object_mtime, {
			"mtime", "nisplus.mtime", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL,
			NULL, 0, "Time Last Modified", HFILL }},

		{ &hf_nisplus_ib_flags, {
			"flags", "nisplus.ib.flags", FT_UINT32, BASE_HEX,
			NULL, 0, "Information Base Flags", HFILL }},

		{ &hf_nisplus_ib_bufsize, {
			"bufsize", "nisplus.ib.bufsize", FT_UINT32, BASE_HEX,
			NULL, 0, "Optional First/NextBufSize", HFILL }},

		{ &hf_nisplus_cookie, {
			"cookie", "nisplus.cookie", FT_BYTES, BASE_NONE,
			NULL, 0, NULL, HFILL }},

		{ &hf_nisplus_fd_dirname, {
			"dirname", "nisplus.fd.dirname", FT_STRING, BASE_NONE,
			NULL, 0, "Directory Name", HFILL }},

		{ &hf_nisplus_fd_requester, {
			"requester", "nisplus.fd.requester", FT_STRING, BASE_NONE,
			NULL, 0, "Host Principal Name For Signature", HFILL }},

		{ &hf_nisplus_taglist, {
			"taglist", "nisplus.taglist", FT_NONE, BASE_NONE,
			NULL, 0, "List Of Tags", HFILL }},

		{ &hf_nisplus_tag, {
			"tag", "nisplus.tag", FT_NONE, BASE_NONE,
			NULL, 0, NULL, HFILL }},

		{ &hf_nisplus_tag_type, {
			"type", "nisplus.tag.type", FT_UINT32, BASE_DEC,
			NULL, 0, "Type Of Statistics Tag", HFILL }},

		{ &hf_nisplus_tag_val, {
			"value", "nisplus.tag.value", FT_STRING, BASE_NONE,
			NULL, 0, "Value Of Statistics Tag", HFILL }},

		{ &hf_nisplus_dump_dir, {
			"directory", "nisplus.dump.dir", FT_STRING, BASE_NONE,
			NULL, 0, "Directory To Dump", HFILL }},

		{ &hf_nisplus_dump_time, {
			"time", "nisplus.dump.time", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL,
			NULL, 0, "From This Timestamp", HFILL }},

		{ &hf_nisplus_dummy, {
			"dummy", "nisplus.dummy", FT_BYTES, BASE_NONE,
			NULL, 0, NULL, HFILL }},

		{ &hf_nisplus_ping_time, {
			"time", "nisplus.ping.time", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL,
			NULL, 0, "Timestamp Of The Transaction", HFILL }},

		{ &hf_nisplus_ping_dir, {
			"directory", "nisplus.ping.dir", FT_STRING, BASE_NONE,
			NULL, 0, "Directory That Had The Change", HFILL }},

		{ &hf_nisplus_error, {
			"status", "nisplus.status", FT_UINT32, BASE_DEC,
			VALS(nis_error), 0, "NIS Status Code", HFILL }},

		{ &hf_nisplus_dir_data, {
			"data", "nisplus.fd.dir.data", FT_BYTES, BASE_NONE,
			NULL, 0, "Directory Data In XDR Format", HFILL }},

		{ &hf_nisplus_signature, {
			"signature", "nisplus.fd.sig", FT_BYTES, BASE_NONE,
			NULL, 0, "Signature Of The Source", HFILL }},

		{ &hf_nisplus_log_entries, {
			"log entries", "nisplus.log.entries", FT_NONE, BASE_NONE,
			NULL, 0, NULL, HFILL }},

		{ &hf_nisplus_log_entry, {
			"log entry", "nisplus.log.entry", FT_NONE, BASE_NONE,
			NULL, 0, NULL, HFILL }},

		{ &hf_nisplus_log_time, {
			"time", "nisplus.log.time", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL,
			NULL, 0, "Time Of Log Entry", HFILL }},

		{ &hf_nisplus_log_type, {
			"type", "nisplus.log.entry.type", FT_UINT32, BASE_DEC,
			VALS(entry_type), 0, "Type Of Entry In Transaction Log", HFILL }},

		{ &hf_nisplus_log_principal, {
			"principal", "nisplus.log.principal", FT_STRING, BASE_NONE,
			NULL, 0, "Principal Making The Change", HFILL }},

		{ &hf_nisplus_callback_status, {
			"status", "nisplus.callback.status",
			FT_BOOLEAN, BASE_NONE, TFS(&tfs_callback_status),
			0x0, "Status Of Callback Thread", HFILL }},

		{ &hf_nisplus_cp_status, {
			"status", "nisplus.checkpoint.status", FT_UINT32, BASE_DEC,
			NULL, 0, "Checkpoint Status", HFILL }},

		{ &hf_nisplus_cp_zticks, {
			"zticks", "nisplus.checkpoint.zticks", FT_UINT32, BASE_DEC,
			NULL, 0, "Service Ticks", HFILL }},

		{ &hf_nisplus_cp_dticks, {
			"dticks", "nisplus.checkpoint.dticks", FT_UINT32, BASE_DEC,
			NULL, 0, "Database Ticks", HFILL }},

		{ &hf_nisplus_zticks, {
			"zticks", "nisplus.zticks", FT_UINT32, BASE_DEC,
			NULL, 0, NULL, HFILL }},

		{ &hf_nisplus_dticks, {
			"dticks", "nisplus.dticks", FT_UINT32, BASE_DEC,
			NULL, 0, NULL, HFILL }},

		{ &hf_nisplus_aticks, {
			"aticks", "nisplus.aticks", FT_UINT32, BASE_DEC,
			NULL, 0, NULL, HFILL }},

		{ &hf_nisplus_cticks, {
			"cticks", "nisplus.cticks", FT_UINT32, BASE_DEC,
			NULL, 0, NULL, HFILL }},

	};

	static int *ett[] = {
		&ett_nisplus,
		&ett_nisplus_object,
		&ett_nisplus_oid,
		&ett_nisplus_directory,
		&ett_nisplus_directory_mask,
		&ett_nisplus_access_mask,
		&ett_nisplus_server,
		&ett_nisplus_endpoint,
		&ett_nisplus_link,
		&ett_nisplus_attr,
		&ett_nisplus_entry,
		&ett_nisplus_entry_col,
		&ett_nisplus_entry_mask,
		&ett_nisplus_table,
		&ett_nisplus_table_col,
		&ett_nisplus_table_col_mask,
		&ett_nisplus_group,
		&ett_nisplus_grps,
		&ett_nisplus_tag,
		&ett_nisplus_log_entry,
	};

	proto_nisplus = proto_register_protocol("NIS+", "NIS+", "nisplus");
	proto_register_field_array(proto_nisplus, hf, array_length(hf));
	proto_register_subtree_array(ett, array_length(ett));
}

void
proto_reg_handoff_nis(void)
{
	/* Register the protocol as RPC */
	rpc_init_prog(proto_nisplus, NIS_PROGRAM, ett_nisplus,
	    G_N_ELEMENTS(nisplus_vers_info), nisplus_vers_info);
}






/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
   callback protocol for NIS+
   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */

static int proto_nispluscb;
static int hf_nispluscb_procedure_v1;
static int hf_nispluscb_entries;
static int hf_nispluscb_entry;

static int ett_nispluscb;
static int ett_nispluscb_entry;

static int
dissect_cb_entry(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree, void* data _U_)
{
	proto_item* lock_item = NULL;
	/* proto_tree* lock_tree = NULL; */
	int old_offset = offset;

	lock_item = proto_tree_add_item(tree, hf_nispluscb_entry,
			tvb, offset, -1, ENC_NA);

	/* lock_tree = proto_item_add_subtree(lock_item, ett_nispluscb_entry); */

/*XXXXX Not implemented yet*/

	proto_item_set_len(lock_item, offset-old_offset);
	return offset;
}

static int
dissect_cback_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
	return dissect_rpc_array(tvb, pinfo, tree, 0,
			dissect_cb_entry, hf_nispluscb_entries);
}

/* proc number, "proc name", dissect_request, dissect_reply */
static const vsff cb1_proc[] = {
	{ CBPROC_NULL,			"NULL",
		dissect_rpc_void,	dissect_rpc_void },
	{ CBPROC_RECEIVE,		"RECEIVE",
		dissect_cback_data,	dissect_callback_result },
	{ CBPROC_FINISH,		"FINISH",
		dissect_rpc_void,	dissect_rpc_void },
	{ CBPROC_ERROR,			"ERROR",
		dissect_nisplus_error,	dissect_rpc_void },
	{	0,	NULL,	NULL,	NULL },
};
static const value_string nispluscb1_proc_vals[] = {
	{ CBPROC_NULL,		"NULL" },
	{ CBPROC_RECEIVE,	"RECEIVE" },
	{ CBPROC_FINISH,	"FINISH" },
	{ CBPROC_ERROR,		"ERROR" },
	{	0,	NULL }
};
static const rpc_prog_vers_info nispluscb_vers_info[] = {
	{ 1, cb1_proc, &hf_nispluscb_procedure_v1 },
};

void
proto_register_niscb(void)
{
	static hf_register_info hf[] = {
		{ &hf_nispluscb_procedure_v1, {
			"V1 Procedure", "nispluscb.procedure_v1", FT_UINT32, BASE_DEC,
			VALS(nispluscb1_proc_vals), 0, NULL, HFILL }},
		{ &hf_nispluscb_entries, {
			"entries", "nispluscb.entries", FT_NONE, BASE_NONE,
			NULL, 0, "NIS Callback Entries", HFILL }},

		{ &hf_nispluscb_entry, {
			"entry", "nispluscb.entry", FT_NONE, BASE_NONE,
			NULL, 0, "NIS Callback Entry", HFILL }},

	};

	static int *ett[] = {
		&ett_nispluscb,
		&ett_nispluscb_entry,
	};

	proto_nispluscb = proto_register_protocol("NIS+ Callback",
	    "NIS+ CB", "nispluscb");
	proto_register_field_array(proto_nispluscb, hf, array_length(hf));
	proto_register_subtree_array(ett, array_length(ett));
}

void
proto_reg_handoff_niscb(void)
{
	/* Register the protocol as RPC */
	rpc_init_prog(proto_nispluscb, CB_PROGRAM, ett_nispluscb,
	    G_N_ELEMENTS(nispluscb_vers_info), nispluscb_vers_info);
}

/*
 * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 *
 * Local variables:
 * c-basic-offset: 8
 * tab-width: 8
 * indent-tabs-mode: t
 * End:
 *
 * vi: set shiftwidth=8 tabstop=8 noexpandtab:
 * :indentSize=8:tabSize=8:noTabs=false:
 */