osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

There are no more old-style (non-tvbuffified) ONC RPC dissectors, so get 

rid of support for them, and remove the "_tvb" from the end of the names
of RPC type dissection routines.

Update Gerald's e-mail address.

svn path=/trunk/; revision=3477
This commit is contained in:
Guy Harris 2001-05-30 06:01:02 +00:00
parent e38a3ef330
commit abd9fc125f
17 changed files with 534 additions and 721 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
packet-bootparams.c
View File

@ -1,10 +1,10 @@
/* packet-bootparams.c
* Routines for bootparams dissection
*
* $Id: packet-bootparams.c,v 1.17 2001/03/18 02:07:02 guy Exp $
* $Id: packet-bootparams.c,v 1.18 2001/05/30 06:01:01 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* Copied from packet-smb.c
@ -69,7 +69,7 @@ dissect_bp_address(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
type = tvb_get_ntohl(tvb, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_bootparams_addresstype, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_bootparams_addresstype, offset);
switch(type){
case 1:
@ -95,8 +95,8 @@ dissect_getfile_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *
{
if ( tree )
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_bootparams_host, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_bootparams_fileid, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_host, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_fileid, offset, NULL);
}
return offset;
@ -107,9 +107,9 @@ dissect_getfile_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
{
if ( tree )
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_bootparams_host, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_host, offset, NULL);
offset = dissect_bp_address(tvb, offset, pinfo, tree, hf_bootparams_hostaddr);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_bootparams_filepath, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_filepath, offset, NULL);
}
return offset;
@ -131,8 +131,8 @@ dissect_whoami_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *
{
if ( tree )
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_bootparams_host, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_bootparams_domain, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_host, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_domain, offset, NULL);
offset = dissect_bp_address(tvb, offset, pinfo, tree, hf_bootparams_routeraddr);
}

114
packet-hclnfsd.c
View File

@ -2,10 +2,10 @@
* Routines for hclnfsd (Hummingbird NFS Daemon) dissection
* Copyright 2001, Mike Frisch <frisch@hummingbird.com>
*
* $Id: packet-hclnfsd.c,v 1.5 2001/05/23 19:29:45 guy Exp $
* $Id: packet-hclnfsd.c,v 1.6 2001/05/30 06:01:01 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* Copied from packet-ypserv.c
@ -124,7 +124,7 @@ dissect_hclnfsd_gids(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *
static int
dissect_hclnfsd_spool_inquire_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_status, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_status, offset);
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "spool filehandle");
@ -135,11 +135,11 @@ dissect_hclnfsd_spool_inquire_call(tvbuff_t *tvb, int offset, packet_info *pinfo
static int
dissect_hclnfsd_spool_file_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_printername, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_printername, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_filename, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_filename, offset, NULL);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_fileext, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_fileext, offset);
return offset;
}
@ -171,9 +171,9 @@ dissect_hclnfsd_authorize_call(tvbuff_t *tvb, int offset, packet_info *pinfo, pr
4, request_type);
offset += 4;
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_device, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_device, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_login, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_login, offset, NULL);
return offset;
}
@ -194,9 +194,9 @@ dissect_hclnfsd_authorize_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, p
proto_tree_add_uint(tree, hf_hclnfsd_status, tvb, offset, 4, status);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_uid, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_uid, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_gid, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_gid, offset);
offset = dissect_hclnfsd_gids(tvb, offset, pinfo, tree);
@ -206,7 +206,7 @@ dissect_hclnfsd_authorize_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, p
static int
dissect_hclnfsd_grp_name_to_numb_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_grpname, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_grpname, offset, NULL);
return offset;
}
@ -214,7 +214,7 @@ dissect_hclnfsd_grp_name_to_numb_call(tvbuff_t *tvb, int offset, packet_info *pi
static int
dissect_hclnfsd_grp_name_to_numb_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_gid, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_gid, offset);
return offset;
}
@ -252,7 +252,7 @@ dissect_hclnfsd_grp_to_number_reply(tvbuff_t *tvb, int offset, packet_info *pinf
return offset;
for (ngrpnames_i = 0; ngrpnames_i < ngrpnames ; ngrpnames_i++)
offset = dissect_rpc_string_tvb(tvb, pinfo, grptree,
offset = dissect_rpc_string(tvb, pinfo, grptree,
hf_hclnfsd_grpname, offset, NULL);
return offset;
@ -276,7 +276,7 @@ dissect_hclnfsd_return_host_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
static int
dissect_hclnfsd_return_host_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_hostname, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_hostname, offset, NULL);
return offset;
}
@ -304,7 +304,7 @@ dissect_hclnfsd_uid_to_name_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
return offset;
for (nuids_i = 0; nuids_i < nuids; nuids_i++)
offset = dissect_rpc_uint32_tvb(tvb, pinfo, uidtree, hf_hclnfsd_uid, offset);
offset = dissect_rpc_uint32(tvb, pinfo, uidtree, hf_hclnfsd_uid, offset);
return offset;
}
@ -332,7 +332,7 @@ dissect_hclnfsd_uid_to_name_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
return offset;
for (nusers_i = 0; nusers_i < nusers; nusers_i++)
offset = dissect_rpc_string_tvb(tvb, pinfo, usertree,
offset = dissect_rpc_string(tvb, pinfo, usertree,
hf_hclnfsd_username, offset, NULL);
return offset;
@ -342,7 +342,7 @@ dissect_hclnfsd_uid_to_name_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
static int
dissect_hclnfsd_name_to_uid_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_username, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_username, offset, NULL);
return offset;
}
@ -351,7 +351,7 @@ dissect_hclnfsd_name_to_uid_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
static int
dissect_hclnfsd_name_to_uid_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_uid, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_uid, offset);
return offset;
}
@ -368,17 +368,17 @@ dissect_hclnfsd_share_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_
4, request_type);
offset += 4;
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "Filehandle");
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_hclnfsd_unknown_data, offset);
offset = dissect_rpc_data(tvb, pinfo, tree, hf_hclnfsd_unknown_data, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_mode, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_mode, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_access, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_access, offset);
offset += 4; /* skip last 4 UNUSED bytes */
@ -397,9 +397,9 @@ dissect_hclnfsd_share_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto
4, request_type);
offset += 4;
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_status, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_sequence, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_status, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_sequence, offset);
return offset;
}
@ -422,23 +422,23 @@ dissect_hclnfsd_unshare_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, pro
static int
dissect_hclnfsd_lock_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_status, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_status, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
offset += 4; /* skip unused uint */
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_exclusive, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_exclusive, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "Filehandle");
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_hclnfsd_lockowner, offset);
offset = dissect_rpc_data(tvb, pinfo, tree, hf_hclnfsd_lockowner, offset);
offset += 4; /* unused, skip */
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_offset, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_offset, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_length, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_length, offset);
return offset;
}
@ -455,8 +455,8 @@ dissect_hclnfsd_lock_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_
4, request_type);
offset += 4;
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_status, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_status, offset);
return offset;
}
@ -465,7 +465,7 @@ dissect_hclnfsd_lock_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_
static int
dissect_hclnfsd_remove_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
offset += 4; /* skip unused */
@ -478,18 +478,18 @@ dissect_hclnfsd_unlock_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto
{
offset += 4; /* skip unused */
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "Filehandle");
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_hclnfsd_unknown_data, offset);
offset = dissect_rpc_data(tvb, pinfo, tree, hf_hclnfsd_unknown_data, offset);
offset += 4; /* skip unused */
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_offset, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_length, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_offset, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_length, offset);
return offset;
}
@ -527,11 +527,11 @@ dissect_hclnfsd_get_printers_reply(tvbuff_t *tvb, int offset, packet_info *pinfo
for (nqueues_i = 0; nqueues_i < nqueues; nqueues_i++)
{
/* create new item for print queue */
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_hclnfsd_queuename, offset, NULL);
/* create subtree on new item with print queue comment */
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_hclnfsd_queuecomment, offset, NULL);
}
@ -542,9 +542,9 @@ dissect_hclnfsd_get_printers_reply(tvbuff_t *tvb, int offset, packet_info *pinfo
static int
dissect_hclnfsd_get_printq_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_queuename, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_queuename, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_username, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_username, offset, NULL);
return offset;
}
@ -559,13 +559,13 @@ dissect_hclnfsd_get_printq_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_item *jobitem;
proto_tree *jobtree;
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_printqueuenumber, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_printqueuenumber, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_queuecomment, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_queuecomment, offset, NULL);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_queuestatus, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_queuestatus, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_numphysicalprinters, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_numphysicalprinters, offset);
datafollows = tvb_get_ntohl(tvb, offset);
if (tree)
@ -589,19 +589,19 @@ dissect_hclnfsd_get_printq_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
jobtree = proto_item_add_subtree(jobitem, ett_hclnfsd_printjob);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_hclnfsd_username, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_hclnfsd_printparams, offset, NULL);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_queuestatus, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_queuestatus, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_jobstatus, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_timesubmitted, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_size, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_copies, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_jobstatus, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_timesubmitted, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_size, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_copies, offset);
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_hclnfsd_queuecomment, offset, NULL);
datafollows = tvb_get_ntohl(tvb, offset);

