/* packet-bootparams.c
* Routines for bootparams dissection
*
- * $Id: packet-bootparams.c,v 1.19 2001/06/18 02:17:45 guy Exp $
+ * $Id: packet-bootparams.c,v 1.20 2002/04/03 13:24:12 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
};
static int
-dissect_bp_address(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, int hfindex)
+dissect_bp_address(tvbuff_t *tvb, int offset, proto_tree *tree, int hfindex)
{
guint32 type;
guint32 ipaddr;
type = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_bootparams_addresstype, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_bootparams_addresstype, offset);
switch(type){
case 1:
static int
-dissect_getfile_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_getfile_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
if ( tree )
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_host, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_bootparams_fileid, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_bootparams_host, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_bootparams_fileid, offset, NULL);
}
return offset;
}
static int
-dissect_getfile_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_getfile_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
if ( tree )
{
- 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, pinfo, tree, hf_bootparams_filepath, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_bootparams_host, offset, NULL);
+ offset = dissect_bp_address(tvb, offset, tree, hf_bootparams_hostaddr);
+ offset = dissect_rpc_string(tvb, tree, hf_bootparams_filepath, offset, NULL);
}
return offset;
}
static int
-dissect_whoami_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_whoami_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
if ( tree )
{
- offset = dissect_bp_address(tvb, offset, pinfo, tree, hf_bootparams_hostaddr);
+ offset = dissect_bp_address(tvb, offset, tree, hf_bootparams_hostaddr);
}
return offset;
}
static int
-dissect_whoami_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_whoami_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
if ( tree )
{
- 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);
+ offset = dissect_rpc_string(tvb, tree, hf_bootparams_host, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_bootparams_domain, offset, NULL);
+ offset = dissect_bp_address(tvb, offset, tree, hf_bootparams_routeraddr);
}
return offset;
* Routines for hclnfsd (Hummingbird NFS Daemon) dissection
* Copyright 2001, Mike Frisch <frisch@hummingbird.com>
*
- * $Id: packet-hclnfsd.c,v 1.11 2002/04/01 22:40:20 guy Exp $
+ * $Id: packet-hclnfsd.c,v 1.12 2002/04/03 13:24:12 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
static gint ett_hclnfsd_auth_ident = -1;
static int
-dissect_hclnfsd_gids(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_gids(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
guint32 ngids, ngids_i, gid;
proto_tree *gidtree = NULL;
static int
dissect_hclnfsd_spool_inquire_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_status, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_status, offset);
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "spool filehandle");
static int
-dissect_hclnfsd_spool_file_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_spool_file_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_printername, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_hclnfsd_printername, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_filename, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_hclnfsd_filename, offset, NULL);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_fileext, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_fileext, offset);
return offset;
}
static int
-dissect_hclnfsd_authorize_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_authorize_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
guint32 request_type;
char *ident = NULL;
char *password = NULL;
int ident_len = 0;
int newoffset;
- char *p;
proto_item *ident_item = NULL;
proto_tree *ident_tree = NULL;
4, request_type);
offset += 4;
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_device, offset,
+ offset = dissect_rpc_string(tvb, tree, hf_hclnfsd_device, offset,
NULL);
if (tree)
if (ident_tree)
{
- newoffset = dissect_rpc_string(tvb, pinfo, ident_tree,
+ newoffset = dissect_rpc_string(tvb, ident_tree,
hf_hclnfsd_auth_ident_obscure, offset, &ident);
proto_item_set_len(ident_item, newoffset - offset);
static int
-dissect_hclnfsd_authorize_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_authorize_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
guint32 status;
proto_tree_add_uint(tree, hf_hclnfsd_status, tvb, offset, 4, status);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_uid, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_uid, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_gid, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_gid, offset);
offset = dissect_hclnfsd_gids(tvb, offset, pinfo, tree);
}
static int
-dissect_hclnfsd_grp_name_to_numb_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_grp_name_to_numb_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_grpname, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_hclnfsd_grpname, offset, NULL);
return offset;
}
static int
-dissect_hclnfsd_grp_name_to_numb_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_grp_name_to_numb_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_gid, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_gid, offset);
return offset;
}
static int
-dissect_hclnfsd_grp_to_number_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_grp_to_number_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- return dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_grpname, offset,
+ return dissect_rpc_string(tvb, tree, hf_hclnfsd_grpname, offset,
NULL);
}
static int
-dissect_hclnfsd_return_host_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_return_host_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_tree_add_item(tree, hf_hclnfsd_host_ip, tvb, offset, 4, FALSE);
offset += 4;
static int
-dissect_hclnfsd_return_host_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_return_host_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_hostname, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_hclnfsd_hostname, offset, NULL);
return offset;
}
static int
-dissect_hclnfsd_uid_to_name_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_uid_to_name_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
guint32 nuids, nuids_i;
proto_tree *uidtree = NULL;
return offset;
for (nuids_i = 0; nuids_i < nuids; nuids_i++)
- offset = dissect_rpc_uint32(tvb, pinfo, uidtree, hf_hclnfsd_uid, offset);
+ offset = dissect_rpc_uint32(tvb, uidtree, hf_hclnfsd_uid, offset);
return offset;
}
static int
-dissect_hclnfsd_uid_to_name_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_uid_to_name_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
guint32 nusers, nusers_i;
proto_tree *usertree = NULL;
return offset;
for (nusers_i = 0; nusers_i < nusers; nusers_i++)
- offset = dissect_rpc_string(tvb, pinfo, usertree,
+ offset = dissect_rpc_string(tvb, usertree,
hf_hclnfsd_username, offset, NULL);
return offset;
static int
-dissect_hclnfsd_name_to_uid_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_name_to_uid_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_username, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_hclnfsd_username, offset, NULL);
return offset;
}
static int
-dissect_hclnfsd_name_to_uid_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_name_to_uid_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_uid, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_uid, offset);
return offset;
}
4, request_type);
offset += 4;
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_cookie, offset);
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_hclnfsd_lockname, offset, NULL);
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "Filehandle");
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_hclnfsd_unknown_data, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_hclnfsd_unknown_data, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_mode, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_mode, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_access, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_access, offset);
offset += 4; /* skip last 4 UNUSED bytes */
static int
-dissect_hclnfsd_share_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_share_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
guint32 request_type;
4, request_type);
offset += 4;
- 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);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_cookie, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_status, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_sequence, offset);
return offset;
}
static int
dissect_hclnfsd_lock_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_status, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_status, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_cookie, offset);
offset += 4; /* skip unused uint */
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_exclusive, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_exclusive, offset);
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_hclnfsd_lockname, offset, NULL);
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "Filehandle");
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_hclnfsd_lockowner, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_hclnfsd_lockowner, offset);
offset += 4; /* unused, skip */
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_offset, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_offset, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_length, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_length, offset);
return offset;
}
static int
-dissect_hclnfsd_lock_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_lock_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
guint request_type;
4, request_type);
offset += 4;
- 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, tree, hf_hclnfsd_cookie, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_status, offset);
return offset;
}
static int
-dissect_hclnfsd_remove_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_remove_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_hclnfsd_lockname, offset, NULL);
offset += 4; /* skip unused */
{
offset += 4; /* skip unused */
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_cookie, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_cookie, offset);
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_lockname, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_hclnfsd_lockname, offset, NULL);
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "Filehandle");
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_hclnfsd_unknown_data, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_hclnfsd_unknown_data, offset);
offset += 4; /* skip unused */
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_offset, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_length, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_offset, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_length, offset);
return offset;
}
static int
-dissect_hclnfsd_get_printers_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_get_printers_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
guint nqueues, nqueues_i;
proto_item *queuesitem = NULL;
for (nqueues_i = 0; nqueues_i < nqueues; nqueues_i++)
{
/* create new item for print queue */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_hclnfsd_queuename, offset, NULL);
/* create subtree on new item with print queue comment */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_hclnfsd_queuecomment, offset, NULL);
}
static int
-dissect_hclnfsd_get_printq_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_get_printq_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_queuename, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_hclnfsd_queuename, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_username, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_hclnfsd_username, offset, NULL);
return offset;
}
static int
-dissect_hclnfsd_get_printq_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_hclnfsd_get_printq_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
guint datafollows, jobid;
proto_item *queueitem = NULL;
proto_item *jobitem;
proto_tree *jobtree;
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_printqueuenumber, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_printqueuenumber, offset);
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_hclnfsd_queuecomment, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_hclnfsd_queuecomment, offset, NULL);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_queuestatus, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_queuestatus, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_numphysicalprinters, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_numphysicalprinters, offset);
datafollows = tvb_get_ntohl(tvb, offset);
if (tree)
jobtree = proto_item_add_subtree(jobitem, ett_hclnfsd_printjob);
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_hclnfsd_username, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_hclnfsd_printparams, offset, NULL);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_hclnfsd_queuestatus, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_queuestatus, offset);
- 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,
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_jobstatus, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_timesubmitted, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_size, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_hclnfsd_copies, offset);
+ offset = dissect_rpc_string(tvb, tree,
hf_hclnfsd_queuecomment, offset, NULL);
datafollows = tvb_get_ntohl(tvb, offset);
/* packet-klm.c 2001 Ronnie Sahlberg <See AUTHORS for email>
* Routines for klm dissection
*
- * $Id: packet-klm.c,v 1.7 2002/01/24 09:20:49 guy Exp $
+ * $Id: packet-klm.c,v 1.8 2002/04/03 13:24:12 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
};
static int
-dissect_holder(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)
+dissect_holder(tvbuff_t *tvb, proto_tree *tree, int offset)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
lock_tree = proto_item_add_subtree(lock_item, ett_klm_holder);
- offset = dissect_rpc_bool( tvb, pinfo, lock_tree,
+ offset = dissect_rpc_bool( tvb, lock_tree,
hf_klm_exclusive, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_klm_pid, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_klm_offset, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_klm_len, offset);
return offset;
}
static int
-dissect_lock(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)
+dissect_lock(tvbuff_t *tvb, packet_info* pinfo, proto_tree *tree, int offset)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
lock_tree = proto_item_add_subtree(lock_item, ett_klm_lock);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_klm_servername, offset, NULL);
offset = dissect_nfs_fh3(tvb, offset, pinfo, lock_tree,"fh");
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_klm_pid, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_klm_offset, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_klm_len, offset);
return offset;
}
static int
-dissect_klm_stat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_klm_stat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_klm_stats, offset);
return offset;
static int
dissect_klm_lock_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_rpc_bool( tvb, pinfo, tree,
+ offset = dissect_rpc_bool( tvb, tree,
hf_klm_block, offset);
- offset = dissect_rpc_bool( tvb, pinfo, tree,
+ offset = dissect_rpc_bool( tvb, tree,
hf_klm_exclusive, offset);
offset = dissect_lock(tvb, pinfo, tree, offset);
}
static int
-dissect_klm_test_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_klm_test_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
gint32 stats;
stats = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_klm_stats, offset);
if (stats == KLM_DENIED) {
- offset = dissect_holder(tvb, pinfo, tree, offset);
+ offset = dissect_holder(tvb, tree, offset);
}
return offset;
static int
dissect_klm_test_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_rpc_bool( tvb, pinfo, tree,
+ offset = dissect_rpc_bool( tvb, tree,
hf_klm_exclusive, offset);
offset = dissect_lock(tvb, pinfo, tree, offset);
/* packet-mount.c
* Routines for mount dissection
*
- * $Id: packet-mount.c,v 1.29 2002/01/20 22:12:26 guy Exp $
+ * $Id: packet-mount.c,v 1.30 2002/04/03 13:24:12 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
gint32 status;
status=tvb_get_ntohl(tvb,offset);
- offset = dissect_rpc_uint32(tvb,pinfo,tree,hf_mount3_status,offset);
+ offset = dissect_rpc_uint32(tvb,tree,hf_mount3_status,offset);
switch (status) {
case 0:
static int
-dissect_mount_dirpath_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_mount_dirpath_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
if((!pinfo->fd->flags.visited) && nfs_file_name_snooping){
rpc_call_info_value *civ=pinfo->private_data;
if ( tree )
{
- offset = dissect_rpc_string(tvb,pinfo,tree,hf_mount_path,offset,NULL);
+ offset = dissect_rpc_string(tvb,tree,hf_mount_path,offset,NULL);
}
return offset;
/* RFC 1094, Page 26 */
/* RFC 1813, Page 110 */
static int
-dissect_mountlist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_mountlist(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
lock_tree = proto_item_add_subtree(lock_item, ett_mount_mountlist);
}
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_mount_mountlist_hostname, offset, &hostname);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_mount_mountlist_directory, offset, &directory);
if (lock_item) {
/* RFC 1094, Page 26 */
/* RFC 1813, Page 110 */
static int
-dissect_group(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_group(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
int len,str_len;
len=tvb_get_ntohl(tvb,offset);
}
group_name_list[group_names_len]=0;
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_mount_groups_group, offset, NULL);
return offset;
exportlist_tree = proto_item_add_subtree(exportlist_item, ett_mount_exportlist);
}
- offset = dissect_rpc_string(tvb, pinfo, exportlist_tree,
+ offset = dissect_rpc_string(tvb, exportlist_tree,
hf_mount_exportlist_directory, offset, &directory);
groups_offset = offset;
static int
-dissect_mount_pathconf_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_mount_pathconf_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
int saved_offset;
guint32 pc_mask;
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,pinfo,tree,hf_mount_pathconf_link_max,offset);
+ dissect_rpc_uint32(tvb,tree,hf_mount_pathconf_link_max,offset);
}
}
offset += 4;
/* RFC 1813, Page 107 */
static int
-dissect_mountstat3(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, int hfindex, guint32 *status)
+dissect_mountstat3(tvbuff_t *tvb, proto_tree *tree, int offset, int hfindex, guint32 *status)
{
guint32 mountstat3;
mountstat3 = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_uint32(tvb,pinfo,tree,hfindex,offset);
+ offset = dissect_rpc_uint32(tvb,tree,hfindex,offset);
*status = mountstat3;
return offset;
}
guint32 auth_flavor;
guint32 auth_flavor_i;
- offset = dissect_mountstat3(tvb,pinfo,tree,offset,hf_mount3_status,&status);
+ offset = dissect_mountstat3(tvb,tree,offset,hf_mount3_status,&status);
switch (status) {
case 0:
* Routines for NDMP dissection
* 2001 Ronnie Sahlberg (see AUTHORS for email)
*
- * $Id: packet-ndmp.c,v 1.16 2002/02/18 23:51:55 guy Exp $
+ * $Id: packet-ndmp.c,v 1.17 2002/04/03 13:24:12 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
offset += 4;
/* hostname */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_hostname, offset, NULL);
/* os type */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_os_type, offset, NULL);
/* os version */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_os_vers, offset, NULL);
/* hostid */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_hostid, offset, NULL);
return offset;
dissect_default_env(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
/* name */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_butype_env_name, offset, NULL);
/* value */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_butype_env_value, offset, NULL);
return offset;
dissect_butype_info(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
/*butype name*/
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_butype_name, offset, NULL);
/* default env */
dissect_fs_env(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
/* name */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_fs_env_name, offset, NULL);
/* value */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_fs_env_value, offset, NULL);
return offset;
offset=dissect_fs_invalid(tvb, offset, pinfo, tree);
/* fs type */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_fs_fs_type, offset, NULL);
/* fs logical device */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_fs_logical_device, offset, NULL);
/* fs physical device */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_fs_physical_device, offset, NULL);
/*total_size*/
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_ndmp_fs_total_size,
+ offset = dissect_rpc_uint64(tvb, tree, hf_ndmp_fs_total_size,
offset);
/*used_size*/
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_ndmp_fs_used_size,
+ offset = dissect_rpc_uint64(tvb, tree, hf_ndmp_fs_used_size,
offset);
/*avail_size*/
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_ndmp_fs_avail_size,
+ offset = dissect_rpc_uint64(tvb, tree, hf_ndmp_fs_avail_size,
offset);
/*total_inodes*/
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_ndmp_fs_total_inodes,
+ offset = dissect_rpc_uint64(tvb, tree, hf_ndmp_fs_total_inodes,
offset);
/*used_inodes*/
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_ndmp_fs_used_inodes,
+ offset = dissect_rpc_uint64(tvb, tree, hf_ndmp_fs_used_inodes,
offset);
/* env */
dissect_fs_env, hf_ndmp_fs_env);
/* status */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_fs_status, offset, NULL);
return offset;
dissect_tape_capability(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
/* name */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_tape_capability_name, offset, NULL);
/* value */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_tape_capability_value, offset, NULL);
return offset;
dissect_tape_dev_cap(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
/* device */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_tape_device, offset, NULL);
/* tape attributes */
dissect_tape_info(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
/* model */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_tape_model, offset, NULL);
/* device capabilites */
dissect_scsi_info(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
/* model */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_scsi_model, offset, NULL);
/* device capabilites */
offset += 4;
/* vendor */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_server_vendor, offset, NULL);
/* product */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_server_product, offset, NULL);
/* revision */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_server_revision, offset, NULL);
proto_tree *tree, guint32 seq)
{
/* device */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_scsi_device, offset, NULL);
return offset;
proto_tree *tree, guint32 seq)
{
/* device */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_scsi_device, offset, NULL);
/* controller */
proto_tree *tree, guint32 seq)
{
/* device */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_tape_device, offset, NULL);
/* open mode */
offset += 4;
/* total_space */
- offset = dissect_rpc_uint64(tvb, pinfo, tree,hf_ndmp_tape_total_space,
+ offset = dissect_rpc_uint64(tvb, tree,hf_ndmp_tape_total_space,
offset);
/* space_remain */
- offset = dissect_rpc_uint64(tvb, pinfo, tree,hf_ndmp_tape_space_remain,
+ offset = dissect_rpc_uint64(tvb, tree,hf_ndmp_tape_space_remain,
offset);
/* partition */
break;
case NDMP_ADDR_IPC:
/* IPC address */
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_ndmp_addr_ipc, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_ndmp_addr_ipc, offset);
break;
}
proto_tree *tree, guint32 seq)
{
/* file */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_file_name, offset, NULL);
/* error */
offset += 4;
/* message */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_log_message, offset, NULL);
return offset;
offset += 4;
/* reason */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_halt_reason, offset, NULL);
return offset;
offset += 4;
/* reason */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_connected_reason, offset, NULL);
return offset;
break;
case NDMP_AUTH_TEXT:
/* auth id */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_auth_id, offset, NULL);
/* auth password */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_auth_password, offset, NULL);
break;
case NDMP_AUTH_MD5:
/* auth id */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_auth_id, offset, NULL);
/* digest */
proto_tree *tree, guint32 seq)
{
/* data */
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_ndmp_data, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_ndmp_data, offset);
return offset;
}
offset += 4;
/* data */
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_ndmp_data, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_ndmp_data, offset);
return offset;
}
switch(type){
case NDMP_FS_UNIX:
/* file */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_file_name, offset, &name);
if (check_col(pinfo->cinfo, COL_INFO)){
col_append_fstr(pinfo->cinfo, COL_INFO, " %s ", name);
break;
case NDMP_FS_NT:
/* nt file */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_nt_file_name, offset, &name);
if (check_col(pinfo->cinfo, COL_INFO)){
col_append_fstr(pinfo->cinfo, COL_INFO, " %s ", name);
}
/* dos file */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_dos_file_name, offset, NULL);
break;
default:
/* file */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_file_name, offset, &name);
if (check_col(pinfo->cinfo, COL_INFO)){
col_append_fstr(pinfo->cinfo, COL_INFO, " %s ", name);
offset += 4;
/*file size*/
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_ndmp_file_size,
+ offset = dissect_rpc_uint64(tvb, tree, hf_ndmp_file_size,
offset);
/* links */
proto_tree *tree, guint32 seq)
{
/*butype name*/
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_butype_name, offset, NULL);
/* default env */
dissect_nlist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
/*original path*/
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_bu_original_path, offset, NULL);
/*destination dir*/
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_bu_destination_dir, offset, NULL);
/*new name*/
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_bu_new_name, offset, NULL);
/*other name*/
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_bu_other_name, offset, NULL);
/* node */
dissect_nlist, hf_ndmp_nlist);
/*butype name*/
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ndmp_butype_name, offset, NULL);
return offset;
offset += 4;
/*bytes processed*/
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_ndmp_data_bytes_processed,
+ offset = dissect_rpc_uint64(tvb, tree, hf_ndmp_data_bytes_processed,
offset);
/*est bytes remain*/
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_ndmp_data_est_bytes_remain,
+ offset = dissect_rpc_uint64(tvb, tree, hf_ndmp_data_est_bytes_remain,
offset);
/* est time remain */
* Routines for nfs dissection
* Copyright 1999, Uwe Girlich <Uwe.Girlich@philosys.de>
* Copyright 2000-2002, Mike Frisch <frisch@hummingbird.com> (NFSv4 decoding)
- * $Id: packet-nfs.c,v 1.68 2002/03/07 05:51:11 guy Exp $
+ * $Id: packet-nfs.c,v 1.69 2002/04/03 13:24:12 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
return key;
}
static gboolean
-nfs_name_snoop_unmatched_free_all(gpointer key_arg, gpointer value, gpointer user_data)
+nfs_name_snoop_unmatched_free_all(gpointer key_arg _U_, gpointer value, gpointer user_data _U_)
{
nfs_name_snoop_t *nns = (nfs_name_snoop_t *)value;
static void
dissect_fhandle_data_SVR4(tvbuff_t* tvb, int offset, proto_tree *tree,
- int fhlen)
+ int fhlen _U_)
{
guint32 nof = offset;
static void
dissect_fhandle_data_LINUX_KNFSD_LE(tvbuff_t* tvb, int offset, proto_tree *tree,
- int fhlen)
+ int fhlen _U_)
{
guint32 dentry;
guint32 inode;
void
dissect_fhandle_data_LINUX_NFSD_LE(tvbuff_t* tvb, int offset, proto_tree *tree,
- int fhlen)
+ int fhlen _U_)
{
/* pseudo inode */
{
static void
dissect_fhandle_data_LINUX_KNFSD_NEW(tvbuff_t* tvb, int offset, proto_tree *tree,
- int fhlen)
+ int fhlen _U_)
{
guint8 version;
guint8 auth_type;
* well as being backwards compatible with NFSv2 and NFSv3.
*/
int
-dissect_stat_internal(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_stat_internal(tvbuff_t *tvb, int offset,
proto_tree *tree, guint32* status, int nfsvers)
{
guint32 stat;
/* RFC 1094, Page 12..14 */
int
-dissect_stat(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
+dissect_stat(tvbuff_t *tvb, int offset, proto_tree *tree,
guint32 *status)
{
- return dissect_stat_internal(tvb, offset, pinfo, tree, status, !4);
+ return dissect_stat_internal(tvb, offset, tree, status, !4);
}
/* RFC 1094, Page 12..14 */
int
-dissect_nfs2_stat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree* tree)
+dissect_nfs2_stat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree* tree)
{
guint32 status;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
return offset;
}
int
-dissect_nfs_nfsstat4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_nfsstat4(tvbuff_t *tvb, int offset,
proto_tree *tree, guint32 *status)
{
- return dissect_stat_internal(tvb, offset, pinfo, tree, status, 4);
+ return dissect_stat_internal(tvb, offset, tree, status, 4);
}
/* RFC 1094, Page 15 */
int
-dissect_ftype(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
+dissect_ftype(tvbuff_t *tvb, int offset, proto_tree *tree,
char* name)
{
guint32 ftype;
/* RFC 1094, Page 15 */
int
-dissect_timeval(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, int hf_time, int hf_time_sec, int hf_time_usec)
+dissect_timeval(tvbuff_t *tvb, int offset, proto_tree *tree, int hf_time, int hf_time_sec, int hf_time_usec)
{
guint32 seconds;
guint32 useconds;
};
int
-dissect_mode(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
+dissect_mode(tvbuff_t *tvb, int offset, proto_tree *tree,
char* name)
{
guint32 mode;
/* RFC 1094, Page 15 */
int
-dissect_fattr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, char* name)
+dissect_fattr(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* fattr_item = NULL;
proto_tree* fattr_tree = NULL;
fattr_tree = proto_item_add_subtree(fattr_item, ett_nfs_fattr);
}
- offset = dissect_ftype(tvb, offset, pinfo, fattr_tree, "type");
- offset = dissect_mode(tvb, offset, pinfo, fattr_tree, "mode");
- 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_ftype(tvb, offset, fattr_tree, "type");
+ offset = dissect_mode(tvb, offset, fattr_tree, "mode");
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_nlink, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_uid, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_gid, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_size, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_blocksize, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_rdev, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_blocks, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_fsid, offset);
+ offset = dissect_rpc_uint32(tvb, fattr_tree, hf_nfs_fattr_fileid, offset);
- offset = dissect_timeval(tvb, offset, pinfo, fattr_tree, hf_nfs_atime, hf_nfs_atime_sec, hf_nfs_atime_usec);
- offset = dissect_timeval(tvb, offset, pinfo, fattr_tree, hf_nfs_mtime, hf_nfs_mtime_sec, hf_nfs_mtime_usec);
- offset = dissect_timeval(tvb, offset, pinfo, fattr_tree, hf_nfs_ctime, hf_nfs_ctime_sec, hf_nfs_ctime_usec);
+ offset = dissect_timeval(tvb, offset, fattr_tree, hf_nfs_atime, hf_nfs_atime_sec, hf_nfs_atime_usec);
+ offset = dissect_timeval(tvb, offset, fattr_tree, hf_nfs_mtime, hf_nfs_mtime_sec, hf_nfs_mtime_usec);
+ offset = dissect_timeval(tvb, offset, fattr_tree, hf_nfs_ctime, hf_nfs_ctime_sec, hf_nfs_ctime_usec);
/* now we know, that fattr is shorter */
if (fattr_item) {
/* RFC 1094, Page 17 */
int
-dissect_sattr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, char* name)
+dissect_sattr(tvbuff_t *tvb, int offset, proto_tree *tree, char* name)
{
proto_item* sattr_item = NULL;
proto_tree* sattr_tree = NULL;
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff)
- offset = dissect_mode(tvb, offset, pinfo, sattr_tree, "mode");
+ offset = dissect_mode(tvb, offset, sattr_tree, "mode");
else {
proto_tree_add_text(sattr_tree, tvb, offset, 4, "mode: no value");
offset += 4;
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff)
- offset = dissect_rpc_uint32(tvb, pinfo, sattr_tree, hf_nfs_fattr_uid,
+ offset = dissect_rpc_uint32(tvb, sattr_tree, hf_nfs_fattr_uid,
offset);
else {
proto_tree_add_text(sattr_tree, tvb, offset, 4, "uid: no value");
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff)
- offset = dissect_rpc_uint32(tvb, pinfo, sattr_tree, hf_nfs_fattr_gid,
+ offset = dissect_rpc_uint32(tvb, sattr_tree, hf_nfs_fattr_gid,
offset);
else {
proto_tree_add_text(sattr_tree, tvb, offset, 4, "gid: no value");
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff)
- offset = dissect_rpc_uint32(tvb, pinfo, sattr_tree, hf_nfs_fattr_size,
+ offset = dissect_rpc_uint32(tvb, sattr_tree, hf_nfs_fattr_size,
offset);
else {
proto_tree_add_text(sattr_tree, tvb, offset, 4, "size: no value");
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff) {
- offset = dissect_timeval(tvb, offset, pinfo, sattr_tree, hf_nfs_atime, hf_nfs_atime_sec, hf_nfs_atime_usec);
+ offset = dissect_timeval(tvb, offset, sattr_tree, hf_nfs_atime, hf_nfs_atime_sec, hf_nfs_atime_usec);
} else {
proto_tree_add_text(sattr_tree, tvb, offset, 8, "atime: no value");
offset += 8;
}
if (tvb_get_ntohl(tvb, offset+0) != 0xffffffff) {
- offset = dissect_timeval(tvb, offset, pinfo, sattr_tree, hf_nfs_mtime, hf_nfs_mtime_sec, hf_nfs_mtime_usec);
+ offset = dissect_timeval(tvb, offset, sattr_tree, hf_nfs_mtime, hf_nfs_mtime_sec, hf_nfs_mtime_usec);
} else {
proto_tree_add_text(sattr_tree, tvb, offset, 8, "mtime: no value");
offset += 8;
/* RFC 1094, Page 17 */
int
-dissect_filename(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_filename(tvbuff_t *tvb, int offset,
proto_tree *tree, int hf, char **string_ret)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf, offset, string_ret);
+ offset = dissect_rpc_string(tvb, tree, hf, offset, string_ret);
return offset;
}
/* RFC 1094, Page 17 */
int
-dissect_path(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, int hf)
+dissect_path(tvbuff_t *tvb, int offset, proto_tree *tree, int hf)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf, offset, NULL);
return offset;
}
/* RFC 1094, Page 17,18 */
int
-dissect_attrstat(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree){
+dissect_attrstat(tvbuff_t *tvb, int offset, proto_tree *tree){
guint32 status;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_fattr(tvb, offset, pinfo, tree, "attributes");
+ offset = dissect_fattr(tvb, offset, tree, "attributes");
break;
default:
/* do nothing */
/* RFC 1094, Page 17,18 */
int
-dissect_nfs2_attrstat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree* tree)
+dissect_nfs2_attrstat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree* tree)
{
- offset = dissect_attrstat(tvb, offset, pinfo, tree);
+ offset = dissect_attrstat(tvb, offset, tree);
return offset;
}
}
offset = dissect_fhandle (tvb,offset,pinfo,diropargs_tree,"dir");
- offset = dissect_filename(tvb,offset,pinfo,diropargs_tree,hf_nfs_name,NULL);
+ offset = dissect_filename(tvb,offset, diropargs_tree,hf_nfs_name,NULL);
/* now we know, that diropargs is shorter */
if (diropargs_item) {
{
guint32 status;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
offset = dissect_fhandle(tvb, offset, pinfo, tree, "file");
- offset = dissect_fattr (tvb, offset, pinfo, tree, "attributes");
+ offset = dissect_fattr (tvb, offset, tree, "attributes");
break;
default:
/* do nothing */
/* nfsdata is simply a chunk of RPC opaque data (length, data, fill bytes) */
int
-dissect_nfsdata(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfsdata(tvbuff_t *tvb, int offset,
proto_tree *tree, int hf)
{
- offset = dissect_rpc_data(tvb, pinfo, tree, hf, offset);
+ offset = dissect_rpc_data(tvb, tree, hf, offset);
return offset;
}
proto_tree *tree)
{
offset = dissect_fhandle(tvb, offset, pinfo, tree, "file" );
- offset = dissect_sattr (tvb, offset, pinfo, tree, "attributes");
+ offset = dissect_sattr (tvb, offset, tree, "attributes");
return offset;
}
/* RFC 1094, Page 6 */
int
-dissect_nfs2_readlink_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs2_readlink_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
guint32 status;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_path(tvb, offset, pinfo, tree, hf_nfs_readlink_data);
+ offset = dissect_path(tvb, offset, tree, hf_nfs_readlink_data);
break;
default:
/* do nothing */
/* RFC 1094, Page 7 */
int
-dissect_nfs2_read_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs2_read_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_fattr(tvb, offset, pinfo, tree, "attributes");
- offset = dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_data);
+ offset = dissect_fattr(tvb, offset, tree, "attributes");
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_data);
break;
default:
/* do nothing */
}
offset += 12;
- offset = dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_data);
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_data);
return offset;
}
proto_tree *tree)
{
offset = dissect_diropargs(tvb, offset, pinfo, tree, "where" );
- offset = dissect_sattr (tvb, offset, pinfo, tree, "attributes");
+ offset = dissect_sattr (tvb, offset, tree, "attributes");
return offset;
}
proto_tree *tree)
{
offset = dissect_diropargs(tvb, offset, pinfo, tree, "from" );
- offset = dissect_path (tvb, offset, pinfo, tree, hf_nfs_symlink_to);
- offset = dissect_sattr (tvb, offset, pinfo, tree, "attributes" );
+ offset = dissect_path (tvb, offset, tree, hf_nfs_symlink_to);
+ offset = dissect_sattr (tvb, offset, tree, "attributes" );
return offset;
}
/* RFC 1094, Page 11 */
int
-dissect_readdir_entry(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_readdir_entry(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
proto_item* entry_item = NULL;
offset+0, 4, fileid);
offset += 4;
- offset = dissect_filename(tvb, offset, pinfo, entry_tree,
+ offset = dissect_filename(tvb, offset, entry_tree,
hf_nfs_readdir_entry_name, &name);
if (entry_item)
proto_item_set_text(entry_item, "Entry: file ID %u, name %s",
guint32 status;
guint32 eof_value;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
offset = dissect_rpc_list(tvb, pinfo, tree, offset,
/* RFC 1094, Page 12 */
int
-dissect_nfs2_statfs_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs2_statfs_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
guint32 bfree;
guint32 bavail;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
tsize = tvb_get_ntohl(tvb, offset+ 0);
/* RFC 1813, Page 15 */
int
-dissect_filename3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_filename3(tvbuff_t *tvb, int offset,
proto_tree *tree, int hf, char **string_ret)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf, offset, string_ret);
+ offset = dissect_rpc_string(tvb, tree, hf, offset, string_ret);
return offset;
}
/* RFC 1813, Page 15 */
int
-dissect_nfspath3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfspath3(tvbuff_t *tvb, int offset,
proto_tree *tree, int hf)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf, offset, NULL);
return offset;
}
/* RFC 1813, Page 15 */
int
-dissect_cookieverf3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_cookieverf3(tvbuff_t *tvb, int offset,
proto_tree *tree)
{
proto_tree_add_text(tree, tvb, offset, NFS3_COOKIEVERFSIZE,
/* RFC 1813, Page 16 */
int
-dissect_createverf3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_createverf3(tvbuff_t *tvb, int offset,
proto_tree *tree)
{
proto_tree_add_text(tree, tvb, offset, NFS3_CREATEVERFSIZE,
/* RFC 1813, Page 16 */
int
-dissect_writeverf3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_writeverf3(tvbuff_t *tvb, int offset,
proto_tree *tree)
{
proto_tree_add_text(tree, tvb, offset, NFS3_WRITEVERFSIZE,
/* RFC 1813, Page 16 */
int
-dissect_mode3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
+dissect_mode3(tvbuff_t *tvb, int offset, proto_tree *tree,
char* name)
{
guint32 mode3;
/* RFC 1813, Page 16 */
int
-dissect_nfsstat3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfsstat3(tvbuff_t *tvb, int offset,
proto_tree *tree,guint32 *status)
{
guint32 nfsstat3;
/* RFC 1813, Page 20 */
int
-dissect_ftype3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
+dissect_ftype3(tvbuff_t *tvb, int offset, proto_tree *tree,
int hf, guint32* ftype3)
{
guint32 type;
/* RFC 1813, Page 20 */
int
-dissect_specdata3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_specdata3(tvbuff_t *tvb, int offset,
proto_tree *tree, char* name)
{
guint32 specdata1;
/* RFC 1813, Page 21 */
int
-dissect_nfstime3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfstime3(tvbuff_t *tvb, int offset,
proto_tree *tree, int hf_time, int hf_time_sec, int hf_time_nsec)
{
guint32 seconds;
/* RFC 1813, Page 22 */
int
-dissect_fattr3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
+dissect_fattr3(tvbuff_t *tvb, int offset, proto_tree *tree,
char* name)
{
proto_item* fattr3_item = NULL;
fattr3_tree = proto_item_add_subtree(fattr3_item, ett_nfs_fattr3);
}
- 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, pinfo, fattr3_tree, hf_nfs_fattr3_nlink,
+ offset = dissect_ftype3(tvb,offset,fattr3_tree,hf_nfs_fattr3_type,&type);
+ offset = dissect_mode3(tvb,offset,fattr3_tree,"mode");
+ offset = dissect_rpc_uint32(tvb, fattr3_tree, hf_nfs_fattr3_nlink,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_uid,
+ offset = dissect_rpc_uint32(tvb, fattr3_tree, hf_nfs_fattr3_uid,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_gid,
+ offset = dissect_rpc_uint32(tvb, fattr3_tree, hf_nfs_fattr3_gid,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_size,
+ offset = dissect_rpc_uint64(tvb, fattr3_tree, hf_nfs_fattr3_size,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_used,
+ offset = dissect_rpc_uint64(tvb, fattr3_tree, hf_nfs_fattr3_used,
offset);
- offset = dissect_specdata3(tvb,offset,pinfo,fattr3_tree,"rdev");
- offset = dissect_rpc_uint64(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_fsid,
+ offset = dissect_specdata3(tvb,offset,fattr3_tree,"rdev");
+ offset = dissect_rpc_uint64(tvb, fattr3_tree, hf_nfs_fattr3_fsid,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, fattr3_tree, hf_nfs_fattr3_fileid,
+ offset = dissect_rpc_uint64(tvb, fattr3_tree, hf_nfs_fattr3_fileid,
offset);
- offset = dissect_nfstime3 (tvb,offset,pinfo,fattr3_tree,hf_nfs_atime,hf_nfs_atime_sec,hf_nfs_atime_nsec);
- offset = dissect_nfstime3 (tvb,offset,pinfo,fattr3_tree,hf_nfs_mtime,hf_nfs_mtime_sec,hf_nfs_mtime_nsec);
- offset = dissect_nfstime3 (tvb,offset,pinfo,fattr3_tree,hf_nfs_ctime,hf_nfs_ctime_sec,hf_nfs_ctime_nsec);
+ offset = dissect_nfstime3 (tvb,offset,fattr3_tree,hf_nfs_atime,hf_nfs_atime_sec,hf_nfs_atime_nsec);
+ offset = dissect_nfstime3 (tvb,offset,fattr3_tree,hf_nfs_mtime,hf_nfs_mtime_sec,hf_nfs_mtime_nsec);
+ offset = dissect_nfstime3 (tvb,offset,fattr3_tree,hf_nfs_ctime,hf_nfs_ctime_sec,hf_nfs_ctime_nsec);
/* now we know, that fattr3 is shorter */
if (fattr3_item) {
/* RFC 1813, Page 23 */
int
-dissect_post_op_attr(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_post_op_attr(tvbuff_t *tvb, int offset,
proto_tree *tree, char* name)
{
proto_item* post_op_attr_item = NULL;
offset += 4;
switch (attributes_follow) {
case TRUE:
- offset = dissect_fattr3(tvb, offset, pinfo, post_op_attr_tree,
+ offset = dissect_fattr3(tvb, offset, post_op_attr_tree,
"attributes");
break;
case FALSE:
/* RFC 1813, Page 24 */
int
-dissect_wcc_attr(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_wcc_attr(tvbuff_t *tvb, int offset,
proto_tree *tree, char* name)
{
proto_item* wcc_attr_item = NULL;
ett_nfs_wcc_attr);
}
- offset = dissect_rpc_uint64(tvb, pinfo, wcc_attr_tree, hf_nfs_wcc_attr_size,
+ offset = dissect_rpc_uint64(tvb, wcc_attr_tree, hf_nfs_wcc_attr_size,
offset);
- offset = dissect_nfstime3(tvb, offset, pinfo, wcc_attr_tree, hf_nfs_mtime, hf_nfs_mtime_sec, hf_nfs_mtime_nsec);
- offset = dissect_nfstime3(tvb, offset, pinfo, wcc_attr_tree, hf_nfs_ctime, hf_nfs_ctime_sec, hf_nfs_ctime_nsec);
+ offset = dissect_nfstime3(tvb, offset, wcc_attr_tree, hf_nfs_mtime, hf_nfs_mtime_sec, hf_nfs_mtime_nsec);
+ offset = dissect_nfstime3(tvb, offset, wcc_attr_tree, hf_nfs_ctime, hf_nfs_ctime_sec, hf_nfs_ctime_nsec);
/* now we know, that wcc_attr_tree is shorter */
if (wcc_attr_item) {
proto_item_set_len(wcc_attr_item, offset - old_offset);
/* RFC 1813, Page 24 */
int
-dissect_pre_op_attr(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_pre_op_attr(tvbuff_t *tvb, int offset,
proto_tree *tree, char* name)
{
proto_item* pre_op_attr_item = NULL;
offset += 4;
switch (attributes_follow) {
case TRUE:
- offset = dissect_wcc_attr(tvb, offset, pinfo, pre_op_attr_tree,
+ offset = dissect_wcc_attr(tvb, offset, pre_op_attr_tree,
"attributes");
break;
case FALSE:
/* RFC 1813, Page 24 */
int
-dissect_wcc_data(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_wcc_data(tvbuff_t *tvb, int offset,
proto_tree *tree, char* name)
{
proto_item* wcc_data_item = NULL;
ett_nfs_wcc_data);
}
- offset = dissect_pre_op_attr (tvb, offset, pinfo, wcc_data_tree, "before");
- offset = dissect_post_op_attr(tvb, offset, pinfo, wcc_data_tree, "after" );
+ offset = dissect_pre_op_attr (tvb, offset, wcc_data_tree, "before");
+ offset = dissect_post_op_attr(tvb, offset, wcc_data_tree, "after" );
/* now we know, that wcc_data is shorter */
if (wcc_data_item) {
/* RFC 1813, Page 25 */
int
-dissect_set_mode3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_set_mode3(tvbuff_t *tvb, int offset,
proto_tree *tree, char* name)
{
proto_item* set_mode3_item = NULL;
switch (set_it) {
case 1:
- offset = dissect_mode3(tvb, offset, pinfo, set_mode3_tree,
+ offset = dissect_mode3(tvb, offset, set_mode3_tree,
"mode");
break;
default:
/* RFC 1813, Page 26 */
int
-dissect_set_uid3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_set_uid3(tvbuff_t *tvb, int offset,
proto_tree *tree, char* name)
{
proto_item* set_uid3_item = NULL;
switch (set_it) {
case 1:
- offset = dissect_rpc_uint32(tvb, pinfo, set_uid3_tree,
+ offset = dissect_rpc_uint32(tvb, set_uid3_tree,
hf_nfs_uid3, offset);
break;
default:
/* RFC 1813, Page 26 */
int
-dissect_set_gid3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_set_gid3(tvbuff_t *tvb, int offset,
proto_tree *tree, char* name)
{
proto_item* set_gid3_item = NULL;
switch (set_it) {
case 1:
- offset = dissect_rpc_uint32(tvb, pinfo, set_gid3_tree,
+ offset = dissect_rpc_uint32(tvb, set_gid3_tree,
hf_nfs_gid3, offset);
break;
default:
/* RFC 1813, Page 26 */
int
-dissect_set_size3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_set_size3(tvbuff_t *tvb, int offset,
proto_tree *tree, char* name)
{
proto_item* set_size3_item = NULL;
switch (set_it) {
case 1:
- offset = dissect_rpc_uint64(tvb, pinfo, set_size3_tree,
+ offset = dissect_rpc_uint64(tvb, set_size3_tree,
hf_nfs_set_size3_size, offset);
break;
default:
/* RFC 1813, Page 26 */
int
-dissect_set_atime(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_set_atime(tvbuff_t *tvb, int offset,
proto_tree *tree, char* name)
{
proto_item* set_atime_item = NULL;
switch (set_it) {
case SET_TO_CLIENT_TIME:
if (set_atime_item) {
- offset = dissect_nfstime3(tvb, offset, pinfo, set_atime_tree,
+ offset = dissect_nfstime3(tvb, offset, set_atime_tree,
hf_nfs_atime, hf_nfs_atime_sec, hf_nfs_atime_nsec);
}
break;
/* RFC 1813, Page 26 */
int
-dissect_set_mtime(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_set_mtime(tvbuff_t *tvb, int offset,
proto_tree *tree, char* name)
{
proto_item* set_mtime_item = NULL;
switch (set_it) {
case SET_TO_CLIENT_TIME:
if (set_mtime_item) {
- offset = dissect_nfstime3(tvb, offset, pinfo, set_mtime_tree,
+ offset = dissect_nfstime3(tvb, offset, set_mtime_tree,
hf_nfs_atime, hf_nfs_atime_sec, hf_nfs_atime_nsec);
}
break;
/* RFC 1813, Page 25..27 */
int
-dissect_sattr3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
+dissect_sattr3(tvbuff_t *tvb, int offset, proto_tree *tree,
char* name)
{
proto_item* sattr3_item = NULL;
sattr3_tree = proto_item_add_subtree(sattr3_item, ett_nfs_sattr3);
}
- offset = dissect_set_mode3(tvb, offset, pinfo, sattr3_tree, "mode");
- offset = dissect_set_uid3 (tvb, offset, pinfo, sattr3_tree, "uid");
- offset = dissect_set_gid3 (tvb, offset, pinfo, sattr3_tree, "gid");
- offset = dissect_set_size3(tvb, offset, pinfo, sattr3_tree, "size");
- offset = dissect_set_atime(tvb, offset, pinfo, sattr3_tree, "atime");
- offset = dissect_set_mtime(tvb, offset, pinfo, sattr3_tree, "mtime");
+ offset = dissect_set_mode3(tvb, offset, sattr3_tree, "mode");
+ offset = dissect_set_uid3 (tvb, offset, sattr3_tree, "uid");
+ offset = dissect_set_gid3 (tvb, offset, sattr3_tree, "gid");
+ offset = dissect_set_size3(tvb, offset, sattr3_tree, "size");
+ offset = dissect_set_atime(tvb, offset, sattr3_tree, "atime");
+ offset = dissect_set_mtime(tvb, offset, sattr3_tree, "mtime");
/* now we know, that sattr3 is shorter */
if (sattr3_item) {
offset = dissect_nfs_fh3(tvb, offset, pinfo, diropargs3_tree, "dir");
name_offset=offset+4;
name_len=tvb_get_ntohl(tvb, offset);
- offset = dissect_filename3(tvb, offset, pinfo, diropargs3_tree,
+ offset = dissect_filename3(tvb, offset, diropargs3_tree,
hf_nfs_name, NULL);
/* are we snooping fh to filenames ?*/
/* RFC 1813, Page 40 */
int
-dissect_access(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
+dissect_access(tvbuff_t *tvb, int offset, proto_tree *tree,
char* name)
{
guint32 access;
}
-/* generic NFS3 reply dissector */
-int
-dissect_nfs3_any_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree* tree)
-{
- guint32 status;
-
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
-
- return offset;
-
-}
-
-
/* RFC 1813, Page 32,33 */
int
dissect_nfs3_getattr_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
/* RFC 1813, Page 32,33 */
int
-dissect_nfs3_getattr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_getattr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_fattr3(tvb, offset, pinfo, tree, "obj_attributes");
+ offset = dissect_fattr3(tvb, offset, tree, "obj_attributes");
break;
default:
/* void */
/* RFC 1813, Page 33 */
int
-dissect_sattrguard3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_sattrguard3(tvbuff_t *tvb, int offset,
proto_tree* tree, char *name)
{
proto_item* sattrguard3_item = NULL;
switch (check) {
case TRUE:
- offset = dissect_nfstime3(tvb, offset, pinfo, sattrguard3_tree,
+ offset = dissect_nfstime3(tvb, offset, sattrguard3_tree,
hf_nfs_ctime, hf_nfs_ctime_sec, hf_nfs_ctime_nsec);
break;
case FALSE:
proto_tree* tree)
{
offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "object");
- offset = dissect_sattr3 (tvb, offset, pinfo, tree, "new_attributes");
- offset = dissect_sattrguard3(tvb, offset, pinfo, tree, "guard");
+ offset = dissect_sattr3 (tvb, offset, tree, "new_attributes");
+ offset = dissect_sattrguard3(tvb, offset, tree, "guard");
return offset;
}
/* RFC 1813, Page 33..36 */
int
-dissect_nfs3_setattr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_setattr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "obj_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "obj_wcc");
break;
default:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "obj_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "obj_wcc");
break;
}
{
guint32 status;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object");
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"dir_attributes");
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"dir_attributes");
break;
}
proto_tree* tree)
{
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "object");
- offset = dissect_access (tvb, offset, pinfo, tree, "access");
+ offset = dissect_access (tvb, offset, tree, "access");
return offset;
}
/* RFC 1813, Page 40..43 */
int
-dissect_nfs3_access_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_access_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
- offset = dissect_access(tvb, offset, pinfo, tree, "access");
+ offset = dissect_access(tvb, offset, tree, "access");
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
break;
}
/* RFC 1813, Page 44,45 */
int
-dissect_nfs3_readlink_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_readlink_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"symlink_attributes");
- offset = dissect_nfspath3(tvb, offset, pinfo, tree,
+ offset = dissect_nfspath3(tvb, offset, tree,
hf_nfs_readlink_data);
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"symlink_attributes");
break;
}
proto_tree* tree)
{
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "file");
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_offset3, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3, offset);
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_offset3, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3, offset);
return offset;
}
/* RFC 1813, Page 46..48 */
int
-dissect_nfs3_read_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_read_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"file_attributes");
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3,
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3,
offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nfs_read_eof,
+ offset = dissect_rpc_bool(tvb, tree, hf_nfs_read_eof,
offset);
- offset = dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_data);
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_data);
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"file_attributes");
break;
}
/* RFC 1813, Page 49 */
int
-dissect_stable_how(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_stable_how(tvbuff_t *tvb, int offset,
proto_tree* tree, int hfindex)
{
guint32 stable_how;
proto_tree* tree)
{
offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "file");
- 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);
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_offset3, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3, offset);
+ offset = dissect_stable_how(tvb, offset, tree, hf_nfs_write_stable);
+ offset = dissect_nfsdata (tvb, offset, tree, hf_nfs_data);
return offset;
}
/* RFC 1813, Page 49..54 */
int
-dissect_nfs3_write_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_write_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_wcc_data (tvb, offset, pinfo, tree, "file_wcc");
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3,
+ offset = dissect_wcc_data (tvb, offset, tree, "file_wcc");
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3,
offset);
- offset = dissect_stable_how(tvb, offset, pinfo, tree,
+ offset = dissect_stable_how(tvb, offset, tree,
hf_nfs_write_committed);
- offset = dissect_writeverf3(tvb, offset, pinfo, tree);
+ offset = dissect_writeverf3(tvb, offset, tree);
break;
default:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "file_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "file_wcc");
break;
}
/* RFC 1813, Page 54 */
int
-dissect_createmode3(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_createmode3(tvbuff_t *tvb, int offset,
proto_tree* tree, guint32* mode)
{
guint32 mode_value;
guint32 mode;
offset = dissect_diropargs3 (tvb, offset, pinfo, tree, "where");
- offset = dissect_createmode3(tvb, offset, pinfo, tree, &mode);
+ offset = dissect_createmode3(tvb, offset, tree, &mode);
switch (mode) {
case UNCHECKED:
case GUARDED:
- offset = dissect_sattr3(tvb, offset, pinfo, tree, "obj_attributes");
+ offset = dissect_sattr3(tvb, offset, tree, "obj_attributes");
break;
case EXCLUSIVE:
- offset = dissect_createverf3(tvb, offset, pinfo, tree);
+ offset = dissect_createverf3(tvb, offset, tree);
break;
}
{
guint32 status;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
offset = dissect_post_op_fh3 (tvb, offset, pinfo, tree, "obj");
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "dir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
break;
default:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "dir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
break;
}
proto_tree* tree)
{
offset = dissect_diropargs3(tvb, offset, pinfo, tree, "where");
- offset = dissect_sattr3 (tvb, offset, pinfo, tree, "attributes");
+ offset = dissect_sattr3 (tvb, offset, tree, "attributes");
return offset;
}
proto_tree* tree)
{
offset = dissect_diropargs3(tvb, offset, pinfo, tree, "where");
- offset = dissect_sattr3 (tvb, offset, pinfo, tree, "symlink_attributes");
- offset = dissect_nfspath3 (tvb, offset, pinfo, tree, hf_nfs_symlink_to);
+ offset = dissect_sattr3 (tvb, offset, tree, "symlink_attributes");
+ offset = dissect_nfspath3 (tvb, offset, tree, hf_nfs_symlink_to);
return offset;
}
guint32 type;
offset = dissect_diropargs3(tvb, offset, pinfo, tree, "where");
- offset = dissect_ftype3(tvb, offset, pinfo, tree, hf_nfs_ftype3, &type);
+ offset = dissect_ftype3(tvb, offset, tree, hf_nfs_ftype3, &type);
switch (type) {
case NF3CHR:
case NF3BLK:
- offset = dissect_sattr3(tvb, offset, pinfo, tree, "dev_attributes");
- offset = dissect_specdata3(tvb, offset, pinfo, tree, "spec");
+ offset = dissect_sattr3(tvb, offset, tree, "dev_attributes");
+ offset = dissect_specdata3(tvb, offset, tree, "spec");
break;
case NF3SOCK:
case NF3FIFO:
- offset = dissect_sattr3(tvb, offset, pinfo, tree, "pipe_attributes");
+ offset = dissect_sattr3(tvb, offset, tree, "pipe_attributes");
break;
default:
/* nothing to do */
/* RFC 1813, Page 67..69 */
int
-dissect_nfs3_remove_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_remove_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_wcc_data (tvb, offset, pinfo, tree, "dir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
break;
default:
- offset = dissect_wcc_data (tvb, offset, pinfo, tree, "dir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "dir_wcc");
break;
}
/* RFC 1813, Page 71..74 */
int
-dissect_nfs3_rename_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_rename_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "fromdir_wcc");
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "todir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "fromdir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "todir_wcc");
break;
default:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "fromdir_wcc");
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "todir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "fromdir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "todir_wcc");
break;
}
/* RFC 1813, Page 74..76 */
int
-dissect_nfs3_link_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_link_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"file_attributes");
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "linkdir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "linkdir_wcc");
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"file_attributes");
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "linkdir_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "linkdir_wcc");
break;
}
proto_tree* tree)
{
offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "dir");
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_cookie3, offset);
- offset = dissect_cookieverf3(tvb, offset, pinfo, tree);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3, offset);
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_cookie3, offset);
+ offset = dissect_cookieverf3(tvb, offset, tree);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3, offset);
return offset;
}
/* RFC 1813, Page 76..80 */
int
-dissect_entry3(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree* tree)
+dissect_entry3(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree* tree)
{
proto_item* entry_item = NULL;
proto_tree* entry_tree = NULL;
entry_tree = proto_item_add_subtree(entry_item, ett_nfs_readdir_entry);
}
- offset = dissect_rpc_uint64(tvb, pinfo, entry_tree, hf_nfs_readdir_entry3_fileid,
+ offset = dissect_rpc_uint64(tvb, entry_tree, hf_nfs_readdir_entry3_fileid,
offset);
- offset = dissect_filename3(tvb, offset, pinfo, entry_tree,
+ offset = dissect_filename3(tvb, offset, entry_tree,
hf_nfs_readdir_entry3_name, &name);
if (entry_item)
proto_item_set_text(entry_item, "Entry: name %s", name);
g_free(name);
- offset = dissect_rpc_uint64(tvb, pinfo, entry_tree, hf_nfs_readdir_entry3_cookie,
+ offset = dissect_rpc_uint64(tvb, entry_tree, hf_nfs_readdir_entry3_cookie,
offset);
/* now we know, that a readdir entry is shorter */
guint32 status;
guint32 eof_value;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"dir_attributes");
- offset = dissect_cookieverf3(tvb, offset, pinfo, tree);
+ offset = dissect_cookieverf3(tvb, offset, tree);
offset = dissect_rpc_list(tvb, pinfo, tree, offset,
dissect_entry3);
eof_value = tvb_get_ntohl(tvb, offset+0);
offset += 4;
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"dir_attributes");
break;
}
proto_tree* tree)
{
offset = dissect_nfs_fh3 (tvb, offset, pinfo, tree, "dir");
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_cookie3, offset);
- offset = dissect_cookieverf3(tvb, offset, pinfo, tree);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3_dircount,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_cookie3, offset);
+ offset = dissect_cookieverf3(tvb, offset, tree);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3_dircount,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3_maxcount,
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3_maxcount,
offset);
return offset;
entry_tree = proto_item_add_subtree(entry_item, ett_nfs_readdir_entry);
}
- offset = dissect_rpc_uint64(tvb, pinfo, entry_tree,
+ offset = dissect_rpc_uint64(tvb, entry_tree,
hf_nfs_readdirplus_entry_fileid, offset);
- offset = dissect_filename3(tvb, offset, pinfo, entry_tree,
+ offset = dissect_filename3(tvb, offset, entry_tree,
hf_nfs_readdirplus_entry_name, &name);
if (entry_item)
proto_item_set_text(entry_item, "Entry: name %s", name);
g_free(name);
- offset = dissect_rpc_uint64(tvb, pinfo, entry_tree, hf_nfs_readdirplus_entry_cookie,
+ offset = dissect_rpc_uint64(tvb, entry_tree, hf_nfs_readdirplus_entry_cookie,
offset);
- offset = dissect_post_op_attr(tvb, offset, pinfo, entry_tree,
+ offset = dissect_post_op_attr(tvb, offset, entry_tree,
"name_attributes");
offset = dissect_post_op_fh3(tvb, offset, pinfo, entry_tree, "name_handle");
guint32 status;
guint32 eof_value;
- offset = dissect_stat(tvb, offset, pinfo, tree, &status);
+ offset = dissect_stat(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"dir_attributes");
- offset = dissect_cookieverf3(tvb, offset, pinfo, tree);
+ offset = dissect_cookieverf3(tvb, offset, tree);
offset = dissect_rpc_list(tvb, pinfo, tree, offset,
dissect_entryplus3);
eof_value = tvb_get_ntohl(tvb, offset+0);
offset += 4;
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"dir_attributes");
break;
}
/* RFC 1813, Page 84..86 */
int
-dissect_nfs3_fsstat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_fsstat_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
guint32 invarsec;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_tbytes,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_fsstat3_resok_tbytes,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_fbytes,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_fsstat3_resok_fbytes,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_abytes,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_fsstat3_resok_abytes,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_tfiles,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_fsstat3_resok_tfiles,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_ffiles,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_fsstat3_resok_ffiles,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_fsstat3_resok_afiles,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_fsstat3_resok_afiles,
offset);
invarsec = tvb_get_ntohl(tvb, offset + 0);
if (tree)
offset += 4;
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
break;
}
/* RFC 1813, Page 86..90 */
int
-dissect_nfs3_fsinfo_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_fsinfo_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
proto_item* properties_item = NULL;
proto_tree* properties_tree = NULL;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
rtmax = tvb_get_ntohl(tvb, offset+0);
if (tree)
offset+0, 4, dtpref);
offset += 4;
- offset = dissect_rpc_uint64(tvb, pinfo, tree,
+ offset = dissect_rpc_uint64(tvb, tree,
hf_nfs_fsinfo_maxfilesize, offset);
- offset = dissect_nfstime3(tvb, offset, pinfo, tree, hf_nfs_dtime, hf_nfs_dtime_sec, hf_nfs_dtime_nsec);
+ offset = dissect_nfstime3(tvb, offset, tree, hf_nfs_dtime, hf_nfs_dtime_sec, hf_nfs_dtime_nsec);
properties = tvb_get_ntohl(tvb, offset+0);
if (tree) {
properties_item = proto_tree_add_uint(tree,
offset += 4;
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
break;
}
/* RFC 1813, Page 90..92 */
int
-dissect_nfs3_pathconf_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_pathconf_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
guint32 linkmax;
guint32 name_max;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
linkmax = tvb_get_ntohl(tvb, offset + 0);
if (tree)
proto_tree_add_uint(tree, hf_nfs_pathconf_name_max, tvb,
offset+0, 4, name_max);
offset += 4;
- offset = dissect_rpc_bool(tvb, pinfo, tree,
+ offset = dissect_rpc_bool(tvb, tree,
hf_nfs_pathconf_no_trunc, offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree,
+ offset = dissect_rpc_bool(tvb, tree,
hf_nfs_pathconf_chown_restricted, offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree,
+ offset = dissect_rpc_bool(tvb, tree,
hf_nfs_pathconf_case_insensitive, offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree,
+ offset = dissect_rpc_bool(tvb, tree,
hf_nfs_pathconf_case_preserving, offset);
break;
default:
- offset = dissect_post_op_attr(tvb, offset, pinfo, tree,
+ offset = dissect_post_op_attr(tvb, offset, tree,
"obj_attributes");
break;
}
proto_tree* tree)
{
offset = dissect_nfs_fh3(tvb, offset, pinfo, tree, "file");
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_offset3, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_count3, offset);
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_offset3, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_count3, offset);
return offset;
}
/* RFC 1813, Page 92..95 */
int
-dissect_nfs3_commit_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs3_commit_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree* tree)
{
guint32 status;
- offset = dissect_nfsstat3(tvb, offset, pinfo, tree, &status);
+ offset = dissect_nfsstat3(tvb, offset, tree, &status);
switch (status) {
case 0:
- offset = dissect_wcc_data (tvb, offset, pinfo, tree, "file_wcc");
- offset = dissect_writeverf3(tvb, offset, pinfo, tree);
+ offset = dissect_wcc_data (tvb, offset, tree, "file_wcc");
+ offset = dissect_writeverf3(tvb, offset, tree);
break;
default:
- offset = dissect_wcc_data(tvb, offset, pinfo, tree, "file_wcc");
+ offset = dissect_wcc_data(tvb, offset, tree, "file_wcc");
break;
}
/**********************************************************/
int
-dissect_nfs_utf8string(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_utf8string(tvbuff_t *tvb, int offset,
proto_tree *tree, int hf, char **string_ret)
{
/* TODO: this needs to be fixed */
- return dissect_rpc_string(tvb, pinfo, tree, hf, offset, string_ret);
+ return dissect_rpc_string(tvb, tree, hf, offset, string_ret);
}
int
-dissect_nfs_linktext4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_linktext4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- return dissect_nfs_utf8string(tvb, offset, pinfo, tree, hf_nfs_linktext4,
+ /* TODO: use parameter "name" */
+ return dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_linktext4,
NULL);
}
int
-dissect_nfs_specdata4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_specdata4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_specdata1, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_specdata2, offset);
+ /* TODO: use parameter "name" */
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_specdata1, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_specdata2, offset);
return offset;
}
int
-dissect_nfs_clientid4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_clientid4(tvbuff_t *tvb, int offset,
proto_tree *tree)
{
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_clientid4, offset);
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_clientid4, offset);
return offset;
}
};
int
-dissect_nfs_component4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_component4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- return dissect_nfs_utf8string(tvb, offset, pinfo, tree, hf_nfs_component4,
+ /* TODO: use parameter "name" */
+ return dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_component4,
NULL);
}
+/* TODO: this function is not referenced at all. Remove it? */
int
-dissect_nfs_reclaim4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_reclaim4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_reclaim4, offset);
+ /* TODO: use parameter "name */
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_reclaim4, offset);
return offset;
}
int
-dissect_nfs_length4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_length4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_length4, offset);
+ /* TODO: use parameter "name */
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_length4, offset);
return offset;
}
int
-dissect_nfs_opaque4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_opaque4(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name);
int
-dissect_nfs_lock_owner4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_lock_owner4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
+ /* TODO: use paramter "name" */
proto_tree *newftree = NULL;
proto_item *fitem = NULL;
newftree = proto_item_add_subtree(fitem, ett_nfs_lock_owner4);
if (newftree) {
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_clientid4,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_clientid4,
offset);
- offset = dissect_nfs_opaque4(tvb, offset, pinfo, newftree, "Owner");
+ offset = dissect_nfs_opaque4(tvb, offset, newftree, "Owner");
}
}
}
int
-dissect_nfs_pathname4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_pathname4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
+ /* TODO: use paramter "name" */
guint comp_count, i;
proto_item *fitem = NULL;
proto_tree *newftree = NULL;
if (newftree) {
for (i=0; i<comp_count; i++)
- offset=dissect_nfs_component4(tvb, offset, pinfo, newftree, "comp");
+ offset=dissect_nfs_component4(tvb, offset, newftree, "comp");
}
}
}
int
-dissect_nfs_changeid4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_changeid4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_changeid4, offset);
+ /* TODO: use parameter "name" */
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_changeid4, offset);
return offset;
}
int
-dissect_nfs_nfstime4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_nfstime4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_nfstime4_seconds,
+ /* TODO: use parameter "name" */
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_nfstime4_seconds,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_nfstime4_nseconds,
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_nfstime4_nseconds,
offset);
return offset;
}
};
int
-dissect_nfs_settime4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_settime4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
guint32 set_it;
offset += 4;
if (set_it == SET_TO_CLIENT_TIME4)
- offset = dissect_nfs_nfstime4(tvb, offset, pinfo, tree, NULL);
+ offset = dissect_nfs_nfstime4(tvb, offset, tree, NULL);
return offset;
}
int
-dissect_nfs_fsid4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_fsid4(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name)
{
proto_tree *newftree = NULL;
if (newftree == NULL) return offset;
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_fsid4_major,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_fsid4_major,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_fsid4_minor,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_fsid4_minor,
offset);
return offset;
}
int
-dissect_nfs_acetype4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_acetype4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_acetype4, offset);
+ /* TODO: use parameter "name" */
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_acetype4, offset);
return offset;
}
int
-dissect_nfs_aceflag4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_aceflag4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_aceflag4, offset);
+ /* TODO: use parameter "name" */
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_aceflag4, offset);
return offset;
}
int
-dissect_nfs_acemask4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_acemask4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- return dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_acemask4, offset);
+ /* TODO: use parameter "name" */
+ return dissect_rpc_uint32(tvb, tree, hf_nfs_acemask4, offset);
}
int
-dissect_nfs_nfsace4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_nfsace4(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name)
{
proto_tree *newftree = NULL;
if (newftree == NULL) return offset;
nextentry = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_data_follows,
+ offset = dissect_rpc_bool(tvb, newftree, hf_nfs_data_follows,
offset);
while (nextentry)
{
- offset = dissect_nfs_acetype4(tvb, offset, pinfo, newftree, "type");
- offset = dissect_nfs_aceflag4(tvb, offset, pinfo, newftree, "flag");
- offset = dissect_nfs_acemask4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_acetype4(tvb, offset, newftree, "type");
+ offset = dissect_nfs_aceflag4(tvb, offset, newftree, "flag");
+ offset = dissect_nfs_acemask4(tvb, offset, newftree,
"access_mask");
- offset = dissect_nfs_utf8string(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_utf8string(tvb, offset, newftree,
hf_nfs_who, NULL);
nextentry = tvb_get_ntohl(tvb, offset);
offset += 4;
}
int
-dissect_nfs_fs_location4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_fs_location4(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name)
{
proto_tree *newftree = NULL;
if (newftree == NULL) return offset;
- offset = dissect_nfs_utf8string(tvb, offset, pinfo, tree, hf_nfs_server,
+ offset = dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_server,
NULL);
return offset;
}
int
-dissect_nfs_fs_locations4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_fs_locations4(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name)
{
proto_tree *newftree = NULL;
if (newftree == NULL) return offset;
- offset = dissect_nfs_pathname4(tvb, offset, pinfo, newftree, "fs_root");
+ offset = dissect_nfs_pathname4(tvb, offset, newftree, "fs_root");
nextentry = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_data_follows,
+ offset = dissect_rpc_bool(tvb, newftree, hf_nfs_data_follows,
offset);
while (nextentry)
{
- offset = dissect_nfs_fs_location4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_fs_location4(tvb, offset, newftree,
"locations");
nextentry = tvb_get_ntohl(tvb, offset);
offset += 4;
}
int
-dissect_nfs_mode4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_mode4(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name)
{
- return dissect_mode(tvb, offset, pinfo, tree, name);
+ return dissect_mode(tvb, offset, tree, name);
}
static const value_string nfs4_fattr4_fh_expire_type_names[] = {
int
dissect_nfs_fattr4_fh_expire_type(tvbuff_t *tvb, int offset,
- packet_info *pinfo, proto_tree *tree)
+ proto_tree *tree)
{
guint32 expire_type;
proto_item *expire_type_item = NULL;
int
dissect_nfs_attributes(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name, int type)
+ proto_tree *tree, char *name _U_, int type)
{
+ /* TODO: use parameter "name" */
guint32 bitmap_len;
proto_item *fitem = NULL;
proto_tree *newftree = NULL;
break;
case FATTR4_TYPE:
- attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb,
attr_newftree, hf_nfs_ftype4, attr_vals_offset);
break;
case FATTR4_FH_EXPIRE_TYPE:
attr_vals_offset = dissect_nfs_fattr4_fh_expire_type(tvb,
- attr_vals_offset, pinfo, attr_newftree);
+ attr_vals_offset, attr_newftree);
break;
case FATTR4_CHANGE:
attr_vals_offset = dissect_nfs_changeid4(tvb,
- attr_vals_offset, pinfo, attr_newftree, "fattr4_change");
+ attr_vals_offset, attr_newftree, "fattr4_change");
break;
case FATTR4_SIZE:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_size, attr_vals_offset);
break;
case FATTR4_LINK_SUPPORT:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_link_support,
attr_vals_offset);
break;
case FATTR4_SYMLINK_SUPPORT:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_symlink_support,
attr_vals_offset);
break;
case FATTR4_NAMED_ATTR:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_named_attr, attr_vals_offset);
break;
case FATTR4_FSID:
attr_vals_offset = dissect_nfs_fsid4(tvb, attr_vals_offset,
- pinfo, attr_newftree, "fattr4_fsid");
+ attr_newftree, "fattr4_fsid");
break;
case FATTR4_UNIQUE_HANDLES:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_unique_handles,
attr_vals_offset);
break;
case FATTR4_LEASE_TIME:
- attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb,
attr_newftree, hf_nfs_fattr4_lease_time,
attr_vals_offset);
break;
case FATTR4_RDATTR_ERROR:
attr_vals_offset = dissect_nfs_nfsstat4(tvb, attr_vals_offset,
- pinfo, attr_newftree, NULL);
+ attr_newftree, NULL);
break;
case FATTR4_ACL:
attr_vals_offset = dissect_nfs_nfsace4(tvb, attr_vals_offset,
- pinfo, attr_newftree, "fattr4_acl");
+ attr_newftree, "fattr4_acl");
break;
case FATTR4_ACLSUPPORT:
- attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb,
attr_newftree, hf_nfs_fattr4_aclsupport, offset);
break;
case FATTR4_ARCHIVE:
attr_vals_offset = dissect_rpc_bool(tvb,
- pinfo, attr_newftree, hf_nfs_fattr4_archive,
+ attr_newftree, hf_nfs_fattr4_archive,
attr_vals_offset);
break;
case FATTR4_CANSETTIME:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_cansettime, attr_vals_offset);
break;
case FATTR4_CASE_INSENSITIVE:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_case_insensitive,
attr_vals_offset);
break;
case FATTR4_CASE_PRESERVING:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_case_preserving,
attr_vals_offset);
break;
case FATTR4_CHOWN_RESTRICTED:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_chown_restricted,
attr_vals_offset);
break;
case FATTR4_FILEID:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_fileid, attr_vals_offset);
break;
case FATTR4_FILES_AVAIL:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_files_avail,
attr_vals_offset);
break;
break;
case FATTR4_FILES_FREE:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_files_free, attr_vals_offset);
break;
case FATTR4_FILES_TOTAL:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_files_total,
attr_vals_offset);
break;
case FATTR4_FS_LOCATIONS:
attr_vals_offset = dissect_nfs_fs_locations4(tvb,
- attr_vals_offset, pinfo, attr_newftree,
+ attr_vals_offset, attr_newftree,
"fattr4_fs_locations");
break;
case FATTR4_HIDDEN:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_hidden, attr_vals_offset);
break;
case FATTR4_HOMOGENEOUS:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_homogeneous,
attr_vals_offset);
break;
case FATTR4_MAXFILESIZE:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_maxfilesize,
attr_vals_offset);
break;
case FATTR4_MAXLINK:
- attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb,
attr_newftree, hf_nfs_fattr4_maxlink, attr_vals_offset);
break;
case FATTR4_MAXNAME:
- attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb,
attr_newftree, hf_nfs_fattr4_maxname, attr_vals_offset);
break;
case FATTR4_MAXREAD:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_maxread, attr_vals_offset);
break;
case FATTR4_MAXWRITE:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_maxwrite, attr_vals_offset);
break;
case FATTR4_MIMETYPE:
attr_vals_offset = dissect_nfs_utf8string(tvb,
- attr_vals_offset, pinfo, attr_newftree,
+ attr_vals_offset, attr_newftree,
hf_nfs_fattr4_mimetype, NULL);
break;
case FATTR4_MODE:
attr_vals_offset = dissect_nfs_mode4(tvb,
- attr_vals_offset, pinfo, attr_newftree, "fattr4_mode");
+ attr_vals_offset, attr_newftree, "fattr4_mode");
break;
case FATTR4_NO_TRUNC:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_no_trunc, attr_vals_offset);
break;
case FATTR4_NUMLINKS:
- attr_vals_offset = dissect_rpc_uint32(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint32(tvb,
attr_newftree, hf_nfs_fattr4_numlinks, attr_vals_offset);
break;
case FATTR4_OWNER:
attr_vals_offset = dissect_nfs_utf8string(tvb,
- attr_vals_offset, pinfo, attr_newftree,
+ attr_vals_offset, attr_newftree,
hf_nfs_fattr4_owner,
NULL);
break;
case FATTR4_OWNER_GROUP:
attr_vals_offset = dissect_nfs_utf8string(tvb,
- attr_vals_offset, pinfo, attr_newftree,
+ attr_vals_offset, attr_newftree,
hf_nfs_fattr4_owner_group, NULL);
break;
case FATTR4_QUOTA_AVAIL_HARD:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_quota_hard, attr_vals_offset);
break;
case FATTR4_QUOTA_AVAIL_SOFT:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_quota_soft, attr_vals_offset);
break;
case FATTR4_QUOTA_USED:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_quota_used, attr_vals_offset);
break;
case FATTR4_RAWDEV:
attr_vals_offset = dissect_nfs_specdata4(tvb,
- attr_vals_offset, pinfo, attr_newftree, "fattr4_rawdev");
+ attr_vals_offset, attr_newftree, "fattr4_rawdev");
break;
case FATTR4_SPACE_AVAIL:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_space_avail,
attr_vals_offset);
break;
case FATTR4_SPACE_FREE:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_space_free, attr_vals_offset);
break;
case FATTR4_SPACE_TOTAL:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_space_total,
attr_vals_offset);
break;
case FATTR4_SPACE_USED:
- attr_vals_offset = dissect_rpc_uint64(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_uint64(tvb,
attr_newftree, hf_nfs_fattr4_space_used, attr_vals_offset);
break;
case FATTR4_SYSTEM:
- attr_vals_offset = dissect_rpc_bool(tvb, pinfo,
+ attr_vals_offset = dissect_rpc_bool(tvb,
attr_newftree, hf_nfs_fattr4_system, attr_vals_offset);
break;
case FATTR4_TIME_METADATA:
case FATTR4_TIME_MODIFY:
attr_vals_offset = dissect_nfs_nfstime4(tvb, attr_vals_offset,
- pinfo, attr_newftree, "nfstime4");
+ attr_newftree, "nfstime4");
break;
case FATTR4_TIME_ACCESS_SET:
case FATTR4_TIME_MODIFY_SET:
attr_vals_offset = dissect_nfs_settime4(tvb,
- attr_vals_offset, pinfo, attr_newftree, "settime4");
+ attr_vals_offset, attr_newftree, "settime4");
break;
default:
offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree, name,
FATTR4_FULL_DISSECT);
- offset = dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_attrlist4);
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_attrlist4);
return offset;
}
};
int
-dissect_nfs_open4_share_access(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_open4_share_access(tvbuff_t *tvb, int offset,
proto_tree *tree)
{
guint share_access;
};
int
-dissect_nfs_open4_share_deny(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_open4_share_deny(tvbuff_t *tvb, int offset,
proto_tree *tree)
{
guint deny_access;
}
int
-dissect_nfs_open_owner4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree)
+dissect_nfs_open_owner4(tvbuff_t *tvb, int offset, proto_tree *tree)
{
- offset = dissect_nfs_clientid4(tvb, offset, pinfo, tree);
- offset = dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_open_owner4);
+ offset = dissect_nfs_clientid4(tvb, offset, tree);
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_open_owner4);
return offset;
}
int
dissect_nfs_open_claim_delegate_cur4(tvbuff_t *tvb, int offset,
- packet_info *pinfo, proto_tree *tree, char *name)
+ proto_tree *tree, char *name _U_)
{
- offset = dissect_rpc_uint64(tvb, pinfo, tree,
+ /* TODO: use parameter "name" */
+ offset = dissect_rpc_uint64(tvb, tree,
hf_nfs_stateid4_delegate_stateid, offset);
- offset = dissect_nfs_component4(tvb, offset, pinfo, tree, "file");
+ offset = dissect_nfs_component4(tvb, offset, tree, "file");
return offset;
}
};
int
-dissect_nfs_open_claim4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_open_claim4(tvbuff_t *tvb, int offset,
proto_tree *tree)
{
guint open_claim_type4;
switch(open_claim_type4)
{
case CLAIM_NULL:
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_component4(tvb, offset, newftree,
"file");
break;
case CLAIM_PREVIOUS:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint32(tvb, newftree,
hf_nfs_delegate_type, offset);
break;
case CLAIM_DELEGATE_CUR:
- offset = dissect_nfs_open_claim_delegate_cur4(tvb, offset, pinfo,
+ offset = dissect_nfs_open_claim_delegate_cur4(tvb, offset,
newftree, "delegate_cur_info");
break;
case CLAIM_DELEGATE_PREV:
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_component4(tvb, offset, newftree,
"file_delegate_prev");
break;
int
dissect_nfs_createhow4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+ proto_tree *tree, char *name _U_)
{
+ /* TODO: use parameter "name" */
guint mode;
/* This is intentional; we're using the same flags as NFSv3 */
break;
case EXCLUSIVE: /* EXCLUSIVE4 */
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_verifier4, offset);
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_verifier4, offset);
break;
default:
}
int
-dissect_nfs_clientaddr4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_clientaddr4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- offset = dissect_nfs_opaque4(tvb, offset, pinfo, tree, "network id");
- offset = dissect_nfs_opaque4(tvb, offset, pinfo, tree, "universal address");
+ /* TODO: use parameter "name" */
+ offset = dissect_nfs_opaque4(tvb, offset, tree, "network id");
+ offset = dissect_nfs_opaque4(tvb, offset, tree, "universal address");
return offset;
}
int
-dissect_nfs_cb_client4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_cb_client4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_cb_program,
+ /* TODO: use parameter "name" */
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_cb_program,
offset);
- offset = dissect_nfs_clientaddr4(tvb, offset, pinfo, tree, "cb_location");
+ offset = dissect_nfs_clientaddr4(tvb, offset, tree, "cb_location");
return offset;
}
};
int
-dissect_nfs_stable_how4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_stable_how4(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name)
{
guint stable_how4;
}
int
-dissect_nfs_opaque4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_opaque4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- return dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_data);
+ /* TODO: use parameter "name" */
+ return dissect_nfsdata(tvb, offset, tree, hf_nfs_data);
}
/* There is probably a better (built-in?) way to do this, but this works
int
dissect_nfs_dirlist4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+ proto_tree *tree, char *name _U_)
{
+ /* TODO: use parameter "name" */
proto_tree *newftree = NULL;
guint nextentry;
nextentry = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_data_follows,
+ offset = dissect_rpc_bool(tvb, newftree, hf_nfs_data_follows,
offset);
while (nextentry)
{
/* offset = dissect_nfs_cookie4(tvb, offset, pinfo, newftree); */
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_cookie4, offset);
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree, "name");
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_cookie4, offset);
+ offset = dissect_nfs_component4(tvb, offset, newftree, "name");
offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree, "attrs");
nextentry = tvb_get_ntohl(tvb, offset);
offset += 4;
}
- offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_dirlist4_eof,
+ offset = dissect_rpc_bool(tvb, newftree, hf_nfs_dirlist4_eof,
offset);
return offset;
}
int
-dissect_nfs_change_info4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_change_info4(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name)
{
proto_tree *newftree = NULL;
newftree = proto_item_add_subtree(fitem, ett_nfs_change_info4);
if (newftree) {
- offset = dissect_rpc_bool(tvb, pinfo, newftree,
+ offset = dissect_rpc_bool(tvb, 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");
+ offset = dissect_nfs_changeid4(tvb, offset, newftree, "before");
+ offset = dissect_nfs_changeid4(tvb, offset, newftree, "after");
}
}
};
int
-dissect_nfs_lock4denied(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_lock4denied(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_offset4, offset);
- offset = dissect_nfs_length4(tvb, offset, pinfo, tree, "length");
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_lock_type4, offset);
- offset = dissect_nfs_lock_owner4(tvb, offset, pinfo, tree, "owner");
+ /* TODO: use parameter "name" */
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_offset4, offset);
+ offset = dissect_nfs_length4(tvb, offset, tree, "length");
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_lock_type4, offset);
+ offset = dissect_nfs_lock_owner4(tvb, offset, tree, "owner");
return offset;
}
int
-dissect_nfs_ace4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_ace4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- offset = dissect_nfs_acetype4(tvb, offset, pinfo, tree, "type");
- offset = dissect_nfs_aceflag4(tvb, offset, pinfo, tree, "flag");
- offset = dissect_nfs_acemask4(tvb, offset, pinfo, tree, "access_mask");
- return dissect_nfs_utf8string(tvb, offset, pinfo, tree, hf_nfs_ace4, NULL);
+ offset = dissect_nfs_acetype4(tvb, offset, tree, "type");
+ offset = dissect_nfs_aceflag4(tvb, offset, tree, "flag");
+ offset = dissect_nfs_acemask4(tvb, offset, tree, "access_mask");
+ return dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_ace4, NULL);
}
static const value_string names_open4_result_flags[] = {
};
int
-dissect_nfs_open4_rflags(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_open4_rflags(tvbuff_t *tvb, int offset,
proto_tree *tree, char *name)
{
guint rflags;
}
int
-dissect_nfs_stateid4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_stateid4(tvbuff_t *tvb, int offset,
proto_tree *tree)
{
proto_item *fitem = NULL;
if (fitem) {
newftree = proto_item_add_subtree(fitem, ett_nfs_stateid4);
if (newftree) {
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_seqid4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
offset);
bytes_left = 12;
}
int
-dissect_nfs_open_read_delegation4(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nfs_open_read_delegation4(tvbuff_t *tvb, int offset,
proto_tree *tree)
{
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, tree);
- offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nfs_recall4, offset);
- offset = dissect_nfs_ace4(tvb, offset, pinfo, tree, "permissions");
+ offset = dissect_nfs_stateid4(tvb, offset, tree);
+ offset = dissect_rpc_bool(tvb, tree, hf_nfs_recall4, offset);
+ offset = dissect_nfs_ace4(tvb, offset, tree, "permissions");
return offset;
}
int
-dissect_nfs_modified_limit4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_modified_limit4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_num_blocks,
+ /* TODO: use parameter "name" */
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_num_blocks,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_bytes_per_block,
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_bytes_per_block,
offset);
return offset;
}
};
int
-dissect_nfs_space_limit4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_space_limit4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
+ /* TODO: use parameter "name" */
guint limitby;
limitby = tvb_get_ntohl(tvb, offset);
switch(limitby)
{
case NFS_LIMIT_SIZE:
- offset = dissect_rpc_uint64(tvb, pinfo, tree, hf_nfs_filesize,
+ offset = dissect_rpc_uint64(tvb, tree, hf_nfs_filesize,
offset);
break;
case NFS_LIMIT_BLOCKS:
- offset = dissect_nfs_modified_limit4(tvb, offset, pinfo, tree,
+ offset = dissect_nfs_modified_limit4(tvb, offset, tree,
"mod_blocks");
break;
int
dissect_nfs_open_write_delegation4(tvbuff_t *tvb, int offset,
- packet_info *pinfo, proto_tree *tree)
+ proto_tree *tree)
{
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, tree);
- 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");
+ offset = dissect_nfs_stateid4(tvb, offset, tree);
+ offset = dissect_rpc_bool(tvb, tree, hf_nfs_recall, offset);
+ offset = dissect_nfs_space_limit4(tvb, offset, tree, "space_limit");
+ return dissect_nfs_ace4(tvb, offset, tree, "permissions");
}
#define OPEN_DELEGATE_NONE 0
};
int
-dissect_nfs_open_delegation4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+dissect_nfs_open_delegation4(tvbuff_t *tvb, int offset,
+ proto_tree *tree, char *name _U_)
{
+ /* TODO: use parameter "name" */
guint delegation_type;
proto_tree *newftree = NULL;
proto_item *fitem = NULL;
break;
case OPEN_DELEGATE_READ:
- offset = dissect_nfs_open_read_delegation4(tvb, offset, pinfo,
+ offset = dissect_nfs_open_read_delegation4(tvb, offset,
newftree);
break;
case OPEN_DELEGATE_WRITE:
- offset = dissect_nfs_open_write_delegation4(tvb, offset, pinfo,
+ offset = dissect_nfs_open_write_delegation4(tvb, offset,
newftree);
break;
}
int
-dissect_nfs_rpcsec_gss_info(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree)
+dissect_nfs_rpcsec_gss_info(tvbuff_t *tvb, int offset, proto_tree *tree)
{
guint data_follows;
while ((data_follows = tvb_get_ntohl(tvb, offset)))
{
offset += 4;
- offset = dissect_nfsdata(tvb, offset, pinfo, tree, hf_nfs_sec_oid4);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_qop4, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_nfsdata(tvb, offset, tree, hf_nfs_sec_oid4);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_qop4, offset);
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nfs_secinfo_rpcsec_gss_info_service, offset);
}
}
int
-dissect_nfs_open_to_lock_owner4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree)
+dissect_nfs_open_to_lock_owner4(tvbuff_t *tvb, int offset, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_seqid4, offset);
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, tree);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_lock_seqid4, offset);
- offset = dissect_nfs_lock_owner4(tvb, offset, pinfo, tree, "owner");
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_seqid4, offset);
+ offset = dissect_nfs_stateid4(tvb, offset, tree);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_lock_seqid4, offset);
+ offset = dissect_nfs_lock_owner4(tvb, offset, tree, "owner");
return offset;
}
int
-dissect_nfs_exist_lock_owner4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree)
+dissect_nfs_exist_lock_owner4(tvbuff_t *tvb, int offset, proto_tree *tree)
{
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, tree);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_lock_seqid4, offset);
+ offset = dissect_nfs_stateid4(tvb, offset, tree);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_lock_seqid4, offset);
return offset;
}
int
-dissect_nfs_locker4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree)
+dissect_nfs_locker4(tvbuff_t *tvb, int offset, proto_tree *tree)
{
guint new_lock_owner;
new_lock_owner = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nfs_new_lock_owner, offset);
+ offset = dissect_rpc_bool(tvb, tree, hf_nfs_new_lock_owner, offset);
if (new_lock_owner)
- offset = dissect_nfs_open_to_lock_owner4(tvb, offset, pinfo, tree);
+ offset = dissect_nfs_open_to_lock_owner4(tvb, offset, tree);
else
- offset = dissect_nfs_exist_lock_owner4(tvb, offset, pinfo, tree);
+ offset = dissect_nfs_exist_lock_owner4(tvb, offset, tree);
return offset;
}
switch(opcode)
{
case NFS4_OP_ACCESS:
- offset = dissect_access(tvb, offset, pinfo, newftree, "access");
+ offset = dissect_access(tvb, offset, newftree, "access");
break;
case NFS4_OP_CLOSE:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_seqid4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
offset);
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
break;
case NFS4_OP_COMMIT:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_offset4,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_count4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_count4,
offset);
break;
guint create_type;
create_type = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_ftype4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_ftype4,
offset);
switch(create_type)
{
case NF4LNK:
- offset = dissect_nfs_linktext4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_linktext4(tvb, offset, newftree,
"linkdata");
break;
case NF4BLK:
case NF4CHR:
- offset = dissect_nfs_specdata4(tvb, offset, pinfo,
+ offset = dissect_nfs_specdata4(tvb, offset,
newftree, "devdata");
break;
break;
}
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_component4(tvb, offset, newftree,
"objname");
offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree,
break;
case NFS4_OP_DELEGPURGE:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint64(tvb, newftree,
hf_nfs_clientid4, offset);
break;
case NFS4_OP_DELEGRETURN:
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
break;
case NFS4_OP_GETATTR:
break;
case NFS4_OP_LINK:
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_component4(tvb, offset, newftree,
"newname");
break;
case NFS4_OP_LOCK:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_lock_type4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_lock_type4,
offset);
- offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_lock4_reclaim,
+ offset = dissect_rpc_bool(tvb, newftree, hf_nfs_lock4_reclaim,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_offset4,
offset);
- offset = dissect_nfs_length4(tvb, offset, pinfo, newftree, "length");
- offset = dissect_nfs_locker4(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_length4(tvb, offset, newftree, "length");
+ offset = dissect_nfs_locker4(tvb, offset, newftree);
break;
case NFS4_OP_LOCKT:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_lock_type4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_lock_type4,
offset);
- offset = dissect_nfs_lock_owner4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_lock_owner4(tvb, offset, newftree,
"owner");
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_offset4,
offset);
- offset = dissect_nfs_length4(tvb, offset, pinfo, newftree, "length");
+ offset = dissect_nfs_length4(tvb, offset, newftree, "length");
break;
case NFS4_OP_LOCKU:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_lock_type4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_lock_type4,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nfs_seqid4, offset);
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, newftree);
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_seqid4, offset);
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_offset4,
offset);
- offset = dissect_nfs_length4(tvb, offset, pinfo, newftree, "length");
+ offset = dissect_nfs_length4(tvb, offset, newftree, "length");
break;
case NFS4_OP_LOOKUP:
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_component4(tvb, offset, newftree,
"objname");
break;
break;
case NFS4_OP_OPEN:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_seqid4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
offset);
- offset = dissect_nfs_open4_share_access(tvb, offset, pinfo, newftree);
- offset = dissect_nfs_open4_share_deny(tvb, offset, pinfo, newftree);
- offset = dissect_nfs_open_owner4(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_open4_share_access(tvb, offset, newftree);
+ offset = dissect_nfs_open4_share_deny(tvb, offset, newftree);
+ offset = dissect_nfs_open_owner4(tvb, offset, newftree);
offset = dissect_nfs_openflag4(tvb, offset, pinfo, newftree);
- offset = dissect_nfs_open_claim4(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_open_claim4(tvb, offset, newftree);
break;
case NFS4_OP_OPENATTR:
- offset = dissect_rpc_bool(tvb, pinfo, newftree, hf_nfs_attrdircreate,
+ offset = dissect_rpc_bool(tvb, newftree, hf_nfs_attrdircreate,
offset);
break;
case NFS4_OP_OPEN_CONFIRM:
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, newftree);
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_seqid4,
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
offset);
break;
case NFS4_OP_OPEN_DOWNGRADE:
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, newftree);
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_seqid4,
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_seqid4,
offset);
- offset = dissect_nfs_open4_share_access(tvb, offset, pinfo, newftree);
- offset = dissect_nfs_open4_share_deny(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_open4_share_access(tvb, offset, newftree);
+ offset = dissect_nfs_open4_share_deny(tvb, offset, newftree);
break;
case NFS4_OP_PUTFH:
break;
case NFS4_OP_READ:
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, newftree);
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_offset4,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_count4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_count4,
offset);
break;
case NFS4_OP_READDIR:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_cookie4,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_cookie4,
offset);
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_cookieverf4,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_cookieverf4,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint32(tvb, newftree,
hf_nfs_count4_dircount, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint32(tvb, newftree,
hf_nfs_count4_maxcount, offset);
offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree, "attr",
FATTR4_BITMAP_ONLY);
break;
case NFS4_OP_REMOVE:
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_component4(tvb, offset, newftree,
"target");
break;
case NFS4_OP_RENAME:
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_component4(tvb, offset, newftree,
"oldname");
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_component4(tvb, offset, newftree,
"newname");
break;
case NFS4_OP_RENEW:
- offset = dissect_nfs_clientid4(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_clientid4(tvb, offset, newftree);
break;
case NFS4_OP_RESTOREFH:
break;
case NFS4_OP_SECINFO:
- offset = dissect_nfs_component4(tvb, offset, pinfo, newftree, "name");
+ offset = dissect_nfs_component4(tvb, offset, newftree, "name");
break;
case NFS4_OP_SETATTR:
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
offset = dissect_nfs_fattr4(tvb, offset, pinfo, newftree,
"obj_attributes");
break;
if (newftree)
{
- offset = dissect_nfs_clientid4(tvb, offset, pinfo,
+ offset = dissect_nfs_clientid4(tvb, offset,
client_tree);
- offset = dissect_nfsdata(tvb, offset, pinfo, client_tree,
+ offset = dissect_nfsdata(tvb, offset, client_tree,
hf_nfs_client_id4_id);
}
}
if (fitem) {
newftree = proto_item_add_subtree(fitem, ett_nfs_cb_client4);
if (newftree)
- offset = dissect_nfs_cb_client4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_cb_client4(tvb, offset, newftree,
"callback");
}
}
break;
case NFS4_OP_SETCLIENTID_CONFIRM:
- offset = dissect_nfs_clientid4(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_clientid4(tvb, offset, newftree);
break;
case NFS4_OP_VERIFY:
break;
case NFS4_OP_WRITE:
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, newftree);
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_offset4,
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_offset4,
offset);
- offset = dissect_nfs_stable_how4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_stable_how4(tvb, offset, newftree,
"stable");
- offset = dissect_nfs_opaque4(tvb, offset, pinfo, newftree, "data");
+ offset = dissect_nfs_opaque4(tvb, offset, newftree, "data");
break;
default:
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, pinfo, tree, hf_nfs_minorversion,
+ offset = dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_tag4, NULL);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nfs_minorversion,
offset);
offset = dissect_nfs_argop4(tvb, offset, pinfo, tree);
int
dissect_nfs_resop4(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, char *name)
+ proto_tree *tree, char *name _U_)
{
+ /* TODO: use parameter "name" */
guint ops, ops_counter;
guint opcode;
proto_item *fitem;
if (newftree == NULL)
break; /* error adding new subtree to operation item */
- offset = dissect_nfs_nfsstat4(tvb, offset, pinfo, newftree, &status);
+ offset = dissect_nfs_nfsstat4(tvb, offset, newftree, &status);
/*
* With the exception of NFS4_OP_LOCK, NFS4_OP_LOCKT, and
switch(opcode)
{
case NFS4_OP_ACCESS:
- offset = dissect_access(tvb, offset, pinfo, newftree, "Supported");
- offset = dissect_access(tvb, offset, pinfo, newftree, "Access");
+ offset = dissect_access(tvb, offset, newftree, "Supported");
+ offset = dissect_access(tvb, offset, newftree, "Access");
break;
case NFS4_OP_CLOSE:
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
break;
case NFS4_OP_COMMIT:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_verifier4,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_verifier4,
offset);
break;
case NFS4_OP_CREATE:
- offset = dissect_nfs_change_info4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"change_info");
offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
"attrsset", FATTR4_BITMAP_ONLY);
break;
case NFS4_OP_LINK:
- offset = dissect_nfs_change_info4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"change_info");
break;
case NFS4_OP_LOCK:
case NFS4_OP_LOCKT:
if (status == NFS4_OK)
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
else
if (status == NFS4ERR_DENIED)
- offset = dissect_nfs_lock4denied(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_lock4denied(tvb, offset, newftree,
"denied");
break;
case NFS4_OP_LOCKU:
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
break;
case NFS4_OP_OPEN:
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, newftree);
- offset = dissect_nfs_change_info4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"change_info");
- offset = dissect_nfs_open4_rflags(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_open4_rflags(tvb, offset, newftree,
"result_flags");
offset = dissect_nfs_attributes(tvb, offset, pinfo, newftree,
"attrsset", FATTR4_BITMAP_ONLY);
- offset = dissect_nfs_open_delegation4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_open_delegation4(tvb, offset, newftree,
"delegation");
break;
case NFS4_OP_OPEN_CONFIRM:
case NFS4_OP_OPEN_DOWNGRADE:
- offset = dissect_nfs_stateid4(tvb, offset, pinfo, newftree);
+ offset = dissect_nfs_stateid4(tvb, offset, newftree);
break;
case NFS4_OP_READ:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_eof,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_eof,
offset);
- offset = dissect_nfs_opaque4(tvb, offset, pinfo, newftree, "data");
+ offset = dissect_nfs_opaque4(tvb, offset, newftree, "data");
break;
case NFS4_OP_READDIR:
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_verifier4,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_verifier4,
offset);
offset = dissect_nfs_dirlist4(tvb, offset, pinfo, newftree, "reply");
break;
case NFS4_OP_READLINK:
- offset = dissect_nfs_linktext4(tvb, offset, pinfo, newftree, "link");
+ offset = dissect_nfs_linktext4(tvb, offset, newftree, "link");
break;
case NFS4_OP_REMOVE:
- offset = dissect_nfs_change_info4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"change_info");
break;
case NFS4_OP_RENAME:
- offset = dissect_nfs_change_info4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"source_cinfo");
- offset = dissect_nfs_change_info4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_change_info4(tvb, offset, newftree,
"target_cinfo");
break;
ett_nfs_secinfo4_flavor_info);
if (secftree)
offset = dissect_nfs_rpcsec_gss_info(tvb, offset,
- pinfo, secftree);
+ secftree);
break;
default:
case NFS4_OP_SETCLIENTID:
if (status == NFS4_OK)
- offset = dissect_rpc_uint64(tvb, pinfo, newftree,
+ offset = dissect_rpc_uint64(tvb, newftree,
hf_nfs_clientid4, offset);
else
if (status == NFS4ERR_CLID_INUSE)
- offset = dissect_nfs_clientaddr4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_clientaddr4(tvb, offset, newftree,
"client_using");
break;
case NFS4_OP_WRITE:
- offset = dissect_rpc_uint32(tvb, pinfo, newftree, hf_nfs_count4,
+ offset = dissect_rpc_uint32(tvb, newftree, hf_nfs_count4,
offset);
- offset = dissect_nfs_stable_how4(tvb, offset, pinfo, newftree,
+ offset = dissect_nfs_stable_how4(tvb, offset, newftree,
"committed");
- offset = dissect_rpc_uint64(tvb, pinfo, newftree, hf_nfs_verifier4,
+ offset = dissect_rpc_uint64(tvb, newftree, hf_nfs_verifier4,
offset);
break;
{
guint32 status;
- offset = dissect_nfs_nfsstat4(tvb, offset, pinfo, tree, &status);
- offset = dissect_nfs_utf8string(tvb, offset, pinfo, tree, hf_nfs_tag4, NULL);
+ offset = dissect_nfs_nfsstat4(tvb, offset, tree, &status);
+ offset = dissect_nfs_utf8string(tvb, offset, tree, hf_nfs_tag4, NULL);
offset = dissect_nfs_resop4(tvb, offset, pinfo, tree, "arguments");
return offset;
/* packet-nisplus.c
* 2001 Ronnie Sahlberg <See AUTHORS for email>
*
- * $Id: packet-nisplus.c,v 1.10 2002/01/20 22:12:27 guy Exp $
+ * $Id: packet-nisplus.c,v 1.11 2002/04/03 13:24:12 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
static int
-dissect_nisplus_time(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree, int hfindex)
+dissect_nisplus_time(tvbuff_t *tvb, int offset, proto_tree *tree, int hfindex)
{
nstime_t ts;
}
static int
-dissect_group(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_group(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_nisplus_group_name, offset, NULL);
return offset;
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_group);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nisplus_group_flags, offset);
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
static int
-dissect_access_rights(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_access_rights(tvbuff_t *tvb, int offset, proto_tree *tree)
{
proto_item* mask_item = NULL;
proto_tree* mask_tree = NULL;
}
static int
-dissect_table(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_table(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_table_col);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_table_col_name, offset, NULL);
tvb, offset, 4, mask);
offset += 4;
- offset = dissect_access_rights(tvb, offset, pinfo, lock_tree);
+ offset = dissect_access_rights(tvb, offset, lock_tree);
proto_item_set_len(lock_item, offset-old_offset);
return offset;
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_table);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_table_type, offset, NULL);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nisplus_table_maxcol, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nisplus_table_sep, offset);
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
dissect_table, hf_nisplus_table_cols);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_table_path, offset, NULL);
proto_item_set_len(lock_item, offset-old_offset);
}
static int
-dissect_entry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_entry(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
proto_tree_add_boolean(mask_tree, hf_nisplus_entry_mask_asn, tvb, offset, 4, mask);
offset += 4;
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_entry_val, offset, NULL);
proto_item_set_len(lock_item, offset-old_offset);
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_entry);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_entry_type, offset, NULL);
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
}
static int
-dissect_attr(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_attr(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_attr);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_attr_name, offset, NULL);
- offset = dissect_rpc_data(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_data(tvb, lock_tree,
hf_nisplus_attr_val, offset);
proto_item_set_len(lock_item, offset-old_offset);
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_link);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nisplus_object_type, offset);
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
dissect_attr, hf_nisplus_attrs_array);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_object_name, offset, NULL);
proto_item_set_len(lock_item, offset-old_offset);
static int
-dissect_endpoint(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_endpoint(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_endpoint);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_endpoint_uaddr, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_endpoint_family, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_endpoint_proto, offset, NULL);
proto_item_set_len(lock_item, offset-old_offset);
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_server);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_server_name, offset, NULL);
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
dissect_endpoint, hf_nisplus_endpoints);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nisplus_key_type, offset);
- offset = dissect_rpc_data(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_data(tvb, lock_tree,
hf_nisplus_key_data, offset);
proto_item_set_len(lock_item, offset-old_offset);
static int
-dissect_directory_mask(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_directory_mask(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_directory_mask);
- offset = dissect_access_rights(tvb, offset, pinfo, lock_tree);
+ offset = dissect_access_rights(tvb, offset, lock_tree);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nisplus_object_type, offset);
proto_item_set_len(lock_item, offset-old_offset);
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_directory);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_directory_name, offset, NULL);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nisplus_directory_type, offset);
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
dissect_directory_server, hf_nisplus_servers);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nisplus_directory_ttl, offset);
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
}
static int
-dissect_nisplus_oid(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_nisplus_oid(tvbuff_t *tvb, int offset, proto_tree *tree)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_oid);
- offset = dissect_nisplus_time(tvb, offset, pinfo, lock_tree,
+ offset = dissect_nisplus_time(tvb, offset, lock_tree,
hf_nisplus_object_ctime);
- offset = dissect_nisplus_time(tvb, offset, pinfo, lock_tree,
+ offset = dissect_nisplus_time(tvb, offset, lock_tree,
hf_nisplus_object_mtime);
proto_item_set_len(lock_item, offset-old_offset);
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_object);
- offset = dissect_nisplus_oid(tvb, offset, pinfo, lock_tree);
+ offset = dissect_nisplus_oid(tvb, offset, lock_tree);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_object_name, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_object_owner, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_object_group, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_object_domain, offset, NULL);
- offset = dissect_access_rights(tvb, offset, pinfo, lock_tree);
+ offset = dissect_access_rights(tvb, offset, lock_tree);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nisplus_object_ttl, offset);
type = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nisplus_object_type, offset);
switch (type) {
case NIS_DIRECTORY_OBJ:
offset = dissect_link_obj(tvb, offset, pinfo, lock_tree);
break;
case NIS_PRIVATE_OBJ:
- offset = dissect_rpc_data(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_data(tvb, lock_tree,
hf_nisplus_object_private, offset);
break;
case NIS_NO_OBJ:
static int
dissect_ns_request(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_nisplus_object_name, offset, NULL);
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
static int
dissect_ib_request(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_nisplus_object_name, offset, NULL);
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
dissect_attr, hf_nisplus_attrs_array);
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nisplus_ib_flags, offset);
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
dissect_directory_server, hf_nisplus_cbservers);
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nisplus_ib_bufsize, offset);
- offset = dissect_rpc_data(tvb, pinfo, tree,
+ offset = dissect_rpc_data(tvb, tree,
hf_nisplus_cookie, offset);
return offset;
}
static int
-dissect_fd_args(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_fd_args(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_nisplus_fd_dirname, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_nisplus_fd_requester, offset, NULL);
return offset;
}
static int
-dissect_nisplus_tag(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_nisplus_tag(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_tag);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nisplus_tag_type, offset);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_tag_val, offset, NULL);
proto_item_set_len(lock_item, offset-old_offset);
static int
dissect_dump_args(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_nisplus_dump_dir, offset, NULL);
- offset = dissect_nisplus_time(tvb, offset, pinfo, tree,
+ offset = dissect_nisplus_time(tvb, offset, tree,
hf_nisplus_dump_time);
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
}
static int
-dissect_netobj(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_netobj(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_data(tvb, pinfo, tree,
+ offset = dissect_rpc_data(tvb, tree,
hf_nisplus_dummy, offset);
return offset;
}
static int
-dissect_nisname(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_nisname(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_nisplus_object_name, offset, NULL);
return offset;
}
static int
-dissect_ping_args(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_ping_args(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_nisplus_ping_dir, offset, NULL);
- offset = dissect_nisplus_time(tvb, offset, pinfo, tree,
+ offset = dissect_nisplus_time(tvb, offset, tree,
hf_nisplus_ping_time);
return offset;
static int
dissect_nisplus_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nisplus_error, offset);
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
dissect_nisplus_object, hf_nisplus_object);
- offset = dissect_rpc_data(tvb, pinfo, tree,
+ offset = dissect_rpc_data(tvb, tree,
hf_nisplus_cookie, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nisplus_zticks, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nisplus_dticks, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nisplus_aticks, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nisplus_cticks, offset);
return offset;
}
static int
-dissect_fd_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_fd_result(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nisplus_error, offset);
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_nisplus_fd_dirname, offset, NULL);
- offset = dissect_rpc_data(tvb, pinfo, tree,
+ offset = dissect_rpc_data(tvb, tree,
hf_nisplus_dir_data, offset);
- offset = dissect_rpc_data(tvb, pinfo, tree,
+ offset = dissect_rpc_data(tvb, tree,
hf_nisplus_signature, offset);
return offset;
lock_tree = proto_item_add_subtree(lock_item, ett_nisplus_log_entry);
- offset = dissect_nisplus_time(tvb, offset, pinfo, lock_tree,
+ offset = dissect_nisplus_time(tvb, offset, lock_tree,
hf_nisplus_log_time);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nisplus_log_type, offset);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_log_principal, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_nisplus_directory_name, offset, NULL);
offset = dissect_rpc_array(tvb, pinfo, lock_tree, offset,
static int
dissect_log_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nisplus_error, offset);
- offset = dissect_rpc_data(tvb, pinfo, tree,
+ offset = dissect_rpc_data(tvb, tree,
hf_nisplus_cookie, offset);
offset = dissect_rpc_array(tvb, pinfo, tree, offset,
}
static int
-dissect_callback_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_callback_result(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nisplus_callback_status,
+ offset = dissect_rpc_bool(tvb, tree, hf_nisplus_callback_status,
offset);
return offset;
}
static int
-dissect_change_time(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_change_time(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_nisplus_time(tvb, offset, pinfo, tree,
+ offset = dissect_nisplus_time(tvb, offset, tree,
hf_nisplus_log_time);
return offset;
}
static int
-dissect_cp_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_cp_result(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nisplus_cp_status, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nisplus_cp_zticks, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nisplus_cp_dticks, offset);
return offset;
}
static int
-dissect_nisplus_error(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_nisplus_error(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_nisplus_error, offset);
return offset;
static gint ett_nispluscb_entry = -1;
static int
-dissect_cb_entry(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_cb_entry(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
/* packet-nlm.c
* Routines for nlm dissection
*
- * $Id: packet-nlm.c,v 1.23 2002/01/24 09:20:50 guy Exp $
+ * $Id: packet-nlm.c,v 1.24 2002/04/03 13:24:12 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
lock_tree = proto_item_add_subtree(lock_item, ett_nlm_lock);
}
- offset = dissect_rpc_string(tvb,pinfo,lock_tree,
+ offset = dissect_rpc_string(tvb,lock_tree,
hf_nlm_lock_caller_name, offset, NULL);
offset = dissect_nfs_fh3(tvb, offset, pinfo, lock_tree,"fh");
- offset = dissect_rpc_data(tvb, pinfo, lock_tree, hf_nlm_lock_owner, offset);
+ offset = dissect_rpc_data(tvb, lock_tree, hf_nlm_lock_owner, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_lock_svid, offset);
+ offset = dissect_rpc_uint32(tvb, lock_tree, hf_nlm_lock_svid, offset);
if (version == 4) {
- offset = dissect_rpc_uint64(tvb, pinfo, lock_tree, hf_nlm_lock_l_offset64, offset);
- offset = dissect_rpc_uint64(tvb, pinfo, lock_tree, hf_nlm_lock_l_len64, offset);
+ offset = dissect_rpc_uint64(tvb, lock_tree, hf_nlm_lock_l_offset64, offset);
+ offset = dissect_rpc_uint64(tvb, lock_tree, hf_nlm_lock_l_len64, offset);
}
else {
- 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);
+ offset = dissect_rpc_uint32(tvb, lock_tree, hf_nlm_lock_l_offset, offset);
+ offset = dissect_rpc_uint32(tvb, lock_tree, hf_nlm_lock_l_len, offset);
}
return offset;
dissect_nlm_test(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, int version)
{
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
- dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_exclusive, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_nlm_cookie, offset);
+ dissect_rpc_bool(tvb, tree, hf_nlm_exclusive, offset);
offset += 4;
offset = dissect_lock(tvb, pinfo, tree, version, offset);
return offset;
dissect_nlm_lock(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree,int version)
{
- offset = dissect_rpc_data(tvb, 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_rpc_data(tvb, tree, hf_nlm_cookie, offset);
+ offset = dissect_rpc_bool(tvb, tree, hf_nlm_block, offset);
+ offset = dissect_rpc_bool(tvb, tree, hf_nlm_exclusive, offset);
offset = dissect_lock(tvb, pinfo, tree, version, offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_reclaim, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_state, offset);
+ offset = dissect_rpc_bool(tvb, tree, hf_nlm_reclaim, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nlm_state, offset);
return offset;
}
dissect_nlm_cancel(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree,int version)
{
- offset = dissect_rpc_data(tvb, 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_rpc_data(tvb, tree, hf_nlm_cookie, offset);
+ offset = dissect_rpc_bool(tvb, tree, hf_nlm_block, offset);
+ offset = dissect_rpc_bool(tvb, tree, hf_nlm_exclusive, offset);
offset = dissect_lock(tvb, pinfo, tree, version, offset);
return offset;
}
dissect_nlm_unlock(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree,int version)
{
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_nlm_cookie, offset);
offset = dissect_lock(tvb, pinfo, tree, version, offset);
return offset;
}
dissect_nlm_granted(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree,int version)
{
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_exclusive, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_nlm_cookie, offset);
+ offset = dissect_rpc_bool(tvb, tree, hf_nlm_exclusive, offset);
offset = dissect_lock(tvb, pinfo, tree, version, offset);
return offset;
}
static int
-dissect_nlm_test_res(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nlm_test_res(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree,int version)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_nlm_cookie, offset);
if (tree) {
lock_item = proto_tree_add_item(tree, hf_nlm_test_stat, tvb,
ett_nlm_lock);
}
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_test_stat_stat,
+ offset = dissect_rpc_uint32(tvb, lock_tree, hf_nlm_test_stat_stat,
offset);
/* last structure is optional, only supplied for stat==1 (LOCKED) */
ett_nlm_lock);
}
- offset = dissect_rpc_bool(tvb, pinfo, lock_tree, hf_nlm_exclusive,
+ offset = dissect_rpc_bool(tvb, lock_tree, hf_nlm_exclusive,
offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree, hf_nlm_lock_svid,
+ offset = dissect_rpc_uint32(tvb, lock_tree, hf_nlm_lock_svid,
offset);
- offset = dissect_rpc_data(tvb, pinfo, lock_tree, hf_nlm_lock_owner,
+ offset = dissect_rpc_data(tvb, lock_tree, hf_nlm_lock_owner,
offset);
if (version == 4) {
- offset = dissect_rpc_uint64(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint64(tvb, lock_tree,
hf_nlm_lock_l_offset64, offset);
- offset = dissect_rpc_uint64(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint64(tvb, lock_tree,
hf_nlm_lock_l_len64, offset);
}
else {
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nlm_lock_l_offset, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_nlm_lock_l_len, offset);
}
static int
dissect_nlm_share(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree,int version)
+ proto_tree *tree,int version _U_)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_nlm_cookie, offset);
if (tree) {
lock_item = proto_tree_add_item(tree, hf_nlm_share, tvb,
ett_nlm_lock);
}
- offset = dissect_rpc_string(tvb,pinfo,lock_tree,
+ offset = dissect_rpc_string(tvb,lock_tree,
hf_nlm_lock_caller_name, offset, NULL);
offset = dissect_nfs_fh3(tvb, offset, pinfo, lock_tree, "fh");
- offset = dissect_rpc_data(tvb, pinfo, lock_tree, hf_nlm_lock_owner, offset);
+ offset = dissect_rpc_data(tvb, lock_tree, hf_nlm_lock_owner, 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_uint32(tvb, lock_tree, hf_nlm_share_mode, offset);
+ offset = dissect_rpc_uint32(tvb, lock_tree, hf_nlm_share_access, offset);
- offset = dissect_rpc_bool(tvb, pinfo, tree, hf_nlm_reclaim, offset);
+ offset = dissect_rpc_bool(tvb, tree, hf_nlm_reclaim, offset);
return offset;
}
static int
-dissect_nlm_shareres(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree, int version)
+dissect_nlm_shareres(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
+ proto_tree *tree, int version _U_)
{
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_stat, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_sequence, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_nlm_cookie, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nlm_stat, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nlm_sequence, offset);
return offset;
}
static int
-dissect_nlm_freeall(tvbuff_t *tvb, int offset, packet_info *pinfo,
- proto_tree *tree,int version)
+dissect_nlm_freeall(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
+ proto_tree *tree,int version _U_)
{
- offset = dissect_rpc_string(tvb,pinfo,tree,
+ offset = dissect_rpc_string(tvb,tree,
hf_nlm_share_name, offset, NULL);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_stat, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nlm_stat, offset);
return offset;
}
/* This function is identical for all NLM protocol versions (1-4)*/
static int
-dissect_nlm_gen_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_nlm_gen_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_nlm_cookie, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_nlm_stat, offset);
+ offset = dissect_rpc_data(tvb, tree, hf_nlm_cookie, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_nlm_stat, offset);
return offset;
}
/* packet-pcnfsd.c
* Routines for PCNFSD dissection
*
- * $Id: packet-pcnfsd.c,v 1.5 2002/01/30 23:08:26 guy Exp $
+ * $Id: packet-pcnfsd.c,v 1.6 2002/04/03 13:24:12 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
/* "NFS Illustrated" 14.7.13 */
int
-dissect_pcnfsd2_auth_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_pcnfsd2_auth_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
int newoffset;
proto_item *password_item = NULL;
proto_tree *password_tree = NULL;
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_pcnfsd_auth_client, offset, NULL);
if (tree) {
ident_tree = proto_item_add_subtree(
ident_item, ett_pcnfsd_auth_ident);
}
- newoffset = dissect_rpc_string(tvb, pinfo, ident_tree,
+ newoffset = dissect_rpc_string(tvb, ident_tree,
hf_pcnfsd_auth_ident_obscure, offset, &ident);
if (ident_item) {
proto_item_set_len(ident_item, newoffset-offset);
password_tree = proto_item_add_subtree(
password_item, ett_pcnfsd_auth_password);
}
- newoffset = dissect_rpc_string(tvb, pinfo, password_tree,
+ newoffset = dissect_rpc_string(tvb, password_tree,
hf_pcnfsd_auth_password_obscure, offset, &password);
if (password_item) {
proto_item_set_len(password_item, newoffset-offset);
offset = newoffset;
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_pcnfsd_comment, offset, NULL);
return offset;
/* "NFS Illustrated" 14.7.13 */
int
-dissect_pcnfsd2_auth_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_pcnfsd2_auth_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
int gids_count;
proto_tree *gtree = NULL;
int gids_i;
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_pcnfsd_status, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_pcnfsd_uid, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_pcnfsd_gid, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_pcnfsd_status, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_pcnfsd_uid, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_pcnfsd_gid, offset);
gids_count = tvb_get_ntohl(tvb,offset+0);
if (tree) {
gitem = proto_tree_add_text(tree, tvb,
}
offset += 4;
for (gids_i = 0 ; gids_i < gids_count ; gids_i++) {
- offset = dissect_rpc_uint32(tvb, pinfo, gtree,
+ offset = dissect_rpc_uint32(tvb, gtree,
hf_pcnfsd_gid, offset);
}
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_pcnfsd_homedir, offset, NULL);
/* should be signed int32 */
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_pcnfsd_def_umask, offset);
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree, hf_pcnfsd_def_umask, offset);
+ offset = dissect_rpc_string(tvb, tree,
hf_pcnfsd_comment, offset, NULL);
return offset;
/* packet-portmap.c
* Routines for portmap dissection
*
- * $Id: packet-portmap.c,v 1.33 2002/01/20 22:12:27 guy Exp $
+ * $Id: packet-portmap.c,v 1.34 2002/04/03 13:24:12 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
/* Dissect a getport call */
-int dissect_getport_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+int dissect_getport_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
guint32 proto;
return offset+16;
}
-int dissect_getport_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+int dissect_getport_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_portmap_port,
+ offset = dissect_rpc_uint32(tvb, tree, hf_portmap_port,
offset);
return offset;
}
/* Dissect a 'set' call */
-int dissect_set_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+int dissect_set_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
guint32 proto;
}
/* Dissect a 'unset' call */
-int dissect_unset_call(tvbuff_t *tvb, int offset, packet_info *pinfo,
+int dissect_unset_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
guint32 proto;
return offset+16;
}
-int dissect_set_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+int dissect_set_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
- offset = dissect_rpc_bool(tvb, pinfo, tree, hf_portmap_answer,
+ offset = dissect_rpc_bool(tvb, tree, hf_portmap_answer,
offset);
return offset;
}
static int
-dissect_dump_entry(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_dump_entry(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
int prog, version, proto, port;
/* RFC 1833, Page 3 */
static int
-dissect_rpcb(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_rpcb(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item* rpcb_item = NULL;
proto_tree* rpcb_tree = NULL;
"Program: %s (%u)", rpc_prog_name(prog), prog);
offset += 4;
- offset = dissect_rpc_uint32(tvb, pinfo, rpcb_tree,
+ offset = dissect_rpc_uint32(tvb, rpcb_tree,
hf_portmap_rpcb_version, offset);
- offset = dissect_rpc_string(tvb, pinfo, rpcb_tree,
+ offset = dissect_rpc_string(tvb, rpcb_tree,
hf_portmap_rpcb_netid, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, rpcb_tree,
+ offset = dissect_rpc_string(tvb, rpcb_tree,
hf_portmap_rpcb_addr, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, rpcb_tree,
+ offset = dissect_rpc_string(tvb, rpcb_tree,
hf_portmap_rpcb_owner, offset, NULL);
/* now we know, that rpcb is shorter */
/* RFC 1833, Page 7 */
-int dissect_rpcb3_getaddr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo,
+int dissect_rpcb3_getaddr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_portmap_uaddr, offset, NULL);
return offset;
}
/* RFC 1833, page 4 */
-int dissect_rpcb_rmtcallres(tvbuff_t *tvb, int offset, packet_info *pinfo,
+int dissect_rpcb_rmtcallres(tvbuff_t *tvb, int offset, packet_info *pinfo _U_,
proto_tree *tree)
{
/* Dissect the remote universal address. */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_portmap_rpcb_addr, offset, NULL);
/* Dissect the result of this procedure.
* Routines for rpc dissection
* Copyright 1999, Uwe Girlich <Uwe.Girlich@philosys.de>
*
- * $Id: packet-rpc.c,v 1.89 2002/04/01 23:56:41 guy Exp $
+ * $Id: packet-rpc.c,v 1.90 2002/04/03 13:24:12 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
int
-dissect_rpc_bool(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_bool(tvbuff_t *tvb, proto_tree *tree,
int hfindex, int offset)
{
if (tree)
int
-dissect_rpc_uint32(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_uint32(tvbuff_t *tvb, proto_tree *tree,
int hfindex, int offset)
{
if (tree)
int
-dissect_rpc_uint64(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_uint64(tvbuff_t *tvb, proto_tree *tree,
int hfindex, int offset)
{
header_field_info *hfinfo;
static int
-dissect_rpc_opaque_data(tvbuff_t *tvb, int offset, packet_info *pinfo,
+dissect_rpc_opaque_data(tvbuff_t *tvb, int offset,
proto_tree *tree, int hfindex, gboolean string_data,
char **string_buffer_ret)
{
int
-dissect_rpc_string(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_string(tvbuff_t *tvb, proto_tree *tree,
int hfindex, int offset, char **string_buffer_ret)
{
- offset = dissect_rpc_opaque_data(tvb, offset, pinfo, tree,
+ offset = dissect_rpc_opaque_data(tvb, offset, tree,
hfindex, TRUE, string_buffer_ret);
return offset;
}
int
-dissect_rpc_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_data(tvbuff_t *tvb, proto_tree *tree,
int hfindex, int offset)
{
- offset = dissect_rpc_opaque_data(tvb, offset, pinfo, tree, hfindex,
+ offset = dissect_rpc_opaque_data(tvb, offset, tree, hfindex,
FALSE, NULL);
return offset;
lock_tree = proto_item_add_subtree(lock_item, ett_rpc_array);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_rpc_array_len, offset);
while (num--) {
}
static int
-dissect_rpc_authunix_cred(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset)
+dissect_rpc_authunix_cred(tvbuff_t* tvb, proto_tree* tree, int offset)
{
guint stamp;
guint uid;
offset+0, 4, stamp);
offset += 4;
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_rpc_auth_machinename, offset, NULL);
uid = tvb_get_ntohl(tvb,offset+0);
}
static int
-dissect_rpc_authgss_cred(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset)
+dissect_rpc_authgss_cred(tvbuff_t* tvb, proto_tree* tree, int offset)
{
guint agc_v;
guint agc_proc;
tvb, offset+0, 4, agc_svc);
offset += 4;
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_ctx,
+ offset = dissect_rpc_data(tvb, tree, hf_rpc_authgss_ctx,
offset);
return offset;
}
static int
-dissect_rpc_authdes_desblock(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
+dissect_rpc_authdes_desblock(tvbuff_t *tvb, proto_tree *tree,
int hfindex, int offset)
{
guint32 value_low;
}
static int
-dissect_rpc_authdes_cred(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset)
+dissect_rpc_authdes_cred(tvbuff_t* tvb, proto_tree* tree, int offset)
{
guint adc_namekind;
guint window = 0;
switch(adc_namekind)
{
case AUTHDES_NAMEKIND_FULLNAME:
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_rpc_authdes_netname, offset, NULL);
- offset = dissect_rpc_authdes_desblock(tvb, pinfo, tree,
+ offset = dissect_rpc_authdes_desblock(tvb, 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,
}
static int
-dissect_rpc_cred(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset)
+dissect_rpc_cred(tvbuff_t* tvb, proto_tree* tree, int offset)
{
guint flavor;
guint length;
switch (flavor) {
case AUTH_UNIX:
- dissect_rpc_authunix_cred(tvb, pinfo, ctree, offset+8);
+ dissect_rpc_authunix_cred(tvb, ctree, offset+8);
break;
/*
case AUTH_SHORT:
break;
*/
case AUTH_DES:
- dissect_rpc_authdes_cred(tvb, pinfo, ctree, offset+8);
+ dissect_rpc_authdes_cred(tvb, ctree, offset+8);
break;
case RPCSEC_GSS:
- dissect_rpc_authgss_cred(tvb, pinfo, ctree, offset+8);
+ dissect_rpc_authgss_cred(tvb, ctree, offset+8);
break;
default:
if (length)
* verifier we're decoding (CALL or REPLY).
*/
static int
-dissect_rpc_verf(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset, int msg_type)
+dissect_rpc_verf(tvbuff_t* tvb, proto_tree* tree, int offset, int msg_type)
{
guint flavor;
guint length;
case AUTH_UNIX:
proto_tree_add_uint(vtree, hf_rpc_auth_length, tvb,
offset+4, 4, length);
- dissect_rpc_authunix_cred(tvb, pinfo, vtree, offset+8);
+ dissect_rpc_authunix_cred(tvb, vtree, offset+8);
break;
case AUTH_DES:
proto_tree_add_uint(vtree, hf_rpc_auth_length, tvb,
{
guint window;
- dissect_rpc_authdes_desblock(tvb, pinfo, vtree,
+ dissect_rpc_authdes_desblock(tvb, vtree,
hf_rpc_authdes_timestamp, offset+8);
window = tvb_get_ntohl(tvb, offset+16);
proto_tree_add_uint(vtree, hf_rpc_authdes_windowverf, tvb,
/* must be an RPC_REPLY */
guint nickname;
- dissect_rpc_authdes_desblock(tvb, pinfo, vtree,
+ dissect_rpc_authdes_desblock(tvb, vtree,
hf_rpc_authdes_timeverf, offset+8);
nickname = tvb_get_ntohl(tvb, offset+16);
proto_tree_add_uint(vtree, hf_rpc_authdes_nickname, tvb,
}
break;
case RPCSEC_GSS:
- dissect_rpc_data(tvb, pinfo, vtree,
+ dissect_rpc_data(tvb, vtree,
hf_rpc_authgss_checksum, offset+4);
break;
default:
}
static int
-dissect_rpc_authgss_initarg(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset)
+dissect_rpc_authgss_initarg(tvbuff_t* tvb, proto_tree* tree, int offset)
{
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_token,
+ offset = dissect_rpc_data(tvb, tree, hf_rpc_authgss_token,
offset);
return offset;
}
static int
-dissect_rpc_authgss_initres(tvbuff_t* tvb, packet_info* pinfo, proto_tree* tree, int offset)
+dissect_rpc_authgss_initres(tvbuff_t* tvb, proto_tree* tree, int offset)
{
int major, minor, window;
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_ctx,
+ offset = dissect_rpc_data(tvb, tree, hf_rpc_authgss_ctx,
offset);
major = tvb_get_ntohl(tvb,offset+0);
offset+0, 4, window);
offset += 4;
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_token,
+ offset = dissect_rpc_data(tvb, tree, hf_rpc_authgss_token,
offset);
return offset;
dissect_function, progname);
}
offset += length - 4;
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_checksum,
+ offset = dissect_rpc_data(tvb, tree, hf_rpc_authgss_checksum,
offset);
return offset;
}
static int
-dissect_rpc_authgss_priv_data(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset)
+dissect_rpc_authgss_priv_data(tvbuff_t *tvb, proto_tree *tree, int offset)
{
- offset = dissect_rpc_data(tvb, pinfo, tree, hf_rpc_authgss_data,
+ offset = dissect_rpc_data(tvb, tree, hf_rpc_authgss_data,
offset);
return offset;
}
Happens only with strange program versions or
non-existing dissectors.
Just show the arguments as opaque data. */
- offset = dissect_rpc_data(tvb, pinfo, tree, args_id,
+ offset = dissect_rpc_data(tvb, tree, args_id,
offset);
return offset;
}
/* 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, pinfo, tree, result_id,
+ offset = dissect_rpc_data(tvb, tree, result_id,
offset);
return offset;
}
/* The XID doesn't match a call from that
conversation, so it's probably not an RPC reply.
Just show the reply stuff as opaque data. */
- offset = dissect_rpc_data(tvb, pinfo, tree, result_id,
+ offset = dissect_rpc_data(tvb, tree, result_id,
offset);
return offset;
}
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, pinfo, tree, result_id,
+ offset = dissect_rpc_data(tvb, tree, result_id,
offset);
return offset;
}
offset += 16;
- offset = dissect_rpc_cred(tvb, pinfo, rpc_tree, offset);
- offset = dissect_rpc_verf(tvb, pinfo, rpc_tree, offset, msg_type);
+ offset = dissect_rpc_cred(tvb, rpc_tree, offset);
+ offset = dissect_rpc_verf(tvb, rpc_tree, offset, msg_type);
/* pass rpc_info to subdissectors */
rpc_call->request=TRUE;
offset += 4;
if (reply_state == MSG_ACCEPTED) {
- offset = dissect_rpc_verf(tvb, pinfo, rpc_tree, offset, msg_type);
+ offset = dissect_rpc_verf(tvb, rpc_tree, offset, msg_type);
accept_state = tvb_get_ntohl(tvb,offset+0);
if (rpc_tree) {
proto_tree_add_uint(rpc_tree, hf_rpc_state_accept, tvb,
case RPCSEC_GSS_CONTINUE_INIT:
if (msg_type == RPC_CALL) {
offset = dissect_rpc_authgss_initarg(tvb,
- pinfo, ptree, offset);
+ ptree, offset);
}
else {
offset = dissect_rpc_authgss_initres(tvb,
- pinfo, ptree, offset);
+ ptree, offset);
}
break;
}
else if (gss_svc == RPCSEC_GSS_SVC_PRIVACY) {
offset = dissect_rpc_authgss_priv_data(tvb,
- pinfo, ptree, offset);
+ ptree, offset);
}
break;
conversation_t *conversation;
fragment_data *ipfd_head;
tvbuff_t *rec_tvb;
- fragment_data *ipfd;
/*
* Get the record mark.
/* packet-rpc.h
*
- * $Id: packet-rpc.h,v 1.34 2002/04/02 00:18:53 guy Exp $
+ * $Id: packet-rpc.h,v 1.35 2002/04/03 13:24:13 girlich Exp $
*
* (c) 1999 Uwe Girlich
*
extern char *rpc_proc_name(guint32 prog, guint32 vers, guint32 proc);
extern unsigned int rpc_roundup(unsigned int a);
-extern int dissect_rpc_bool(tvbuff_t *tvb, packet_info *pinfo,
+extern int dissect_rpc_bool(tvbuff_t *tvb,
proto_tree *tree, int hfindex, int offset);
-extern int dissect_rpc_string(tvbuff_t *tvb, packet_info *pinfo,
+extern int dissect_rpc_string(tvbuff_t *tvb,
proto_tree *tree, int hfindex, int offset, char **string_buffer_ret);
-extern int dissect_rpc_data(tvbuff_t *tvb, packet_info *pinfo,
+extern int dissect_rpc_data(tvbuff_t *tvb,
proto_tree *tree, int hfindex, int offset);
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(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree, int offset, dissect_function_t *rpc_array_dissector,
int hfindex);
-extern int dissect_rpc_uint32(tvbuff_t *tvb, packet_info *pinfo,
+extern int dissect_rpc_uint32(tvbuff_t *tvb,
proto_tree *tree, int hfindex, int offset);
-extern int dissect_rpc_uint64(tvbuff_t *tvb, packet_info *pinfo,
+extern int dissect_rpc_uint64(tvbuff_t *tvb,
proto_tree *tree, int hfindex, int offset);
extern int dissect_rpc_indir_call(tvbuff_t *tvb, packet_info *pinfo,
* Routines for rquota dissection
* Copyright 2001, Mike Frisch <frisch@hummingbird.com>
*
- * $Id: packet-rquota.c,v 1.6 2002/01/24 09:20:51 guy Exp $
+ * $Id: packet-rquota.c,v 1.7 2002/04/03 13:24:13 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
static int
-dissect_rquota(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_rquota(tvbuff_t *tvb, int offset, proto_tree *tree)
{
proto_item *lock_item = NULL;
lock_tree = proto_item_add_subtree(lock_item, ett_rquota_rquota);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_rquota_bsize, offset);
- offset = dissect_rpc_bool(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_bool(tvb, lock_tree,
hf_rquota_active, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_rquota_bhardlimit, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_rquota_bsoftlimit, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_rquota_curblocks, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_rquota_fhardlimit, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_rquota_fsoftlimit, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_rquota_curfiles, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_rquota_btimeleft, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_rquota_ftimeleft, offset);
return offset;
}
static int
-dissect_getquota_result(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_getquota_result(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
gint32 status;
status = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_rquota_status, offset);
if (status==Q_OK) {
- offset = dissect_rquota(tvb, offset, pinfo, tree);
+ offset = dissect_rquota(tvb, offset, tree);
}
return offset;
}
static int
-dissect_getquota_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_getquota_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_rquota_pathp, offset, NULL);
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_rquota_uid, offset);
return offset;
/* packet-rwall.c
*
- * $Id: packet-rwall.c,v 1.4 2001/06/18 02:17:52 guy Exp $
+ * $Id: packet-rwall.c,v 1.5 2002/04/03 13:24:13 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
static gint ett_rwall = -1;
static int
-dissect_rwall_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_rwall_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_rwall_message, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_rwall_message, offset, NULL);
return offset;
}
/* packet-spray.c
* 2001 Ronnie Sahlberg <See AUTHORS for email>
*
- * $Id: packet-spray.c,v 1.7 2002/01/24 09:20:51 guy Exp $
+ * $Id: packet-spray.c,v 1.8 2002/04/03 13:24:13 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
static int
-dissect_get_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_get_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item* lock_item = NULL;
proto_tree* lock_tree = NULL;
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_spray_counter, offset);
lock_item = proto_tree_add_item(tree, hf_spray_clock, tvb,
lock_tree = proto_item_add_subtree(lock_item, ett_spray_clock);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_spray_sec, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_spray_usec, offset);
return offset;
}
static int
-dissect_spray_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_spray_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_data(tvb, pinfo, tree,
+ offset = dissect_rpc_data(tvb, tree,
hf_spray_sprayarr, offset);
return offset;
* Routines for async NSM stat callback dissection
* 2001 Ronnie Sahlberg <See AUTHORS for email>
*
- * $Id: packet-stat-notify.c,v 1.8 2001/12/23 21:36:57 guy Exp $
+ * $Id: packet-stat-notify.c,v 1.9 2002/04/03 13:24:13 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
static int
-dissect_statnotify_mon(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_statnotify_mon(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb,pinfo,tree,hf_statnotify_name,offset,NULL);
+ offset = dissect_rpc_string(tvb,tree,hf_statnotify_name,offset,NULL);
- offset = dissect_rpc_uint32(tvb,pinfo,tree,hf_statnotify_state,offset);
+ offset = dissect_rpc_uint32(tvb,tree,hf_statnotify_state,offset);
proto_tree_add_item(tree,hf_statnotify_priv,tvb,offset,16,FALSE);
offset += 16;
/* packet-stat.c
* Routines for stat dissection
*
- * $Id: packet-stat.c,v 1.14 2002/03/05 11:04:15 guy Exp $
+ * $Id: packet-stat.c,v 1.15 2002/04/03 13:24:13 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
}
static int
-dissect_stat_stat(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_stat_stat(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
if (tree)
{
- offset = dissect_rpc_string(tvb,pinfo,tree,hf_stat_mon_name,offset,NULL);
+ offset = dissect_rpc_string(tvb,tree,hf_stat_mon_name,offset,NULL);
}
return offset;
}
static int
-dissect_stat_stat_res(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_stat_stat_res(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item* sub_item = NULL;
proto_tree* sub_tree = NULL;
}
res = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_uint32(tvb,pinfo,sub_tree,hf_stat_stat_res_res,offset);
+ offset = dissect_rpc_uint32(tvb,sub_tree,hf_stat_stat_res_res,offset);
if (res==STAT_SUCC) {
state = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_uint32(tvb,pinfo,sub_tree,hf_stat_stat_res_state,offset);
+ offset = dissect_rpc_uint32(tvb,sub_tree,hf_stat_stat_res_state,offset);
} else {
offset += 4;
}
}
static int
-dissect_stat_my_id(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_stat_my_id(tvbuff_t *tvb, int offset, proto_tree *tree)
{
proto_item* sub_item = NULL;
proto_tree* sub_tree = NULL;
sub_tree = proto_item_add_subtree(sub_item, ett_stat_my_id);
}
- offset = dissect_rpc_string(tvb,pinfo,sub_tree,hf_stat_my_id_hostname,offset,NULL);
- offset = dissect_rpc_uint32(tvb,pinfo,sub_tree,hf_stat_my_id_prog,offset);
- offset = dissect_rpc_uint32(tvb,pinfo,sub_tree,hf_stat_my_id_vers,offset);
- offset = dissect_rpc_uint32(tvb,pinfo,sub_tree,hf_stat_my_id_proc,offset);
+ offset = dissect_rpc_string(tvb,sub_tree,hf_stat_my_id_hostname,offset,NULL);
+ offset = dissect_rpc_uint32(tvb,sub_tree,hf_stat_my_id_prog,offset);
+ offset = dissect_rpc_uint32(tvb,sub_tree,hf_stat_my_id_vers,offset);
+ offset = dissect_rpc_uint32(tvb,sub_tree,hf_stat_my_id_proc,offset);
return offset;
}
static int
-dissect_stat_mon_id(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_stat_mon_id(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item* sub_item = NULL;
proto_tree* sub_tree = NULL;
}
- offset = dissect_rpc_string(tvb,pinfo,sub_tree,hf_stat_mon_id_name,offset,NULL);
+ offset = dissect_rpc_string(tvb,sub_tree,hf_stat_mon_id_name,offset,NULL);
- offset = dissect_stat_my_id(tvb,offset,pinfo,sub_tree);
+ offset = dissect_stat_my_id(tvb,offset,sub_tree);
return offset;
}
static int
-dissect_stat_priv(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_stat_priv(tvbuff_t *tvb, int offset, proto_tree *tree)
{
proto_tree_add_item(tree, hf_stat_priv, tvb, offset, 16, FALSE);
offset += 16;
offset = dissect_stat_mon_id(tvb,offset,pinfo,tree);
- offset = dissect_stat_priv(tvb,offset,pinfo,tree);
+ offset = dissect_stat_priv(tvb,offset,tree);
return offset;
}
static int
-dissect_stat_state(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_stat_state(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb,pinfo,tree,hf_stat_state,offset);
+ offset = dissect_rpc_uint32(tvb,tree,hf_stat_state,offset);
return offset;
}
static int
-dissect_stat_notify(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_stat_notify(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item* sub_item = NULL;
proto_tree* sub_tree = NULL;
sub_tree = proto_item_add_subtree(sub_item, ett_stat_stat_chge);
}
- offset = dissect_rpc_string(tvb,pinfo,sub_tree,hf_stat_mon_id_name,offset,NULL);
+ offset = dissect_rpc_string(tvb,sub_tree,hf_stat_mon_id_name,offset,NULL);
- offset = dissect_rpc_uint32(tvb,pinfo,tree,hf_stat_state,offset);
+ offset = dissect_rpc_uint32(tvb,tree,hf_stat_state,offset);
if(sub_item)
proto_item_set_len(sub_item, offset - start_offset);
}
static int
-dissect_stat_umon_all(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_stat_umon_all(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_stat_my_id(tvb,offset,pinfo,tree);
+ offset = dissect_stat_my_id(tvb,offset,tree);
return offset;
}
/* packet-ypbind.c
* Routines for ypbind dissection
*
- * $Id: packet-ypbind.c,v 1.10 2002/04/02 01:32:46 guy Exp $
+ * $Id: packet-ypbind.c,v 1.11 2002/04/03 13:24:13 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
static int
-dissect_ypbind_domain_v2_request(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_ypbind_domain_v2_request(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
/* domain */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ypbind_domain, offset, NULL);
return offset;
};
static int
-dissect_ypbind_domain_v2_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_ypbind_domain_v2_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
guint32 type;
/* response type */
type=tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypbind_resp_type, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_ypbind_resp_type, offset);
switch(type){
case YPBIND_RESP_TYPE_SUCC_VAL:
offset += 4;
/* port */
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_ypbind_port, offset);
break;
case YPBIND_RESP_TYPE_FAIL_VAL:
/* error */
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_ypbind_resp_type, offset);
break;
}
}
static int
-dissect_ypbind_setdomain_v2_request(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_ypbind_setdomain_v2_request(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
/* domain */
- offset = dissect_rpc_string(tvb, pinfo, tree,
+ offset = dissect_rpc_string(tvb, tree,
hf_ypbind_domain, offset, NULL);
/* ip address */
offset += 4;
/* port */
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_ypbind_port, offset);
/* version */
- offset = dissect_rpc_uint32(tvb, pinfo, tree,
+ offset = dissect_rpc_uint32(tvb, tree,
hf_ypbind_setdom_version, offset);
return offset;
/* packet-yppasswd.c
* Routines for yppasswd dissection
*
- * $Id: packet-yppasswd.c,v 1.5 2002/01/24 09:20:54 guy Exp $
+ * $Id: packet-yppasswd.c,v 1.6 2002/04/03 13:24:13 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
static gint ett_yppasswd_newpw = -1;
static int
-dissect_yppasswd_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_yppasswd_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item *lock_item = NULL;
proto_tree *lock_tree = NULL;
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_yppasswd_oldpass,
+ offset = dissect_rpc_string(tvb, tree, hf_yppasswd_oldpass,
offset, NULL);
lock_item = proto_tree_add_item(tree, hf_yppasswd_newpw, tvb,
lock_tree = proto_item_add_subtree(lock_item, ett_yppasswd_newpw);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_yppasswd_newpw_name, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_yppasswd_newpw_passwd, offset, NULL);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_yppasswd_newpw_uid, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_uint32(tvb, lock_tree,
hf_yppasswd_newpw_gid, offset);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_yppasswd_newpw_gecos, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_yppasswd_newpw_dir, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, lock_tree,
+ offset = dissect_rpc_string(tvb, lock_tree,
hf_yppasswd_newpw_shell, offset, NULL);
return offset;
}
static int
-dissect_yppasswd_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_yppasswd_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_yppasswd_status, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_yppasswd_status, offset);
return offset;
}
/* packet-ypserv.c
* Routines for ypserv dissection
*
- * $Id: packet-ypserv.c,v 1.21 2002/04/02 01:32:46 guy Exp $
+ * $Id: packet-ypserv.c,v 1.22 2002/04/03 13:24:13 girlich Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
};
static int
-dissect_domain_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_domain_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
if ( tree )
{
- offset = dissect_rpc_string(tvb,pinfo,tree,hf_ypserv_domain,offset,NULL);
+ offset = dissect_rpc_string(tvb,tree,hf_ypserv_domain,offset,NULL);
}
return offset;
}
static int
-dissect_domain_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_domain_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
if ( tree )
{
}
static int
-dissect_match_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_match_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
if ( tree )
{
- 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);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_domain, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_map, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_key, offset, NULL);
}
return offset;
}
static int
-dissect_match_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_match_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
if ( tree )
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_ypserv_status, offset);
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_value,offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_value,offset, NULL);
}
return offset;
static int
-dissect_first_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_first_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
/*
* XXX - does Sun's "yp.x" lie, and claim that the argument to a
if ( tree )
{
- 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, tree, hf_ypserv_domain, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_map, offset, NULL);
}
return offset;
static int
-dissect_firstnext_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_firstnext_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
if ( tree )
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
+ offset = dissect_rpc_uint32(tvb, 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);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_value, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_key, offset, NULL);
}
return offset;
static int
-dissect_next_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_next_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
if ( tree )
{
- 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);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_domain, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_map, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_key, offset, NULL);
}
return offset;
}
static int
-dissect_xfr_call(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_xfr_call(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_item *sub_item=NULL;
proto_tree *sub_tree=NULL;
sub_tree = proto_item_add_subtree(sub_item, ett_ypserv_map_parms);
}
- offset = dissect_rpc_string(tvb, pinfo, sub_tree, hf_ypserv_domain, offset, NULL);
+ offset = dissect_rpc_string(tvb, sub_tree, hf_ypserv_domain, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, sub_tree, hf_ypserv_map, offset, NULL);
+ offset = dissect_rpc_string(tvb, sub_tree, hf_ypserv_map, offset, NULL);
- offset = dissect_rpc_uint32(tvb, pinfo, sub_tree, hf_ypserv_ordernum, offset);
+ offset = dissect_rpc_uint32(tvb, sub_tree, hf_ypserv_ordernum, offset);
- offset = dissect_rpc_string(tvb, pinfo, sub_tree, hf_ypserv_peer, offset, NULL);
+ offset = dissect_rpc_string(tvb, sub_tree, hf_ypserv_peer, offset, NULL);
proto_tree_add_item(tree, hf_ypserv_transid, tvb, offset, 4, FALSE);
offset += 4;
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_prog, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_port, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_ypserv_prog, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_ypserv_port, offset);
if(sub_item)
proto_item_set_len(sub_item, offset - start_offset);
}
static int
-dissect_xfr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_xfr_reply(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
proto_tree_add_item(tree, hf_ypserv_transid, tvb, offset, 4, FALSE);
offset += 4;
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_xfrstat, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_ypserv_xfrstat, offset);
return offset;
}
static int
-dissect_ypreq_nokey(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_ypreq_nokey(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_domain, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_domain, offset, NULL);
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_map, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_map, offset, NULL);
return offset;
}
static int
-dissect_ypresp_all(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_ypresp_all(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
guint32 more;
for (;;) {
more = tvb_get_ntohl(tvb, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_more, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_ypserv_more, offset);
if (!more)
break;
- 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);
+ offset = dissect_rpc_uint32(tvb, tree, hf_ypserv_status, offset);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_value, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_key, offset, NULL);
}
return offset;
}
static int
-dissect_ypresp_master(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_ypresp_master(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_ypserv_status, offset);
- offset = dissect_rpc_string(tvb, pinfo, tree, hf_ypserv_peer, offset, NULL);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_peer, offset, NULL);
return offset;
}
static int
-dissect_ypresp_order(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_ypresp_order(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_ypserv_status, offset);
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_ordernum, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_ypserv_ordernum, offset);
return offset;
}
static int
-dissect_ypresp_maplist(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
+dissect_ypresp_maplist(tvbuff_t *tvb, int offset, packet_info *pinfo _U_, proto_tree *tree)
{
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_status, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_ypserv_status, offset);
while(tvb_get_ntohl(tvb,offset)){
- 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, tree, hf_ypserv_more, offset);
+ offset = dissect_rpc_string(tvb, tree, hf_ypserv_map, offset, NULL);
}
- offset = dissect_rpc_uint32(tvb, pinfo, tree, hf_ypserv_more, offset);
+ offset = dissect_rpc_uint32(tvb, tree, hf_ypserv_more, offset);
return offset;
}
git.samba.org / metze / wireshark / wip.git / commitdiff