There are no more old-style (non-tvbuffified) ONC RPC dissectors, so get
authorguy <guy@f5534014-38df-0310-8fa8-9805f1628bb7>
Wed, 30 May 2001 06:01:02 +0000 (06:01 +0000)
committerguy <guy@f5534014-38df-0310-8fa8-9805f1628bb7>
Wed, 30 May 2001 06:01:02 +0000 (06:01 +0000)
rid of support for them, and remove the "_tvb" from the end of the names
of RPC type dissection routines.

Update Gerald's e-mail address.

git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@3477 f5534014-38df-0310-8fa8-9805f1628bb7

17 files changed:
packet-bootparams.c
packet-hclnfsd.c
packet-klm.c
packet-mount.c
packet-nfs.c
packet-nisplus.c
packet-nlm.c
packet-portmap.c
packet-rpc.c
packet-rpc.h
packet-rquota.c
packet-rwall.c
packet-spray.c
packet-stat-notify.c
packet-stat.c
packet-yppasswd.c
packet-ypserv.c

index a3b4a52d15dd8b5b54b239a420373cd841e36801..d2ae45bf3810ea33b382a7e6a07cd58b100b8a80 100644 (file)
@@ -1,10 +1,10 @@
 /* packet-bootparams.c
  * Routines for bootparams dissection
  *
- * $Id: packet-bootparams.c,v 1.17 2001/03/18 02:07:02 guy Exp $
+ * $Id: packet-bootparams.c,v 1.18 2001/05/30 06:01:01 guy Exp $
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * Copied from packet-smb.c
@@ -69,7 +69,7 @@ dissect_bp_address(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
 
        type = tvb_get_ntohl(tvb, offset);
        
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_bootparams_addresstype, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_bootparams_addresstype, offset);
 
        switch(type){
        case 1:
@@ -95,8 +95,8 @@ dissect_getfile_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *
 {
        if ( tree )
        {
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_bootparams_host, offset, NULL);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_bootparams_fileid, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_host, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_fileid, offset, NULL);
        }
        
        return offset;
@@ -107,9 +107,9 @@ dissect_getfile_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
 {
        if ( tree )
        {
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_bootparams_host, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_host, offset, NULL);
                offset = dissect_bp_address(tvb, offset, pinfo, tree, hf_bootparams_hostaddr);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_bootparams_filepath, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_filepath, offset, NULL);
        }
        
        return offset;
@@ -131,8 +131,8 @@ dissect_whoami_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *
 {
        if ( tree )
        {
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_bootparams_host, offset, NULL);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_bootparams_domain, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_host, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_domain, offset, NULL);
                offset = dissect_bp_address(tvb, offset, pinfo, tree, hf_bootparams_routeraddr);
        }
        
index 1047dd5cbb5e8ffc885df3824e788869663ddb2d..396e8896b982521a030811d0322e8a861dcaa487 100644 (file)
@@ -2,10 +2,10 @@
  * Routines for hclnfsd (Hummingbird NFS Daemon) dissection
  * Copyright 2001, Mike Frisch <frisch@hummingbird.com>
  *
- * $Id: packet-hclnfsd.c,v 1.5 2001/05/23 19:29:45 guy Exp $
+ * $Id: packet-hclnfsd.c,v 1.6 2001/05/30 06:01:01 guy Exp $
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * Copied from packet-ypserv.c
@@ -124,7 +124,7 @@ dissect_hclnfsd_gids(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *
 static int
 dissect_hclnfsd_spool_inquire_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_status, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_status, offset);
 
        offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "spool filehandle");
 
@@ -135,11 +135,11 @@ dissect_hclnfsd_spool_inquire_call(tvbuff_t *tvb, int offset, packet_info *pinfo
 static int
 dissect_hclnfsd_spool_file_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_printername, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_printername, offset, NULL);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_filename, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_filename, offset, NULL);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_fileext, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_fileext, offset);
 
        return offset;
 }
@@ -171,9 +171,9 @@ dissect_hclnfsd_authorize_call(tvbuff_t *tvb, int offset, packet_info *pinfo, pr
                        4, request_type);
        offset += 4;
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_device, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_device, offset, NULL);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_login, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_login, offset, NULL);
 
        return offset;
 }
@@ -194,9 +194,9 @@ dissect_hclnfsd_authorize_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, p
 
        proto_tree_add_uint(tree, hf_hclnfsd_status, tvb, offset, 4, status);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_uid, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_uid, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_gid, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_gid, offset);
 
        offset = dissect_hclnfsd_gids(tvb, offset, pinfo, tree);
 
@@ -206,7 +206,7 @@ dissect_hclnfsd_authorize_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, p
 static int
 dissect_hclnfsd_grp_name_to_numb_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_grpname, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_grpname, offset, NULL);
 
        return offset;
 }
@@ -214,7 +214,7 @@ dissect_hclnfsd_grp_name_to_numb_call(tvbuff_t *tvb, int offset, packet_info *pi
 static int
 dissect_hclnfsd_grp_name_to_numb_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_gid, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_gid, offset);
        
        return offset;
 }
@@ -252,7 +252,7 @@ dissect_hclnfsd_grp_to_number_reply(tvbuff_t *tvb, int offset, packet_info *pinf
                return offset;
 
        for (ngrpnames_i = 0; ngrpnames_i < ngrpnames ; ngrpnames_i++)
-               offset = dissect_rpc_string_tvb(tvb, pinfo, grptree, 
+               offset = dissect_rpc_string(tvb, pinfo, grptree, 
                        hf_hclnfsd_grpname, offset, NULL);
        
        return offset;
@@ -276,7 +276,7 @@ dissect_hclnfsd_return_host_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
 static int
 dissect_hclnfsd_return_host_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_hostname, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_hostname, offset, NULL);
 
        return offset;
 }
@@ -304,7 +304,7 @@ dissect_hclnfsd_uid_to_name_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
                return offset;
 
        for (nuids_i = 0; nuids_i < nuids; nuids_i++)
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, uidtree, hf_hclnfsd_uid, offset);
+               offset = dissect_rpc_uint32(tvb, pinfo, uidtree, hf_hclnfsd_uid, offset);
 
        return offset;
 }
@@ -332,7 +332,7 @@ dissect_hclnfsd_uid_to_name_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
                return offset;
 
        for (nusers_i = 0; nusers_i < nusers; nusers_i++)
-               offset = dissect_rpc_string_tvb(tvb, pinfo, usertree, 
+               offset = dissect_rpc_string(tvb, pinfo, usertree, 
                        hf_hclnfsd_username, offset, NULL);
 
        return offset;
@@ -342,7 +342,7 @@ dissect_hclnfsd_uid_to_name_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
 static int
 dissect_hclnfsd_name_to_uid_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_username, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_username, offset, NULL);
 
        return offset;
 }
@@ -351,7 +351,7 @@ dissect_hclnfsd_name_to_uid_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
 static int
 dissect_hclnfsd_name_to_uid_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_uid, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_uid, offset);
 
        return offset;
 }
@@ -368,17 +368,17 @@ dissect_hclnfsd_share_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_
                        4, request_type);
        offset += 4;
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
 
        offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "Filehandle");
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_hclnfsd_unknown_data, offset);
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_hclnfsd_unknown_data, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_mode, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_mode, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_access, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_access, offset);
 
        offset += 4;    /* skip last 4 UNUSED bytes */
 
@@ -397,9 +397,9 @@ dissect_hclnfsd_share_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto
                        4, request_type);
        offset += 4;
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_status, offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_sequence, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_status, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_sequence, offset);
 
        return offset;
 }
@@ -422,23 +422,23 @@ dissect_hclnfsd_unshare_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, pro
 static int
 dissect_hclnfsd_lock_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_status, offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_status, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
        offset += 4; /* skip unused uint */
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_exclusive, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_exclusive, offset);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
 
        offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "Filehandle");
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_hclnfsd_lockowner, offset);
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_hclnfsd_lockowner, offset);
 
        offset += 4;  /* unused, skip */
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_offset, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_offset, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_length, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_length, offset);
 
        return offset;
 }
@@ -455,8 +455,8 @@ dissect_hclnfsd_lock_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_
                        4, request_type);
        offset += 4;
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_status, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_status, offset);
 
        return offset;
 }
@@ -465,7 +465,7 @@ dissect_hclnfsd_lock_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_
 static int
 dissect_hclnfsd_remove_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
 
        offset += 4;  /* skip unused */
 
@@ -478,18 +478,18 @@ dissect_hclnfsd_unlock_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto
 {
        offset += 4;  /* skip unused */
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
 
        offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "Filehandle");
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_hclnfsd_unknown_data, offset);
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_hclnfsd_unknown_data, offset);
 
        offset += 4;  /* skip unused */
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_offset, offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_length, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_offset, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_length, offset);
        
        return offset;
 }
@@ -527,11 +527,11 @@ dissect_hclnfsd_get_printers_reply(tvbuff_t *tvb, int offset, packet_info *pinfo
        for (nqueues_i = 0; nqueues_i < nqueues; nqueues_i++)
        {
                /* create new item for print queue */
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+               offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_hclnfsd_queuename, offset, NULL);
 
                /* create subtree on new item with print queue comment */
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+               offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_hclnfsd_queuecomment, offset, NULL);
        }
 
@@ -542,9 +542,9 @@ dissect_hclnfsd_get_printers_reply(tvbuff_t *tvb, int offset, packet_info *pinfo
 static int
 dissect_hclnfsd_get_printq_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_queuename, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_queuename, offset, NULL);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_username, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_username, offset, NULL);
 
        return offset;
 }
@@ -559,13 +559,13 @@ dissect_hclnfsd_get_printq_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
        proto_item *jobitem;
        proto_tree *jobtree;
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_printqueuenumber, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_printqueuenumber, offset);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_hclnfsd_queuecomment, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_queuecomment, offset, NULL);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_queuestatus, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_queuestatus, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_numphysicalprinters, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_numphysicalprinters, offset);
 
        datafollows = tvb_get_ntohl(tvb, offset);
        if (tree)
@@ -589,19 +589,19 @@ dissect_hclnfsd_get_printq_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
 
                jobtree = proto_item_add_subtree(jobitem, ett_hclnfsd_printjob);
                        
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+               offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_hclnfsd_username, offset, NULL);
 
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+               offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_hclnfsd_printparams, offset, NULL);
 
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_queuestatus, offset);
+               offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_queuestatus, offset);
 
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_jobstatus, offset);
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_timesubmitted, offset);
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_size, offset);
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_hclnfsd_copies, offset);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+               offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_jobstatus, offset);
+               offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_timesubmitted, offset);
+               offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_size, offset);
+               offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_copies, offset);
+               offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_hclnfsd_queuecomment, offset, NULL);
 
                datafollows = tvb_get_ntohl(tvb, offset);