28
packet-klm.c
View File

@ -2,7 +2,7 @@
* Routines for klm dissection
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* This program is free software; you can redistribute it and/or
@ -72,16 +72,16 @@ dissect_holder(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)
lock_tree = proto_item_add_subtree(lock_item, ett_klm_holder);
offset = dissect_rpc_bool_tvb( tvb, pinfo, lock_tree,
offset = dissect_rpc_bool( tvb, pinfo, lock_tree,
hf_klm_exclusive, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_klm_pid, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_klm_offset, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_klm_len, offset);
return offset;
@ -98,18 +98,18 @@ dissect_lock(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)
lock_tree = proto_item_add_subtree(lock_item, ett_klm_lock);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_klm_servername, offset, NULL);
offset = dissect_nfs_fh3(tvb, offset, pinfo, lock_tree,"fh");
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_klm_pid, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_klm_offset, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_klm_len, offset);
return offset;
@ -127,7 +127,7 @@ static int
dissect_klm_stat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_klm_stats, offset);
return offset;
@ -136,10 +136,10 @@ dissect_klm_stat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
static int
dissect_klm_lock_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_bool_tvb( tvb, pinfo, tree,
offset = dissect_rpc_bool( tvb, pinfo, tree,
hf_klm_block, offset);
offset = dissect_rpc_bool_tvb( tvb, pinfo, tree,
offset = dissect_rpc_bool( tvb, pinfo, tree,
hf_klm_exclusive, offset);
offset = dissect_lock(tvb, pinfo, tree, offset);
@ -154,7 +154,7 @@ dissect_klm_test_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
stats = tvb_get_ntohl(tvb, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_klm_stats, offset);
if (stats == KLM_DENIED) {
@ -167,7 +167,7 @@ dissect_klm_test_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
static int
dissect_klm_test_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_bool_tvb( tvb, pinfo, tree,
offset = dissect_rpc_bool( tvb, pinfo, tree,
hf_klm_exclusive, offset);
offset = dissect_lock(tvb, pinfo, tree, offset);

26
packet-mount.c
View File

@ -1,10 +1,10 @@
/* packet-mount.c
* Routines for mount dissection
*
* $Id: packet-mount.c,v 1.23 2001/04/07 09:25:23 guy Exp $
* $Id: packet-mount.c,v 1.24 2001/05/30 06:01:01 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* Copied from packet-smb.c
@ -94,7 +94,7 @@ dissect_fhstatus(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
gint32 status;
status=tvb_get_ntohl(tvb,offset);
offset = dissect_rpc_uint32_tvb(tvb,pinfo,tree,hf_mount3_status,offset);
offset = dissect_rpc_uint32(tvb,pinfo,tree,hf_mount3_status,offset);
switch (status) {
case 0:
@ -114,7 +114,7 @@ dissect_mount_dirpath_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_
{
if ( tree )
{
offset = dissect_rpc_string_tvb(tvb,pinfo,tree,hf_mount_path,offset,NULL);
offset = dissect_rpc_string(tvb,pinfo,tree,hf_mount_path,offset,NULL);
}
return offset;
@ -150,9 +150,9 @@ dissect_mountlist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
lock_tree = proto_item_add_subtree(lock_item, ett_mount_mountlist);
}
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_mount_mountlist_hostname, offset, &hostname);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_mount_mountlist_directory, offset, &directory);
if (lock_item) {
@ -173,7 +173,7 @@ dissect_mountlist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
static int
dissect_mount_dump_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_list_tvb(tvb, pinfo, tree, offset, dissect_mountlist);
offset = dissect_rpc_list(tvb, pinfo, tree, offset, dissect_mountlist);
return offset;
}
@ -199,7 +199,7 @@ dissect_group(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
}
group_name_list[group_names_len]=0;
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_mount_groups_group, offset, NULL);
return offset;
@ -228,7 +228,7 @@ dissect_exportlist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
exportlist_tree = proto_item_add_subtree(exportlist_item, ett_mount_exportlist);
}
offset = dissect_rpc_string_tvb(tvb, pinfo, exportlist_tree,
offset = dissect_rpc_string(tvb, pinfo, exportlist_tree,
hf_mount_exportlist_directory, offset, &directory);
groups_offset = offset;
@ -239,7 +239,7 @@ dissect_exportlist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
groups_tree = proto_item_add_subtree(groups_item, ett_mount_groups);
}
offset = dissect_rpc_list_tvb(tvb, pinfo, groups_tree, offset, dissect_group);
offset = dissect_rpc_list(tvb, pinfo, groups_tree, offset, dissect_group);
if (groups_item) {
/* mark empty lists */
if (offset - groups_offset == 4) {
@ -267,7 +267,7 @@ dissect_exportlist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
static int
dissect_mount_export_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_list_tvb(tvb, pinfo, tree, offset, dissect_exportlist);
offset = dissect_rpc_list(tvb, pinfo, tree, offset, dissect_exportlist);
return offset;
}
@ -353,7 +353,7 @@ dissect_mount_pathconf_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, prot
pc_mask = tvb_get_ntohl(tvb, offset+OFFS_MASK) & 0xffff;
if (!(pc_mask & (PC_ERROR_LINK_MAX|PC_ERROR_ALL))) {
if (tree) {
dissect_rpc_uint32_tvb(tvb,pinfo,tree,hf_mount_pathconf_link_max,offset);
dissect_rpc_uint32(tvb,pinfo,tree,hf_mount_pathconf_link_max,offset);
}
}
offset += 4;
@ -472,7 +472,7 @@ dissect_mountstat3(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offs
mountstat3 = tvb_get_ntohl(tvb, offset);
offset = dissect_rpc_uint32_tvb(tvb,pinfo,tree,hfindex,offset);
offset = dissect_rpc_uint32(tvb,pinfo,tree,hfindex,offset);
*status = mountstat3;
return offset;
}

324
packet-nfs.c
View File

File diff suppressed because it is too large Load Diff

162
packet-nisplus.c
View File

@ -2,7 +2,7 @@
* 2001 Ronnie Sahlberg <rsahlber@bigpond.net.au>
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* This program is free software; you can redistribute it and/or
@ -280,7 +280,7 @@ dissect_nisplus_time(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *
static int
dissect_group(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_nisplus_group_name, offset, NULL);
return offset;
@ -299,10 +299,10 @@ dissect_group_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_group);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nisplus_group_flags, offset);
offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
dissect_group, hf_nisplus_grps);
proto_item_set_len(lock_item, offset-old_offset);
@ -359,7 +359,7 @@ dissect_table(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_table_col);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_table_col_name, offset, NULL);
@ -403,19 +403,19 @@ dissect_table_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_table);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_table_type, offset, NULL);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nisplus_table_maxcol, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nisplus_table_sep, offset);
offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
dissect_table, hf_nisplus_table_cols);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_table_path, offset, NULL);
proto_item_set_len(lock_item, offset-old_offset);
@ -450,7 +450,7 @@ dissect_entry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
proto_tree_add_boolean(mask_tree, hf_nisplus_entry_mask_asn, tvb, offset, 4, mask);
offset += 4;
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_entry_val, offset, NULL);
proto_item_set_len(lock_item, offset-old_offset);
@ -469,10 +469,10 @@ dissect_entry_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_entry);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_entry_type, offset, NULL);
offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
dissect_entry, hf_nisplus_entry_cols);
proto_item_set_len(lock_item, offset-old_offset);
@ -491,10 +491,10 @@ dissect_attr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_attr);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_attr_name, offset, NULL);
offset = dissect_rpc_data_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_data(tvb, pinfo, lock_tree,
hf_nisplus_attr_val, offset);
proto_item_set_len(lock_item, offset-old_offset);
@ -513,13 +513,13 @@ dissect_link_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_link);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nisplus_object_type, offset);
offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
dissect_attr, hf_nisplus_attrs_array);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_object_name, offset, NULL);
proto_item_set_len(lock_item, offset-old_offset);
@ -539,13 +539,13 @@ dissect_endpoint(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_endpoint);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_endpoint_uaddr, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_endpoint_family, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_endpoint_proto, offset, NULL);
proto_item_set_len(lock_item, offset-old_offset);
@ -565,16 +565,16 @@ dissect_directory_server(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tr
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_server);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_server_name, offset, NULL);
offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
dissect_endpoint, hf_nisplus_endpoints);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nisplus_key_type, offset);
offset = dissect_rpc_data_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_data(tvb, pinfo, lock_tree,
hf_nisplus_key_data, offset);
proto_item_set_len(lock_item, offset-old_offset);
@ -596,7 +596,7 @@ dissect_directory_mask(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
offset = dissect_access_rights(tvb, offset, pinfo, lock_tree);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nisplus_object_type, offset);
proto_item_set_len(lock_item, offset-old_offset);
@ -615,19 +615,19 @@ dissect_directory_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_directory);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_directory_name, offset, NULL);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nisplus_directory_type, offset);
offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
dissect_directory_server, hf_nisplus_servers);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nisplus_directory_ttl, offset);
offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, 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);
@ -671,25 +671,25 @@ dissect_nisplus_object(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
offset = dissect_nisplus_oid(tvb, offset, pinfo, lock_tree);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_object_name, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_object_owner, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_object_group, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_object_domain, offset, NULL);
offset = dissect_access_rights(tvb, offset, pinfo, lock_tree);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nisplus_object_ttl, offset);
type = tvb_get_ntohl(tvb, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nisplus_object_type, offset);
switch (type) {
case NIS_DIRECTORY_OBJ:
@ -708,7 +708,7 @@ dissect_nisplus_object(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
offset = dissect_link_obj(tvb, offset, pinfo, lock_tree);
break;
case NIS_PRIVATE_OBJ:
offset = dissect_rpc_data_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_data(tvb, pinfo, lock_tree,
hf_nisplus_object_private, offset);
break;
case NIS_NO_OBJ:
@ -732,10 +732,10 @@ dissect_nisplus_object(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
static int
dissect_ns_request(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_nisplus_object_name, offset, NULL);
offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
dissect_nisplus_object, hf_nisplus_object);
return offset;
@ -744,25 +744,25 @@ dissect_ns_request(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
static int
dissect_ib_request(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_nisplus_object_name, offset, NULL);
offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
dissect_attr, hf_nisplus_attrs_array);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_nisplus_ib_flags, offset);
offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
dissect_nisplus_object, hf_nisplus_object);
offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
dissect_directory_server, hf_nisplus_cbservers);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_nisplus_ib_bufsize, offset);
offset = dissect_rpc_data_tvb(tvb, pinfo, tree,
offset = dissect_rpc_data(tvb, pinfo, tree,
hf_nisplus_cookie, offset);
return offset;
@ -771,10 +771,10 @@ dissect_ib_request(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
static int
dissect_fd_args(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_nisplus_fd_dirname, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_nisplus_fd_requester, offset, NULL);
return offset;
@ -792,10 +792,10 @@ dissect_nisplus_tag(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_tag);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nisplus_tag_type, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_tag_val, offset, NULL);
proto_item_set_len(lock_item, offset-old_offset);
@ -805,7 +805,7 @@ dissect_nisplus_tag(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
static int
dissect_nisplus_taglist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
dissect_nisplus_tag, hf_nisplus_taglist);
return offset;
@ -814,13 +814,13 @@ dissect_nisplus_taglist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tre
static int
dissect_dump_args(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_nisplus_dump_dir, offset, NULL);
offset = dissect_nisplus_time(tvb, offset, pinfo, tree,
hf_nisplus_dump_time);
offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
dissect_directory_server, hf_nisplus_cbservers);
return offset;
@ -829,7 +829,7 @@ dissect_dump_args(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
static int
dissect_netobj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_data_tvb(tvb, pinfo, tree,
offset = dissect_rpc_data(tvb, pinfo, tree,
hf_nisplus_dummy, offset);
return offset;
@ -838,7 +838,7 @@ dissect_netobj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
static int
dissect_nisname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_nisplus_object_name, offset, NULL);
return offset;
@ -847,7 +847,7 @@ dissect_nisname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
static int
dissect_ping_args(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_nisplus_ping_dir, offset, NULL);
offset = dissect_nisplus_time(tvb, offset, pinfo, tree,
@ -960,25 +960,25 @@ static const value_string nis_error[] = {
static int
dissect_nisplus_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_nisplus_error, offset);
offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
dissect_nisplus_object, hf_nisplus_object);
offset = dissect_rpc_data_tvb(tvb, pinfo, tree,
offset = dissect_rpc_data(tvb, pinfo, tree,
hf_nisplus_cookie, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_nisplus_zticks, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_nisplus_dticks, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_nisplus_aticks, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_nisplus_cticks, offset);
return offset;
@ -987,16 +987,16 @@ dissect_nisplus_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
static int
dissect_fd_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_nisplus_error, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_nisplus_fd_dirname, offset, NULL);
offset = dissect_rpc_data_tvb(tvb, pinfo, tree,
offset = dissect_rpc_data(tvb, pinfo, tree,
hf_nisplus_dir_data, offset);
offset = dissect_rpc_data_tvb(tvb, pinfo, tree,
offset = dissect_rpc_data(tvb, pinfo, tree,
hf_nisplus_signature, offset);
return offset;
@ -1038,16 +1038,16 @@ dissect_log_entry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
offset = dissect_nisplus_time(tvb, offset, pinfo, lock_tree,
hf_nisplus_log_time);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nisplus_log_type, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_log_principal, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_nisplus_directory_name, offset, NULL);
offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
dissect_attr, hf_nisplus_attrs_array);
offset = dissect_nisplus_object(tvb, offset, pinfo, lock_tree);
@ -1059,13 +1059,13 @@ dissect_log_entry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
static int
dissect_log_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_nisplus_error, offset);
offset = dissect_rpc_data_tvb(tvb, pinfo, tree,
offset = dissect_rpc_data(tvb, pinfo, tree,
hf_nisplus_cookie, offset);
offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
dissect_log_entry, hf_nisplus_log_entries);
return offset;
@ -1074,7 +1074,7 @@ dissect_log_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
static int
dissect_callback_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nisplus_callback_status,
offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nisplus_callback_status,
offset);
return offset;
@ -1092,13 +1092,13 @@ dissect_change_time(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
static int
dissect_cp_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_nisplus_cp_status, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_nisplus_cp_zticks, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_nisplus_cp_dticks, offset);
return offset;
@ -1107,7 +1107,7 @@ dissect_cp_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
static int
dissect_nisplus_error(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_nisplus_error, offset);
return offset;
@ -1867,7 +1867,7 @@ dissect_cb_entry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
static int
dissect_cback_data(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
dissect_cb_entry, hf_nispluscb_entries);
return offset;

