/* 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
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:
{
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;
{
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;
{
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);
}
* 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
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");
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;
}
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;
}
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);
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;
}
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;
}
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;
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;
}
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;
}
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;
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;
}
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;
}
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 */
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;
}
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;
}
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;
}
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 */
{
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;
}
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);
}
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;
}
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)
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);
* 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
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;
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;
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;
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);
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) {
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);
/* 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
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:
{
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;
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) {
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;
}
}
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;
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;
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) {
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;
}
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;
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;
}
* Copyright 1999, Uwe Girlich <Uwe.Girlich@philosys.de>
* Copyright 2000-2001, Mike Frisch <frisch@hummingbird.com> (NFSv4 decoding)
*
- * $Id: packet-nfs.c,v 1.52 2001/05/30 04:40:27 guy Exp $
+ * $Id: packet-nfs.c,v 1.53 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
offset = dissect_ftype(tvb, offset, pinfo, fattr_tree, "type");
offset = dissect_mode(tvb, offset, pinfo, fattr_tree, "mode");
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, fattr_tree, hf_nfs_fattr_nlink, offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, fattr_tree, hf_nfs_fattr_uid, offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, fattr_tree, hf_nfs_fattr_gid, offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, fattr_tree, hf_nfs_fattr_size, offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, fattr_tree, hf_nfs_fattr_blocksize, offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, fattr_tree, hf_nfs_fattr_rdev, offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, fattr_tree, hf_nfs_fattr_blocks, offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, fattr_tree, hf_nfs_fattr_fsid, offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, fattr_tree, hf_nfs_fattr_fileid, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_nlink, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_uid, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_gid, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_size, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_blocksize, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_rdev, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_blocks, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_fsid, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, fattr_tree, hf_nfs_fattr_fileid, offset);
offset = dissect_timeval(tvb, offset, pinfo, fattr_tree, "atime");
offset = dissect_timeval(tvb, offset, pinfo, fattr_tree, "mtime");
offset = dissect_timeval(tvb, offset, pinfo, fattr_tree, "ctime");
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff)
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, sattr_tree, hf_nfs_fattr_uid,
+ offset = dissect_rpc_uint32(tvb, pinfo, sattr_tree, hf_nfs_fattr_uid,
offset);
else {
proto_tree_add_text(sattr_tree, tvb, offset, 4, "uid: no value");
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff)
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, sattr_tree, hf_nfs_fattr_gid,
+ offset = dissect_rpc_uint32(tvb, pinfo, sattr_tree, hf_nfs_fattr_gid,
offset);
else {
proto_tree_add_text(sattr_tree, tvb, offset, 4, "gid: no value");
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff)
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, sattr_tree, hf_nfs_fattr_size,
+ offset = dissect_rpc_uint32(tvb, pinfo, sattr_tree, hf_nfs_fattr_size,
offset);
else {
proto_tree_add_text(sattr_tree, tvb, offset, 4, "size: no value");
dissect_filename(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, int hf, char **string_ret)
{
- offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf, offset, string_ret);
+ offset = dissect_rpc_string(tvb, pinfo, tree, hf, offset, string_ret);
return offset;
}
int
dissect_path(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, int hf)
{
- offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf, offset, NULL);
+ offset = dissect_rpc_string(tvb, pinfo, tree, hf, offset, NULL);
return offset;
}
dissect_nfsdata(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, int hf)
{
- offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf, offset);
+ offset = dissect_rpc_data(tvb, pinfo, tree, hf, offset);
return offset;
}
offset = dissect_stat(tvb, offset, pinfo, tree, &status);
switch (status) {
case 0:
- offset = dissect_rpc_list_tvb(tvb, pinfo, tree, offset,
+ offset = dissect_rpc_list(tvb, pinfo, tree, offset,
dissect_readdir_entry);
eof_value = tvb_get_ntohl(tvb, offset+0);
if (tree)
dissect_filename3(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, int hf, char **string_ret)
{
- offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf, offset, string_ret);
+ offset = dissect_rpc_string(tvb, pinfo, tree, hf, offset, string_ret);
return offset;
}
dissect_nfspath3(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, int hf)
{
- offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf, offset, NULL);
+ offset = dissect_rpc_string(tvb, pinfo, tree, hf, offset, NULL);
return offset;
}
offset = dissect_ftype3(tvb,offset,pinfo,fattr3_tree,hf_nfs_fattr3_type,&type);
offset = dissect_mode3(tvb,offset,pinfo,fattr3_tree,"mode");
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_nlink,
+ offset = dissect_rpc_uint32(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_nlink,
offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_uid,
+ offset = dissect_rpc_uint32(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_uid,
offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_gid,
+ offset = dissect_rpc_uint32(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_gid,
offset);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_size,
+ offset = dissect_rpc_uint64(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_size,
offset);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_used,
+ offset = dissect_rpc_uint64(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_used,
offset);
offset = dissect_specdata3(tvb,offset,pinfo,fattr3_tree,"rdev");
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_fsid,
+ offset = dissect_rpc_uint64(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_fsid,
offset);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_fileid,
+ offset = dissect_rpc_uint64(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_fileid,
offset);
offset = dissect_nfstime3 (tvb,offset,pinfo,fattr3_tree,"atime");
offset = dissect_nfstime3 (tvb,offset,pinfo,fattr3_tree,"mtime");
ett_nfs_wcc_attr);
}
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, wcc_attr_tree, hf_nfs_wcc_attr_size,
+ offset = dissect_rpc_uint64(tvb, pinfo, wcc_attr_tree, hf_nfs_wcc_attr_size,
offset);
offset = dissect_nfstime3(tvb, offset, pinfo, wcc_attr_tree, "mtime");
offset = dissect_nfstime3(tvb, offset, pinfo, wcc_attr_tree, "ctime");
switch (set_it) {
case 1:
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, set_uid3_tree,
+ offset = dissect_rpc_uint32(tvb, pinfo, set_uid3_tree,
hf_nfs_uid3, offset);
break;
default:
switch (set_it) {
case 1:
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, set_gid3_tree,
+ offset = dissect_rpc_uint32(tvb, pinfo, set_gid3_tree,
hf_nfs_gid3, offset);
break;
default:
switch (set_it) {
case 1:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, set_size3_tree,
+ offset = dissect_rpc_uint64(tvb, pinfo, set_size3_tree,
hf_nfs_set_size3_size, offset);
break;
default:
proto_tree* tree)
{
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "file");
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_offset3, offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_count3, offset);
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_offset3, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3, offset);
return offset;
}
case 0:
offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
"file_attributes");
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_count3,
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3,
offset);
- offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nfs_read_eof,
+ offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nfs_read_eof,
offset);
offset = dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_data);
break;
proto_tree* tree)
{
offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "file");
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_offset3, offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_count3, offset);
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_offset3, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3, offset);
offset = dissect_stable_how(tvb, offset, pinfo, tree, hf_nfs_write_stable);
offset = dissect_nfsdata (tvb, offset, pinfo, tree, hf_nfs_data);
switch (status) {
case 0:
offset = dissect_wcc_data (tvb, offset, pinfo, tree, "file_wcc");
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_count3,
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3,
offset);
offset = dissect_stable_how(tvb, offset, pinfo, tree,
hf_nfs_write_committed);
proto_tree* tree)
{
offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "dir");
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_cookie3, offset);
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_cookie3, offset);
offset = dissect_cookieverf3(tvb, offset, pinfo, tree);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_count3, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3, offset);
return offset;
}
entry_tree = proto_item_add_subtree(entry_item, ett_nfs_readdir_entry);
}
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, entry_tree, hf_nfs_readdir_entry3_fileid,
+ offset = dissect_rpc_uint64(tvb, pinfo, entry_tree, hf_nfs_readdir_entry3_fileid,
offset);
offset = dissect_filename3(tvb, offset, pinfo, entry_tree,
proto_item_set_text(entry_item, "Entry: name %s", name);
g_free(name);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, entry_tree, hf_nfs_readdir_entry3_cookie,
+ offset = dissect_rpc_uint64(tvb, pinfo, entry_tree, hf_nfs_readdir_entry3_cookie,
offset);
/* now we know, that a readdir entry is shorter */
offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
"dir_attributes");
offset = dissect_cookieverf3(tvb, offset, pinfo, tree);
- offset = dissect_rpc_list_tvb(tvb, pinfo, tree, offset,
+ offset = dissect_rpc_list(tvb, pinfo, tree, offset,
dissect_entry3);
eof_value = tvb_get_ntohl(tvb, offset+0);
if (tree)
proto_tree* tree)
{
offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "dir");
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_cookie3, offset);
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_cookie3, offset);
offset = dissect_cookieverf3(tvb, offset, pinfo, tree);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_count3_dircount,
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3_dircount,
offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_count3_maxcount,
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3_maxcount,
offset);
return offset;
entry_tree = proto_item_add_subtree(entry_item, ett_nfs_readdir_entry);
}
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, entry_tree,
+ offset = dissect_rpc_uint64(tvb, pinfo, entry_tree,
hf_nfs_readdirplus_entry_fileid, offset);
offset = dissect_filename3(tvb, offset, pinfo, entry_tree,
proto_item_set_text(entry_item, "Entry: name %s", name);
g_free(name);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, entry_tree, hf_nfs_readdirplus_entry_cookie,
+ offset = dissect_rpc_uint64(tvb, pinfo, entry_tree, hf_nfs_readdirplus_entry_cookie,
offset);
offset = dissect_post_op_attr(tvb, offset, pinfo, entry_tree,
offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
"dir_attributes");
offset = dissect_cookieverf3(tvb, offset, pinfo, tree);
- offset = dissect_rpc_list_tvb(tvb, pinfo, tree, offset,
+ offset = dissect_rpc_list(tvb, pinfo, tree, offset,
dissect_entryplus3);
eof_value = tvb_get_ntohl(tvb, offset+0);
if (tree)
case 0:
offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
"obj_attributes");
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_fsstat3_resok_tbytes,
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_tbytes,
offset);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_fsstat3_resok_fbytes,
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_fbytes,
offset);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_fsstat3_resok_abytes,
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_abytes,
offset);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_fsstat3_resok_tfiles,
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_tfiles,
offset);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_fsstat3_resok_ffiles,
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_ffiles,
offset);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_fsstat3_resok_afiles,
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_afiles,
offset);
invarsec = tvb_get_ntohl(tvb, offset + 0);
if (tree)
offset+0, 4, dtpref);
offset += 4;
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree,
+ offset = dissect_rpc_uint64(tvb, pinfo, tree,
hf_nfs_fsinfo_maxfilesize, offset);
offset = dissect_nfstime3(tvb, offset, pinfo, tree, "time_delta");
properties = tvb_get_ntohl(tvb, offset+0);
proto_tree_add_uint(tree, hf_nfs_pathconf_name_max, tvb,
offset+0, 4, name_max);
offset += 4;
- offset = dissect_rpc_bool_tvb(tvb, pinfo, tree,
+ offset = dissect_rpc_bool(tvb, pinfo, tree,
hf_nfs_pathconf_no_trunc, offset);
- offset = dissect_rpc_bool_tvb(tvb, pinfo, tree,
+ offset = dissect_rpc_bool(tvb, pinfo, tree,
hf_nfs_pathconf_chown_restricted, offset);
- offset = dissect_rpc_bool_tvb(tvb, pinfo, tree,
+ offset = dissect_rpc_bool(tvb, pinfo, tree,
hf_nfs_pathconf_case_insensitive, offset);
- offset = dissect_rpc_bool_tvb(tvb, pinfo, tree,
+ offset = dissect_rpc_bool(tvb, pinfo, tree,
hf_nfs_pathconf_case_preserving, offset);
break;
default:
proto_tree* tree)
{
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "file");
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_offset3, offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_count3, offset);
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_offset3, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3, offset);
return offset;
}
proto_tree *tree, int hf, char **string_ret)
{
/* TODO: this needs to be fixed */
- return dissect_rpc_string_tvb(tvb, pinfo, tree, hf, offset, string_ret);
+ return dissect_rpc_string(tvb, pinfo, tree, hf, offset, string_ret);
}
int
dissect_nfs_specdata4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_specdata1, offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_specdata2, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_specdata1, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_specdata2, offset);
return offset;
}
dissect_nfs_client_id4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_clientid4_verifier,
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_clientid4_verifier,
offset);
offset = dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_data);
dissect_nfs_reclaim4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_reclaim4, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_reclaim4, offset);
return offset;
}
dissect_nfs_length4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_length4, offset);
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_length4, offset);
return offset;
}
newftree = proto_item_add_subtree(fitem, ett_nfs_lockowner4);
if (newftree) {
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_clientid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_clientid4,
offset);
offset = dissect_nfs_opaque4(tvb, offset, pinfo, newftree, "Owner");
}
dissect_nfs_changeid4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_changeid4, offset);
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_changeid4, offset);
return offset;
}
dissect_nfs_nfstime4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_nfstime4_seconds,
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_nfstime4_seconds,
offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_nfstime4_nseconds,
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_nfstime4_nseconds,
offset);
return offset;
}
if (newftree == NULL) return offset;
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_fsid4_major,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_fsid4_major,
offset);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_fsid4_minor,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_fsid4_minor,
offset);
return offset;
dissect_nfs_acetype4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_acetype4, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_acetype4, offset);
return offset;
}
dissect_nfs_aceflag4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_aceflag4, offset);
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_aceflag4, offset);
return offset;
}
dissect_nfs_acemask4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- return dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_acemask4, offset);
+ return dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_acemask4, offset);
}
int
if (newftree == NULL) return offset;
nextentry = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_bool_tvb(tvb, pinfo, newftree, hf_nfs_data_follows,
+ offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_data_follows,
offset);
while (nextentry)
offset = dissect_nfs_pathname4(tvb, offset, pinfo, newftree, "fs_root");
nextentry = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_bool_tvb(tvb, pinfo, newftree, hf_nfs_data_follows,
+ offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_data_follows,
offset);
while (nextentry)
break;
case FATTR4_SIZE:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_size, attr_vals_offset);
break;
case FATTR4_LINK_SUPPORT:
- attr_vals_offset = dissect_rpc_bool_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_link_support,
attr_vals_offset);
break;
case FATTR4_SYMLINK_SUPPORT:
- attr_vals_offset = dissect_rpc_bool_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_symlink_support,
attr_vals_offset);
break;
case FATTR4_NAMED_ATTR:
- attr_vals_offset = dissect_rpc_bool_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_named_attr, attr_vals_offset);
break;
break;
case FATTR4_UNIQUE_HANDLES:
- attr_vals_offset = dissect_rpc_bool_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_unique_handles,
attr_vals_offset);
break;
case FATTR4_LEASE_TIME:
- attr_vals_offset = dissect_rpc_uint32_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_lease_time, offset);
break;
break;
case FATTR4_ACLSUPPORT:
- attr_vals_offset = dissect_rpc_uint32_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_aclsupport, offset);
break;
case FATTR4_ARCHIVE:
- attr_vals_offset = dissect_rpc_bool_tvb(tvb,
+ attr_vals_offset = dissect_rpc_bool(tvb,
pinfo, attr_newftree, hf_nfs_fattr4_archive,
attr_vals_offset);
break;
case FATTR4_CANSETTIME:
- attr_vals_offset = dissect_rpc_bool_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_cansettime, attr_vals_offset);
break;
case FATTR4_CASE_INSENSITIVE:
- attr_vals_offset = dissect_rpc_bool_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_case_insensitive,
attr_vals_offset);
break;
case FATTR4_CASE_PRESERVING:
- attr_vals_offset = dissect_rpc_bool_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_case_preserving,
attr_vals_offset);
break;
case FATTR4_CHOWN_RESTRICTED:
- attr_vals_offset = dissect_rpc_bool_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_chown_restricted,
attr_vals_offset);
break;
case FATTR4_FILEID:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_fileid, attr_vals_offset);
break;
case FATTR4_FILES_AVAIL:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_files_avail,
attr_vals_offset);
break;
break;
case FATTR4_FILES_FREE:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_files_free, attr_vals_offset);
break;
case FATTR4_FILES_TOTAL:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_files_total,
attr_vals_offset);
break;
break;
case FATTR4_HIDDEN:
- attr_vals_offset = dissect_rpc_bool_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_hidden, attr_vals_offset);
break;
case FATTR4_HOMOGENEOUS:
- attr_vals_offset = dissect_rpc_bool_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_homogeneous,
attr_vals_offset);
break;
case FATTR4_MAXFILESIZE:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_maxfilesize,
attr_vals_offset);
break;
case FATTR4_MAXLINK:
- attr_vals_offset = dissect_rpc_uint32_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_maxlink, attr_vals_offset);
break;
case FATTR4_MAXNAME:
- attr_vals_offset = dissect_rpc_uint32_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_maxname, attr_vals_offset);
break;
case FATTR4_MAXREAD:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_maxread, attr_vals_offset);
break;
case FATTR4_MAXWRITE:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_maxwrite, attr_vals_offset);
break;
break;
case FATTR4_NO_TRUNC:
- attr_vals_offset = dissect_rpc_bool_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_no_trunc, attr_vals_offset);
break;
case FATTR4_NUMLINKS:
- attr_vals_offset = dissect_rpc_uint32_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_numlinks, attr_vals_offset);
break;
break;
case FATTR4_QUOTA_AVAIL_HARD:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_quota_hard, attr_vals_offset);
break;
case FATTR4_QUOTA_AVAIL_SOFT:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_quota_soft, attr_vals_offset);
break;
case FATTR4_QUOTA_USED:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_quota_used, attr_vals_offset);
break;
break;
case FATTR4_SPACE_AVAIL:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_space_avail,
attr_vals_offset);
break;
case FATTR4_SPACE_FREE:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_space_free, attr_vals_offset);
break;
case FATTR4_SPACE_TOTAL:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_space_total,
attr_vals_offset);
break;
case FATTR4_SPACE_USED:
- attr_vals_offset = dissect_rpc_uint64_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_space_used, attr_vals_offset);
break;
case FATTR4_SYSTEM:
- attr_vals_offset = dissect_rpc_bool_tvb(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
attr_newftree, hf_nfs_fattr4_system, attr_vals_offset);
break;
packet_info *pinfo, proto_tree *tree, char *name)
{
offset = dissect_nfs_pathname4(tvb, offset, pinfo, tree, "file");
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree,
+ offset = dissect_rpc_uint64(tvb, pinfo, tree,
hf_nfs_stateid4_delegate_stateid, offset);
return offset;
}
break;
case CLAIM_PREVIOUS:
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint32(tvb, pinfo, newftree,
hf_nfs_delegate_type, offset);
break;
dissect_nfs_verifier4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- return dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_verifier4, offset);
+ return dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_verifier4, offset);
}
dissect_nfs_cookie4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- return dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_cookie4, offset);
+ return dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_cookie4, offset);
}
int
dissect_nfs_cookieverf4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- return dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_cookieverf4, offset);
+ return dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_cookieverf4, offset);
}
dissect_nfs_cb_client4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_cb_program,
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_cb_program,
offset);
offset = dissect_nfs_clientaddr4(tvb, offset, pinfo, tree, "cb_location");
return offset;
nextentry = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_bool_tvb(tvb, pinfo, newftree, hf_nfs_data_follows,
+ offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_data_follows,
offset);
while (nextentry)
offset += 4;
}
- offset = dissect_rpc_bool_tvb(tvb, pinfo, newftree, hf_nfs_dirlist4_eof,
+ offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_dirlist4_eof,
offset);
return offset;
newftree=proto_item_add_subtree(fitem, ett_nfs_change_info4);
if (newftree) {
- offset = dissect_rpc_bool_tvb(tvb, pinfo, newftree,
+ offset = dissect_rpc_bool(tvb, pinfo, newftree,
hf_nfs_change_info4_atomic, offset);
offset = dissect_nfs_changeid4(tvb, offset, pinfo, newftree, "before");
offset = dissect_nfs_changeid4(tvb, offset, pinfo, newftree, "after");
proto_tree *tree, char *name)
{
offset = dissect_nfs_lockowner4(tvb, offset, pinfo, tree, "owner");
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_offset4, offset);
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_offset4, offset);
offset = dissect_nfs_length4(tvb, offset, pinfo, tree, "length");
return offset;
}
dissect_nfs_open_read_delegation4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree)
{
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_stateid4, offset);
- offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nfs_recall4, offset);
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_stateid4, offset);
+ offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nfs_recall4, offset);
offset = dissect_nfs_ace4(tvb, offset, pinfo, tree, "permissions");
return offset;
dissect_nfs_modified_limit4(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, char *name)
{
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_num_blocks,
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_num_blocks,
offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_bytes_per_block,
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_bytes_per_block,
offset);
return offset;
}
switch(limitby)
{
case NFS_LIMIT_SIZE:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_filesize,
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_filesize,
offset);
break;
dissect_nfs_open_write_delegation4(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, tree, hf_nfs_stateid4, offset);
- offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nfs_recall, offset);
+ offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_stateid4, offset);
+ offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nfs_recall, offset);
offset = dissect_nfs_space_limit4(tvb, offset, pinfo, tree, "space_limit");
return dissect_nfs_ace4(tvb, offset, pinfo, tree, "permissions");
}
case NFS4_OP_CLOSE:
offset = dissect_nfs_seqid4(tvb, offset, pinfo, newftree);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
offset);
break;
case NFS4_OP_COMMIT:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, newftree, hf_nfs_count4,
+ offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_count4,
offset);
break;
break;
case NFS4_OP_DELEGPURGE:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree,
hf_nfs_clientid4, offset);
break;
case NFS4_OP_DELEGRETURN:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
offset);
break;
break;
case NFS4_OP_LOCK:
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, newftree, hf_nfs_locktype4,
+ offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_locktype4,
offset);
offset = dissect_nfs_seqid4(tvb, offset, pinfo, newftree);
offset = dissect_nfs_reclaim4(tvb, offset, pinfo, newftree, "reclaim");
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
offset);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
offset);
offset = dissect_nfs_length4(tvb, offset, pinfo, newftree, "length");
break;
case NFS4_OP_LOCKT:
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, newftree, hf_nfs_locktype4,
+ offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_locktype4,
offset);
offset = dissect_nfs_lockowner4(tvb, offset, pinfo, newftree, "owner");
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
offset);
offset = dissect_nfs_length4(tvb, offset, pinfo, newftree, "length");
break;
case NFS4_OP_LOCKU:
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, newftree, hf_nfs_locktype4,
+ offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_locktype4,
offset);
offset = dissect_nfs_seqid4(tvb, offset, pinfo, newftree);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
offset);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
offset);
offset = dissect_nfs_length4(tvb, offset, pinfo, newftree, "length");
break;
break;
case NFS4_OP_OPEN_DOWNGRADE:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
offset);
offset = dissect_nfs_seqid4(tvb, offset, pinfo, newftree);
offset = dissect_nfs_open4_share_access(tvb, offset, pinfo, newftree);
break;
case NFS4_OP_READ:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
offset);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, newftree, hf_nfs_count4,
+ offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_count4,
offset);
break;
offset = dissect_nfs_cookie4(tvb, offset, pinfo, newftree, "cookie");
offset = dissect_nfs_cookieverf4(tvb, offset, pinfo, newftree,
"cookieverf");
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint32(tvb, pinfo, newftree,
hf_nfs_count4_dircount, offset);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint32(tvb, pinfo, newftree,
hf_nfs_count4_maxcount, offset);
offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree, "attr",
0);
break;
case NFS4_OP_RENEW:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
offset);
break;
break;
case NFS4_OP_SETATTR:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
offset);
offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree,
"obj_attributes");
break;
case NFS4_OP_WRITE:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
offset);
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
offset);
offset = dissect_nfs_stable_how4(tvb, offset, pinfo, newftree,
"stable");
proto_tree* tree)
{
offset = dissect_nfs_utf8string(tvb, offset, pinfo, tree, hf_nfs_tag4, NULL);
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nfs_minorversion,
+ offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_minorversion,
offset);
offset = dissect_nfs_argop4(tvb, offset, pinfo, tree);
return offset;
break;
case NFS4_OP_CLOSE:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
offset);
break;
case NFS4_OP_LOCK:
case NFS4_OP_LOCKT:
if (status == NFS4_OK)
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree,
hf_nfs_stateid4, offset);
else
if (status == NFS4ERR_DENIED)
break;
case NFS4_OP_LOCKU:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
offset);
break;
break;
case NFS4_OP_OPEN:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
offset);
offset = dissect_nfs_change_info4(tvb, offset, pinfo, newftree,
"change_info");
case NFS4_OP_OPEN_CONFIRM:
case NFS4_OP_OPEN_DOWNGRADE:
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree, hf_nfs_stateid4,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_stateid4,
offset);
break;
break;
case NFS4_OP_READ:
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, newftree, hf_nfs_eof,
+ offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_eof,
offset);
offset = dissect_nfs_opaque4(tvb, offset, pinfo, newftree, "data");
break;
break;
case NFS4_OP_SECINFO:
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint32(tvb, pinfo, newftree,
hf_nfs_secinfo_flavor, offset);
offset = dissect_nfs_opaque4(tvb, offset, pinfo, newftree,
"flavor_info");
case NFS4_OP_SETCLIENTID:
if (status == NFS4_OK)
{
- offset = dissect_rpc_uint64_tvb(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint64(tvb, pinfo, newftree,
hf_nfs_clientid4, offset);
offset = dissect_nfs_verifier4(tvb, offset, pinfo, newftree,
"setclientid_confirm");
break;
case NFS4_OP_WRITE:
- offset = dissect_rpc_uint32_tvb(tvb, pinfo, newftree, hf_nfs_count4,
+ offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_count4,
offset);
offset = dissect_nfs_stable_how4(tvb, offset, pinfo, newftree,
"committed");
* 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
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;
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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:
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:
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;
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;
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;
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);
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;
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;
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;
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;
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,
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;
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;
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);
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;
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;
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;
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;
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;
/* 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
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;
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;
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;
}
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;
}
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;
}
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;
}
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,
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) */
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);
}
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,
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;
}
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;
}
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;
}
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;
}
/* 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
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;
}
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;
}
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;
}
"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 */
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;
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;
}
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.
* 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
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 {
/* 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)
{
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);
}
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)
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)
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;
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,
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,
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;
}
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)
{
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--) {
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;
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;
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,
{
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,
/* 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,
}
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:
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;
}
{
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;
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;
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;
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)
{
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);
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;
}
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;
}
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
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;
}
/* Dissect the arguments */
offset = call_dissect_function(tvb, pinfo, tree, offset,
- old_dissect_function, dissect_function, NULL);
+ dissect_function, NULL);
return offset;
}
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
/* 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;
}
/* 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;
}
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;
}
/* Dissect the return value */
offset = call_dissect_function(tvb, pinfo, tree, offset,
- old_dissect_function, dissect_function, NULL);
+ dissect_function, NULL);
return offset;
}
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 */
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 {
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;
}
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) {
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);
}
}
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
/* 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
*
*
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,
* 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
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;
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) {
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;
/* 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
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;
}
* 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
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,
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;
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;
*
*
* Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
* Copyright 1998 Gerald Combs
*
*
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;
/* 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
{
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;
}
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;
}
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;
}
}
- 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);
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;
}
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;
}
* 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
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,
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;
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;
}
/* 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
{
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;
{
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;
{
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;
{
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;
{
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;
{
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;
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);
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;
}
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;
}
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;
}
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;
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;
}
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;
}
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;
}
git.samba.org / metze / wireshark / wip.git / commitdiff