index 3967940d20d65a7f8eee56c1fdd3294546b48867..0cc44596c4fdd47529a1e5604bd143355f44fb1f 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for klm dissection
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * This program is free software; you can redistribute it and/or
@@ -72,16 +72,16 @@ dissect_holder(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)
 
        lock_tree = proto_item_add_subtree(lock_item, ett_klm_holder);
 
-       offset = dissect_rpc_bool_tvb( tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_bool( tvb, pinfo, lock_tree, 
                        hf_klm_exclusive, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_klm_pid, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_klm_offset, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_klm_len, offset);
 
        return offset;
@@ -98,18 +98,18 @@ dissect_lock(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)
 
        lock_tree = proto_item_add_subtree(lock_item, ett_klm_lock);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree,
                        hf_klm_servername, offset, NULL);
 
        offset = dissect_nfs_fh3(tvb, offset, pinfo, lock_tree,"fh");
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_klm_pid, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_klm_offset, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_klm_len, offset);
 
        return offset;
@@ -127,7 +127,7 @@ static int
 dissect_klm_stat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_klm_stats, offset);
 
        return offset;
@@ -136,10 +136,10 @@ dissect_klm_stat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
 static int
 dissect_klm_lock_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_bool_tvb( tvb, pinfo, tree, 
+       offset = dissect_rpc_bool( tvb, pinfo, tree, 
                        hf_klm_block, offset);
 
-       offset = dissect_rpc_bool_tvb( tvb, pinfo, tree, 
+       offset = dissect_rpc_bool( tvb, pinfo, tree, 
                        hf_klm_exclusive, offset);
 
        offset = dissect_lock(tvb, pinfo, tree, offset);
@@ -154,7 +154,7 @@ dissect_klm_test_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
 
        stats = tvb_get_ntohl(tvb, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_klm_stats, offset);
 
        if (stats == KLM_DENIED) {
@@ -167,7 +167,7 @@ dissect_klm_test_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
 static int
 dissect_klm_test_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_bool_tvb( tvb, pinfo, tree, 
+       offset = dissect_rpc_bool( tvb, pinfo, tree, 
                        hf_klm_exclusive, offset);
 
        offset = dissect_lock(tvb, pinfo, tree, offset);
index ff9c58ef7348023d69c2b5e88afca38957a1b75b..e7f5e22d521846460b3bf87f08721f996d8c4871 100644 (file)
@@ -1,10 +1,10 @@
 /* packet-mount.c
  * Routines for mount dissection
  *
- * $Id: packet-mount.c,v 1.23 2001/04/07 09:25:23 guy Exp $
+ * $Id: packet-mount.c,v 1.24 2001/05/30 06:01:01 guy Exp $
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * Copied from packet-smb.c
@@ -94,7 +94,7 @@ dissect_fhstatus(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
        gint32 status;
 
        status=tvb_get_ntohl(tvb,offset);
-       offset = dissect_rpc_uint32_tvb(tvb,pinfo,tree,hf_mount3_status,offset);
+       offset = dissect_rpc_uint32(tvb,pinfo,tree,hf_mount3_status,offset);
 
        switch (status) {
                case 0:
@@ -114,7 +114,7 @@ dissect_mount_dirpath_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_
 {
        if ( tree )
        {
-               offset = dissect_rpc_string_tvb(tvb,pinfo,tree,hf_mount_path,offset,NULL);
+               offset = dissect_rpc_string(tvb,pinfo,tree,hf_mount_path,offset,NULL);
        }
        
        return offset;
@@ -150,9 +150,9 @@ dissect_mountlist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
                        lock_tree = proto_item_add_subtree(lock_item, ett_mount_mountlist);
        }
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_mount_mountlist_hostname, offset, &hostname);
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree,
                        hf_mount_mountlist_directory, offset, &directory);
 
        if (lock_item) {
@@ -173,7 +173,7 @@ dissect_mountlist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
 static int
 dissect_mount_dump_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_list_tvb(tvb, pinfo, tree, offset, dissect_mountlist);
+       offset = dissect_rpc_list(tvb, pinfo, tree, offset, dissect_mountlist);
 
        return offset;
 }
@@ -199,7 +199,7 @@ dissect_group(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
        }
        group_name_list[group_names_len]=0;
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_mount_groups_group, offset, NULL);
 
        return offset;
@@ -228,7 +228,7 @@ dissect_exportlist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
                        exportlist_tree = proto_item_add_subtree(exportlist_item, ett_mount_exportlist);
        }
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, exportlist_tree,
+       offset = dissect_rpc_string(tvb, pinfo, exportlist_tree,
                        hf_mount_exportlist_directory, offset, &directory);
        groups_offset = offset;
 
@@ -239,7 +239,7 @@ dissect_exportlist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
                        groups_tree = proto_item_add_subtree(groups_item, ett_mount_groups);
        }
 
-       offset = dissect_rpc_list_tvb(tvb, pinfo, groups_tree, offset, dissect_group);
+       offset = dissect_rpc_list(tvb, pinfo, groups_tree, offset, dissect_group);
        if (groups_item) {
                /* mark empty lists */
                if (offset - groups_offset == 4) {
@@ -267,7 +267,7 @@ dissect_exportlist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
 static int
 dissect_mount_export_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_list_tvb(tvb, pinfo, tree, offset, dissect_exportlist);
+       offset = dissect_rpc_list(tvb, pinfo, tree, offset, dissect_exportlist);
 
        return offset;
 }
@@ -353,7 +353,7 @@ dissect_mount_pathconf_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, prot
        pc_mask = tvb_get_ntohl(tvb, offset+OFFS_MASK) & 0xffff;
        if (!(pc_mask & (PC_ERROR_LINK_MAX|PC_ERROR_ALL))) {
                if (tree) {
-                       dissect_rpc_uint32_tvb(tvb,pinfo,tree,hf_mount_pathconf_link_max,offset);
+                       dissect_rpc_uint32(tvb,pinfo,tree,hf_mount_pathconf_link_max,offset);
                }
        }
        offset += 4;
@@ -472,7 +472,7 @@ dissect_mountstat3(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offs
 
        mountstat3 = tvb_get_ntohl(tvb, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb,pinfo,tree,hfindex,offset);
+       offset = dissect_rpc_uint32(tvb,pinfo,tree,hfindex,offset);
        *status = mountstat3;
        return offset;
 }
index 7b943b90b63e7bd5878373212e65172e40840ac0..297f80a40c4fed9247a8a9882304deb5004f6dda 100644 (file)
@@ -3,10 +3,10 @@
  * 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
@@ -1062,15 +1062,15 @@ dissect_fattr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, 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");
@@ -1106,7 +1106,7 @@ dissect_sattr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, c
        }
 
        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");
@@ -1114,7 +1114,7 @@ dissect_sattr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, c
        }
 
        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");
@@ -1122,7 +1122,7 @@ dissect_sattr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, c
        }
 
        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");
@@ -1157,7 +1157,7 @@ int
 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;
 }
 
@@ -1166,7 +1166,7 @@ dissect_filename(tvbuff_t *tvb, int offset, packet_info *pinfo,
 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;
 }
 
@@ -1262,7 +1262,7 @@ int
 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;
 }
 
@@ -1516,7 +1516,7 @@ dissect_nfs2_readdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
        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)
@@ -1630,7 +1630,7 @@ int
 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;
 }
 
@@ -1640,7 +1640,7 @@ int
 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;
 }
 
@@ -1933,20 +1933,20 @@ dissect_fattr3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
 
        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");
@@ -2026,7 +2026,7 @@ dissect_wcc_attr(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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");
@@ -2227,7 +2227,7 @@ dissect_set_uid3(tvbuff_t *tvb, int offset, packet_info *pinfo,
 
        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:
@@ -2274,7 +2274,7 @@ dissect_set_gid3(tvbuff_t *tvb, int offset, packet_info *pinfo,
 
        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:
@@ -2321,7 +2321,7 @@ dissect_set_size3(tvbuff_t *tvb, int offset, packet_info *pinfo,
 
        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:
@@ -2795,8 +2795,8 @@ dissect_nfs3_read_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
        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;
 }
@@ -2814,9 +2814,9 @@ dissect_nfs3_read_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
                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;
@@ -2863,8 +2863,8 @@ dissect_nfs3_write_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
        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);
 
@@ -2883,7 +2883,7 @@ dissect_nfs3_write_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
        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);
@@ -3125,9 +3125,9 @@ dissect_nfs3_readdir_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
        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;
 }
@@ -3148,7 +3148,7 @@ dissect_entry3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree* tree)
                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,
@@ -3157,7 +3157,7 @@ dissect_entry3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree* 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 */
@@ -3183,7 +3183,7 @@ dissect_nfs3_readdir_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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)
@@ -3207,11 +3207,11 @@ dissect_nfs3_readdirplus_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
        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;
@@ -3234,7 +3234,7 @@ dissect_entryplus3(tvbuff_t *tvb, int offset, packet_info *pinfo,
                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,
@@ -3243,7 +3243,7 @@ dissect_entryplus3(tvbuff_t *tvb, int offset, packet_info *pinfo,
                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, 
@@ -3273,7 +3273,7 @@ dissect_nfs3_readdirplus_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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)
@@ -3304,17 +3304,17 @@ dissect_nfs3_fsstat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
                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)
@@ -3396,7 +3396,7 @@ dissect_nfs3_fsinfo_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                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);
@@ -3473,13 +3473,13 @@ dissect_nfs3_pathconf_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                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:
@@ -3498,8 +3498,8 @@ dissect_nfs3_commit_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
        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;
 }
 
@@ -3534,7 +3534,7 @@ dissect_nfs_utf8string(tvbuff_t *tvb, int offset, packet_info *pinfo,
        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
@@ -3562,8 +3562,8 @@ 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;
 }
@@ -3572,7 +3572,7 @@ int
 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);
 
@@ -3617,7 +3617,7 @@ int
 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;
 }
 
@@ -3625,7 +3625,7 @@ int
 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;
 }
 
@@ -3646,7 +3646,7 @@ dissect_nfs_lockowner4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                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");
                }
@@ -3684,7 +3684,7 @@ int
 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;
 }
 
@@ -3692,9 +3692,9 @@ int
 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;
 }
@@ -3767,9 +3767,9 @@ dissect_nfs_fsid4(tvbuff_t *tvb, int offset, packet_info *pinfo,
 
        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;
@@ -3779,7 +3779,7 @@ int
 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;
 }
 
@@ -3787,7 +3787,7 @@ int
 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;
 }
 
@@ -3795,7 +3795,7 @@ int
 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
@@ -3815,7 +3815,7 @@ dissect_nfs_nfsace4(tvbuff_t *tvb, int offset, packet_info *pinfo,
        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)