88
packet-nlm.c
View File

@ -1,10 +1,10 @@
/* packet-nlm.c
* Routines for nlm dissection
*
* $Id: packet-nlm.c,v 1.16 2001/05/23 19:29:45 guy Exp $
* $Id: packet-nlm.c,v 1.17 2001/05/30 06:01:02 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* Copied from packet-mount.c
@ -162,21 +162,21 @@ dissect_lock(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int version, i
lock_tree = proto_item_add_subtree(lock_item, ett_nlm_lock);
}
offset = dissect_rpc_string_tvb(tvb,pinfo,lock_tree,
offset = dissect_rpc_string(tvb,pinfo,lock_tree,
hf_nlm_lock_caller_name, offset, NULL);
offset = dissect_nfs_fh3(tvb, offset, pinfo, lock_tree,"fh");
offset = dissect_rpc_data_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_owner, offset);
offset = dissect_rpc_data(tvb, pinfo, lock_tree, hf_nlm_lock_owner, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_svid, offset);
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_lock_svid, offset);
if (version == 4) {
offset = dissect_rpc_uint64_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_l_offset, offset);
offset = dissect_rpc_uint64_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_l_len, offset);
offset = dissect_rpc_uint64(tvb, pinfo, lock_tree, hf_nlm_lock_l_offset, offset);
offset = dissect_rpc_uint64(tvb, pinfo, lock_tree, hf_nlm_lock_l_len, offset);
}
else {
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_l_offset, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_l_len, offset);
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_lock_l_offset, offset);
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_lock_l_len, offset);
}
return offset;
@ -187,8 +187,8 @@ static int
dissect_nlm_test(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, int version)
{
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_exclusive, offset);
offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_exclusive, offset);
offset += 4;
offset = dissect_lock(tvb, pinfo, tree, version, offset);
return offset;
@ -198,12 +198,12 @@ static int
dissect_nlm_lock(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree,int version)
{
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_block, offset);
offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_exclusive, offset);
offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_block, offset);
offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_exclusive, offset);
offset = dissect_lock(tvb, pinfo, tree, version, offset);
offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_reclaim, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nlm_state, offset);
offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_reclaim, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_state, offset);
return offset;
}
@ -211,9 +211,9 @@ static int
dissect_nlm_cancel(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree,int version)
{
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_block, offset);
offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_exclusive, offset);
offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_block, offset);
offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_exclusive, offset);
offset = dissect_lock(tvb, pinfo, tree, version, offset);
return offset;
}
@ -222,7 +222,7 @@ static int
dissect_nlm_unlock(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree,int version)
{
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_lock(tvb, pinfo, tree, version, offset);
return offset;
}
@ -231,8 +231,8 @@ static int
dissect_nlm_granted(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree,int version)
{
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_exclusive, offset);
offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_exclusive, offset);
offset = dissect_lock(tvb, pinfo, tree, version, offset);
return offset;
}
@ -245,7 +245,7 @@ dissect_nlm_test_res(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
if (tree) {
lock_item = proto_tree_add_item(tree, hf_nlm_test_stat, tvb,
@ -257,7 +257,7 @@ dissect_nlm_test_res(tvbuff_t *tvb, int offset, packet_info *pinfo,
ett_nlm_lock);
}
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_test_stat_stat,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_test_stat_stat,
offset);
/* last structure is optional, only supplied for stat==1 (LOCKED) */
@ -275,23 +275,23 @@ dissect_nlm_test_res(tvbuff_t *tvb, int offset, packet_info *pinfo,
ett_nlm_lock);
}
offset = dissect_rpc_bool_tvb(tvb, pinfo, lock_tree, hf_nlm_exclusive,
offset = dissect_rpc_bool(tvb, pinfo, lock_tree, hf_nlm_exclusive,
offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_svid,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_lock_svid,
offset);
offset = dissect_rpc_data_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_owner,
offset = dissect_rpc_data(tvb, pinfo, lock_tree, hf_nlm_lock_owner,
offset);
if (version == 4) {
offset = dissect_rpc_uint64_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint64(tvb, pinfo, lock_tree,
hf_nlm_lock_l_offset, offset);
offset = dissect_rpc_uint64_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint64(tvb, pinfo, lock_tree,
hf_nlm_lock_l_len, offset);
}
else {
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nlm_lock_l_offset, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_nlm_lock_l_len, offset);
}
@ -306,7 +306,7 @@ dissect_nlm_share(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
if (tree) {
lock_item = proto_tree_add_item(tree, hf_nlm_share, tvb,
@ -318,18 +318,18 @@ dissect_nlm_share(tvbuff_t *tvb, int offset, packet_info *pinfo,
ett_nlm_lock);
}
offset = dissect_rpc_string_tvb(tvb,pinfo,lock_tree,
offset = dissect_rpc_string(tvb,pinfo,lock_tree,
hf_nlm_lock_caller_name, offset, NULL);
offset = dissect_nfs_fh3(tvb, offset, pinfo, lock_tree, "fh");
offset = dissect_rpc_data_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_owner, offset);
offset = dissect_rpc_data(tvb, pinfo, lock_tree, hf_nlm_lock_owner, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_share_mode, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_share_access, offset);
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_share_mode, offset);
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_share_access, offset);
offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_reclaim, offset);
offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_reclaim, offset);
return offset;
}
@ -337,9 +337,9 @@ static int
dissect_nlm_shareres(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, int version)
{
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nlm_state, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nlm_sequence, offset);
offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_state, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_sequence, offset);
return offset;
}
@ -347,10 +347,10 @@ static int
dissect_nlm_freeall(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree,int version)
{
offset = dissect_rpc_string_tvb(tvb,pinfo,tree,
offset = dissect_rpc_string(tvb,pinfo,tree,
hf_nlm_share_name, offset, NULL);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nlm_state, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_state, offset);
return offset;
}
@ -364,8 +364,8 @@ static int
dissect_nlm_gen_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nlm_state, offset);
offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_state, offset);
return offset;
}

24
packet-portmap.c
View File

@ -1,10 +1,10 @@
/* packet-portmap.c
* Routines for portmap dissection
*
* $Id: packet-portmap.c,v 1.29 2001/04/17 06:29:12 guy Exp $
* $Id: packet-portmap.c,v 1.30 2001/05/30 06:01:02 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* Copied from packet-smb.c
@ -97,7 +97,7 @@ int dissect_getport_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
int dissect_getport_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_portmap_port,
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_portmap_port,
offset);
return offset;
}
@ -159,7 +159,7 @@ int dissect_unset_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
int dissect_set_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_portmap_answer,
offset = dissect_rpc_bool(tvb, pinfo, tree, hf_portmap_answer,
offset);
return offset;
}
@ -200,7 +200,7 @@ dissect_dump_entry(tvbuff_t *tvb, int offset, packet_info *pinfo,
int dissect_dump_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
offset = dissect_rpc_list_tvb(tvb, pinfo, tree, offset,
offset = dissect_rpc_list(tvb, pinfo, tree, offset,
dissect_dump_entry);
return offset;
}
@ -322,13 +322,13 @@ dissect_rpcb(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
"Program: %s (%u)", rpc_prog_name(prog), prog);
offset += 4;
offset = dissect_rpc_uint32_tvb(tvb, pinfo, rpcb_tree,
offset = dissect_rpc_uint32(tvb, pinfo, rpcb_tree,
hf_portmap_rpcb_version, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, rpcb_tree,
offset = dissect_rpc_string(tvb, pinfo, rpcb_tree,
hf_portmap_rpcb_netid, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, rpcb_tree,
offset = dissect_rpc_string(tvb, pinfo, rpcb_tree,
hf_portmap_rpcb_addr, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, rpcb_tree,
offset = dissect_rpc_string(tvb, pinfo, rpcb_tree,
hf_portmap_rpcb_owner, offset, NULL);
/* now we know, that rpcb is shorter */
@ -355,7 +355,7 @@ int dissect_rpcb3_getaddr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
int dissect_rpcb3_getaddr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_portmap_uaddr, offset, NULL);
return offset;
@ -366,7 +366,7 @@ int dissect_rpcb3_getaddr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
int dissect_rpcb3_dump_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
offset = dissect_rpc_list_tvb(tvb, pinfo, tree, offset, dissect_rpcb);
offset = dissect_rpc_list(tvb, pinfo, tree, offset, dissect_rpcb);
return offset;
}
@ -375,7 +375,7 @@ int dissect_rpcb_rmtcallres(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
/* Dissect the remote universal address. */
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_portmap_rpcb_addr, offset, NULL);
/* Dissect the result of this procedure.

269
packet-rpc.c
View File

@ -2,10 +2,10 @@
* Routines for rpc dissection
* Copyright 1999, Uwe Girlich <Uwe.Girlich@philosys.de>
*
* $Id: packet-rpc.c,v 1.60 2001/05/27 09:15:14 guy Exp $
* $Id: packet-rpc.c,v 1.61 2001/05/30 06:01:02 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* Copied from packet-smb.c
@ -203,15 +203,8 @@ typedef struct _rpc_proc_info_key {
typedef struct _rpc_proc_info_value {
gchar *name;
gboolean is_old_dissector;
union {
old_dissect_function_t *old;
dissect_function_t *new;
} dissect_call;
union {
old_dissect_function_t *old;
dissect_function_t *new;
} dissect_reply;
dissect_function_t *dissect_call;
dissect_function_t *dissect_reply;
} rpc_proc_info_value;
typedef struct _rpc_prog_info_key {
@ -253,30 +246,6 @@ rpc_proc_hash(gconstpointer k)
/* insert some entries */
void
old_rpc_init_proc_table(guint prog, guint vers, const old_vsff *proc_table)
{
const old_vsff *proc;
for (proc = proc_table ; proc->strptr!=NULL; proc++) {
rpc_proc_info_key *key;
rpc_proc_info_value *value;
key = (rpc_proc_info_key *) g_malloc(sizeof(rpc_proc_info_key));
key->prog = prog;
key->vers = vers;
key->proc = proc->value;
value = (rpc_proc_info_value *) g_malloc(sizeof(rpc_proc_info_value));
value->name = proc->strptr;
value->is_old_dissector = TRUE;
value->dissect_call.old = proc->dissect_call;
value->dissect_reply.old = proc->dissect_reply;
g_hash_table_insert(rpc_procs,key,value);
}
}
void
rpc_init_proc_table(guint prog, guint vers, const vsff *proc_table)
{
@ -293,9 +262,8 @@ rpc_init_proc_table(guint prog, guint vers, const vsff *proc_table)
value = (rpc_proc_info_value *) g_malloc(sizeof(rpc_proc_info_value));
value->name = proc->strptr;
value->is_old_dissector = FALSE;
value->dissect_call.new = proc->dissect_call;
value->dissect_reply.new = proc->dissect_reply;
value->dissect_call = proc->dissect_call;
value->dissect_reply = proc->dissect_reply;
g_hash_table_insert(rpc_procs,key,value);
}
@ -452,23 +420,7 @@ rpc_roundup(unsigned int a)
int
dissect_rpc_bool(const u_char *pd, int offset, frame_data *fd, proto_tree *tree,
int hfindex)
{
guint32 value;
if (!BYTES_ARE_IN_FRAME(offset,4)) return offset;
value = EXTRACT_UINT(pd, offset+0);
if (tree)
proto_tree_add_boolean(tree, hfindex, NullTVB, offset, 4, value);
offset += 4;
return offset;
}
int
dissect_rpc_bool_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
dissect_rpc_bool(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int hfindex, int offset)
{
if (tree)
@ -478,26 +430,7 @@ int hfindex, int offset)
int
dissect_rpc_uint32(const u_char *pd, int offset, frame_data *fd, proto_tree *tree,
char* name)
{
guint32 value;
if (!BYTES_ARE_IN_FRAME(offset,4)) return offset;
value = EXTRACT_UINT(pd, offset+0);
if (tree) {
proto_tree_add_text(tree, NullTVB, offset, 4,
"%s: %u", name, value);
}
offset += 4;
return offset;
}
int
dissect_rpc_uint32_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
dissect_rpc_uint32(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int hfindex, int offset)
{
if (tree)
@ -507,32 +440,7 @@ int hfindex, int offset)
int
dissect_rpc_uint64(const u_char *pd, int offset, frame_data *fd, proto_tree *tree,
char* name)
{
guint32 value_low;
guint32 value_high;
if (!BYTES_ARE_IN_FRAME(offset,8)) return offset;
value_high = EXTRACT_UINT(pd, offset+0);
value_low = EXTRACT_UINT(pd, offset+4);
if (tree) {
if (value_high)
proto_tree_add_text(tree, NullTVB, offset, 8,
"%s: 0x%x%08x", name, value_high, value_low);
else
proto_tree_add_text(tree, NullTVB, offset, 8,
"%s: %u", name, value_low);
}
offset += 8;
return offset;
}
int
dissect_rpc_uint64_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
dissect_rpc_uint64(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int hfindex, int offset)
{
guint32 value_low;
@ -723,19 +631,7 @@ dissect_rpc_opaque_data(tvbuff_t *tvb, int offset, packet_info *pinfo,
int
dissect_rpc_string(const u_char *pd, int offset, frame_data *fd,
proto_tree *tree, int hfindex, char **string_buffer_ret)
{
tvbuff_t *tvb = tvb_create_from_top(offset);
offset = dissect_rpc_string_tvb(tvb, &pi, tree, hfindex, 0,
string_buffer_ret);
return tvb_raw_offset(tvb) + offset;
}
int
dissect_rpc_string_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
dissect_rpc_string(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int hfindex, int offset, char **string_buffer_ret)
{
offset = dissect_rpc_opaque_data(tvb, offset, pinfo, tree,
@ -745,19 +641,7 @@ dissect_rpc_string_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int
dissect_rpc_data(const u_char *pd, int offset, frame_data *fd,
proto_tree *tree, int hfindex)
{
tvbuff_t *tvb = tvb_create_from_top(offset);
offset = dissect_rpc_data_tvb(tvb, &pi, tree, hfindex, 0);
return tvb_raw_offset(tvb) + offset;
}
int
dissect_rpc_data_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
dissect_rpc_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int hfindex, int offset)
{
offset = dissect_rpc_opaque_data(tvb, offset, pinfo, tree, hfindex,
@ -768,30 +652,7 @@ dissect_rpc_data_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int
dissect_rpc_list(const u_char *pd, int offset, frame_data *fd,
proto_tree *tree, old_dissect_function_t *rpc_list_dissector)
{
guint32 value_follows;
while (1) {
if (!BYTES_ARE_IN_FRAME(offset,4)) break;
value_follows = EXTRACT_UINT(pd, offset+0);
proto_tree_add_boolean(tree,hf_rpc_value_follows, NullTVB,
offset+0, 4, value_follows);
offset += 4;
if (value_follows == 1) {
offset = rpc_list_dissector(pd, offset, fd, tree);
}
else {
break;
}
}
return offset;
}
int
dissect_rpc_list_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
dissect_rpc_list(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int offset, dissect_function_t *rpc_list_dissector)
{
guint32 value_follows;
@ -813,7 +674,7 @@ dissect_rpc_list_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
}
int
dissect_rpc_array_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
dissect_rpc_array(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int offset, dissect_function_t *rpc_array_dissector,
int hfindex)
{
@ -837,7 +698,7 @@ dissect_rpc_array_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
lock_tree = proto_item_add_subtree(lock_item, ett_rpc_array);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_rpc_array_len, offset);
while (num--) {
@ -867,7 +728,7 @@ dissect_rpc_authunix_cred(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, i
offset+0, 4, stamp);
offset += 4;
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_rpc_auth_machinename, offset, NULL);
if (!tvb_bytes_exist(tvb,offset,4)) return offset;
@ -943,14 +804,14 @@ dissect_rpc_authgss_cred(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, in
tvb, offset+0, 4, agc_svc);
offset += 4;
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_rpc_authgss_ctx,
offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_ctx,
offset);
return offset;
}
int
dissect_rpc_authdes_desblock_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
dissect_rpc_authdes_desblock(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int hfindex, int offset)
{
guint32 value_low;
@ -986,9 +847,9 @@ dissect_rpc_authdes_cred(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, in
switch(adc_namekind)
{
case AUTHDES_NAMEKIND_FULLNAME:
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_rpc_authdes_netname, offset, NULL);
offset = dissect_rpc_authdes_desblock_tvb(tvb, pinfo, tree,
offset = dissect_rpc_authdes_desblock(tvb, pinfo, tree,
hf_rpc_authdes_convkey, offset);
window = tvb_get_ntohl(tvb, offset+0);
proto_tree_add_uint(tree, hf_rpc_authdes_window, tvb, offset+0, 4,
@ -1098,7 +959,7 @@ dissect_rpc_verf(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset
{
guint window;
dissect_rpc_authdes_desblock_tvb(tvb, pinfo, vtree,
dissect_rpc_authdes_desblock(tvb, pinfo, vtree,
hf_rpc_authdes_timestamp, offset+8);
window = tvb_get_ntohl(tvb, offset+16);
proto_tree_add_uint(vtree, hf_rpc_authdes_windowverf, tvb,
@ -1109,7 +970,7 @@ dissect_rpc_verf(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset
/* must be an RPC_REPLY */
guint nickname;
dissect_rpc_authdes_desblock_tvb(tvb, pinfo, vtree,
dissect_rpc_authdes_desblock(tvb, pinfo, vtree,
hf_rpc_authdes_timeverf, offset+8);
nickname = tvb_get_ntohl(tvb, offset+16);
proto_tree_add_uint(vtree, hf_rpc_authdes_nickname, tvb,
@ -1117,7 +978,7 @@ dissect_rpc_verf(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset
}
break;
case RPCSEC_GSS:
dissect_rpc_data_tvb(tvb, pinfo, vtree,
dissect_rpc_data(tvb, pinfo, vtree,
hf_rpc_authgss_checksum, offset+4);
break;
default:
@ -1137,7 +998,7 @@ dissect_rpc_verf(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset
static int
dissect_rpc_authgss_initarg(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset)
{
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_rpc_authgss_token,
offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_token,
offset);
return offset;
}
@ -1147,7 +1008,7 @@ dissect_rpc_authgss_initres(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree,
{
int major, minor, window;
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_rpc_authgss_ctx,
offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_ctx,
offset);
if (!tvb_bytes_exist(tvb,offset,4)) return offset;
@ -1171,7 +1032,7 @@ dissect_rpc_authgss_initres(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree,
offset+0, 4, window);
offset += 4;
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_rpc_authgss_token,
offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_token,
offset);
return offset;
@ -1180,32 +1041,18 @@ dissect_rpc_authgss_initres(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree,
static int
call_dissect_function(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
int offset, old_dissect_function_t *old_dissect_function,
dissect_function_t* dissect_function, const char *progname)
int offset, dissect_function_t* dissect_function, const char *progname)
{
const char *saved_proto;
if (old_dissect_function != NULL || dissect_function != NULL) {
if (dissect_function != NULL) {
/* set the current protocol name */
saved_proto = pinfo->current_proto;
if (progname != NULL)
pinfo->current_proto = progname;
/* call the dissector for the next level */
if (dissect_function == NULL) {
const guint8 *tvb_pd;
int tvb_offset;
/*
* It's an old-style dissector.
* Make a pd, offset pair.
*/
tvb_compat(tvb, &tvb_pd, &tvb_offset);
offset = old_dissect_function(tvb_pd,
tvb_offset + offset, pinfo->fd, tree) - tvb_offset;
} else
offset = dissect_function(tvb, offset, pinfo, tree);
offset = dissect_function(tvb, offset, pinfo, tree);
/* restore the protocol name */
pinfo->current_proto = saved_proto;
@ -1218,7 +1065,6 @@ call_dissect_function(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
static int
dissect_rpc_authgss_integ_data(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, int offset,
old_dissect_function_t *old_dissect_function,
dissect_function_t* dissect_function,
const char *progname)
{
@ -1227,7 +1073,6 @@ dissect_rpc_authgss_integ_data(tvbuff_t *tvb, packet_info *pinfo,
proto_item *gitem;
proto_tree *gtree = NULL;
if (!tvb_bytes_exist(tvb, offset, 8)) return offset;
length = tvb_get_ntohl(tvb, offset+0);
length = rpc_roundup(length);
seq = tvb_get_ntohl(tvb, offset+4);
@ -1241,14 +1086,13 @@ dissect_rpc_authgss_integ_data(tvbuff_t *tvb, packet_info *pinfo,
proto_tree_add_uint(gtree, hf_rpc_authgss_seq,
tvb, offset+4, 4, seq);
}
if (old_dissect_function != NULL || dissect_function != NULL) {
if (dissect_function != NULL) {
/* offset = */
call_dissect_function(tvb, pinfo, gtree, offset,
old_dissect_function, dissect_function,
progname);
dissect_function, progname);
}
offset += 8 + length;
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_rpc_authgss_checksum,
offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_checksum,
offset);
return offset;
}
@ -1257,7 +1101,7 @@ dissect_rpc_authgss_integ_data(tvbuff_t *tvb, packet_info *pinfo,
static int
dissect_rpc_authgss_priv_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)
{
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_rpc_authgss_data,
offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_data,
offset);
return offset;
}
@ -1280,17 +1124,13 @@ dissect_rpc_indir_call(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
rpc_call_info_value *rpc_call;
rpc_call_info_key rpc_call_key;
rpc_call_info_key *new_rpc_call_key;
old_dissect_function_t *old_dissect_function = NULL;
dissect_function_t *dissect_function = NULL;
key.prog = prog;
key.vers = vers;
key.proc = proc;
if ((value = g_hash_table_lookup(rpc_procs,&key)) != NULL) {
if (value->is_old_dissector)
old_dissect_function = value->dissect_call.old;
else
dissect_function = value->dissect_call.new;
dissect_function = value->dissect_call;
/* Keep track of the address and port whence the call came,
and the port to which the call is being sent, so that
@ -1351,7 +1191,7 @@ dissect_rpc_indir_call(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
Happens only with strange program versions or
non-existing dissectors.
Just show the arguments as opaque data. */
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, args_id,
offset = dissect_rpc_data(tvb, pinfo, tree, args_id,
offset);
return offset;
}
@ -1366,7 +1206,7 @@ dissect_rpc_indir_call(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
/* Dissect the arguments */
offset = call_dissect_function(tvb, pinfo, tree, offset,
old_dissect_function, dissect_function, NULL);
dissect_function, NULL);
return offset;
}
@ -1384,7 +1224,6 @@ dissect_rpc_indir_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
rpc_call_info_value *rpc_call;
char *procname = NULL;
char procname_static[20];
old_dissect_function_t *old_dissect_function = NULL;
dissect_function_t *dissect_function = NULL;
/* Look for the matching call in the hash table of indirect
@ -1401,7 +1240,7 @@ dissect_rpc_indir_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
/* We haven't seen an RPC call for that conversation,
so we can't check for a reply to that call.
Just show the reply stuff as opaque data. */
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, result_id,
offset = dissect_rpc_data(tvb, pinfo, tree, result_id,
offset);
return offset;
}
@ -1414,16 +1253,13 @@ dissect_rpc_indir_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
/* The XID doesn't match a call from that
conversation, so it's probably not an RPC reply.
Just show the reply stuff as opaque data. */
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, result_id,
offset = dissect_rpc_data(tvb, pinfo, tree, result_id,
offset);
return offset;
}
if (rpc_call->proc_info != NULL) {
if (rpc_call->proc_info->is_old_dissector)
old_dissect_function = rpc_call->proc_info->dissect_reply.old;
else
dissect_function = rpc_call->proc_info->dissect_reply.new;
dissect_function = rpc_call->proc_info->dissect_reply;
if (rpc_call->proc_info->name != NULL) {
procname = rpc_call->proc_info->name;
}
@ -1452,10 +1288,10 @@ dissect_rpc_indir_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
procname, rpc_call->proc);
}
if (old_dissect_function == NULL && dissect_function == NULL) {
if (dissect_function == NULL) {
/* We don't know how to dissect the reply procedure.
Just show the reply stuff as opaque data. */
offset = dissect_rpc_data_tvb(tvb, pinfo, tree, result_id,
offset = dissect_rpc_data(tvb, pinfo, tree, result_id,
offset);
return offset;
}
@ -1470,7 +1306,7 @@ dissect_rpc_indir_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
/* Dissect the return value */
offset = call_dissect_function(tvb, pinfo, tree, offset,
old_dissect_function, dissect_function, NULL);
dissect_function, NULL);
return offset;
}
@ -1525,7 +1361,6 @@ dissect_rpc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
conversation_t* conversation;
static address null_address = { AT_NONE, 0, NULL };
old_dissect_function_t *old_dissect_function = NULL;
dissect_function_t *dissect_function = NULL;
/* TCP uses record marking */
@ -1697,10 +1532,7 @@ dissect_rpc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
key.proc = proc;
if ((value = g_hash_table_lookup(rpc_procs,&key)) != NULL) {
if (value->is_old_dissector)
old_dissect_function = value->dissect_call.old;
else
dissect_function = value->dissect_call.new;
dissect_function = value->dissect_call;
procname = value->name;
}
else {
@ -1817,10 +1649,7 @@ dissect_rpc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
rpc_call->req_num);
if (rpc_call->proc_info != NULL) {
if (rpc_call->proc_info->is_old_dissector)
old_dissect_function = rpc_call->proc_info->dissect_reply.old;
else
dissect_function = rpc_call->proc_info->dissect_reply.new;
dissect_function = rpc_call->proc_info->dissect_reply;
if (rpc_call->proc_info->name != NULL) {
procname = rpc_call->proc_info->name;
}
@ -2002,17 +1831,15 @@ dissect_rpc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
if (ptree) {
proto_tree_add_uint(ptree,
hf_rpc_programversion, NullTVB, 0, 0, vers);
hf_rpc_programversion, tvb, 0, 0, vers);
proto_tree_add_uint_format(ptree,
hf_rpc_procedure, NullTVB, 0, 0, proc,
hf_rpc_procedure, tvb, 0, 0, proc,
"Procedure: %s (%u)", procname, proc);
}
}
if (!proto_is_protocol_enabled(proto)) {
old_dissect_function = NULL;
if (!proto_is_protocol_enabled(proto))
dissect_function = NULL;
}
/* RPCSEC_GSS processing. */
if (flavor == RPCSEC_GSS) {
@ -2032,14 +1859,12 @@ dissect_rpc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
if (gss_svc == RPCSEC_GSS_SVC_NONE) {
offset = call_dissect_function(tvb,
pinfo, ptree, offset,
old_dissect_function,
dissect_function,
progname);
}
else if (gss_svc == RPCSEC_GSS_SVC_INTEGRITY) {
offset = dissect_rpc_authgss_integ_data(tvb,
pinfo, ptree, offset,
old_dissect_function,
dissect_function,
progname);
}
@ -2054,7 +1879,7 @@ dissect_rpc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
}
else {
offset=call_dissect_function(tvb, pinfo, ptree, offset,
old_dissect_function, dissect_function, progname);
dissect_function, progname);
}
/* dissect any remaining bytes (incomplete dissection) as pure data in

30
packet-rpc.h
View File

@ -1,11 +1,11 @@
/* packet-rpc.h
*
* $Id: packet-rpc.h,v 1.28 2001/05/25 20:13:04 guy Exp $
* $Id: packet-rpc.h,v 1.29 2001/05/30 06:01:02 guy Exp $
*
* (c) 1999 Uwe Girlich
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
*
@ -100,32 +100,20 @@ extern char *rpc_prog_name(guint32 prog);
extern char *rpc_proc_name(guint32 prog, guint32 vers, guint32 proc);
extern unsigned int rpc_roundup(unsigned int a);
extern int dissect_rpc_bool(const u_char *pd, int offset, frame_data *fd,
proto_tree *tree, int hfindex);
extern int dissect_rpc_bool_tvb(tvbuff_t *tvb, packet_info *pinfo,
extern int dissect_rpc_bool(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, int hfindex, int offset);
extern int dissect_rpc_string(const u_char *pd, int offset, frame_data *fd,
proto_tree *tree, int hfindex, char **string_buffer_ret);
extern int dissect_rpc_string_tvb(tvbuff_t *tvb, packet_info *pinfo,
extern int dissect_rpc_string(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, int hfindex, int offset, char **string_buffer_ret);
extern int dissect_rpc_data(const u_char *pd, int offset, frame_data *fd,
proto_tree *tree, int hfindex);
extern int dissect_rpc_data_tvb(tvbuff_t *tvb, packet_info *pinfo,
extern int dissect_rpc_data(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, int hfindex, int offset);
extern int dissect_rpc_list(const u_char *pd, int offset, frame_data *fd,
proto_tree *tree, old_dissect_function_t *rpc_list_dissector);
extern int dissect_rpc_list_tvb(tvbuff_t *tvb, packet_info *pinfo,
extern int dissect_rpc_list(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, int offset, dissect_function_t *rpc_list_dissector);
extern int dissect_rpc_array_tvb(tvbuff_t *tvb, packet_info *pinfo,
extern int dissect_rpc_array(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, int offset, dissect_function_t *rpc_array_dissector,
int hfindex);
extern int dissect_rpc_uint32(const u_char *pd, int offset, frame_data *fd,
proto_tree *tree, char* name);
extern int dissect_rpc_uint32_tvb(tvbuff_t *tvb, packet_info *pinfo,
extern int dissect_rpc_uint32(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, int hfindex, int offset);
extern int dissect_rpc_uint64(const u_char *pd, int offset, frame_data *fd,
proto_tree *tree, char* name);
extern int dissect_rpc_uint64_tvb(tvbuff_t *tvb, packet_info *pinfo,
extern int dissect_rpc_uint64(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, int hfindex, int offset);
extern int dissect_rpc_indir_call(tvbuff_t *tvb, packet_info *pinfo,

30
packet-rquota.c
View File

@ -2,10 +2,10 @@
* Routines for rquota dissection
* Copyright 2001, Mike Frisch <frisch@hummingbird.com>
*
* $Id: packet-rquota.c,v 1.2 2001/04/21 08:00:12 guy Exp $
* $Id: packet-rquota.c,v 1.3 2001/05/30 06:01:02 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* Copied from packet-ypxfr.c
@ -80,34 +80,34 @@ dissect_rquota(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
lock_tree = proto_item_add_subtree(lock_item, ett_rquota_rquota);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_rquota_bsize, offset);
offset = dissect_rpc_bool_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_bool(tvb, pinfo, lock_tree,
hf_rquota_active, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_rquota_bhardlimit, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_rquota_bsoftlimit, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_rquota_curblocks, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_rquota_fhardlimit, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_rquota_fsoftlimit, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_rquota_curfiles, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_rquota_btimeleft, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_rquota_ftimeleft, offset);
return offset;
@ -120,7 +120,7 @@ dissect_getquota_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tre
status = tvb_get_ntohl(tvb, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_rquota_status, offset);
if (status==Q_OK) {
@ -133,10 +133,10 @@ dissect_getquota_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tre
static int
dissect_getquota_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
offset = dissect_rpc_string(tvb, pinfo, tree,
hf_rquota_pathp, offset, NULL);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_rquota_uid, offset);
return offset;

4
packet-rwall.c
View File

@ -1,7 +1,7 @@
/* packet-rwall.c
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* This program is free software; you can redistribute it and/or
@ -40,7 +40,7 @@ static gint ett_rwall = -1;
static int
dissect_rwall_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_rwall_message, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_rwall_message, offset, NULL);
return offset;
}

10
packet-spray.c
View File

@ -2,7 +2,7 @@
* 2001 Ronnie Sahlberg <rsahlber@bigpond.net.au>
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* This program is free software; you can redistribute it and/or
@ -50,7 +50,7 @@ dissect_get_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree,
offset = dissect_rpc_uint32(tvb, pinfo, tree,
hf_spray_counter, offset);
lock_item = proto_tree_add_item(tree, hf_spray_clock, tvb,
@ -58,10 +58,10 @@ dissect_get_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
lock_tree = proto_item_add_subtree(lock_item, ett_spray_clock);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_spray_sec, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_spray_usec, offset);
return offset;
@ -70,7 +70,7 @@ dissect_get_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
static int
dissect_spray_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_data_tvb(tvb, pinfo, tree,
offset = dissect_rpc_data(tvb, pinfo, tree,
hf_spray_sprayarr, offset);
return offset;

6
packet-stat-notify.c
View File

@ -4,7 +4,7 @@
*
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
*
@ -47,9 +47,9 @@ static int
dissect_statnotify_mon(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb,pinfo,tree,hf_statnotify_name,offset,NULL);
offset = dissect_rpc_string(tvb,pinfo,tree,hf_statnotify_name,offset,NULL);
offset = dissect_rpc_uint32_tvb(tvb,pinfo,tree,hf_statnotify_state,offset);
offset = dissect_rpc_uint32(tvb,pinfo,tree,hf_statnotify_state,offset);
proto_tree_add_item(tree,hf_statnotify_priv,tvb,offset,16,FALSE);
offset += 16;

26
packet-stat.c
View File

@ -1,10 +1,10 @@
/* packet-stat.c
* Routines for stat dissection
*
* $Id: packet-stat.c,v 1.8 2001/03/15 21:55:07 guy Exp $
* $Id: packet-stat.c,v 1.9 2001/05/30 06:01:02 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* Copied from packet-smb.c
@ -113,7 +113,7 @@ dissect_stat_stat(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
{
if (tree)
{
offset = dissect_rpc_string_tvb(tvb,pinfo,tree,hf_stat_mon_name,offset,NULL);
offset = dissect_rpc_string(tvb,pinfo,tree,hf_stat_mon_name,offset,NULL);
}
return offset;
@ -135,11 +135,11 @@ dissect_stat_stat_res(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
}
res = tvb_get_ntohl(tvb, offset);
offset = dissect_rpc_uint32_tvb(tvb,pinfo,lock_tree,hf_stat_stat_res_res,offset);
offset = dissect_rpc_uint32(tvb,pinfo,lock_tree,hf_stat_stat_res_res,offset);
if (res==STAT_SUCC) {
state = tvb_get_ntohl(tvb, offset);
offset = dissect_rpc_uint32_tvb(tvb,pinfo,lock_tree,hf_stat_stat_res_state,offset);
offset = dissect_rpc_uint32(tvb,pinfo,lock_tree,hf_stat_stat_res_state,offset);
} else {
offset += 4;
}
@ -160,10 +160,10 @@ dissect_stat_my_id(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
lock_tree = proto_item_add_subtree(lock_item, ett_stat_my_id);
}
offset = dissect_rpc_string_tvb(tvb,pinfo,lock_tree,hf_stat_my_id_hostname,offset,NULL);
offset = dissect_rpc_uint32_tvb(tvb,pinfo,lock_tree,hf_stat_my_id_prog,offset);
offset = dissect_rpc_uint32_tvb(tvb,pinfo,lock_tree,hf_stat_my_id_vers,offset);
offset = dissect_rpc_uint32_tvb(tvb,pinfo,lock_tree,hf_stat_my_id_proc,offset);
offset = dissect_rpc_string(tvb,pinfo,lock_tree,hf_stat_my_id_hostname,offset,NULL);
offset = dissect_rpc_uint32(tvb,pinfo,lock_tree,hf_stat_my_id_prog,offset);
offset = dissect_rpc_uint32(tvb,pinfo,lock_tree,hf_stat_my_id_vers,offset);
offset = dissect_rpc_uint32(tvb,pinfo,lock_tree,hf_stat_my_id_proc,offset);
return offset;
}
@ -182,7 +182,7 @@ dissect_stat_mon_id(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
}
offset = dissect_rpc_string_tvb(tvb,pinfo,lock_tree,hf_stat_mon_id_name,offset,NULL);
offset = dissect_rpc_string(tvb,pinfo,lock_tree,hf_stat_mon_id_name,offset,NULL);
offset = dissect_stat_my_id(tvb,offset,pinfo,lock_tree);
@ -211,7 +211,7 @@ dissect_stat_mon(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
static int
dissect_stat_state(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb,pinfo,tree,hf_stat_state,offset);
offset = dissect_rpc_uint32(tvb,pinfo,tree,hf_stat_state,offset);
return offset;
}
@ -229,9 +229,9 @@ dissect_stat_notify(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
lock_tree = proto_item_add_subtree(lock_item, ett_stat_stat_chge);
}
offset = dissect_rpc_string_tvb(tvb,pinfo,lock_tree,hf_stat_mon_id_name,offset,NULL);
offset = dissect_rpc_string(tvb,pinfo,lock_tree,hf_stat_mon_id_name,offset,NULL);
offset = dissect_rpc_uint32_tvb(tvb,pinfo,tree,hf_stat_state,offset);
offset = dissect_rpc_uint32(tvb,pinfo,tree,hf_stat_state,offset);
return offset;
}

20
packet-yppasswd.c
View File

@ -2,7 +2,7 @@
* Routines for yppasswd dissection
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* This program is free software; you can redistribute it and/or
@ -54,7 +54,7 @@ dissect_yppasswd_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
proto_item *lock_item = NULL;
proto_tree *lock_tree = NULL;
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_yppasswd_oldpass,
offset = dissect_rpc_string(tvb, pinfo, tree, hf_yppasswd_oldpass,
offset, NULL);
lock_item = proto_tree_add_item(tree, hf_yppasswd_newpw, tvb,
@ -62,19 +62,19 @@ dissect_yppasswd_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
lock_tree = proto_item_add_subtree(lock_item, ett_yppasswd_newpw);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_yppasswd_newpw_name, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_yppasswd_newpw_passwd, offset, NULL);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_yppasswd_newpw_uid, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
hf_yppasswd_newpw_gid, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_yppasswd_newpw_gecos, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_yppasswd_newpw_dir, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
offset = dissect_rpc_string(tvb, pinfo, lock_tree,
hf_yppasswd_newpw_shell, offset, NULL);
return offset;
@ -83,7 +83,7 @@ dissect_yppasswd_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
static int
dissect_yppasswd_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_yppasswd_status, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_yppasswd_status, offset);
return offset;
}

76
packet-ypserv.c
View File

@ -1,10 +1,10 @@
/* packet-ypserv.c
* Routines for ypserv dissection
*
* $Id: packet-ypserv.c,v 1.15 2001/03/17 21:16:56 guy Exp $
* $Id: packet-ypserv.c,v 1.16 2001/05/30 06:01:02 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
* By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
* Copied from packet-smb.c
@ -101,7 +101,7 @@ dissect_domain_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
{
if ( tree )
{
offset = dissect_rpc_string_tvb(tvb,pinfo,tree,hf_ypserv_domain,offset,NULL);
offset = dissect_rpc_string(tvb,pinfo,tree,hf_ypserv_domain,offset,NULL);
}
return offset;
@ -125,9 +125,9 @@ dissect_match_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
{
if ( tree )
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
}
return offset;
@ -138,9 +138,9 @@ dissect_match_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
{
if ( tree )
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_status, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_value,offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_value,offset, NULL);
}
return offset;
@ -152,9 +152,9 @@ dissect_first_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
{
if ( tree )
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
}
return offset;
@ -166,10 +166,10 @@ dissect_firstnext_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tre
{
if ( tree )
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_status, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_value, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_value, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
}
return offset;
@ -181,9 +181,9 @@ dissect_next_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
{
if ( tree )
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
}
return offset;
@ -203,13 +203,13 @@ dissect_xfr_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
lock_tree = proto_item_add_subtree(lock_item, ett_ypserv_map_parms);
}
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, hf_ypserv_domain, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, lock_tree, hf_ypserv_domain, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, hf_ypserv_map, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, lock_tree, hf_ypserv_map, offset, NULL);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_ypserv_ordernum, offset);
offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_ypserv_ordernum, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, hf_ypserv_peer, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, lock_tree, hf_ypserv_peer, offset, NULL);
tid=tvb_get_ntohl(tvb,offset);
@ -217,8 +217,8 @@ dissect_xfr_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
proto_tree_add_ipv4(tree, hf_ypserv_transid, tvb, offset, 4, tid);
offset += 4;
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_prog, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_port, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_prog, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_port, offset);
return offset;
}
@ -233,7 +233,7 @@ dissect_xfr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
proto_tree_add_ipv4(tree, hf_ypserv_transid, tvb, offset, 4, tid);
offset += 4;
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_xfrstat, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_xfrstat, offset);
return offset;
}
@ -242,9 +242,9 @@ static int
dissect_ypreq_nokey(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
return offset;
}
@ -256,11 +256,11 @@ dissect_ypresp_all(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
more = tvb_get_ntohl(tvb, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_more, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_more, offset);
if (more) {
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_status, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_value, offset, NULL);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_value, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
}
return offset;
@ -270,9 +270,9 @@ static int
dissect_ypresp_master(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_status, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_peer, offset, NULL);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_peer, offset, NULL);
return offset;
}
@ -282,9 +282,9 @@ static int
dissect_ypresp_order(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_status, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_ordernum, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_ordernum, offset);
return offset;
}
@ -293,13 +293,13 @@ dissect_ypresp_order(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *
static int
dissect_ypresp_maplist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_status, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
while(tvb_get_ntohl(tvb,offset)){
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_more, offset);
offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_more, offset);
offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
}
offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_more, offset);
offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_more, offset);
return offset;
}