@@ -3880,7 +3880,7 @@ dissect_nfs_fs_locations4(tvbuff_t *tvb, int offset, packet_info *pinfo,
        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)
@@ -4104,24 +4104,24 @@ dissect_nfs_attributes(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                                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;
 
@@ -4131,13 +4131,13 @@ dissect_nfs_attributes(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                                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;
 
@@ -4152,46 +4152,46 @@ dissect_nfs_attributes(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                                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;
@@ -4202,12 +4202,12 @@ dissect_nfs_attributes(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                                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;
@@ -4219,39 +4219,39 @@ dissect_nfs_attributes(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                                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;
 
@@ -4267,12 +4267,12 @@ dissect_nfs_attributes(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                                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;
 
@@ -4290,17 +4290,17 @@ dissect_nfs_attributes(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                                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;
 
@@ -4310,29 +4310,29 @@ dissect_nfs_attributes(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                                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;
 
@@ -4452,7 +4452,7 @@ dissect_nfs_open_claim_delegate_cur4(tvbuff_t *tvb, int offset,
        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;
 }
@@ -4496,7 +4496,7 @@ dissect_nfs_open_claim4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                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;
 
@@ -4598,7 +4598,7 @@ int
 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);
 }
 
 
@@ -4606,14 +4606,14 @@ int
 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);
 }
 
 
@@ -4632,7 +4632,7 @@ int
 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;
@@ -4765,7 +4765,7 @@ dissect_nfs_dirlist4(tvbuff_t *tvb, int offset, packet_info *pinfo,
 
        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)
@@ -4777,7 +4777,7 @@ dissect_nfs_dirlist4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                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;
@@ -4796,7 +4796,7 @@ dissect_nfs_change_info4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                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");
@@ -4811,7 +4811,7 @@ dissect_nfs_lock4denied(tvbuff_t *tvb, int offset, packet_info *pinfo,
        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;
 }
@@ -4875,8 +4875,8 @@ int
 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;
@@ -4886,9 +4886,9 @@ int
 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;
 }
@@ -4914,7 +4914,7 @@ dissect_nfs_space_limit4(tvbuff_t *tvb, int offset, packet_info *pinfo,
        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;
 
@@ -4934,8 +4934,8 @@ int
 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");
 }
@@ -5036,14 +5036,14 @@ dissect_nfs_argop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
 
                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;
 
@@ -5082,12 +5082,12 @@ dissect_nfs_argop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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;
 
@@ -5105,33 +5105,33 @@ dissect_nfs_argop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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;
@@ -5168,7 +5168,7 @@ dissect_nfs_argop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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);
@@ -5184,11 +5184,11 @@ dissect_nfs_argop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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;
 
@@ -5196,9 +5196,9 @@ dissect_nfs_argop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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);
@@ -5220,7 +5220,7 @@ dissect_nfs_argop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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;
        
@@ -5233,7 +5233,7 @@ dissect_nfs_argop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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");
@@ -5276,9 +5276,9 @@ dissect_nfs_argop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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");
@@ -5298,7 +5298,7 @@ dissect_nfs4_compound_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
        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;
@@ -5365,7 +5365,7 @@ dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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;
 
@@ -5404,7 +5404,7 @@ dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                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)
@@ -5413,7 +5413,7 @@ dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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;
 
@@ -5430,7 +5430,7 @@ dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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");
@@ -5448,7 +5448,7 @@ dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
 
                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;
 
@@ -5465,7 +5465,7 @@ dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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;
@@ -5505,7 +5505,7 @@ dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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");
@@ -5519,7 +5519,7 @@ dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                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");
@@ -5541,7 +5541,7 @@ dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
                        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");
index 2a114a94bdb18556992f56285c6764a71afe3eaf..ee3b3d6b4d7f90526d7c08fa2c5326d935363b41 100644 (file)
@@ -2,7 +2,7 @@
  * 2001  Ronnie Sahlberg   <rsahlber@bigpond.net.au>
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * This program is free software; you can redistribute it and/or
@@ -280,7 +280,7 @@ dissect_nisplus_time(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *
 static int
 dissect_group(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_nisplus_group_name, offset, NULL);
 
        return offset;
@@ -299,10 +299,10 @@ dissect_group_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
 
        lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_group);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_nisplus_group_flags, offset);
 
-       offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
                        dissect_group, hf_nisplus_grps);
 
        proto_item_set_len(lock_item, offset-old_offset);
@@ -359,7 +359,7 @@ dissect_table(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 
        lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_table_col);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_nisplus_table_col_name, offset, NULL);
 
 
@@ -403,19 +403,19 @@ dissect_table_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
 
        lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_table);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_nisplus_table_type, offset, NULL);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_nisplus_table_maxcol, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_nisplus_table_sep, offset);
 
-       offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
                        dissect_table, hf_nisplus_table_cols);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_nisplus_table_path, offset, NULL);
 
        proto_item_set_len(lock_item, offset-old_offset);
@@ -450,7 +450,7 @@ dissect_entry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
        proto_tree_add_boolean(mask_tree, hf_nisplus_entry_mask_asn, tvb, offset, 4, mask);
        offset += 4;
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_nisplus_entry_val, offset, NULL);
 
        proto_item_set_len(lock_item, offset-old_offset);
@@ -469,10 +469,10 @@ dissect_entry_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
 
        lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_entry);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_nisplus_entry_type, offset, NULL);
 
-       offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
                        dissect_entry, hf_nisplus_entry_cols);
 
        proto_item_set_len(lock_item, offset-old_offset);
@@ -491,10 +491,10 @@ dissect_attr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 
        lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_attr);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_nisplus_attr_name, offset, NULL);
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_data(tvb, pinfo, lock_tree, 
                        hf_nisplus_attr_val, offset);
 
        proto_item_set_len(lock_item, offset-old_offset);
@@ -513,13 +513,13 @@ dissect_link_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
 
        lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_link);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_nisplus_object_type, offset);
 
-       offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
                        dissect_attr, hf_nisplus_attrs_array);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree,
                        hf_nisplus_object_name, offset, NULL);
        
        proto_item_set_len(lock_item, offset-old_offset);
@@ -539,13 +539,13 @@ dissect_endpoint(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
 
        lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_endpoint);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_nisplus_endpoint_uaddr, offset, NULL);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_nisplus_endpoint_family, offset, NULL);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_nisplus_endpoint_proto, offset, NULL);
 
        proto_item_set_len(lock_item, offset-old_offset);
@@ -565,16 +565,16 @@ dissect_directory_server(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tr
 
        lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_server);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_nisplus_server_name, offset, NULL);
 
-       offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
                        dissect_endpoint, hf_nisplus_endpoints);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_nisplus_key_type, offset);
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_data(tvb, pinfo, lock_tree, 
                        hf_nisplus_key_data, offset);
 
        proto_item_set_len(lock_item, offset-old_offset);
@@ -596,7 +596,7 @@ dissect_directory_mask(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
 
        offset = dissect_access_rights(tvb, offset, pinfo, lock_tree);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_nisplus_object_type, offset);
 
        proto_item_set_len(lock_item, offset-old_offset);
@@ -615,19 +615,19 @@ dissect_directory_obj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
 
        lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_directory);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree,
                        hf_nisplus_directory_name, offset, NULL);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_nisplus_directory_type, offset);
 
-       offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
                        dissect_directory_server, hf_nisplus_servers);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_nisplus_directory_ttl, offset);
 
-       offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
                        dissect_directory_mask, hf_nisplus_directory_mask_list);
 
        proto_item_set_len(lock_item, offset-old_offset);
@@ -671,25 +671,25 @@ dissect_nisplus_object(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
 
        offset = dissect_nisplus_oid(tvb, offset, pinfo, lock_tree);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree,
                        hf_nisplus_object_name, offset, NULL);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree,
                        hf_nisplus_object_owner, offset, NULL);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree,
                        hf_nisplus_object_group, offset, NULL);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree,
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree,
                        hf_nisplus_object_domain, offset, NULL);
 
        offset = dissect_access_rights(tvb, offset, pinfo, lock_tree);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_nisplus_object_ttl, offset);
 
        type = tvb_get_ntohl(tvb, offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_nisplus_object_type, offset);
        switch (type) {
        case    NIS_DIRECTORY_OBJ:
@@ -708,7 +708,7 @@ dissect_nisplus_object(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
                offset = dissect_link_obj(tvb, offset, pinfo, lock_tree);
                break;
        case    NIS_PRIVATE_OBJ:
-               offset = dissect_rpc_data_tvb(tvb, pinfo, lock_tree, 
+               offset = dissect_rpc_data(tvb, pinfo, lock_tree, 
                                hf_nisplus_object_private, offset);
                break;
        case    NIS_NO_OBJ:
@@ -732,10 +732,10 @@ dissect_nisplus_object(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
 static int
 dissect_ns_request(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_nisplus_object_name, offset, NULL);
        
-       offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, tree, offset,
                        dissect_nisplus_object, hf_nisplus_object);
 
        return offset;
@@ -744,25 +744,25 @@ dissect_ns_request(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
 static int
 dissect_ib_request(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_nisplus_object_name, offset, NULL);
        
-       offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, tree, offset,
                        dissect_attr, hf_nisplus_attrs_array);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_nisplus_ib_flags, offset);
 
-       offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, tree, offset,
                        dissect_nisplus_object, hf_nisplus_object);
 
-       offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, tree, offset,
                        dissect_directory_server, hf_nisplus_cbservers);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_nisplus_ib_bufsize, offset);
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_data(tvb, pinfo, tree, 
                        hf_nisplus_cookie, offset);
 
        return offset;
@@ -771,10 +771,10 @@ dissect_ib_request(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
 static int
 dissect_fd_args(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_nisplus_fd_dirname, offset, NULL);
        
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_nisplus_fd_requester, offset, NULL);
 
        return offset;
@@ -792,10 +792,10 @@ dissect_nisplus_tag(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
 
        lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_tag);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_nisplus_tag_type, offset);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_nisplus_tag_val, offset, NULL);
 
        proto_item_set_len(lock_item, offset-old_offset);
@@ -805,7 +805,7 @@ dissect_nisplus_tag(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
 static int
 dissect_nisplus_taglist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, tree, offset,
                        dissect_nisplus_tag, hf_nisplus_taglist);
 
        return offset;
@@ -814,13 +814,13 @@ dissect_nisplus_taglist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tre
 static int
 dissect_dump_args(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_nisplus_dump_dir, offset, NULL);
 
        offset = dissect_nisplus_time(tvb, offset, pinfo, tree, 
                        hf_nisplus_dump_time);
 
-       offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, tree, offset,
                        dissect_directory_server, hf_nisplus_cbservers);
 
        return offset;
@@ -829,7 +829,7 @@ dissect_dump_args(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
 static int
 dissect_netobj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_data(tvb, pinfo, tree, 
                        hf_nisplus_dummy, offset);
 
        return offset;
@@ -838,7 +838,7 @@ dissect_netobj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 static int
 dissect_nisname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_nisplus_object_name, offset, NULL);
        
        return offset;
@@ -847,7 +847,7 @@ dissect_nisname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 static int
 dissect_ping_args(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_nisplus_ping_dir, offset, NULL);
 
        offset = dissect_nisplus_time(tvb, offset, pinfo, tree, 
@@ -960,25 +960,25 @@ static const value_string nis_error[] = {
 static int
 dissect_nisplus_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_nisplus_error, offset);
 
-       offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, tree, offset,
                        dissect_nisplus_object, hf_nisplus_object);
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_data(tvb, pinfo, tree, 
                        hf_nisplus_cookie, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_nisplus_zticks, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_nisplus_dticks, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_nisplus_aticks, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_nisplus_cticks, offset);
 
        return offset;
@@ -987,16 +987,16 @@ dissect_nisplus_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
 static int
 dissect_fd_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_nisplus_error, offset);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_nisplus_fd_dirname, offset, NULL);
        
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_data(tvb, pinfo, tree, 
                        hf_nisplus_dir_data, offset);
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_data(tvb, pinfo, tree, 
                        hf_nisplus_signature, offset);
 
        return offset;
@@ -1038,16 +1038,16 @@ dissect_log_entry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
        offset = dissect_nisplus_time(tvb, offset, pinfo, lock_tree, 
                        hf_nisplus_log_time);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_nisplus_log_type, offset);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_nisplus_log_principal, offset, NULL);
        
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_nisplus_directory_name, offset, NULL);
 
-       offset = dissect_rpc_array_tvb(tvb, pinfo, lock_tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
                        dissect_attr, hf_nisplus_attrs_array);
 
        offset = dissect_nisplus_object(tvb, offset, pinfo, lock_tree);
@@ -1059,13 +1059,13 @@ dissect_log_entry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
 static int
 dissect_log_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_nisplus_error, offset);
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_data(tvb, pinfo, tree, 
                        hf_nisplus_cookie, offset);
 
-       offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, tree, offset,
                        dissect_log_entry, hf_nisplus_log_entries);
 
        return offset;
@@ -1074,7 +1074,7 @@ dissect_log_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
 static int
 dissect_callback_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nisplus_callback_status,
+       offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nisplus_callback_status,
                        offset);
 
        return offset;
@@ -1092,13 +1092,13 @@ dissect_change_time(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
 static int
 dissect_cp_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_nisplus_cp_status, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_nisplus_cp_zticks, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_nisplus_cp_dticks, offset);
 
        return offset;
@@ -1107,7 +1107,7 @@ dissect_cp_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
 static int
 dissect_nisplus_error(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_nisplus_error, offset);
 
        return offset;
@@ -1867,7 +1867,7 @@ dissect_cb_entry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
 static int
 dissect_cback_data(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_array_tvb(tvb, pinfo, tree, offset,
+       offset = dissect_rpc_array(tvb, pinfo, tree, offset,
                        dissect_cb_entry, hf_nispluscb_entries);
 
        return offset;
index 00b5fa40a833dee98311753fd594284c0297a328..d3fd61666af6bbbede3d7e08bb201e2594cc88c6 100644 (file)
@@ -1,10 +1,10 @@
 /* packet-nlm.c
  * Routines for nlm dissection
  *
- * $Id: packet-nlm.c,v 1.16 2001/05/23 19:29:45 guy Exp $
+ * $Id: packet-nlm.c,v 1.17 2001/05/30 06:01:02 guy Exp $
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * Copied from packet-mount.c
@@ -162,21 +162,21 @@ dissect_lock(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int version, i
                        lock_tree = proto_item_add_subtree(lock_item, ett_nlm_lock);
        }
 
-       offset = dissect_rpc_string_tvb(tvb,pinfo,lock_tree,
+       offset = dissect_rpc_string(tvb,pinfo,lock_tree,
                        hf_nlm_lock_caller_name, offset, NULL);
        offset = dissect_nfs_fh3(tvb, offset, pinfo, lock_tree,"fh");
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_owner, offset);
+       offset = dissect_rpc_data(tvb, pinfo, lock_tree, hf_nlm_lock_owner, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_svid, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_lock_svid, offset);
 
        if (version == 4) {
-               offset = dissect_rpc_uint64_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_l_offset, offset);
-               offset = dissect_rpc_uint64_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_l_len, offset);
+               offset = dissect_rpc_uint64(tvb, pinfo, lock_tree, hf_nlm_lock_l_offset, offset);
+               offset = dissect_rpc_uint64(tvb, pinfo, lock_tree, hf_nlm_lock_l_len, offset);
        }
        else {
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_l_offset, offset);
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_l_len, offset);
+               offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_lock_l_offset, offset);
+               offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_lock_l_len, offset);
        }
 
        return offset;
@@ -187,8 +187,8 @@ static int
 dissect_nlm_test(tvbuff_t *tvb, int offset, packet_info *pinfo,
     proto_tree *tree, int version)
 {
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
-       dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_exclusive, offset);
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
+       dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_exclusive, offset);
        offset += 4;
        offset = dissect_lock(tvb, pinfo, tree, version, offset);
        return offset;
@@ -198,12 +198,12 @@ static int
 dissect_nlm_lock(tvbuff_t *tvb, int offset, packet_info *pinfo,
     proto_tree *tree,int version)
 {
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
-       offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_block, offset);
-       offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_exclusive, offset);
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
+       offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_block, offset);
+       offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_exclusive, offset);
        offset = dissect_lock(tvb, pinfo, tree, version, offset);
-       offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_reclaim, offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nlm_state, offset);
+       offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_reclaim, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_state, offset);
        return offset;
 }
 
@@ -211,9 +211,9 @@ static int
 dissect_nlm_cancel(tvbuff_t *tvb, int offset, packet_info *pinfo,
     proto_tree *tree,int version)
 {
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
-       offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_block, offset);
-       offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_exclusive, offset);
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
+       offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_block, offset);
+       offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_exclusive, offset);
        offset = dissect_lock(tvb, pinfo, tree, version, offset);
        return offset;
 }
@@ -222,7 +222,7 @@ static int
 dissect_nlm_unlock(tvbuff_t *tvb, int offset, packet_info *pinfo,
     proto_tree *tree,int version)
 {
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
        offset = dissect_lock(tvb, pinfo, tree, version, offset);
        return offset;
 }
@@ -231,8 +231,8 @@ static int
 dissect_nlm_granted(tvbuff_t *tvb, int offset, packet_info *pinfo,
     proto_tree *tree,int version)
 {
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
-       offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_exclusive, offset);
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
+       offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_exclusive, offset);
        offset = dissect_lock(tvb, pinfo, tree, version, offset);
        return offset;
 }
@@ -245,7 +245,7 @@ dissect_nlm_test_res(tvbuff_t *tvb, int offset, packet_info *pinfo,
        proto_item* lock_item = NULL;
        proto_tree* lock_tree = NULL;
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
 
        if (tree) {
                lock_item = proto_tree_add_item(tree, hf_nlm_test_stat, tvb,
@@ -257,7 +257,7 @@ dissect_nlm_test_res(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                ett_nlm_lock);
        }
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_test_stat_stat,
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_test_stat_stat,
            offset);
 
        /* last structure is optional, only supplied for stat==1 (LOCKED) */
@@ -275,23 +275,23 @@ dissect_nlm_test_res(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                ett_nlm_lock);
        }
 
-       offset = dissect_rpc_bool_tvb(tvb, pinfo, lock_tree, hf_nlm_exclusive,
+       offset = dissect_rpc_bool(tvb, pinfo, lock_tree, hf_nlm_exclusive,
            offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_svid,
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_lock_svid,
            offset);
-       offset = dissect_rpc_data_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_owner,
+       offset = dissect_rpc_data(tvb, pinfo, lock_tree, hf_nlm_lock_owner,
            offset);
 
        if (version == 4) {
-               offset = dissect_rpc_uint64_tvb(tvb, pinfo, lock_tree,
+               offset = dissect_rpc_uint64(tvb, pinfo, lock_tree,
                    hf_nlm_lock_l_offset, offset);
-               offset = dissect_rpc_uint64_tvb(tvb, pinfo, lock_tree,
+               offset = dissect_rpc_uint64(tvb, pinfo, lock_tree,
                    hf_nlm_lock_l_len, offset);
        }
        else {
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
+               offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
                    hf_nlm_lock_l_offset, offset);
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
+               offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
                    hf_nlm_lock_l_len, offset);
        }
 
@@ -306,7 +306,7 @@ dissect_nlm_share(tvbuff_t *tvb, int offset, packet_info *pinfo,
        proto_item* lock_item = NULL;
        proto_tree* lock_tree = NULL;
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
 
        if (tree) {
                lock_item = proto_tree_add_item(tree, hf_nlm_share, tvb,
@@ -318,18 +318,18 @@ dissect_nlm_share(tvbuff_t *tvb, int offset, packet_info *pinfo,
                                ett_nlm_lock);
        }
 
-       offset = dissect_rpc_string_tvb(tvb,pinfo,lock_tree,
+       offset = dissect_rpc_string(tvb,pinfo,lock_tree,
                        hf_nlm_lock_caller_name, offset, NULL);
        
        offset = dissect_nfs_fh3(tvb, offset, pinfo, lock_tree, "fh");
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, lock_tree, hf_nlm_lock_owner, offset);
+       offset = dissect_rpc_data(tvb, pinfo, lock_tree, hf_nlm_lock_owner, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_share_mode, offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_nlm_share_access, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_share_mode, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_share_access, offset);
 
 
-       offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_nlm_reclaim, offset);
+       offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_reclaim, offset);
        return offset;
 }
 
@@ -337,9 +337,9 @@ static int
 dissect_nlm_shareres(tvbuff_t *tvb, int offset, packet_info *pinfo,
     proto_tree *tree, int version)
 {
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nlm_state, offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nlm_sequence, offset);
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_state, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_sequence, offset);
        return offset;
 }
 
@@ -347,10 +347,10 @@ static int
 dissect_nlm_freeall(tvbuff_t *tvb, int offset, packet_info *pinfo,
     proto_tree *tree,int version)
 {
-       offset = dissect_rpc_string_tvb(tvb,pinfo,tree,
+       offset = dissect_rpc_string(tvb,pinfo,tree,
                        hf_nlm_share_name, offset, NULL);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nlm_state, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_state, offset);
 
        return offset;
 }
@@ -364,8 +364,8 @@ static int
 dissect_nlm_gen_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
     proto_tree *tree)
 {
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_nlm_cookie, offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_nlm_state, offset);
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_state, offset);
        return offset;
 }
 
index 2aa5f45fb395d3f2ccd73a6e317304ee2a688965..57e8c4ebd186a04d66bcee27ad90693b0ab44858 100644 (file)
@@ -1,10 +1,10 @@
 /* packet-portmap.c
  * Routines for portmap dissection
  *
- * $Id: packet-portmap.c,v 1.29 2001/04/17 06:29:12 guy Exp $
+ * $Id: packet-portmap.c,v 1.30 2001/05/30 06:01:02 guy Exp $
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * Copied from packet-smb.c
@@ -97,7 +97,7 @@ int dissect_getport_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
 int dissect_getport_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
        proto_tree *tree)
 {
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_portmap_port,
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_portmap_port,
            offset);
        return offset;
 }
@@ -159,7 +159,7 @@ int dissect_unset_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
 int dissect_set_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
        proto_tree *tree)
 {
-       offset = dissect_rpc_bool_tvb(tvb, pinfo, tree, hf_portmap_answer,
+       offset = dissect_rpc_bool(tvb, pinfo, tree, hf_portmap_answer,
            offset);
        return offset;
 }
@@ -200,7 +200,7 @@ dissect_dump_entry(tvbuff_t *tvb, int offset, packet_info *pinfo,
 int dissect_dump_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
        proto_tree *tree)
 {
-       offset = dissect_rpc_list_tvb(tvb, pinfo, tree, offset,
+       offset = dissect_rpc_list(tvb, pinfo, tree, offset,
                dissect_dump_entry);
        return offset;
 }
@@ -322,13 +322,13 @@ dissect_rpcb(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
                        "Program: %s (%u)", rpc_prog_name(prog), prog);
        offset += 4;
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, rpcb_tree,
+       offset = dissect_rpc_uint32(tvb, pinfo, rpcb_tree,
            hf_portmap_rpcb_version, offset);
-       offset = dissect_rpc_string_tvb(tvb, pinfo, rpcb_tree,
+       offset = dissect_rpc_string(tvb, pinfo, rpcb_tree,
            hf_portmap_rpcb_netid, offset, NULL);
-       offset = dissect_rpc_string_tvb(tvb, pinfo, rpcb_tree,
+       offset = dissect_rpc_string(tvb, pinfo, rpcb_tree,
            hf_portmap_rpcb_addr, offset, NULL);
-       offset = dissect_rpc_string_tvb(tvb, pinfo, rpcb_tree,
+       offset = dissect_rpc_string(tvb, pinfo, rpcb_tree,
            hf_portmap_rpcb_owner, offset, NULL);
 
        /* now we know, that rpcb is shorter */
@@ -355,7 +355,7 @@ int dissect_rpcb3_getaddr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
 int dissect_rpcb3_getaddr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
        proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
+       offset = dissect_rpc_string(tvb, pinfo, tree,
            hf_portmap_uaddr, offset, NULL);
 
        return offset;
@@ -366,7 +366,7 @@ int dissect_rpcb3_getaddr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
 int dissect_rpcb3_dump_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
        proto_tree *tree)
 {
-       offset = dissect_rpc_list_tvb(tvb, pinfo, tree, offset, dissect_rpcb);
+       offset = dissect_rpc_list(tvb, pinfo, tree, offset, dissect_rpcb);
        return offset;
 }
 
@@ -375,7 +375,7 @@ int dissect_rpcb_rmtcallres(tvbuff_t *tvb, int offset, packet_info *pinfo,
        proto_tree *tree)
 {
        /* Dissect the remote universal address. */
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
+       offset = dissect_rpc_string(tvb, pinfo, tree,
            hf_portmap_rpcb_addr, offset, NULL);
 
        /* Dissect the result of this procedure.
index 73b1264bef6df16171134ba9370498a175094e17..6c75d5ad2d7e10451233b32bf4345447431b4856 100644 (file)
@@ -2,10 +2,10 @@
  * Routines for rpc dissection
  * Copyright 1999, Uwe Girlich <Uwe.Girlich@philosys.de>
  * 
- * $Id: packet-rpc.c,v 1.60 2001/05/27 09:15:14 guy Exp $
+ * $Id: packet-rpc.c,v 1.61 2001/05/30 06:01:02 guy Exp $
  * 
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  * 
  * Copied from packet-smb.c
@@ -203,15 +203,8 @@ typedef struct _rpc_proc_info_key {
 
 typedef struct _rpc_proc_info_value {
        gchar           *name;
-       gboolean        is_old_dissector;
-       union {
-               old_dissect_function_t *old;
-               dissect_function_t *new;
-       } dissect_call;
-       union {
-               old_dissect_function_t *old;
-               dissect_function_t *new;
-       } dissect_reply;
+       dissect_function_t *dissect_call;
+       dissect_function_t *dissect_reply;
 } rpc_proc_info_value;
 
 typedef struct _rpc_prog_info_key {
@@ -253,30 +246,6 @@ rpc_proc_hash(gconstpointer k)
 
 
 /* insert some entries */
-void
-old_rpc_init_proc_table(guint prog, guint vers, const old_vsff *proc_table)
-{
-       const old_vsff *proc;
-
-       for (proc = proc_table ; proc->strptr!=NULL; proc++) {
-               rpc_proc_info_key *key;
-               rpc_proc_info_value *value;
-
-               key = (rpc_proc_info_key *) g_malloc(sizeof(rpc_proc_info_key));
-               key->prog = prog;
-               key->vers = vers;
-               key->proc = proc->value;
-
-               value = (rpc_proc_info_value *) g_malloc(sizeof(rpc_proc_info_value));
-               value->name = proc->strptr;
-               value->is_old_dissector = TRUE;
-               value->dissect_call.old = proc->dissect_call;
-               value->dissect_reply.old = proc->dissect_reply;
-
-               g_hash_table_insert(rpc_procs,key,value);
-       }
-}
-
 void
 rpc_init_proc_table(guint prog, guint vers, const vsff *proc_table)
 {
@@ -293,9 +262,8 @@ rpc_init_proc_table(guint prog, guint vers, const vsff *proc_table)
 
                value = (rpc_proc_info_value *) g_malloc(sizeof(rpc_proc_info_value));
                value->name = proc->strptr;
-               value->is_old_dissector = FALSE;
-               value->dissect_call.new = proc->dissect_call;
-               value->dissect_reply.new = proc->dissect_reply;
+               value->dissect_call = proc->dissect_call;
+               value->dissect_reply = proc->dissect_reply;
 
                g_hash_table_insert(rpc_procs,key,value);
        }
@@ -452,23 +420,7 @@ rpc_roundup(unsigned int a)
 
 
 int
-dissect_rpc_bool(const u_char *pd, int offset, frame_data *fd, proto_tree *tree,
-int hfindex)
-{
-       guint32 value;
-
-       if (!BYTES_ARE_IN_FRAME(offset,4)) return offset;
-       value = EXTRACT_UINT(pd, offset+0);
-       if (tree)
-               proto_tree_add_boolean(tree, hfindex, NullTVB, offset, 4, value);
-       offset += 4;
-
-       return offset;
-}
-
-
-int
-dissect_rpc_bool_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_bool(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 int hfindex, int offset)
 {
        if (tree)
@@ -478,26 +430,7 @@ int hfindex, int offset)
 
 
 int
-dissect_rpc_uint32(const u_char *pd, int offset, frame_data *fd, proto_tree *tree,
-char* name)
-{
-       guint32 value;
-
-       if (!BYTES_ARE_IN_FRAME(offset,4)) return offset;
-       value = EXTRACT_UINT(pd, offset+0);
-
-       if (tree) {
-               proto_tree_add_text(tree, NullTVB, offset, 4,
-               "%s: %u", name, value);
-       }
-
-       offset += 4;
-       return offset;
-}
-
-
-int
-dissect_rpc_uint32_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_uint32(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 int hfindex, int offset)
 {
        if (tree)
@@ -507,32 +440,7 @@ int hfindex, int offset)
 
 
 int
-dissect_rpc_uint64(const u_char *pd, int offset, frame_data *fd, proto_tree *tree,
-char* name)
-{
-       guint32 value_low;
-       guint32 value_high;
-
-       if (!BYTES_ARE_IN_FRAME(offset,8)) return offset;
-       value_high = EXTRACT_UINT(pd, offset+0);
-       value_low = EXTRACT_UINT(pd, offset+4);
-
-       if (tree) {
-               if (value_high)
-                       proto_tree_add_text(tree, NullTVB, offset, 8,
-                               "%s: 0x%x%08x", name, value_high, value_low);
-               else
-                       proto_tree_add_text(tree, NullTVB, offset, 8,
-                               "%s: %u", name, value_low);
-       }
-
-       offset += 8;
-       return offset;
-}
-
-
-int
-dissect_rpc_uint64_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_uint64(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 int hfindex, int offset)
 {
        guint32 value_low;
@@ -723,19 +631,7 @@ dissect_rpc_opaque_data(tvbuff_t *tvb, int offset, packet_info *pinfo,
 
 
 int
-dissect_rpc_string(const u_char *pd, int offset, frame_data *fd,
-    proto_tree *tree, int hfindex, char **string_buffer_ret)
-{
-       tvbuff_t *tvb = tvb_create_from_top(offset);
-
-       offset = dissect_rpc_string_tvb(tvb, &pi, tree, hfindex, 0,
-           string_buffer_ret);
-       return tvb_raw_offset(tvb) + offset;
-}
-
-
-int
-dissect_rpc_string_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_string(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
     int hfindex, int offset, char **string_buffer_ret)
 {
        offset = dissect_rpc_opaque_data(tvb, offset, pinfo, tree,
@@ -745,19 +641,7 @@ dissect_rpc_string_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 
 
 int
-dissect_rpc_data(const u_char *pd, int offset, frame_data *fd,
-    proto_tree *tree, int hfindex)
-{
-       tvbuff_t *tvb = tvb_create_from_top(offset);
-
-       offset = dissect_rpc_data_tvb(tvb, &pi, tree, hfindex, 0);
-
-       return tvb_raw_offset(tvb) + offset;
-}
-
-
-int
-dissect_rpc_data_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
     int hfindex, int offset)
 {
        offset = dissect_rpc_opaque_data(tvb, offset, pinfo, tree, hfindex,
@@ -768,30 +652,7 @@ dissect_rpc_data_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 
 
 int
-dissect_rpc_list(const u_char *pd, int offset, frame_data *fd,
-       proto_tree *tree, old_dissect_function_t *rpc_list_dissector)
-{
-       guint32 value_follows;
-
-       while (1) {
-               if (!BYTES_ARE_IN_FRAME(offset,4)) break;
-               value_follows = EXTRACT_UINT(pd, offset+0);
-               proto_tree_add_boolean(tree,hf_rpc_value_follows, NullTVB,
-                       offset+0, 4, value_follows);
-               offset += 4;
-               if (value_follows == 1) {
-                       offset = rpc_list_dissector(pd, offset, fd, tree);
-               }
-               else {
-                       break;
-               }
-       }
-
-       return offset;
-}
-
-int
-dissect_rpc_list_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_list(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
        int offset, dissect_function_t *rpc_list_dissector)
 {
        guint32 value_follows;
@@ -813,7 +674,7 @@ dissect_rpc_list_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 }
 
 int
-dissect_rpc_array_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_array(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
        int offset, dissect_function_t *rpc_array_dissector,
        int hfindex)
 {
@@ -837,7 +698,7 @@ dissect_rpc_array_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 
        lock_tree = proto_item_add_subtree(lock_item, ett_rpc_array);   
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree,
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
                        hf_rpc_array_len, offset);
 
        while (num--) {
@@ -867,7 +728,7 @@ dissect_rpc_authunix_cred(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, i
                        offset+0, 4, stamp);
        offset += 4;
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree,
+       offset = dissect_rpc_string(tvb, pinfo, tree,
                        hf_rpc_auth_machinename, offset, NULL);
 
        if (!tvb_bytes_exist(tvb,offset,4)) return offset;
@@ -943,14 +804,14 @@ dissect_rpc_authgss_cred(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, in
                                    tvb, offset+0, 4, agc_svc);
        offset += 4;
        
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_rpc_authgss_ctx,
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_ctx,
                        offset);
        
        return offset;
 }
 
 int
-dissect_rpc_authdes_desblock_tvb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_authdes_desblock(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 int hfindex, int offset)
 {
        guint32 value_low;
@@ -986,9 +847,9 @@ dissect_rpc_authdes_cred(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, in
        switch(adc_namekind)
        {
        case AUTHDES_NAMEKIND_FULLNAME:
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+               offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_rpc_authdes_netname, offset, NULL);
-               offset = dissect_rpc_authdes_desblock_tvb(tvb, pinfo, tree,
+               offset = dissect_rpc_authdes_desblock(tvb, pinfo, tree,
                        hf_rpc_authdes_convkey, offset);
                window = tvb_get_ntohl(tvb, offset+0);
                proto_tree_add_uint(tree, hf_rpc_authdes_window, tvb, offset+0, 4,
@@ -1098,7 +959,7 @@ dissect_rpc_verf(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset
                        {
                                guint window;
 
-                               dissect_rpc_authdes_desblock_tvb(tvb, pinfo, vtree,
+                               dissect_rpc_authdes_desblock(tvb, pinfo, vtree,
                                        hf_rpc_authdes_timestamp, offset+8);
                                window = tvb_get_ntohl(tvb, offset+16);
                                proto_tree_add_uint(vtree, hf_rpc_authdes_windowverf, tvb, 
@@ -1109,7 +970,7 @@ dissect_rpc_verf(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset
                                /* must be an RPC_REPLY */
                                guint nickname;
 
-                               dissect_rpc_authdes_desblock_tvb(tvb, pinfo, vtree,
+                               dissect_rpc_authdes_desblock(tvb, pinfo, vtree,
                                        hf_rpc_authdes_timeverf, offset+8);
                                nickname = tvb_get_ntohl(tvb, offset+16);
                                proto_tree_add_uint(vtree, hf_rpc_authdes_nickname, tvb, 
@@ -1117,7 +978,7 @@ dissect_rpc_verf(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset
                        }
                        break;
                case RPCSEC_GSS:
-                       dissect_rpc_data_tvb(tvb, pinfo, vtree,
+                       dissect_rpc_data(tvb, pinfo, vtree,
                                hf_rpc_authgss_checksum, offset+4);
                        break;
                default:
@@ -1137,7 +998,7 @@ dissect_rpc_verf(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset
 static int
 dissect_rpc_authgss_initarg(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset)
 {
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_rpc_authgss_token,
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_token,
                        offset);
        return offset;
 }
@@ -1147,7 +1008,7 @@ dissect_rpc_authgss_initres(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree,
 {
        int major, minor, window;
        
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_rpc_authgss_ctx,
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_ctx,
                        offset);
        
        if (!tvb_bytes_exist(tvb,offset,4)) return offset;
@@ -1171,7 +1032,7 @@ dissect_rpc_authgss_initres(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree,
                                    offset+0, 4, window);
        offset += 4;
 
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_rpc_authgss_token,
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_token,
                        offset);
 
        return offset;
@@ -1180,32 +1041,18 @@ dissect_rpc_authgss_initres(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree,
 
 static int
 call_dissect_function(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-       int offset, old_dissect_function_t *old_dissect_function,
-       dissect_function_t* dissect_function, const char *progname)
+       int offset, dissect_function_t* dissect_function, const char *progname)
 {
        const char *saved_proto;
 
-       if (old_dissect_function != NULL || dissect_function != NULL) {
+       if (dissect_function != NULL) {
                /* set the current protocol name */
                saved_proto = pinfo->current_proto;
                if (progname != NULL)
                        pinfo->current_proto = progname;
 
                /* call the dissector for the next level */
-               if (dissect_function == NULL) {
-                       const guint8 *tvb_pd;
-                       int tvb_offset;
-
-                       /*
-                        * It's an old-style dissector.
-                        * Make a pd, offset pair.
-                        */
-                       tvb_compat(tvb, &tvb_pd, &tvb_offset);
-
-                       offset = old_dissect_function(tvb_pd,
-                           tvb_offset + offset, pinfo->fd, tree) - tvb_offset;
-               } else
-                       offset = dissect_function(tvb, offset, pinfo, tree);
+               offset = dissect_function(tvb, offset, pinfo, tree);
 
                /* restore the protocol name */
                pinfo->current_proto = saved_proto;
@@ -1218,7 +1065,6 @@ call_dissect_function(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 static int
 dissect_rpc_authgss_integ_data(tvbuff_t *tvb, packet_info *pinfo,
        proto_tree *tree, int offset,
-       old_dissect_function_t *old_dissect_function,
        dissect_function_t* dissect_function,
        const char *progname)
 {
@@ -1227,7 +1073,6 @@ dissect_rpc_authgss_integ_data(tvbuff_t *tvb, packet_info *pinfo,
        proto_item *gitem;
        proto_tree *gtree = NULL;
 
-       if (!tvb_bytes_exist(tvb, offset, 8)) return offset;
        length = tvb_get_ntohl(tvb, offset+0);
        length = rpc_roundup(length);
        seq = tvb_get_ntohl(tvb, offset+4);
@@ -1241,14 +1086,13 @@ dissect_rpc_authgss_integ_data(tvbuff_t *tvb, packet_info *pinfo,
                proto_tree_add_uint(gtree, hf_rpc_authgss_seq,
                                    tvb, offset+4, 4, seq);
        }
-       if (old_dissect_function != NULL || dissect_function != NULL) {
+       if (dissect_function != NULL) {
                /* offset = */
                call_dissect_function(tvb, pinfo, gtree, offset,
-                                     old_dissect_function, dissect_function,
-                                     progname);
+                                     dissect_function, progname);
        }
        offset += 8 + length;
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_rpc_authgss_checksum,
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_checksum,
                        offset);
        return offset;
 }
@@ -1257,7 +1101,7 @@ dissect_rpc_authgss_integ_data(tvbuff_t *tvb, packet_info *pinfo,
 static int
 dissect_rpc_authgss_priv_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)
 {
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, hf_rpc_authgss_data,
+       offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_data,
                        offset);
        return offset;
 }
@@ -1280,17 +1124,13 @@ dissect_rpc_indir_call(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
        rpc_call_info_value *rpc_call;
        rpc_call_info_key rpc_call_key;
        rpc_call_info_key *new_rpc_call_key;
-       old_dissect_function_t *old_dissect_function = NULL;
        dissect_function_t *dissect_function = NULL;
 
        key.prog = prog;
        key.vers = vers;
        key.proc = proc;
        if ((value = g_hash_table_lookup(rpc_procs,&key)) != NULL) {
-               if (value->is_old_dissector)
-                       old_dissect_function = value->dissect_call.old;
-               else
-                       dissect_function = value->dissect_call.new;
+               dissect_function = value->dissect_call;
 
                /* Keep track of the address and port whence the call came,
                   and the port to which the call is being sent, so that
@@ -1351,7 +1191,7 @@ dissect_rpc_indir_call(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                   Happens only with strange program versions or
                   non-existing dissectors.
                   Just show the arguments as opaque data. */
-               offset = dissect_rpc_data_tvb(tvb, pinfo, tree, args_id,
+               offset = dissect_rpc_data(tvb, pinfo, tree, args_id,
                    offset);
                return offset;
        }
@@ -1366,7 +1206,7 @@ dissect_rpc_indir_call(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 
        /* Dissect the arguments */
        offset = call_dissect_function(tvb, pinfo, tree, offset,
-                       old_dissect_function, dissect_function, NULL);
+                       dissect_function, NULL);
        return offset;
 }
 
@@ -1384,7 +1224,6 @@ dissect_rpc_indir_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
        rpc_call_info_value *rpc_call;
        char *procname = NULL;
        char procname_static[20];
-       old_dissect_function_t *old_dissect_function = NULL;
        dissect_function_t *dissect_function = NULL;
 
        /* Look for the matching call in the hash table of indirect
@@ -1401,7 +1240,7 @@ dissect_rpc_indir_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                /* We haven't seen an RPC call for that conversation,
                   so we can't check for a reply to that call.
                   Just show the reply stuff as opaque data. */
-               offset = dissect_rpc_data_tvb(tvb, pinfo, tree, result_id,
+               offset = dissect_rpc_data(tvb, pinfo, tree, result_id,
                    offset);
                return offset;
        }
@@ -1414,16 +1253,13 @@ dissect_rpc_indir_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                /* The XID doesn't match a call from that
                   conversation, so it's probably not an RPC reply.
                   Just show the reply stuff as opaque data. */
-               offset = dissect_rpc_data_tvb(tvb, pinfo, tree, result_id,
+               offset = dissect_rpc_data(tvb, pinfo, tree, result_id,
                    offset);
                return offset;
        }
 
        if (rpc_call->proc_info != NULL) {
-               if (rpc_call->proc_info->is_old_dissector)
-                       old_dissect_function = rpc_call->proc_info->dissect_reply.old;
-               else
-                       dissect_function = rpc_call->proc_info->dissect_reply.new;
+               dissect_function = rpc_call->proc_info->dissect_reply;
                if (rpc_call->proc_info->name != NULL) {
                        procname = rpc_call->proc_info->name;
                }
@@ -1452,10 +1288,10 @@ dissect_rpc_indir_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
                        procname, rpc_call->proc);
        }
 
-       if (old_dissect_function == NULL && dissect_function == NULL) {
+       if (dissect_function == NULL) {
                /* We don't know how to dissect the reply procedure.
                   Just show the reply stuff as opaque data. */
-               offset = dissect_rpc_data_tvb(tvb, pinfo, tree, result_id,
+               offset = dissect_rpc_data(tvb, pinfo, tree, result_id,
                    offset);
                return offset;
        }
@@ -1470,7 +1306,7 @@ dissect_rpc_indir_reply(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 
        /* Dissect the return value */
        offset = call_dissect_function(tvb, pinfo, tree, offset,
-                       old_dissect_function, dissect_function, NULL);
+                       dissect_function, NULL);
        return offset;
 }
 
@@ -1525,7 +1361,6 @@ dissect_rpc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
        conversation_t* conversation;
        static address null_address = { AT_NONE, 0, NULL };
 
-       old_dissect_function_t *old_dissect_function = NULL;
        dissect_function_t *dissect_function = NULL;
 
        /* TCP uses record marking */
@@ -1697,10 +1532,7 @@ dissect_rpc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
                key.proc = proc;
 
                if ((value = g_hash_table_lookup(rpc_procs,&key)) != NULL) {
-                       if (value->is_old_dissector)
-                               old_dissect_function = value->dissect_call.old;
-                       else
-                               dissect_function = value->dissect_call.new;
+                       dissect_function = value->dissect_call;
                        procname = value->name;
                }
                else {
@@ -1817,10 +1649,7 @@ dissect_rpc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
                    rpc_call->req_num);
 
                if (rpc_call->proc_info != NULL) {
-                       if (rpc_call->proc_info->is_old_dissector)
-                               old_dissect_function = rpc_call->proc_info->dissect_reply.old;
-                       else
-                               dissect_function = rpc_call->proc_info->dissect_reply.new;
+                       dissect_function = rpc_call->proc_info->dissect_reply;
                        if (rpc_call->proc_info->name != NULL) {
                                procname = rpc_call->proc_info->name;
                        }
@@ -2002,17 +1831,15 @@ dissect_rpc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 
                if (ptree) {
                        proto_tree_add_uint(ptree,
-                               hf_rpc_programversion, NullTVB, 0, 0, vers);
+                               hf_rpc_programversion, tvb, 0, 0, vers);
                        proto_tree_add_uint_format(ptree,
-                               hf_rpc_procedure, NullTVB, 0, 0, proc,
+                               hf_rpc_procedure, tvb, 0, 0, proc,
                                "Procedure: %s (%u)", procname, proc);
                }
        }
 
-       if (!proto_is_protocol_enabled(proto)) {
-               old_dissect_function = NULL;
+       if (!proto_is_protocol_enabled(proto))
                dissect_function = NULL;
-       }
 
        /* RPCSEC_GSS processing. */
        if (flavor == RPCSEC_GSS) {
@@ -2032,14 +1859,12 @@ dissect_rpc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
                        if (gss_svc == RPCSEC_GSS_SVC_NONE) {
                                offset = call_dissect_function(tvb, 
                                                pinfo, ptree, offset,
-                                               old_dissect_function,
                                                dissect_function,
                                                progname);
                        }
                        else if (gss_svc == RPCSEC_GSS_SVC_INTEGRITY) {
                                offset = dissect_rpc_authgss_integ_data(tvb,
                                                pinfo, ptree, offset,
-                                               old_dissect_function,
                                                dissect_function,
                                                progname);
                        }
@@ -2054,7 +1879,7 @@ dissect_rpc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
        }
        else {
                offset=call_dissect_function(tvb, pinfo, ptree, offset,
-                               old_dissect_function, dissect_function, progname);
+                               dissect_function, progname);
        }
 
        /* dissect any remaining bytes (incomplete dissection) as pure data in
index d4e4ae6f61ea9aa5932c16b3998dd19d7a644ce3..a3ff56ecc6b628ae3505b62301a9e4226905b264 100644 (file)
@@ -1,11 +1,11 @@
 /* packet-rpc.h
  *
- * $Id: packet-rpc.h,v 1.28 2001/05/25 20:13:04 guy Exp $
+ * $Id: packet-rpc.h,v 1.29 2001/05/30 06:01:02 guy Exp $
  *
  * (c) 1999 Uwe Girlich
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * 
@@ -100,32 +100,20 @@ extern char *rpc_prog_name(guint32 prog);
 extern char *rpc_proc_name(guint32 prog, guint32 vers, guint32 proc);
 
 extern unsigned int rpc_roundup(unsigned int a);
-extern int dissect_rpc_bool(const u_char *pd, int offset, frame_data *fd,
-       proto_tree *tree, int hfindex);
-extern int dissect_rpc_bool_tvb(tvbuff_t *tvb, packet_info *pinfo,
+extern int dissect_rpc_bool(tvbuff_t *tvb, packet_info *pinfo,
        proto_tree *tree, int hfindex, int offset);
-extern int dissect_rpc_string(const u_char *pd, int offset, frame_data *fd,
-       proto_tree *tree, int hfindex, char **string_buffer_ret);
-extern int dissect_rpc_string_tvb(tvbuff_t *tvb, packet_info *pinfo,
+extern int dissect_rpc_string(tvbuff_t *tvb, packet_info *pinfo,
        proto_tree *tree, int hfindex, int offset, char **string_buffer_ret);
-extern int dissect_rpc_data(const u_char *pd, int offset, frame_data *fd,
-       proto_tree *tree, int hfindex);
-extern int dissect_rpc_data_tvb(tvbuff_t *tvb, packet_info *pinfo,
+extern int dissect_rpc_data(tvbuff_t *tvb, packet_info *pinfo,
        proto_tree *tree, int hfindex, int offset);
-extern int dissect_rpc_list(const u_char *pd, int offset, frame_data *fd,
-       proto_tree *tree, old_dissect_function_t *rpc_list_dissector);
-extern int dissect_rpc_list_tvb(tvbuff_t *tvb, packet_info *pinfo,
+extern int dissect_rpc_list(tvbuff_t *tvb, packet_info *pinfo,
        proto_tree *tree, int offset, dissect_function_t *rpc_list_dissector);
-extern int dissect_rpc_array_tvb(tvbuff_t *tvb, packet_info *pinfo,
+extern int dissect_rpc_array(tvbuff_t *tvb, packet_info *pinfo,
        proto_tree *tree, int offset, dissect_function_t *rpc_array_dissector,
        int hfindex);
-extern int dissect_rpc_uint32(const u_char *pd, int offset, frame_data *fd,
-       proto_tree *tree, char* name);
-extern int dissect_rpc_uint32_tvb(tvbuff_t *tvb, packet_info *pinfo,
+extern int dissect_rpc_uint32(tvbuff_t *tvb, packet_info *pinfo,
        proto_tree *tree, int hfindex, int offset);
-extern int dissect_rpc_uint64(const u_char *pd, int offset, frame_data *fd,
-       proto_tree *tree, char* name);
-extern int dissect_rpc_uint64_tvb(tvbuff_t *tvb, packet_info *pinfo,
+extern int dissect_rpc_uint64(tvbuff_t *tvb, packet_info *pinfo,
        proto_tree *tree, int hfindex, int offset);
 
 extern int dissect_rpc_indir_call(tvbuff_t *tvb, packet_info *pinfo,
index 97c2810360b57348e7e4b9added24e9da5ef2ad0..fd2430e3b0abf87114201d9d7b69149001d6b9f6 100644 (file)
@@ -2,10 +2,10 @@
  * Routines for rquota dissection
  * Copyright 2001, Mike Frisch <frisch@hummingbird.com>
  *
- * $Id: packet-rquota.c,v 1.2 2001/04/21 08:00:12 guy Exp $
+ * $Id: packet-rquota.c,v 1.3 2001/05/30 06:01:02 guy Exp $
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * Copied from packet-ypxfr.c
@@ -80,34 +80,34 @@ dissect_rquota(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 
        lock_tree = proto_item_add_subtree(lock_item, ett_rquota_rquota);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_rquota_bsize, offset);
 
-       offset = dissect_rpc_bool_tvb(tvb, pinfo, lock_tree,
+       offset = dissect_rpc_bool(tvb, pinfo, lock_tree,
                        hf_rquota_active, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_rquota_bhardlimit, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_rquota_bsoftlimit, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_rquota_curblocks, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_rquota_fhardlimit, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_rquota_fsoftlimit, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_rquota_curfiles, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_rquota_btimeleft, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_rquota_ftimeleft, offset);
 
        return offset;
@@ -120,7 +120,7 @@ dissect_getquota_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tre
 
        status = tvb_get_ntohl(tvb, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_rquota_status, offset);
 
        if (status==Q_OK) {
@@ -133,10 +133,10 @@ dissect_getquota_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tre
 static int
 dissect_getquota_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_string(tvb, pinfo, tree, 
                        hf_rquota_pathp, offset, NULL);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_rquota_uid, offset);
 
        return offset;
index 9f02b6f12babad6d9d31d8f51bc2a5227f5cdbf4..a5299c0668c23184c7d78c0035a8a229c79f848d 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-rwall.c
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * This program is free software; you can redistribute it and/or
@@ -40,7 +40,7 @@ static gint ett_rwall = -1;
 static int
 dissect_rwall_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_rwall_message, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_rwall_message, offset, NULL);
        
        return offset;
 }
index 627dd0f5b77918089f6975c53f7f2494706927e5..37c1f656e02ad77f853a08f7436cd858968d28a3 100644 (file)
@@ -2,7 +2,7 @@
  * 2001  Ronnie Sahlberg   <rsahlber@bigpond.net.au>
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * This program is free software; you can redistribute it and/or
@@ -50,7 +50,7 @@ dissect_get_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
        proto_item* lock_item = NULL;
        proto_tree* lock_tree = NULL;
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, 
                        hf_spray_counter, offset);
 
        lock_item = proto_tree_add_item(tree, hf_spray_clock, tvb,
@@ -58,10 +58,10 @@ dissect_get_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
 
        lock_tree = proto_item_add_subtree(lock_item, ett_spray_clock);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_spray_sec, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_spray_usec, offset);
 
        return offset;
@@ -70,7 +70,7 @@ dissect_get_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
 static int
 dissect_spray_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_data_tvb(tvb, pinfo, tree, 
+       offset = dissect_rpc_data(tvb, pinfo, tree, 
                        hf_spray_sprayarr, offset);
 
        return offset;
index 0fb9baf6b94da1a3bf934b1948f2a939c7e01d77..c5679f4b531362af05b4733d3236028583e50c16 100644 (file)
@@ -4,7 +4,7 @@
  *
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  *
@@ -47,9 +47,9 @@ static int
 dissect_statnotify_mon(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
 
-       offset = dissect_rpc_string_tvb(tvb,pinfo,tree,hf_statnotify_name,offset,NULL);
+       offset = dissect_rpc_string(tvb,pinfo,tree,hf_statnotify_name,offset,NULL);
 
-       offset = dissect_rpc_uint32_tvb(tvb,pinfo,tree,hf_statnotify_state,offset);
+       offset = dissect_rpc_uint32(tvb,pinfo,tree,hf_statnotify_state,offset);
 
        proto_tree_add_item(tree,hf_statnotify_priv,tvb,offset,16,FALSE);
        offset += 16;
index d72d4da47bda2f620491b300315b269f93b2c66d..598c36bb9c9a81430b814b3f09fd829a587ed11c 100644 (file)
@@ -1,10 +1,10 @@
 /* packet-stat.c
  * Routines for stat dissection
  *
- * $Id: packet-stat.c,v 1.8 2001/03/15 21:55:07 guy Exp $
+ * $Id: packet-stat.c,v 1.9 2001/05/30 06:01:02 guy Exp $
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * Copied from packet-smb.c
@@ -113,7 +113,7 @@ dissect_stat_stat(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
 {
        if (tree)
        {
-               offset = dissect_rpc_string_tvb(tvb,pinfo,tree,hf_stat_mon_name,offset,NULL);
+               offset = dissect_rpc_string(tvb,pinfo,tree,hf_stat_mon_name,offset,NULL);
        }
 
        return offset;
@@ -135,11 +135,11 @@ dissect_stat_stat_res(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
        }
 
        res = tvb_get_ntohl(tvb, offset);
-       offset = dissect_rpc_uint32_tvb(tvb,pinfo,lock_tree,hf_stat_stat_res_res,offset);
+       offset = dissect_rpc_uint32(tvb,pinfo,lock_tree,hf_stat_stat_res_res,offset);
 
        if (res==STAT_SUCC) {
                state = tvb_get_ntohl(tvb, offset);
-               offset = dissect_rpc_uint32_tvb(tvb,pinfo,lock_tree,hf_stat_stat_res_state,offset);
+               offset = dissect_rpc_uint32(tvb,pinfo,lock_tree,hf_stat_stat_res_state,offset);
        } else {
                offset += 4;
        }
@@ -160,10 +160,10 @@ dissect_stat_my_id(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
                        lock_tree = proto_item_add_subtree(lock_item, ett_stat_my_id);
        }
 
-       offset = dissect_rpc_string_tvb(tvb,pinfo,lock_tree,hf_stat_my_id_hostname,offset,NULL);
-       offset = dissect_rpc_uint32_tvb(tvb,pinfo,lock_tree,hf_stat_my_id_prog,offset);
-       offset = dissect_rpc_uint32_tvb(tvb,pinfo,lock_tree,hf_stat_my_id_vers,offset);
-       offset = dissect_rpc_uint32_tvb(tvb,pinfo,lock_tree,hf_stat_my_id_proc,offset);
+       offset = dissect_rpc_string(tvb,pinfo,lock_tree,hf_stat_my_id_hostname,offset,NULL);
+       offset = dissect_rpc_uint32(tvb,pinfo,lock_tree,hf_stat_my_id_prog,offset);
+       offset = dissect_rpc_uint32(tvb,pinfo,lock_tree,hf_stat_my_id_vers,offset);
+       offset = dissect_rpc_uint32(tvb,pinfo,lock_tree,hf_stat_my_id_proc,offset);
 
        return offset;
 }
@@ -182,7 +182,7 @@ dissect_stat_mon_id(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
        }
 
 
-       offset = dissect_rpc_string_tvb(tvb,pinfo,lock_tree,hf_stat_mon_id_name,offset,NULL);
+       offset = dissect_rpc_string(tvb,pinfo,lock_tree,hf_stat_mon_id_name,offset,NULL);
 
        offset = dissect_stat_my_id(tvb,offset,pinfo,lock_tree);
 
@@ -211,7 +211,7 @@ dissect_stat_mon(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
 static int
 dissect_stat_state(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_uint32_tvb(tvb,pinfo,tree,hf_stat_state,offset);
+       offset = dissect_rpc_uint32(tvb,pinfo,tree,hf_stat_state,offset);
 
        return offset;
 }      
@@ -229,9 +229,9 @@ dissect_stat_notify(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
                        lock_tree = proto_item_add_subtree(lock_item, ett_stat_stat_chge);
        }
 
-       offset = dissect_rpc_string_tvb(tvb,pinfo,lock_tree,hf_stat_mon_id_name,offset,NULL);
+       offset = dissect_rpc_string(tvb,pinfo,lock_tree,hf_stat_mon_id_name,offset,NULL);
        
-       offset = dissect_rpc_uint32_tvb(tvb,pinfo,tree,hf_stat_state,offset);
+       offset = dissect_rpc_uint32(tvb,pinfo,tree,hf_stat_state,offset);
 
        return offset;
 }
index d8330b17d220b52d99c870fe2f067a6e8348a60f..214d905a60e0654e7eae0fec36c614d04c31738c 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for yppasswd dissection
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * This program is free software; you can redistribute it and/or
@@ -54,7 +54,7 @@ dissect_yppasswd_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
        proto_item *lock_item = NULL;
        proto_tree *lock_tree = NULL;
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_yppasswd_oldpass, 
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_yppasswd_oldpass, 
                        offset, NULL);
 
        lock_item = proto_tree_add_item(tree, hf_yppasswd_newpw, tvb,
@@ -62,19 +62,19 @@ dissect_yppasswd_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
 
        lock_tree = proto_item_add_subtree(lock_item, ett_yppasswd_newpw);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_yppasswd_newpw_name, offset, NULL);
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_yppasswd_newpw_passwd, offset, NULL);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_yppasswd_newpw_uid, offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, 
                        hf_yppasswd_newpw_gid, offset);
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_yppasswd_newpw_gecos, offset, NULL);
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_yppasswd_newpw_dir, offset, NULL);
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, 
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, 
                        hf_yppasswd_newpw_shell, offset, NULL);
 
        return offset;
@@ -83,7 +83,7 @@ dissect_yppasswd_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree
 static int
 dissect_yppasswd_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_yppasswd_status, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_yppasswd_status, offset);
 
        return offset;
 }
index 5674f45b65f6bc2be11a2363047a00defc7ffacf..75f6b21f66325f182aeb5698d8e9aa58987ae2d4 100644 (file)
@@ -1,10 +1,10 @@
 /* packet-ypserv.c
  * Routines for ypserv dissection
  *
- * $Id: packet-ypserv.c,v 1.15 2001/03/17 21:16:56 guy Exp $
+ * $Id: packet-ypserv.c,v 1.16 2001/05/30 06:01:02 guy Exp $
  *
  * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@zing.org>
+ * By Gerald Combs <gerald@ethereal.com>
  * Copyright 1998 Gerald Combs
  *
  * Copied from packet-smb.c
@@ -101,7 +101,7 @@ dissect_domain_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
 {
        if ( tree )
        {
-               offset = dissect_rpc_string_tvb(tvb,pinfo,tree,hf_ypserv_domain,offset,NULL);
+               offset = dissect_rpc_string(tvb,pinfo,tree,hf_ypserv_domain,offset,NULL);
        }
        
        return offset;
@@ -125,9 +125,9 @@ dissect_match_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
 {
        if ( tree )
        {
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
        }
        
        return offset;
@@ -138,9 +138,9 @@ dissect_match_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *t
 {
        if ( tree )
        {
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_status, offset);
+               offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
 
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_value,offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_value,offset, NULL);
        }
        
        return offset;
@@ -152,9 +152,9 @@ dissect_first_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
 {
        if ( tree )
        {
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
        }
        
        return offset;
@@ -166,10 +166,10 @@ dissect_firstnext_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tre
 {
        if ( tree )
        {
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_status, offset);
+               offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
 
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_value, offset, NULL);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_value, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
        }
        
        return offset;
@@ -181,9 +181,9 @@ dissect_next_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
 {
        if ( tree )
        {
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
        }
        
        return offset;
@@ -203,13 +203,13 @@ dissect_xfr_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
                        lock_tree = proto_item_add_subtree(lock_item, ett_ypserv_map_parms);
        }
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, hf_ypserv_domain, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, hf_ypserv_domain, offset, NULL);
        
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, hf_ypserv_map, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, hf_ypserv_map, offset, NULL);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, lock_tree, hf_ypserv_ordernum, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_ypserv_ordernum, offset);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, lock_tree, hf_ypserv_peer, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, lock_tree, hf_ypserv_peer, offset, NULL);
 
 
        tid=tvb_get_ntohl(tvb,offset);
@@ -217,8 +217,8 @@ dissect_xfr_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree
        proto_tree_add_ipv4(tree, hf_ypserv_transid, tvb, offset, 4, tid);
        offset += 4;
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_prog, offset);
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_port, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_prog, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_port, offset);
 
        return offset;
 }
@@ -233,7 +233,7 @@ dissect_xfr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tre
        proto_tree_add_ipv4(tree, hf_ypserv_transid, tvb, offset, 4, tid);
        offset += 4;
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_xfrstat, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_xfrstat, offset);
 
        return offset;
 }
@@ -242,9 +242,9 @@ static int
 dissect_ypreq_nokey(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
        
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
 
        return offset;
 }
@@ -256,11 +256,11 @@ dissect_ypresp_all(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tr
 
        more = tvb_get_ntohl(tvb, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_more, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_more, offset);
        if (more) {
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_status, offset);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_value, offset, NULL);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
+               offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_value, offset, NULL);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_key, offset, NULL);
        }
 
        return offset;
@@ -270,9 +270,9 @@ static int
 dissect_ypresp_master(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_status, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
 
-       offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_peer, offset, NULL);
+       offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_peer, offset, NULL);
 
        return offset;
 }
@@ -282,9 +282,9 @@ static int
 dissect_ypresp_order(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_status, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
 
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_ordernum, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_ordernum, offset);
 
        return offset;
 }
@@ -293,13 +293,13 @@ dissect_ypresp_order(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *
 static int
 dissect_ypresp_maplist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 {
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_status, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
        while(tvb_get_ntohl(tvb,offset)){
-               offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_more, offset);
-               offset = dissect_rpc_string_tvb(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
+               offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_more, offset);
+               offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
 
        }
-       offset = dissect_rpc_uint32_tvb(tvb, pinfo, tree, hf_ypserv_more, offset);
+       offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_more, offset);
        return offset;
 }