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

From Joerg Mayer: explicitly fill in all members of a 

"header_field_info" structure, including the ones that are later set by
the routines to register fields.

svn path=/trunk/; revision=3561
This commit is contained in:
Guy Harris 2001-06-18 02:18:27 +00:00
parent b9222c0011
commit 8412393197
162 changed files with 3028 additions and 3023 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
epan/proto.h
View File

@ -1,7 +1,7 @@
/* proto.h
* Definitions for protocol display
*
* $Id: proto.h,v 1.12 2001/06/05 07:38:35 guy Exp $
* $Id: proto.h,v 1.13 2001/06/18 02:18:24 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -102,7 +102,12 @@ struct _header_field_info {
header_field_info *same_name_prev; /* Link to previous hfinfo with same abbrev*/
};
/*
* HFILL initializes all the "set by proto routines" fields in a
* "header_field_info"; if new fields are added or removed, it should
* be changed as necessary.
*/
#define HFILL 0, 0, 0, NULL, NULL
/* Used when registering many fields at once */
typedef struct hf_register_info {

6
make-reg-dotc.py
View File

@ -9,7 +9,7 @@
# seds for each input file. I wrote this python version so that
# less processes would have to be started.
#
# $Id: make-reg-dotc.py,v 1.1 2001/01/11 07:21:35 gram Exp $
# $Id: make-reg-dotc.py,v 1.2 2001/06/18 02:17:44 guy Exp $
import os
import sys
@ -87,7 +87,7 @@ for symbol in proto_reg:
line = " {extern void %s (void); %s ();}\n" % (symbol, symbol)
reg_code.write(line)
reg_code.write("}\n")
reg_code.write(", HFILL }\n")
# Make register_all_protocol_handoffs()
@ -97,7 +97,7 @@ for symbol in handoff_reg:
line = " {extern void %s (void); %s ();}\n" % (symbol, symbol)
reg_code.write(line)
reg_code.write("}\n")
reg_code.write(", HFILL }\n")
# Close the file
reg_code.close()

14
ncp2222.py
View File

@ -20,7 +20,7 @@ http://developer.novell.com/ndk/doc/docui/index.htm#../ncp/ncp__enu/data/
for a badly-formatted HTML version of the same PDF.
$Id: ncp2222.py,v 1.8 2001/06/02 06:26:53 guy Exp $
$Id: ncp2222.py,v 1.9 2001/06/18 02:17:44 guy Exp $
Copyright (c) 2000 by Gilbert Ramirez <gram@xiexie.org>
@ -1315,25 +1315,25 @@ proto_register_ncp2222(void)
static hf_register_info hf[] = {
{ &hf_ncp_func,
{ "Function", "ncp.func", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
{ "Function", "ncp.func", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_ncp_length,
{ "Packet Length", "ncp.length", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
{ "Packet Length", "ncp.length", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_ncp_subfunc,
{ "SubFunction", "ncp.subfunc", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
{ "SubFunction", "ncp.subfunc", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_ncp_completion_code,
{ "Completion Code", "ncp.completion_code", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
{ "Completion Code", "ncp.completion_code", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_ncp_connection_status,
{ "Connection Status", "ncp.connection_status", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "Connection Status", "ncp.connection_status", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
"""
# Print the registration code for the hf variables
for var in variables_used_hash.keys():
print "\t{ &%s," % (var.HFName())
print "\t{ \"%s\", \"%s\", %s, %s, %s, 0x%x, \"\" }},\n" % \
print "\t{ \"%s\", \"%s\", %s, %s, %s, 0x%x, \"\", HFILL }},\n" % \
(var.Description(), var.DFilter(),
var.EtherealFType(), var.Display(), var.ValuesName(),
var.Mask())

20
packet-aarp.c
View File

@ -1,7 +1,7 @@
/* packet-aarp.c
* Routines for Appletalk ARP packet disassembly
*
* $Id: packet-aarp.c,v 1.30 2001/03/15 09:11:00 guy Exp $
* $Id: packet-aarp.c,v 1.31 2001/06/18 02:17:44 guy Exp $
*
* Simon Wilkinson <sxw@dcs.ed.ac.uk>
*
@ -232,47 +232,47 @@ proto_register_aarp(void)
{ &hf_aarp_hard_type,
{ "Hardware type", "aarp.hard.type",
FT_UINT16, BASE_HEX, VALS(hrd_vals), 0x0,
"" }},
"", HFILL }},
{ &hf_aarp_proto_type,
{ "Protocol type", "aarp.proto.type",
FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0,
"" }},
"", HFILL }},
{ &hf_aarp_hard_size,
{ "Hardware size", "aarp.hard.size",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_aarp_proto_size,
{ "Protocol size", "aarp.proto.size",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_aarp_opcode,
{ "Opcode", "aarp.opcode",
FT_UINT16, BASE_DEC, VALS(op_vals), 0x0,
"" }},
"", HFILL }},
{ &hf_aarp_src_ether,
{ "Sender ether", "aarp.src.ether",
FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_aarp_src_id,
{ "Sender ID", "aarp.src.id",
FT_BYTES, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_aarp_dst_ether,
{ "Target ether", "aarp.dst.ether",
FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_aarp_dst_id,
{ "Target ID", "aarp.dst.id",
FT_BYTES, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
};
static gint *ett[] = {
&ett_aarp,

442
packet-afs-register-info.h
View File

@ -8,7 +8,7 @@
* Portions based on information/specs retrieved from the OpenAFS sources at
* www.openafs.org, Copyright IBM.
*
* $Id: packet-afs-register-info.h,v 1.7 2001/03/26 15:27:55 nneul Exp $
* $Id: packet-afs-register-info.h,v 1.8 2001/06/18 02:17:44 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -32,498 +32,498 @@
*/
{ &hf_afs_fs, { "File Server", "afs.fs",
FT_BOOLEAN, BASE_NONE, 0, 0, "File Server" }},
FT_BOOLEAN, BASE_NONE, 0, 0, "File Server", HFILL }},
{ &hf_afs_cb, { "Callback", "afs.cb",
FT_BOOLEAN, BASE_NONE, 0, 0, "Callback" }},
FT_BOOLEAN, BASE_NONE, 0, 0, "Callback", HFILL }},
{ &hf_afs_prot, { "Protection", "afs.prot",
FT_BOOLEAN, BASE_NONE, 0, 0, "Protection Server" }},
FT_BOOLEAN, BASE_NONE, 0, 0, "Protection Server", HFILL }},
{ &hf_afs_vldb, { "VLDB", "afs.vldb",
FT_BOOLEAN, BASE_NONE, 0, 0, "Volume Location Database Server" }},
FT_BOOLEAN, BASE_NONE, 0, 0, "Volume Location Database Server", HFILL }},
{ &hf_afs_kauth, { "KAuth", "afs.kauth",
FT_BOOLEAN, BASE_NONE, 0, 0, "Kerberos Auth Server" }},
FT_BOOLEAN, BASE_NONE, 0, 0, "Kerberos Auth Server", HFILL }},
{ &hf_afs_vol, { "Volume Server", "afs.vol",
FT_BOOLEAN, BASE_NONE, 0, 0, "Volume Server" }},
FT_BOOLEAN, BASE_NONE, 0, 0, "Volume Server", HFILL }},
{ &hf_afs_error, { "Error", "afs.error",
FT_BOOLEAN, BASE_NONE, 0, 0, "Error" }},
FT_BOOLEAN, BASE_NONE, 0, 0, "Error", HFILL }},
{ &hf_afs_bos, { "BOS", "afs.bos",
FT_BOOLEAN, BASE_NONE, 0, 0, "Basic Oversee Server" }},
FT_BOOLEAN, BASE_NONE, 0, 0, "Basic Oversee Server", HFILL }},
{ &hf_afs_update, { "Update", "afs.update",
FT_BOOLEAN, BASE_NONE, 0, 0, "Update Server" }},
FT_BOOLEAN, BASE_NONE, 0, 0, "Update Server", HFILL }},
{ &hf_afs_rmtsys, { "Rmtsys", "afs.rmtsys",
FT_BOOLEAN, BASE_NONE, 0, 0, "Rmtsys" }},
FT_BOOLEAN, BASE_NONE, 0, 0, "Rmtsys", HFILL }},
{ &hf_afs_ubik, { "Ubik", "afs.ubik",
FT_BOOLEAN, BASE_NONE, 0, 0, "Ubik" }},
FT_BOOLEAN, BASE_NONE, 0, 0, "Ubik", HFILL }},
{ &hf_afs_backup, { "Backup", "afs.backup",
FT_BOOLEAN, BASE_NONE, 0, 0, "Backup Server" }},
FT_BOOLEAN, BASE_NONE, 0, 0, "Backup Server", HFILL }},
{ &hf_afs_fs_opcode, { "Operation", "afs.fs.opcode",
FT_UINT32, BASE_DEC,
VALS(fs_req), 0, "Operation" }},
VALS(fs_req), 0, "Operation", HFILL }},
{ &hf_afs_cb_opcode, { "Operation", "afs.cb.opcode",
FT_UINT32, BASE_DEC,
VALS(cb_req), 0, "Operation" }},
VALS(cb_req), 0, "Operation", HFILL }},
{ &hf_afs_prot_opcode, { "Operation", "afs.prot.opcode",
FT_UINT32, BASE_DEC,
VALS(prot_req), 0, "Operation" }},
VALS(prot_req), 0, "Operation", HFILL }},
{ &hf_afs_vldb_opcode, { "Operation", "afs.vldb.opcode",
FT_UINT32, BASE_DEC,
VALS(vldb_req), 0, "Operation" }},
VALS(vldb_req), 0, "Operation", HFILL }},
{ &hf_afs_kauth_opcode, { "Operation", "afs.kauth.opcode",
FT_UINT32, BASE_DEC,
VALS(kauth_req), 0, "Operation" }},
VALS(kauth_req), 0, "Operation", HFILL }},
{ &hf_afs_vol_opcode, { "Operation", "afs.vol.opcode",
FT_UINT32, BASE_DEC,
VALS(vol_req), 0, "Operation" }},
VALS(vol_req), 0, "Operation", HFILL }},
{ &hf_afs_bos_opcode, { "Operation", "afs.bos.opcode",
FT_UINT32, BASE_DEC,
VALS(bos_req), 0, "Operation" }},
VALS(bos_req), 0, "Operation", HFILL }},
{ &hf_afs_update_opcode, { "Operation", "afs.update.opcode",
FT_UINT32, BASE_DEC,
VALS(update_req), 0, "Operation" }},
VALS(update_req), 0, "Operation", HFILL }},
{ &hf_afs_rmtsys_opcode, { "Operation", "afs.rmtsys.opcode",
FT_UINT32, BASE_DEC,
VALS(rmtsys_req), 0, "Operation" }},
VALS(rmtsys_req), 0, "Operation", HFILL }},
{ &hf_afs_error_opcode, { "Operation", "afs.error.opcode",
FT_UINT32, BASE_DEC,
0, 0, "Operation" }},
0, 0, "Operation", HFILL }},
{ &hf_afs_backup_opcode, {
"Operation", "afs.backup.opcode",
FT_UINT32, BASE_DEC,
VALS(backup_req), 0, "Operation" }},
VALS(backup_req), 0, "Operation", HFILL }},
{ &hf_afs_ubik_opcode, {
"Operation", "afs.ubik.opcode",
FT_UINT32, BASE_DEC,
VALS(ubik_req), 0, "Operation" }},
VALS(ubik_req), 0, "Operation", HFILL }},
/* File Server Fields */
{ &hf_afs_fs_fid_volume, { "FileID (Volume)", "afs.fs.fid.volume",
FT_UINT32, BASE_DEC,
0, 0, "File ID (Volume)" }},
0, 0, "File ID (Volume)", HFILL }},
{ &hf_afs_fs_fid_vnode, { "FileID (VNode)", "afs.fs.fid.vnode",
FT_UINT32, BASE_DEC,
0, 0, "File ID (VNode)" }},
0, 0, "File ID (VNode)", HFILL }},
{ &hf_afs_fs_fid_uniqifier, { "FileID (Uniqifier)", "afs.fs.fid.uniq",
FT_UINT32, BASE_DEC,
0, 0, "File ID (Uniqifier)" }},
0, 0, "File ID (Uniqifier)", HFILL }},
{ &hf_afs_fs_offset, { "Offset", "afs.fs.offset",
FT_UINT32, BASE_DEC,
0, 0, "Offset" }},
0, 0, "Offset", HFILL }},
{ &hf_afs_fs_length, { "Length", "afs.fs.length",
FT_UINT32, BASE_DEC, 0, 0, "Length" }},
FT_UINT32, BASE_DEC, 0, 0, "Length", HFILL }},
{ &hf_afs_fs_flength, { "FLength", "afs.fs.flength",
FT_UINT32, BASE_DEC, 0, 0, "FLength" }},
FT_UINT32, BASE_DEC, 0, 0, "FLength", HFILL }},
{ &hf_afs_fs_errcode, { "Error Code", "afs.fs.errcode",
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
{ &hf_afs_fs_data, { "Data", "afs.fs.data",
FT_BYTES, BASE_HEX, 0, 0, "Data" }},
FT_BYTES, BASE_HEX, 0, 0, "Data", HFILL }},
{ &hf_afs_fs_token, { "Token", "afs.fs.token",
FT_BYTES, BASE_HEX, 0, 0, "Token" }},
FT_BYTES, BASE_HEX, 0, 0, "Token", HFILL }},
{ &hf_afs_fs_oldname, { "Old Name", "afs.fs.oldname",
FT_STRING, BASE_HEX, 0, 0, "Old Name" }},
FT_STRING, BASE_HEX, 0, 0, "Old Name", HFILL }},
{ &hf_afs_fs_newname, { "New Name", "afs.fs.newname",
FT_STRING, BASE_HEX, 0, 0, "New Name" }},
FT_STRING, BASE_HEX, 0, 0, "New Name", HFILL }},
{ &hf_afs_fs_name, { "Name", "afs.fs.name",
FT_STRING, BASE_HEX, 0, 0, "Name" }},
FT_STRING, BASE_HEX, 0, 0, "Name", HFILL }},
{ &hf_afs_fs_symlink_name, { "Symlink Name", "afs.fs.symlink.name",
FT_STRING, BASE_HEX, 0, 0, "Symlink Name" }},
FT_STRING, BASE_HEX, 0, 0, "Symlink Name", HFILL }},
{ &hf_afs_fs_symlink_content, { "Symlink Content", "afs.fs.symlink.content",
FT_STRING, BASE_HEX, 0, 0, "Symlink Content" }},
FT_STRING, BASE_HEX, 0, 0, "Symlink Content", HFILL }},
{ &hf_afs_fs_volid, { "Volume ID", "afs.fs.volid",
FT_UINT32, BASE_DEC, 0, 0, "Volume ID" }},
FT_UINT32, BASE_DEC, 0, 0, "Volume ID", HFILL }},
{ &hf_afs_fs_volname, { "Volume Name", "afs.fs.volname",
FT_STRING, BASE_HEX, 0, 0, "Volume Name" }},
FT_STRING, BASE_HEX, 0, 0, "Volume Name", HFILL }},
{ &hf_afs_fs_timestamp, { "Timestamp", "afs.fs.timestamp",
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Timestamp" }},
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Timestamp", HFILL }},
{ &hf_afs_fs_offlinemsg, { "Offline Message", "afs.fs.offlinemsg",
FT_STRING, BASE_HEX, 0, 0, "Volume Name" }},
FT_STRING, BASE_HEX, 0, 0, "Volume Name", HFILL }},
{ &hf_afs_fs_motd, { "Message of the Day", "afs.fs.motd",
FT_STRING, BASE_HEX, 0, 0, "Message of the Day" }},
FT_STRING, BASE_HEX, 0, 0, "Message of the Day", HFILL }},
{ &hf_afs_fs_xstats_version, { "XStats Version", "afs.fs.xstats.version",
FT_UINT32, BASE_DEC, 0, 0, "XStats Version" }},
FT_UINT32, BASE_DEC, 0, 0, "XStats Version", HFILL }},
{ &hf_afs_fs_xstats_clientversion, { "Client Version", "afs.fs.xstats.clientversion",
FT_UINT32, BASE_DEC, 0, 0, "Client Version" }},
FT_UINT32, BASE_DEC, 0, 0, "Client Version", HFILL }},
{ &hf_afs_fs_xstats_version, { "Collection Number", "afs.fs.xstats.collnumber",
FT_UINT32, BASE_DEC, VALS(xstat_collections), 0, "Collection Number" }},
FT_UINT32, BASE_DEC, VALS(xstat_collections), 0, "Collection Number", HFILL }},
{ &hf_afs_fs_xstats_timestamp, { "XStats Timestamp", "afs.fs.xstats.timestamp",
FT_UINT32, BASE_DEC, 0, 0, "XStats Timestamp" }},
FT_UINT32, BASE_DEC, 0, 0, "XStats Timestamp", HFILL }},
{ &hf_afs_fs_cps_spare1, { "CPS Spare1", "afs.fs.cps.spare1",
FT_UINT32, BASE_DEC, 0, 0, "CPS Spare1" }},
FT_UINT32, BASE_DEC, 0, 0, "CPS Spare1", HFILL }},
{ &hf_afs_fs_cps_spare2, { "CPS Spare2", "afs.fs.cps.spare2",
FT_UINT32, BASE_DEC, 0, 0, "CPS Spare2" }},
FT_UINT32, BASE_DEC, 0, 0, "CPS Spare2", HFILL }},
{ &hf_afs_fs_cps_spare3, { "CPS Spare3", "afs.fs.cps.spare3",
FT_UINT32, BASE_DEC, 0, 0, "CPS Spare3" }},
FT_UINT32, BASE_DEC, 0, 0, "CPS Spare3", HFILL }},
{ &hf_afs_fs_vicelocktype, { "Vice Lock Type", "afs.fs.vicelocktype",
FT_UINT32, BASE_DEC, VALS(vice_lock_types), 0, "Vice Lock Type" }},
FT_UINT32, BASE_DEC, VALS(vice_lock_types), 0, "Vice Lock Type", HFILL }},
{ &hf_afs_fs_viceid, { "Vice ID", "afs.fs.viceid",
FT_UINT32, BASE_DEC, 0, 0, "Vice ID" }},
FT_UINT32, BASE_DEC, 0, 0, "Vice ID", HFILL }},
{ &hf_afs_fs_viceid, { "IP Address", "afs.fs.ipaddr",
FT_IPv4, BASE_HEX, 0, 0, "IP Address" }},
FT_IPv4, BASE_HEX, 0, 0, "IP Address", HFILL }},
{ &hf_afs_fs_status_mask, { "Mask", "afs.fs.status.mask",
FT_UINT32, BASE_HEX, 0, 0, "Mask" }},
FT_UINT32, BASE_HEX, 0, 0, "Mask", HFILL }},
{ &hf_afs_fs_status_mask_setmodtime, { "Set Modification Time", "afs.fs.status.mask.setmodtime",
FT_UINT32, BASE_BIN, 0, 1, "Set Modification Time" }},
FT_UINT32, BASE_BIN, 0, 1, "Set Modification Time", HFILL }},
{ &hf_afs_fs_status_mask_setowner, { "Set Owner", "afs.fs.status.mask.setowner",
FT_UINT32, BASE_BIN, 0, 2, "Set Owner" }},
FT_UINT32, BASE_BIN, 0, 2, "Set Owner", HFILL }},
{ &hf_afs_fs_status_mask_setgroup, { "Set Group", "afs.fs.status.mask.setgroup",
FT_UINT32, BASE_BIN, 0, 4, "Set Group" }},
FT_UINT32, BASE_BIN, 0, 4, "Set Group", HFILL }},
{ &hf_afs_fs_status_mask_setmode, { "Set Mode", "afs.fs.status.mask.setmode",
FT_UINT32, BASE_BIN, 0, 8, "Set Mode" }},
FT_UINT32, BASE_BIN, 0, 8, "Set Mode", HFILL }},
{ &hf_afs_fs_status_mask_setsegsize, { "Set Segment Size", "afs.fs.status.mask.setsegsize",
FT_UINT32, BASE_BIN, 0, 16, "Set Segment Size" }},
FT_UINT32, BASE_BIN, 0, 16, "Set Segment Size", HFILL }},
{ &hf_afs_fs_status_mask_fsync, { "FSync", "afs.fs.status.mask.fsync",
FT_UINT32, BASE_BIN, 0, 1024, "FSync" }},
FT_UINT32, BASE_BIN, 0, 1024, "FSync", HFILL }},
{ &hf_afs_fs_status_clientmodtime, { "Client Modification Time", "afs.fs.status.clientmodtime",
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Client Modification Time" }},
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Client Modification Time", HFILL }},
{ &hf_afs_fs_status_servermodtime, { "Server Modification Time", "afs.fs.status.servermodtime",
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Server Modification Time" }},
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Server Modification Time", HFILL }},
{ &hf_afs_fs_status_owner, { "Owner", "afs.fs.status.owner",
FT_UINT32, BASE_DEC, 0, 0, "Owner" }},
FT_UINT32, BASE_DEC, 0, 0, "Owner", HFILL }},
{ &hf_afs_fs_status_group, { "Group", "afs.fs.status.group",
FT_UINT32, BASE_DEC, 0, 0, "Group" }},
FT_UINT32, BASE_DEC, 0, 0, "Group", HFILL }},
{ &hf_afs_fs_status_mode, { "Unix Mode", "afs.fs.status.mode",
FT_UINT32, BASE_OCT, 0, 0, "Unix Mode" }},
FT_UINT32, BASE_OCT, 0, 0, "Unix Mode", HFILL }},
{ &hf_afs_fs_status_segsize, { "Segment Size", "afs.fs.status.segsize",
FT_UINT32, BASE_DEC, 0, 0, "Segment Size" }},
FT_UINT32, BASE_DEC, 0, 0, "Segment Size", HFILL }},
{ &hf_afs_fs_status_interfaceversion, { "Interface Version", "afs.fs.status.interfaceversion",
FT_UINT32, BASE_DEC, 0, 0, "Interface Version" }},
FT_UINT32, BASE_DEC, 0, 0, "Interface Version", HFILL }},
{ &hf_afs_fs_status_filetype, { "File Type", "afs.fs.status.filetype",
FT_UINT32, BASE_DEC, 0, 0, "File Type" }},
FT_UINT32, BASE_DEC, 0, 0, "File Type", HFILL }},
{ &hf_afs_fs_status_author, { "Author", "afs.fs.status.author",
FT_UINT32, BASE_DEC, 0, 0, "Author" }},
FT_UINT32, BASE_DEC, 0, 0, "Author", HFILL }},
{ &hf_afs_fs_status_calleraccess, { "Caller Access", "afs.fs.status.calleraccess",
FT_UINT32, BASE_DEC, 0, 0, "Caller Access" }},
FT_UINT32, BASE_DEC, 0, 0, "Caller Access", HFILL }},
{ &hf_afs_fs_status_anonymousaccess, { "Anonymous Access", "afs.fs.status.anonymousaccess",
FT_UINT32, BASE_DEC, 0, 0, "Anonymous Access" }},
FT_UINT32, BASE_DEC, 0, 0, "Anonymous Access", HFILL }},
{ &hf_afs_fs_status_parentvnode, { "Parent VNode", "afs.fs.status.parentvnode",
FT_UINT32, BASE_DEC, 0, 0, "Parent VNode" }},
FT_UINT32, BASE_DEC, 0, 0, "Parent VNode", HFILL }},
{ &hf_afs_fs_status_parentunique, { "Parent Unique", "afs.fs.status.parentunique",
FT_UINT32, BASE_DEC, 0, 0, "Parent Unique" }},
FT_UINT32, BASE_DEC, 0, 0, "Parent Unique", HFILL }},
{ &hf_afs_fs_status_dataversion, { "Data Version", "afs.fs.status.dataversion",
FT_UINT32, BASE_DEC, 0, 0, "Data Version" }},
FT_UINT32, BASE_DEC, 0, 0, "Data Version", HFILL }},
{ &hf_afs_fs_status_dataversionhigh, { "Data Version (High)", "afs.fs.status.dataversionhigh",
FT_UINT32, BASE_DEC, 0, 0, "Data Version (High)" }},
FT_UINT32, BASE_DEC, 0, 0, "Data Version (High)", HFILL }},
{ &hf_afs_fs_status_linkcount, { "Link Count", "afs.fs.status.linkcount",
FT_UINT32, BASE_DEC, 0, 0, "Link Count" }},
FT_UINT32, BASE_DEC, 0, 0, "Link Count", HFILL }},
{ &hf_afs_fs_status_spare2, { "Spare 2", "afs.fs.status.spare2",
FT_UINT32, BASE_DEC, 0, 0, "Spare 2" }},
FT_UINT32, BASE_DEC, 0, 0, "Spare 2", HFILL }},
{ &hf_afs_fs_status_spare3, { "Spare 3", "afs.fs.status.spare3",
FT_UINT32, BASE_DEC, 0, 0, "Spare 3" }},
FT_UINT32, BASE_DEC, 0, 0, "Spare 3", HFILL }},
{ &hf_afs_fs_status_spare4, { "Spare 4", "afs.fs.status.spare4",
FT_UINT32, BASE_DEC, 0, 0, "Spare 4" }},
FT_UINT32, BASE_DEC, 0, 0, "Spare 4", HFILL }},
{ &hf_afs_fs_status_synccounter, { "Sync Counter", "afs.fs.status.synccounter",
FT_UINT32, BASE_DEC, 0, 0, "Sync Counter" }},
FT_UINT32, BASE_DEC, 0, 0, "Sync Counter", HFILL }},
{ &hf_afs_fs_status_length, { "Length", "afs.fs.status.length",
FT_UINT32, BASE_DEC, 0, 0, "Length" }},
FT_UINT32, BASE_DEC, 0, 0, "Length", HFILL }},
{ &hf_afs_fs_volsync_spare1, { "Spare 1", "afs.fs.volsync.spare1",
FT_UINT32, BASE_DEC, 0, 0, "Spare 1" }},
FT_UINT32, BASE_DEC, 0, 0, "Spare 1", HFILL }},
{ &hf_afs_fs_volsync_spare2, { "Spare 2", "afs.fs.volsync.spare2",
FT_UINT32, BASE_DEC, 0, 0, "Spare 2" }},
FT_UINT32, BASE_DEC, 0, 0, "Spare 2", HFILL }},
{ &hf_afs_fs_volsync_spare3, { "Spare 3", "afs.fs.volsync.spare3",
FT_UINT32, BASE_DEC, 0, 0, "Spare 3" }},
FT_UINT32, BASE_DEC, 0, 0, "Spare 3", HFILL }},
{ &hf_afs_fs_volsync_spare4, { "Spare 4", "afs.fs.volsync.spare4",
FT_UINT32, BASE_DEC, 0, 0, "Spare 4" }},
FT_UINT32, BASE_DEC, 0, 0, "Spare 4", HFILL }},
{ &hf_afs_fs_volsync_spare5, { "Spare 5", "afs.fs.volsync.spare5",
FT_UINT32, BASE_DEC, 0, 0, "Spare 5" }},
FT_UINT32, BASE_DEC, 0, 0, "Spare 5", HFILL }},
{ &hf_afs_fs_volsync_spare6, { "Spare 6", "afs.fs.volsync.spare6",
FT_UINT32, BASE_DEC, 0, 0, "Spare 6" }},
FT_UINT32, BASE_DEC, 0, 0, "Spare 6", HFILL }},
{ &hf_afs_fs_acl_count_positive, {
"ACL Count (Positive)", "afs.fs.acl.count.positive",
FT_UINT32, BASE_DEC, 0, 0, "Number of Positive ACLs" }},
FT_UINT32, BASE_DEC, 0, 0, "Number of Positive ACLs", HFILL }},
{ &hf_afs_fs_acl_count_negative, {
"ACL Count (Negative)", "afs.fs.acl.count.negative",
FT_UINT32, BASE_DEC, 0, 0, "Number of Negative ACLs" }},
FT_UINT32, BASE_DEC, 0, 0, "Number of Negative ACLs", HFILL }},
{ &hf_afs_fs_acl_datasize, {
"ACL Size", "afs.fs.acl.datasize",
FT_UINT32, BASE_DEC, 0, 0, "ACL Data Size" }},
FT_UINT32, BASE_DEC, 0, 0, "ACL Data Size", HFILL }},
{ &hf_afs_fs_acl_entity, {
"Entity (User/Group)", "afs.fs.acl.entity",
FT_STRING, BASE_HEX, 0, 0, "ACL Entity (User/Group)" }},
FT_STRING, BASE_HEX, 0, 0, "ACL Entity (User/Group)", HFILL }},
{ &hf_afs_fs_acl_r, {
"_R_ead", "afs.fs.acl.r",
FT_UINT8, BASE_BIN, 0, PRSFS_READ, "Read" }},
FT_UINT8, BASE_BIN, 0, PRSFS_READ, "Read", HFILL }},
{ &hf_afs_fs_acl_l, {
"_L_ookup", "afs.fs.acl.l",
FT_UINT8, BASE_BIN, 0, PRSFS_LOOKUP, "Lookup" }},
FT_UINT8, BASE_BIN, 0, PRSFS_LOOKUP, "Lookup", HFILL }},
{ &hf_afs_fs_acl_i, {
"_I_nsert", "afs.fs.acl.i",
FT_UINT8, BASE_BIN, 0, PRSFS_INSERT, "Insert" }},
FT_UINT8, BASE_BIN, 0, PRSFS_INSERT, "Insert", HFILL }},
{ &hf_afs_fs_acl_d, { "_D_elete", "afs.fs.acl.d",
FT_UINT8, BASE_BIN, 0, PRSFS_DELETE, "Delete" }},
FT_UINT8, BASE_BIN, 0, PRSFS_DELETE, "Delete", HFILL }},
{ &hf_afs_fs_acl_w, { "_W_rite", "afs.fs.acl.w",
FT_UINT8, BASE_BIN, 0, PRSFS_WRITE, "Write" }},
FT_UINT8, BASE_BIN, 0, PRSFS_WRITE, "Write", HFILL }},
{ &hf_afs_fs_acl_k, { "_L_ock", "afs.fs.acl.k",
FT_UINT8, BASE_BIN, 0, PRSFS_LOCK, "Lock" }},
FT_UINT8, BASE_BIN, 0, PRSFS_LOCK, "Lock", HFILL }},
{ &hf_afs_fs_acl_a, { "_A_dminister", "afs.fs.acl.a",
FT_UINT8, BASE_BIN, 0, PRSFS_ADMINISTER, "Administer" }},
FT_UINT8, BASE_BIN, 0, PRSFS_ADMINISTER, "Administer", HFILL }},
{ &hf_afs_fs_callback_version, { "Version", "afs.fs.callback.version",
FT_UINT32, BASE_DEC, 0, 0, "Version" }},
FT_UINT32, BASE_DEC, 0, 0, "Version", HFILL }},
{ &hf_afs_fs_callback_expires, { "Expires", "afs.fs.callback.expires",
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Expires" }},
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Expires", HFILL }},
{ &hf_afs_fs_callback_type, { "Type", "afs.fs.callback.type",
FT_UINT32, BASE_DEC, VALS(cb_types), 0, "Type" }},
FT_UINT32, BASE_DEC, VALS(cb_types), 0, "Type", HFILL }},
/* BOS Server Fields */
{ &hf_afs_bos_errcode, { "Error Code", "afs.bos.errcode",
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
{ &hf_afs_bos_type, { "Type", "afs.bos.type",
FT_STRING, BASE_HEX, 0, 0, "Type" }},
FT_STRING, BASE_HEX, 0, 0, "Type", HFILL }},
{ &hf_afs_bos_content, { "Content", "afs.bos.content",
FT_STRING, BASE_HEX, 0, 0, "Content" }},
FT_STRING, BASE_HEX, 0, 0, "Content", HFILL }},
{ &hf_afs_bos_data, { "Data", "afs.bos.data",
FT_BYTES, BASE_HEX, 0, 0, "Data" }},
FT_BYTES, BASE_HEX, 0, 0, "Data", HFILL }},
{ &hf_afs_bos_path, { "Path", "afs.bos.path",
FT_STRING, BASE_HEX, 0, 0, "Path" }},
FT_STRING, BASE_HEX, 0, 0, "Path", HFILL }},
{ &hf_afs_bos_parm, { "Parm", "afs.bos.parm",
FT_STRING, BASE_HEX, 0, 0, "Parm" }},
FT_STRING, BASE_HEX, 0, 0, "Parm", HFILL }},
{ &hf_afs_bos_error, { "Error", "afs.bos.error",
FT_STRING, BASE_HEX, 0, 0, "Error" }},
FT_STRING, BASE_HEX, 0, 0, "Error", HFILL }},
{ &hf_afs_bos_spare1, { "Spare1", "afs.bos.spare1",
FT_STRING, BASE_HEX, 0, 0, "Spare1" }},
FT_STRING, BASE_HEX, 0, 0, "Spare1", HFILL }},
{ &hf_afs_bos_spare2, { "Spare2", "afs.bos.spare2",
FT_STRING, BASE_HEX, 0, 0, "Spare2" }},
FT_STRING, BASE_HEX, 0, 0, "Spare2", HFILL }},
{ &hf_afs_bos_spare3, { "Spare3", "afs.bos.spare3",
FT_STRING, BASE_HEX, 0, 0, "Spare3" }},
FT_STRING, BASE_HEX, 0, 0, "Spare3", HFILL }},
{ &hf_afs_bos_file, { "File", "afs.bos.file",
FT_STRING, BASE_HEX, 0, 0, "File" }},
FT_STRING, BASE_HEX, 0, 0, "File", HFILL }},
{ &hf_afs_bos_cmd, { "Command", "afs.bos.cmd",
FT_STRING, BASE_HEX, 0, 0, "Command" }},
FT_STRING, BASE_HEX, 0, 0, "Command", HFILL }},
{ &hf_afs_bos_key, { "Key", "afs.bos.key",
FT_BYTES, BASE_HEX, 0, 0, "key" }},
FT_BYTES, BASE_HEX, 0, 0, "key", HFILL }},
{ &hf_afs_bos_user, { "User", "afs.bos.user",
FT_STRING, BASE_HEX, 0, 0, "User" }},
FT_STRING, BASE_HEX, 0, 0, "User", HFILL }},
{ &hf_afs_bos_instance, { "Instance", "afs.bos.instance",
FT_STRING, BASE_HEX, 0, 0, "Instance" }},
FT_STRING, BASE_HEX, 0, 0, "Instance", HFILL }},
{ &hf_afs_bos_status, { "Status", "afs.bos.status",
FT_INT32, BASE_DEC, 0, 0, "Status" }},
FT_INT32, BASE_DEC, 0, 0, "Status", HFILL }},
{ &hf_afs_bos_statusdesc, { "Status Description", "afs.bos.statusdesc",
FT_STRING, BASE_DEC, 0, 0, "Status Description" }},
FT_STRING, BASE_DEC, 0, 0, "Status Description", HFILL }},
{ &hf_afs_bos_num, { "Number", "afs.bos.number",
FT_UINT32, BASE_DEC, 0, 0, "Number" }},
FT_UINT32, BASE_DEC, 0, 0, "Number", HFILL }},
{ &hf_afs_bos_size, { "Size", "afs.bos.size",
FT_UINT32, BASE_DEC, 0, 0, "Size" }},
FT_UINT32, BASE_DEC, 0, 0, "Size", HFILL }},
{ &hf_afs_bos_flags, { "Flags", "afs.bos.flags",
FT_UINT32, BASE_DEC, 0, 0, "Flags" }},
FT_UINT32, BASE_DEC, 0, 0, "Flags", HFILL }},
{ &hf_afs_bos_date, { "Date", "afs.bos.date",
FT_UINT32, BASE_DEC, 0, 0, "Date" }},
FT_UINT32, BASE_DEC, 0, 0, "Date", HFILL }},
{ &hf_afs_bos_kvno, { "Key Version Number", "afs.bos.kvno",
FT_UINT32, BASE_DEC, 0, 0, "Key Version Number" }},
FT_UINT32, BASE_DEC, 0, 0, "Key Version Number", HFILL }},
{ &hf_afs_bos_cell, { "Cell", "afs.bos.cell",
FT_STRING, BASE_HEX, 0, 0, "Cell" }},
FT_STRING, BASE_HEX, 0, 0, "Cell", HFILL }},
{ &hf_afs_bos_host, { "Host", "afs.bos.host",
FT_STRING, BASE_HEX, 0, 0, "Host" }},
FT_STRING, BASE_HEX, 0, 0, "Host", HFILL }},
{ &hf_afs_bos_newtime, { "New Time", "afs.bos.newtime",
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "New Time" }},
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "New Time", HFILL }},
{ &hf_afs_bos_baktime, { "Backup Time", "afs.bos.baktime",
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Backup Time" }},
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Backup Time", HFILL }},
{ &hf_afs_bos_oldtime, { "Old Time", "afs.bos.oldtime",
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Old Time" }},
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Old Time", HFILL }},
{ &hf_afs_bos_keymodtime, { "Key Modification Time", "afs.bos.keymodtime",
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Key Modification Time" }},
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Key Modification Time", HFILL }},
{ &hf_afs_bos_keychecksum, { "Key Checksum", "afs.bos.keychecksum",
FT_UINT32, BASE_DEC, 0, 0, "Key Checksum" }},
FT_UINT32, BASE_DEC, 0, 0, "Key Checksum", HFILL }},
{ &hf_afs_bos_keyspare2, { "Key Spare 2", "afs.bos.keyspare2",
FT_UINT32, BASE_DEC, 0, 0, "Key Spare 2" }},
FT_UINT32, BASE_DEC, 0, 0, "Key Spare 2", HFILL }},
/* KAUTH Server Fields */
{ &hf_afs_kauth_errcode, { "Error Code", "afs.kauth.errcode",
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
{ &hf_afs_kauth_princ, { "Principal", "afs.kauth.princ",
FT_STRING, BASE_HEX, 0, 0, "Principal" }},
FT_STRING, BASE_HEX, 0, 0, "Principal", HFILL }},
{ &hf_afs_kauth_realm, { "Realm", "afs.kauth.realm",
FT_STRING, BASE_HEX, 0, 0, "Realm" }},
FT_STRING, BASE_HEX, 0, 0, "Realm", HFILL }},
{ &hf_afs_kauth_domain, { "Domain", "afs.kauth.domain",
FT_STRING, BASE_HEX, 0, 0, "Domain" }},
FT_STRING, BASE_HEX, 0, 0, "Domain", HFILL }},
{ &hf_afs_kauth_name, { "Name", "afs.kauth.name",
FT_STRING, BASE_HEX, 0, 0, "Name" }},
FT_STRING, BASE_HEX, 0, 0, "Name", HFILL }},
{ &hf_afs_kauth_data, { "Data", "afs.kauth.data",
FT_BYTES, BASE_HEX, 0, 0, "Data" }},
FT_BYTES, BASE_HEX, 0, 0, "Data", HFILL }},
{ &hf_afs_kauth_kvno, { "Key Version Number", "afs.kauth.kvno",
FT_UINT32, BASE_DEC, 0, 0, "Key Version Number" }},
FT_UINT32, BASE_DEC, 0, 0, "Key Version Number", HFILL }},
/* VOL Server Fields */
{ &hf_afs_vol_errcode, { "Error Code", "afs.vol.errcode",
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
{ &hf_afs_vol_id, { "Volume ID", "afs.vol.id",
FT_UINT32, BASE_DEC, 0, 0, "Volume ID" }},
FT_UINT32, BASE_DEC, 0, 0, "Volume ID", HFILL }},
{ &hf_afs_vol_count, { "Volume Count", "afs.vol.count",
FT_UINT32, BASE_DEC, 0, 0, "Volume Count" }},
FT_UINT32, BASE_DEC, 0, 0, "Volume Count", HFILL }},
{ &hf_afs_vol_name, { "Volume Name", "afs.vol.name",
FT_STRING, BASE_HEX, 0, 0, "Volume Name" }},
FT_STRING, BASE_HEX, 0, 0, "Volume Name", HFILL }},
/* VLDB Server Fields */
{ &hf_afs_vldb_errcode, { "Error Code", "afs.vldb.errcode",
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
{ &hf_afs_vldb_type, { "Volume Type", "afs.vldb.type",
FT_UINT32, BASE_DEC, VALS(volume_types), 0, "Volume Type" }},
FT_UINT32, BASE_DEC, VALS(volume_types), 0, "Volume Type", HFILL }},
{ &hf_afs_vldb_id, { "Volume ID", "afs.vldb.id",
FT_UINT32, BASE_DEC, 0, 0, "Volume ID" }},
FT_UINT32, BASE_DEC, 0, 0, "Volume ID", HFILL }},
{ &hf_afs_vldb_bump, { "Bumped Volume ID", "afs.vldb.bump",
FT_UINT32, BASE_DEC, 0, 0, "Bumped Volume ID" }},
FT_UINT32, BASE_DEC, 0, 0, "Bumped Volume ID", HFILL }},
{ &hf_afs_vldb_index, { "Volume Index", "afs.vldb.index",
FT_UINT32, BASE_DEC, 0, 0, "Volume Index" }},
FT_UINT32, BASE_DEC, 0, 0, "Volume Index", HFILL }},
{ &hf_afs_vldb_count, { "Volume Count", "afs.vldb.count",
FT_UINT32, BASE_DEC, 0, 0, "Volume Count" }},
FT_UINT32, BASE_DEC, 0, 0, "Volume Count", HFILL }},
{ &hf_afs_vldb_numservers, { "Number of Servers", "afs.vldb.numservers",
FT_UINT32, BASE_DEC, 0, 0, "Number of Servers" }},
FT_UINT32, BASE_DEC, 0, 0, "Number of Servers", HFILL }},
{ &hf_afs_vldb_nextindex, { "Next Volume Index", "afs.vldb.nextindex",
FT_UINT32, BASE_DEC, 0, 0, "Next Volume Index" }},
FT_UINT32, BASE_DEC, 0, 0, "Next Volume Index", HFILL }},
{ &hf_afs_vldb_rovol, { "Read-Only Volume ID", "afs.vldb.rovol",
FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID" }},
FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID", HFILL }},
{ &hf_afs_vldb_rwvol, { "Read-Write Volume ID", "afs.vldb.rwvol",
FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID" }},
FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID", HFILL }},
{ &hf_afs_vldb_bkvol, { "Backup Volume ID", "afs.vldb.bkvol",
FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID" }},
FT_UINT32, BASE_DEC, 0, 0, "Read-Only Volume ID", HFILL }},
{ &hf_afs_vldb_name, { "Volume Name", "afs.vldb.name",
FT_STRING, BASE_HEX, 0, 0, "Volume Name" }},
FT_STRING, BASE_HEX, 0, 0, "Volume Name", HFILL }},
{ &hf_afs_vldb_partition, { "Partition", "afs.vldb.partition",
FT_STRING, BASE_HEX, 0, 0, "Partition" }},
FT_STRING, BASE_HEX, 0, 0, "Partition", HFILL }},
{ &hf_afs_vldb_server, { "Server", "afs.vldb.server",
FT_IPv4, BASE_HEX, 0, 0, "Server" }},
FT_IPv4, BASE_HEX, 0, 0, "Server", HFILL }},
{ &hf_afs_vldb_serveruuid, { "Server UUID", "afs.vldb.serveruuid",
FT_BYTES, BASE_HEX, 0, 0, "Server UUID" }},
FT_BYTES, BASE_HEX, 0, 0, "Server UUID", HFILL }},
/* BACKUP Server Fields */
{ &hf_afs_backup_errcode, { "Error Code", "afs.backup.errcode",
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
/* CB Server Fields */
{ &hf_afs_cb_errcode, { "Error Code", "afs.cb.errcode",
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
{ &hf_afs_cb_callback_version, { "Version", "afs.cb.callback.version",
FT_UINT32, BASE_DEC, 0, 0, "Version" }},
FT_UINT32, BASE_DEC, 0, 0, "Version", HFILL }},
{ &hf_afs_cb_callback_expires, { "Expires", "afs.cb.callback.expires",
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Expires" }},
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Expires", HFILL }},
{ &hf_afs_cb_callback_type, { "Type", "afs.cb.callback.type",
FT_UINT32, BASE_DEC, VALS(cb_types), 0, "Type" }},
FT_UINT32, BASE_DEC, VALS(cb_types), 0, "Type", HFILL }},
{ &hf_afs_cb_fid_volume, { "FileID (Volume)", "afs.cb.fid.volume",
FT_UINT32, BASE_DEC, 0, 0, "File ID (Volume)" }},
FT_UINT32, BASE_DEC, 0, 0, "File ID (Volume)", HFILL }},
{ &hf_afs_cb_fid_vnode, { "FileID (VNode)", "afs.cb.fid.vnode",
FT_UINT32, BASE_DEC, 0, 0, "File ID (VNode)" }},
FT_UINT32, BASE_DEC, 0, 0, "File ID (VNode)", HFILL }},
{ &hf_afs_cb_fid_uniqifier, { "FileID (Uniqifier)", "afs.cb.fid.uniq",
FT_UINT32, BASE_DEC, 0, 0, "File ID (Uniqifier)" }},
FT_UINT32, BASE_DEC, 0, 0, "File ID (Uniqifier)", HFILL }},
/* PROT Server Fields */
{ &hf_afs_prot_errcode, { "Error Code", "afs.prot.errcode",
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
{ &hf_afs_prot_name, { "Name", "afs.prot.name",
FT_STRING, BASE_HEX, 0, 0, "Name" }},
FT_STRING, BASE_HEX, 0, 0, "Name", HFILL }},
{ &hf_afs_prot_id, { "ID", "afs.prot.id",
FT_UINT32, BASE_DEC, 0, 0, "ID" }},
FT_UINT32, BASE_DEC, 0, 0, "ID", HFILL }},
{ &hf_afs_prot_oldid, { "Old ID", "afs.prot.oldid",
FT_UINT32, BASE_DEC, 0, 0, "Old ID" }},
FT_UINT32, BASE_DEC, 0, 0, "Old ID", HFILL }},
{ &hf_afs_prot_newid, { "New ID", "afs.prot.newid",
FT_UINT32, BASE_DEC, 0, 0, "New ID" }},
FT_UINT32, BASE_DEC, 0, 0, "New ID", HFILL }},
{ &hf_afs_prot_gid, { "Group ID", "afs.prot.gid",
FT_UINT32, BASE_DEC, 0, 0, "Group ID" }},
FT_UINT32, BASE_DEC, 0, 0, "Group ID", HFILL }},
{ &hf_afs_prot_uid, { "User ID", "afs.prot.uid",
FT_UINT32, BASE_DEC, 0, 0, "User ID" }},
FT_UINT32, BASE_DEC, 0, 0, "User ID", HFILL }},
{ &hf_afs_prot_count, { "Count", "afs.prot.count",
FT_UINT32, BASE_DEC, 0, 0, "Count" }},
FT_UINT32, BASE_DEC, 0, 0, "Count", HFILL }},
{ &hf_afs_prot_maxgid, { "Maximum Group ID", "afs.prot.maxgid",
FT_UINT32, BASE_DEC, 0, 0, "Maximum Group ID" }},
FT_UINT32, BASE_DEC, 0, 0, "Maximum Group ID", HFILL }},
{ &hf_afs_prot_maxuid, { "Maximum User ID", "afs.prot.maxuid",
FT_UINT32, BASE_DEC, 0, 0, "Maximum User ID" }},
FT_UINT32, BASE_DEC, 0, 0, "Maximum User ID", HFILL }},
{ &hf_afs_prot_pos, { "Position", "afs.prot.pos",
FT_UINT32, BASE_DEC, 0, 0, "Position" }},
FT_UINT32, BASE_DEC, 0, 0, "Position", HFILL }},
{ &hf_afs_prot_flag, { "Flag", "afs.prot.flag",
FT_UINT32, BASE_HEX, 0, 0, "Flag" }},
FT_UINT32, BASE_HEX, 0, 0, "Flag", HFILL }},
/* UBIK Fields */
{ &hf_afs_ubik_errcode, { "Error Code", "afs.ubik.errcode",
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code", HFILL }},
{ &hf_afs_ubik_state, { "State", "afs.ubik.state",
FT_UINT32, BASE_HEX, 0, 0, "State" }},
FT_UINT32, BASE_HEX, 0, 0, "State", HFILL }},
{ &hf_afs_ubik_version_epoch, { "Epoch", "afs.ubik.version.epoch",
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Epoch" }},
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Epoch", HFILL }},
{ &hf_afs_ubik_version_counter, { "Counter", "afs.ubik.version.counter",
FT_UINT32, BASE_DEC, 0, 0, "Counter" }},
FT_UINT32, BASE_DEC, 0, 0, "Counter", HFILL }},
{ &hf_afs_ubik_votestart, { "Vote Started", "afs.ubik.votestart",
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Vote Started" }},
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Vote Started", HFILL }},
{ &hf_afs_ubik_voteend, { "Vote Ends", "afs.ubik.voteend",
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Vote Ends" }},
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Vote Ends", HFILL }},
{ &hf_afs_ubik_file, { "File", "afs.ubik.file",
FT_UINT32, BASE_DEC, 0, 0, "File" }},
FT_UINT32, BASE_DEC, 0, 0, "File", HFILL }},
{ &hf_afs_ubik_pos, { "Position", "afs.ubik.position",
FT_UINT32, BASE_DEC, 0, 0, "Position" }},
FT_UINT32, BASE_DEC, 0, 0, "Position", HFILL }},
{ &hf_afs_ubik_length, { "Length", "afs.ubik.length",
FT_UINT32, BASE_DEC, 0, 0, "Length" }},
FT_UINT32, BASE_DEC, 0, 0, "Length", HFILL }},
{ &hf_afs_ubik_locktype, { "Lock Type", "afs.ubik.locktype",
FT_UINT32, BASE_DEC, VALS(ubik_lock_types), 0, "Lock Type" }},
FT_UINT32, BASE_DEC, VALS(ubik_lock_types), 0, "Lock Type", HFILL }},
{ &hf_afs_ubik_votetype, { "Vote Type", "afs.ubik.votetype",
FT_UINT32, BASE_HEX, 0, 0, "Vote Type" }},
FT_UINT32, BASE_HEX, 0, 0, "Vote Type", HFILL }},
{ &hf_afs_ubik_site, { "Site", "afs.ubik.site",
FT_IPv4, BASE_HEX, 0, 0, "Site" }},
FT_IPv4, BASE_HEX, 0, 0, "Site", HFILL }},
{ &hf_afs_ubik_interface, { "Interface Address", "afs.ubik.interface",
FT_IPv4, BASE_HEX, 0, 0, "Interface Address" }},
FT_IPv4, BASE_HEX, 0, 0, "Interface Address", HFILL }},
{ &hf_afs_ubik_now, { "Now", "afs.ubik.now",
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Now" }},
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Now", HFILL }},
{ &hf_afs_ubik_lastyestime, { "Last Yes Time", "afs.ubik.lastyesttime",
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Yes Time" }},
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Yes Time", HFILL }},
{ &hf_afs_ubik_lastyeshost, { "Last Yes Host", "afs.ubik.lastyeshost",
FT_IPv4, BASE_HEX, 0, 0, "Last Yes Host" }},
FT_IPv4, BASE_HEX, 0, 0, "Last Yes Host", HFILL }},
{ &hf_afs_ubik_lastyesstate, { "Last Yes State", "afs.ubik.lastyesstate",
FT_UINT32, BASE_HEX, 0, 0, "Last Yes State" }},
FT_UINT32, BASE_HEX, 0, 0, "Last Yes State", HFILL }},
{ &hf_afs_ubik_lastyesclaim, { "Last Yes Claim", "afs.ubik.lastyesclaim",
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Yes Claim" }},
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Yes Claim", HFILL }},
{ &hf_afs_ubik_lowesthost, { "Lowest Host", "afs.ubik.lowesthost",
FT_IPv4, BASE_HEX, 0, 0, "Lowest Host" }},
FT_IPv4, BASE_HEX, 0, 0, "Lowest Host", HFILL }},
{ &hf_afs_ubik_lowesttime, { "Lowest Time", "afs.ubik.lowesttime",
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Lowest Time" }},
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Lowest Time", HFILL }},
{ &hf_afs_ubik_synchost, { "Sync Host", "afs.ubik.synchost",
FT_IPv4, BASE_HEX, 0, 0, "Sync Host" }},
FT_IPv4, BASE_HEX, 0, 0, "Sync Host", HFILL }},
{ &hf_afs_ubik_addr, { "Address", "afs.ubik.addr",
FT_IPv4, BASE_HEX, 0, 0, "Address" }},
FT_IPv4, BASE_HEX, 0, 0, "Address", HFILL }},
{ &hf_afs_ubik_synctime, { "Sync Time", "afs.ubik.synctime",
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Sync Time" }},
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Sync Time", HFILL }},
{ &hf_afs_ubik_lastvotetime, { "Last Vote Time", "afs.ubik.lastvotetime",
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Vote Time" }},
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Vote Time", HFILL }},
{ &hf_afs_ubik_lastbeaconsent, { "Last Beacon Sent", "afs.ubik.lastbeaconsent",
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Beacon Sent" }},
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Last Beacon Sent", HFILL }},
{ &hf_afs_ubik_lastvote, { "Last Vote", "afs.ubik.lastvote",
FT_UINT32, BASE_HEX, 0, 0, "Last Vote" }},
FT_UINT32, BASE_HEX, 0, 0, "Last Vote", HFILL }},
{ &hf_afs_ubik_currentdb, { "Current DB", "afs.ubik.currentdb",
FT_UINT32, BASE_HEX, 0, 0, "Current DB" }},
FT_UINT32, BASE_HEX, 0, 0, "Current DB", HFILL }},
{ &hf_afs_ubik_up, { "Up", "afs.ubik.up",
FT_UINT32, BASE_HEX, 0, 0, "Up" }},
FT_UINT32, BASE_HEX, 0, 0, "Up", HFILL }},
{ &hf_afs_ubik_beaconsincedown, { "Beacon Since Down", "afs.ubik.beaconsincedown",
FT_UINT32, BASE_HEX, 0, 0, "Beacon Since Down" }},
FT_UINT32, BASE_HEX, 0, 0, "Beacon Since Down", HFILL }},
{ &hf_afs_ubik_amsyncsite, { "Am Sync Site", "afs.ubik.amsyncsite",
FT_UINT32, BASE_HEX, 0, 0, "Am Sync Site" }},
FT_UINT32, BASE_HEX, 0, 0, "Am Sync Site", HFILL }},
{ &hf_afs_ubik_syncsiteuntil, { "Sync Site Until", "afs.ubik.syncsiteuntil",
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Sync Site Until" }},
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Sync Site Until", HFILL }},
{ &hf_afs_ubik_nservers, { "Number of Servers", "afs.ubik.nservers",
FT_UINT32, BASE_HEX, 0, 0, "Number of Servers" }},
FT_UINT32, BASE_HEX, 0, 0, "Number of Servers", HFILL }},
{ &hf_afs_ubik_lockedpages, { "Locked Pages", "afs.ubik.lockedpages",
FT_UINT32, BASE_HEX, 0, 0, "Locked Pages" }},
FT_UINT32, BASE_HEX, 0, 0, "Locked Pages", HFILL }},
{ &hf_afs_ubik_writelockedpages, { "Write Locked Pages", "afs.ubik.writelockedpages",
FT_UINT32, BASE_HEX, 0, 0, "Write Locked Pages" }},
FT_UINT32, BASE_HEX, 0, 0, "Write Locked Pages", HFILL }},
{ &hf_afs_ubik_activewrite, { "Active Write", "afs.ubik.activewrite",
FT_UINT32, BASE_HEX, 0, 0, "Active Write" }},
FT_UINT32, BASE_HEX, 0, 0, "Active Write", HFILL }},
{ &hf_afs_ubik_tidcounter, { "TID Counter", "afs.ubik.tidcounter",
FT_UINT32, BASE_HEX, 0, 0, "TID Counter" }},
FT_UINT32, BASE_HEX, 0, 0, "TID Counter", HFILL }},
{ &hf_afs_ubik_anyreadlocks, { "Any Read Locks", "afs.ubik.anyreadlocks",
FT_UINT32, BASE_HEX, 0, 0, "Any Read Locks" }},
FT_UINT32, BASE_HEX, 0, 0, "Any Read Locks", HFILL }},
{ &hf_afs_ubik_anywritelocks, { "Any Write Locks", "afs.ubik.anywritelocks",
FT_UINT32, BASE_HEX, 0, 0, "Any Write Locks" }},
FT_UINT32, BASE_HEX, 0, 0, "Any Write Locks", HFILL }},
{ &hf_afs_ubik_recoverystate, { "Recovery State", "afs.ubik.recoverystate",
FT_UINT32, BASE_HEX, 0, 0, "Recovery State" }},
FT_UINT32, BASE_HEX, 0, 0, "Recovery State", HFILL }},
{ &hf_afs_ubik_currenttrans, { "Current Transaction", "afs.ubik.currenttran",
FT_UINT32, BASE_HEX, 0, 0, "Current Transaction" }},
FT_UINT32, BASE_HEX, 0, 0, "Current Transaction", HFILL }},
{ &hf_afs_ubik_writetrans, { "Write Transaction", "afs.ubik.writetran",
FT_UINT32, BASE_HEX, 0, 0, "Write Transaction" }},
FT_UINT32, BASE_HEX, 0, 0, "Write Transaction", HFILL }},
{ &hf_afs_ubik_epochtime, { "Epoch Time", "afs.ubik.epochtime",
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Epoch Time" }},
FT_ABSOLUTE_TIME, BASE_HEX, 0, 0, "Epoch Time", HFILL }},
{ &hf_afs_ubik_isclone, { "Is Clone", "afs.ubik.isclone",
FT_UINT32, BASE_HEX, 0, 0, "Is Clone" }},
FT_UINT32, BASE_HEX, 0, 0, "Is Clone", HFILL }},

14
packet-aim.c
View File

@ -2,7 +2,7 @@
* Routines for AIM Instant Messenger (OSCAR) dissection
* Copyright 2000, Ralf Hoelzer <ralf@well.com>
*
* $Id: packet-aim.c,v 1.8 2001/04/20 20:34:28 guy Exp $
* $Id: packet-aim.c,v 1.9 2001/06/18 02:17:44 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -576,22 +576,22 @@ proto_register_aim(void)
/* Setup list of header fields */
static hf_register_info hf[] = {
{ &hf_aim_cmd_start,
{ "Command Start", "aim.cmd_start", FT_UINT8, BASE_HEX, NULL, 0x0, "" }
{ "Command Start", "aim.cmd_start", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }
},
{ &hf_aim_channel,
{ "Channel ID", "aim.channel", FT_UINT8, BASE_HEX, NULL, 0x0, "" }
{ "Channel ID", "aim.channel", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }
},
{ &hf_aim_seqno,
{ "Sequence Number", "aim.seqno", FT_UINT16, BASE_DEC, NULL, 0x0, "" }
{ "Sequence Number", "aim.seqno", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }
},
{ &hf_aim_data_len,
{ "Data Field Length", "aim.datalen", FT_UINT16, BASE_DEC, NULL, 0x0, "" }
{ "Data Field Length", "aim.datalen", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }
},
{ &hf_aim_fnac_family,
{ "FNAC Family ID", "aim.fnac.family", FT_UINT16, BASE_HEX, NULL, 0x0, "" }
{ "FNAC Family ID", "aim.fnac.family", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }
},
{ &hf_aim_fnac_subtype,
{ "FNAC Subtype ID", "aim.fnac.subtype", FT_UINT16, BASE_HEX, NULL, 0x0, "" }
{ "FNAC Subtype ID", "aim.fnac.subtype", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }
},
};

52
packet-arp.c
View File

@ -1,7 +1,7 @@
/* packet-arp.c
* Routines for ARP packet disassembly
*
* $Id: packet-arp.c,v 1.43 2001/03/13 21:34:23 gram Exp $
* $Id: packet-arp.c,v 1.44 2001/06/18 02:17:44 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -806,127 +806,127 @@ proto_register_arp(void)
{ &hf_arp_hard_type,
{ "Hardware type", "arp.hw.type",
FT_UINT16, BASE_HEX, VALS(hrd_vals), 0x0,
"" }},
"", HFILL }},
{ &hf_arp_proto_type,
{ "Protocol type", "arp.proto.type",
FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0,
"" }},
"", HFILL }},
{ &hf_arp_hard_size,
{ "Hardware size", "arp.hw.size",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_atmarp_sht,
{ "Sender ATM number type", "arp.src.htype",
FT_BOOLEAN, 8, &type_bit, ATMARP_IS_E164,
"" }},
"", HFILL }},
{ &hf_atmarp_shl,
{ "Sender ATM number length", "arp.src.hlen",
FT_UINT8, BASE_DEC, NULL, ATMARP_LEN_MASK,
"" }},
"", HFILL }},
{ &hf_atmarp_sst,
{ "Sender ATM subaddress type", "arp.src.stype",
FT_BOOLEAN, 8, &type_bit, ATMARP_IS_E164,
"" }},
"", HFILL }},
{ &hf_atmarp_ssl,
{ "Sender ATM subaddress length", "arp.src.slen",
FT_UINT8, BASE_DEC, NULL, ATMARP_LEN_MASK,
"" }},
"", HFILL }},
{ &hf_arp_proto_size,
{ "Protocol size", "arp.proto.size",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_arp_opcode,
{ "Opcode", "arp.opcode",
FT_UINT16, BASE_HEX, VALS(op_vals), 0x0,
"" }},
"", HFILL }},
{ &hf_atmarp_spln,
{ "Sender protocol size", "arp.src.pln",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_atmarp_tht,
{ "Target ATM number type", "arp.dst.htype",
FT_BOOLEAN, 8, &type_bit, ATMARP_IS_E164,
"" }},
"", HFILL }},
{ &hf_atmarp_thl,
{ "Target ATM number length", "arp.dst.hlen",
FT_UINT8, BASE_DEC, NULL, ATMARP_LEN_MASK,
"" }},
"", HFILL }},
{ &hf_atmarp_tst,
{ "Target ATM subaddress type", "arp.dst.stype",
FT_BOOLEAN, 8, &type_bit, ATMARP_IS_E164,
"" }},
"", HFILL }},
{ &hf_atmarp_tsl,
{ "Target ATM subaddress length", "arp.dst.slen",
FT_UINT8, BASE_DEC, NULL, ATMARP_LEN_MASK,
"" }},
"", HFILL }},
{ &hf_atmarp_tpln,
{ "Target protocol size", "arp.dst.pln",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_arp_src_ether,
{ "Sender hardware address", "arp.src.hw",
FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_atmarp_src_atm_num_e164,
{ "Sender ATM number (E.164)", "arp.src.atm_num_e164",
FT_STRING, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_atmarp_src_atm_num_nsap,
{ "Sender ATM number (NSAP)", "arp.src.atm_num_nsap",
FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_atmarp_src_atm_subaddr,
{ "Sender ATM subaddress", "arp.src.atm_subaddr",
FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_arp_src_proto,
{ "Sender protocol address", "arp.src.proto",
FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_arp_dst_ether,
{ "Target hardware address", "arp.dst.hw",
FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_atmarp_dst_atm_num_e164,
{ "Target ATM number (E.164)", "arp.dst.atm_num_e164",
FT_STRING, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_atmarp_dst_atm_num_nsap,
{ "Target ATM number (NSAP)", "arp.dst.atm_num_nsap",
FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_atmarp_dst_atm_subaddr,
{ "Target ATM subaddress", "arp.dst.atm_subaddr",
FT_BYTES, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_arp_dst_proto,
{ "Target protocol address", "arp.dst.proto",
FT_BYTES, BASE_NONE, NULL, 0x0,
"" }}
"", HFILL }}
};
static gint *ett[] = {
&ett_arp,

14
packet-ascend.c
View File

@ -1,7 +1,7 @@
/* packet-ascend.c
* Routines for decoding Lucent/Ascend packet traces
*
* $Id: packet-ascend.c,v 1.25 2001/03/30 06:10:54 guy Exp $
* $Id: packet-ascend.c,v 1.26 2001/06/18 02:17:44 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -113,27 +113,27 @@ proto_register_ascend(void)
static hf_register_info hf[] = {
{ &hf_link_type,
{ "Link type", "ascend.type", FT_UINT32, BASE_DEC, VALS(encaps_vals), 0x0,
"" }},
"", HFILL }},
{ &hf_session_id,
{ "Session ID", "ascend.sess", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_called_number,
{ "Called number", "ascend.number", FT_STRING, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_chunk,
{ "WDD Chunk", "ascend.chunk", FT_UINT32, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_task,
{ "Task", "ascend.task", FT_UINT32, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_user_name,
{ "User name", "ascend.user", FT_STRING, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
};
static gint *ett[] = {
&ett_raw,

60
packet-atalk.c
View File

@ -1,7 +1,7 @@
/* packet-atalk.c
* Routines for Appletalk packet disassembly (DDP, currently).
*
* $Id: packet-atalk.c,v 1.54 2001/04/27 01:27:36 guy Exp $
* $Id: packet-atalk.c,v 1.55 2001/06/18 02:17:44 guy Exp $
*
* Simon Wilkinson <sxw@dcs.ed.ac.uk>
*
@ -427,106 +427,106 @@ proto_register_atalk(void)
static hf_register_info hf_ddp[] = {
{ &hf_ddp_hopcount,
{ "Hop count", "ddp.hopcount", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ddp_len,
{ "Datagram length", "ddp.len", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ddp_checksum,
{ "Checksum", "ddp.checksum", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ddp_dst_net,
{ "Destination Net", "ddp.dst.net", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ddp_src_net,
{ "Source Net", "ddp.src.net", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ddp_dst_node,
{ "Destination Node", "ddp.dst.node", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ddp_src_node,
{ "Source Node", "ddp.src.node", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ddp_dst_socket,
{ "Destination Socket", "ddp.dst.socket", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ddp_src_socket,
{ "Source Socket", "ddp.src.socket", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ddp_type,
{ "Protocol type", "ddp.type", FT_UINT8, BASE_DEC, VALS(op_vals), 0x0,
"" }},
"", HFILL }},
};
static hf_register_info hf_nbp[] = {
{ &hf_nbp_op,
{ "Operation", "nbp.op", FT_UINT8, BASE_DEC,
VALS(nbp_op_vals), 0xF0, "Operation" }},
VALS(nbp_op_vals), 0xF0, "Operation", HFILL }},
{ &hf_nbp_info,
{ "Info", "nbp.info", FT_UINT8, BASE_HEX,
NULL, 0x0, "Info" }},
NULL, 0x0, "Info", HFILL }},
{ &hf_nbp_count,
{ "Count", "nbp.count", FT_UINT8, BASE_DEC,
NULL, 0x0F, "Count" }},
NULL, 0x0F, "Count", HFILL }},
{ &hf_nbp_node_net,
{ "Network", "nbp.net", FT_UINT16, BASE_DEC,
NULL, 0x0, "Network" }},
NULL, 0x0, "Network", HFILL }},
{ &hf_nbp_node_node,
{ "Node", "nbp.node", FT_UINT8, BASE_DEC,
NULL, 0x0, "Node" }},
NULL, 0x0, "Node", HFILL }},
{ &hf_nbp_node_port,
{ "Port", "nbp.port", FT_UINT8, BASE_DEC,
NULL, 0x0, "Port" }},
NULL, 0x0, "Port", HFILL }},
{ &hf_nbp_node_enum,
{ "Enumerator", "nbp.enum", FT_UINT8, BASE_DEC,
NULL, 0x0, "Enumerator" }},
NULL, 0x0, "Enumerator", HFILL }},
{ &hf_nbp_node_object,
{ "Object", "nbp.object", FT_STRING, BASE_DEC,
NULL, 0x0, "Object" }},
NULL, 0x0, "Object", HFILL }},
{ &hf_nbp_node_type,
{ "Type", "nbp.type", FT_STRING, BASE_DEC,
NULL, 0x0, "Type" }},
NULL, 0x0, "Type", HFILL }},
{ &hf_nbp_node_zone,
{ "Zone", "nbp.zone", FT_STRING, BASE_DEC,
NULL, 0x0, "Zone" }},
NULL, 0x0, "Zone", HFILL }},
{ &hf_nbp_tid,
{ "Transaction ID", "nbp.tid", FT_UINT8, BASE_DEC,
NULL, 0x0, "Transaction ID" }}
NULL, 0x0, "Transaction ID", HFILL }}
};
static hf_register_info hf_rtmp[] = {
{ &hf_rtmp_net,
{ "Net", "rtmp.net", FT_UINT16, BASE_DEC,
NULL, 0x0, "Net" }},
NULL, 0x0, "Net", HFILL }},
{ &hf_rtmp_node,
{ "Node", "nbp.nodeid", FT_UINT8, BASE_DEC,
NULL, 0x0, "Node" }},
NULL, 0x0, "Node", HFILL }},
{ &hf_rtmp_node_len,
{ "Node Length", "nbp.nodeid.length", FT_UINT8, BASE_DEC,
NULL, 0x0, "Node Length" }},
NULL, 0x0, "Node Length", HFILL }},
{ &hf_rtmp_tuple_net,
{ "Net", "rtmp.tuple.net", FT_UINT16, BASE_DEC,
NULL, 0x0, "Net" }},
NULL, 0x0, "Net", HFILL }},
{ &hf_rtmp_tuple_range_start,
{ "Range Start", "rtmp.tuple.range_start", FT_UINT16, BASE_DEC,
NULL, 0x0, "Range Start" }},
NULL, 0x0, "Range Start", HFILL }},
{ &hf_rtmp_tuple_range_end,
{ "Range End", "rtmp.tuple.range_end", FT_UINT16, BASE_DEC,
NULL, 0x0, "Range End" }},
NULL, 0x0, "Range End", HFILL }},
{ &hf_rtmp_tuple_dist,
{ "Distance", "rtmp.tuple.dist", FT_UINT16, BASE_DEC,
NULL, 0x0, "Distance" }},
NULL, 0x0, "Distance", HFILL }},
{ &hf_rtmp_function,
{ "Function", "rtmp.function", FT_UINT8, BASE_DEC,
VALS(rtmp_function_vals), 0x0, "Request Function" }}
VALS(rtmp_function_vals), 0x0, "Request Function", HFILL }}
};

6
packet-atm.c
View File

@ -1,7 +1,7 @@
/* packet-atm.c
* Routines for ATM packet disassembly
*
* $Id: packet-atm.c,v 1.35 2001/05/27 07:46:57 guy Exp $
* $Id: packet-atm.c,v 1.36 2001/06/18 02:17:44 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -765,11 +765,11 @@ proto_register_atm(void)
static hf_register_info hf[] = {
{ &hf_atm_vpi,
{ "VPI", "atm.vpi", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_atm_vci,
{ "VCI", "atm.vci", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
};
static gint *ett[] = {
&ett_atm,

20
packet-auto_rp.c
View File

@ -4,7 +4,7 @@
*
* Heikki Vatiainen <hessu@cs.tut.fi>
*
* $Id: packet-auto_rp.c,v 1.13 2001/01/25 06:14:13 guy Exp $
* $Id: packet-auto_rp.c,v 1.14 2001/06/18 02:17:44 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -182,47 +182,47 @@ void proto_register_auto_rp(void)
{ &hf_auto_rp_version,
{"Protocol version", "auto_rp.version",
FT_UINT8, BASE_DEC, VALS(auto_rp_ver_vals), AUTO_RP_VERSION_MASK,
"Auto-RP protocol version"}},
"Auto-RP protocol version", HFILL }},
{ &hf_auto_rp_type,
{"Packet type", "auto_rp.type",
FT_UINT8, BASE_DEC, VALS(auto_rp_type_vals), AUTO_RP_TYPE_MASK,
"Auto-RP packet type"}},
"Auto-RP packet type", HFILL }},
{ &hf_auto_rp_count,
{"RP count", "auto_rp.rp_count",
FT_UINT8, BASE_DEC, NULL, 0,
"The number of RP addresses contained in this message"}},
"The number of RP addresses contained in this message", HFILL }},
{ &hf_auto_rp_holdtime,
{"Holdtime", "auto_rp.holdtime",
FT_UINT16, BASE_DEC, NULL, 0,
"The amount of time in seconds this announcement is valid"}},
"The amount of time in seconds this announcement is valid", HFILL }},
{ &hf_auto_rp_pim_ver,
{"Version", "auto_rp.pim_ver",
FT_UINT8, BASE_DEC, VALS(auto_rp_pim_ver_vals), AUTO_RP_PIM_VER_MASK,
"RP's highest PIM version"}},
"RP's highest PIM version", HFILL }},
{ &hf_auto_rp_rp_addr,
{"RP address", "auto_rp.rp_addr",
FT_IPv4, 0, NULL, 0,
"The unicast IP address of the RP"}},
"The unicast IP address of the RP", HFILL }},
{ &hf_auto_rp_prefix_sgn,
{"Sign", "auto_rp.prefix_sign",
FT_UINT8, BASE_DEC, VALS(auto_rp_mask_sign_vals), AUTO_RP_SIGN_MASK,
"Group prefix sign"}},
"Group prefix sign", HFILL }},
{ &hf_auto_rp_mask_len,
{"Mask length", "auto_rp.mask_len",
FT_UINT8, BASE_BIN, NULL, 0x0,
"Length of group prefix"}},
"Length of group prefix", HFILL }},
{ &hf_auto_rp_group_prefix,
{"Prefix", "auto_rp.group_prefix",
FT_IPv4, 0, NULL, 0,
"Group prefix"}}
"Group prefix", HFILL }}
};
static gint *ett[] = {

4
packet-bacapp.c
View File

@ -2,7 +2,7 @@
* Routines for BACnet (APDU) dissection
* Copyright 2001, Hartmut Mueller <hartmut@abmlinux.org>, FH Dortmund
*
* $Id: packet-bacapp.c,v 1.3 2001/05/30 07:48:23 guy Exp $
* $Id: packet-bacapp.c,v 1.4 2001/06/18 02:17:44 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -111,7 +111,7 @@ proto_register_bacapp(void)
static hf_register_info hf[] = {
{ &hf_bacapp_type,
{ "APDU Type", "bacapp.bacapp_type",
FT_UINT8, BASE_DEC, NULL, 0xf0, "APDU Type" }
FT_UINT8, BASE_DEC, NULL, 0xf0, "APDU Type", HFILL }
},
};
static gint *ett[] = {

56
packet-bacnet.c
View File

@ -2,7 +2,7 @@
* Routines for BACnet (NPDU) dissection
* Copyright 2001, Hartmut Mueller <hartmut@abmlinux.org>, FH Dortmund
*
* $Id: packet-bacnet.c,v 1.3 2001/05/30 07:48:23 guy Exp $
* $Id: packet-bacnet.c,v 1.4 2001/06/18 02:17:44 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -438,145 +438,145 @@ proto_register_bacnet(void)
{ &hf_bacnet_version,
{ "Version", "bacnet.version",
FT_UINT8, BASE_DEC, NULL, 0,
"BACnet Version" }
"BACnet Version", HFILL }
},
{ &hf_bacnet_control,
{ "Control", "bacnet.control",
FT_UINT8, BASE_HEX, NULL, 0xff,
"BACnet Control" }
"BACnet Control", HFILL }
},
{ &hf_bacnet_control_net,
{ "NSDU contains",
"bacnet.control_net",
FT_BOOLEAN, 8, TFS(&control_net_set_high),
BAC_CONTROL_NET, "BACnet Control" }
BAC_CONTROL_NET, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_res1,
{ "Reserved",
"bacnet.control_res1",
FT_BOOLEAN, 8, TFS(&control_res_high),
BAC_CONTROL_RES1, "BACnet Control" }
BAC_CONTROL_RES1, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_dest,
{ "Destination Specifier",
"bacnet.control_dest",
FT_BOOLEAN, 8, TFS(&control_dest_high),
BAC_CONTROL_DEST, "BACnet Control" }
BAC_CONTROL_DEST, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_res2,
{ "Reserved",
"bacnet.control_res2",
FT_BOOLEAN, 8, TFS(&control_res_high),
BAC_CONTROL_RES2, "BACnet Control" }
BAC_CONTROL_RES2, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_src,
{ "Source specifier",
"bacnet.control_src",
FT_BOOLEAN, 8, TFS(&control_src_high),
BAC_CONTROL_SRC, "BACnet Control" }
BAC_CONTROL_SRC, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_expect,
{ "Expecting Reply",
"bacnet.control_expect",
FT_BOOLEAN, 8, TFS(&control_expect_high),
BAC_CONTROL_EXPECT, "BACnet Control" }
BAC_CONTROL_EXPECT, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_prio_high,
{ "Priority",
"bacnet.control_prio_high",
FT_BOOLEAN, 8, TFS(&control_prio_high_high),
BAC_CONTROL_PRIO_HIGH, "BACnet Control" }
BAC_CONTROL_PRIO_HIGH, "BACnet Control", HFILL }
},
{ &hf_bacnet_control_prio_low,
{ "Priority",
"bacnet.control_prio_low",
FT_BOOLEAN, 8, TFS(&control_prio_low_high),
BAC_CONTROL_PRIO_LOW, "BACnet Control" }
BAC_CONTROL_PRIO_LOW, "BACnet Control", HFILL }
},
{ &hf_bacnet_dnet,
{ "Destination Network Address", "bacnet.dnet",
FT_UINT16, BASE_HEX, NULL, 0,
"Destination Network Address" }
"Destination Network Address", HFILL }
},
{ &hf_bacnet_dlen,
{ "Destination MAC Layer Address Length", "bacnet.dlen",
FT_UINT8, BASE_DEC, NULL, 0,
"Destination MAC Layer Address Length" }
"Destination MAC Layer Address Length", HFILL }
},
{ &hf_bacnet_dadr_eth,
{ "Destination ISO 8802-3 MAC Address", "bacnet.dadr_eth",
FT_ETHER, BASE_HEX, NULL, 0,
"Destination ISO 8802-3 MAC Address" }
"Destination ISO 8802-3 MAC Address", HFILL }
},
{ &hf_bacnet_dadr_tmp,
{ "Unknown Destination MAC", "bacnet.dadr_tmp",
FT_BYTES, BASE_HEX, NULL, 0,
"Unknown Destination MAC" }
"Unknown Destination MAC", HFILL }
},
{ &hf_bacnet_snet,
{ "Source Network Address", "bacnet.snet",
FT_UINT16, BASE_HEX, NULL, 0,
"Source Network Address" }
"Source Network Address", HFILL }
},
{ &hf_bacnet_slen,
{ "Source MAC Layer Address Length", "bacnet.slen",
FT_UINT8, BASE_DEC, NULL, 0,
"Source MAC Layer Address Length" }
"Source MAC Layer Address Length", HFILL }
},
{ &hf_bacnet_sadr_eth,
{ "SADR", "bacnet.sadr_eth",
FT_ETHER, BASE_HEX, NULL, 0,
"Source ISO 8802-3 MAC Address" }
"Source ISO 8802-3 MAC Address", HFILL }
},
{ &hf_bacnet_sadr_tmp,
{ "Unknown Source MAC", "bacnet.sadr_tmp",
FT_BYTES, BASE_HEX, NULL, 0,
"Unknown Source MAC" }
"Unknown Source MAC", HFILL }
},
{ &hf_bacnet_hopc,
{ "Hop Count", "bacnet.hopc",
FT_UINT8, BASE_DEC, NULL, 0,
"Hop Count" }
"Hop Count", HFILL }
},
{ &hf_bacnet_mesgtyp,
{ "Message Type", "bacnet.mesgtyp",
FT_UINT8, BASE_HEX, NULL, 0,
"Message Type" }
"Message Type", HFILL }
},
{ &hf_bacnet_vendor,
{ "Vendor ID", "bacnet.vendor",
FT_UINT16, BASE_HEX, NULL, 0,
"Vendor ID" }
"Vendor ID", HFILL }
},
{ &hf_bacnet_perf,
{ "Performance Index", "bacnet.perf",
FT_UINT8, BASE_DEC, NULL, 0,
"Performance Index" }
"Performance Index", HFILL }
},
{ &hf_bacnet_rejectreason,
{ "Reject Reason", "bacnet.rejectreason",
FT_UINT8, BASE_DEC, NULL, 0,
"Reject Reason" }
"Reject Reason", HFILL }
},
{ &hf_bacnet_rportnum,
{ "Number of Port Mappings", "bacnet.rportnum",
FT_UINT8, BASE_DEC, NULL, 0,
"Number of Port Mappings" }
"Number of Port Mappings", HFILL }
},
{ &hf_bacnet_pinfolen,
{ "Port Info Length", "bacnet.pinfolen",
FT_UINT8, BASE_DEC, NULL, 0,
"Port Info Length" }
"Port Info Length", HFILL }
},
{ &hf_bacnet_portid,
{ "Port ID", "bacnet.portid",
FT_UINT8, BASE_HEX, NULL, 0,
"Port ID" }
"Port ID", HFILL }
},
{ &hf_bacnet_pinfo,
{ "Port Info", "bacnet.pinfo",
FT_UINT8, BASE_HEX, NULL, 0,
"Port Info" }
"Port Info", HFILL }
},
};

4
packet-bgp.c
View File

@ -2,7 +2,7 @@
* Routines for BGP packet dissection.
* Copyright 1999, Jun-ichiro itojun Hagino <itojun@itojun.org>
*
* $Id: packet-bgp.c,v 1.40 2001/06/15 08:01:31 guy Exp $
* $Id: packet-bgp.c,v 1.41 2001/06/18 02:17:44 guy Exp $
*
* Supports:
* RFC1771 A Border Gateway Protocol 4 (BGP-4)
@ -1701,7 +1701,7 @@ proto_register_bgp(void)
static hf_register_info hf[] = {
{ &hf_bgp_type,
{ "BGP message type", "bgp.type", FT_UINT8, BASE_HEX,
VALS(bgptypevals), 0x0, "BGP message type" }},
VALS(bgptypevals), 0x0, "BGP message type", HFILL }},
};
static gint *ett[] = {

34
packet-bootp.c
View File

@ -2,7 +2,7 @@
* Routines for BOOTP/DHCP packet disassembly
* Gilbert Ramirez <gram@xiexie.org>
*
* $Id: packet-bootp.c,v 1.53 2001/05/25 06:56:53 guy Exp $
* $Id: packet-bootp.c,v 1.54 2001/06/18 02:17:45 guy Exp $
*
* The information used comes from:
* RFC 951: Bootstrap Protocol
@ -1178,82 +1178,82 @@ proto_register_bootp(void)
{ &hf_bootp_dhcp,
{ "Frame is DHCP", "bootp.dhcp", FT_BOOLEAN,
BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_type,
{ "Message type", "bootp.type", FT_UINT8,
BASE_DEC, VALS(op_vals), 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_hw_type,
{ "Hardware type", "bootp.hw.type", FT_UINT8,
BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_hw_len,
{ "Hardware address length", "bootp.hw.len", FT_UINT8,
BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_hops,
{ "Hops", "bootp.hops", FT_UINT8,
BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_id,
{ "Transaction ID", "bootp.id", FT_UINT32,
BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_secs,
{ "Seconds elapsed", "bootp.secs", FT_UINT16,
BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_flag,
{ "Broadcast flag", "bootp.flag", FT_UINT16,
BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_ip_client,
{ "Client IP address", "bootp.ip.client",FT_IPv4,
BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_ip_your,
{ "Your (client) IP address", "bootp.ip.your", FT_IPv4,
BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_ip_server,
{ "Next server IP address", "bootp.ip.server",FT_IPv4,
BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_ip_relay,
{ "Relay agent IP address", "bootp.ip.relay", FT_IPv4,
BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_hw_addr,
{ "Client hardware address", "bootp.hw.addr", FT_BYTES,
BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_server,
{ "Server host name", "bootp.server", FT_STRING,
BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_file,
{ "Boot file name", "bootp.file", FT_STRING,
BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bootp_cookie,
{ "Magic cookie", "bootp.cookie", FT_IPv4,
BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
};
static gint *ett[] = {
&ett_bootp,

16
packet-bootparams.c
View File

@ -1,7 +1,7 @@
/* packet-bootparams.c
* Routines for bootparams dissection
*
* $Id: packet-bootparams.c,v 1.18 2001/05/30 06:01:01 guy Exp $
* $Id: packet-bootparams.c,v 1.19 2001/06/18 02:17:45 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -159,25 +159,25 @@ proto_register_bootparams(void)
static hf_register_info hf[] = {
{ &hf_bootparams_host, {
"Client Host", "bootparams.host", FT_STRING, BASE_DEC,
NULL, 0, "Client Host" }},
NULL, 0, "Client Host", HFILL }},
{ &hf_bootparams_domain, {
"Client Domain", "bootparams.domain", FT_STRING, BASE_DEC,
NULL, 0, "Client Domain" }},
NULL, 0, "Client Domain", HFILL }},
{ &hf_bootparams_fileid, {
"File ID", "bootparams.fileid", FT_STRING, BASE_DEC,
NULL, 0, "File ID" }},
NULL, 0, "File ID", HFILL }},
{ &hf_bootparams_filepath, {
"File Path", "bootparams.filepath", FT_STRING, BASE_DEC,
NULL, 0, "File Path" }},
NULL, 0, "File Path", HFILL }},
{ &hf_bootparams_hostaddr, {
"Client Address", "bootparams.hostaddr", FT_IPv4, BASE_DEC,
NULL, 0, "Address" }},
NULL, 0, "Address", HFILL }},
{ &hf_bootparams_routeraddr, {
"Router Address", "bootparams.routeraddr", FT_IPv4, BASE_DEC,
NULL, 0, "Router Address" }},
NULL, 0, "Router Address", HFILL }},
{ &hf_bootparams_addresstype, {
"Address Type", "bootparams.type", FT_UINT32, BASE_DEC,
VALS(addr_type), 0, "Address Type" }},
VALS(addr_type), 0, "Address Type", HFILL }},
};
static gint *ett[] = {
&ett_bootparams,

26
packet-bpdu.c
View File

@ -1,7 +1,7 @@
/* packet-bpdu.c
* Routines for BPDU (Spanning Tree Protocol) disassembly
*
* $Id: packet-bpdu.c,v 1.25 2001/05/27 07:07:34 guy Exp $
* $Id: packet-bpdu.c,v 1.26 2001/06/18 02:17:45 guy Exp $
*
* Copyright 1999 Christophe Tronche <ch.tronche@computer.org>
*
@ -275,51 +275,51 @@ proto_register_bpdu(void)
{ &hf_bpdu_proto_id,
{ "Protocol Identifier", "stp.protocol",
FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bpdu_version_id,
{ "Protocol Version Identifier", "stp.version",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bpdu_type,
{ "BPDU type", "stp.type",
FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bpdu_flags,
{ "BPDU flags", "stp.flags",
FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bpdu_root_mac,
{ "Root Identifier", "stp.root.hw",
FT_ETHER, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bpdu_root_cost,
{ "Root Path Cost", "stp.root.cost",
FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bpdu_bridge_mac,
{ "Bridge Identifier", "stp.bridge.hw",
FT_ETHER, BASE_NONE, NULL, 0x0,
""}},
"", HFILL }},
{ &hf_bpdu_port_id,
{ "Port identifier", "stp.port",
FT_UINT16, BASE_HEX, NULL, 0x0,
""}},
"", HFILL }},
{ &hf_bpdu_msg_age,
{ "Message Age", "stp.msg_age",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bpdu_max_age,
{ "Max Age", "stp.max_age",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bpdu_hello_time,
{ "Hello Time", "stp.hello",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_bpdu_forward_delay,
{ "Forward Delay", "stp.forward",
FT_DOUBLE, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
};
static gint *ett[] = {
&ett_bpdu,

30
packet-bvlc.c
View File

@ -2,7 +2,7 @@
* Routines for BACnet/IP (BVLL, BVLC) dissection
* Copyright 2001, Hartmut Mueller <hartmut@abmlinux.org>, FH Dortmund
*
* $Id: packet-bvlc.c,v 1.3 2001/05/30 07:48:23 guy Exp $
* $Id: packet-bvlc.c,v 1.4 2001/06/18 02:17:45 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -304,74 +304,74 @@ proto_register_bvlc(void)
{ &hf_bvlc_type,
{ "Type", "bvlc.type",
FT_UINT8, BASE_HEX, NULL, 0,
"Type" }
"Type", HFILL }
},
{ &hf_bvlc_function,
{ "Function", "bvlc.function",
FT_UINT8, BASE_HEX, NULL, 0,
"BLVC Function" }
"BLVC Function", HFILL }
},
{ &hf_bvlc_length,
{ "Length", "bvlc.length",
FT_UINT16, BASE_DEC, NULL, 0,
"Length of BVLC" }
"Length of BVLC", HFILL }
},
/* We should bitmask the result correctly when we have a
* packet to dissect */
{ &hf_bvlc_result,
{ "Result", "bvlc.result",
FT_UINT16, BASE_HEX, NULL, 0xffff,
"Result Code" }
"Result Code", HFILL }
},
{ &hf_bvlc_bdt_ip,
{ "IP", "bvlc.bdt_ip",
FT_IPv4, BASE_NONE, NULL, 0,
"BDT IP" }
"BDT IP", HFILL }
},
{ &hf_bvlc_bdt_port,
{ "Port", "bvlc.bdt_port",
FT_UINT16, BASE_DEC, NULL, 0,
"BDT Port" }
"BDT Port", HFILL }
},
{ &hf_bvlc_bdt_mask,
{ "Mask", "bvlc.bdt_mask",
FT_BYTES, BASE_HEX, NULL, 0,
"BDT Broadcast Distribution Mask" }
"BDT Broadcast Distribution Mask", HFILL }
},
{ &hf_bvlc_reg_ttl,
{ "TTL", "bvlc.reg_ttl",
FT_UINT16, BASE_DEC, NULL, 0,
"Foreign Device Time To Live" }
"Foreign Device Time To Live", HFILL }
},
{ &hf_bvlc_fdt_ip,
{ "IP", "bvlc.fdt_ip",
FT_IPv4, BASE_NONE, NULL, 0,
"FDT IP" }
"FDT IP", HFILL }
},
{ &hf_bvlc_fdt_port,
{ "Port", "bvlc.fdt_port",
FT_UINT16, BASE_DEC, NULL, 0,
"FDT Port" }
"FDT Port", HFILL }
},
{ &hf_bvlc_fdt_ttl,
{ "TTL", "bvlc.fdt_ttl",
FT_UINT16, BASE_DEC, NULL, 0,
"Foreign Device Time To Live" }
"Foreign Device Time To Live", HFILL }
},
{ &hf_bvlc_fdt_timeout,
{ "Timeout", "bvlc.fdt_timeout",
FT_UINT16, BASE_DEC, NULL, 0,
"Foreign Device Timeout (seconds)" }
"Foreign Device Timeout (seconds)", HFILL }
},
{ &hf_bvlc_fwd_ip,
{ "IP", "bvlc.fwd_ip",
FT_IPv4, BASE_NONE, NULL, 0,
"FWD IP" }
"FWD IP", HFILL }
},
{ &hf_bvlc_fwd_port,
{ "Port", "bvlc.fwd_port",
FT_UINT16, BASE_DEC, NULL, 0,
"FWD Port" }
"FWD Port", HFILL }
},
};

38
packet-bxxp.c
View File

@ -1,7 +1,7 @@
/* packet-bxxp.c
* Routines for BXXP packet disassembly
*
* $Id: packet-bxxp.c,v 1.18 2001/04/27 01:27:36 guy Exp $
* $Id: packet-bxxp.c,v 1.19 2001/06/18 02:17:45 guy Exp $
*
* Copyright (c) 2000 by Richard Sharpe <rsharpe@ns.aus.com>
*
@ -1150,58 +1150,58 @@ proto_register_bxxp(void)
{
static hf_register_info hf[] = {
{ &hf_bxxp_proto_viol,
{ "Protocol Violation", "bxxp.violation", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
{ "Protocol Violation", "bxxp.violation", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_req,
{ "Request", "bxxp.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
{ "Request", "bxxp.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_req_chan,
{ "Request Channel Number", "bxxp.req.channel", FT_UINT32, BASE_DEC, NULL, 0x0, ""}},
{ "Request Channel Number", "bxxp.req.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_rsp,
{ "Response", "bxxp.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
{ "Response", "bxxp.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_rsp_chan,
{ "Response Channel Number", "bxxp.rsp.channel", FT_UINT32, BASE_DEC, NULL, 0x0, ""}},
{ "Response Channel Number", "bxxp.rsp.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_seq,
{ "Sequence", "bxxp.seq", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
{ "Sequence", "bxxp.seq", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_seq_chan,
{ "Sequence Channel Number", "bxxp.seq.channel", FT_UINT32, BASE_DEC, NULL, 0x0, ""}},
{ "Sequence Channel Number", "bxxp.seq.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_end,
{ "End", "bxxp.end", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
{ "End", "bxxp.end", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_complete,
{ "Complete", "bxxp.more.complete", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
{ "Complete", "bxxp.more.complete", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_intermediate,
{ "Intermediate", "bxxp.more.intermediate", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
{ "Intermediate", "bxxp.more.intermediate", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_serial,
{ "Serial", "bxxp.serial", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
{ "Serial", "bxxp.serial", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_seqno,
{ "Seqno", "bxxp.seqno", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
{ "Seqno", "bxxp.seqno", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_size,
{ "Size", "bxxp.size", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
{ "Size", "bxxp.size", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_channel,
{ "Channel", "bxxp.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
{ "Channel", "bxxp.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_negative,
{ "Negative", "bxxp.status.negative", FT_BOOLEAN, BASE_NONE, NULL, 0x0, ""}},
{ "Negative", "bxxp.status.negative", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_positive,
{ "Positive", "bxxp.status.positive", FT_BOOLEAN, BASE_NONE, NULL, 0x0, ""}},
{ "Positive", "bxxp.status.positive", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_ackno,
{ "Ackno", "bxxp.seq.ackno", FT_UINT32, BASE_DEC, NULL, 0x0, ""}},
{ "Ackno", "bxxp.seq.ackno", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_bxxp_window,
{ "Window", "bxxp.seq.window", FT_UINT32, BASE_DEC, NULL, 0x0, ""}},
{ "Window", "bxxp.seq.window", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
};
static gint *ett[] = {

12
packet-cdp.c
View File

@ -2,7 +2,7 @@
* Routines for the disassembly of the "Cisco Discovery Protocol"
* (c) Copyright Hannes R. Boehm <hannes@boehm.org>
*
* $Id: packet-cdp.c,v 1.36 2001/03/15 09:11:00 guy Exp $
* $Id: packet-cdp.c,v 1.37 2001/06/18 02:17:45 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -539,23 +539,23 @@ proto_register_cdp(void)
static hf_register_info hf[] = {
{ &hf_cdp_version,
{ "Version", "cdp.version", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_cdp_ttl,
{ "TTL", "cdp.ttl", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_cdp_checksum,
{ "Checksum", "cdp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_cdp_tlvtype,
{ "Type", "cdp.tlv.type", FT_UINT16, BASE_HEX, VALS(type_vals), 0x0,
"" }},
"", HFILL }},
{ &hf_cdp_tlvlength,
{ "Length", "cdp.tlv.len", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
};
static gint *ett[] = {
&ett_cdp,

12
packet-cgmp.c
View File

@ -1,7 +1,7 @@
/* packet-cgmp.c
* Routines for the disassembly of the Cisco Group Management Protocol
*
* $Id: packet-cgmp.c,v 1.9 2001/01/25 06:14:13 guy Exp $
* $Id: packet-cgmp.c,v 1.10 2001/06/18 02:17:45 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -109,23 +109,23 @@ proto_register_cgmp(void)
static hf_register_info hf[] = {
{ &hf_cgmp_version,
{ "Version", "cgmp.version", FT_UINT8, BASE_DEC, NULL, 0xF0,
"" }},
"", HFILL }},
{ &hf_cgmp_type,
{ "Type", "cgmp.type", FT_UINT8, BASE_DEC, VALS(type_vals), 0x0F,
"" }},
"", HFILL }},
{ &hf_cgmp_count,
{ "Count", "cgmp.count", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_cgmp_gda,
{ "Group Destination Address", "cgmp.gda", FT_ETHER, BASE_NONE, NULL, 0x0,
"Group Destination Address" }},
"Group Destination Address", HFILL }},
{ &hf_cgmp_usa,
{ "Unicast Source Address", "cgmp.usa", FT_ETHER, BASE_NONE, NULL, 0x0,
"Unicast Source Address" }},
"Unicast Source Address", HFILL }},
};
static gint *ett[] = {
&ett_cgmp,

14
packet-chdlc.c
View File

@ -1,7 +1,7 @@
/* packet-chdlc.c
* Routines for Cisco HDLC packet disassembly
*
* $Id: packet-chdlc.c,v 1.3 2001/04/10 14:04:31 guy Exp $
* $Id: packet-chdlc.c,v 1.4 2001/06/18 02:17:45 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -168,10 +168,10 @@ proto_register_chdlc(void)
static hf_register_info hf[] = {
{ &hf_chdlc_addr,
{ "Address", "chdlc.address", FT_UINT8, BASE_HEX,
VALS(chdlc_address_vals), 0x0, "" }},
VALS(chdlc_address_vals), 0x0, "", HFILL }},
{ &hf_chdlc_proto,
{ "Protocol", "chdlc.protocol", FT_UINT16, BASE_HEX,
VALS(chdlc_vals), 0x0, "" }},
VALS(chdlc_vals), 0x0, "", HFILL }},
};
static gint *ett[] = {
&ett_chdlc,
@ -278,18 +278,18 @@ proto_register_slarp(void)
static hf_register_info hf[] = {
{ &hf_slarp_ptype,
{ "Packet type", "slarp.ptype", FT_UINT32, BASE_DEC,
VALS(slarp_ptype_vals), 0x0, "" }},
VALS(slarp_ptype_vals), 0x0, "", HFILL }},
{ &hf_slarp_address,
{ "Address", "slarp.address", FT_IPv4, BASE_NONE,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
/* XXX - need an FT_ for netmasks, which is like FT_IPV4 but doesn't
get translated to a host name. */
{ &hf_slarp_mysequence,
{ "Outgoing sequence number", "slarp.mysequence", FT_UINT32, BASE_DEC,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
{ &hf_slarp_yoursequence,
{ "Returned sequence number", "slarp.yoursequence", FT_UINT32, BASE_DEC,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
};
static gint *ett[] = {
&ett_chdlc,

38
packet-clnp.c
View File

@ -1,7 +1,7 @@
/* packet-clnp.c
* Routines for ISO/OSI network and transport protocol packet disassembly
*
* $Id: packet-clnp.c,v 1.32 2001/06/18 01:49:16 guy Exp $
* $Id: packet-clnp.c,v 1.33 2001/06/18 02:17:45 guy Exp $
* Laurent Deniel <deniel@worldnet.fr>
* Ralf Schneider <Ralf.Schneider@t-online.de>
*
@ -2062,65 +2062,65 @@ void proto_register_clnp(void)
static hf_register_info hf[] = {
{ &hf_clnp_id,
{ "Network Layer Protocol Identifier", "clnp.nlpi", FT_UINT8, BASE_HEX,
VALS(nlpid_vals), 0x0, "" }},
VALS(nlpid_vals), 0x0, "", HFILL }},
{ &hf_clnp_length,
{ "HDR Length ", "clnp.len", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "HDR Length ", "clnp.len", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_version,
{ "Version ", "clnp.version", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "Version ", "clnp.version", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_ttl,
{ "Holding Time ", "clnp.ttl", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "Holding Time ", "clnp.ttl", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_type,
{ "PDU Type ", "clnp.type", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "PDU Type ", "clnp.type", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_pdu_length,
{ "PDU length ", "clnp.pdu.len", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
{ "PDU length ", "clnp.pdu.len", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_checksum,
{ "Checksum ", "clnp.checksum", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
{ "Checksum ", "clnp.checksum", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_dest_length,
{ "DAL ", "clnp.dsap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "DAL ", "clnp.dsap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_dest,
{ " DA ", "clnp.dsap", FT_BYTES, BASE_NONE, NULL, 0x0, "" }},
{ " DA ", "clnp.dsap", FT_BYTES, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_clnp_src_length,
{ "SAL ", "clnp.ssap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "SAL ", "clnp.ssap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_clnp_src,
{ " SA ", "clnp.ssap", FT_BYTES, BASE_NONE, NULL, 0x0, "" }},
{ " SA ", "clnp.ssap", FT_BYTES, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_clnp_segment_overlap,
{ "Segment overlap", "clnp.segment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Segment overlaps with other segments" }},
"Segment overlaps with other segments", HFILL }},
{ &hf_clnp_segment_overlap_conflict,
{ "Conflicting data in segment overlap", "clnp.segment.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Overlapping segments contained conflicting data" }},
"Overlapping segments contained conflicting data", HFILL }},
{ &hf_clnp_segment_multiple_tails,
{ "Multiple tail segments found", "clnp.segment.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Several tails were found when reassembling the packet" }},
"Several tails were found when reassembling the packet", HFILL }},
{ &hf_clnp_segment_too_long_segment,
{ "Segment too long", "clnp.segment.toolongsegment", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Segment contained data past end of packet" }},
"Segment contained data past end of packet", HFILL }},
{ &hf_clnp_segment_error,
{ "Reassembly error", "clnp.segment.error", FT_NONE, BASE_DEC, NULL, 0x0,
"Reassembly error due to illegal segments" }},
"Reassembly error due to illegal segments", HFILL }},
{ &hf_clnp_segment,
{ "CLNP Segment", "clnp.segment", FT_NONE, BASE_DEC, NULL, 0x0,
"CLNP Segment" }},
"CLNP Segment", HFILL }},
{ &hf_clnp_segments,
{ "CLNP Segments", "clnp.segments", FT_NONE, BASE_DEC, NULL, 0x0,
"CLNP Segments" }},
"CLNP Segments", HFILL }},
};
static gint *ett[] = {
&ett_clnp,

68
packet-cops.c
View File

@ -4,7 +4,7 @@
*
* Copyright 2000, Heikki Vatiainen <hessu@cs.tut.fi>
*
* $Id: packet-cops.c,v 1.12 2001/04/23 18:19:03 guy Exp $
* $Id: packet-cops.c,v 1.13 2001/06/18 02:17:45 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -637,167 +637,167 @@ void proto_register_cops(void)
{ &hf_cops_ver_flags,
{ "Version and Flags", "cops.ver_flags",
FT_UINT8, BASE_HEX, NULL, 0x0,
"Version and Flags in COPS Common Header" }
"Version and Flags in COPS Common Header", HFILL }
},
{ &hf_cops_version,
{ "Version", "cops.version",
FT_UINT8, BASE_DEC, NULL, 0xF0,
"Version in COPS Common Header" }
"Version in COPS Common Header", HFILL }
},
{ &hf_cops_flags,
{ "Flags", "cops.flags",
FT_UINT8, BASE_HEX, VALS(cops_flags_vals), 0x0F,
"Flags in COPS Common Header" }
"Flags in COPS Common Header", HFILL }
},
{ &hf_cops_op_code,
{ "Op Code", "cops.op_code",
FT_UINT8, BASE_DEC, VALS(cops_op_code_vals), 0x0,
"Op Code in COPS Common Header" }
"Op Code in COPS Common Header", HFILL }
},
{ &hf_cops_client_type,
{ "Client Type", "cops.client_type",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Client Type in COPS Common Header" }
"Client Type in COPS Common Header", HFILL }
},
{ &hf_cops_msg_len,
{ "Message Length", "cops.msg_len",
FT_UINT32, BASE_DEC, NULL, 0x0,
"Message Length in COPS Common Header" }
"Message Length in COPS Common Header", HFILL }
},
{ &hf_cops_obj_len,
{ "Object Length", "cops.obj.len",
FT_UINT32, BASE_DEC, NULL, 0x0,
"Object Length in COPS Object Header" }
"Object Length in COPS Object Header", HFILL }
},
{ &hf_cops_obj_c_num,
{ "C-Num", "cops.c_num",
FT_UINT8, BASE_DEC, VALS(cops_c_num_vals), 0x0,
"C-Num in COPS Object Header" }
"C-Num in COPS Object Header", HFILL }
},
{ &hf_cops_obj_c_type,
{ "C-Type", "cops.c_type",
FT_UINT8, BASE_DEC, NULL, 0x0,
"C-Type in COPS Object Header" }
"C-Type in COPS Object Header", HFILL }
},
{ &hf_cops_r_type_flags,
{ "R-Type", "cops.context.r_type",
FT_UINT16, BASE_HEX, VALS(cops_r_type_vals), 0xFFFF,
"R-Type in COPS Context Object" }
"R-Type in COPS Context Object", HFILL }
},
{ &hf_cops_m_type_flags,
{ "M-Type", "cops.context.m_type",
FT_UINT16, BASE_HEX, NULL, 0xFFFF,
"M-Type in COPS Context Object" }
"M-Type in COPS Context Object", HFILL }
},
{ &hf_cops_in_int_ipv4,
{ "IPv4 address", "cops.in-int.ipv4",
FT_IPv4, 0, NULL, 0xFFFF,
"IPv4 address in COPS IN-Int object" }
"IPv4 address in COPS IN-Int object", HFILL }
},
{ &hf_cops_in_int_ipv6,
{ "IPv6 address", "cops.in-int.ipv6",
FT_IPv6, 0, NULL, 0xFFFF,
"IPv6 address in COPS IN-Int object" }
"IPv6 address in COPS IN-Int object", HFILL }
},
{ &hf_cops_out_int_ipv4,
{ "IPv4 address", "cops.out-int.ipv4",
FT_IPv4, 0, NULL, 0xFFFF,
"IPv4 address in COPS OUT-Int object" }
"IPv4 address in COPS OUT-Int object", HFILL }
},
{ &hf_cops_out_int_ipv6,
{ "IPv6 address", "cops.out-int.ipv6",
FT_IPv6, 0, NULL, 0xFFFF,
"IPv6 address in COPS OUT-Int" }
"IPv6 address in COPS OUT-Int", HFILL }
},
{ &hf_cops_int_ifindex,
{ "ifIndex", "cops.in-out-int.ifindex",
FT_UINT32, BASE_DEC, NULL, 0x0,
"If SNMP is supported, corresponds to MIB-II ifIndex" }
"If SNMP is supported, corresponds to MIB-II ifIndex", HFILL }
},
{ &hf_cops_reason,
{ "Reason", "cops.reason",
FT_UINT16, BASE_DEC, VALS(cops_reason_vals), 0,
"Reason in Reason object" }
"Reason in Reason object", HFILL }
},
{ &hf_cops_reason_sub,
{ "Reason Sub-code", "cops.reason_sub",
FT_UINT16, BASE_HEX, NULL, 0,
"Reason Sub-code in Reason object" }
"Reason Sub-code in Reason object", HFILL }
},
{ &hf_cops_dec_cmd_code,
{ "Command-Code", "cops.decision.cmd",
FT_UINT16, BASE_DEC, VALS(cops_dec_cmd_code_vals), 0,
"Command-Code in Decision/LPDP Decision object" }
"Command-Code in Decision/LPDP Decision object", HFILL }
},
{ &hf_cops_dec_flags,
{ "Flags", "cops.decision.flags",
FT_UINT16, BASE_HEX, VALS(cops_dec_cmd_flag_vals), 0xffff,
"Flags in Decision/LPDP Decision object" }
"Flags in Decision/LPDP Decision object", HFILL }
},
{ &hf_cops_error,
{ "Error", "cops.error",
FT_UINT16, BASE_DEC, VALS(cops_error_vals), 0,
"Error in Error object" }
"Error in Error object", HFILL }
},
{ &hf_cops_error_sub,
{ "Error Sub-code", "cops.error_sub",
FT_UINT16, BASE_HEX, NULL, 0,
"Error Sub-code in Error object" }
"Error Sub-code in Error object", HFILL }
},
{ &hf_cops_katimer,
{ "Contents: KA Timer Value", "cops.katimer.value",
FT_UINT16, BASE_DEC, NULL, 0,
"Keep-Alive Timer Value in KATimer object" }
"Keep-Alive Timer Value in KATimer object", HFILL }
},
{ &hf_cops_pepid,
{ "Contents: PEP Id", "cops.pepid.id",
FT_STRING, BASE_NONE, NULL, 0,
"PEP Id in PEPID object" }
"PEP Id in PEPID object", HFILL }
},
{ &hf_cops_report_type,
{ "Contents: Report-Type", "cops.report_type",
FT_UINT16, BASE_DEC, VALS(cops_report_type_vals), 0,
"Report-Type in Report-Type object" }
"Report-Type in Report-Type object", HFILL }
},
{ &hf_cops_pdprediraddr_ipv4,
{ "IPv4 address", "cops.pdprediraddr.ipv4",
FT_IPv4, 0, NULL, 0xFFFF,
"IPv4 address in COPS PDPRedirAddr object" }
"IPv4 address in COPS PDPRedirAddr object", HFILL }
},
{ &hf_cops_pdprediraddr_ipv6,
{ "IPv6 address", "cops.pdprediraddr.ipv6",
FT_IPv6, 0, NULL, 0xFFFF,
"IPv6 address in COPS PDPRedirAddr object" }
"IPv6 address in COPS PDPRedirAddr object", HFILL }
},
{ &hf_cops_lastpdpaddr_ipv4,
{ "IPv4 address", "cops.lastpdpaddr.ipv4",
FT_IPv4, 0, NULL, 0xFFFF,
"IPv4 address in COPS LastPDPAddr object" }
"IPv4 address in COPS LastPDPAddr object", HFILL }
},
{ &hf_cops_lastpdpaddr_ipv6,
{ "IPv6 address", "cops.lastpdpaddr.ipv6",
FT_IPv6, 0, NULL, 0xFFFF,
"IPv6 address in COPS LastPDPAddr object" }
"IPv6 address in COPS LastPDPAddr object", HFILL }
},
{ &hf_cops_pdp_tcp_port,
{ "TCP Port Number", "cops.pdp.tcp_port",
FT_UINT32, BASE_DEC, NULL, 0x0,
"TCP Port Number of PDP in PDPRedirAddr/LastPDPAddr object" }
"TCP Port Number of PDP in PDPRedirAddr/LastPDPAddr object", HFILL }
},
{ &hf_cops_accttimer,
{ "Contents: ACCT Timer Value", "cops.accttimer.value",
FT_UINT16, BASE_DEC, NULL, 0,
"Accounting Timer Value in AcctTimer object" }
"Accounting Timer Value in AcctTimer object", HFILL }
},
{ &hf_cops_key_id,
{ "Contents: Key ID", "cops.integrity.key_id",
FT_UINT32, BASE_DEC, NULL, 0,
"Key ID in Integrity object" }
"Key ID in Integrity object", HFILL }
},
{ &hf_cops_seq_num,
{ "Contents: Sequence Number", "cops.integrity.seq_num",
FT_UINT32, BASE_DEC, NULL, 0,
"Sequence Number in Integrity object" }
"Sequence Number in Integrity object", HFILL }
},
};

6
packet-cups.c
View File

@ -5,7 +5,7 @@
* Charles Levert <charles@comm.polymtl.ca>
* Copyright 2001 Charles Levert
*
* $Id: packet-cups.c,v 1.4 2001/03/15 07:03:13 guy Exp $
* $Id: packet-cups.c,v 1.5 2001/06/18 02:17:45 guy Exp $
*
*
* This program is free software; you can redistribute it and/or
@ -353,11 +353,11 @@ proto_register_cups(void)
/* This one could be split in separate fields. */
{ &hf_cups_ptype,
{ "Type", "cups.ptype", FT_UINT32, BASE_HEX,
NULL, 0x0, ""}},
NULL, 0x0, "", HFILL }},
{ &hf_cups_state,
{ "State", "cups.state", FT_UINT8, BASE_HEX,
VALS(cups_state_values), 0x0, "" }}
VALS(cups_state_values), 0x0, "", HFILL }}
};
static gint *ett[] = {

126
packet-dcerpc.c
View File

@ -2,7 +2,7 @@
* Routines for DCERPC packet disassembly
* Copyright 2001, Todd Sabin <tas@webspan.net>
*
* $Id: packet-dcerpc.c,v 1.4 2001/04/27 01:27:36 guy Exp $
* $Id: packet-dcerpc.c,v 1.5 2001/06/18 02:17:45 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -735,129 +735,129 @@ proto_register_dcerpc(void)
{
static hf_register_info hf[] = {
{ &hf_dcerpc_ver,
{ "Version", "dcerpc.ver", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "Version", "dcerpc.ver", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_ver_minor,
{ "Version (minor)", "dcerpc.ver_minor", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "Version (minor)", "dcerpc.ver_minor", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_packet_type,
{ "Packet type", "dcerpc.pkt_type", FT_UINT8, BASE_HEX, VALS (pckt_vals), 0x0, "" }},
{ "Packet type", "dcerpc.pkt_type", FT_UINT8, BASE_HEX, VALS (pckt_vals), 0x0, "", HFILL }},
{ &hf_dcerpc_cn_flags,
{ "Packet Flags", "dcerpc.cn_flags", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
{ "Packet Flags", "dcerpc.cn_flags", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_flags_first_frag,
{ "First Frag", "dcerpc.cn_flags.first_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x1, "" }},
{ "First Frag", "dcerpc.cn_flags.first_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x1, "", HFILL }},
{ &hf_dcerpc_cn_flags_last_frag,
{ "Last Frag", "dcerpc.cn_flags.last_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x2, "" }},
{ "Last Frag", "dcerpc.cn_flags.last_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x2, "", HFILL }},
{ &hf_dcerpc_cn_flags_cancel_pending,
{ "Cancel Pending", "dcerpc.cn_flags.cancel_pending", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x4, "" }},
{ "Cancel Pending", "dcerpc.cn_flags.cancel_pending", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x4, "", HFILL }},
{ &hf_dcerpc_cn_flags_reserved,
{ "Reserved", "dcerpc.cn_flags.reserved", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x8, "" }},
{ "Reserved", "dcerpc.cn_flags.reserved", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x8, "", HFILL }},
{ &hf_dcerpc_cn_flags_mpx,
{ "Multiplex", "dcerpc.cn_flags.mpx", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x10, "" }},
{ "Multiplex", "dcerpc.cn_flags.mpx", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x10, "", HFILL }},
{ &hf_dcerpc_cn_flags_dne,
{ "Did Not Execute", "dcerpc.cn_flags.dne", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x20, "" }},
{ "Did Not Execute", "dcerpc.cn_flags.dne", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x20, "", HFILL }},
{ &hf_dcerpc_cn_flags_maybe,
{ "Maybe", "dcerpc.cn_flags.maybe", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x40, "" }},
{ "Maybe", "dcerpc.cn_flags.maybe", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x40, "", HFILL }},
{ &hf_dcerpc_cn_flags_object,
{ "Object", "dcerpc.cn_flags.object", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x80, "" }},
{ "Object", "dcerpc.cn_flags.object", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x80, "", HFILL }},
{ &hf_dcerpc_cn_frag_len,
{ "Frag Length", "dcerpc.cn_frag_len", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
{ "Frag Length", "dcerpc.cn_frag_len", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_auth_len,
{ "Auth Length", "dcerpc.cn_auth_len", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
{ "Auth Length", "dcerpc.cn_auth_len", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_call_id,
{ "Call ID", "dcerpc.cn_call_id", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
{ "Call ID", "dcerpc.cn_call_id", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_max_xmit,
{ "Max Xmit Frag", "dcerpc.cn_max_xmit", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
{ "Max Xmit Frag", "dcerpc.cn_max_xmit", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_max_recv,
{ "Max Recv Frag", "dcerpc.cn_max_recv", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
{ "Max Recv Frag", "dcerpc.cn_max_recv", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_assoc_group,
{ "Assoc Group", "dcerpc.cn_assoc_group", FT_UINT32, BASE_HEX, NULL, 0x0, "" }},
{ "Assoc Group", "dcerpc.cn_assoc_group", FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_num_ctx_items,
{ "Num Ctx Items", "dcerpc.cn_num_ctx_items", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "Num Ctx Items", "dcerpc.cn_num_ctx_items", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_ctx_id,
{ "Context ID", "dcerpc.cn_ctx_id", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
{ "Context ID", "dcerpc.cn_ctx_id", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_num_trans_items,
{ "Num Trans Items", "dcerpc.cn_num_trans_items", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
{ "Num Trans Items", "dcerpc.cn_num_trans_items", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_bind_if_id,
{ "Interface UUID", "dcerpc.cn_bind_to_uuid", FT_STRING, BASE_NONE, NULL, 0x0, "" }},
{ "Interface UUID", "dcerpc.cn_bind_to_uuid", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_bind_if_ver,
{ "Interface Ver", "dcerpc.cn_bind_if_ver", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
{ "Interface Ver", "dcerpc.cn_bind_if_ver", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_bind_trans_id,
{ "Transfer Syntax", "dcerpc.cn_bind_trans_id", FT_STRING, BASE_NONE, NULL, 0x0, "" }},
{ "Transfer Syntax", "dcerpc.cn_bind_trans_id", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_bind_trans_ver,
{ "Syntax ver", "dcerpc.cn_bind_trans_ver", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
{ "Syntax ver", "dcerpc.cn_bind_trans_ver", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_alloc_hint,
{ "Alloc hint", "dcerpc.cn_alloc_hint", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
{ "Alloc hint", "dcerpc.cn_alloc_hint", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_sec_addr_len,
{ "Scndry Addr len", "dcerpc.cn_sec_addr_len", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
{ "Scndry Addr len", "dcerpc.cn_sec_addr_len", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_num_results,
{ "Num results", "dcerpc.cn_num_results", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "Num results", "dcerpc.cn_num_results", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_ack_result,
{ "Ack result", "dcerpc.cn_ack_result", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
{ "Ack result", "dcerpc.cn_ack_result", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_cn_ack_reason,
{ "Ack reason", "dcerpc.cn_ack_reason", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
{ "Ack reason", "dcerpc.cn_ack_reason", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_flags1,
{ "Flags1", "dcerpc.dg_flags1", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
{ "Flags1", "dcerpc.dg_flags1", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_flags1_rsrvd_01,
{ "Reserved", "dcerpc.dg_flags1_rsrvd_01", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x01, "" }},
{ "Reserved", "dcerpc.dg_flags1_rsrvd_01", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x01, "", HFILL }},
{ &hf_dcerpc_dg_flags1_last_frag,
{ "Last Fragment", "dcerpc.dg_flags1_last_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x02, "" }},
{ "Last Fragment", "dcerpc.dg_flags1_last_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x02, "", HFILL }},
{ &hf_dcerpc_dg_flags1_frag,
{ "Fragment", "dcerpc.dg_flags1_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x04, "" }},
{ "Fragment", "dcerpc.dg_flags1_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x04, "", HFILL }},
{ &hf_dcerpc_dg_flags1_nofack,
{ "No Fack", "dcerpc.dg_flags1_nofack", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x08, "" }},
{ "No Fack", "dcerpc.dg_flags1_nofack", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x08, "", HFILL }},
{ &hf_dcerpc_dg_flags1_maybe,
{ "Maybe", "dcerpc.dg_flags1_maybe", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x10, "" }},
{ "Maybe", "dcerpc.dg_flags1_maybe", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x10, "", HFILL }},
{ &hf_dcerpc_dg_flags1_idempotent,
{ "Idempotent", "dcerpc.dg_flags1_idempotent", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x20, "" }},
{ "Idempotent", "dcerpc.dg_flags1_idempotent", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x20, "", HFILL }},
{ &hf_dcerpc_dg_flags1_broadcast,
{ "Broadcast", "dcerpc.dg_flags1_broadcast", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x40, "" }},
{ "Broadcast", "dcerpc.dg_flags1_broadcast", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x40, "", HFILL }},
{ &hf_dcerpc_dg_flags1_rsrvd_80,
{ "Reserved", "dcerpc.dg_flags1_rsrvd_80", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x80, "" }},
{ "Reserved", "dcerpc.dg_flags1_rsrvd_80", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x80, "", HFILL }},
{ &hf_dcerpc_dg_flags2,
{ "Flags2", "dcerpc.dg_flags2", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
{ "Flags2", "dcerpc.dg_flags2", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_flags2_rsrvd_01,
{ "Reserved", "dcerpc.dg_flags2_rsrvd_01", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x01, "" }},
{ "Reserved", "dcerpc.dg_flags2_rsrvd_01", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x01, "", HFILL }},
{ &hf_dcerpc_dg_flags2_cancel_pending,
{ "Cancel Pending", "dcerpc.dg_flags2_cancel_pending", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x02, "" }},
{ "Cancel Pending", "dcerpc.dg_flags2_cancel_pending", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x02, "", HFILL }},
{ &hf_dcerpc_dg_flags2_rsrvd_04,
{ "Reserved", "dcerpc.dg_flags2_rsrvd_04", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x04, "" }},
{ "Reserved", "dcerpc.dg_flags2_rsrvd_04", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x04, "", HFILL }},
{ &hf_dcerpc_dg_flags2_rsrvd_08,
{ "Reserved", "dcerpc.dg_flags2_rsrvd_08", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x08, "" }},
{ "Reserved", "dcerpc.dg_flags2_rsrvd_08", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x08, "", HFILL }},
{ &hf_dcerpc_dg_flags2_rsrvd_10,
{ "Reserved", "dcerpc.dg_flags2_rsrvd_10", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x10, "" }},
{ "Reserved", "dcerpc.dg_flags2_rsrvd_10", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x10, "", HFILL }},
{ &hf_dcerpc_dg_flags2_rsrvd_20,
{ "Reserved", "dcerpc.dg_flags2_rsrvd_20", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x20, "" }},
{ "Reserved", "dcerpc.dg_flags2_rsrvd_20", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x20, "", HFILL }},
{ &hf_dcerpc_dg_flags2_rsrvd_40,
{ "Reserved", "dcerpc.dg_flags2_rsrvd_40", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x40, "" }},
{ "Reserved", "dcerpc.dg_flags2_rsrvd_40", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x40, "", HFILL }},
{ &hf_dcerpc_dg_flags2_rsrvd_80,
{ "Reserved", "dcerpc.dg_flags2_rsrvd_80", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x80, "" }},
{ "Reserved", "dcerpc.dg_flags2_rsrvd_80", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x80, "", HFILL }},
{ &hf_dcerpc_dg_serial_lo,
{ "Serial Low", "dcerpc.dg_serial_lo", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
{ "Serial Low", "dcerpc.dg_serial_lo", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_serial_hi,
{ "Serial High", "dcerpc.dg_serial_hi", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
{ "Serial High", "dcerpc.dg_serial_hi", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_ahint,
{ "Activity Hint", "dcerpc.dg_ahint", FT_UINT16, BASE_HEX, NULL, 0x0, "" }},
{ "Activity Hint", "dcerpc.dg_ahint", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_ihint,
{ "Interface Hint", "dcerpc.dg_ihint", FT_UINT16, BASE_HEX, NULL, 0x0, "" }},
{ "Interface Hint", "dcerpc.dg_ihint", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_frag_len,
{ "Fragment len", "dcerpc.dg_frag_len", FT_UINT16, BASE_HEX, NULL, 0x0, "" }},
{ "Fragment len", "dcerpc.dg_frag_len", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_frag_num,
{ "Fragment num", "dcerpc.dg_frag_num", FT_UINT16, BASE_HEX, NULL, 0x0, "" }},
{ "Fragment num", "dcerpc.dg_frag_num", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_auth_proto,
{ "Auth proto", "dcerpc.dg_auth_proto", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
{ "Auth proto", "dcerpc.dg_auth_proto", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_seqnum,
{ "Sequence num", "dcerpc.dg_seqnum", FT_UINT32, BASE_HEX, NULL, 0x0, "" }},
{ "Sequence num", "dcerpc.dg_seqnum", FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_server_boot,
{ "Server boot time", "dcerpc.dg_server_boot", FT_UINT32, BASE_HEX, NULL, 0x0, "" }},
{ "Server boot time", "dcerpc.dg_server_boot", FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_if_ver,
{ "Interface Ver", "dcerpc.dg_if_ver", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
{ "Interface Ver", "dcerpc.dg_if_ver", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_obj_id,
{ "Object", "dcerpc.obj_id", FT_STRING, BASE_NONE, NULL, 0x0, "" }},
{ "Object", "dcerpc.obj_id", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_if_id,
{ "Interface", "dcerpc.dg_if_id", FT_STRING, BASE_NONE, NULL, 0x0, "" }},
{ "Interface", "dcerpc.dg_if_id", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_dg_act_id,
{ "Activitiy", "dcerpc.dg_act_id", FT_STRING, BASE_NONE, NULL, 0x0, "" }},
{ "Activitiy", "dcerpc.dg_act_id", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_dcerpc_opnum,
{ "Opnum", "dcerpc.opnum", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
{ "Opnum", "dcerpc.opnum", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
};

16
packet-ddtp.c
View File

@ -3,7 +3,7 @@
* see http://ddt.sourceforge.net/
* Olivier Abad <oabad@cybercable.fr>
*
* $Id: packet-ddtp.c,v 1.15 2001/01/22 08:03:45 guy Exp $
* $Id: packet-ddtp.c,v 1.16 2001/06/18 02:17:45 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -181,25 +181,25 @@ proto_register_ddtp(void)
static hf_register_info hf_ddtp[] = {
{ &hf_ddtp_version,
{ "Version", "ddtp.version", FT_UINT32, BASE_DEC, VALS(vals_ddtp_version), 0x0,
"Version" } },
"Version", HFILL }},
{ &hf_ddtp_encrypt,
{ "Encryption", "ddtp.encrypt", FT_UINT32, BASE_DEC, VALS(vals_ddtp_encrypt), 0x0,
"Encryption type" } },
"Encryption type", HFILL }},
{ &hf_ddtp_hostid,
{ "Hostid", "ddtp.hostid", FT_UINT32, BASE_DEC, NULL, 0x0,
"Host ID" } },
"Host ID", HFILL }},
{ &hf_ddtp_msgtype,
{ "Message type", "ddtp.msgtype", FT_UINT32, BASE_DEC, VALS(vals_ddtp_msgtype), 0x0,
"Message Type" } },
"Message Type", HFILL }},
{ &hf_ddtp_opcode,
{ "Opcode", "ddtp.opcode", FT_UINT32, BASE_DEC, VALS(vals_ddtp_opcode), 0x0,
"Update query opcode" } },
"Update query opcode", HFILL }},
{ &hf_ddtp_ipaddr,
{ "IP address", "ddtp.ipaddr", FT_IPv4, BASE_NONE, NULL, 0x0,
"IP address" } },
"IP address", HFILL }},
{ &hf_ddtp_status,
{ "Status", "ddtp.status", FT_UINT32, BASE_DEC, VALS(vals_ddtp_status), 0x0,
"Update reply status" } }
"Update reply status", HFILL }}
};
static gint *ett[] = { &ett_ddtp };

46
packet-diameter.c
View File

@ -1,7 +1,7 @@
/* packet-diameter.c
* Routines for DIAMETER packet disassembly
*
* $Id: packet-diameter.c,v 1.22 2001/05/27 21:38:46 guy Exp $
* $Id: packet-diameter.c,v 1.23 2001/06/18 02:17:45 guy Exp $
*
* Copyright (c) 2001 by David Frascone <dave@frascone.com>
*
@ -778,76 +778,76 @@ proto_register_diameter(void)
static hf_register_info hf[] = {
{ &hf_diameter_reserved,
{ "Reserved", "diameter.reserved", FT_UINT8, BASE_HEX, NULL, 0x0,
"Should be zero" }},
"Should be zero", HFILL }},
{ &hf_diameter_flags,
{ "Flags", "diameter.flags", FT_UINT8, BASE_HEX, NULL, 0xf8,
"" }},
"", HFILL }},
{ &hf_diameter_version,
{ "Version", "diameter.version", FT_UINT8, BASE_HEX, NULL, 0x07,
"" }},
"", HFILL }},
{ &hf_diameter_length,
{ "Length","diameter.length", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_diameter_hopbyhopid,
{ "Hop-by-Hop Identifier", "diameter.hopbyhopid", FT_UINT32,
BASE_HEX, NULL, 0x0, "" }},
BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_diameter_endtoendid,
{ "End-to-End Identifier", "diameter.endtoendid", FT_UINT32,
BASE_HEX, NULL, 0x0, "" }},
BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_diameter_code,
{ "Command Code","diameter.code", FT_UINT32, BASE_DEC,
VALS(diameter_command_code_vals), 0x0, "" }},
VALS(diameter_command_code_vals), 0x0, "", HFILL }},
{ &hf_diameter_vendor_id,
{ "VendorId", "diameter.vendorId", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_diameter_avp_code,
{ "AVP Code","diameter.avp.code", FT_UINT32, BASE_DEC,
VALS(diameter_attrib_type_vals), 0x0, "" }},
VALS(diameter_attrib_type_vals), 0x0, "", HFILL }},
{ &hf_diameter_avp_length,
{ "AVP length","diameter.avp.length", FT_UINT16, BASE_DEC,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
{ &hf_diameter_avp_reserved,
{ "AVP Reserved","diameter.avp.reserved", FT_UINT8, BASE_HEX,
NULL, 0x0, "Should be Zero" }},
NULL, 0x0, "Should be Zero", HFILL }},
{ &hf_diameter_avp_flags,
{ "AVP Flags","diameter.avp.flags", FT_UINT8, BASE_HEX,
NULL, 0x1f, "" }},
NULL, 0x1f, "", HFILL }},
{ &hf_diameter_avp_vendor_id,
{ "AVP Vendor Id","diameter.avp.vendorId", FT_UINT32, BASE_DEC,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
{ &hf_diameter_avp_data_uint32,
{ "AVP Data","diameter.avp.data.uint32", FT_UINT32, BASE_DEC,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
#if 0
{ &hf_diameter_avp_data_uint64,
{ "AVP Data","diameter.avp.data.uint64", FT_UINT64, BASE_DEC,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
#endif
{ &hf_diameter_avp_data_int32,
{ "AVP Data","diameter.avp.data.int32", FT_INT32, BASE_DEC,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
#if 0
{ &hf_diameter_avp_data_int64,
{ "AVP Data","diameter.avp.data.int64", FT_INT_64, BASE_DEC,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
#endif
{ &hf_diameter_avp_data_bytes,
{ "AVP Data","diameter.avp.data.bytes", FT_BYTES, BASE_NONE,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
{ &hf_diameter_avp_data_string,
{ "AVP Data","diameter.avp.data.string", FT_STRING, BASE_NONE,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
{ &hf_diameter_avp_data_v4addr,
{ "AVP Data","diameter.avp.data.v4addr", FT_IPv4, BASE_NONE,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
{ &hf_diameter_avp_data_v6addr,
{ "AVP Data","diameter.avp.data.v6addr", FT_IPv6, BASE_NONE,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
{ &hf_diameter_avp_data_time,
{ "AVP Data","diameter.avp.data.time", FT_ABSOLUTE_TIME, BASE_NONE,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
};
static gint *ett[] = {

18
packet-dns.c
View File

@ -1,7 +1,7 @@
/* packet-dns.c
* Routines for DNS packet disassembly
*
* $Id: packet-dns.c,v 1.67 2001/06/18 01:49:16 guy Exp $
* $Id: packet-dns.c,v 1.68 2001/06/18 02:17:45 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -2493,35 +2493,35 @@ proto_register_dns(void)
{ &hf_dns_response,
{ "Response", "dns.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if DNS response" }},
"TRUE if DNS response", HFILL }},
{ &hf_dns_query,
{ "Query", "dns.query",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if DNS query" }},
"TRUE if DNS query", HFILL }},
{ &hf_dns_flags,
{ "Flags", "dns.flags",
FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_dns_transaction_id,
{ "Transaction ID", "dns.id",
FT_UINT16, BASE_HEX, NULL, 0x0,
"Identification of transaction" }},
"Identification of transaction", HFILL }},
{ &hf_dns_count_questions,
{ "Questions", "dns.count.queries",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Number of queries in packet" }},
"Number of queries in packet", HFILL }},
{ &hf_dns_count_answers,
{ "Answer RRs", "dns.count.answers",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Number of answers in packet" }},
"Number of answers in packet", HFILL }},
{ &hf_dns_count_auth_rr,
{ "Authority RRs", "dns.count.auth_rr",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Number of authoritative records in packet" }},
"Number of authoritative records in packet", HFILL }},
{ &hf_dns_count_add_rr,
{ "Additional RRs", "dns.count.add_rr",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Number of additional records in packet" }}
"Number of additional records in packet", HFILL }}
};
static gint *ett[] = {
&ett_dns,

14
packet-dsi.c
View File

@ -2,7 +2,7 @@
* Routines for dsi packet dissection
* Copyright 2001, Randy McEoin <rmceoin@pe.com>
*
* $Id: packet-dsi.c,v 1.1 2001/05/24 20:25:24 guy Exp $
* $Id: packet-dsi.c,v 1.2 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -443,32 +443,32 @@ proto_register_dsi(void)
{ &hf_dsi_flags,
{ "Flags", "dsi.flags",
FT_UINT8, BASE_HEX, VALS(flag_vals), 0x0,
"Indicates request or reply." }},
"Indicates request or reply.", HFILL }},
{ &hf_dsi_command,
{ "Command", "dsi.command",
FT_UINT8, BASE_DEC, VALS(func_vals), 0x0,
"Represents a DSI command." }},
"Represents a DSI command.", HFILL }},
{ &hf_dsi_requestid,
{ "Request ID", "dsi.requestid",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Keeps track of which request this is. Replies must match a Request. IDs must be generated in sequential order." }},
"Keeps track of which request this is. Replies must match a Request. IDs must be generated in sequential order.", HFILL }},
{ &hf_dsi_code,
{ "Code", "dsi.code",
FT_UINT32, BASE_HEX, NULL, 0x0,
"In Reply packets this is an error code. In Request Write packets this is a data offset." }},
"In Reply packets this is an error code. In Request Write packets this is a data offset.", HFILL }},
{ &hf_dsi_length,
{ "Length", "dsi.length",
FT_UINT32, BASE_DEC, NULL, 0x0,
"Total length of the data that follows the DSI header." }},
"Total length of the data that follows the DSI header.", HFILL }},
{ &hf_dsi_reserved,
{ "Reserved", "dsi.reserved",
FT_UINT32, BASE_HEX, NULL, 0x0,
"Reserved for future use. Should be set to zero." }},
"Reserved for future use. Should be set to zero.", HFILL }},
};
static gint *ett[] = {

68
packet-dvmrp.c
View File

@ -1,7 +1,7 @@
/* packet-dvmrp.c 2001 Ronnie Sahlberg <rsahlber@bigpond.net.au>
* Routines for IGMP/DVMRP packet disassembly
*
* $Id: packet-dvmrp.c,v 1.1 2001/06/12 06:21:55 guy Exp $
* $Id: packet-dvmrp.c,v 1.2 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -684,135 +684,135 @@ proto_register_dvmrp(void)
static hf_register_info hf[] = {
{ &hf_version,
{ "DVMRP Version", "dvmrp.version", FT_UINT8, BASE_DEC,
NULL, 0, "DVMRP Version" }},
NULL, 0, "DVMRP Version", HFILL }},
{ &hf_type,
{ "Type", "dvmrp.type", FT_UINT8, BASE_HEX,
VALS(dvmrp_type), 0, "DVMRP Packet Type" }},
VALS(dvmrp_type), 0, "DVMRP Packet Type", HFILL }},
{ &hf_code_v1,
{ "Code", "dvmrp.v1.code", FT_UINT8, BASE_HEX,
VALS(code_v1), 0, "DVMRP Packet Code" }},
VALS(code_v1), 0, "DVMRP Packet Code", HFILL }},
{ &hf_checksum,
{ "Checksum", "dvmrp.checksum", FT_UINT16, BASE_HEX,
NULL, 0, "DVMRP Checksum" }},
NULL, 0, "DVMRP Checksum", HFILL }},
{ &hf_checksum_bad,
{ "Bad Checksum", "dvmrp.checksum_bad", FT_BOOLEAN, BASE_NONE,
NULL, 0, "Bad DVMRP Checksum" }},
NULL, 0, "Bad DVMRP Checksum", HFILL }},
{ &hf_commands,
{ "Commands", "dvmrp.commands", FT_NONE, BASE_NONE,
NULL, 0, "DVMRP V1 Commands" }},
NULL, 0, "DVMRP V1 Commands", HFILL }},
{ &hf_command,
{ "Command", "dvmrp.command", FT_UINT8, BASE_HEX,
VALS(command), 0, "DVMRP V1 Command" }},
VALS(command), 0, "DVMRP V1 Command", HFILL }},
{ &hf_afi,
{ "Address Family", "dvmrp.afi", FT_UINT8, BASE_HEX,
VALS(afi), 0, "DVMRP Address Family Indicator" }},
VALS(afi), 0, "DVMRP Address Family Indicator", HFILL }},
{ &hf_count,
{ "Count", "dvmrp.count", FT_UINT8, BASE_HEX,
NULL, 0, "Count" }},
NULL, 0, "Count", HFILL }},
{ &hf_netmask,
{ "Netmask", "igmp.netmask", FT_IPv4, BASE_NONE,
NULL, 0, "DVMRP Netmask" }},
NULL, 0, "DVMRP Netmask", HFILL }},
{ &hf_metric,
{ "Metric", "dvmrp.metric", FT_UINT8, BASE_DEC,
NULL, 0, "DVMRP Metric" }},
NULL, 0, "DVMRP Metric", HFILL }},
{&hf_dest_unr,
{ "Destination Unreachable", "dvmrp.dest_unreach", FT_BOOLEAN, 8,
TFS(&tfs_dest_unreach), 0x01, "Destination Unreachable" }},
TFS(&tfs_dest_unreach), 0x01, "Destination Unreachable", HFILL }},
{&hf_split_horiz,
{ "Split Horizon", "dvmrp.split_horiz", FT_BOOLEAN, 8,
TFS(&tfs_split_horiz), 0x02, "Split Horizon concealed route" }},
TFS(&tfs_split_horiz), 0x02, "Split Horizon concealed route", HFILL }},
{ &hf_infinity,
{ "Infinity", "dvmrp.infinity", FT_UINT8, BASE_DEC,
NULL, 0, "DVMRP Infinity" }},
NULL, 0, "DVMRP Infinity", HFILL }},
{ &hf_daddr,
{ "Dest Addr", "igmp.daddr", FT_IPv4, BASE_NONE,
NULL, 0, "DVMRP Destination Address" }},
NULL, 0, "DVMRP Destination Address", HFILL }},
{ &hf_maddr,
{ "Multicast Addr", "igmp.maddr", FT_IPv4, BASE_NONE,
NULL, 0, "DVMRP Multicast Address" }},
NULL, 0, "DVMRP Multicast Address", HFILL }},
{ &hf_hold,
{ "Hold Time", "dvmrp.hold", FT_UINT32, BASE_DEC,
NULL, 0, "DVMRP Hold Time in seconds" }},
NULL, 0, "DVMRP Hold Time in seconds", HFILL }},
{ &hf_code_v3,
{ "Code", "dvmrp.v3.code", FT_UINT8, BASE_HEX,
VALS(code_v3), 0, "DVMRP Packet Code" }},
VALS(code_v3), 0, "DVMRP Packet Code", HFILL }},
{ &hf_capabilities,
{ "Capabilities", "dvmrp.capabilities", FT_NONE, BASE_NONE,
NULL, 0, "DVMRP V3 Capabilities" }},
NULL, 0, "DVMRP V3 Capabilities", HFILL }},
{&hf_cap_leaf,
{ "Leaf", "dvmrp.cap.leaf", FT_BOOLEAN, 8,
TFS(&tfs_cap_leaf), DVMRP_V3_CAP_LEAF, "Leaf" }},
TFS(&tfs_cap_leaf), DVMRP_V3_CAP_LEAF, "Leaf", HFILL }},
{&hf_cap_prune,
{ "Prune", "dvmrp.cap.prune", FT_BOOLEAN, 8,
TFS(&tfs_cap_prune), DVMRP_V3_CAP_PRUNE, "Prune capability" }},
TFS(&tfs_cap_prune), DVMRP_V3_CAP_PRUNE, "Prune capability", HFILL }},
{&hf_cap_genid,
{ "Genid", "dvmrp.cap.genid", FT_BOOLEAN, 8,
TFS(&tfs_cap_genid), DVMRP_V3_CAP_GENID, "Genid capability" }},
TFS(&tfs_cap_genid), DVMRP_V3_CAP_GENID, "Genid capability", HFILL }},
{&hf_cap_mtrace,
{ "Mtrace", "dvmrp.cap.mtrace", FT_BOOLEAN, 8,
TFS(&tfs_cap_mtrace), DVMRP_V3_CAP_MTRACE, "Mtrace capability" }},
TFS(&tfs_cap_mtrace), DVMRP_V3_CAP_MTRACE, "Mtrace capability", HFILL }},
{&hf_cap_snmp,
{ "SNMP", "dvmrp.cap.snmp", FT_BOOLEAN, 8,
TFS(&tfs_cap_snmp), DVMRP_V3_CAP_SNMP, "SNMP capability" }},
TFS(&tfs_cap_snmp), DVMRP_V3_CAP_SNMP, "SNMP capability", HFILL }},
{&hf_cap_netmask,
{ "Netmask", "dvmrp.cap.netmask", FT_BOOLEAN, 8,
TFS(&tfs_cap_netmask), DVMRP_V3_CAP_NETMASK, "Netmask capability" }},
TFS(&tfs_cap_netmask), DVMRP_V3_CAP_NETMASK, "Netmask capability", HFILL }},
{ &hf_min_ver,
{ "Minor Version", "dvmrp.min_ver", FT_UINT8, BASE_HEX,
NULL, 0, "DVMRP Minor Version" }},
NULL, 0, "DVMRP Minor Version", HFILL }},
{ &hf_maj_ver,
{ "Major Version", "dvmrp.maj_ver", FT_UINT8, BASE_HEX,
NULL, 0, "DVMRP Major Version" }},
NULL, 0, "DVMRP Major Version", HFILL }},
{ &hf_genid,
{ "Generation ID", "dvmrp.genid", FT_UINT32, BASE_DEC,
NULL, 0, "DVMRP Generation ID" }},
NULL, 0, "DVMRP Generation ID", HFILL }},
{ &hf_naddr,
{ "Neighbor Addr", "igmp.naddr", FT_IPv4, BASE_NONE,
NULL, 0, "DVMRP Neighbor Address" }},
NULL, 0, "DVMRP Neighbor Address", HFILL }},
{ &hf_route,
{ "Route", "dvmrp.route", FT_NONE, BASE_NONE,
NULL, 0, "DVMRP V3 Route Report" }},
NULL, 0, "DVMRP V3 Route Report", HFILL }},
{ &hf_saddr,
{ "Source Addr", "igmp.saddr", FT_IPv4, BASE_NONE,
NULL, 0, "DVMRP Source Address" }},
NULL, 0, "DVMRP Source Address", HFILL }},
{ &hf_life,
{ "Prune lifetime", "dvmrp.lifetime", FT_UINT32, BASE_DEC,
NULL, 0, "DVMRP Prune Lifetime" }},
NULL, 0, "DVMRP Prune Lifetime", HFILL }},
{ &hf_neighbor,
{ "Neighbor Addr", "igmp.neighbor", FT_IPv4, BASE_NONE,
NULL, 0, "DVMRP Neighbor Address" }},
NULL, 0, "DVMRP Neighbor Address", HFILL }},
};
static gint *ett[] = {

8
packet-eigrp.c
View File

@ -2,7 +2,7 @@
* Routines for EIGRP dissection
* Copyright 2000, Paul Ionescu <paul@acorp.ro>
*
* $Id: packet-eigrp.c,v 1.16 2001/05/03 22:50:33 guy Exp $
* $Id: packet-eigrp.c,v 1.17 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -449,17 +449,17 @@ proto_register_eigrp(void)
{ &hf_eigrp_opcode,
{ "Opcode", "eigrp.opcode",
FT_UINT8, BASE_DEC, NULL, 0x0 ,
"Opcode number" },
"Opcode number", HFILL }
},
{ &hf_eigrp_as,
{ "Autonomous System ", "eigrp.as",
FT_UINT16, BASE_DEC, NULL, 0x0 ,
"Autonomous System number" }
"Autonomous System number", HFILL }
},
{ &hf_eigrp_tlv,
{ "Entry ", "eigrp.tlv",
FT_UINT16, BASE_DEC, NULL, 0x0 ,
"Type/Length/Value" }
"Type/Length/Value", HFILL }
},
};

16
packet-esis.c
View File

@ -2,7 +2,7 @@
* Routines for ISO/OSI End System to Intermediate System
* Routeing Exchange Protocol ISO 9542.
*
* $Id: packet-esis.c,v 1.15 2001/06/05 09:06:19 guy Exp $
* $Id: packet-esis.c,v 1.16 2001/06/18 02:17:46 guy Exp $
* Ralf Schneider <Ralf.Schneider@t-online.de>
*
* Ethereal - Network traffic analyzer
@ -418,20 +418,20 @@ proto_register_esis(void) {
static hf_register_info hf[] = {
{ &hf_esis_nlpi,
{ "Network Layer Protocol Identifier", "esis.nlpi",
FT_UINT8, BASE_HEX, VALS(nlpid_vals), 0x0, "" }},
FT_UINT8, BASE_HEX, VALS(nlpid_vals), 0x0, "", HFILL }},
{ &hf_esis_length,
{ "PDU Length ", "esis.length", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "PDU Length ", "esis.length", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_esis_version,
{ "Version (==1) ", "esis.ver", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "Version (==1) ", "esis.ver", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_esis_reserved,
{ "Reserved(==0) ", "esis.res", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "Reserved(==0) ", "esis.res", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_esis_type,
{ "PDU Type ", "esis.type", FT_UINT8, BASE_DEC, VALS(esis_vals),
0xff, "" }},
0xff, "", HFILL }},
{ &hf_esis_holdtime,
{ "Holding Time ", "esis.htime", FT_UINT16, BASE_DEC, NULL, 0x0, " s"}},
{ "Holding Time ", "esis.htime", FT_UINT16, BASE_DEC, NULL, 0x0, " s", HFILL }},
{ &hf_esis_checksum,
{ "Checksum ", "esis.chksum", FT_UINT16, BASE_HEX, NULL, 0x0, "" }}
{ "Checksum ", "esis.chksum", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }}
};
/*
*

14
packet-eth.c
View File

@ -1,7 +1,7 @@
/* packet-eth.c
* Routines for ethernet packet disassembly
*
* $Id: packet-eth.c,v 1.64 2001/04/17 06:43:18 guy Exp $
* $Id: packet-eth.c,v 1.65 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -266,27 +266,27 @@ proto_register_eth(void)
{ &hf_eth_dst,
{ "Destination", "eth.dst", FT_ETHER, BASE_NONE, NULL, 0x0,
"Destination Hardware Address" }},
"Destination Hardware Address", HFILL }},
{ &hf_eth_src,
{ "Source", "eth.src", FT_ETHER, BASE_NONE, NULL, 0x0,
"Source Hardware Address" }},
"Source Hardware Address", HFILL }},
{ &hf_eth_len,
{ "Length", "eth.len", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
/* registered here but handled in ethertype.c */
{ &hf_eth_type,
{ "Type", "eth.type", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0,
"" }},
"", HFILL }},
{ &hf_eth_addr,
{ "Source or Destination Address", "eth.addr", FT_ETHER, BASE_NONE, NULL, 0x0,
"Source or Destination Hardware Address" }},
"Source or Destination Hardware Address", HFILL }},
{ &hf_eth_trailer,
{ "Trailer", "eth.trailer", FT_BYTES, BASE_NONE, NULL, 0x0,
"Ethernet Trailer or Checksum" }},
"Ethernet Trailer or Checksum", HFILL }},
};
static gint *ett[] = {

10
packet-fddi.c
View File

@ -3,7 +3,7 @@
*
* Laurent Deniel <deniel@worldnet.fr>
*
* $Id: packet-fddi.c,v 1.48 2001/01/21 22:10:22 guy Exp $
* $Id: packet-fddi.c,v 1.49 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -349,19 +349,19 @@ proto_register_fddi(void)
*/
{ &hf_fddi_fc,
{ "Frame Control", "fddi.fc", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_fddi_dst,
{ "Destination", "fddi.dst", FT_ETHER, BASE_NONE, NULL, 0x0,
"Destination Hardware Address" }},
"Destination Hardware Address", HFILL }},
{ &hf_fddi_src,
{ "Source", "fddi.src", FT_ETHER, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_fddi_addr,
{ "Source or Destination Address", "fddi.addr", FT_ETHER, BASE_NONE, NULL, 0x0,
"Source or Destination Hardware Address" }},
"Source or Destination Hardware Address", HFILL }},
};
static gint *ett[] = {

26
packet-fr.c
View File

@ -3,7 +3,7 @@
*
* Copyright 2001, Paul Ionescu <paul@acorp.ro>
*
* $Id: packet-fr.c,v 1.17 2001/04/17 06:43:18 guy Exp $
* $Id: packet-fr.c,v 1.18 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -372,41 +372,41 @@ void proto_register_fr(void)
{ &hf_fr_dlci, {
"DLCI", "fr.dlci", FT_UINT16, BASE_DEC,
NULL, FRELAY_DLCI, "Data-Link Connection Identifier" }},
NULL, FRELAY_DLCI, "Data-Link Connection Identifier", HFILL }},
{ &hf_fr_cr, {
"CR", "fr.cr", FT_BOOLEAN, 16, TFS(&cmd_string),
FRELAY_CR, "Command/Response" }},
FRELAY_CR, "Command/Response", HFILL }},
{ &hf_fr_dc, {
"DC", "fr.dc", FT_BOOLEAN, 16, TFS(&ctrl_string),
FRELAY_CR, "Address/Control" }},
FRELAY_CR, "Address/Control", HFILL }},
{ &hf_fr_fecn, {
"FECN", "fr.fecn", FT_BOOLEAN, 16,
NULL, FRELAY_FECN, "Forward Explicit Congestion Notification" }},
NULL, FRELAY_FECN, "Forward Explicit Congestion Notification", HFILL }},
{ &hf_fr_becn, {
"BECN", "fr.becn", FT_BOOLEAN, 16,
NULL, FRELAY_BECN, "Backward Explicit Congestion Notification" }},
NULL, FRELAY_BECN, "Backward Explicit Congestion Notification", HFILL }},
{ &hf_fr_de, {
"DE", "fr.de", FT_BOOLEAN, 16,
NULL, FRELAY_DE, "Discard Eligibility" }},
NULL, FRELAY_DE, "Discard Eligibility", HFILL }},
{ &hf_fr_ea, {
"EA", "fr.ea", FT_BOOLEAN, 16, TFS(&ea_string),
FRELAY_EA, "Extended Address" }},
FRELAY_EA, "Extended Address", HFILL }},
{ &hf_fr_nlpid, {
"NLPID", "fr.nlpid", FT_UINT8, BASE_HEX,
VALS(fr_nlpid_vals), 0x0, "FrameRelay Encapsulated Protocol NLPID" }},
VALS(fr_nlpid_vals), 0x0, "FrameRelay Encapsulated Protocol NLPID", HFILL }},
{ &hf_fr_oui, {
"Organization Code", "fr.snap.oui", FT_UINT24, BASE_HEX,
VALS(oui_vals), 0x0, ""}},
VALS(oui_vals), 0x0, "", HFILL }},
{ &hf_fr_pid, {
"Protocol ID", "fr.snap.pid", FT_UINT16, BASE_HEX,
NULL, 0x0, ""}},
NULL, 0x0, "", HFILL }},
{ &hf_fr_snaptype, {
"Type", "fr.snaptype", FT_UINT16, BASE_HEX,
VALS(etype_vals), 0x0, "FrameRelay SNAP Encapsulated Protocol" }},
VALS(etype_vals), 0x0, "FrameRelay SNAP Encapsulated Protocol", HFILL }},
{ &hf_fr_chdlctype, {
"Type", "fr.chdlctype", FT_UINT16, BASE_HEX,
VALS(chdlc_vals), 0x0, "FrameRelay Cisco HDLC Encapsulated Protocol" }},
VALS(chdlc_vals), 0x0, "FrameRelay Cisco HDLC Encapsulated Protocol", HFILL }},
};

16
packet-frame.c
View File

@ -2,7 +2,7 @@
*
* Top-most dissector. Decides dissector based on Wiretap Encapsulation Type.
*
* $Id: packet-frame.c,v 1.7 2001/04/01 21:12:05 hagbard Exp $
* $Id: packet-frame.c,v 1.8 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -151,33 +151,33 @@ proto_register_frame(void)
static hf_register_info hf[] = {
{ &hf_frame_arrival_time,
{ "Arrival Time", "frame.time", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0,
""}},
"", HFILL }},
{ &hf_frame_time_delta,
{ "Time delta from previous packet", "frame.time_delta", FT_RELATIVE_TIME, BASE_NONE, NULL,
0x0,
"" }},
"", HFILL }},
{ &hf_frame_time_relative,
{ "Time relative to first packet", "frame.time_relative", FT_RELATIVE_TIME, BASE_NONE, NULL,
0x0,
"" }},
"", HFILL }},
{ &hf_frame_number,
{ "Frame Number", "frame.number", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_frame_packet_len,
{ "Total Frame Length", "frame.pkt_len", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_frame_capture_len,
{ "Capture Frame Length", "frame.cap_len", FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_frame_p2p_dir,
{ "Point-to-Point Direction", "frame.p2p_dir", FT_UINT8, BASE_DEC, VALS(p2p_dirs), 0x0,
"" }},
"", HFILL }},
};
static gint *ett[] = {
&ett_frame,

14
packet-ftp.c
View File

@ -3,7 +3,7 @@
* Copyright 1999, Richard Sharpe <rsharpe@ns.aus.com>
* Copyright 2001, Juan Toledo <toledo@users.sourceforge.net> (Passive FTP)
*
* $Id: packet-ftp.c,v 1.29 2001/06/10 09:50:18 guy Exp $
* $Id: packet-ftp.c,v 1.30 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -264,32 +264,32 @@ proto_register_ftp(void)
{ &hf_ftp_response,
{ "Response", "ftp.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if FTP response" }},
"TRUE if FTP response", HFILL }},
{ &hf_ftp_request,
{ "Request", "ftp.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if FTP request" }},
"TRUE if FTP request", HFILL }},
{ &hf_ftp_request_command,
{ "Request command", "ftp.request.command",
FT_STRING, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ftp_request_data,
{ "Request data", "ftp.request.data",
FT_STRING, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ftp_response_code,
{ "Response code", "ftp.response.code",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ftp_response_data,
{ "Response data", "ftp.reponse.data",
FT_STRING, BASE_NONE, NULL, 0x0,
"" }}
"", HFILL }}
};
static gint *ett[] = {
&ett_ftp,

8
packet-giop.c
View File

@ -4,7 +4,7 @@
* Laurent Deniel <deniel@worldnet.fr>
* Craig Rodrigues <rodrigc@mediaone.net>
*
* $Id: packet-giop.c,v 1.33 2001/06/18 01:49:16 guy Exp $
* $Id: packet-giop.c,v 1.34 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -204,7 +204,7 @@ static const value_string reply_status_types[] = {
{ SYSTEM_EXCEPTION, "System Exception" } ,
{ LOCATION_FORWARD, "Location Forward" } ,
{ LOCATION_FORWARD_PERM, "Location Forward Perm" } ,
{ NEEDS_ADDRESSING_MODE, "Needs Addressing Mode"} ,
{ NEEDS_ADDRESSING_MODE, "Needs Addressing Mode" } ,
{ 0, NULL }
};
@ -1402,14 +1402,14 @@ proto_register_giop (void)
&hf_giop_message_type,
{
"Message type", "giop.type",
FT_UINT8, BASE_DEC, NULL, 0x0, ""}
FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }
}
,
{
&hf_giop_message_size,
{
"Message size", "giop.len",
FT_UINT32, BASE_DEC, NULL, 0x0, ""}
FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }
}
,
};

68
packet-gnutella.c
View File

@ -2,7 +2,7 @@
* Routines for gnutella dissection
* Copyright 2001, B. Johannessen <bob@havoq.com>
*
* $Id: packet-gnutella.c,v 1.1 2001/06/06 01:30:29 guy Exp $
* $Id: packet-gnutella.c,v 1.2 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -635,167 +635,167 @@ void proto_register_gnutella(void) {
{ &hf_gnutella_header,
{ "Descriptor Header", "gnutella.header",
FT_NONE, BASE_NONE, NULL, 0,
"Gnutella Descriptor Header" }
"Gnutella Descriptor Header", HFILL }
},
{ &hf_gnutella_pong_payload,
{ "Pong", "gnutella.pong.payload",
FT_NONE, BASE_NONE, NULL, 0,
"Gnutella Pong Payload" }
"Gnutella Pong Payload", HFILL }
},
{ &hf_gnutella_push_payload,
{ "Push", "gnutella.push.payload",
FT_NONE, BASE_NONE, NULL, 0,
"Gnutella Push Payload" }
"Gnutella Push Payload", HFILL }
},
{ &hf_gnutella_query_payload,
{ "Query", "gnutella.query.payload",
FT_NONE, BASE_NONE, NULL, 0,
"Gnutella Query Payload" }
"Gnutella Query Payload", HFILL }
},
{ &hf_gnutella_queryhit_payload,
{ "QueryHit", "gnutella.queryhit.payload",
FT_NONE, BASE_NONE, NULL, 0,
"Gnutella QueryHit Payload" }
"Gnutella QueryHit Payload", HFILL }
},
{ &hf_gnutella_truncated,
{ "Truncated Frame", "gnutella.truncated",
FT_NONE, BASE_NONE, NULL, 0,
"The Gnutella Frame Was Truncated" }
"The Gnutella Frame Was Truncated", HFILL }
},
{ &hf_gnutella_stream,
{ "Gnutella Upload / Download Stream", "gnutella.stream",
FT_NONE, BASE_NONE, NULL, 0,
"Gnutella Upload / Download Stream" }
"Gnutella Upload / Download Stream", HFILL }
},
{ &hf_gnutella_header_id,
{ "ID", "gnutella.header.id",
FT_BYTES, BASE_HEX, NULL, 0,
"Gnutella Descriptor ID" }
"Gnutella Descriptor ID", HFILL }
},
{ &hf_gnutella_header_payload,
{ "Payload", "gnutella.header.payload",
FT_UINT8, BASE_DEC, NULL, 0,
"Gnutella Descriptor Payload" }
"Gnutella Descriptor Payload", HFILL }
},
{ &hf_gnutella_header_ttl,
{ "TTL", "gnutella.header.ttl",
FT_UINT8, BASE_DEC, NULL, 0,
"Gnutella Descriptor Time To Live" }
"Gnutella Descriptor Time To Live", HFILL }
},
{ &hf_gnutella_header_hops,
{ "Hops", "gnutella.header.hops",
FT_UINT8, BASE_DEC, NULL, 0,
"Gnutella Descriptor Hop Count" }
"Gnutella Descriptor Hop Count", HFILL }
},
{ &hf_gnutella_header_size,
{ "Length", "gnutella.header.size",
FT_UINT8, BASE_DEC, NULL, 0,
"Gnutella Descriptor Payload Length" }
"Gnutella Descriptor Payload Length", HFILL }
},
{ &hf_gnutella_pong_port,
{ "Port", "gnutella.pong.port",
FT_UINT16, BASE_DEC, NULL, 0,
"Gnutella Pong TCP Port" }
"Gnutella Pong TCP Port", HFILL }
},
{ &hf_gnutella_pong_ip,
{ "IP", "gnutella.pong.ip",
FT_IPv4, BASE_DEC, NULL, 0,
"Gnutella Pong IP Address" }
"Gnutella Pong IP Address", HFILL }
},
{ &hf_gnutella_pong_files,
{ "Files Shared", "gnutella.pong.files",
FT_UINT32, BASE_DEC, NULL, 0,
"Gnutella Pong Files Shared" }
"Gnutella Pong Files Shared", HFILL }
},
{ &hf_gnutella_pong_kbytes,
{ "KBytes Shared", "gnutella.pong.kbytes",
FT_UINT32, BASE_DEC, NULL, 0,
"Gnutella Pong KBytes Shared" }
"Gnutella Pong KBytes Shared", HFILL }
},
{ &hf_gnutella_query_min_speed,
{ "Min Speed", "gnutella.query.min_speed",
FT_UINT32, BASE_DEC, NULL, 0,
"Gnutella Query Minimum Speed" }
"Gnutella Query Minimum Speed", HFILL }
},
{ &hf_gnutella_query_search,
{ "Search", "gnutella.query.search",
FT_STRINGZ, BASE_NONE, NULL, 0,
"Gnutella Query Search" }
"Gnutella Query Search", HFILL }
},
{ &hf_gnutella_queryhit_hit,
{ "Hit", "gnutella.queryhit.hit",
FT_NONE, BASE_NONE, NULL, 0,
"Gnutella QueryHit" }
"Gnutella QueryHit", HFILL }
},
{ &hf_gnutella_queryhit_hit_index,
{ "Index", "gnutella.queryhit.hit.index",
FT_UINT32, BASE_DEC, NULL, 0,
"Gnutella QueryHit Index" }
"Gnutella QueryHit Index", HFILL }
},
{ &hf_gnutella_queryhit_hit_size,
{ "Size", "gnutella.queryhit.hit.size",
FT_UINT32, BASE_DEC, NULL, 0,
"Gnutella QueryHit Size" }
"Gnutella QueryHit Size", HFILL }
},
{ &hf_gnutella_queryhit_hit_name,
{ "Name", "gnutella.queryhit.hit.name",
FT_STRING, BASE_NONE, NULL, 0,
"Gnutella Query Name" }
"Gnutella Query Name", HFILL }
},
{ &hf_gnutella_queryhit_hit_extra,
{ "Extra", "gnutella.queryhit.hit.extra",
FT_BYTES, BASE_HEX, NULL, 0,
"Gnutella Query Extra" }
"Gnutella Query Extra", HFILL }
},
{ &hf_gnutella_queryhit_count,
{ "Count", "gnutella.queryhit.count",
FT_UINT8, BASE_DEC, NULL, 0,
"Gnutella QueryHit Count" }
"Gnutella QueryHit Count", HFILL }
},
{ &hf_gnutella_queryhit_port,
{ "Port", "gnutella.queryhit.port",
FT_UINT16, BASE_DEC, NULL, 0,
"Gnutella QueryHit Port" }
"Gnutella QueryHit Port", HFILL }
},
{ &hf_gnutella_queryhit_ip,
{ "IP", "gnutella.queryhit.ip",
FT_IPv4, BASE_DEC, NULL, 0,
"Gnutella QueryHit IP Address" }
"Gnutella QueryHit IP Address", HFILL }
},
{ &hf_gnutella_queryhit_speed,
{ "Speed", "gnutella.queryhit.speed",
FT_UINT32, BASE_DEC, NULL, 0,
"Gnutella QueryHit Speed" }
"Gnutella QueryHit Speed", HFILL }
},
{ &hf_gnutella_queryhit_extra,
{ "Extra", "gnutella.queryhit.extra",
FT_BYTES, BASE_HEX, NULL, 0,
"Gnutella QueryHit Extra" }
"Gnutella QueryHit Extra", HFILL }
},
{ &hf_gnutella_queryhit_servent_id,
{ "Servent ID", "gnutella.queryhit.servent_id",
FT_BYTES, BASE_HEX, NULL, 0,
"Gnutella QueryHit Servent ID" }
"Gnutella QueryHit Servent ID", HFILL }
},
{ &hf_gnutella_push_servent_id,
{ "Servent ID", "gnutella.push.servent_id",
FT_BYTES, BASE_HEX, NULL, 0,
"Gnutella Push Servent ID" }
"Gnutella Push Servent ID", HFILL }
},
{ &hf_gnutella_push_ip,
{ "IP", "gnutella.push.ip",
FT_IPv4, BASE_DEC, NULL, 0,
"Gnutella Push IP Address" }
"Gnutella Push IP Address", HFILL }
},
{ &hf_gnutella_push_index,
{ "Index", "gnutella.push.index",
FT_UINT32, BASE_DEC, NULL, 0,
"Gnutella Push Index" }
"Gnutella Push Index", HFILL }
},
{ &hf_gnutella_push_port,
{ "Port", "gnutella.push.port",
FT_UINT16, BASE_DEC, NULL, 0,
"Gnutella Push Port" }
"Gnutella Push Port", HFILL }
},
};

4
packet-gre.c
View File

@ -2,7 +2,7 @@
* Routines for the Generic Routing Encapsulation (GRE) protocol
* Brad Robel-Forrest <brad.robel-forrest@watchguard.com>
*
* $Id: packet-gre.c,v 1.43 2001/04/23 18:11:01 guy Exp $
* $Id: packet-gre.c,v 1.44 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -340,7 +340,7 @@ proto_register_gre(void)
static hf_register_info hf[] = {
{ &hf_gre_proto,
{ "Protocol Type", "gre.proto", FT_UINT16, BASE_HEX, VALS(typevals), 0x0,
"The protocol that is GRE encapsulated"}
"The protocol that is GRE encapsulated", HFILL }
},
};
static gint *ett[] = {

106
packet-gtp.c
View File

@ -2,7 +2,7 @@
* Routines for GTP dissection
* Copyright 2001, Michal Melerowicz <michal.melerowicz@nokia.com>
*
* $Id: packet-gtp.c,v 1.5 2001/04/23 18:05:18 guy Exp $
* $Id: packet-gtp.c,v 1.6 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -1988,84 +1988,84 @@ proto_register_gtp(void)
static hf_register_info hf[] = {
{ &hf_gtp_flags, { "Flags", "gtp.flags", FT_UINT8, BASE_HEX, NULL, 0, "Ver/PT/Res/E/S/PN" }},
{ &hf_gtp_flags_ver, { "Version", "gtp.flags.version", FT_UINT8, BASE_DEC, VALS(ver_types), GTP_VER_MASK, "GTP version" }},
{ &hf_gtp_flags_pt, { "Payload Type", "gtp.flags.payload_type", FT_UINT8, BASE_DEC, NULL, GTP_PT_MASK, "Payload types" }},
{ &hf_gtp_flags_spare, { "Reserved", "gtp.flags.spare", FT_UINT8, BASE_DEC, NULL, GTP_SPARE_MASK, "Reserved" }},
{ &hf_gtp_flags_snn, { "Is seq number", "gtp.flags.snn", FT_UINT8, BASE_DEC, NULL, GTP_SNN_MASK, "Is sequence number present" }},
{ &hf_gtp_message_type, { "Message type", "gtp.message_type", FT_UINT8, BASE_HEX, VALS(message_type), 0x0, "GTP message type" }},
{ &hf_gtp_length, { "Length", "gtp.length", FT_UINT16, BASE_DEC, NULL, 0, "Length" }},
{ &hf_gtp_seq_number, { "Sequence number", "gtp.seq_number", FT_UINT16, BASE_HEX, NULL, 0, "Sequence number" }},
{ &hf_gtp_flow_label, { "Flow label", "gtp.flow_label", FT_UINT16, BASE_HEX, NULL, 0, "Flow label" }},
{ &hf_gtp_sndcp_number, { "SNDCP N-PDU LLC Number", "gtp.sndcp_number", FT_UINT8, BASE_HEX, NULL, 0, "SNDCP N-PDU LLC Number" }},
{ &hf_gtp_tid, { "Tunnel ID", "gtp.tid", FT_STRING, BASE_DEC, NULL, 0, "Tunnel ID" }},
{ &hf_gtp_ext, { "Extension header", "gtp.ext", FT_UINT8, BASE_HEX, NULL, 0, "Extension header" }},
{ &hf_gtp_flags, { "Flags", "gtp.flags", FT_UINT8, BASE_HEX, NULL, 0, "Ver/PT/Res/E/S/PN", HFILL }},
{ &hf_gtp_flags_ver, { "Version", "gtp.flags.version", FT_UINT8, BASE_DEC, VALS(ver_types), GTP_VER_MASK, "GTP version", HFILL }},
{ &hf_gtp_flags_pt, { "Payload Type", "gtp.flags.payload_type", FT_UINT8, BASE_DEC, NULL, GTP_PT_MASK, "Payload types", HFILL }},
{ &hf_gtp_flags_spare, { "Reserved", "gtp.flags.spare", FT_UINT8, BASE_DEC, NULL, GTP_SPARE_MASK, "Reserved", HFILL }},
{ &hf_gtp_flags_snn, { "Is seq number", "gtp.flags.snn", FT_UINT8, BASE_DEC, NULL, GTP_SNN_MASK, "Is sequence number present", HFILL }},
{ &hf_gtp_message_type, { "Message type", "gtp.message_type", FT_UINT8, BASE_HEX, VALS(message_type), 0x0, "GTP message type", HFILL }},
{ &hf_gtp_length, { "Length", "gtp.length", FT_UINT16, BASE_DEC, NULL, 0, "Length", HFILL }},
{ &hf_gtp_seq_number, { "Sequence number", "gtp.seq_number", FT_UINT16, BASE_HEX, NULL, 0, "Sequence number", HFILL }},
{ &hf_gtp_flow_label, { "Flow label", "gtp.flow_label", FT_UINT16, BASE_HEX, NULL, 0, "Flow label", HFILL }},
{ &hf_gtp_sndcp_number, { "SNDCP N-PDU LLC Number", "gtp.sndcp_number", FT_UINT8, BASE_HEX, NULL, 0, "SNDCP N-PDU LLC Number", HFILL }},
{ &hf_gtp_tid, { "Tunnel ID", "gtp.tid", FT_STRING, BASE_DEC, NULL, 0, "Tunnel ID", HFILL }},
{ &hf_gtp_ext, { "Extension header", "gtp.ext", FT_UINT8, BASE_HEX, NULL, 0, "Extension header", HFILL }},
{ &hf_gtp_ext_cause, { "Cause", "gtp.ext.cause", FT_UINT8, BASE_DEC, VALS(cause_type), 0, "Cause of operation" }},
{ &hf_gtp_ext_cause, { "Cause", "gtp.ext.cause", FT_UINT8, BASE_DEC, VALS(cause_type), 0, "Cause of operation", HFILL }},
{ &hf_gtp_ext_imsi, { "IMSI", "gtp.ext.imsi", FT_STRING, BASE_DEC, NULL, 0, "IMSI number" }},
{ &hf_gtp_ext_imsi, { "IMSI", "gtp.ext.imsi", FT_STRING, BASE_DEC, NULL, 0, "IMSI number", HFILL }},
{ &hf_gtp_ext_rai_mcc, { "MCC", "gtp.ext.mcc", FT_UINT16, BASE_DEC, NULL, 0, "Mobile Country Code" }},
{ &hf_gtp_ext_rai_mnc, { "MNC", "gtp.ext.mnc", FT_UINT8, BASE_DEC, NULL, 0, "Mobile National Code" }},
{ &hf_gtp_ext_rai_rac, { "RAC", "gtp.ext.rac", FT_UINT8, BASE_DEC, NULL, 0, "Routing Area" }},
{ &hf_gtp_ext_rai_lac, { "LAC", "gtp.ext.lac", FT_UINT16, BASE_DEC, NULL, 0, "Location Area" }},
{ &hf_gtp_ext_rai_mcc, { "MCC", "gtp.ext.mcc", FT_UINT16, BASE_DEC, NULL, 0, "Mobile Country Code", HFILL }},
{ &hf_gtp_ext_rai_mnc, { "MNC", "gtp.ext.mnc", FT_UINT8, BASE_DEC, NULL, 0, "Mobile National Code", HFILL }},
{ &hf_gtp_ext_rai_rac, { "RAC", "gtp.ext.rac", FT_UINT8, BASE_DEC, NULL, 0, "Routing Area", HFILL }},
{ &hf_gtp_ext_rai_lac, { "LAC", "gtp.ext.lac", FT_UINT16, BASE_DEC, NULL, 0, "Location Area", HFILL }},
{ &hf_gtp_ext_tlli, { "TLLI", "gtp.ext.tlli", FT_UINT32, BASE_HEX, NULL, 0, "Temporary Logical Link Identity" }},
{ &hf_gtp_ext_tlli, { "TLLI", "gtp.ext.tlli", FT_UINT32, BASE_HEX, NULL, 0, "Temporary Logical Link Identity", HFILL }},
{ &hf_gtp_ext_ptmsi, { "P-TMSI", "gtp.ext.ptmsi", FT_UINT32, BASE_HEX, NULL, 0, "Packet TMSI" }},
{ &hf_gtp_ext_ptmsi, { "P-TMSI", "gtp.ext.ptmsi", FT_UINT32, BASE_HEX, NULL, 0, "Packet TMSI", HFILL }},
{ &hf_gtp_ext_qos_delay, { "QoS delay", "gtp.ext.qos_delay", FT_UINT8, BASE_DEC, VALS(qos_delay_type), 0, "QoS delay class" }},
{ &hf_gtp_ext_qos_reliability, { "QoS reliability","gtp.ext.qos_reliabilty", FT_UINT8, BASE_DEC, VALS(qos_reliability_type), 0, "QoS reliability class" }},
{ &hf_gtp_ext_qos_peak, { "QoS peak", "gtp.ext.qos_peak", FT_UINT8, BASE_DEC, VALS(qos_peak_type), 0, "QoS peak throughput" }},
{ &hf_gtp_ext_qos_precedence, { "QoS precedence", "gtp.ext.qos_precedence", FT_UINT8, BASE_DEC, VALS(qos_precedence_type), 0, "QoS precedence class" }},
{ &hf_gtp_ext_qos_mean, { "QoS mean", "gtp.ext.qos_mean", FT_UINT8, BASE_DEC, VALS(qos_mean_type), 0, "QoS mean throughput" }},
{ &hf_gtp_ext_qos_delay, { "QoS delay", "gtp.ext.qos_delay", FT_UINT8, BASE_DEC, VALS(qos_delay_type), 0, "QoS delay class", HFILL }},
{ &hf_gtp_ext_qos_reliability, { "QoS reliability","gtp.ext.qos_reliabilty", FT_UINT8, BASE_DEC, VALS(qos_reliability_type), 0, "QoS reliability class", HFILL }},
{ &hf_gtp_ext_qos_peak, { "QoS peak", "gtp.ext.qos_peak", FT_UINT8, BASE_DEC, VALS(qos_peak_type), 0, "QoS peak throughput", HFILL }},
{ &hf_gtp_ext_qos_precedence, { "QoS precedence", "gtp.ext.qos_precedence", FT_UINT8, BASE_DEC, VALS(qos_precedence_type), 0, "QoS precedence class", HFILL }},
{ &hf_gtp_ext_qos_mean, { "QoS mean", "gtp.ext.qos_mean", FT_UINT8, BASE_DEC, VALS(qos_mean_type), 0, "QoS mean throughput", HFILL }},
{ &hf_gtp_ext_reorder, { "Reordering required", "gtp.ext.reorder", FT_BOOLEAN, BASE_NONE, NULL, 0, "Reordering required" }},
{ &hf_gtp_ext_reorder, { "Reordering required", "gtp.ext.reorder", FT_BOOLEAN, BASE_NONE, NULL, 0, "Reordering required", HFILL }},
/* { &hf_gtp_ext_auth_rand, { "Authentication RAND", "gtp.ext.auth_rand", FT_STRING, BASE_DEC, NULL, 0, "Authentication RAND" }},
{ &hf_gtp_ext_auth_sres, { "Authentication SRES", "gtp.ext.auth_sres", FT_STRING, BASE_DEC, NULL, 0, "Authentication SRES" }},
{ &hf_gtp_ext_auth_kc, { "Authentication Kc", "gtp.ext.auth_kc", FT_STRING, BASE_DEC, NULL, 0, "Authentication Kc" }},
/* { &hf_gtp_ext_auth_rand, { "Authentication RAND", "gtp.ext.auth_rand", FT_STRING, BASE_DEC, NULL, 0, "Authentication RAND", HFILL }},
{ &hf_gtp_ext_auth_sres, { "Authentication SRES", "gtp.ext.auth_sres", FT_STRING, BASE_DEC, NULL, 0, "Authentication SRES", HFILL }},
{ &hf_gtp_ext_auth_kc, { "Authentication Kc", "gtp.ext.auth_kc", FT_STRING, BASE_DEC, NULL, 0, "Authentication Kc", HFILL }},
*/
{ &hf_gtp_ext_map, { "Ext type", "gtp.ext.map", FT_UINT8, BASE_DEC, VALS(map_cause_type), 0, "MAP cause" }},
{ &hf_gtp_ext_map, { "Ext type", "gtp.ext.map", FT_UINT8, BASE_DEC, VALS(map_cause_type), 0, "MAP cause", HFILL }},
{ &hf_gtp_ext_ptmsi_sig, { "P-TMSI signature", "gtp.ext.ptmsi_sig", FT_UINT24, BASE_HEX, NULL, 0, "P-TMSI signature" }},
{ &hf_gtp_ext_ptmsi_sig, { "P-TMSI signature", "gtp.ext.ptmsi_sig", FT_UINT24, BASE_HEX, NULL, 0, "P-TMSI signature", HFILL }},
{ &hf_gtp_ext_ms, { "MS validated", "gtp.ext.ms", FT_BOOLEAN, BASE_NONE, NULL, 0, "MS validated" }},
{ &hf_gtp_ext_ms, { "MS validated", "gtp.ext.ms", FT_BOOLEAN, BASE_NONE, NULL, 0, "MS validated", HFILL }},
{ &hf_gtp_ext_recover, { "Restart counter", "gtp.ext.recover", FT_UINT8, BASE_DEC, NULL, 0, "Restart counter" }},
{ &hf_gtp_ext_recover, { "Restart counter", "gtp.ext.recover", FT_UINT8, BASE_DEC, NULL, 0, "Restart counter", HFILL }},
{ &hf_gtp_ext_sel_mode, { "Selection mode", "gtp.ext.sel_mode", FT_UINT8, BASE_DEC, VALS(sel_mode_type), 0, "Selection mode" }},
{ &hf_gtp_ext_sel_mode, { "Selection mode", "gtp.ext.sel_mode", FT_UINT8, BASE_DEC, VALS(sel_mode_type), 0, "Selection mode", HFILL }},
{ &hf_gtp_ext_flow_label, { "Flow label", "gtp.ext.flow_label", FT_UINT16, BASE_DEC, NULL, 0, "Flow label" }},
{ &hf_gtp_ext_flow_label, { "Flow label", "gtp.ext.flow_label", FT_UINT16, BASE_DEC, NULL, 0, "Flow label", HFILL }},
{ &hf_gtp_ext_flow_sig, { "Flow label signature", "gtp.ext.flow_sig", FT_UINT16, BASE_DEC, NULL, 0, "Flow label signature" }},
{ &hf_gtp_ext_flow_sig, { "Flow label signature", "gtp.ext.flow_sig", FT_UINT16, BASE_DEC, NULL, 0, "Flow label signature", HFILL }},
{ &hf_gtp_ext_flow_ii_nsapi,{ "NSAPI", "gtp.ext.flow_ii_nsapi", FT_UINT8, BASE_HEX, NULL, 0, "NSAPI" }},
{ &hf_gtp_ext_flow_ii, { "Downlink flow label data", "gtp.ext.flow_ii", FT_UINT16, BASE_DEC, NULL, 0, "Downlink flow label data" }},
{ &hf_gtp_ext_flow_ii_nsapi,{ "NSAPI", "gtp.ext.flow_ii_nsapi", FT_UINT8, BASE_HEX, NULL, 0, "NSAPI", HFILL }},
{ &hf_gtp_ext_flow_ii, { "Downlink flow label data", "gtp.ext.flow_ii", FT_UINT16, BASE_DEC, NULL, 0, "Downlink flow label data", HFILL }},
{ &hf_gtp_ext_tr_comm, { "Transfer command", "gtp.ext.tr_comm", FT_UINT8, BASE_DEC, VALS(tr_comm_type), 0, "Packet transfer command" }},
{ &hf_gtp_ext_chrg_id, { "Charging ID", "gtp.ext.chrg_id", FT_UINT32, BASE_HEX, NULL, 0, "Charging ID" }},
{ &hf_gtp_ext_tr_comm, { "Transfer command", "gtp.ext.tr_comm", FT_UINT8, BASE_DEC, VALS(tr_comm_type), 0, "Packet transfer command", HFILL }},
{ &hf_gtp_ext_chrg_id, { "Charging ID", "gtp.ext.chrg_id", FT_UINT32, BASE_HEX, NULL, 0, "Charging ID", HFILL }},
{ &hf_gtp_ext_user_addr, { "End user address", "gtp.ext.user_addr", FT_IPv4, BASE_DEC, NULL, 0, "End user address" }},
{ &hf_gtp_ext_user_addr_pdp_type, { "PDP type", "gtp.ext.user_addr_pdp_type", FT_UINT8, BASE_HEX, VALS(pdp_type), 0, "PDP type" }},
{ &hf_gtp_ext_user_addr_pdp_org, { "PDP type organization", "gtp.ext.user_addr_pdp_org", FT_UINT8, BASE_DEC, NULL, 0, "PDP type organization" }},
{ &hf_gtp_ext_user_addr, { "End user address", "gtp.ext.user_addr", FT_IPv4, BASE_DEC, NULL, 0, "End user address", HFILL }},
{ &hf_gtp_ext_user_addr_pdp_type, { "PDP type", "gtp.ext.user_addr_pdp_type", FT_UINT8, BASE_HEX, VALS(pdp_type), 0, "PDP type", HFILL }},
{ &hf_gtp_ext_user_addr_pdp_org, { "PDP type organization", "gtp.ext.user_addr_pdp_org", FT_UINT8, BASE_DEC, NULL, 0, "PDP type organization", HFILL }},
{ &hf_gtp_ext_apn, { "APN", "gtp.ext.apn", FT_STRING, BASE_DEC, NULL, 0, "Access Point Name" }},
{ &hf_gtp_ext_apn, { "APN", "gtp.ext.apn", FT_STRING, BASE_DEC, NULL, 0, "Access Point Name", HFILL }},
{ &hf_gtp_ext_proto_conf, { "Protocol configuration", "gtp.ext.proto_conf", FT_STRING, BASE_DEC, NULL, 0, "Protocol configuration" }},
{ &hf_gtp_ext_proto_conf, { "Protocol configuration", "gtp.ext.proto_conf", FT_STRING, BASE_DEC, NULL, 0, "Protocol configuration", HFILL }},
{ &hf_gtp_ext_gsn_addr, { "GSN address", "gtp.ext.gsn_addr", FT_IPv4, BASE_DEC, NULL, 0, "GSN address" }},
{ &hf_gtp_ext_gsn_addr, { "GSN address", "gtp.ext.gsn_addr", FT_IPv4, BASE_DEC, NULL, 0, "GSN address", HFILL }},
{ &hf_gtp_ext_msisdn, { "MSISDN", "gtp.ext.msisdn", FT_STRING, BASE_DEC, NULL, 0, "MSISDN" }},
{ &hf_gtp_ext_msisdn, { "MSISDN", "gtp.ext.msisdn", FT_STRING, BASE_DEC, NULL, 0, "MSISDN", HFILL }},
{ &hf_gtp_ext_chrg_addr, { "CG address", "gtp.ext.chrg_addr", FT_IPv4, BASE_DEC, NULL, 0, "Charging gateway address" }},
{ &hf_gtp_ext_chrg_addr, { "CG address", "gtp.ext.chrg_addr", FT_IPv4, BASE_DEC, NULL, 0, "Charging gateway address", HFILL }},
{ &hf_gtp_ext_node_addr, { "Node address", "gtp.ext.node_addr", FT_IPv4, BASE_DEC, NULL, 0, "Recommended node address" }},
{ &hf_gtp_ext_node_addr, { "Node address", "gtp.ext.node_addr", FT_IPv4, BASE_DEC, NULL, 0, "Recommended node address", HFILL }},
{ &hf_gtp_ext_ext_id, { "Ext id", "gtp.ext.ext_id", FT_UINT16, BASE_DEC, NULL, 0, "Extension id" }},
{ &hf_gtp_ext_ext_val, { "Ext val", "gtp.ext.ext_val", FT_STRING, BASE_DEC, NULL, 0, "Extension value" }},
{ &hf_gtp_ext_ext_id, { "Ext id", "gtp.ext.ext_id", FT_UINT16, BASE_DEC, NULL, 0, "Extension id", HFILL }},
{ &hf_gtp_ext_ext_val, { "Ext val", "gtp.ext.ext_val", FT_STRING, BASE_DEC, NULL, 0, "Extension value", HFILL }},
{ &hf_gtp_ext_unknown, { "Unknown data (length)", "gtp.ext.unknown", FT_UINT16, BASE_DEC, NULL, 0, "Unknown data" }},
{ &hf_gtp_ext_unknown, { "Unknown data (length)", "gtp.ext.unknown", FT_UINT16, BASE_DEC, NULL, 0, "Unknown data", HFILL }},
};

12
packet-gvrp.c
View File

@ -2,7 +2,7 @@
* Routines for GVRP (GARP VLAN Registration Protocol) dissection
* Copyright 2000, Kevin Shi <techishi@ms22.hinet.net>
*
* $Id: packet-gvrp.c,v 1.5 2001/05/27 07:07:34 guy Exp $
* $Id: packet-gvrp.c,v 1.6 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -303,27 +303,27 @@ proto_register_gvrp(void)
{ &hf_gvrp_proto_id,
{ "Protocol ID", "garp.protocol_id",
FT_UINT16, BASE_HEX, NULL, 0x0,
"" }
"", HFILL }
},
{ &hf_gvrp_attribute_type,
{ "Type", "garp.attribute_type",
FT_UINT8, BASE_HEX, VALS(attribute_type_vals), 0x0,
"" }
"", HFILL }
},
{ &hf_gvrp_attribute_length,
{ "Length", "garp.attribute_length",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }
"", HFILL }
},
{ &hf_gvrp_attribute_event,
{ "Event", "garp.attribute_event",
FT_UINT8, BASE_DEC, VALS(event_vals), 0x0,
"" }
"", HFILL }
},
{ &hf_gvrp_attribute_value,
{ "Value", "garp.attribute_value",
FT_UINT16, BASE_DEC, NULL, 0x0,
"" }
"", HFILL }
}
};

34
packet-h1.c
View File

@ -2,7 +2,7 @@
* Routines for Sinec H1 packet disassembly
* Gerrit Gehnen <G.Gehnen@atrie.de>
*
* $Id: packet-h1.c,v 1.19 2001/06/08 08:35:15 guy Exp $
* $Id: packet-h1.c,v 1.20 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -257,48 +257,48 @@ proto_register_h1 (void)
static hf_register_info hf[] = {
{&hf_h1_header,
{"H1-Header", "h1.header", FT_UINT16, BASE_HEX, NULL, 0x0,
""}},
"", HFILL }},
{&hf_h1_len,
{"Length indicator", "h1.len", FT_UINT16, BASE_DEC, NULL, 0x0,
""}},
"", HFILL }},
{&hf_h1_opfield,
{"Operation identifier", "h1.opfield", FT_UINT8, BASE_HEX, NULL, 0x0,
""}},
"", HFILL }},
{&hf_h1_oplen,
{"Operation length", "h1.oplen", FT_UINT8, BASE_HEX, NULL, 0x0, ""}},
{"Operation length", "h1.oplen", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{&hf_h1_opcode,
{"Opcode", "h1.opcode", FT_UINT8, BASE_HEX, VALS (opcode_vals), 0x0,
""}},
"", HFILL }},
{&hf_h1_requestblock,
{"Request identifier", "h1.request", FT_UINT8, BASE_HEX, NULL, 0x0,
""}},
"", HFILL }},
{&hf_h1_requestlen,
{"Request length", "h1.reqlen", FT_UINT8, BASE_HEX, NULL, 0x0,
""}},
"", HFILL }},
{&hf_h1_org,
{"Memory type", "h1.org", FT_UINT8, BASE_HEX, VALS (org_vals), 0x0,
""}},
"", HFILL }},
{&hf_h1_dbnr,
{"Memory block number", "h1.dbnr", FT_UINT8, BASE_DEC, NULL, 0x0, ""}},
{"Memory block number", "h1.dbnr", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{&hf_h1_dwnr,
{"Address within memory block", "h1.dwnr", FT_UINT16, BASE_DEC, NULL, 0x0,
""}},
"", HFILL }},
{&hf_h1_dlen,
{"Length in words", "h1.dlen", FT_INT16, BASE_DEC, NULL, 0x0, ""}},
{"Length in words", "h1.dlen", FT_INT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{&hf_h1_response,
{"Response identifier", "h1.response", FT_UINT8, BASE_HEX, NULL, 0x0, ""}},
{"Response identifier", "h1.response", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{&hf_h1_response_len,
{"Response length", "h1.reslen", FT_UINT8, BASE_DEC, NULL, 0x0,
""}},
"", HFILL }},
{&hf_h1_response_value,
{"Response value", "h1.resvalue", FT_UINT8, BASE_DEC,
VALS (returncode_vals), 0x0, ""}},
VALS (returncode_vals), 0x0, "", HFILL }},
{&hf_h1_empty,
{"Empty field", "h1.empty", FT_UINT8, BASE_HEX, NULL, 0x0,
""}},
"", HFILL }},
{&hf_h1_empty_len,
{"Empty field length", "h1.empty_len", FT_UINT8, BASE_DEC, NULL, 0x0,
""}}
"", HFILL }}
};
static gint *ett[] = {

22
packet-h261.c
View File

@ -2,7 +2,7 @@
*
* Routines for ITU-T Recommendation H.261 dissection
*
* $Id: packet-h261.c,v 1.7 2001/06/12 06:31:14 guy Exp $
* $Id: packet-h261.c,v 1.8 2001/06/18 02:17:46 guy Exp $
*
* Copyright 2000, Philips Electronics N.V.
* Andreas Sikkema <andreas.sikkema@philips.com>
@ -135,7 +135,7 @@ proto_register_h261(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -147,7 +147,7 @@ proto_register_h261(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -159,7 +159,7 @@ proto_register_h261(void)
BASE_NONE,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -171,7 +171,7 @@ proto_register_h261(void)
BASE_NONE,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -183,7 +183,7 @@ proto_register_h261(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -195,7 +195,7 @@ proto_register_h261(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -207,7 +207,7 @@ proto_register_h261(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -219,7 +219,7 @@ proto_register_h261(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -231,7 +231,7 @@ proto_register_h261(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -243,7 +243,7 @@ proto_register_h261(void)
BASE_NONE,
NULL,
0x0,
""
"", HFILL
}
},
};

70
packet-hclnfsd.c
View File

@ -2,7 +2,7 @@
* Routines for hclnfsd (Hummingbird NFS Daemon) dissection
* Copyright 2001, Mike Frisch <frisch@hummingbird.com>
*
* $Id: packet-hclnfsd.c,v 1.6 2001/05/30 06:01:01 guy Exp $
* $Id: packet-hclnfsd.c,v 1.7 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -668,139 +668,139 @@ proto_register_hclnfsd(void)
static hf_register_info hf[] = {
{ &hf_hclnfsd_request_type, {
"Request Type", "hclnfsd.request_type", FT_UINT32, BASE_DEC,
VALS(names_request_type), 0, "Request Type" }},
VALS(names_request_type), 0, "Request Type", HFILL }},
{ &hf_hclnfsd_device, {
"Device", "hclnfsd.device", FT_STRING, BASE_DEC,
NULL, 0, "Device" }},
NULL, 0, "Device", HFILL }},
{ &hf_hclnfsd_login, {
"Login Text", "hclnfsd.logintext", FT_STRING, BASE_DEC,
NULL, 0, "Login Text" }},
NULL, 0, "Login Text", HFILL }},
{ &hf_hclnfsd_lockname, {
"Lockname", "hclnfsd.lockname", FT_STRING, BASE_DEC,
NULL, 0, "Lockname" }},
NULL, 0, "Lockname", HFILL }},
{ &hf_hclnfsd_unknown_data, {
"Unknown", "hclnfsd.unknown_data", FT_BYTES, BASE_DEC,
NULL, 0, "Data" }},
NULL, 0, "Data", HFILL }},
{ &hf_hclnfsd_lockowner, {
"Lockowner", "hclnfsd.lockowner", FT_BYTES, BASE_DEC,
NULL, 0, "Lockowner" }},
NULL, 0, "Lockowner", HFILL }},
{ &hf_hclnfsd_printername, {
"Printer Name", "hclnfsd.printername", FT_STRING, BASE_DEC,
NULL, 0, "Printer name" }},
NULL, 0, "Printer name", HFILL }},
{ &hf_hclnfsd_filename, {
"Filename", "hclnfsd.filename", FT_STRING, BASE_DEC,
NULL, 0, "Filename" }},
NULL, 0, "Filename", HFILL }},
{ &hf_hclnfsd_fileext, {
"File Extension", "hclnfsd.fileext", FT_UINT32, BASE_DEC,
NULL, 0, "File Extension" }},
NULL, 0, "File Extension", HFILL }},
{ &hf_hclnfsd_grpname, {
"Group", "hclnfsd.group", FT_STRING, BASE_DEC,
NULL, 0, "Group" }},
NULL, 0, "Group", HFILL }},
{ &hf_hclnfsd_hostname, {
"Hostname", "hclnfsd.hostname", FT_STRING, BASE_DEC,
NULL, 0, "Hostname" }},
NULL, 0, "Hostname", HFILL }},
{ &hf_hclnfsd_username, {
"Username", "hclnfsd.username", FT_STRING, BASE_DEC,
NULL, 0, "Username" }},
NULL, 0, "Username", HFILL }},
{ &hf_hclnfsd_queuename, {
"Name", "hclnfsd.printqueuename", FT_STRING, BASE_DEC,
NULL, 0, "Print Queue Name" }},
NULL, 0, "Print Queue Name", HFILL }},
{ &hf_hclnfsd_queuecomment, {
"Comment", "hclnfsd.printqueuecomment", FT_STRING, BASE_DEC,
NULL, 0, "Print Queue Comment" }},
NULL, 0, "Print Queue Comment", HFILL }},
{ &hf_hclnfsd_printparams, {
"Print Parameters", "hclnfsd.printparameters", FT_STRING, BASE_DEC,
NULL, 0, "Print Parameters" }},
NULL, 0, "Print Parameters", HFILL }},
{ &hf_hclnfsd_status, {
"Status", "hclnfsd.status", FT_UINT32, BASE_DEC,
NULL, 0, "Status" }},
NULL, 0, "Status", HFILL }},
{ &hf_hclnfsd_uid, {
"UID", "hclnfsd.uid", FT_UINT32, BASE_DEC,
NULL, 0, "User ID" }},
NULL, 0, "User ID", HFILL }},
{ &hf_hclnfsd_sequence, {
"Sequence", "hclnfsd.sequence", FT_UINT32, BASE_HEX,
NULL, 0, "Sequence" }},
NULL, 0, "Sequence", HFILL }},
{ &hf_hclnfsd_cookie, {
"Cookie", "hclnfsd.cookie", FT_UINT32, BASE_HEX,
NULL, 0, "Cookie" }},
NULL, 0, "Cookie", HFILL }},
{ &hf_hclnfsd_mode, {
"Mode", "hclnfsd.mode", FT_UINT32, BASE_DEC,
NULL, 0, "Mode" }},
NULL, 0, "Mode", HFILL }},
{ &hf_hclnfsd_access, {
"Access", "hclnfsd.access", FT_UINT32, BASE_DEC,
NULL, 0, "Access" }},
NULL, 0, "Access", HFILL }},
{ &hf_hclnfsd_exclusive, {
"Exclusive", "hclnfsd.exclusive", FT_UINT32, BASE_DEC,
NULL, 0, "Exclusive" }},
NULL, 0, "Exclusive", HFILL }},
{ &hf_hclnfsd_offset, {
"Offset", "hclnfsd.offset", FT_UINT32, BASE_DEC,
NULL, 0, "Offset" }},
NULL, 0, "Offset", HFILL }},
{ &hf_hclnfsd_length, {
"Length", "hclnfsd.length", FT_UINT32, BASE_DEC,
NULL, 0, "Length" }},
NULL, 0, "Length", HFILL }},
{ &hf_hclnfsd_queuestatus, {
"Queue Status", "hclnfsd.queuestatus", FT_UINT32, BASE_DEC,
NULL, 0, "Queue Status" }},
NULL, 0, "Queue Status", HFILL }},
{ &hf_hclnfsd_printqueuenumber, {
"Print Queue Number", "hclnfsd.pqn", FT_UINT32, BASE_DEC,
NULL, 0, "Print Queue Number" }},
NULL, 0, "Print Queue Number", HFILL }},
{ &hf_hclnfsd_numphysicalprinters, {
"Number of Physical Printers", "hclnfsd.npp", FT_UINT32, BASE_DEC,
NULL, 0, "Number of Physical Printers" }},
NULL, 0, "Number of Physical Printers", HFILL }},
{ &hf_hclnfsd_jobstatus, {
"Job Status", "hclnfsd.jobstatus", FT_UINT32, BASE_DEC,
NULL, 0, "Job Status" }},
NULL, 0, "Job Status", HFILL }},
{ &hf_hclnfsd_timesubmitted, {
"Time Submitted", "hclnfsd.timesubmitted", FT_UINT32, BASE_DEC,
NULL, 0, "Time Submitted" }},
NULL, 0, "Time Submitted", HFILL }},
{ &hf_hclnfsd_size, {
"Size", "hclnfsd.size", FT_UINT32, BASE_DEC,
NULL, 0, "Size" }},
NULL, 0, "Size", HFILL }},
{ &hf_hclnfsd_copies, {
"Copies", "hclnfsd.copies", FT_UINT32, BASE_DEC,
NULL, 0, "Copies" }},
NULL, 0, "Copies", HFILL }},
{ &hf_hclnfsd_gid, {
"GID", "hclnfsd.gid", FT_UINT32, BASE_DEC,
NULL, 0, "Group ID" }},
NULL, 0, "Group ID", HFILL }},
{ &hf_hclnfsd_server_ip, {
"Server IP", "hclnfsd.server_ip", FT_IPv4, BASE_DEC,
NULL, 0, "Server IP" }},
NULL, 0, "Server IP", HFILL }},
{ &hf_hclnfsd_host_ip, {
"Host IP", "hclnfsd.host_ip", FT_IPv4, BASE_DEC,
NULL, 0, "Host IP" }},
NULL, 0, "Host IP", HFILL }},
};
static gint *ett[] = {
&ett_hclnfsd,

22
packet-hsrp.c
View File

@ -4,7 +4,7 @@
*
* Heikki Vatiainen <hessu@cs.tut.fi>
*
* $Id: packet-hsrp.c,v 1.16 2001/01/22 03:33:45 guy Exp $
* $Id: packet-hsrp.c,v 1.17 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -178,52 +178,52 @@ void proto_register_hsrp(void)
{ &hf_hsrp_version,
{ "Version", "hsrp.version",
FT_UINT8, BASE_DEC, NULL, 0x0,
"The version of the HSRP messages"}},
"The version of the HSRP messages", HFILL }},
{ &hf_hsrp_opcode,
{ "Op Code", "hsrp.opcode",
FT_UINT8, BASE_DEC, VALS(hsrp_opcode_vals), 0x0,
"The type of message contained in this packet" }},
"The type of message contained in this packet", HFILL }},
{ &hf_hsrp_state,
{ "State", "hsrp.state",
FT_UINT8, BASE_DEC, VALS(hsrp_state_vals), 0x0,
"The current state of the router sending the message" }},
"The current state of the router sending the message", HFILL }},
{ &hf_hsrp_hellotime,
{ "Hellotime", "hsrp.hellotime",
FT_UINT8, BASE_DEC, NULL, 0x0,
"The approximate period between the Hello messages that the router sends" }},
"The approximate period between the Hello messages that the router sends", HFILL }},
{ &hf_hsrp_holdtime,
{ "Holdtime", "hsrp.holdtime",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Time that the current Hello message should be considered valid" }},
"Time that the current Hello message should be considered valid", HFILL }},
{ &hf_hsrp_priority,
{ "Priority", "hsrp.priority",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Used to elect the active and standby routers. Numerically higher priority wins vote" }},
"Used to elect the active and standby routers. Numerically higher priority wins vote", HFILL }},
{ &hf_hsrp_group,
{ "Group", "hsrp.group",
FT_UINT8, BASE_DEC, NULL, 0x0,
"This field identifies the standby group" }},
"This field identifies the standby group", HFILL }},
{ &hf_hsrp_reserved,
{ "Reserved", "hsrp.reserved",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Reserved" }},
"Reserved", HFILL }},
{ &hf_hsrp_auth_data,
{ "Authentication Data", "hsrp.auth_data",
FT_STRING, 0, NULL, 0x0,
"Contains a clear-text 8 character reused password" }},
"Contains a clear-text 8 character reused password", HFILL }},
{ &hf_hsrp_virt_ip_addr,
{ "Virtual IP Address", "hsrp.virt_ip",
FT_IPv4, 0, NULL, 0x0,
"The virtual IP address used by this group" }},
"The virtual IP address used by this group", HFILL }},
};

8
packet-http.c
View File

@ -3,7 +3,7 @@
*
* Guy Harris <guy@alum.mit.edu>
*
* $Id: packet-http.c,v 1.37 2001/01/22 08:54:06 guy Exp $
* $Id: packet-http.c,v 1.38 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -374,15 +374,15 @@ proto_register_http(void)
{ &hf_http_notification,
{ "Notification", "http.notification",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if HTTP notification" }},
"TRUE if HTTP notification", HFILL }},
{ &hf_http_response,
{ "Response", "http.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if HTTP response" }},
"TRUE if HTTP response", HFILL }},
{ &hf_http_request,
{ "Request", "http.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if HTTP request" }},
"TRUE if HTTP request", HFILL }},
};
static gint *ett[] = {
&ett_http,

10
packet-icmpv6.c
View File

@ -1,7 +1,7 @@
/* packet-icmpv6.c
* Routines for ICMPv6 packet disassembly
*
* $Id: packet-icmpv6.c,v 1.46 2001/06/02 08:10:02 guy Exp $
* $Id: packet-icmpv6.c,v 1.47 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -1346,16 +1346,16 @@ proto_register_icmpv6(void)
static hf_register_info hf[] = {
{ &hf_icmpv6_type,
{ "Type", "icmpv6.type", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_icmpv6_code,
{ "Code", "icmpv6.code", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_icmpv6_checksum,
{ "Checksum", "icmpv6.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_icmpv6_checksum_bad,
{ "Bad Checksum", "icmpv6.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
};
static gint *ett[] = {
&ett_icmpv6,

10
packet-icp.c
View File

@ -2,7 +2,7 @@
* Routines for ICP (internet cache protocol) packet disassembly
* RFC 2186 && RFC 2187
*
* $Id: packet-icp.c,v 1.17 2001/02/28 21:26:58 guy Exp $
* $Id: packet-icp.c,v 1.18 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Peter Torvals
@ -225,19 +225,19 @@ proto_register_icp(void)
static hf_register_info hf[] = {
{ &hf_icp_opcode,
{ "Opcode", "icp.opcode", FT_UINT8, BASE_HEX, VALS(opcode_vals),
0x0, "" }},
0x0, "", HFILL }},
{ &hf_icp_version,
{ "Version", "icp.version", FT_UINT8, BASE_DEC, NULL,
0x0, "" }},
0x0, "", HFILL }},
{ &hf_icp_length,
{ "Length", "icp.length", FT_UINT16, BASE_DEC, NULL,
0x0, "" }},
0x0, "", HFILL }},
{ &hf_icp_request_nr,
{ "Request Number", "icp.nr", FT_UINT32, BASE_DEC, NULL,
0x0, "" }},
0x0, "", HFILL }},
};
static gint *ett[] = {
&ett_icp,

14
packet-icq.c
View File

@ -1,7 +1,7 @@
/* packet-icq.c
* Routines for ICQ packet disassembly
*
* $Id: packet-icq.c,v 1.31 2001/05/27 21:37:23 guy Exp $
* $Id: packet-icq.c,v 1.32 2001/06/18 02:17:46 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -2161,17 +2161,17 @@ proto_register_icq(void)
{
static hf_register_info hf[] = {
{ &hf_icq_type,
{"Type", "icq.type", FT_UINT16, BASE_DEC, NULL, 0x0, ""}},
{"Type", "icq.type", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_icq_uin,
{"UIN", "icq.uin", FT_UINT32, BASE_DEC, NULL, 0x0, ""}},
{"UIN", "icq.uin", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_icq_sessionid,
{"Session ID", "icq.sessionid", FT_UINT32, BASE_HEX, NULL, 0x0, ""}},
{"Session ID", "icq.sessionid", FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_icq_cmd,
{"Command", "icq.cmd", FT_UINT16, BASE_DEC, NULL, 0x0, ""}},
{"Command", "icq.cmd", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_icq_checkcode,
{"Checkcode", "icq.checkcode", FT_UINT32, BASE_HEX, NULL, 0x0, ""}},
{"Checkcode", "icq.checkcode", FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_icq_decode,
{"Decode", "icq.decode", FT_STRING, BASE_NONE, NULL, 0x0, ""}}
{"Decode", "icq.decode", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }}
};
static gint *ett[] = {
&ett_icq,

104
packet-ieee80211.c
View File

@ -3,7 +3,7 @@
* Copyright 2000, Axis Communications AB
* Inquiries/bugreports should be sent to Johan.Jorgensen@axis.com
*
* $Id: packet-ieee80211.c,v 1.22 2001/06/12 05:40:05 guy Exp $
* $Id: packet-ieee80211.c,v 1.23 2001/06/18 02:17:47 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -1673,214 +1673,214 @@ proto_register_wlan (void)
static hf_register_info hf[] = {
{&hf_fc_field,
{"Frame Control Field", "wlan.fc", FT_UINT16, BASE_HEX, NULL, 0,
"MAC Frame control"}},
"MAC Frame control", HFILL }},
{&hf_fc_proto_version,
{"Version", "wlan.fc.version", FT_UINT8, BASE_DEC, NULL, 0,
"MAC Protocol version"}}, /* 0 */
"MAC Protocol version", HFILL }}, /* 0 */
{&hf_fc_frame_type,
{"Type", "wlan.fc.type", FT_UINT8, BASE_DEC, NULL, 0,
"Frame type"}},
"Frame type", HFILL }},
{&hf_fc_frame_subtype,
{"Subtype", "wlan.fc.subtype", FT_UINT8, BASE_DEC, NULL, 0,
"Frame subtype"}}, /* 2 */
"Frame subtype", HFILL }}, /* 2 */
{&hf_fc_flags,
{"Protocol Flags", "wlan.flags", FT_UINT8, BASE_HEX, NULL, 0,
"Protocol flags"}},
"Protocol flags", HFILL }},
{&hf_fc_data_ds,
{"DS status", "wlan.fc.ds", FT_UINT8, BASE_HEX, TFS (&tofrom_ds), 0,
"Data-frame DS-traversal status"}}, /* 3 */
"Data-frame DS-traversal status", HFILL }}, /* 3 */
{&hf_fc_to_ds,
{"To DS", "wlan.fc.tods", FT_BOOLEAN, 8, TFS (&tods_flag), 0x1,
"To DS flag"}}, /* 4 */
"To DS flag", HFILL }}, /* 4 */
{&hf_fc_from_ds,
{"From DS", "wlan.fc.fromds", FT_BOOLEAN, 8, TFS (&fromds_flag), 0x2,
"From DS flag"}}, /* 5 */
"From DS flag", HFILL }}, /* 5 */
{&hf_fc_more_frag,
{"Fragments", "wlan.fc.frag", FT_BOOLEAN, 8, TFS (&more_frags), 0x4,
"More Fragments flag"}}, /* 6 */
"More Fragments flag", HFILL }}, /* 6 */
{&hf_fc_retry,
{"Retry", "wlan.fc.retry", FT_BOOLEAN, 8, TFS (&retry_flags), 0x8,
"Retransmission flag"}},
"Retransmission flag", HFILL }},
{&hf_fc_pwr_mgt,
{"PWR MGT", "wlan.fc.pwrmgt", FT_BOOLEAN, 8, TFS (&pm_flags), 0x10,
"Power management status"}},
"Power management status", HFILL }},
{&hf_fc_more_data,
{"More Data", "wlan.fc.moredata", FT_BOOLEAN, 8, TFS (&md_flags), 0x20,
"More data flag"}},
"More data flag", HFILL }},
{&hf_fc_wep,
{"WEP flag", "wlan.fc.wep", FT_BOOLEAN, 8, TFS (&wep_flags), 0x40,
"WEP flag"}},
"WEP flag", HFILL }},
{&hf_fc_order,
{"Order flag", "wlan.fc.order", FT_BOOLEAN, 8, TFS (&order_flags), 0x80,
"Strictly ordered flag"}},
"Strictly ordered flag", HFILL }},
{&hf_assoc_id,
{"Association ID","wlan.aid",FT_UINT16, BASE_DEC,NULL,0,
"Association-ID field" }},
"Association-ID field", HFILL }},
{&hf_did_duration,
{"Duration", "wlan.duration", FT_UINT16, BASE_DEC, NULL, 0,
"Duration field"}},
"Duration field", HFILL }},
{&hf_addr_da,
{"Destination address", "wlan.da", FT_ETHER, BASE_NONE, NULL, 0,
"Destination Hardware address"}},
"Destination Hardware address", HFILL }},
{&hf_addr_sa,
{"Source address", "wlan.sa", FT_ETHER, BASE_NONE, NULL, 0,
"Source Hardware address"}},
"Source Hardware address", HFILL }},
{&hf_addr_ra,
{"Receiver address", "wlan.ra", FT_ETHER, BASE_NONE, NULL, 0,
"Receiving Station Hardware Address"}},
"Receiving Station Hardware Address", HFILL }},
{&hf_addr_ta,
{"Transmitter address", "wlan.ta", FT_ETHER, BASE_NONE, NULL, 0,
"Transmitting Station Hardware Address"}},
"Transmitting Station Hardware Address", HFILL }},
{&hf_addr_bssid,
{"BSS Id", "wlan.bssid", FT_ETHER, BASE_NONE, NULL, 0,
"Basic Service Set ID"}},
"Basic Service Set ID", HFILL }},
{&hf_frag_number,
{"Fragment number", "wlan.frag", FT_UINT16, BASE_HEX, NULL, 0,
"Fragment number"}},
"Fragment number", HFILL }},
{&hf_seq_number,
{"Sequence number", "wlan.seq", FT_UINT16, BASE_HEX, NULL, 0,
"Fragment number"}},
"Fragment number", HFILL }},
{&hf_fcs,
{"Frame Check Sequence (not verified)", "wlan.fcs", FT_UINT32, BASE_HEX,
NULL, 0, ""}},
NULL, 0, "", HFILL }},
{&ff_timestamp,
{"Timestamp", "wlan.fixed.timestamp", FT_STRING, BASE_NONE,
NULL, 0, ""}},
NULL, 0, "", HFILL }},
{&ff_auth_alg,
{"Authentication Algorithm", "wlan.fixed.auth.alg",
FT_UINT16, BASE_DEC, VALS (&auth_alg), 0, ""}},
FT_UINT16, BASE_DEC, VALS (&auth_alg), 0, "", HFILL }},
{&ff_beacon_interval,
{"Beacon Interval", "wlan.fixed.beacon", FT_DOUBLE, BASE_DEC, NULL, 0,
""}},
"", HFILL }},
{&hf_fixed_parameters,
{"Fixed parameters", "wlan.fixed.all", FT_UINT16, BASE_DEC, NULL, 0,
""}},
"", HFILL }},
{&hf_tagged_parameters,
{"Tagged parameters", "wlan.tagged.all", FT_UINT16, BASE_DEC, NULL, 0,
""}},
"", HFILL }},
{&hf_wep_parameters,
{"WEP parameters", "wlan.wep.all", FT_STRING, BASE_NONE, NULL, 0,
""}},
"", HFILL }},
{&hf_wep_iv,
{"Initialization Vector", "wlan.wep.iv", FT_UINT32, BASE_HEX, NULL, 0,
"Initialization Vector"}},
"Initialization Vector", HFILL }},
{&hf_wep_key,
{"Key", "wlan.wep.key", FT_UINT32, BASE_DEC, NULL, 0,
"Key"}},
"Key", HFILL }},
{&hf_wep_crc,
{"WEP CRC (not verified)", "wlan.wep.crc", FT_UINT32, BASE_HEX, NULL, 0,
"WEP CRC"}},
"WEP CRC", HFILL }},
{&ff_capture,
{"Capabilities", "wlan.fixed.capabilities", FT_UINT16, BASE_HEX, NULL, 0,
"Capability information"}},
"Capability information", HFILL }},
{&ff_cf_sta_poll,
{"CFP participation capabilities", "wlan.fixed.capabilities.cfpoll.sta",
FT_UINT16, BASE_HEX, VALS (&sta_cf_pollable), 0,
"CF-Poll capabilities for a STA"}},
"CF-Poll capabilities for a STA", HFILL }},
{&ff_cf_ap_poll,
{"CFP participation capabilities", "wlan.fixed.capabilities.cfpoll.ap",
FT_UINT16, BASE_HEX, VALS (&ap_cf_pollable), 0,
"CF-Poll capabilities for an AP"}},
"CF-Poll capabilities for an AP", HFILL }},
{&ff_cf_ess,
{"ESS capabilities", "wlan.fixed.capabilities.ess",
FT_BOOLEAN, 8, TFS (&cf_ess_flags), 0x0001, "ESS capabilities"}},
FT_BOOLEAN, 8, TFS (&cf_ess_flags), 0x0001, "ESS capabilities", HFILL }},
{&ff_cf_ibss,
{"IBSS status", "wlan.fixed.capabilities.ibss",
FT_BOOLEAN, 8, TFS (&cf_ibss_flags), 0x0002, "IBSS participation"}},
FT_BOOLEAN, 8, TFS (&cf_ibss_flags), 0x0002, "IBSS participation", HFILL }},
{&ff_cf_privacy,
{"Privacy", "wlan.fixed.capabilities.privacy",
FT_BOOLEAN, 8, TFS (&cf_privacy_flags), 0x0010, "WEP support"}},
FT_BOOLEAN, 8, TFS (&cf_privacy_flags), 0x0010, "WEP support", HFILL }},
{&ff_cf_preamble,
{"Short Preamble", "wlan.fixed.capabilities.preamble",
FT_BOOLEAN, 8, TFS (&cf_preamble_flags), 0x0020, "Short Preamble"}},
FT_BOOLEAN, 8, TFS (&cf_preamble_flags), 0x0020, "Short Preamble", HFILL }},
{&ff_cf_pbcc,
{"PBCC", "wlan.fixed.capabilities.pbcc",
FT_BOOLEAN, 8, TFS (&cf_pbcc_flags), 0x0040, "PBCC Modulation"}},
FT_BOOLEAN, 8, TFS (&cf_pbcc_flags), 0x0040, "PBCC Modulation", HFILL }},
{&ff_cf_agility,
{"Channel Agility", "wlan.fixed.capabilities.agility",
FT_BOOLEAN, 8, TFS (&cf_agility_flags), 0x0080, "Channel Agility"}},
FT_BOOLEAN, 8, TFS (&cf_agility_flags), 0x0080, "Channel Agility", HFILL }},
{&ff_auth_seq,
{"Authentication SEQ", "wlan.fixed.auth_seq",
FT_UINT16, BASE_HEX, NULL, 0, "Authentication sequence number"}},
FT_UINT16, BASE_HEX, NULL, 0, "Authentication sequence number", HFILL }},
{&ff_assoc_id,
{"Association ID", "wlan.fixed.aid",
FT_UINT16, BASE_HEX, NULL, 0, "Association ID"}},
FT_UINT16, BASE_HEX, NULL, 0, "Association ID", HFILL }},
{&ff_listen_ival,
{"Listen Interval", "wlan.fixed.listen_ival",
FT_UINT16, BASE_HEX, NULL, 0, "Listen Interval"}},
FT_UINT16, BASE_HEX, NULL, 0, "Listen Interval", HFILL }},
{&ff_current_ap,
{"Current AP", "wlan.fixed.current_ap",
FT_ETHER, BASE_NONE, NULL, 0, "MAC address of current AP"}},
FT_ETHER, BASE_NONE, NULL, 0, "MAC address of current AP", HFILL }},
{&ff_reason,
{"Reason code", "wlan.fixed.reason_code",
FT_UINT16, BASE_HEX, VALS (&reason_codes), 0,
"Reason for unsolicited notification"}},
"Reason for unsolicited notification", HFILL }},
{&ff_status_code,
{"Status code", "wlan.fixed.status_code",
FT_UINT16, BASE_HEX, VALS (&status_codes), 0,
"Status of requested event"}},
"Status of requested event", HFILL }},
{&tag_number,
{"Tag", "wlan.tag.number",
FT_UINT16, BASE_DEC, NULL, 0,
"Element ID"}},
"Element ID", HFILL }},
{&tag_length,
{"Tag length", "wlan.tag.length",
FT_UINT16, BASE_DEC, NULL, 0, "Length of tag"}},
FT_UINT16, BASE_DEC, NULL, 0, "Length of tag", HFILL }},
{&tag_interpretation,
{"Tag interpretation", "wlan.tag.interpretation",
FT_STRING, BASE_NONE, NULL, 0, "Interpretation of tag"}}
FT_STRING, BASE_NONE, NULL, 0, "Interpretation of tag", HFILL }}
};

46
packet-igmp.c
View File

@ -1,7 +1,7 @@
/* packet-igmp.c 2001 Ronnie Sahlberg <rsahlber@bigpond.net.au>
* Routines for IGMP packet disassembly
*
* $Id: packet-igmp.c,v 1.4 2001/06/12 06:21:55 guy Exp $
* $Id: packet-igmp.c,v 1.5 2001/06/18 02:17:47 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -672,91 +672,91 @@ proto_register_igmp(void)
static hf_register_info hf[] = {
{ &hf_type,
{ "Type", "igmp.type", FT_UINT8, BASE_HEX,
VALS(commands), 0, "IGMP Packet Type" }},
VALS(commands), 0, "IGMP Packet Type", HFILL }},
{ &hf_version,
{ "IGMP Version", "igmp.version", FT_UINT8, BASE_DEC,
NULL, 0, "IGMP Version" }},
NULL, 0, "IGMP Version", HFILL }},
{ &hf_group_type,
{ "Type Of Group", "igmp.group_type", FT_UINT8, BASE_DEC,
VALS(vs_group_type), 0, "IGMP V0 Type Of Group" }},
VALS(vs_group_type), 0, "IGMP V0 Type Of Group", HFILL }},
{ &hf_reply_code,
{ "Reply", "igmp.reply", FT_UINT8, BASE_DEC,
VALS(vs_reply_code), 0, "IGMP V0 Reply" }},
VALS(vs_reply_code), 0, "IGMP V0 Reply", HFILL }},
{ &hf_reply_pending,
{ "Reply Pending", "igmp.reply.pending", FT_UINT8, BASE_DEC,
NULL, 0, "IGMP V0 Reply Pending, Retry in this many seconds" }},
NULL, 0, "IGMP V0 Reply Pending, Retry in this many seconds", HFILL }},
{ &hf_checksum,
{ "Checksum", "igmp.checksum", FT_UINT16, BASE_HEX,
NULL, 0, "IGMP Checksum" }},
NULL, 0, "IGMP Checksum", HFILL }},
{ &hf_checksum_bad,
{ "Bad Checksum", "igmp.checksum_bad", FT_BOOLEAN, BASE_NONE,
NULL, 0, "Bad IGMP Checksum" }},
NULL, 0, "Bad IGMP Checksum", HFILL }},
{ &hf_identifier,
{ "Identifier", "igmp.identifier", FT_UINT32, BASE_DEC,
NULL, 0, "IGMP V0 Identifier" }},
NULL, 0, "IGMP V0 Identifier", HFILL }},
{ &hf_access_key,
{ "Access Key", "igmp.access_key", FT_BYTES, BASE_HEX,
NULL, 0, "IGMP V0 Access Key" }},
NULL, 0, "IGMP V0 Access Key", HFILL }},
{ &hf_max_resp,
{ "Max Resp Time", "igmp.max_resp", FT_UINT8, BASE_DEC,
NULL, 0, "Max Response Time" }},
NULL, 0, "Max Response Time", HFILL }},
{ &hf_supress,
{ "S", "igmp.s", FT_BOOLEAN, 8,
TFS(&tfs_s), IGMP_V3_S, "Supress Router Side Processing" }},
TFS(&tfs_s), IGMP_V3_S, "Supress Router Side Processing", HFILL }},
{ &hf_qrv,
{ "QRV", "igmp.qrv", FT_UINT8, BASE_DEC,
NULL, IGMP_V3_QRV_MASK, "Querier's Robustness Value"}},
NULL, IGMP_V3_QRV_MASK, "Querier's Robustness Value", HFILL }},
{ &hf_qqic,
{ "QQIC", "igmp.qqic", FT_UINT8, BASE_DEC,
NULL, 0, "Querier's Query Interval Code" }},
NULL, 0, "Querier's Query Interval Code", HFILL }},
{ &hf_num_src,
{ "Num Src", "igmp.num_src", FT_UINT16, BASE_DEC,
NULL, 0, "Number Of Sources" }},
NULL, 0, "Number Of Sources", HFILL }},
{ &hf_saddr,
{ "Source Address", "igmp.saddr", FT_IPv4, BASE_NONE,
NULL, 0, "Source Address" }},
NULL, 0, "Source Address", HFILL }},
{ &hf_num_grp_recs,
{ "Num Group Records", "igmp.num_grp_recs", FT_UINT16, BASE_DEC,
NULL, 0, "Number Of Group Records" }},
NULL, 0, "Number Of Group Records", HFILL }},
{ &hf_record_type,
{ "Record Type", "igmp.record_type", FT_UINT8, BASE_DEC,
VALS(vs_record_type), 0, "Record Type"}},
VALS(vs_record_type), 0, "Record Type", HFILL }},
{ &hf_aux_data_len,
{ "Aux Data Len", "igmp.aux_data_len", FT_UINT8, BASE_DEC,
NULL, 0, "Aux Data Len, In units of 32bit words"}},
NULL, 0, "Aux Data Len, In units of 32bit words", HFILL }},
{ &hf_maddr,
{ "Multicast Address", "igmp.maddr", FT_IPv4, BASE_NONE,
NULL, 0, "Multicast Address" }},
NULL, 0, "Multicast Address", HFILL }},
{ &hf_aux_data,
{ "Aux Data", "igmp.aux_data", FT_BYTES, BASE_HEX,
NULL, 0, "IGMP V3 Auxiliary Data" }},
NULL, 0, "IGMP V3 Auxiliary Data", HFILL }},
{ &hf_max_resp_exp,
{ "Exponent", "igmp.max_resp.exp", FT_UINT8, BASE_HEX,
NULL, IGMP_MAX_RESP_EXP, "Maxmimum Response Time, Exponent"}},
NULL, IGMP_MAX_RESP_EXP, "Maxmimum Response Time, Exponent", HFILL }},
{ &hf_max_resp_mant,
{ "Mantissa", "igmp.max_resp.mant", FT_UINT8, BASE_HEX,
NULL, IGMP_MAX_RESP_MANT, "Maxmimum Response Time, Mantissa"}},
NULL, IGMP_MAX_RESP_MANT, "Maxmimum Response Time, Mantissa", HFILL }},
};
static gint *ett[] = {

6
packet-igrp.c
View File

@ -2,7 +2,7 @@
* Routines for IGRP dissection
* Copyright 2000, Paul Ionescu <paul@acorp.ro>
*
* $Id: packet-igrp.c,v 1.7 2001/04/23 17:51:33 guy Exp $
* $Id: packet-igrp.c,v 1.8 2001/06/18 02:17:47 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -177,12 +177,12 @@ void proto_register_igrp(void)
{ &hf_igrp_update,
{ "Update Release", "igrp.update",
FT_UINT8, BASE_DEC, NULL, 0x0 ,
"Update Release number" },
"Update Release number", HFILL }
},
{ &hf_igrp_as,
{ "Autonomous System", "igrp.as",
FT_UINT16, BASE_DEC, NULL, 0x0 ,
"Autonomous System number" }
"Autonomous System number", HFILL }
}
};

6
packet-imap.c
View File

@ -2,7 +2,7 @@
* Routines for imap packet dissection
* Copyright 1999, Richard Sharpe <rsharpe@ns.aus.com>
*
* $Id: packet-imap.c,v 1.14 2001/01/22 08:03:45 guy Exp $
* $Id: packet-imap.c,v 1.15 2001/06/18 02:17:47 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -162,12 +162,12 @@ proto_register_imap(void)
{ &hf_imap_response,
{ "Response", "imap.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if IMAP response" }},
"TRUE if IMAP response", HFILL }},
{ &hf_imap_request,
{ "Request", "imap.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if IMAP request" }}
"TRUE if IMAP request", HFILL }}
};
static gint *ett[] = {
&ett_imap,

74
packet-ip.c
View File

@ -1,7 +1,7 @@
/* packet-ip.c
* Routines for IP and miscellaneous IP protocol packet disassembly
*
* $Id: packet-ip.c,v 1.136 2001/06/08 08:29:15 guy Exp $
* $Id: packet-ip.c,v 1.137 2001/06/18 02:17:47 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -1409,139 +1409,139 @@ proto_register_ip(void)
{ &hf_ip_version,
{ "Version", "ip.version", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_hdr_len,
{ "Header Length", "ip.hdr_len", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_dsfield,
{ "Differentiated Services field", "ip.dsfield", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_dsfield_dscp,
{ "Differentiated Services Codepoint", "ip.dsfield.dscp", FT_UINT8, BASE_HEX,
VALS(dscp_vals), IPDSFIELD_DSCP_MASK,
"" }},
"", HFILL }},
{ &hf_ip_dsfield_ect,
{ "ECN-Capable Transport (ECT)", "ip.dsfield.ect", FT_UINT8, BASE_DEC, NULL,
IPDSFIELD_ECT_MASK,
"" }},
"", HFILL }},
{ &hf_ip_dsfield_ce,
{ "ECN-CE", "ip.dsfield.ce", FT_UINT8, BASE_DEC, NULL,
IPDSFIELD_CE_MASK,
"" }},
"", HFILL }},
{ &hf_ip_tos,
{ "Type of Service", "ip.tos", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_tos_precedence,
{ "Precedence", "ip.tos.precedence", FT_UINT8, BASE_DEC, VALS(precedence_vals),
IPTOS_PREC_MASK,
"" }},
"", HFILL }},
{ &hf_ip_tos_delay,
{ "Delay", "ip.tos.delay", FT_BOOLEAN, 8, TFS(&tos_set_low),
IPTOS_LOWDELAY,
"" }},
"", HFILL }},
{ &hf_ip_tos_throughput,
{ "Throughput", "ip.tos.throughput", FT_BOOLEAN, 8, TFS(&tos_set_high),
IPTOS_THROUGHPUT,
"" }},
"", HFILL }},
{ &hf_ip_tos_reliability,
{ "Reliability", "ip.tos.reliability", FT_BOOLEAN, 8, TFS(&tos_set_high),
IPTOS_RELIABILITY,
"" }},
"", HFILL }},
{ &hf_ip_tos_cost,
{ "Cost", "ip.tos.cost", FT_BOOLEAN, 8, TFS(&tos_set_low),
IPTOS_LOWCOST,
"" }},
"", HFILL }},
{ &hf_ip_len,
{ "Total Length", "ip.len", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_id,
{ "Identification", "ip.id", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_dst,
{ "Destination", "ip.dst", FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_src,
{ "Source", "ip.src", FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_addr,
{ "Source or Destination Address", "ip.addr", FT_IPv4, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_flags,
{ "Flags", "ip.flags", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_flags_df,
{ "Don't fragment", "ip.flags.df", FT_BOOLEAN, 4, TFS(&flags_set_truth), IP_DF>>12,
"" }},
"", HFILL }},
{ &hf_ip_flags_mf,
{ "More fragments", "ip.flags.mf", FT_BOOLEAN, 4, TFS(&flags_set_truth), IP_MF>>12,
"" }},
"", HFILL }},
{ &hf_ip_frag_offset,
{ "Fragment offset", "ip.frag_offset", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_ttl,
{ "Time to live", "ip.ttl", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_proto,
{ "Protocol", "ip.proto", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_checksum,
{ "Header checksum", "ip.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_checksum_bad,
{ "Bad Header checksum", "ip.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ip_fragment_overlap,
{ "Fragment overlap", "ip.fragment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Fragment overlaps with other fragments" }},
"Fragment overlaps with other fragments", HFILL }},
{ &hf_ip_fragment_overlap_conflict,
{ "Conflicting data in fragment overlap", "ip.fragment.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Overlapping fragments contained conflicting data" }},
"Overlapping fragments contained conflicting data", HFILL }},
{ &hf_ip_fragment_multiple_tails,
{ "Multiple tail fragments found", "ip.fragment.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Several tails were found when defragmenting the packet" }},
"Several tails were found when defragmenting the packet", HFILL }},
{ &hf_ip_fragment_too_long_fragment,
{ "Fragment too long", "ip.fragment.toolongfragment", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Fragment contained data past end of packet" }},
"Fragment contained data past end of packet", HFILL }},
{ &hf_ip_fragment_error,
{ "Defragmentation error", "ip.fragment.error", FT_NONE, BASE_NONE, NULL, 0x0,
"Defragmentation error due to illegal fragments" }},
"Defragmentation error due to illegal fragments", HFILL }},
{ &hf_ip_fragment,
{ "IP Fragment", "ip.fragment", FT_NONE, BASE_NONE, NULL, 0x0,
"IP Fragment" }},
"IP Fragment", HFILL }},
{ &hf_ip_fragments,
{ "IP Fragments", "ip.fragments", FT_NONE, BASE_NONE, NULL, 0x0,
"IP Fragments" }},
"IP Fragments", HFILL }},
};
static gint *ett[] = {
&ett_ip,
@ -1605,19 +1605,19 @@ proto_register_icmp(void)
{ &hf_icmp_type,
{ "Type", "icmp.type", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_icmp_code,
{ "Code", "icmp.code", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_icmp_checksum,
{ "Checksum", "icmp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_icmp_checksum_bad,
{ "Bad Checksum", "icmp.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
};
static gint *ett[] = {
&ett_icmp,

14
packet-ipsec.c
View File

@ -1,7 +1,7 @@
/* packet-ipsec.c
* Routines for IPsec/IPComp packet disassembly
*
* $Id: packet-ipsec.c,v 1.29 2001/04/23 03:37:31 guy Exp $
* $Id: packet-ipsec.c,v 1.30 2001/06/18 02:17:47 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -291,28 +291,28 @@ proto_register_ipsec(void)
static hf_register_info hf_ah[] = {
{ &hf_ah_spi,
{ "SPI", "ah.spi", FT_UINT32, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ah_sequence,
{ "Sequence", "ah.sequence", FT_UINT32, BASE_HEX, NULL, 0x0,
"" }}
"", HFILL }}
};
static hf_register_info hf_esp[] = {
{ &hf_esp_spi,
{ "SPI", "esp.spi", FT_UINT32, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_esp_sequence,
{ "Sequence", "esp.sequence", FT_UINT32, BASE_HEX, NULL, 0x0,
"" }}
"", HFILL }}
};
static hf_register_info hf_ipcomp[] = {
{ &hf_ipcomp_flags,
{ "Flags", "ipcomp.flags", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipcomp_cpi,
{ "CPI", "ipcomp.cpi", FT_UINT16, BASE_HEX,
VALS(cpi2val), 0x0, "" }},
VALS(cpi2val), 0x0, "", HFILL }},
};
static gint *ett[] = {
&ett_ah,

72
packet-ipv6.c
View File

@ -1,7 +1,7 @@
/* packet-ipv6.c
* Routines for IPv6 packet disassembly
*
* $Id: packet-ipv6.c,v 1.58 2001/06/08 08:30:42 guy Exp $
* $Id: packet-ipv6.c,v 1.59 2001/06/18 02:17:47 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -984,155 +984,155 @@ proto_register_ipv6(void)
static hf_register_info hf[] = {
{ &hf_ipv6_version,
{ "Version", "ipv6.version",
FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_ipv6_class,
{ "Traffic class", "ipv6.class",
FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_ipv6_flow,
{ "Flowlabel", "ipv6.flow",
FT_UINT32, BASE_HEX, NULL, 0x0, "" }},
FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_ipv6_plen,
{ "Payload length", "ipv6.plen",
FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_ipv6_nxt,
{ "Next header", "ipv6.nxt",
FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_ipv6_hlim,
{ "Hop limit", "ipv6.hlim",
FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_ipv6_src,
{ "Source", "ipv6.src",
FT_IPv6, BASE_NONE, NULL, 0x0,
"Source IPv6 Address" }},
"Source IPv6 Address", HFILL }},
{ &hf_ipv6_dst,
{ "Destination", "ipv6.dst",
FT_IPv6, BASE_NONE, NULL, 0x0,
"Destination IPv6 Address" }},
"Destination IPv6 Address", HFILL }},
{ &hf_ipv6_addr,
{ "Address", "ipv6.addr",
FT_IPv6, BASE_NONE, NULL, 0x0,
"Source or Destination IPv6 Address" }},
"Source or Destination IPv6 Address", HFILL }},
{ &hf_ipv6_fragment_overlap,
{ "Fragment overlap", "ipv6.fragment.overlap",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Fragment overlaps with other fragments" }},
"Fragment overlaps with other fragments", HFILL }},
{ &hf_ipv6_fragment_overlap_conflict,
{ "Conflicting data in fragment overlap", "ipv6.fragment.overlap.conflict",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Overlapping fragments contained conflicting data" }},
"Overlapping fragments contained conflicting data", HFILL }},
{ &hf_ipv6_fragment_multiple_tails,
{ "Multiple tail fragments found", "ipv6.fragment.multipletails",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Several tails were found when defragmenting the packet" }},
"Several tails were found when defragmenting the packet", HFILL }},
{ &hf_ipv6_fragment_too_long_fragment,
{ "Fragment too long", "ipv6.fragment.toolongfragment",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"Fragment contained data past end of packet" }},
"Fragment contained data past end of packet", HFILL }},
{ &hf_ipv6_fragment_error,
{ "Defragmentation error", "ipv6.fragment.error",
FT_NONE, BASE_NONE, NULL, 0x0,
"Defragmentation error due to illegal fragments" }},
"Defragmentation error due to illegal fragments", HFILL }},
{ &hf_ipv6_fragment,
{ "IPv6 Fragment", "ipv6.fragment",
FT_NONE, BASE_NONE, NULL, 0x0,
"IPv6 Fragment" }},
"IPv6 Fragment", HFILL }},
{ &hf_ipv6_fragments,
{ "IPv6 Fragments", "ipv6.fragments",
FT_NONE, BASE_NONE, NULL, 0x0,
"IPv6 Fragments" }},
"IPv6 Fragments", HFILL }},
/* BT INSERT BEGIN */
{ &hf_ipv6_mipv6_type,
{ "Option Type ", "ipv6.mipv6_type",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_length,
{ "Option Length ", "ipv6.mipv6_length",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_a_flag,
{ "Acknowledge (A) ", "ipv6.mipv6_a_flag",
FT_BOOLEAN, 8, TFS(&ipv6_mipv6_bu_a_flag_value),
IP6_MIPv6_BU_A_FLAG,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_h_flag,
{ "Home Registration (H) ", "ipv6.mipv6_h_flag",
FT_BOOLEAN, 8, TFS(&ipv6_mipv6_bu_h_flag_value),
IP6_MIPv6_BU_H_FLAG,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_r_flag,
{ "Router (R) ", "ipv6.mipv6_r_flag",
FT_BOOLEAN, 8, TFS(&ipv6_mipv6_bu_r_flag_value),
IP6_MIPv6_BU_R_FLAG,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_d_flag,
{ "Duplicate Address Detection (D) ", "ipv6.mipv6_d_flag",
FT_BOOLEAN, 8, TFS(&ipv6_mipv6_bu_d_flag_value),
IP6_MIPv6_BU_D_FLAG,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_m_flag,
{ "MAP Registration (M) ", "ipv6.mipv6_m_flag",
FT_BOOLEAN, 8, TFS(&ipv6_mipv6_bu_m_flag_value),
IP6_MIPv6_BU_M_FLAG,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_b_flag,
{ "Bicasting all (B) ", "ipv6.mipv6_b_flag",
FT_BOOLEAN, 8, TFS(&ipv6_mipv6_bu_b_flag_value),
IP6_MIPv6_BU_B_FLAG,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_prefix_length,
{ "Prefix Length ", "ipv6.mipv6_prefix_length",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_sequence_number,
{ "Sequence Number ", "ipv6.mipv6_sequence_number",
FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_life_time,
{ "Life Time ", "ipv6.mipv6_life_time",
FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_status,
{ "Status ", "ipv6.mipv6_status",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_refresh,
{ "Refresh ", "ipv6.mipv6_refresh",
FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_home_address,
{ "Home Address ", "ipv6.mipv6_home_address",
FT_IPv6, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_sub_type,
{ "Sub-Option Type ", "ipv6.mipv6_sub_type",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_sub_length,
{ "Sub-Option Length ", "ipv6.mipv6_sub_length",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_sub_unique_ID,
{ "Unique Identifier ", "ipv6.mipv6_sub_unique_ID",
FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipv6_mipv6_sub_alternative_COA,
{ "Alternative Care of Address ", "ipv6.mipv6_sub_alternative_COA",
FT_IPv6, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
/* BT INSERT END */
#ifdef TEST_FINALHDR
{ &hf_ipv6_final,
{ "Final next header", "ipv6.final",
FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
#endif
};
static gint *ett[] = {

48
packet-ipx.c
View File

@ -2,7 +2,7 @@
* Routines for NetWare's IPX
* Gilbert Ramirez <gram@xiexie.org>
*
* $Id: packet-ipx.c,v 1.85 2001/05/03 22:50:33 guy Exp $
* $Id: packet-ipx.c,v 1.86 2001/06/18 02:17:47 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -662,117 +662,117 @@ proto_register_ipx(void)
static hf_register_info hf_ipx[] = {
{ &hf_ipx_checksum,
{ "Checksum", "ipx.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipx_len,
{ "Length", "ipx.len", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipx_hops,
{ "Transport Control (Hops)", "ipx.hops", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipx_packet_type,
{ "Packet Type", "ipx.packet_type", FT_UINT8, BASE_HEX, VALS(ipx_packet_type_vals),
0x0,
"" }},
"", HFILL }},
{ &hf_ipx_dnet,
{ "Destination Network","ipx.dst.net", FT_IPXNET, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipx_dnode,
{ "Destination Node", "ipx.dst.node", FT_ETHER, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipx_dsocket,
{ "Destination Socket", "ipx.dst.socket", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipx_snet,
{ "Source Network","ipx.src.net", FT_IPXNET, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipx_snode,
{ "Source Node", "ipx.src.node", FT_ETHER, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ipx_ssocket,
{ "Source Socket", "ipx.src.socket", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
};
static hf_register_info hf_spx[] = {
{ &hf_spx_connection_control,
{ "Connection Control", "spx.ctl",
FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_spx_datastream_type,
{ "Datastream type", "spx.type",
FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_spx_src_id,
{ "Source Connection ID", "spx.src",
FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_spx_dst_id,
{ "Destination Connection ID", "spx.dst",
FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_spx_seq_nr,
{ "Sequence Number", "spx.seq",
FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_spx_ack_nr,
{ "Acknowledgment Number", "spx.ack",
FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_spx_all_nr,
{ "Allocation Number", "spx.alloc",
FT_UINT16, BASE_DEC, NULL, 0x0,
"" }}
"", HFILL }}
};
static hf_register_info hf_ipxrip[] = {
{ &hf_ipxrip_request,
{ "Request", "ipxrip.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if IPX RIP request" }},
"TRUE if IPX RIP request", HFILL }},
{ &hf_ipxrip_response,
{ "Response", "ipxrip.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if IPX RIP response" }}
"TRUE if IPX RIP response", HFILL }}
};
static hf_register_info hf_sap[] = {
{ &hf_sap_request,
{ "Request", "ipxsap.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if SAP request" }},
"TRUE if SAP request", HFILL }},
{ &hf_sap_response,
{ "Response", "ipxsap.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if SAP response" }}
"TRUE if SAP response", HFILL }}
};
static hf_register_info hf_ipxmsg[] = {
{ &hf_msg_conn,
{ "Connection Number", "ipxmsg.conn",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Connection Number" }},
"Connection Number", HFILL }},
{ &hf_msg_sigchar,
{ "Signature Char", "ipxmsg.sigchar",
FT_UINT8, BASE_DEC, VALS(ipxmsg_sigchar_vals), 0x0,
"Signature Char" }}
"Signature Char", HFILL }}
};
static gint *ett[] = {

8
packet-irc.c
View File

@ -1,7 +1,7 @@
/* packet-irc.c
* Routines for IRC packet dissection
*
* $Id: packet-irc.c,v 1.13 2001/02/03 08:07:04 guy Exp $
* $Id: packet-irc.c,v 1.14 2001/06/18 02:17:47 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -140,17 +140,17 @@ proto_register_irc(void)
{ &hf_irc_response,
{ "Response", "irc.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if IRC response" }},
"TRUE if IRC response", HFILL }},
{ &hf_irc_request,
{ "Request", "irc.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if IRC request" }},
"TRUE if IRC request", HFILL }},
{ &hf_irc_command,
{ "Command", "irc.command",
FT_STRING, BASE_NONE, NULL, 0x0,
"Command associated with request" }}
"Command associated with request", HFILL }}
};
static gint *ett[] = {

176
packet-iscsi.c
View File

@ -5,7 +5,7 @@
* Conforms to the protocol described in: draft-ietf-ips-iscsi-06.txt
* Optionally, supports the protocol described in: draft-ietf-ips-iscsi-03.txt
*
* $Id: packet-iscsi.c,v 1.5 2001/06/04 05:32:52 guy Exp $
* $Id: packet-iscsi.c,v 1.6 2001/06/18 02:17:47 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -1236,439 +1236,439 @@ proto_register_iscsi(void)
{ &hf_iscsi_Payload,
{ "Payload", "iscsi.payload",
FT_BYTES, BASE_HEX, NULL, 0,
"Payload (includes any header digest)" }
"Payload (includes any header digest)", HFILL }
},
{ &hf_iscsi_Opcode,
{ "Opcode", "iscsi.opcode",
FT_UINT8, BASE_HEX, VALS(iscsi_opcodes), 0,
"Opcode" }
"Opcode", HFILL }
},
{ &hf_iscsi_Opcode_03,
{ "Opcode", "iscsi.opcode",
FT_UINT8, BASE_HEX, VALS(iscsi_opcodes_03), 0,
"Opcode" }
"Opcode", HFILL }
},
#if 0
{ &hf_iscsi_X,
{ "X", "iscsi.x",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_X), 0x80,
"Command Retry" }
"Command Retry", HFILL }
},
{ &hf_iscsi_I,
{ "I", "iscsi.i",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_I), 0x40,
"Immediate delivery" }
"Immediate delivery", HFILL }
},
#endif
{ &hf_iscsi_Flags,
{ "Flags", "iscsi.flags",
FT_UINT8, BASE_HEX, NULL, 0,
"Opcode specific flags" }
"Opcode specific flags", HFILL }
},
{ &hf_iscsi_SCSICommand_X03,
{ "X", "iscsi.scsicommand.x",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_X), 0x80,
"Command Retry" }
"Command Retry", HFILL }
},
{ &hf_iscsi_SCSICommand_F,
{ "F", "iscsi.scsicommand.f",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_F), 0x80,
"PDU completes command" }
"PDU completes command", HFILL }
},
{ &hf_iscsi_SCSICommand_R,
{ "R", "iscsi.scsicommand.r",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_R), 0x40,
"Command reads from SCSI target" }
"Command reads from SCSI target", HFILL }
},
{ &hf_iscsi_SCSICommand_W,
{ "W", "iscsi.scsicommand.r",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_W), 0x20,
"Command writes to SCSI target" }
"Command writes to SCSI target", HFILL }
},
{ &hf_iscsi_SCSICommand_Attr,
{ "Attr", "iscsi.scsicommand.attr",
FT_UINT8, BASE_HEX, VALS(iscsi_scsicommand_taskattrs), 0x07,
"SCSI task attributes" }
"SCSI task attributes", HFILL }
},
{ &hf_iscsi_SCSICommand_CRN,
{ "CRN", "iscsi.scsicommand.crn",
FT_UINT8, BASE_HEX, NULL, 0,
"SCSI command reference number" }
"SCSI command reference number", HFILL }
},
{ &hf_iscsi_SCSICommand_AddCDB,
{ "AddCDB", "iscsi.scsicommand.addcdb",
FT_UINT8, BASE_HEX, NULL, 0,
"Additional CDB length (in 4 byte units)" }
"Additional CDB length (in 4 byte units)", HFILL }
},
{ &hf_iscsi_Length03,
{ "Length", "iscsi.length",
FT_UINT32, BASE_HEX, NULL, 0,
"Data length (bytes)" }
"Data length (bytes)", HFILL }
},
{ &hf_iscsi_DataSegmentLength,
{ "DataSegmentLength", "iscsi.datasegmentlength",
FT_UINT32, BASE_HEX, NULL, 0,
"Data segment length (bytes)" }
"Data segment length (bytes)", HFILL }
},
{ &hf_iscsi_TotalAHSLength,
{ "TotalAHSLength", "iscsi.totalahslength",
FT_UINT8, BASE_HEX, NULL, 0,
"Total additional header segment length (4 byte words)" }
"Total additional header segment length (4 byte words)", HFILL }
},
{ &hf_iscsi_LUN,
{ "LUN", "iscsi.lun",
FT_BYTES, BASE_HEX, NULL, 0,
"Logical Unit Number" }
"Logical Unit Number", HFILL }
},
{ &hf_iscsi_InitiatorTaskTag,
{ "InitiatorTaskTag", "iscsi.initiatortasktag",
FT_UINT32, BASE_HEX, NULL, 0,
"Initiator's task tag" }
"Initiator's task tag", HFILL }
},
{ &hf_iscsi_ExpectedDataTransferLength,
{ "ExpectedDataTransferLength", "iscsi.scsicommand.expecteddatatransferlength",
FT_UINT32, BASE_HEX, NULL, 0,
"Expected length of data transfer" }
"Expected length of data transfer", HFILL }
},
{ &hf_iscsi_CmdSN,
{ "CmdSN", "iscsi.cmdsn",
FT_UINT32, BASE_HEX, NULL, 0,
"Sequence number for this command (0 == immediate)" }
"Sequence number for this command (0 == immediate)", HFILL }
},
{ &hf_iscsi_ExpStatSN,
{ "ExpStatSN", "iscsi.expstatsn",
FT_UINT32, BASE_HEX, NULL, 0,
"Next expected status sequence number" }
"Next expected status sequence number", HFILL }
},
{ &hf_iscsi_SCSICommand_CDB,
{ "CDB", "iscsi.scsicommand.cdb",
FT_BYTES, BASE_HEX, NULL, 0,
"SCSI CDB" }
"SCSI CDB", HFILL }
},
{ &hf_iscsi_SCSICommand_CDB0,
{ "CDB", "iscsi.scsicommand.cdb0",
FT_UINT8, BASE_HEX, VALS(iscsi_scsi_cdb0), 0,
"SCSI CDB[0]" }
"SCSI CDB[0]", HFILL }
},
{ &hf_iscsi_SCSIResponse_BasicResidualCount,
{ "BasicResidualCount", "iscsi.scsiresponse.basicresidualcount",
FT_UINT32, BASE_HEX, NULL, 0,
"Residual count" }
"Residual count", HFILL }
},
{ &hf_iscsi_StatSN,
{ "StatSN", "iscsi.statsn",
FT_UINT32, BASE_HEX, NULL, 0,
"Status sequence number" }
"Status sequence number", HFILL }
},
{ &hf_iscsi_ExpCmdSN,
{ "ExpCmdSN", "iscsi.expcmdsn",
FT_UINT32, BASE_HEX, NULL, 0,
"Next expected command sequence number" }
"Next expected command sequence number", HFILL }
},
{ &hf_iscsi_MaxCmdSN,
{ "MaxCmdSN", "iscsi.maxcmdsn",
FT_UINT32, BASE_HEX, NULL, 0,
"Maximum acceptable command sequence number" }
"Maximum acceptable command sequence number", HFILL }
},
{ &hf_iscsi_SCSIResponse_o03,
{ "o", "iscsi.scsiresponse.o",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_o), 0x08,
"Bi-directional read residual overflow" }
"Bi-directional read residual overflow", HFILL }
},
{ &hf_iscsi_SCSIResponse_u03,
{ "u", "iscsi.scsiresponse.u",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_u), 0x04,
"Bi-directional read residual underflow" }
"Bi-directional read residual underflow", HFILL }
},
{ &hf_iscsi_SCSIResponse_O03,
{ "O", "iscsi.scsiresponse.O",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_O), 0x02,
"Residual overflow" }
"Residual overflow", HFILL }
},
{ &hf_iscsi_SCSIResponse_U03,
{ "U", "iscsi.scsiresponse.U",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_U), 0x01,
"Residual underflow" }
"Residual underflow", HFILL }
},
{ &hf_iscsi_SCSIResponse_o,
{ "o", "iscsi.scsiresponse.o",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_o), 0x10,
"Bi-directional read residual overflow" }
"Bi-directional read residual overflow", HFILL }
},
{ &hf_iscsi_SCSIResponse_u,
{ "u", "iscsi.scsiresponse.u",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_u), 0x08,
"Bi-directional read residual underflow" }
"Bi-directional read residual underflow", HFILL }
},
{ &hf_iscsi_SCSIResponse_O,
{ "O", "iscsi.scsiresponse.O",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_O), 0x04,
"Residual overflow" }
"Residual overflow", HFILL }
},
{ &hf_iscsi_SCSIResponse_U,
{ "U", "iscsi.scsiresponse.U",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_U), 0x02,
"Residual underflow" }
"Residual underflow", HFILL }
},
{ &hf_iscsi_SCSIResponse_S,
{ "S", "iscsi.scsiresponse.S",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_scsiresponse_S), 0x01,
"Status/Response" }
"Status/Response", HFILL }
},
{ &hf_iscsi_CommandStatus03,
{ "CommandStatus", "iscsi.commandstatus",
FT_UINT8, BASE_HEX, VALS(iscsi_scsi_statuses), 0,
"SCSI command status value" }
"SCSI command status value", HFILL }
},
{ &hf_iscsi_StatusResponse_is_status,
{ "Status/Response", "iscsi.scsiresponse.statusresponse",
FT_UINT8, BASE_HEX, VALS(iscsi_scsi_statuses), 0,
"SCSI command status value" }
"SCSI command status value", HFILL }
},
{ &hf_iscsi_StatusResponse_is_response,
{ "Status/Response", "iscsi.scsiresponse.statusresponse",
FT_UINT8, BASE_HEX, VALS(iscsi_scsi_responses), 0,
"iSCSI response value" }
"iSCSI response value", HFILL }
},
{ &hf_iscsi_SCSIResponse_SenseLength,
{ "SenseLength", "iscsi.scsiresponse.senselength",
FT_UINT16, BASE_HEX, NULL, 0,
"SCSI sense data length" }
"SCSI sense data length", HFILL }
},
{ &hf_iscsi_SCSIResponse_BidiReadResidualCount,
{ "BidiReadResidualCount", "iscsi.scsiresponse.bidireadresidualcount",
FT_UINT32, BASE_HEX, NULL, 0,
"Bi-directional read residual count" }
"Bi-directional read residual count", HFILL }
},
{ &hf_iscsi_SCSIData_F,
{ "F", "iscsi.scsidata.f",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_F), 0x80,
"Final PDU" }
"Final PDU", HFILL }
},
{ &hf_iscsi_SCSIData_P03,
{ "P", "iscsi.scsidata.p",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_P), 0x80,
"Poll requested" }
"Poll requested", HFILL }
},
{ &hf_iscsi_SCSIData_S03,
{ "S", "iscsi.scsidata.s",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_S), 0x04,
"PDU Contains SCSI command status" }
"PDU Contains SCSI command status", HFILL }
},
{ &hf_iscsi_SCSIData_O03,
{ "O", "iscsi.scsidata.O",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_O), 0x02,
"Residual overflow" }
"Residual overflow", HFILL }
},
{ &hf_iscsi_SCSIData_U03,
{ "U", "iscsi.scsidata.U",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_U), 0x01,
"Residual underflow" }
"Residual underflow", HFILL }
},
{ &hf_iscsi_SCSIData_S,
{ "S", "iscsi.scsidata.s",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_S), 0x01,
"PDU Contains SCSI command status" }
"PDU Contains SCSI command status", HFILL }
},
{ &hf_iscsi_SCSIData_U,
{ "U", "iscsi.scsidata.U",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_U), 0x02,
"Residual underflow" }
"Residual underflow", HFILL }
},
{ &hf_iscsi_SCSIData_O,
{ "O", "iscsi.scsidata.O",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_O), 0x04,
"Residual overflow" }
"Residual overflow", HFILL }
},
{ &hf_iscsi_TargetTransferTag,
{ "TargetTransferTag", "iscsi.targettransfertag",
FT_UINT32, BASE_HEX, NULL, 0,
"Target transfer tag" }
"Target transfer tag", HFILL }
},
{ &hf_iscsi_BufferOffset,
{ "BufferOffset", "iscsi.bufferOffset",
FT_UINT32, BASE_HEX, NULL, 0,
"Buffer offset" }
"Buffer offset", HFILL }
},
{ &hf_iscsi_SCSIData_ResidualCount,
{ "ResidualCount", "iscsi.scsidata.readresidualcount",
FT_UINT32, BASE_HEX, NULL, 0,
"Residual count" }
"Residual count", HFILL }
},
{ &hf_iscsi_DataSN,
{ "DataSN", "iscsi.datasn",
FT_UINT32, BASE_HEX, NULL, 0,
"Data sequence number" }
"Data sequence number", HFILL }
},
{ &hf_iscsi_VersionMax,
{ "VersionMax", "iscsi.versionmax",
FT_UINT8, BASE_HEX, NULL, 0,
"Maximum supported protocol version" }
"Maximum supported protocol version", HFILL }
},
{ &hf_iscsi_VersionMin,
{ "VersionMin", "iscsi.versionmin",
FT_UINT8, BASE_HEX, NULL, 0,
"Minimum supported protocol version" }
"Minimum supported protocol version", HFILL }
},
{ &hf_iscsi_CID,
{ "CID", "iscsi.cid",
FT_UINT16, BASE_HEX, NULL, 0,
"Connection identifier" }
"Connection identifier", HFILL }
},
{ &hf_iscsi_ISID,
{ "ISID", "iscsi.isid",
FT_UINT16, BASE_HEX, NULL, 0,
"Initiator part of session identifier" }
"Initiator part of session identifier", HFILL }
},
{ &hf_iscsi_TSID,
{ "TSID", "iscsi.tsid",
FT_UINT16, BASE_HEX, NULL, 0,
"Target part of session identifier" }
"Target part of session identifier", HFILL }
},
{ &hf_iscsi_InitStatSN,
{ "InitStatSN", "iscsi.initstatsn",
FT_UINT32, BASE_HEX, NULL, 0,
"Initial status sequence number" }
"Initial status sequence number", HFILL }
},
{ &hf_iscsi_InitCmdSN,
{ "InitCmdSN", "iscsi.initcmdsn",
FT_UINT32, BASE_HEX, NULL, 0,
"Initial command sequence number" }
"Initial command sequence number", HFILL }
},
{ &hf_iscsi_Login_F,
{ "F", "iscsi.login.f",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_F), 0x80,
"Final PDU in login sequence" }
"Final PDU in login sequence", HFILL }
},
{ &hf_iscsi_Login_Status03,
{ "Status", "iscsi.login.status",
FT_UINT8, BASE_HEX, VALS(iscsi_login_status03), 0,
"Status" }
"Status", HFILL }
},
{ &hf_iscsi_Login_Status,
{ "Status", "iscsi.login.status",
FT_UINT16, BASE_HEX, VALS(iscsi_login_status), 0,
"Status class and detail" }
"Status class and detail", HFILL }
},
{ &hf_iscsi_KeyValue,
{ "KeyValue", "iscsi.keyvalue",
FT_STRING, 0, NULL, 0,
"Key/value pair" }
"Key/value pair", HFILL }
},
{ &hf_iscsi_Text_F,
{ "F", "iscsi.text.f",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_F), 0x80,
"Final PDU in text sequence" }
"Final PDU in text sequence", HFILL }
},
{ &hf_iscsi_NOP_P,
{ "P", "iscsi.nop.p",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_P), 0x80,
"Poll requested" }
"Poll requested", HFILL }
},
{ &hf_iscsi_ExpDataSN,
{ "ExpCmdSN", "iscsi.expdatasn",
FT_UINT32, BASE_HEX, NULL, 0,
"Next expected data sequence number" }
"Next expected data sequence number", HFILL }
},
{ &hf_iscsi_R2TExpDataSN,
{ "R2TExpCmdSN", "iscsi.r2texpdatasn",
FT_UINT32, BASE_HEX, NULL, 0,
"Next expected R2T data sequence number" }
"Next expected R2T data sequence number", HFILL }
},
{ &hf_iscsi_SCSITask_Response,
{ "Response", "iscsi.scsitask.response",
FT_UINT8, BASE_HEX, VALS(iscsi_task_responses), 0,
"Response" }
"Response", HFILL }
},
{ &hf_iscsi_SCSITask_ReferencedTaskTag,
{ "InitiatorTaskTag", "iscsi.scsitask.referencedtasktag",
FT_UINT32, BASE_HEX, NULL, 0,
"Task's initiator task tag" }
"Task's initiator task tag", HFILL }
},
{ &hf_iscsi_SCSITask_Function,
{ "Function", "iscsi.scsitask.function",
FT_UINT8, BASE_HEX, VALS(iscsi_task_functions), 0x7F,
"Requested task function" }
"Requested task function", HFILL }
},
{ &hf_iscsi_Logout_Reason03,
{ "Reason", "iscsi.logout.reason",
FT_UINT8, BASE_HEX, VALS(iscsi_logout_reasons03), 0,
"Reason for logout" }
"Reason for logout", HFILL }
},
{ &hf_iscsi_Logout_Reason,
{ "Reason", "iscsi.logout.reason",
FT_UINT8, BASE_HEX, VALS(iscsi_logout_reasons), 0,
"Reason for logout" }
"Reason for logout", HFILL }
},
{ &hf_iscsi_Logout_Response,
{ "Response", "iscsi.logout.response",
FT_UINT8, BASE_HEX, VALS(iscsi_logout_response), 0,
"Logout response" }
"Logout response", HFILL }
},
{ &hf_iscsi_DesiredDataLength,
{ "DesiredDataLength", "iscsi.desireddatalength",
FT_UINT32, BASE_HEX, NULL, 0,
"Desired data length (bytes)" }
"Desired data length (bytes)", HFILL }
},
{ &hf_iscsi_SCSIEvent03,
{ "SCSIEvent", "iscsi.scsievent",
FT_UINT8, BASE_HEX, VALS(iscsi_scsievents03), 0,
"SCSI event indicator" }
"SCSI event indicator", HFILL }
},
{ &hf_iscsi_iSCSIEvent03,
{ "iSCSIEvent", "iscsi.iscsievent",
FT_UINT8, BASE_HEX, VALS(iscsi_iscsievents03), 0,
"iSCSI event indicator" }
"iSCSI event indicator", HFILL }
},
{ &hf_iscsi_Parameter1,
{ "Parameter1", "iscsi.parameter1",
FT_UINT16, BASE_HEX, NULL, 0,
"Parameter 1" }
"Parameter 1", HFILL }
},
{ &hf_iscsi_Parameter2,
{ "Parameter2", "iscsi.parameter2",
FT_UINT16, BASE_HEX, NULL, 0,
"Parameter 2" }
"Parameter 2", HFILL }
},
{ &hf_iscsi_Reject_Reason,
{ "Reason", "iscsi.reject.reason",
FT_UINT8, BASE_HEX, VALS(iscsi_reject_reasons), 0,
"Reason for command rejection" }
"Reason for command rejection", HFILL }
},
{ &hf_iscsi_Reject_FirstBadByte,
{ "FirstBadByte", "iscsi.reject.firstbadbyte",
FT_UINT16, BASE_HEX, NULL, 0,
"Offset of first bad byte in PDU when reason is 'format error'" }
"Offset of first bad byte in PDU when reason is 'format error'", HFILL }
},
{ &hf_iscsi_Reject_Reason03,
{ "Reason", "iscsi.reject.reason",
FT_UINT8, BASE_HEX, VALS(iscsi_reject_reasons03), 0,
"Reason for command rejection" }
"Reason for command rejection", HFILL }
},
{ &hf_iscsi_SNACK_S,
{ "S", "iscsi.snack.s",
FT_BOOLEAN, 8, TFS(&iscsi_meaning_SNACK_S), 0x01,
"Status not data SNACK requested" }
"Status not data SNACK requested", HFILL }
},
{ &hf_iscsi_AddRuns,
{ "AddRuns", "iscsi.snack.addruns",
FT_UINT8, BASE_HEX, NULL, 0,
"Number of additional runs" }
"Number of additional runs", HFILL }
},
{ &hf_iscsi_BegRun,
{ "BegRun", "iscsi.snack.begrun",
FT_UINT32, BASE_HEX, NULL, 0,
"First missed DataSN or StatSN" }
"First missed DataSN or StatSN", HFILL }
},
{ &hf_iscsi_RunLength,
{ "RunLength", "iscsi.snack.runlength",
FT_UINT32, BASE_HEX, NULL, 0,
"Number of additional missing status PDUs in this run" }
"Number of additional missing status PDUs in this run", HFILL }
},
{ &hf_iscsi_AdditionalRuns,
{ "AdditionalRuns", "iscsi.snack.additionalruns",
FT_BYTES, BASE_HEX, NULL, 0,
"Additional runs of missing status PDUs" }
"Additional runs of missing status PDUs", HFILL }
},
};

20
packet-isis-hello.c
View File

@ -1,7 +1,7 @@
/* packet-isis-hello.c
* Routines for decoding isis hello packets and their CLVs
*
* $Id: packet-isis-hello.c,v 1.15 2001/06/05 21:23:32 guy Exp $
* $Id: packet-isis-hello.c,v 1.16 2001/06/18 02:17:47 guy Exp $
* Stuart Stanley <stuarts@mxmail.net>
*
* Ethereal - Network traffic analyzer
@ -595,39 +595,39 @@ proto_register_isis_hello(void) {
static hf_register_info hf[] = {
{ &hf_isis_hello_circuit_reserved,
{ "Circuit type ", "isis_hello.circuite_type",
FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_isis_hello_source_id,
{ "SystemID{ Sender of PDU } ", "isis_hello.source_id",
FT_BYTES, BASE_HEX, NULL, 0x0, "" }},
FT_BYTES, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_isis_hello_holding_timer,
{ "Holding timer ", "isis_hello.holding_timer",
FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_isis_hello_pdu_length,
{ "PDU length ", "isis_hello.pdu_length",
FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_isis_hello_priority_reserved,
{ "Priority ", "isis_hello.priority",
FT_UINT8, BASE_DEC, NULL, ISIS_HELLO_P_RESERVED_MASK, "" }},
FT_UINT8, BASE_DEC, NULL, ISIS_HELLO_P_RESERVED_MASK, "", HFILL }},
{ &hf_isis_hello_lan_id,
{ "SystemID{ Designated IS } ", "isis_hello.lan_id",
FT_BYTES, BASE_DEC, NULL, 0x0, "" }},
FT_BYTES, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_isis_hello_local_circuit_id,
{ "Local circuit ID ", "isis_hello.local_circuit_id",
FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_isis_hello_clv_ipv4_int_addr,
{ "IPv4 interface address ", "isis_hello.clv_ipv4_int_addr",
FT_IPv4, BASE_NONE, NULL, 0x0, "" }},
FT_IPv4, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_isis_hello_clv_ipv6_int_addr,
{ "IPv6 interface address ", "isis_hello.clv_ipv6_int_addr",
FT_IPv6, BASE_NONE, NULL, 0x0, "" }},
FT_IPv6, BASE_NONE, NULL, 0x0, "", HFILL }},
};
static gint *ett[] = {

16
packet-isis-lsp.c
View File

@ -1,7 +1,7 @@
/* packet-isis-lsp.c
* Routines for decoding isis lsp packets and their CLVs
*
* $Id: packet-isis-lsp.c,v 1.16 2001/06/18 01:24:58 guy Exp $
* $Id: packet-isis-lsp.c,v 1.17 2001/06/18 02:17:47 guy Exp $
* Stuart Stanley <stuarts@mxmail.net>
*
* Ethereal - Network traffic analyzer
@ -1546,31 +1546,31 @@ proto_register_isis_lsp(void) {
static hf_register_info hf[] = {
{ &hf_isis_lsp_pdu_length,
{ "PDU length", "isis_lsp.pdu_length", FT_UINT16,
BASE_DEC, NULL, 0x0, "" }},
BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_isis_lsp_remaining_life,
{ "Remaining life", "isis_lsp.remaining_life", FT_UINT16,
BASE_DEC, NULL, 0x0, "" }},
BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_isis_lsp_sequence_number,
{ "Sequence number", "isis_lsp.sequence_number",
FT_UINT32, BASE_HEX, NULL, 0x0, "" }},
FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_isis_lsp_checksum,
{ "Checksum", "isis_lsp.checksum",FT_UINT16,
BASE_HEX, NULL, 0x0, "" }},
BASE_HEX, NULL, 0x0, "", HFILL }},
{ &hf_isis_lsp_clv_ipv4_int_addr,
{ "IPv4 interface address", "isis_lsp.clv_ipv4_int_addr", FT_IPv4,
BASE_NONE, NULL, 0x0, "" }},
BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_isis_lsp_clv_ipv6_int_addr,
{ "IPv6 interface address", "isis_lsp.clv_ipv6_int_addr", FT_IPv6,
BASE_NONE, NULL, 0x0, "" }},
BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_isis_lsp_clv_te_router_id,
{ "Traffic Engineering Router ID", "isis_lsp.clv_te_router_id", FT_IPv4,
BASE_NONE, NULL, 0x0, "" }},
BASE_NONE, NULL, 0x0, "", HFILL }},
};
static gint *ett[] = {
&ett_isis_lsp,

6
packet-isis-snp.c
View File

@ -1,7 +1,7 @@
/* packet-isis-snp.c
* Routines for decoding isis complete & partial SNP and their payload
*
* $Id: packet-isis-snp.c,v 1.8 2001/01/03 06:55:29 guy Exp $
* $Id: packet-isis-snp.c,v 1.9 2001/06/18 02:17:47 guy Exp $
* Stuart Stanley <stuarts@mxmail.net>
*
* Ethereal - Network traffic analyzer
@ -454,7 +454,7 @@ proto_register_isis_csnp(void) {
static hf_register_info hf[] = {
{ &hf_isis_csnp_pdu_length,
{ "PDU length", "isis_csnp.pdu_length", FT_UINT16,
BASE_DEC, NULL, 0x0, "" }},
BASE_DEC, NULL, 0x0, "", HFILL }},
};
static gint *ett[] = {
&ett_isis_csnp,
@ -493,7 +493,7 @@ proto_register_isis_psnp(void) {
static hf_register_info hf[] = {
{ &hf_isis_psnp_pdu_length,
{ "PDU length", "isis_psnp.pdu_length", FT_UINT16,
BASE_DEC, NULL, 0x0, "" }},
BASE_DEC, NULL, 0x0, "", HFILL }},
};
static gint *ett[] = {
&ett_isis_psnp,

18
packet-isis.c
View File

@ -2,7 +2,7 @@
* Routines for ISO/OSI network and transport protocol packet disassembly, core
* bits.
*
* $Id: packet-isis.c,v 1.20 2001/05/23 18:52:54 guy Exp $
* $Id: packet-isis.c,v 1.21 2001/06/18 02:17:48 guy Exp $
* Stuart Stanley <stuarts@mxmail.net>
*
* Ethereal - Network traffic analyzer
@ -291,34 +291,34 @@ proto_register_isis(void) {
static hf_register_info hf[] = {
{ &hf_isis_irpd,
{ "Intra Domain Routing Protocol Discriminator", "isis.irpd",
FT_UINT8, BASE_HEX, VALS(nlpid_vals), 0x0, "" }},
FT_UINT8, BASE_HEX, VALS(nlpid_vals), 0x0, "", HFILL }},
{ &hf_isis_header_length,
{ "PDU Header Length ", "isis.len", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
{ "PDU Header Length ", "isis.len", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_isis_version,
{ "Version (==1) ", "isis.version", FT_UINT8,
BASE_DEC, NULL, 0x0, "" }},
BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_isis_system_id_length,
{ "System ID Length ", "isis.sysid_len",
FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_isis_type,
{ "PDU Type ", "isis.type", FT_UINT8, BASE_DEC,
VALS(isis_vals), 0xff, "" }},
VALS(isis_vals), 0xff, "", HFILL }},
{ &hf_isis_version2,
{ "Version2 (==1) ", "isis.version2", FT_UINT8, BASE_DEC, NULL,
0x0, "" }},
0x0, "", HFILL }},
{ &hf_isis_reserved,
{ "Reserved (==0) ", "isis.reserved", FT_UINT8, BASE_DEC, NULL,
0x0, "" }},
0x0, "", HFILL }},
{ &hf_isis_max_area_adr,
{ "Max.AREAs: (0==3) ", "isis.max_area_adr", FT_UINT8, BASE_DEC, NULL,
0x0, "" }},
0x0, "", HFILL }},
};
/*

38
packet-isl.c
View File

@ -1,7 +1,7 @@
/* packet-isl.c
* Routines for Cisco ISL Ethernet header disassembly
*
* $Id: packet-isl.c,v 1.24 2001/04/19 23:02:44 guy Exp $
* $Id: packet-isl.c,v 1.25 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -282,60 +282,60 @@ proto_register_isl(void)
static hf_register_info hf[] = {
{ &hf_isl_dst,
{ "Destination", "isl.dst", FT_ETHER, BASE_NONE, NULL, 0x0,
"Destination Address" }},
"Destination Address", HFILL }},
{ &hf_isl_type,
{ "Type", "isl.type", FT_UINT8, BASE_DEC,
VALS(type_vals), 0xF0, "Type" }},
VALS(type_vals), 0xF0, "Type", HFILL }},
{ &hf_isl_user_eth,
{ "User", "isl.user_eth", FT_UINT8, BASE_DEC,
VALS(ether_user_vals), 0x0F, "Priority (for Ethernet)" }},
VALS(ether_user_vals), 0x0F, "Priority (for Ethernet)", HFILL }},
{ &hf_isl_user,
{ "User", "isl.user", FT_UINT8, BASE_HEX, NULL, 0x0F,
"User-defined bits" }},
"User-defined bits", HFILL }},
{ &hf_isl_src,
{ "Source", "isl.src", FT_ETHER, BASE_NONE, NULL, 0x0,
"Source Hardware Address" }},
"Source Hardware Address", HFILL }},
{ &hf_isl_addr,
{ "Source or Destination Address", "isl.addr", FT_ETHER, BASE_NONE, NULL, 0x0,
"Source or Destination Hardware Address" }},
"Source or Destination Hardware Address", HFILL }},
{ &hf_isl_len,
{ "Length", "isl.len", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_isl_hsa,
{ "HSA", "isl.hsa", FT_UINT24, BASE_HEX, NULL, 0x0,
"High bits of source address" }},
"High bits of source address", HFILL }},
{ &hf_isl_vlan_id,
{ "VLAN ID", "isl.vlan_id", FT_UINT16, BASE_HEX, NULL,
0xFFFE, "Virtual LAN ID" }},
0xFFFE, "Virtual LAN ID", HFILL }},
{ &hf_isl_bpdu,
{ "BPDU", "isl.bpdu", FT_BOOLEAN, 16,
TFS(&bpdu_tfs), 0x0001, "BPDU indicator" }},
TFS(&bpdu_tfs), 0x0001, "BPDU indicator", HFILL }},
{ &hf_isl_index,
{ "Index", "isl.index", FT_UINT16, BASE_DEC, NULL, 0x0,
"Port index of packet source" }},
"Port index of packet source", HFILL }},
{ &hf_isl_crc,
{ "CRC", "isl.crc", FT_UINT32, BASE_HEX, NULL, 0x0,
"CRC field of encapsulated frame" }},
"CRC field of encapsulated frame", HFILL }},
{ &hf_isl_src_vlan_id,
{ "Source VLAN ID", "isl.src_vlan_id", FT_UINT16, BASE_HEX, NULL,
0xFFFE, "Source Virtual LAN ID" }},
0xFFFE, "Source Virtual LAN ID", HFILL }},
{ &hf_isl_explorer,
{ "Explorer", "isl.explorer", FT_BOOLEAN, 16,
TFS(&explorer_tfs), 0x0001, "Explorer" }},
TFS(&explorer_tfs), 0x0001, "Explorer", HFILL }},
{ &hf_isl_dst_route_descriptor,
{ "Destination route descriptor", "isl.dst_route_desc",
FT_UINT16, BASE_HEX, NULL, 0x0,
"Route descriptor to be used for forwarding" }},
"Route descriptor to be used for forwarding", HFILL }},
{ &hf_isl_src_route_descriptor,
{ "Source-route descriptor", "isl.src_route_desc",
FT_UINT16, BASE_HEX, NULL, 0x0,
"Route descriptor to be used for source learning" }},
"Route descriptor to be used for source learning", HFILL }},
{ &hf_isl_fcs_not_incl,
{ "FCS Not Included", "isl.fcs_not_incl", FT_BOOLEAN, 9,
NULL, 0x40, "FCS not included" }},
NULL, 0x40, "FCS not included", HFILL }},
{ &hf_isl_esize,
{ "Esize", "isl.esize", FT_UINT8, BASE_DEC, NULL,
0x3F, "Frame size for frames less than 64 bytes" }},
0x3F, "Frame size for frames less than 64 bytes", HFILL }},
};
static gint *ett[] = {
&ett_isl,

174
packet-isup.c
View File

@ -2,7 +2,7 @@
* Routines for ISUP dissection
* Copyright 2001, Martina Obermeier <martina.obermeier@icn.siemens.de>
*
* $Id: packet-isup.c,v 1.3 2001/05/30 08:49:23 guy Exp $
* $Id: packet-isup.c,v 1.4 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -3838,432 +3838,432 @@ proto_register_isup(void)
{ &hf_isup_cic,
{ "CIC", "isup.cic",
FT_UINT16, BASE_HEX, NULL, 0xFF0F,
"" }},
"", HFILL }},
{ &hf_isup_message_type,
{ "Message Type", "isup.message_type",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_isup_parameter_type,
{ "Parameter Type", "isup.parameter_type",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_isup_parameter_length,
{ "Parameter Length", "isup.parameter_length",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_isup_mandatory_variable_parameter_pointer,
{ "Pointer to Parameter", "isup.mandatory_variable_parameter_pointer",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_isup_pointer_to_start_of_optional_part,
{ "Pointer to optional parameter part", "isup.optional_parameter_part_pointer",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_isup_satellite_indicator,
{ "Satellite Indicator", "isup.satellite_indicator",
FT_UINT8, BASE_HEX, VALS(isup_satellite_ind_value), BA_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_continuity_check_indicator,
{ "Continuity Check Indicator", "isup.continuity_check_indicator",
FT_UINT8, BASE_HEX, VALS(isup_continuity_check_ind_value), DC_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_echo_control_device_indicator,
{ "Echo Control Device Indicator", "isup.echo_control_device_indicator",
FT_BOOLEAN, 8, TFS(&isup_echo_control_device_ind_value),E_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_forw_call_natnl_inatnl_call_indicator,
{ "National/international call indicator", "isup.forw_call_natnl_inatnl_call_indicator",
FT_BOOLEAN, 16, TFS(&isup_natnl_inatnl_call_ind_value),A_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_forw_call_end_to_end_method_indicator,
{ "End-to-end method indicator", "isup.forw_call_end_to_end_method_indicator",
FT_UINT16, BASE_HEX, VALS(isup_end_to_end_method_ind_value), CB_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_forw_call_interworking_indicator,
{ "Interworking indicator", "isup.forw_call_interworking_indicator",
FT_BOOLEAN, 16, TFS(&isup_interworking_ind_value), D_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_forw_call_end_to_end_info_indicator,
{ "End-to-end information indicator", "isup.forw_call_end_to_end_information_indicator",
FT_BOOLEAN, 16, TFS(&isup_end_to_end_info_ind_value), E_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_forw_call_isdn_user_part_indicator,
{ "ISDN user part indicator", "isup.forw_call_isdn_user_part_indicator",
FT_BOOLEAN, 16, TFS(&isup_ISDN_user_part_ind_value), F_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_forw_call_preferences_indicator,
{ "ISDN user part preference indicator", "isup.forw_call_preferences_indicator",
FT_UINT16, BASE_HEX, VALS(isup_preferences_ind_value), HG_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_forw_call_isdn_access_indicator,
{ "ISDN access indicator", "isup.forw_call_isdn_access_indicator",
FT_BOOLEAN, 16, TFS(&isup_ISDN_originating_access_ind_value), I_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_forw_call_sccp_method_indicator,
{ "SCCP method indicator", "isup.forw_call_sccp_method_indicator",
FT_UINT16, BASE_HEX, VALS(isup_SCCP_method_ind_value), KJ_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_calling_partys_category,
{ "Calling Party's category", "isup.calling_partys_category",
FT_UINT8, BASE_HEX, VALS(isup_calling_partys_category_value), 0x0,
"" }},
"", HFILL }},
{ &hf_isup_transmission_medium_requirement,
{ "Transmission medium requirement", "isup.transmission_medium_requirement",
FT_UINT8, BASE_DEC, VALS(isup_transmission_medium_requirement_value), 0x0,
"" }},
"", HFILL }},
{ &hf_isup_odd_even_indicator,
{ "Odd/even indicator", "isup.isdn_odd_even_indicator",
FT_BOOLEAN, 8, TFS(&isup_odd_even_ind_value), ISUP_ODD_EVEN_MASK,
"" }},
"", HFILL }},
{ &hf_isup_called_party_nature_of_address_indicator,
{ "Nature of address indicator", "isup.called_party_nature_of_address_indicator",
FT_UINT8, BASE_DEC, VALS(isup_called_party_nature_of_address_ind_value), ISUP_NATURE_OF_ADDRESS_IND_MASK,
"" }},
"", HFILL }},
{ &hf_isup_calling_party_nature_of_address_indicator,
{ "Nature of address indicator", "isup.calling_party_nature_of_address_indicator",
FT_UINT8, BASE_DEC, VALS(isup_calling_party_nature_of_address_ind_value), ISUP_NATURE_OF_ADDRESS_IND_MASK,
"" }},
"", HFILL }},
{ &hf_isup_inn_indicator,
{ "INN indicator", "isup.inn_indicator",
FT_BOOLEAN, 8, TFS(&isup_INN_ind_value), ISUP_INN_MASK,
"" }},
"", HFILL }},
{ &hf_isup_ni_indicator,
{ "NI indicator", "isup.ni_indicator",
FT_BOOLEAN, 8, TFS(&isup_NI_ind_value), ISUP_NI_MASK,
"" }},
"", HFILL }},
{ &hf_isup_numbering_plan_indicator,
{ "Numbering plan indicator", "isup.numbering_plan_indicator",
FT_UINT8, BASE_DEC, VALS(isup_numbering_plan_ind_value), ISUP_NUMBERING_PLAN_IND_MASK,
"" }},
"", HFILL }},
{ &hf_isup_address_presentation_restricted_indicator,
{ "Address presentation restricted indicator", "isup.address_presentation_restricted_indicator",
FT_UINT8, BASE_DEC, VALS(isup_address_presentation_restricted_ind_value), ISUP_ADDRESS_PRESENTATION_RESTR_IND_MASK,
"" }},
"", HFILL }},
{ &hf_isup_screening_indicator,
{ "Screening indicator", "isup.screening_indicator",
FT_UINT8, BASE_DEC, VALS(isup_screening_ind_value), ISUP_SCREENING_IND_MASK,
"" }},
"", HFILL }},
{ &hf_isup_screening_indicator_enhanced,
{ "Screening indicator", "isup.screening_indicator_enhanced",
FT_UINT8, BASE_DEC, VALS(isup_screening_ind_enhanced_value), ISUP_SCREENING_IND_MASK,
"" }},
"", HFILL }},
{ &hf_isup_called_party_odd_address_signal_digit,
{ "Address signal digit", "isup.called_party_odd_address_signal_digit",
FT_UINT8, BASE_DEC, VALS(isup_called_party_address_digit_value), ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_calling_party_odd_address_signal_digit,
{ "Address signal digit", "isup.calling_party_odd_address_signal_digit",
FT_UINT8, BASE_DEC, VALS(isup_calling_party_address_digit_value), ISUP_ODD_ADDRESS_SIGNAL_DIGIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_called_party_even_address_signal_digit,
{ "Address signal digit", "isup.called_party_even_address_signal_digit",
FT_UINT8, BASE_DEC, VALS(isup_called_party_address_digit_value), ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_calling_party_even_address_signal_digit,
{ "Address signal digit", "isup.calling_party_even_address_signal_digit",
FT_UINT8, BASE_DEC, VALS(isup_calling_party_address_digit_value), ISUP_EVEN_ADDRESS_SIGNAL_DIGIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_calling_party_address_request_indicator,
{ "Calling party address request indicator", "isup.calling_party_address_request_indicator",
FT_BOOLEAN, 16, TFS(&isup_calling_party_address_request_ind_value), A_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_info_req_holding_indicator,
{ "Holding indicator", "isup.info_req_holding_indicator",
FT_BOOLEAN, 16, TFS(&isup_holding_ind_value), B_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_calling_partys_category_request_indicator,
{ "Calling party's category request indicator", "isup.calling_partys_category_request_indicator",
FT_BOOLEAN, 16, TFS(&isup_calling_partys_category_request_ind_value), D_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_charge_information_request_indicator,
{ "Charge information request indicator", "isup.charge_information_request_indicator",
FT_BOOLEAN, 16, TFS(&isup_charge_information_request_ind_value), E_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_malicious_call_identification_request_indicator,
{ "Malicious call identification request indicator (ISUP'88)", "isup.malicious_call_ident_request_indicator",
FT_BOOLEAN, 16, TFS(&isup_malicious_call_identification_request_ind_value), H_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_calling_party_address_response_indicator,
{ "Calling party address response indicator", "isup.calling_party_address_response_indicator",
FT_UINT16, BASE_HEX, VALS(isup_calling_party_address_response_ind_value), BA_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_hold_provided_indicator,
{ "Hold provided indicator", "isup.hold_provided_indicator",
FT_BOOLEAN, 16, TFS(&isup_hold_provided_ind_value), C_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_calling_partys_category_response_indicator,
{ "Calling party's category response indicator", "isup.calling_partys_category_response_indicator",
FT_BOOLEAN, 16, TFS(&isup_calling_partys_category_response_ind_value), F_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_charge_information_response_indicator,
{ "Charge information response indicator", "isup.charge_information_response_indicator",
FT_BOOLEAN, 16, TFS(&isup_charge_information_response_ind_value), G_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_solicited_indicator,
{ "Solicited indicator", "isup.solicided_indicator",
FT_BOOLEAN, 16, TFS(&isup_solicited_information_ind_value), H_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_continuity_indicator,
{ "Continuity indicator", "isup.continuity_indicator",
FT_BOOLEAN, 8, TFS(&isup_continuity_ind_value), A_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_backw_call_charge_ind,
{ "Charge indicator", "isup.charge_indicator",
FT_UINT16, BASE_HEX, VALS(isup_charge_ind_value), BA_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_backw_call_called_partys_status_ind,
{ "Called party's status indicator", "isup.called_partys_status_indicator",
FT_UINT16, BASE_HEX, VALS(isup_called_partys_status_ind_value), DC_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_backw_call_called_partys_category_ind,
{ "Called party's category indicator", "isup.called_partys_category_indicator",
FT_UINT16, BASE_HEX, VALS(isup_called_partys_category_ind_value), FE_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_backw_call_end_to_end_method_ind,
{ "End-to-end method indicator", "isup.backw_call_end_to_end_method_indicator",
FT_UINT16, BASE_HEX, VALS(isup_end_to_end_method_ind_value), HG_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_backw_call_interworking_ind,
{ "Interworking indicator", "isup.backw_call_interworking_indicator",
FT_BOOLEAN, 16, TFS(&isup_interworking_ind_value), I_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_backw_call_end_to_end_info_ind,
{ "End-to-end information indicator", "isup.backw_call_end_to_end_information_indicator",
FT_BOOLEAN, 16, TFS(&isup_end_to_end_info_ind_value), J_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_backw_call_isdn_user_part_ind,
{ "ISDN user part indicator", "isup.backw_call_isdn_user_part_indicator",
FT_BOOLEAN, 16, TFS(&isup_ISDN_user_part_ind_value), K_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_backw_call_holding_ind,
{ "Holding indicator", "isup.backw_call_holding_indicator",
FT_BOOLEAN, 16, TFS(&isup_holding_ind_value), L_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_backw_call_isdn_access_ind,
{ "ISDN access indicator", "isup.backw_call_isdn_access_indicator",
FT_BOOLEAN, 16, TFS(&isup_ISDN_terminating_access_ind_value), M_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_backw_call_echo_control_device_ind,
{ "Echo Control Device Indicator", "isup.backw_call_echo_control_device_indicator",
FT_BOOLEAN, 16, TFS(&isup_echo_control_device_ind_value), N_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_backw_call_sccp_method_ind,
{ "SCCP method indicator", "isup.backw_call_sccp_method_indicator",
FT_UINT16, BASE_HEX, VALS(isup_SCCP_method_ind_value), PO_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_suspend_resume_indicator,
{ "Suspend/Resume indicator", "isup.suspend_resume_indicator",
FT_BOOLEAN, 8, TFS(&isup_suspend_resume_ind_value), A_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_transmission_medium_requirement,
{ "Transmission medium requirement", "isup.transmission_medium_requirement",
FT_UINT8, BASE_DEC, VALS(isup_transmission_medium_requirement_value), 0x0,
"" }},
"", HFILL }},
{ &hf_isup_range_indicator,
{ "Range indicator", "isup.range_indicator",
FT_UINT8, BASE_DEC, NULL , 0x0,
"" }},
"", HFILL }},
{ &hf_isup_cgs_message_type,
{ "Circuit group supervision message type", "isup.cgs_message_type",
FT_UINT8, BASE_DEC, VALS(isup_cgs_message_type_value), BA_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_mtc_blocking_state1,
{ "Maintenance blocking state", "isup.mtc_blocking_state",
FT_UINT8, BASE_DEC, VALS(isup_mtc_blocking_state_DC00_value), BA_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_mtc_blocking_state2,
{ "Maintenance blocking state", "isup.mtc_blocking_state",
FT_UINT8, BASE_DEC, VALS(isup_mtc_blocking_state_DCnot00_value), BA_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_call_proc_state,
{ "Call processing state", "isup.call_processing_state",
FT_UINT8, BASE_DEC, VALS(isup_call_processing_state_value), DC_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_hw_blocking_state,
{ "HW blocking state", "isup.hw_blocking_state",
FT_UINT8, BASE_DEC, VALS(isup_HW_blocking_state_value), FE_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_event_ind,
{ "Event indicator", "isup.event_ind",
FT_UINT8, 8, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_isup_event_presentation_restricted_ind,
{ "Event presentation restricted indicator", "isup.event_presentatiation_restr_ind",
FT_BOOLEAN, 8, TFS(&isup_event_presentation_restricted_ind_value), H_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_cug_call_ind,
{ "Closed user group call indicator", "isup.clg_call_ind",
FT_UINT8, BASE_DEC, VALS(isup_CUG_call_ind_value), BA_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_simple_segmentation_ind,
{ "Simple segmentation indicator", "isup.simple_segmentation_ind",
FT_BOOLEAN, 8, TFS(&isup_simple_segmentation_ind_value), C_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_connected_line_identity_request_ind,
{ "Connected line identity request indicator", "isup.connected_line_identity_request_ind",
FT_BOOLEAN, 8, TFS(&isup_connected_line_identity_request_ind_value), H_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_redirecting_ind,
{ "Redirection indicator", "isup.redirecting_ind",
FT_UINT16, BASE_DEC, VALS(isup_redirecting_ind_value), CBA_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_original_redirection_reason,
{ "Original redirection reason", "isup.original_redirection_reason",
FT_UINT16, BASE_DEC, VALS(isup_original_redirection_reason_value), HGFE_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_redirection_counter,
{ "Redirection counter", "isup.redirection_counter",
FT_UINT16, BASE_DEC, NULL, KJI_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_redirection_reason,
{ "Redirection reason", "isup.redirection_reason",
FT_UINT16, BASE_DEC, VALS(isup_redirection_reason_value), PONM_16BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_type_of_network_identification,
{ "Type of network identification", "isup.type_of_network_identification",
FT_UINT8, BASE_DEC, VALS(isup_type_of_network_identification_value), GFE_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_network_identification_plan,
{ "Network identification plan", "isup.network_identification_plan",
FT_UINT8, BASE_DEC, VALS(isup_network_identification_plan_value), DCBA_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_map_type,
{ "Map Type", "isup.map_type",
FT_UINT8, BASE_DEC, VALS(isup_map_type_value), FEDCBA_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_automatic_congestion_level,
{ "Automatic congestion level", "isup.automatic_congestion_level",
FT_UINT8, BASE_DEC, VALS(isup_auto_congestion_level_value), 0x0,
"" }},
"", HFILL }},
{ &hf_isup_inband_information_ind,
{ "In-band information indicator", "isup.inband_information_ind",
FT_BOOLEAN, 8, TFS(&isup_inband_information_ind_value), A_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_call_diversion_may_occur_ind,
{ "Call diversion may occur indicator", "isup.call_diversion_may_occur_ind",
FT_BOOLEAN, 8, TFS(&isup_call_diversion_may_occur_ind_value), B_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_mlpp_user_ind,
{ "MLPP user indicator", "isup.mlpp_user",
FT_BOOLEAN, 8, TFS(&isup_MLPP_user_ind_value), D_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_access_delivery_ind,
{ "Access delivery indicator", "isup.access_delivery_ind",
FT_BOOLEAN, 8, TFS(&isup_access_delivery_ind_value), A_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_transmission_medium_requirement_prime,
{ "Transmission medium requirement prime", "isup.transmission_medium_requirement_prime",
FT_UINT8, BASE_DEC, VALS(isup_transmission_medium_requirement_prime_value), 0x0,
"" }},
"", HFILL }},
{ &hf_isup_loop_prevention_response_ind,
{ "Response indicator", "isup.loop_prevention_response_ind",
FT_UINT8, BASE_DEC, VALS(isup_loop_prevention_response_ind_value), CB_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_temporary_alternative_routing_ind,
{ "Temporary alternative routing indicator", "isup.temporary_alternative_routing_ind",
FT_BOOLEAN, 8, TFS(&isup_temporary_alternative_routing_ind_value), A_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_extension_ind,
{ "Extension indicator", "isup.extension_ind",
FT_BOOLEAN, 8, TFS(&isup_extension_ind_value), H_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_call_to_be_diverted_ind,
{ "Call to be diverted indicator", "isup.call_to_be_diverted_ind",
FT_UINT8, BASE_DEC, VALS(isup_call_to_be_diverted_ind_value), BA_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_call_to_be_offered_ind,
{ "Call to be offered indicator", "isup.call_to_be_offered_ind",
FT_UINT8, BASE_DEC, VALS(isup_call_to_be_offered_ind_value), BA_8BIT_MASK,
"" }},
"", HFILL }},
{ &hf_isup_conference_acceptance_ind,
{ "Conference acceptance indicator", "isup.conference_acceptance_ind",
FT_UINT8, BASE_DEC, VALS(isup_conference_acceptance_ind_value), BA_8BIT_MASK,
"" }},
"", HFILL }},
};
/* Setup protocol subtree array */

50
packet-iua.c
View File

@ -8,7 +8,7 @@
*
* Copyright 2000, Michael Tüxen <Michael.Tuexen@icn.siemens.de>
*
* $Id: packet-iua.c,v 1.6 2001/04/23 18:05:19 guy Exp $
* $Id: packet-iua.c,v 1.7 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -870,122 +870,122 @@ proto_register_iua(void)
{ &hf_iua_version,
{ "Version", "iua.version",
FT_UINT8, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_reserved,
{ "Reserved", "iua.reserved",
FT_UINT8, BASE_HEX, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_message_class,
{ "Message class", "iua.message_class",
FT_UINT8, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_message_type,
{ "Message Type", "iua.message_type",
FT_UINT8, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_message_length,
{ "Message length", "iua.message_length",
FT_UINT32, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_parameter_tag,
{ "Parameter Tag", "iua.parameter_tag",
FT_UINT16, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_parameter_length,
{ "Parameter length", "iua.parameter_length",
FT_UINT16, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_int_interface_identifier,
{ "Integer interface identifier", "iua.int_interface_identifier",
FT_UINT32, BASE_HEX, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_text_interface_identifier,
{ "Text interface identifier", "iua.text_interface_identifier",
FT_STRING, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_spare_bit,
{ "Spare bit", "hf.iua.spare_bit",
FT_BOOLEAN, 8, NULL, SPARE_BIT_MASK,
""}
"", HFILL }
},
{ &hf_iua_sapi,
{ "SAPI", "hf.iua.sapi",
FT_UINT8, BASE_HEX, NULL, SAPI_MASK,
""}
"", HFILL }
},
{ &hf_iua_zero_bit,
{ "Zero bit", "hf.iua.zero_bit",
FT_BOOLEAN, 8, NULL, ZERO_BIT_MASK,
""}
"", HFILL }
},
{ &hf_iua_one_bit,
{ "One bit", "hf.iua.one_bit",
FT_BOOLEAN, 8, NULL, ONE_BIT_MASK,
""}
"", HFILL }
},
{ &hf_iua_tei,
{ "TEI", "hf.iua.tei",
FT_UINT8, BASE_HEX, NULL, TEI_MASK,
""}
"", HFILL }
},
{ &hf_iua_info_string,
{ "Info string", "iua.info_string",
FT_STRING, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_interface_range_start,
{ "Start", "iua.interface_range_start",
FT_UINT32, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_interface_range_end,
{ "End", "iua.interface_range_end",
FT_UINT32, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_release_reason,
{ "Reason", "iua.release_reason",
FT_UINT32, BASE_HEX, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_status_type,
{ "Status type", "iua.status_type",
FT_UINT16, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_status_ident,
{ "Status identification", "iua.status_identification",
FT_UINT16, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_traffic_mode_type,
{ "Traffic mode type", "iua.traffic_mode_type",
FT_UINT32, BASE_HEX, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_error_code,
{ "Error code", "iua.error_code",
FT_UINT32, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_asp_reason,
{ "Reason", "iua.asp_reason",
FT_UINT32, BASE_HEX, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_iua_tei_status,
{ "TEI status", "iua.tei_status",
FT_UINT32, BASE_HEX, NULL, 0x0,
""}
"", HFILL }
},
};
/* Setup protocol subtree array */

20
packet-klm.c
View File

@ -1,7 +1,7 @@
/* packet-klm.c 2001 Ronnie Sahlberg <rsahlber@bigpond.net.au>
* Routines for klm dissection
*
* $Id: packet-klm.c,v 1.3 2001/06/12 06:31:14 guy Exp $
* $Id: packet-klm.c,v 1.4 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -201,39 +201,39 @@ proto_register_klm(void)
static hf_register_info hf[] = {
{ &hf_klm_exclusive, {
"exclusive", "klm.exclusive", FT_BOOLEAN, BASE_NONE,
&tfs_exclusive, 0, "Exclusive lock" }},
&tfs_exclusive, 0, "Exclusive lock", HFILL }},
{ &hf_klm_lock, {
"lock", "klm.lock", FT_NONE, BASE_NONE,
NULL, 0, "KLM lock structure" }},
NULL, 0, "KLM lock structure", HFILL }},
{ &hf_klm_servername, {
"server name", "klm.servername", FT_STRING, BASE_NONE,
NULL, 0, "Server name" }},
NULL, 0, "Server name", HFILL }},
{ &hf_klm_pid, {
"pid", "klm.pid", FT_UINT32, BASE_DEC,
NULL, 0, "ProcessID" }},
NULL, 0, "ProcessID", HFILL }},
{ &hf_klm_offset, {
"offset", "klm.offset", FT_UINT32, BASE_DEC,
NULL, 0, "File offset" }},
NULL, 0, "File offset", HFILL }},
{ &hf_klm_len, {
"length", "klm.len", FT_UINT32, BASE_DEC,
NULL, 0, "Length of lock region" }},
NULL, 0, "Length of lock region", HFILL }},
{ &hf_klm_stats, {
"stats", "klm.stats", FT_UINT32, BASE_DEC,
VALS(names_klm_stats), 0, "stats" }},
VALS(names_klm_stats), 0, "stats", HFILL }},
{ &hf_klm_holder, {
"holder", "klm.holder", FT_NONE, BASE_NONE,
NULL, 0, "KLM lock holder" }},
NULL, 0, "KLM lock holder", HFILL }},
{ &hf_klm_block, {
"block", "klm.block", FT_BOOLEAN, BASE_NONE,
&tfs_block, 0, "Block" }},
&tfs_block, 0, "Block", HFILL }},
};

36
packet-l2tp.c
View File

@ -7,7 +7,7 @@
* Laurent Cazalet <laurent.cazalet@mailclub.net>
* Thomas Parvais <thomas.parvais@advalvas.be>
*
* $Id: packet-l2tp.c,v 1.23 2001/06/10 04:42:34 guy Exp $
* $Id: packet-l2tp.c,v 1.24 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -887,72 +887,72 @@ proto_register_l2tp(void)
static hf_register_info hf[] = {
{ &hf_l2tp_type,
{ "Type", "lt2p.type", FT_UINT16, BASE_DEC, VALS(l2tp_type_vals), 0x8000,
"Type bit" }},
"Type bit", HFILL }},
{ &hf_l2tp_length_bit,
{ "Length Bit", "lt2p.length_bit", FT_BOOLEAN, 16, TFS(&l2tp_length_bit_truth), 0x4000,
"Length bit" }},
"Length bit", HFILL }},
{ &hf_l2tp_seq_bit,
{ "Sequence Bit", "lt2p.seq_bit", FT_BOOLEAN, 16, TFS(&l2tp_seq_bit_truth), 0x0800,
"Sequence bit" }},
"Sequence bit", HFILL }},
{ &hf_l2tp_offset_bit,
{ "Offset bit", "lt2p.offset_bit", FT_BOOLEAN, 16, TFS(&l2tp_offset_bit_truth), 0x0200,
"Offset bit" }},
"Offset bit", HFILL }},
{ &hf_l2tp_priority,
{ "Priority", "lt2p.priority", FT_BOOLEAN, 16, TFS(&l2tp_priority_truth), 0x0100,
"Priority bit" }},
"Priority bit", HFILL }},
{ &hf_l2tp_version,
{ "Version", "lt2p.version", FT_UINT16, BASE_DEC, NULL, 0x000f,
"Version" }},
"Version", HFILL }},
{ &hf_l2tp_length,
{ "Length","l2tp.length", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_l2tp_tunnel,
{ "Tunnel ID","l2tp.tunnel", FT_UINT16, BASE_DEC, NULL, 0x0, /* Probably should be FT_BYTES */
"Tunnel ID" }},
"Tunnel ID", HFILL }},
{ &hf_l2tp_session,
{ "Session ID","l2tp.session", FT_UINT16, BASE_DEC, NULL, 0x0, /* Probably should be FT_BYTES */
"Session ID" }},
"Session ID", HFILL }},
{ &hf_l2tp_Ns,
{ "Ns","l2tp.Ns", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_l2tp_Nr,
{ "Nr","l2tp.Nr", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_l2tp_offset,
{ "Offset","l2tp.offset", FT_UINT16, BASE_DEC, NULL, 0x0,
"Number of octest past the L2TP header at which the"
"payload data starts." }},
"payload data starts.", HFILL }},
{ &hf_l2tp_avp_mandatory,
{ "Mandatory", "lt2p.avp.mandatory", FT_BOOLEAN, BASE_NONE, NULL, 0,
"Mandatory AVP" }},
"Mandatory AVP", HFILL }},
{ &hf_l2tp_avp_hidden,
{ "Hidden", "lt2p.avp.hidden", FT_BOOLEAN, BASE_NONE, NULL, 0,
"Hidden AVP" }},
"Hidden AVP", HFILL }},
{ &hf_l2tp_avp_length,
{ "Length", "lt2p.avp.length", FT_UINT16, BASE_DEC, NULL, 0,
"AVP Length" }},
"AVP Length", HFILL }},
{ &hf_l2tp_avp_vendor_id,
{ "Vendor ID", "lt2p.avp.vendor_id", FT_UINT16, BASE_DEC, NULL, 0,
"AVP Vendor ID" }},
"AVP Vendor ID", HFILL }},
{ &hf_l2tp_avp_type,
{ "Type", "lt2p.avp.type", FT_UINT16, BASE_DEC, VALS(avp_type_vals), 0,
"AVP Type" }},
"AVP Type", HFILL }},
};
static gint *ett[] = {

6
packet-lapb.c
View File

@ -2,7 +2,7 @@
* Routines for lapb frame disassembly
* Olivier Abad <oabad@cybercable.fr>
*
* $Id: packet-lapb.c,v 1.29 2001/02/12 09:06:17 guy Exp $
* $Id: packet-lapb.c,v 1.30 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -119,11 +119,11 @@ proto_register_lapb(void)
static hf_register_info hf[] = {
{ &hf_lapb_address,
{ "Address Field", "lapb.address", FT_UINT8, BASE_HEX, NULL, 0x0,
"Address" }},
"Address", HFILL }},
{ &hf_lapb_control,
{ "Control Field", "lapb.control", FT_UINT8, BASE_HEX, NULL, 0x0,
"Control field" }},
"Control field", HFILL }},
};
static gint *ett[] = {
&ett_lapb,

4
packet-lapbether.c
View File

@ -3,7 +3,7 @@
* Richard Sharpe <rsharpe@ns.aus.com> based on the lapb module by
* Olivier Abad <oabad@cybercable.fr>
*
* $Id: packet-lapbether.c,v 1.5 2001/01/25 06:14:14 guy Exp $
* $Id: packet-lapbether.c,v 1.6 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -83,7 +83,7 @@ proto_register_lapbether(void)
static hf_register_info hf[] = {
{ &hf_lapbether_length,
{ "Length Field", "lapbether.length", FT_UINT16, BASE_DEC, NULL, 0x0,
"LAPBEther Length Field"}},
"LAPBEther Length Field", HFILL }},
};
static gint *ett[] = {

16
packet-lapd.c
View File

@ -2,7 +2,7 @@
* Routines for LAPD frame disassembly
* Gilbert Ramirez <gram@xiexie.org>
*
* $Id: packet-lapd.c,v 1.22 2001/05/27 07:28:00 guy Exp $
* $Id: packet-lapd.c,v 1.23 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -163,31 +163,31 @@ proto_register_lapd(void)
static hf_register_info hf[] = {
{ &hf_lapd_address,
{ "Address Field", "lapd.address", FT_UINT16, BASE_HEX, NULL, 0x0,
"Address" }},
"Address", HFILL }},
{ &hf_lapd_sapi,
{ "SAPI", "lapd.sapi", FT_UINT16, BASE_DEC, VALS(lapd_sapi_vals), LAPD_SAPI,
"Service Access Point Identifier" }},
"Service Access Point Identifier", HFILL }},
{ &hf_lapd_cr,
{ "C/R", "lapd.cr", FT_UINT16, BASE_DEC, NULL, LAPD_CR,
"Command/Response bit" }},
"Command/Response bit", HFILL }},
{ &hf_lapd_ea1,
{ "EA1", "lapd.ea1", FT_UINT16, BASE_DEC, NULL, LAPD_EA1,
"First Address Extension bit" }},
"First Address Extension bit", HFILL }},
{ &hf_lapd_tei,
{ "TEI", "lapd.tei", FT_UINT16, BASE_DEC, NULL, LAPD_TEI,
"Terminal Endpoint Identifier" }},
"Terminal Endpoint Identifier", HFILL }},
{ &hf_lapd_ea2,
{ "EA2", "lapd.ea2", FT_UINT16, BASE_DEC, NULL, LAPD_EA2,
"Second Address Extension bit" }},
"Second Address Extension bit", HFILL }},
{ &hf_lapd_control,
{ "Control Field", "lapd.control", FT_UINT16, BASE_HEX, NULL, 0x0,
"Control field" }},
"Control field", HFILL }},
};
static gint *ett[] = {
&ett_lapd,

62
packet-ldap.c
View File

@ -1,7 +1,7 @@
/* packet-ldap.c
* Routines for ldap packet dissection
*
* $Id: packet-ldap.c,v 1.26 2001/05/08 19:50:29 guy Exp $
* $Id: packet-ldap.c,v 1.27 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -1074,131 +1074,131 @@ proto_register_ldap(void)
{ &hf_ldap_length,
{ "Length", "ldap.length",
FT_UINT32, BASE_DEC, NULL, 0x0,
"LDAP Length" }},
"LDAP Length", HFILL }},
{ &hf_ldap_message_id,
{ "Message Id", "ldap.message_id",
FT_UINT32, BASE_DEC, NULL, 0x0,
"LDAP Message Id" }},
"LDAP Message Id", HFILL }},
{ &hf_ldap_message_type,
{ "Message Type", "ldap.message_type",
FT_UINT8, BASE_HEX, &msgTypes, 0x0,
"LDAP Message Type" }},
"LDAP Message Type", HFILL }},
{ &hf_ldap_message_length,
{ "Message Length", "ldap.message_length",
FT_UINT32, BASE_DEC, NULL, 0x0,
"LDAP Message Length" }},
"LDAP Message Length", HFILL }},
{ &hf_ldap_message_result,
{ "Result Code", "ldap.result.code",
FT_UINT8, BASE_HEX, result_codes, 0x0,
"LDAP Result Code" }},
"LDAP Result Code", HFILL }},
{ &hf_ldap_message_result_matcheddn,
{ "Matched DN", "ldap.result.matcheddn",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Result Matched DN" }},
"LDAP Result Matched DN", HFILL }},
{ &hf_ldap_message_result_errormsg,
{ "Error Message", "ldap.result.errormsg",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Result Error Message" }},
"LDAP Result Error Message", HFILL }},
{ &hf_ldap_message_result_referral,
{ "Referral", "ldap.result.referral",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Result Referral URL" }},
"LDAP Result Referral URL", HFILL }},
{ &hf_ldap_message_bind_version,
{ "Version", "ldap.bind.version",
FT_UINT32, BASE_DEC, NULL, 0x0,
"LDAP Bind Version" }},
"LDAP Bind Version", HFILL }},
{ &hf_ldap_message_bind_dn,
{ "DN", "ldap.bind.dn",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Bind Distinguished Name" }},
"LDAP Bind Distinguished Name", HFILL }},
{ &hf_ldap_message_bind_auth,
{ "Auth Type", "ldap.bind.auth_type",
FT_UINT8, BASE_HEX, auth_types, 0x0,
"LDAP Bind Auth Type" }},
"LDAP Bind Auth Type", HFILL }},
{ &hf_ldap_message_bind_auth_password,
{ "Password", "ldap.bind.password",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Bind Password" }},
"LDAP Bind Password", HFILL }},
{ &hf_ldap_message_search_base,
{ "Base DN", "ldap.search.basedn",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Search Base Distinguished Name" }},
"LDAP Search Base Distinguished Name", HFILL }},
{ &hf_ldap_message_search_scope,
{ "Scope", "ldap.search.scope",
FT_UINT8, BASE_HEX, search_scope, 0x0,
"LDAP Search Scope" }},
"LDAP Search Scope", HFILL }},
{ &hf_ldap_message_search_deref,
{ "Dereference", "ldap.search.dereference",
FT_UINT8, BASE_HEX, search_dereference, 0x0,
"LDAP Search Dereference" }},
"LDAP Search Dereference", HFILL }},
{ &hf_ldap_message_search_sizeLimit,
{ "Size Limit", "ldap.search.sizelimit",
FT_UINT32, BASE_DEC, NULL, 0x0,
"LDAP Search Size Limit" }},
"LDAP Search Size Limit", HFILL }},
{ &hf_ldap_message_search_timeLimit,
{ "Time Limit", "ldap.search.timelimit",
FT_UINT32, BASE_DEC, NULL, 0x0,
"LDAP Search Time Limit" }},
"LDAP Search Time Limit", HFILL }},
{ &hf_ldap_message_search_typesOnly,
{ "Attributes Only", "ldap.search.typesonly",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"LDAP Search Attributes Only" }},
"LDAP Search Attributes Only", HFILL }},
{ &hf_ldap_message_search_filter,
{ "Filter", "ldap.search.filter",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Search Filter" }},
"LDAP Search Filter", HFILL }},
{ &hf_ldap_message_dn,
{ "Distinguished Name", "ldap.dn",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Distinguished Name" }},
"LDAP Distinguished Name", HFILL }},
{ &hf_ldap_message_attribute,
{ "Attribute", "ldap.attribute",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Attribute" }},
"LDAP Attribute", HFILL }},
{ &hf_ldap_message_value,
{ "Value", "ldap.value",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Value" }},
"LDAP Value", HFILL }},
{ &hf_ldap_message_modrdn_name,
{ "New Name", "ldap.modrdn.name",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP New Name" }},
"LDAP New Name", HFILL }},
{ &hf_ldap_message_modrdn_delete,
{ "Delete Values", "ldap.modrdn.delete",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"LDAP Modify RDN - Delete original values" }},
"LDAP Modify RDN - Delete original values", HFILL }},
{ &hf_ldap_message_modrdn_superior,
{ "New Location", "ldap.modrdn.superior",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Modify RDN - New Location" }},
"LDAP Modify RDN - New Location", HFILL }},
{ &hf_ldap_message_compare,
{ "Test", "ldap.compare.test",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Compare Test" }},
"LDAP Compare Test", HFILL }},
{ &hf_ldap_message_modify_add,
{ "Add", "ldap.modify.add",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Add" }},
"LDAP Add", HFILL }},
{ &hf_ldap_message_modify_replace,
{ "Replace", "ldap.modify.replace",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Replace" }},
"LDAP Replace", HFILL }},
{ &hf_ldap_message_modify_delete,
{ "Delete", "ldap.modify.delete",
FT_STRING, BASE_NONE, NULL, 0x0,
"LDAP Delete" }},
"LDAP Delete", HFILL }},
{ &hf_ldap_message_abandon_msgid,
{ "Abandon Msg Id", "ldap.abandon.msgid",
FT_UINT32, BASE_DEC, NULL, 0x0,
"LDAP Abandon Msg Id" }},
"LDAP Abandon Msg Id", HFILL }},
};
static gint *ett[] = {

46
packet-ldp.c
View File

@ -1,7 +1,7 @@
/* packet-ldp.c
* Routines for ldp packet disassembly
*
* $Id: packet-ldp.c,v 1.16 2001/06/05 21:00:17 guy Exp $
* $Id: packet-ldp.c,v 1.17 2001/06/18 02:17:48 guy Exp $
*
* Copyright (c) November 2000 by Richard Sharpe <rsharpe@ns.aus.com>
*
@ -736,70 +736,70 @@ proto_register_ldp(void)
static hf_register_info hf[] = {
{ &hf_ldp_req,
/* Change the following to the type you need */
{ "Request", "ldp.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
{ "Request", "ldp.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_ldp_rsp,
{ "Response", "ldp.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
{ "Response", "ldp.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
{ &hf_ldp_version,
{ "Version", "ldp.hdr.version", FT_UINT16, BASE_DEC, NULL, 0x0, "LDP Version Number" }},
{ "Version", "ldp.hdr.version", FT_UINT16, BASE_DEC, NULL, 0x0, "LDP Version Number", HFILL }},
{ &hf_ldp_pdu_len,
{ "PDU Length", "ldp.hdr.pdu_len", FT_UINT16, BASE_DEC, NULL, 0x0, "LDP PDU Length"}},
{ "PDU Length", "ldp.hdr.pdu_len", FT_UINT16, BASE_DEC, NULL, 0x0, "LDP PDU Length", HFILL }},
{ &hf_ldp_lsr,
{ "LSR ID", "ldp.hdr.ldpid.lsr", FT_UINT32, BASE_HEX, NULL, 0x0, "LDP Label Space Router ID"}},
{ "LSR ID", "ldp.hdr.ldpid.lsr", FT_UINT32, BASE_HEX, NULL, 0x0, "LDP Label Space Router ID", HFILL }},
{ &hf_ldp_ls_id,
{ "Label Space ID", "ldp.hdr.ldpid.lsid", FT_UINT16, BASE_HEX, NULL, 0x0, "LDP Label Space ID"}},
{ "Label Space ID", "ldp.hdr.ldpid.lsid", FT_UINT16, BASE_HEX, NULL, 0x0, "LDP Label Space ID", HFILL }},
{ &hf_ldp_msg_type,
{ "Message Type", "ldp.msg.type", FT_UINT16, BASE_HEX, VALS(ldp_message_types), 0x0, "LDP message type"}},
{ "Message Type", "ldp.msg.type", FT_UINT16, BASE_HEX, VALS(ldp_message_types), 0x0, "LDP message type", HFILL }},
{ &hf_ldp_msg_len,
{ "Message Length", "ldp.msg.len", FT_UINT16, BASE_DEC, NULL, 0x0, "LDP Message Length (excluding message type and len)"}},
{ "Message Length", "ldp.msg.len", FT_UINT16, BASE_DEC, NULL, 0x0, "LDP Message Length (excluding message type and len)", HFILL }},
{ &hf_ldp_msg_id,
{ "Message ID", "ldp.msg.id", FT_UINT32, BASE_HEX, NULL, 0x0, "LDP Message ID"}},
{ "Message ID", "ldp.msg.id", FT_UINT32, BASE_HEX, NULL, 0x0, "LDP Message ID", HFILL }},
{ &hf_ldp_tlv_type,
{ "TLV Type", "ldp.msg.tlv.type", FT_UINT16, BASE_HEX, VALS(tlv_type_names), 0x0, "TLV Type Field"}},
{ "TLV Type", "ldp.msg.tlv.type", FT_UINT16, BASE_HEX, VALS(tlv_type_names), 0x0, "TLV Type Field", HFILL }},
{ &hf_ldp_tlv_len,
{"TLV Length", "ldp.msg.tlv.len", FT_UINT16, BASE_DEC, NULL, 0x0, "TLV Length Field"}},
{"TLV Length", "ldp.msg.tlv.len", FT_UINT16, BASE_DEC, NULL, 0x0, "TLV Length Field", HFILL }},
{ &hf_ldp_tlv_value,
{ "TLV Value", "ldp.msg.tlv.value", FT_BYTES, BASE_NONE, NULL, 0x0, "TLV Value Bytes"}},
{ "TLV Value", "ldp.msg.tlv.value", FT_BYTES, BASE_NONE, NULL, 0x0, "TLV Value Bytes", HFILL }},
{ &hf_ldp_tlv_val_hold,
{ "Hold Time", "ldp.msg.tlv.hello.hold", FT_UINT16, BASE_DEC, NULL, 0x0, "Hello Common Parameters Hold Time"}},
{ "Hold Time", "ldp.msg.tlv.hello.hold", FT_UINT16, BASE_DEC, NULL, 0x0, "Hello Common Parameters Hold Time", HFILL }},
{ &hf_ldp_tlv_val_target,
{ "Targeted Hello", "ldp.msg.tlv.hello.targeted", FT_BOOLEAN, 8, TFS(&hello_targeted_vals), 0x80, "Hello Common Parameters Targeted Bit"}},
{ "Targeted Hello", "ldp.msg.tlv.hello.targeted", FT_BOOLEAN, 8, TFS(&hello_targeted_vals), 0x80, "Hello Common Parameters Targeted Bit", HFILL }},
{ &hf_ldp_tlv_val_request,
{ "Hello Requested", "ldp,msg.tlv.hello.requested", FT_BOOLEAN, 8, TFS(&hello_requested_vals), 0x40, "Hello Common Parameters Hello Requested Bit" }},
{ "Hello Requested", "ldp,msg.tlv.hello.requested", FT_BOOLEAN, 8, TFS(&hello_requested_vals), 0x40, "Hello Common Parameters Hello Requested Bit", HFILL }},
{ &hf_ldp_tlv_val_res,
{ "Reserved", "ldp.msg.tlv.hello.res", FT_UINT16, BASE_HEX, NULL, 0x3FFF, "Hello Common Parameters Reserved Field"}},
{ "Reserved", "ldp.msg.tlv.hello.res", FT_UINT16, BASE_HEX, NULL, 0x3FFF, "Hello Common Parameters Reserved Field", HFILL }},
{ &hf_ldp_tlv_config_seqno,
{ "Configuration Sequence Number", "ldp.msg.tlv.hello.cnf_seqno", FT_UINT32, BASE_HEX, NULL, 0x0, "Hello COnfiguration Sequence Number"}},
{ "Configuration Sequence Number", "ldp.msg.tlv.hello.cnf_seqno", FT_UINT32, BASE_HEX, NULL, 0x0, "Hello COnfiguration Sequence Number", HFILL }},
{ &hf_ldp_tlv_fec_wc,
{ "FEC Element Type", "ldp.msg.tlv.fec.type", FT_UINT8, BASE_DEC, VALS(fec_types), 0x0, "Forwarding Equivalence Class Element Types"}},
{ "FEC Element Type", "ldp.msg.tlv.fec.type", FT_UINT8, BASE_DEC, VALS(fec_types), 0x0, "Forwarding Equivalence Class Element Types", HFILL }},
{ &hf_ldp_tlv_fec_af,
{ "FEC Element Address Type", "ldp.msg.tlv.fec.af", FT_UINT16, BASE_DEC, VALS(fec_af_types), 0x0, "Forwarding Equivalence Class Element Address Family"}},
{ "FEC Element Address Type", "ldp.msg.tlv.fec.af", FT_UINT16, BASE_DEC, VALS(fec_af_types), 0x0, "Forwarding Equivalence Class Element Address Family", HFILL }},
{ &hf_ldp_tlv_fec_len,
{ "FEC Element Length", "ldp.msg.tlv.fec.len", FT_UINT8, BASE_DEC, NULL, 0x0, "Forwarding Equivalence Class Element Length"}},
{ "FEC Element Length", "ldp.msg.tlv.fec.len", FT_UINT8, BASE_DEC, NULL, 0x0, "Forwarding Equivalence Class Element Length", HFILL }},
{ &hf_ldp_tlv_fec_pfval,
{ "FEC Element Prefix Value", "ldp.msg.tlv.fec.pfval", FT_IPv4, BASE_DEC, NULL, 0x0, "Forwarding Equivalence Class Element Prefix"}},
{ "FEC Element Prefix Value", "ldp.msg.tlv.fec.pfval", FT_IPv4, BASE_DEC, NULL, 0x0, "Forwarding Equivalence Class Element Prefix", HFILL }},
{ &hf_ldp_tlv_generic_label,
{ "Generic Label", "ldp.msg.tlv.label", FT_UINT32, BASE_HEX, NULL, 0x0, "Label Mapping Generic Label"}},
{ "Generic Label", "ldp.msg.tlv.label", FT_UINT32, BASE_HEX, NULL, 0x0, "Label Mapping Generic Label", HFILL }},
};
static gint *ett[] = {

18
packet-llc.c
View File

@ -2,7 +2,7 @@
* Routines for IEEE 802.2 LLC layer
* Gilbert Ramirez <gram@xiexie.org>
*
* $Id: packet-llc.c,v 1.86 2001/06/02 03:04:12 guy Exp $
* $Id: packet-llc.c,v 1.87 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -509,36 +509,36 @@ proto_register_llc(void)
static hf_register_info hf[] = {
{ &hf_llc_dsap,
{ "DSAP", "llc.dsap", FT_UINT8, BASE_HEX,
VALS(sap_vals), 0x0, "" }},
VALS(sap_vals), 0x0, "", HFILL }},
{ &hf_llc_dsap_ig,
{ "IG Bit", "llc.dsap.ig", FT_BOOLEAN, BASE_HEX,
&ig_bit, 0x0, "Individual/Group" }},
&ig_bit, 0x0, "Individual/Group", HFILL }},
{ &hf_llc_ssap,
{ "SSAP", "llc.ssap", FT_UINT8, BASE_HEX,
VALS(sap_vals), 0x0, "" }},
VALS(sap_vals), 0x0, "", HFILL }},
{ &hf_llc_ssap_cr,
{ "CR Bit", "llc.ssap.cr", FT_BOOLEAN, BASE_HEX,
&cr_bit, 0x0, "Command/Response" }},
&cr_bit, 0x0, "Command/Response", HFILL }},
{ &hf_llc_ctrl,
{ "Control", "llc.control", FT_UINT16, BASE_HEX,
NULL, 0x0, "" }},
NULL, 0x0, "", HFILL }},
/* registered here but handled in ethertype.c */
{ &hf_llc_type,
{ "Type", "llc.type", FT_UINT16, BASE_HEX,
VALS(etype_vals), 0x0, "" }},
VALS(etype_vals), 0x0, "", HFILL }},
{ &hf_llc_oui,
{ "Organization Code", "llc.oui", FT_UINT24, BASE_HEX,
VALS(oui_vals), 0x0, ""}},
VALS(oui_vals), 0x0, "", HFILL }},
{ &hf_llc_pid,
{ "Protocol ID", "llc.pid", FT_UINT16, BASE_HEX,
NULL, 0x0, ""}}
NULL, 0x0, "", HFILL }}
};
static gint *ett[] = {
&ett_llc,

26
packet-lmi.c
View File

@ -2,7 +2,7 @@
* Routines for Frame Relay Local Management Interface (LMI) disassembly
* Copyright 2001, Jeffrey C. Foster <jfoste@woodward.com>
*
* $Id: packet-lmi.c,v 1.4 2001/03/30 11:03:29 guy Exp $
* $Id: packet-lmi.c,v 1.5 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -196,43 +196,43 @@ proto_register_lmi(void)
static hf_register_info hf[] = {
{ &hf_lmi_call_ref,
{ "Call reference", "lmi.cmd", FT_UINT8, BASE_HEX, NULL, 0,
"Call Reference" }},
"Call Reference", HFILL }},
{ &hf_lmi_msg_type,
{ "Message Type", "lmi.msg_type", FT_UINT8, BASE_HEX, VALS(msg_type_str), 0,
"Message Type" }},
"Message Type", HFILL }},
{ &hf_lmi_inf_ele,
{ "Information Element", "lmi.inf_ele", FT_UINT8, BASE_DEC, VALS(element_type_str), 0,
"Information Element" }},
"Information Element", HFILL }},
{ &hf_lmi_inf_ele,
{ "Type", "lmi.inf_ele_type", FT_UINT8, BASE_DEC, VALS(element_type_str), 0,
"Information Element Type" }},
"Information Element Type", HFILL }},
{ &hf_lmi_inf_len,
{ "Length", "lmi.inf_ele_len", FT_UINT8, BASE_DEC, NULL, 0,
"Information Element Length" }},
"Information Element Length", HFILL }},
{ &hf_lmi_rcd_type,
{ "Record Type", "lmi.ele_rcd_type", FT_UINT8, BASE_DEC, VALS(record_type_str), 0,
"Record Type" }},
"Record Type", HFILL }},
{ &hf_lmi_send_seq,
{ "Send Seq", "lmi.send_seq", FT_UINT8, BASE_DEC, NULL, 0,
"Send Sequence" }},
"Send Sequence", HFILL }},
{ &hf_lmi_recv_seq,
{ "Recv Seq", "lmi.recv_seq", FT_UINT8, BASE_DEC, NULL, 0,
"Receive Sequence" }},
"Receive Sequence", HFILL }},
{ &hf_lmi_dlci_high,
{ "DLCI High", "lmi.dlci_hi", FT_UINT8, BASE_DEC, NULL, 0x3f,
"DLCI High bits" }},
"DLCI High bits", HFILL }},
{ &hf_lmi_dlci_low,
{ "DLCI Low", "lmi.dlci_low", FT_UINT8, BASE_DEC, NULL, 0x78,
"DLCI Low bits" }},
"DLCI Low bits", HFILL }},
{ &hf_lmi_new,
{ "DLCI New", "lmi.dlci_new", FT_UINT8, BASE_DEC, VALS(pvc_status_new_str), 0x08,
"DLCI New Flag" }},
"DLCI New Flag", HFILL }},
{ &hf_lmi_act,
{ "DLCI Active","lmi.dlci_act", FT_UINT8, BASE_DEC, VALS(pvc_status_act_str), 0x02,
"DLCI Active Flag" }},
"DLCI Active Flag", HFILL }},
};
static gint *ett[] = {
&ett_lmi,

6
packet-lpd.c
View File

@ -2,7 +2,7 @@
* Routines for LPR and LPRng packet disassembly
* Gilbert Ramirez <gram@xiexie.org>
*
* $Id: packet-lpd.c,v 1.27 2001/01/22 08:03:45 guy Exp $
* $Id: packet-lpd.c,v 1.28 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -173,12 +173,12 @@ proto_register_lpd(void)
{ &hf_lpd_response,
{ "Response", "lpd.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if LPD response" }},
"TRUE if LPD response", HFILL }},
{ &hf_lpd_request,
{ "Request", "lpd.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if LPD request" }}
"TRUE if LPD request", HFILL }}
};
static gint *ett[] = {
&ett_lpd,

42
packet-m3ua.c
View File

@ -8,7 +8,7 @@
*
* Copyright 2000, Michael Tüxen <Michael.Tuexen@icn.siemens.de>
*
* $Id: packet-m3ua.c,v 1.7 2001/05/24 08:13:56 guy Exp $
* $Id: packet-m3ua.c,v 1.8 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -848,102 +848,102 @@ proto_register_m3ua(void)
{ &hf_m3ua_version,
{ "Version", "m3ua.version",
FT_UINT8, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_reserved,
{ "Reserved", "m3ua.reserved",
FT_UINT8, BASE_HEX, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_message_class,
{ "Message class", "m3ua.message_class",
FT_UINT8, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_message_type,
{ "Message Type", "m3ua.message_type",
FT_UINT8, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_message_length,
{ "Message length", "m3ua.message_length",
FT_UINT32, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_parameter_tag,
{ "Parameter Tag", "m3ua.parameter_tag",
FT_UINT16, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_parameter_length,
{ "Parameter length", "m3ua.parameter_length",
FT_UINT16, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_network_appearance,
{ "Network appearance", "m3ua.network_appearance",
FT_UINT32, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_info_string,
{ "Info string", "m3ua.info_string",
FT_STRING, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_error_code,
{ "Error code", "m3ua.error_code",
FT_UINT32, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_status_type,
{ "Status type", "m3ua.status_type",
FT_UINT16, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_status_info,
{ "Status info", "m3ua.status_info",
FT_UINT16, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_unavailability_cause,
{ "Unavailability cause", "m3ua.unavailability_cause",
FT_UINT16, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_user_identity,
{ "User Identity", "m3ua.user_identity",
FT_UINT16, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_reason,
{ "Reason", "m3ua.reason",
FT_UINT32, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_traffic_mode_type,
{ "Traffic mode Type", "m3ua.traffic_mode_type",
FT_UINT32, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_routing_context,
{ "Routing context", "m3ua.routing_context",
FT_UINT32, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_mask,
{ "Mask", "m3ua.mask",
FT_UINT8, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_dpc,
{ "Affected DPC", "m3ua.affected_dpc",
FT_UINT24, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
{ &hf_m3ua_congestion_level,
{ "Congestion level", "m3ua.congestion_level",
FT_UINT8, BASE_DEC, NULL, 0x0,
""}
"", HFILL }
},
};

6
packet-mapi.c
View File

@ -1,7 +1,7 @@
/* packet-mapi.c
* Routines for MSX mapi packet dissection
*
* $Id: packet-mapi.c,v 1.15 2001/04/09 02:15:10 guy Exp $
* $Id: packet-mapi.c,v 1.16 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -112,12 +112,12 @@ proto_register_mapi(void)
{ &hf_mapi_response,
{ "Response", "mapi.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if MAPI response" }},
"TRUE if MAPI response", HFILL }},
{ &hf_mapi_request,
{ "Request", "mapi.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if MAPI request" }}
"TRUE if MAPI request", HFILL }}
};
static gint *ett[] = {

12
packet-mbtcp.c
View File

@ -10,7 +10,7 @@
*
* for information on Modbus/TCP.
*
* $Id: packet-mbtcp.c,v 1.3 2001/04/24 23:22:03 guy Exp $
* $Id: packet-mbtcp.c,v 1.4 2001/06/18 02:17:48 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -368,28 +368,28 @@ proto_register_modbus(void)
{ &hf_mbtcp_transid,
{ "transaction identifier", "modbus_tcp.trans_id",
FT_UINT16, BASE_DEC, NULL, 0x0,
"" }
"", HFILL }
},
{ &hf_mbtcp_protid,
{ "protocol identifier", "modbus_tcp.prot_id",
FT_UINT16, BASE_DEC, NULL, 0x0,
"" }
"", HFILL }
},
{ &hf_mbtcp_len,
{ "length", "modbus_tcp.len",
FT_UINT16, BASE_DEC, NULL, 0x0,
"" }
"", HFILL }
},
/* Modbus header fields */
{ &hf_mbtcp_unitid,
{ "unit identifier", "modbus_tcp.unit_id",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }
"", HFILL }
},
{ &hf_mbtcp_functioncode,
{ "function code ", "modbus_tcp.func_code",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }
"", HFILL }
}
};

40
packet-mip.c
View File

@ -2,7 +2,7 @@
* Routines for Mobile IP dissection
* Copyright 2000, Stefan Raab <sraab@cisco.com>
*
* $Id: packet-mip.c,v 1.17 2001/04/20 20:34:29 guy Exp $
* $Id: packet-mip.c,v 1.18 2001/06/18 02:17:49 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -279,99 +279,99 @@ void proto_register_mip(void)
{ &hf_mip_type,
{ "Message Type", "mip.type",
FT_INT8, BASE_DEC, VALS(mip_types), 0,
"Mobile IP Message type." }
"Mobile IP Message type.", HFILL }
},
{ &hf_mip_s,
{"Simultaneous Bindings", "mip.s",
FT_BOOLEAN, 8, NULL, 128,
"Simultaneous Bindings Allowed" }
"Simultaneous Bindings Allowed", HFILL }
},
{ &hf_mip_b,
{"Broadcast Datagrams", "mip.b",
FT_BOOLEAN, 8, NULL, 64,
"Broadcast Datagrams requested" }
"Broadcast Datagrams requested", HFILL }
},
{ &hf_mip_d,
{ "Co-lcated Care-of Address", "mip.d",
FT_BOOLEAN, 8, NULL, 32,
"MN using Co-located Care-of address" }
"MN using Co-located Care-of address", HFILL }
},
{ &hf_mip_m,
{"Minimal Encapsulation", "mip.m",
FT_BOOLEAN, 8, NULL, 16,
"MN wants Minimal encapsulation" }
"MN wants Minimal encapsulation", HFILL }
},
{ &hf_mip_g,
{"GRE", "mip.g",
FT_BOOLEAN, 8, NULL, 8,
"MN wants GRE encapsulation" }
"MN wants GRE encapsulation", HFILL }
},
{ &hf_mip_v,
{ "Van Jacobson", "mip.v",
FT_BOOLEAN, 8, NULL, 4,
"Van Jacobson" }
"Van Jacobson", HFILL }
},
{ &hf_mip_t,
{ "Reverse Tunneling", "mip.t",
FT_BOOLEAN, 8, NULL, 2,
"Reverse tunneling requested" }
"Reverse tunneling requested", HFILL }
},
{ &hf_mip_code,
{ "Reply Code", "mip.code",
FT_UINT8, BASE_DEC, VALS(mip_reply_codes), 0,
"Mobile IP Reply code." }
"Mobile IP Reply code.", HFILL }
},
{ &hf_mip_life,
{ "Lifetime", "mip.life",
FT_UINT16, BASE_DEC, NULL, 0,
"Mobile IP Lifetime." }
"Mobile IP Lifetime.", HFILL }
},
{ &hf_mip_homeaddr,
{ "Home Address", "mip.homeaddr",
FT_IPv4, BASE_NONE, NULL, 0,
"Mobile Node's home address." }
"Mobile Node's home address.", HFILL }
},
{ &hf_mip_haaddr,
{ "Home Agent", "mip.haaddr",
FT_IPv4, BASE_NONE, NULL, 0,
"Home agent IP Address." }
"Home agent IP Address.", HFILL }
},
{ &hf_mip_coa,
{ "Care of Address", "mip.coa",
FT_IPv4, BASE_NONE, NULL, 0,
"Care of Address." }
"Care of Address.", HFILL }
},
{ &hf_mip_ident,
{ "Identification", "mip.ident",
FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0,
"MN Identification." }
"MN Identification.", HFILL }
},
{ &hf_mip_ext_type,
{ "Extension Type", "mip.ext.type",
FT_INT8, BASE_DEC, VALS(mip_ext_types), 0,
"Mobile IP Extension Type." }
"Mobile IP Extension Type.", HFILL }
},
{ &hf_mip_ext_len,
{ "Extension Length", "mip.ext.len",
FT_INT8, BASE_DEC, NULL, 0,
"Mobile IP Extension Length."}
"Mobile IP Extension Length.", HFILL }
},
{ &hf_mip_aext_spi,
{ "SPI", "mip.auth.spi",
FT_INT32, BASE_HEX, NULL, 0,
"Authentication Header Security Parameter Index."}
"Authentication Header Security Parameter Index.", HFILL }
},
{ &hf_mip_aext_auth,
{ "Authenticator", "mip.auth.auth",
FT_BYTES, BASE_NONE, NULL, 0,
"Authenticator."}
"Authenticator.", HFILL }
},
{ &hf_mip_next_nai,
{ "NAI", "mip.nai",
FT_STRING, BASE_NONE, NULL, 0,
"NAI"}
"NAI", HFILL }
},
};

60
packet-mount.c
View File

@ -1,7 +1,7 @@
/* packet-mount.c
* Routines for mount dissection
*
* $Id: packet-mount.c,v 1.24 2001/05/30 06:01:01 guy Exp $
* $Id: packet-mount.c,v 1.25 2001/06/18 02:17:49 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -583,109 +583,109 @@ proto_register_mount(void)
static hf_register_info hf[] = {
{ &hf_mount_path, {
"Path", "mount.path", FT_STRING, BASE_DEC,
NULL, 0, "Path" }},
NULL, 0, "Path", HFILL }},
{ &hf_mount3_status, {
"Status", "mount.status", FT_UINT32, BASE_DEC,
VALS(mount3_mountstat3), 0, "Status" }},
VALS(mount3_mountstat3), 0, "Status", HFILL }},
{ &hf_mount_mountlist_hostname, {
"Hostname", "mount.dump.hostname", FT_STRING, BASE_DEC,
NULL, 0, "Hostname" }},
NULL, 0, "Hostname", HFILL }},
{ &hf_mount_mountlist_directory, {
"Directory", "mount.dump.directory", FT_STRING, BASE_DEC,
NULL, 0, "Directory" }},
NULL, 0, "Directory", HFILL }},
{ &hf_mount_mountlist, {
"Mount List Entry", "mount.dump.entry", FT_NONE, 0,
NULL, 0, "Mount List Entry" }},
NULL, 0, "Mount List Entry", HFILL }},
{ &hf_mount_groups_group, {
"Group", "mount.export.group", FT_STRING, BASE_DEC,
NULL, 0, "Group" }},
NULL, 0, "Group", HFILL }},
{ &hf_mount_groups, {
"Groups", "mount.export.groups", FT_NONE, 0,
NULL, 0, "Groups" }},
NULL, 0, "Groups", HFILL }},
{ &hf_mount_exportlist_directory, {
"Directory", "mount.export.directory", FT_STRING, BASE_DEC,
NULL, 0, "Directory" }},
NULL, 0, "Directory", HFILL }},
{ &hf_mount_exportlist, {
"Export List Entry", "mount.export.entry", FT_NONE, 0,
NULL, 0, "Export List Entry" }},
NULL, 0, "Export List Entry", HFILL }},
{ &hf_mount_pathconf_link_max, {
"Maximum number of links to a file", "mount.pathconf.link_max",
FT_UINT32, BASE_DEC,
NULL, 0, "Maximum number of links allowed to a file" }},
NULL, 0, "Maximum number of links allowed to a file", HFILL }},
{ &hf_mount_pathconf_max_canon, {
"Maximum terminal input line length", "mount.pathconf.max_canon",
FT_UINT16, BASE_DEC,
NULL, 0, "Max tty input line length" }},
NULL, 0, "Max tty input line length", HFILL }},
{ &hf_mount_pathconf_max_input, {
"Terminal input buffer size", "mount.pathconf.max_input",
FT_UINT16, BASE_DEC,
NULL, 0, "Terminal input buffer size" }},
NULL, 0, "Terminal input buffer size", HFILL }},
{ &hf_mount_pathconf_name_max, {
"Maximum file name length", "mount.pathconf.name_max",
FT_UINT16, BASE_DEC,
NULL, 0, "Maximum file name length" }},
NULL, 0, "Maximum file name length", HFILL }},
{ &hf_mount_pathconf_path_max, {
"Maximum path name length", "mount.pathconf.path_max",
FT_UINT16, BASE_DEC,
NULL, 0, "Maximum path name length" }},
NULL, 0, "Maximum path name length", HFILL }},
{ &hf_mount_pathconf_pipe_buf, {
"Pipe buffer size", "mount.pathconf.pipe_buf",
FT_UINT16, BASE_DEC,
NULL, 0, "Maximum amount of data that can be written atomically to a pipe" }},
NULL, 0, "Maximum amount of data that can be written atomically to a pipe", HFILL }},
{ &hf_mount_pathconf_vdisable, {
"VDISABLE character", "mount.pathconf.vdisable_char",
FT_UINT8, BASE_HEX,
NULL, 0, "Character value to disable a terminal special character" }},
NULL, 0, "Character value to disable a terminal special character", HFILL }},
{ &hf_mount_pathconf_mask, {
"Reply error/status bits", "mount.pathconf.mask",
FT_UINT16, BASE_HEX,
NULL, 0, "Bit mask with error and status bits" }},
NULL, 0, "Bit mask with error and status bits", HFILL }},
{ &hf_mount_pathconf_error_all, {
"ERROR_ALL", "mount.pathconf.mask.error_all",
FT_BOOLEAN, 16, TFS(&tos_error_all),
PC_ERROR_ALL, "" }},
PC_ERROR_ALL, "", HFILL }},
{ &hf_mount_pathconf_error_link_max, {
"ERROR_LINK_MAX", "mount.pathconf.mask.error_link_max",
FT_BOOLEAN, 16, TFS(&tos_error_link_max),
PC_ERROR_LINK_MAX, "" }},
PC_ERROR_LINK_MAX, "", HFILL }},
{ &hf_mount_pathconf_error_max_canon, {
"ERROR_MAX_CANON", "mount.pathconf.mask.error_max_canon",
FT_BOOLEAN, 16, TFS(&tos_error_max_canon),
PC_ERROR_MAX_CANON, "" }},
PC_ERROR_MAX_CANON, "", HFILL }},
{ &hf_mount_pathconf_error_max_input, {
"ERROR_MAX_INPUT", "mount.pathconf.mask.error_max_input",
FT_BOOLEAN, 16, TFS(&tos_error_max_input),
PC_ERROR_MAX_INPUT, "" }},
PC_ERROR_MAX_INPUT, "", HFILL }},
{ &hf_mount_pathconf_error_name_max, {
"ERROR_NAME_MAX", "mount.pathconf.mask.error_name_max",
FT_BOOLEAN, 16, TFS(&tos_error_name_max),
PC_ERROR_NAME_MAX, "" }},
PC_ERROR_NAME_MAX, "", HFILL }},
{ &hf_mount_pathconf_error_path_max, {
"ERROR_PATH_MAX", "mount.pathconf.mask.error_path_max",
FT_BOOLEAN, 16, TFS(&tos_error_path_max),
PC_ERROR_PATH_MAX, "" }},
PC_ERROR_PATH_MAX, "", HFILL }},
{ &hf_mount_pathconf_error_pipe_buf, {
"ERROR_PIPE_BUF", "mount.pathconf.mask.error_pipe_buf",
FT_BOOLEAN, 16, TFS(&tos_error_pipe_buf),
PC_ERROR_PIPE_BUF, "" }},
PC_ERROR_PIPE_BUF, "", HFILL }},
{ &hf_mount_pathconf_chown_restricted, {
"CHOWN_RESTRICTED", "mount.pathconf.mask.chown_restricted",
FT_BOOLEAN, 16, TFS(&tos_chown_restricted),
PC_CHOWN_RESTRICTED, "" }},
PC_CHOWN_RESTRICTED, "", HFILL }},
{ &hf_mount_pathconf_no_trunc, {
"NO_TRUNC", "mount.pathconf.mask.no_trunc",
FT_BOOLEAN, 16, TFS(&tos_no_trunc),
PC_NO_TRUNC, "" }},
PC_NO_TRUNC, "", HFILL }},
{ &hf_mount_pathconf_error_vdisable, {
"ERROR_VDISABLE", "mount.pathconf.mask.error_vdisable",
FT_BOOLEAN, 16, TFS(&tos_error_vdisable),
PC_ERROR_VDISABLE, "" }},
PC_ERROR_VDISABLE, "", HFILL }},
{ &hf_mount_flavors, {
"Flavors", "mount.flavors", FT_UINT32, BASE_DEC,
NULL, 0, "Flavors" }},
NULL, 0, "Flavors", HFILL }},
{ &hf_mount_flavor, {
"Flavor", "mount.flavor", FT_UINT32, BASE_DEC,
VALS(rpc_auth_flavor), 0, "Flavor" }},
VALS(rpc_auth_flavor), 0, "Flavor", HFILL }},
};
static gint *ett[] = {
&ett_mount,

30
packet-mpeg1.c
View File

@ -2,7 +2,7 @@
*
* Routines for RFC 2250 MPEG-1 dissection
*
* $Id: packet-mpeg1.c,v 1.1 2001/06/14 09:25:23 guy Exp $
* $Id: packet-mpeg1.c,v 1.2 2001/06/18 02:17:49 guy Exp $
*
* Copyright 2001,
* Francisco Javier Cabello Torres, <fjcabello@vtools.es>
@ -211,7 +211,7 @@ proto_register_mpeg1(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -223,7 +223,7 @@ proto_register_mpeg1(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -235,7 +235,7 @@ proto_register_mpeg1(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -247,7 +247,7 @@ proto_register_mpeg1(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
@ -260,7 +260,7 @@ proto_register_mpeg1(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
@ -273,7 +273,7 @@ proto_register_mpeg1(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
@ -286,7 +286,7 @@ proto_register_mpeg1(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
@ -299,7 +299,7 @@ proto_register_mpeg1(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
@ -312,7 +312,7 @@ proto_register_mpeg1(void)
BASE_DEC,
VALS(rtp_mpg_picture_types_vals),
0x0,
""
"", HFILL
}
},
@ -325,7 +325,7 @@ proto_register_mpeg1(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
@ -338,7 +338,7 @@ proto_register_mpeg1(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -350,7 +350,7 @@ proto_register_mpeg1(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
@ -363,7 +363,7 @@ proto_register_mpeg1(void)
BASE_DEC,
NULL,
0x0,
""
"", HFILL
}
},
{
@ -375,7 +375,7 @@ proto_register_mpeg1(void)
BASE_NONE,
NULL,
0x0,
""
"", HFILL
}
},

12
packet-mpls.c
View File

@ -3,7 +3,7 @@
*
* (c) Copyright Ashok Narayanan <ashokn@cisco.com>
*
* $Id: packet-mpls.c,v 1.20 2001/04/23 18:05:19 guy Exp $
* $Id: packet-mpls.c,v 1.21 2001/06/18 02:17:49 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -89,23 +89,23 @@ static hf_register_info mplsf_info[] = {
/* {&mpls_filter[MPLSF_PACKET],
{"MPLS Label Switched Packet", "mpls", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},*/
"", HFILL }},*/
{&mpls_filter[MPLSF_LABEL],
{"MPLS Label", "mpls.label", FT_UINT32, BASE_DEC, VALS(special_labels), 0x0,
"" }},
"", HFILL }},
{&mpls_filter[MPLSF_EXP],
{"MPLS Experimental Bits", "mpls.exp", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{&mpls_filter[MPLSF_BOTTOM_OF_STACK],
{"MPLS Bottom Of Label Stack", "mpls.bottom", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{&mpls_filter[MPLSF_TTL],
{"MPLS TTL", "mpls.ttl", FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
};
static dissector_handle_t ip_handle;

34
packet-msproxy.c
View File

@ -2,7 +2,7 @@
* Routines for Microsoft Proxy packet dissection
* Copyright 2000, Jeffrey C. Foster <jfoste@woodward.com>
*
* $Id: packet-msproxy.c,v 1.20 2001/06/08 08:36:40 guy Exp $
* $Id: packet-msproxy.c,v 1.21 2001/06/18 02:17:49 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -1186,87 +1186,87 @@ proto_register_msproxy( void){
{ &hf_msproxy_cmd,
{ "Command", "msproxy.command", FT_UINT16, BASE_DEC,
NULL, 0x0, ""
NULL, 0x0, "", HFILL
}
},
{ &hf_msproxy_dstaddr,
{ "Destination Address", "msproxy.dstaddr", FT_IPv4, BASE_NONE, NULL,
0x0, ""
0x0, "", HFILL
}
},
{ &hf_msproxy_srcport,
{ "Source Port", "msproxy.srcport", FT_UINT16,
BASE_DEC, NULL, 0x0, ""
BASE_DEC, NULL, 0x0, "", HFILL
}
},
{ &hf_msproxy_dstport,
{ "Destination Port", "msproxy.dstport", FT_UINT16,
BASE_DEC, NULL, 0x0, ""
BASE_DEC, NULL, 0x0, "", HFILL
}
},
{ &hf_msproxy_clntport,
{ "Client Port", "msproxy.clntport", FT_UINT16,
BASE_DEC, NULL, 0x0, ""
BASE_DEC, NULL, 0x0, "", HFILL
}
},
{ &hf_msproxy_server_ext_addr,
{ "Server External Address", "msproxy.server_ext_addr", FT_IPv4, BASE_NONE, NULL,
0x0, ""
0x0, "", HFILL
}
},
{ &hf_msproxy_server_ext_port,
{ "Server External Port", "msproxy.server_ext_port", FT_UINT16,
BASE_DEC, NULL, 0x0, ""
BASE_DEC, NULL, 0x0, "", HFILL
}
},
{ &hf_msproxy_server_int_addr,
{ "Server Internal Address", "msproxy.server_int_addr", FT_IPv4, BASE_NONE, NULL,
0x0, ""
0x0, "", HFILL
}
},
{ &hf_msproxy_server_int_port,
{ "Server Internal Port", "msproxy.server_int_port", FT_UINT16,
BASE_DEC, NULL, 0x0, ""
BASE_DEC, NULL, 0x0, "", HFILL
}
},
{ &hf_msproxy_serverport,
{ "Server Port", "msproxy.serverport", FT_UINT16,
BASE_DEC, NULL, 0x0, ""
BASE_DEC, NULL, 0x0, "", HFILL
}
},
{ &hf_msproxy_bindport,
{ "Bind Port", "msproxy.bindport", FT_UINT16,
BASE_DEC, NULL, 0x0, ""
BASE_DEC, NULL, 0x0, "", HFILL
}
},
{ &hf_msproxy_boundport,
{ "Bound Port", "msproxy.boundport", FT_UINT16,
BASE_DEC, NULL, 0x0, ""
BASE_DEC, NULL, 0x0, "", HFILL
}
},
{ &hf_msproxy_serveraddr,
{ "Server Address", "msproxy.serveraddr", FT_IPv4, BASE_NONE, NULL,
0x0, ""
0x0, "", HFILL
}
},
{ &hf_msproxy_bindaddr,
{ "Destination", "msproxy.bindaddr", FT_IPv4, BASE_NONE, NULL,
0x0, ""
0x0, "", HFILL
}
},
{ &hf_msproxy_bind_id,
{ "Bound Port Id", "msproxy.bindid", FT_UINT32,
BASE_HEX, NULL, 0x0, ""
BASE_HEX, NULL, 0x0, "", HFILL
}
},
{ &hf_msproxy_resolvaddr,
{ "Address", "msproxy.resolvaddr", FT_IPv4, BASE_NONE, NULL,
0x0, ""
0x0, "", HFILL
}
}

14
packet-mtp3.c
View File

@ -2,7 +2,7 @@
* Routines for Message Transfer Part Level 3 dissection
* Copyright 2001, Michael Tuexen <Michael.Tuexen@icn.siemens.de>
*
* $Id: packet-mtp3.c,v 1.3 2001/05/31 08:51:29 guy Exp $
* $Id: packet-mtp3.c,v 1.4 2001/06/18 02:17:49 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -212,32 +212,32 @@ proto_register_mtp3(void)
{ "Service indicator",
"mtp3.service_indicator",
FT_UINT8, BASE_HEX, VALS(service_indicator_code_vals), SERVICE_INDICATOR_MASK,
"" }},
"", HFILL }},
{ &hf_mtp3_network_indicator,
{ "Network indicator",
"mtp3.network_indicator",
FT_UINT8, BASE_HEX, VALS(network_indicator_vals), NETWORK_INDICATOR_MASK,
"" }},
"", HFILL }},
{ &hf_mtp3_spare,
{ "Spare",
"mtp3.spare",
FT_UINT8, BASE_HEX, NULL, SPARE_MASK,
"" }},
"", HFILL }},
{ &hf_mtp3_opc,
{ "OPC",
"mtp3.opc",
FT_UINT32, BASE_DEC, NULL, OPC_MASK,
"" }},
"", HFILL }},
{ &hf_mtp3_dpc,
{ "DPC",
"mtp3.dpc",
FT_UINT32, BASE_DEC, NULL, DPC_MASK,
"" }},
"", HFILL }},
{ &hf_mtp3_sls,
{ "SLS",
"mtp3.sls",
FT_UINT32, BASE_DEC, NULL, SLS_MASK,
"" }},
"", HFILL }},
};
/* Setup protocol subtree array */

34
packet-nbns.c
View File

@ -4,7 +4,7 @@
* Gilbert Ramirez <gram@xiexie.org>
* Much stuff added by Guy Harris <guy@alum.mit.edu>
*
* $Id: packet-nbns.c,v 1.51 2001/01/22 08:03:45 guy Exp $
* $Id: packet-nbns.c,v 1.52 2001/06/18 02:17:49 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -1672,73 +1672,73 @@ proto_register_nbt(void)
{ &hf_nbns_response,
{ "Response", "nbns.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if NBNS response" }},
"TRUE if NBNS response", HFILL }},
{ &hf_nbns_query,
{ "Query", "nbns.query",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if NBNS query" }},
"TRUE if NBNS query", HFILL }},
{ &hf_nbns_transaction_id,
{ "Transaction ID", "nbns.id",
FT_UINT16, BASE_HEX, NULL, 0x0,
"Identification of transaction" }},
"Identification of transaction", HFILL }},
{ &hf_nbns_count_questions,
{ "Questions", "nbns.count.queries",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Number of queries in packet" }},
"Number of queries in packet", HFILL }},
{ &hf_nbns_count_answers,
{ "Answer RRs", "nbns.count.answers",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Number of answers in packet" }},
"Number of answers in packet", HFILL }},
{ &hf_nbns_count_auth_rr,
{ "Authority RRs", "nbns.count.auth_rr",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Number of authoritative records in packet" }},
"Number of authoritative records in packet", HFILL }},
{ &hf_nbns_count_add_rr,
{ "Additional RRs", "nbns.count.add_rr",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Number of additional records in packet" }}
"Number of additional records in packet", HFILL }}
};
static hf_register_info hf_nbdgm[] = {
{ &hf_nbdgm_type,
{ "Message Type", "nbdgm.type",
FT_UINT8, BASE_DEC, NULL, 0x0,
"NBDGM message type" }},
"NBDGM message type", HFILL }},
{ &hf_nbdgm_fragment,
{ "Fragmented", "nbdgm.next",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if more fragments follow" }},
"TRUE if more fragments follow", HFILL }},
{ &hf_nbdgm_first,
{ "First fragment", "nbdgm.first",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if first fragment" }},
"TRUE if first fragment", HFILL }},
{ &hf_nbdgm_node_type,
{ "Node Type", "nbdgm.node_type",
FT_UINT8, BASE_DEC, NULL, 0x0,
"Node type" }},
"Node type", HFILL }},
{ &hf_nbdgm_datagram_id,
{ "Datagram ID", "nbdgm.dgram_id",
FT_UINT16, BASE_HEX, NULL, 0x0,
"Datagram identifier" }},
"Datagram identifier", HFILL }},
{ &hf_nbdgm_src_ip,
{ "Source IP", "nbdgm.src.ip",
FT_IPv4, BASE_NONE, NULL, 0x0,
"Source IPv4 address" }},
"Source IPv4 address", HFILL }},
{ &hf_nbdgm_src_port,
{ "Source Port", "nbdgm.src.port",
FT_UINT16, BASE_DEC, NULL, 0x0,
"Source port" }}
"Source port", HFILL }}
};
static hf_register_info hf_nbss[] = {
{ &hf_nbss_type,
{ "Message Type", "nbss.type",
FT_UINT8, BASE_DEC, NULL, 0x0,
"NBSS message type" }},
"NBSS message type", HFILL }},
{ &hf_nbss_flags,
{ "Flags", "nbss.flags",
FT_UINT8, BASE_HEX, NULL, 0x0,
"NBSS message flags" }}
"NBSS message flags", HFILL }}
};
static gint *ett[] = {
&ett_nbns,

18
packet-ncp.c
View File

@ -3,7 +3,7 @@
* Gilbert Ramirez <gram@xiexie.org>
* Modified to allow NCP over TCP/IP decodes by James Coe <jammer@cin.net>
*
* $Id: packet-ncp.c,v 1.47 2001/01/22 03:33:45 guy Exp $
* $Id: packet-ncp.c,v 1.48 2001/06/18 02:17:49 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -345,35 +345,35 @@ proto_register_ncp(void)
{ &hf_ncp_ip_sig,
{ "NCP over IP signature", "ncp.ip.signature",
FT_UINT32, BASE_HEX, VALS(ncp_ip_signature), 0x0,
"" }},
"", HFILL }},
{ &hf_ncp_ip_length,
{ "NCP over IP length", "ncp.ip.length",
FT_UINT32, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ncp_ip_ver,
{ "NCP over IP Version", "ncp.ip.version",
FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ncp_ip_rplybufsize,
{ "NCP over IP Reply Buffer Size", "ncp.ip.replybufsize",
FT_UINT32, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ncp_type,
{ "Type", "ncp.type",
FT_UINT16, BASE_HEX, VALS(ncp_type_vals), 0x0,
"NCP message type" }},
"NCP message type", HFILL }},
{ &hf_ncp_seq,
{ "Sequence Number", "ncp.seq",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ncp_connection,
{ "Connection Number", "ncp.connection",
FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_ncp_task,
{ "Task Number", "ncp.task",
FT_UINT8, BASE_DEC, NULL, 0x0,
"" }}
"", HFILL }}
};
static gint *ett[] = {
&ett_ncp,

36
packet-netbios.c
View File

@ -5,7 +5,7 @@
*
* derived from the packet-nbns.c
*
* $Id: packet-netbios.c,v 1.33 2001/05/27 08:45:51 guy Exp $
* $Id: packet-netbios.c,v 1.34 2001/06/18 02:17:49 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -1075,67 +1075,67 @@ void proto_register_netbios(void)
static hf_register_info hf_netb[] = {
{ &hf_netb_cmd,
{ "Command", "netbios.command", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_netb_hdr_len,
{ "Header Length", "netbios.hdr_len", FT_UINT16, BASE_DEC, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_netb_xmit_corrl,
{ "Transmit Correlator", "netbios.xmit_corrl", FT_INT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_netb_resp_corrl,
{ "Response Correlator", "netbios.resp_corrl", FT_INT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_netb_call_name_type,
{ "Call Name Type", "netbios.call_name_type", FT_INT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_netb_name_type,
{ "Netbios Name Type", "netbios.name_type", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_netb_name,
{ "Netbios Name", "netbios.name", FT_STRING, BASE_NONE, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_netb_ack,
{ "Acknowledge", "netbios.ack", FT_BOOLEAN, 8, TFS( &flags_set), 0x08,
"" }},
"", HFILL }},
{ &hf_netb_ack_with_data,
{ "Acknowledge with data", "netbios.ack_with_data", FT_BOOLEAN, 8, TFS( &flags_allowed), 0x04,
"" }},
"", HFILL }},
{ &hf_netb_ack_expected,
{ "Acknowledge expected", "netbios.ack_expected", FT_BOOLEAN, 8,
TFS( &flags_yes_no), 0x02, "" }},
TFS( &flags_yes_no), 0x02, "", HFILL }},
{ &hf_netb_recv_cont_req,
{ "RECEIVE_CONTINUE requested", "netbios.recv_cont_req", FT_BOOLEAN, 8,
TFS( &flags_yes_no), 0x01, "" }},
TFS( &flags_yes_no), 0x01, "", HFILL }},
{ &hf_netb_send_no_ack,
{ "Handle SEND.NO.ACK", "netbios.send_no_ack", FT_BOOLEAN, 8,
TFS( &flags_yes_no), 0x80, "" }},
TFS( &flags_yes_no), 0x80, "", HFILL }},
{ &hf_netb_version,
{ "NetBIOS Version", "netbios.version", FT_BOOLEAN, 8,
TFS( &netb_version_str), 0x01, "" }},
TFS( &netb_version_str), 0x01, "", HFILL }},
{ &hf_netb_largest_frame,
{ "Largest Frame", "netbios.largest_frame", FT_UINT8, BASE_HEX, NULL, 0x0E,
"" }},
"", HFILL }},
{ &hf_netb_local_ses_no,
{ "Local Session No. ", "netbios.local_session", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_netb_remote_ses_no,
{ "Remote Session No. ", "netbios.remote_session", FT_UINT8, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
{ &hf_netb_data2,
{ "DATA2 value ", "netbios.data2", FT_UINT16, BASE_HEX, NULL, 0x0,
"" }},
"", HFILL }},
};
proto_netbios = proto_register_protocol("NetBIOS", "NetBIOS", "netbios");

402
packet-nfs.c
View File

@ -3,7 +3,7 @@
* Copyright 1999, Uwe Girlich <Uwe.Girlich@philosys.de>
* Copyright 2000-2001, Mike Frisch <frisch@hummingbird.com> (NFSv4 decoding)
*
* $Id: packet-nfs.c,v 1.53 2001/05/30 06:01:01 guy Exp $
* $Id: packet-nfs.c,v 1.54 2001/06/18 02:17:49 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -5640,748 +5640,748 @@ proto_register_nfs(void)
static hf_register_info hf[] = {
{ &hf_nfs_fh_fsid_major, {
"major", "nfs.fh.fsid.major", FT_UINT32, BASE_DEC,
NULL, 0, "major file system ID" }},
NULL, 0, "major file system ID", HFILL }},
{ &hf_nfs_fh_fsid_minor, {
"minor", "nfs.fh.fsid.minor", FT_UINT32, BASE_DEC,
NULL, 0, "minor file system ID" }},
NULL, 0, "minor file system ID", HFILL }},
{ &hf_nfs_fh_xfsid_major, {
"exported major", "nfs.fh.xfsid.major", FT_UINT32, BASE_DEC,
NULL, 0, "exported major file system ID" }},
NULL, 0, "exported major file system ID", HFILL }},
{ &hf_nfs_fh_xfsid_minor, {
"exported minor", "nfs.fh.xfsid.minor", FT_UINT32, BASE_DEC,
NULL, 0, "exported minor file system ID" }},
NULL, 0, "exported minor file system ID", HFILL }},
{ &hf_nfs_fh_fstype, {
"file system type", "nfs.fh.fstype", FT_UINT32, BASE_DEC,
NULL, 0, "file system type" }},
NULL, 0, "file system type", HFILL }},
{ &hf_nfs_fh_fn, {
"file number", "nfs.fh.fn", FT_UINT32, BASE_DEC,
NULL, 0, "file number" }},
NULL, 0, "file number", HFILL }},
{ &hf_nfs_fh_fn_len, {
"length", "nfs.fh.fn.len", FT_UINT32, BASE_DEC,
NULL, 0, "file number length" }},
NULL, 0, "file number length", HFILL }},
{ &hf_nfs_fh_fn_inode, {
"inode", "nfs.fh.fn.inode", FT_UINT32, BASE_DEC,
NULL, 0, "file number inode" }},
NULL, 0, "file number inode", HFILL }},
{ &hf_nfs_fh_fn_generation, {
"generation", "nfs.fh.fn.generation", FT_UINT32, BASE_DEC,
NULL, 0, "file number generation" }},
NULL, 0, "file number generation", HFILL }},
{ &hf_nfs_fh_xfn, {
"exported file number", "nfs.fh.xfn", FT_UINT32, BASE_DEC,
NULL, 0, "exported file number" }},
NULL, 0, "exported file number", HFILL }},
{ &hf_nfs_fh_xfn_len, {
"length", "nfs.fh.xfn.len", FT_UINT32, BASE_DEC,
NULL, 0, "exported file number length" }},
NULL, 0, "exported file number length", HFILL }},
{ &hf_nfs_fh_xfn_inode, {
"exported inode", "nfs.fh.xfn.inode", FT_UINT32, BASE_DEC,
NULL, 0, "exported file number inode" }},
NULL, 0, "exported file number inode", HFILL }},
{ &hf_nfs_fh_xfn_generation, {
"generation", "nfs.fh.xfn.generation", FT_UINT32, BASE_DEC,
NULL, 0, "exported file number generation" }},
NULL, 0, "exported file number generation", HFILL }},
{ &hf_nfs_fh_dentry, {
"dentry", "nfs.fh.dentry", FT_UINT32, BASE_HEX,
NULL, 0, "dentry (cookie)" }},
NULL, 0, "dentry (cookie)", HFILL }},
{ &hf_nfs_fh_dev, {
"device", "nfs.fh.dev", FT_UINT32, BASE_DEC,
NULL, 0, "device" }},
NULL, 0, "device", HFILL }},
{ &hf_nfs_fh_xdev, {
"exported device", "nfs.fh.xdev", FT_UINT32, BASE_DEC,
NULL, 0, "exported device" }},
NULL, 0, "exported device", HFILL }},
{ &hf_nfs_fh_dirinode, {
"directory inode", "nfs.fh.dirinode", FT_UINT32, BASE_DEC,
NULL, 0, "directory inode" }},
NULL, 0, "directory inode", HFILL }},
{ &hf_nfs_fh_pinode, {
"pseudo inode", "nfs.fh.pinode", FT_UINT32, BASE_HEX,
NULL, 0, "pseudo inode" }},
NULL, 0, "pseudo inode", HFILL }},
{ &hf_nfs_fh_hp_len, {
"length", "nfs.fh.hp.len", FT_UINT32, BASE_DEC,
NULL, 0, "hash path length" }},
NULL, 0, "hash path length", HFILL }},
{ &hf_nfs_stat, {
"Status", "nfs.status2", FT_UINT32, BASE_DEC,
VALS(names_nfs_stat), 0, "Reply status" }},
VALS(names_nfs_stat), 0, "Reply status", HFILL }},
{ &hf_nfs_name, {
"Name", "nfs.name", FT_STRING, BASE_DEC,
NULL, 0, "Name" }},
NULL, 0, "Name", HFILL }},
{ &hf_nfs_readlink_data, {
"Data", "nfs.readlink.data", FT_STRING, BASE_DEC,
NULL, 0, "Symbolic Link Data" }},
NULL, 0, "Symbolic Link Data", HFILL }},
{ &hf_nfs_read_offset, {
"Offset", "nfs.read.offset", FT_UINT32, BASE_DEC,
NULL, 0, "Read Offset" }},
NULL, 0, "Read Offset", HFILL }},
{ &hf_nfs_read_count, {
"Count", "nfs.read.count", FT_UINT32, BASE_DEC,
NULL, 0, "Read Count" }},
NULL, 0, "Read Count", HFILL }},
{ &hf_nfs_read_totalcount, {
"Total Count", "nfs.read.totalcount", FT_UINT32, BASE_DEC,
NULL, 0, "Total Count (obsolete)" }},
NULL, 0, "Total Count (obsolete)", HFILL }},
{ &hf_nfs_data, {
"Data", "nfs.data", FT_BYTES, BASE_DEC,
NULL, 0, "Data" }},
NULL, 0, "Data", HFILL }},
{ &hf_nfs_write_beginoffset, {
"Begin Offset", "nfs.write.beginoffset", FT_UINT32, BASE_DEC,
NULL, 0, "Begin offset (obsolete)" }},
NULL, 0, "Begin offset (obsolete)", HFILL }},
{ &hf_nfs_write_offset, {
"Offset", "nfs.write.offset", FT_UINT32, BASE_DEC,
NULL, 0, "Offset" }},
NULL, 0, "Offset", HFILL }},
{ &hf_nfs_write_totalcount, {
"Total Count", "nfs.write.totalcount", FT_UINT32, BASE_DEC,
NULL, 0, "Total Count (obsolete)" }},
NULL, 0, "Total Count (obsolete)", HFILL }},
{ &hf_nfs_symlink_to, {
"To", "nfs.symlink.to", FT_STRING, BASE_DEC,
NULL, 0, "Symbolic link destination name" }},
NULL, 0, "Symbolic link destination name", HFILL }},
{ &hf_nfs_readdir_cookie, {
"Cookie", "nfs.readdir.cookie", FT_UINT32, BASE_DEC,
NULL, 0, "Directory Cookie" }},
NULL, 0, "Directory Cookie", HFILL }},
{ &hf_nfs_readdir_count, {
"Count", "nfs.readdir.count", FT_UINT32, BASE_DEC,
NULL, 0, "Directory Count" }},
NULL, 0, "Directory Count", HFILL }},
{ &hf_nfs_readdir_entry, {
"Entry", "nfs.readdir.entry", FT_NONE, 0,
NULL, 0, "Directory Entry" }},
NULL, 0, "Directory Entry", HFILL }},
{ &hf_nfs_readdir_entry_fileid, {
"File ID", "nfs.readdir.entry.fileid", FT_UINT32, BASE_DEC,
NULL, 0, "File ID" }},
NULL, 0, "File ID", HFILL }},
{ &hf_nfs_readdir_entry_name, {
"Name", "nfs.readdir.entry.name", FT_STRING, BASE_DEC,
NULL, 0, "Name" }},
NULL, 0, "Name", HFILL }},
{ &hf_nfs_readdir_entry_cookie, {
"Cookie", "nfs.readdir.entry.cookie", FT_UINT32, BASE_DEC,
NULL, 0, "Directory Cookie" }},
NULL, 0, "Directory Cookie", HFILL }},
{ &hf_nfs_readdir_entry3_fileid, {
"File ID", "nfs.readdir.entry3.fileid", FT_UINT32, BASE_DEC,
NULL, 0, "File ID" }},
NULL, 0, "File ID", HFILL }},
{ &hf_nfs_readdir_entry3_name, {
"Name", "nfs.readdir.entry3.name", FT_STRING, BASE_DEC,
NULL, 0, "Name" }},
NULL, 0, "Name", HFILL }},
{ &hf_nfs_readdir_entry3_cookie, {
"Cookie", "nfs.readdir.entry3.cookie", FT_UINT32, BASE_DEC,
NULL, 0, "Directory Cookie" }},
NULL, 0, "Directory Cookie", HFILL }},
{ &hf_nfs_readdirplus_entry_fileid, {
"File ID", "nfs.readdirplus.entry.fileid", FT_UINT32, BASE_DEC,
NULL, 0, "Name" }},
NULL, 0, "Name", HFILL }},
{ &hf_nfs_readdirplus_entry_name, {
"Name", "nfs.readdirplus.entry.name", FT_STRING, BASE_DEC,
NULL, 0, "Name" }},
NULL, 0, "Name", HFILL }},
{ &hf_nfs_readdirplus_entry_cookie, {
"Cookie", "nfs.readdirplus.entry.cookie", FT_UINT32, BASE_DEC,
NULL, 0, "Directory Cookie" }},
NULL, 0, "Directory Cookie", HFILL }},
{ &hf_nfs_readdir_eof, {
"EOF", "nfs.readdir.eof", FT_UINT32, BASE_DEC,
NULL, 0, "EOF" }},
NULL, 0, "EOF", HFILL }},
{ &hf_nfs_statfs_tsize, {
"Transfer Size", "nfs.statfs.tsize", FT_UINT32, BASE_DEC,
NULL, 0, "Transfer Size" }},
NULL, 0, "Transfer Size", HFILL }},
{ &hf_nfs_statfs_bsize, {
"Block Size", "nfs.statfs.bsize", FT_UINT32, BASE_DEC,
NULL, 0, "Block Size" }},
NULL, 0, "Block Size", HFILL }},
{ &hf_nfs_statfs_blocks, {
"Total Blocks", "nfs.statfs.blocks", FT_UINT32, BASE_DEC,
NULL, 0, "Total Blocks" }},
NULL, 0, "Total Blocks", HFILL }},
{ &hf_nfs_statfs_bfree, {
"Free Blocks", "nfs.statfs.bfree", FT_UINT32, BASE_DEC,
NULL, 0, "Free Blocks" }},
NULL, 0, "Free Blocks", HFILL }},
{ &hf_nfs_statfs_bavail, {
"Available Blocks", "nfs.statfs.bavail", FT_UINT32, BASE_DEC,
NULL, 0, "Available Blocks" }},
NULL, 0, "Available Blocks", HFILL }},
{ &hf_nfs_ftype3, {
"Type", "nfs.type", FT_UINT32, BASE_DEC,
VALS(names_nfs_ftype3), 0, "File Type" }},
VALS(names_nfs_ftype3), 0, "File Type", HFILL }},
{ &hf_nfs_nfsstat3, {
"Status", "nfs.status", FT_UINT32, BASE_DEC,
VALS(names_nfs_nfsstat3), 0, "Reply status" }},
VALS(names_nfs_nfsstat3), 0, "Reply status", HFILL }},
{ &hf_nfs_read_eof, {
"EOF", "nfs.read.eof", FT_BOOLEAN, BASE_NONE,
&yesno, 0, "EOF" }},
&yesno, 0, "EOF", HFILL }},
{ &hf_nfs_write_stable, {
"Stable", "nfs.write.stable", FT_UINT32, BASE_DEC,
VALS(names_stable_how), 0, "Stable" }},
VALS(names_stable_how), 0, "Stable", HFILL }},
{ &hf_nfs_write_committed, {
"Committed", "nfs.write.committed", FT_UINT32, BASE_DEC,
VALS(names_stable_how), 0, "Committed" }},
VALS(names_stable_how), 0, "Committed", HFILL }},
{ &hf_nfs_createmode3, {
"Create Mode", "nfs.createmode", FT_UINT32, BASE_DEC,
VALS(names_createmode3), 0, "Create Mode" }},
VALS(names_createmode3), 0, "Create Mode", HFILL }},
{ &hf_nfs_fsstat_invarsec, {
"invarsec", "nfs.fsstat.invarsec", FT_UINT32, BASE_DEC,
NULL, 0, "probable number of seconds of file system invariance" }},
NULL, 0, "probable number of seconds of file system invariance", HFILL }},
{ &hf_nfs_fsinfo_rtmax, {
"rtmax", "nfs.fsinfo.rtmax", FT_UINT32, BASE_DEC,
NULL, 0, "maximum READ request" }},
NULL, 0, "maximum READ request", HFILL }},
{ &hf_nfs_fsinfo_rtpref, {
"rtpref", "nfs.fsinfo.rtpref", FT_UINT32, BASE_DEC,
NULL, 0, "Preferred READ request size" }},
NULL, 0, "Preferred READ request size", HFILL }},
{ &hf_nfs_fsinfo_rtmult, {
"rtmult", "nfs.fsinfo.rtmult", FT_UINT32, BASE_DEC,
NULL, 0, "Suggested READ multiple" }},
NULL, 0, "Suggested READ multiple", HFILL }},
{ &hf_nfs_fsinfo_wtmax, {
"wtmax", "nfs.fsinfo.wtmax", FT_UINT32, BASE_DEC,
NULL, 0, "Maximum WRITE request size" }},
NULL, 0, "Maximum WRITE request size", HFILL }},
{ &hf_nfs_fsinfo_wtpref, {
"wtpref", "nfs.fsinfo.wtpref", FT_UINT32, BASE_DEC,
NULL, 0, "Preferred WRITE request size" }},
NULL, 0, "Preferred WRITE request size", HFILL }},
{ &hf_nfs_fsinfo_wtmult, {
"wtmult", "nfs.fsinfo.wtmult", FT_UINT32, BASE_DEC,
NULL, 0, "Suggested WRITE multiple" }},
NULL, 0, "Suggested WRITE multiple", HFILL }},
{ &hf_nfs_fsinfo_dtpref, {
"dtpref", "nfs.fsinfo.dtpref", FT_UINT32, BASE_DEC,
NULL, 0, "Preferred READDIR request" }},
NULL, 0, "Preferred READDIR request", HFILL }},
{ &hf_nfs_fsinfo_maxfilesize, {
"maxfilesize", "nfs.fsinfo.maxfilesize", FT_UINT32, BASE_DEC,
NULL, 0, "Maximum file size" }},
NULL, 0, "Maximum file size", HFILL }},
{ &hf_nfs_fsinfo_properties, {
"Properties", "nfs.fsinfo.propeties", FT_UINT32, BASE_HEX,
NULL, 0, "File System Properties" }},
NULL, 0, "File System Properties", HFILL }},
{ &hf_nfs_pathconf_linkmax, {
"linkmax", "nfs.pathconf.linkmax", FT_UINT32, BASE_DEC,
NULL, 0, "Maximum number of hard links" }},
NULL, 0, "Maximum number of hard links", HFILL }},
{ &hf_nfs_pathconf_name_max, {
"name_max", "nfs.pathconf.name_max", FT_UINT32, BASE_DEC,
NULL, 0, "Maximum file name length" }},
NULL, 0, "Maximum file name length", HFILL }},
{ &hf_nfs_pathconf_no_trunc, {
"no_trunc", "nfs.pathconf.no_trunc", FT_BOOLEAN, BASE_NONE,
&yesno, 0, "No long file name truncation" }},
&yesno, 0, "No long file name truncation", HFILL }},
{ &hf_nfs_pathconf_chown_restricted, {
"chown_restricted", "nfs.pathconf.chown_restricted", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "chown is restricted to root" }},
BASE_NONE, &yesno, 0, "chown is restricted to root", HFILL }},
{ &hf_nfs_pathconf_case_insensitive, {
"case_insensitive", "nfs.pathconf.case_insensitive", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "file names are treated case insensitive" }},
BASE_NONE, &yesno, 0, "file names are treated case insensitive", HFILL }},
{ &hf_nfs_pathconf_case_preserving, {
"case_preserving", "nfs.pathconf.case_preserving", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "file name cases are preserved" }},
BASE_NONE, &yesno, 0, "file name cases are preserved", HFILL }},
{ &hf_nfs_fattr_type, {
"type", "nfs.fattr.type", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr.type" }},
NULL, 0, "nfs.fattr.type", HFILL }},
{ &hf_nfs_fattr_nlink, {
"nlink", "nfs.fattr.nlink", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr.nlink" }},
NULL, 0, "nfs.fattr.nlink", HFILL }},
{ &hf_nfs_fattr_uid, {
"uid", "nfs.fattr.uid", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr.uid" }},
NULL, 0, "nfs.fattr.uid", HFILL }},
{ &hf_nfs_fattr_gid, {
"gid", "nfs.fattr.gid", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr.gid" }},
NULL, 0, "nfs.fattr.gid", HFILL }},
{ &hf_nfs_fattr_size, {
"size", "nfs.fattr.size", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr.size" }},
NULL, 0, "nfs.fattr.size", HFILL }},
{ &hf_nfs_fattr_blocksize, {
"blocksize", "nfs.fattr.blocksize", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr.blocksize" }},
NULL, 0, "nfs.fattr.blocksize", HFILL }},
{ &hf_nfs_fattr_rdev, {
"rdev", "nfs.fattr.rdev", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr.rdev" }},
NULL, 0, "nfs.fattr.rdev", HFILL }},
{ &hf_nfs_fattr_blocks, {
"blocks", "nfs.fattr.blocks", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr.blocks" }},
NULL, 0, "nfs.fattr.blocks", HFILL }},
{ &hf_nfs_fattr_fsid, {
"fsid", "nfs.fattr.fsid", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr.fsid" }},
NULL, 0, "nfs.fattr.fsid", HFILL }},
{ &hf_nfs_fattr_fileid, {
"fileid", "nfs.fattr.fileid", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr.fileid" }},
NULL, 0, "nfs.fattr.fileid", HFILL }},
{ &hf_nfs_fattr3_type, {
"Type", "nfs.fattr3.type", FT_UINT32, BASE_DEC,
VALS(names_nfs_ftype3), 0, "nfs.fattr3.type" }},
VALS(names_nfs_ftype3), 0, "nfs.fattr3.type", HFILL }},
{ &hf_nfs_fattr3_nlink, {
"nlink", "nfs.fattr3.nlink", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr3.nlink" }},
NULL, 0, "nfs.fattr3.nlink", HFILL }},
{ &hf_nfs_fattr3_uid, {
"uid", "nfs.fattr3.uid", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr3.uid" }},
NULL, 0, "nfs.fattr3.uid", HFILL }},
{ &hf_nfs_fattr3_gid, {
"gid", "nfs.fattr3.gid", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr3.gid" }},
NULL, 0, "nfs.fattr3.gid", HFILL }},
{ &hf_nfs_fattr3_size, {
"size", "nfs.fattr3.size", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr3.size" }},
NULL, 0, "nfs.fattr3.size", HFILL }},
{ &hf_nfs_fattr3_used, {
"used", "nfs.fattr3.used", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr3.used" }},
NULL, 0, "nfs.fattr3.used", HFILL }},
{ &hf_nfs_fattr3_rdev, {
"rdev", "nfs.fattr3.rdev", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr3.rdev" }},
NULL, 0, "nfs.fattr3.rdev", HFILL }},
{ &hf_nfs_fattr3_fsid, {
"fsid", "nfs.fattr3.fsid", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr3.fsid" }},
NULL, 0, "nfs.fattr3.fsid", HFILL }},
{ &hf_nfs_fattr3_fileid, {
"fileid", "nfs.fattr3.fileid", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr3.fileid" }},
NULL, 0, "nfs.fattr3.fileid", HFILL }},
{ &hf_nfs_wcc_attr_size, {
"size", "nfs.wcc_attr.size", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.wcc_attr.size" }},
NULL, 0, "nfs.wcc_attr.size", HFILL }},
{ &hf_nfs_set_size3_size, {
"size", "nfs.set_size3.size", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.set_size3.size" }},
NULL, 0, "nfs.set_size3.size", HFILL }},
{ &hf_nfs_uid3, {
"uid", "nfs.uid3", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.uid3" }},
NULL, 0, "nfs.uid3", HFILL }},
{ &hf_nfs_gid3, {
"gid", "nfs.gid3", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.gid3" }},
NULL, 0, "nfs.gid3", HFILL }},
{ &hf_nfs_cookie3, {
"cookie", "nfs.cookie3", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.cookie3" }},
NULL, 0, "nfs.cookie3", HFILL }},
{ &hf_nfs_offset3, {
"offset", "nfs.offset3", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.offset3" }},
NULL, 0, "nfs.offset3", HFILL }},
{ &hf_nfs_count3, {
"count", "nfs.count3", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.count3" }},
NULL, 0, "nfs.count3", HFILL }},
{ &hf_nfs_count3_maxcount, {
"maxcount", "nfs.count3_maxcount", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.count3_maxcount" }},
NULL, 0, "nfs.count3_maxcount", HFILL }},
{ &hf_nfs_count3_dircount, {
"dircount", "nfs.count3_dircount", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.count3_dircount" }},
NULL, 0, "nfs.count3_dircount", HFILL }},
{ &hf_nfs_fsstat3_resok_tbytes, {
"tbytes", "nfs.fsstat3_resok.tbytes", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fsstat3_resok.tbytes" }},
NULL, 0, "nfs.fsstat3_resok.tbytes", HFILL }},
{ &hf_nfs_fsstat3_resok_fbytes, {
"fbytes", "nfs.fsstat3_resok.fbytes", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fsstat3_resok.fbytes" }},
NULL, 0, "nfs.fsstat3_resok.fbytes", HFILL }},
{ &hf_nfs_fsstat3_resok_abytes, {
"abytes", "nfs.fsstat3_resok.abytes", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fsstat3_resok.abytes" }},
NULL, 0, "nfs.fsstat3_resok.abytes", HFILL }},
{ &hf_nfs_fsstat3_resok_tfiles, {
"tfiles", "nfs.fsstat3_resok.tfiles", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fsstat3_resok.tfiles" }},
NULL, 0, "nfs.fsstat3_resok.tfiles", HFILL }},
{ &hf_nfs_fsstat3_resok_ffiles, {
"ffiles", "nfs.fsstat3_resok.ffiles", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fsstat3_resok.ffiles" }},
NULL, 0, "nfs.fsstat3_resok.ffiles", HFILL }},
{ &hf_nfs_fsstat3_resok_afiles, {
"afiles", "nfs.fsstat3_resok.afiles", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fsstat3_resok.afiles" }},
NULL, 0, "nfs.fsstat3_resok.afiles", HFILL }},
/* NFSv4 */
{ &hf_nfs_argop4, {
"Opcode", "nfs.call.operation", FT_UINT32, BASE_DEC,
VALS(names_nfsv4_operation), 0, "Opcode" }},
VALS(names_nfsv4_operation), 0, "Opcode", HFILL }},
{ &hf_nfs_resop4, {
"Opcode", "nfs.reply.operation", FT_UINT32, BASE_DEC,
VALS(names_nfsv4_operation), 0, "Opcode" }},
VALS(names_nfsv4_operation), 0, "Opcode", HFILL }},
{ &hf_nfs_linktext4, {
"Name", "nfs.symlink.linktext", FT_STRING, BASE_DEC,
NULL, 0, "Symbolic link contents" }},
NULL, 0, "Symbolic link contents", HFILL }},
{ &hf_nfs_component4, {
"Filename", "nfs.pathname.component", FT_STRING, BASE_DEC,
NULL, 0, "Pathname component" }},
NULL, 0, "Pathname component", HFILL }},
{ &hf_nfs_tag4, {
"Tag", "nfs.tag", FT_STRING, BASE_DEC,
NULL, 0, "Tag" }},
NULL, 0, "Tag", HFILL }},
{ &hf_nfs_clientid4, {
"clientid", "nfs.clientid", FT_UINT32, BASE_DEC,
NULL, 0, "Client ID" }},
NULL, 0, "Client ID", HFILL }},
{ &hf_nfs_clientid4_verifier, {
"verifier", "nfs.clientid.verifier", FT_UINT32, BASE_DEC,
NULL, 0, "Verifier Client ID" }},
NULL, 0, "Verifier Client ID", HFILL }},
{ &hf_nfs_ace4, {
"ace", "nfs.ace", FT_STRING, BASE_DEC,
NULL, 0, "Access Control Entry" }},
NULL, 0, "Access Control Entry", HFILL }},
{ &hf_nfs_recall, {
"EOF", "nfs.recall", FT_BOOLEAN, BASE_NONE,
&yesno, 0, "Recall" }},
&yesno, 0, "Recall", HFILL }},
{ &hf_nfs_open_claim_type4, {
"Claim Type", "nfs.open.claim_type", FT_UINT32, BASE_DEC,
VALS(names_claim_type4), 0, "Claim Type" }},
VALS(names_claim_type4), 0, "Claim Type", HFILL }},
{ &hf_nfs_opentype4, {
"Open Type", "nfs.open.opentype", FT_UINT32, BASE_DEC,
VALS(names_opentype4), 0, "Open Type" }},
VALS(names_opentype4), 0, "Open Type", HFILL }},
{ &hf_nfs_limit_by4, {
"Space Limit", "nfs.open.limit_by", FT_UINT32, BASE_DEC,
VALS(names_limit_by4), 0, "Limit By" }},
VALS(names_limit_by4), 0, "Limit By", HFILL }},
{ &hf_nfs_open_delegation_type4, {
"Delegation Type", "nfs.open.delegation_type", FT_UINT32, BASE_DEC,
VALS(names_open_delegation_type4), 0, "Delegation Type" }},
VALS(names_open_delegation_type4), 0, "Delegation Type", HFILL }},
{ &hf_nfs_ftype4, {
"nfs_ftype4", "nfs.nfs_ftype4", FT_UINT32, BASE_DEC,
VALS(names_ftype4), 0, "nfs.nfs_ftype4" }},
VALS(names_ftype4), 0, "nfs.nfs_ftype4", HFILL }},
{ &hf_nfs_change_info4_atomic, {
"Atomic", "nfs.change_info.atomic", FT_BOOLEAN, BASE_NONE,
&yesno, 0, "Atomic" }},
&yesno, 0, "Atomic", HFILL }},
{ &hf_nfs_open4_share_access, {
"share_access", "nfs.open4.share_access", FT_UINT32, BASE_DEC,
VALS(names_open4_share_access), 0, "Share Access" }},
VALS(names_open4_share_access), 0, "Share Access", HFILL }},
{ &hf_nfs_open4_share_deny, {
"share_deny", "nfs.open4.share_deny", FT_UINT32, BASE_DEC,
VALS(names_open4_share_deny), 0, "Share Deny" }},
VALS(names_open4_share_deny), 0, "Share Deny", HFILL }},
{ &hf_nfs_seqid4, {
"seqid", "nfs.seqid", FT_UINT32, BASE_HEX,
NULL, 0, "Sequence ID" }},
NULL, 0, "Sequence ID", HFILL }},
{ &hf_nfs_mand_attr, {
"mand_attr", "nfs.attr", FT_UINT32, BASE_DEC,
VALS(names_fattr4), 0, "Mandatory Attribute" }},
VALS(names_fattr4), 0, "Mandatory Attribute", HFILL }},
{ &hf_nfs_recc_attr, {
"recc_attr", "nfs.attr", FT_UINT32, BASE_DEC,
VALS(names_fattr4), 0, "Recommended Attribute" }},
VALS(names_fattr4), 0, "Recommended Attribute", HFILL }},
{ &hf_nfs_time_how4, {
"set_it", "nfs.set_it", FT_UINT32, BASE_DEC,
VALS(names_time_how4), 0, "How To Set Time" }},
VALS(names_time_how4), 0, "How To Set Time", HFILL }},
{ &hf_nfs_attrlist4, {
"attr_vals", "nfs.fattr4.attr_vals", FT_BYTES, BASE_DEC,
NULL, 0, "attr_vals" }},
NULL, 0, "attr_vals", HFILL }},
{ &hf_nfs_fattr4_expire_type, {
"fattr4_expire_type", "nfs.fattr4_expire_type", FT_UINT32, BASE_DEC,
VALS(names_fattr4_expire_type), 0, "fattr4_expire_type" }},
VALS(names_fattr4_expire_type), 0, "fattr4_expire_type", HFILL }},
{ &hf_nfs_fattr4_link_support, {
"fattr4_link_support", "nfs.fattr4_link_support", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_link_support" }},
BASE_NONE, &yesno, 0, "nfs.fattr4_link_support", HFILL }},
{ &hf_nfs_fattr4_symlink_support, {
"fattr4_symlink_support", "nfs.fattr4_symlink_support", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_symlink_support" }},
BASE_NONE, &yesno, 0, "nfs.fattr4_symlink_support", HFILL }},
{ &hf_nfs_fattr4_named_attr, {
"fattr4_named_attr", "nfs.fattr4_named_attr", FT_BOOLEAN, BASE_NONE,
&yesno, 0, "nfs.fattr4_named_attr" }},
&yesno, 0, "nfs.fattr4_named_attr", HFILL }},
{ &hf_nfs_fattr4_unique_handles, {
"fattr4_unique_handles", "nfs.fattr4_unique_handles", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_unique_handles" }},
BASE_NONE, &yesno, 0, "nfs.fattr4_unique_handles", HFILL }},
{ &hf_nfs_fattr4_archive, {
"fattr4_archive", "nfs.fattr4_archive", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_archive" }},
BASE_NONE, &yesno, 0, "nfs.fattr4_archive", HFILL }},
{ &hf_nfs_fattr4_cansettime, {
"fattr4_cansettime", "nfs.fattr4_cansettime", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_cansettime" }},
BASE_NONE, &yesno, 0, "nfs.fattr4_cansettime", HFILL }},
{ &hf_nfs_fattr4_case_insensitive, {
"fattr4_case_insensitive", "nfs.fattr4_case_insensitive", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_case_insensitive" }},
BASE_NONE, &yesno, 0, "nfs.fattr4_case_insensitive", HFILL }},
{ &hf_nfs_fattr4_case_preserving, {
"fattr4_case_preserving", "nfs.fattr4_case_preserving", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_case_preserving" }},
BASE_NONE, &yesno, 0, "nfs.fattr4_case_preserving", HFILL }},
{ &hf_nfs_fattr4_chown_restricted, {
"fattr4_chown_restricted", "nfs.fattr4_chown_restricted", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_chown_restricted" }},
BASE_NONE, &yesno, 0, "nfs.fattr4_chown_restricted", HFILL }},
{ &hf_nfs_fattr4_hidden, {
"fattr4_hidden", "nfs.fattr4_hidden", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_hidden" }},
BASE_NONE, &yesno, 0, "nfs.fattr4_hidden", HFILL }},
{ &hf_nfs_fattr4_homogeneous, {
"fattr4_homogeneous", "nfs.fattr4_homogeneous", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_homogeneous" }},
BASE_NONE, &yesno, 0, "nfs.fattr4_homogeneous", HFILL }},
{ &hf_nfs_fattr4_mimetype, {
"fattr4_mimetype", "nfs.fattr4_mimetype", FT_STRING, BASE_DEC,
NULL, 0, "nfs.fattr4_mimetype" }},
NULL, 0, "nfs.fattr4_mimetype", HFILL }},
{ &hf_nfs_fattr4_no_trunc, {
"fattr4_no_trunc", "nfs.fattr4_no_trunc", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_no_trunc" }},
BASE_NONE, &yesno, 0, "nfs.fattr4_no_trunc", HFILL }},
{ &hf_nfs_fattr4_system, {
"fattr4_system", "nfs.fattr4_system", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.fattr4_system" }},
BASE_NONE, &yesno, 0, "nfs.fattr4_system", HFILL }},
{ &hf_nfs_who, {
"who", "nfs.who", FT_STRING, BASE_DEC,
NULL, 0, "nfs.who" }},
NULL, 0, "nfs.who", HFILL }},
{ &hf_nfs_server, {
"server", "nfs.server", FT_STRING, BASE_DEC,
NULL, 0, "nfs.server" }},
NULL, 0, "nfs.server", HFILL }},
{ &hf_nfs_fattr4_owner, {
"fattr4_owner", "nfs.fattr4_owner", FT_STRING, BASE_DEC,
NULL, 0, "nfs.fattr4_owner" }},
NULL, 0, "nfs.fattr4_owner", HFILL }},
{ &hf_nfs_fattr4_owner_group, {
"fattr4_owner_group", "nfs.fattr4_owner_group", FT_STRING, BASE_DEC,
NULL, 0, "nfs.fattr4_owner_group" }},
NULL, 0, "nfs.fattr4_owner_group", HFILL }},
{ &hf_nfs_stable_how4, {
"stable_how4", "nfs.stable_how4", FT_UINT32, BASE_DEC,
VALS(names_stable_how4), 0, "nfs.stable_how4" }},
VALS(names_stable_how4), 0, "nfs.stable_how4", HFILL }},
{ &hf_nfs_dirlist4_eof, {
"eof", "nfs.dirlist4.eof", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.dirlist4.eof" }},
BASE_NONE, &yesno, 0, "nfs.dirlist4.eof", HFILL }},
{ &hf_nfs_data_follows, {
"data_follows", "nfs.data_follows", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.data_follows" }},
BASE_NONE, &yesno, 0, "nfs.data_follows", HFILL }},
{ &hf_nfs_stateid4, {
"stateid", "nfs.stateid4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.stateid4" }},
NULL, 0, "nfs.stateid4", HFILL }},
{ &hf_nfs_offset4, {
"offset", "nfs.offset4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.offset4" }},
NULL, 0, "nfs.offset4", HFILL }},
{ &hf_nfs_specdata1, {
"specdata1", "nfs.specdata1", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.specdata1" }},
NULL, 0, "nfs.specdata1", HFILL }},
{ &hf_nfs_specdata2, {
"specdata2", "nfs.specdata2", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.specdata2" }},
NULL, 0, "nfs.specdata2", HFILL }},
{ &hf_nfs_locktype4, {
"locktype", "nfs.locktype4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.locktype4" }},
NULL, 0, "nfs.locktype4", HFILL }},
{ &hf_nfs_reclaim4, {
"reclaim", "nfs.reclaim4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.reclaim4" }},
NULL, 0, "nfs.reclaim4", HFILL }},
{ &hf_nfs_length4, {
"length", "nfs.length4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.length4" }},
NULL, 0, "nfs.length4", HFILL }},
{ &hf_nfs_changeid4, {
"changeid", "nfs.changeid4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.changeid4" }},
NULL, 0, "nfs.changeid4", HFILL }},
{ &hf_nfs_nfstime4_seconds, {
"seconds", "nfs.nfstime4.seconds", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.nfstime4.seconds" }},
NULL, 0, "nfs.nfstime4.seconds", HFILL }},
{ &hf_nfs_nfstime4_nseconds, {
"nseconds", "nfs.nfstime4.nseconds", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.nfstime4.nseconds" }},
NULL, 0, "nfs.nfstime4.nseconds", HFILL }},
{ &hf_nfs_fsid4_major, {
"fsid4.major", "nfs.fsid4.major", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.nfstime4.fsid4.major" }},
NULL, 0, "nfs.nfstime4.fsid4.major", HFILL }},
{ &hf_nfs_fsid4_minor, {
"fsid4.minor", "nfs.fsid4.minor", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fsid4.minor" }},
NULL, 0, "nfs.fsid4.minor", HFILL }},
{ &hf_nfs_acetype4, {
"acetype", "nfs.acetype4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.acetype4" }},
NULL, 0, "nfs.acetype4", HFILL }},
{ &hf_nfs_aceflag4, {
"aceflag", "nfs.aceflag4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.aceflag4" }},
NULL, 0, "nfs.aceflag4", HFILL }},
{ &hf_nfs_acemask4, {
"acemask", "nfs.acemask4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.acemask4" }},
NULL, 0, "nfs.acemask4", HFILL }},
{ &hf_nfs_fattr4_size, {
"size", "nfs.fattr4.size", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.size" }},
NULL, 0, "nfs.fattr4.size", HFILL }},
{ &hf_nfs_fattr4_lease_time, {
"lease_time", "nfs.fattr4.lease_time", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.lease_time" }},
NULL, 0, "nfs.fattr4.lease_time", HFILL }},
{ &hf_nfs_fattr4_aclsupport, {
"aclsupport", "nfs.fattr4.aclsupport", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.aclsupport" }},
NULL, 0, "nfs.fattr4.aclsupport", HFILL }},
{ &hf_nfs_fattr4_fileid, {
"fileid", "nfs.fattr4.fileid", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.fileid" }},
NULL, 0, "nfs.fattr4.fileid", HFILL }},
{ &hf_nfs_fattr4_files_avail, {
"files_avail", "nfs.fattr4.files_avail", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.files_avail" }},
NULL, 0, "nfs.fattr4.files_avail", HFILL }},
{ &hf_nfs_fattr4_files_free, {
"files_free", "nfs.fattr4.files_free", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.files_free" }},
NULL, 0, "nfs.fattr4.files_free", HFILL }},
{ &hf_nfs_fattr4_files_total, {
"files_total", "nfs.fattr4.files_total", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.files_total" }},
NULL, 0, "nfs.fattr4.files_total", HFILL }},
{ &hf_nfs_fattr4_maxfilesize, {
"maxfilesize", "nfs.fattr4.maxfilesize", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.maxfilesize" }},
NULL, 0, "nfs.fattr4.maxfilesize", HFILL }},
{ &hf_nfs_fattr4_maxlink, {
"maxlink", "nfs.fattr4.maxlink", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.maxlink" }},
NULL, 0, "nfs.fattr4.maxlink", HFILL }},
{ &hf_nfs_fattr4_maxname, {
"maxname", "nfs.fattr4.maxname", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.maxname" }},
NULL, 0, "nfs.fattr4.maxname", HFILL }},
{ &hf_nfs_fattr4_numlinks, {
"numlinks", "nfs.fattr4.numlinks", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.numlinks" }},
NULL, 0, "nfs.fattr4.numlinks", HFILL }},
{ &hf_nfs_delegate_type, {
"delegate_type", "nfs.delegate_type", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.delegate_type" }},
NULL, 0, "nfs.delegate_type", HFILL }},
{ &hf_nfs_secinfo_flavor, {
"secinfo_flavor", "nfs.secinfo_flavor", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.secinfo_flavor" }},
NULL, 0, "nfs.secinfo_flavor", HFILL }},
{ &hf_nfs_num_blocks, {
"num_blocks", "nfs.num_blocks", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.num_blocks" }},
NULL, 0, "nfs.num_blocks", HFILL }},
{ &hf_nfs_bytes_per_block, {
"bytes_per_block", "nfs.bytes_per_block", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.bytes_per_block" }},
NULL, 0, "nfs.bytes_per_block", HFILL }},
{ &hf_nfs_eof, {
"eof", "nfs.eof", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.eof" }},
NULL, 0, "nfs.eof", HFILL }},
{ &hf_nfs_fattr4_maxread, {
"maxread", "nfs.fattr4.maxread", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.maxread" }},
NULL, 0, "nfs.fattr4.maxread", HFILL }},
{ &hf_nfs_fattr4_maxwrite, {
"maxwrite", "nfs.fattr4.maxwrite", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.maxwrite" }},
NULL, 0, "nfs.fattr4.maxwrite", HFILL }},
{ &hf_nfs_fattr4_quota_hard, {
"quota_hard", "nfs.fattr4.quota_hard", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.quota_hard" }},
NULL, 0, "nfs.fattr4.quota_hard", HFILL }},
{ &hf_nfs_fattr4_quota_soft, {
"quota_soft", "nfs.fattr4.quota_soft", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.quota_soft" }},
NULL, 0, "nfs.fattr4.quota_soft", HFILL }},
{ &hf_nfs_fattr4_quota_used, {
"quota_used", "nfs.fattr4.quota_used", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.quota_used" }},
NULL, 0, "nfs.fattr4.quota_used", HFILL }},
{ &hf_nfs_fattr4_space_avail, {
"space_avail", "nfs.fattr4.space_avail", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.space_avail" }},
NULL, 0, "nfs.fattr4.space_avail", HFILL }},
{ &hf_nfs_fattr4_space_free, {
"space_free", "nfs.fattr4.space_free", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.space_free" }},
NULL, 0, "nfs.fattr4.space_free", HFILL }},
{ &hf_nfs_fattr4_space_total, {
"space_total", "nfs.fattr4.space_total", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.space_total" }},
NULL, 0, "nfs.fattr4.space_total", HFILL }},
{ &hf_nfs_fattr4_space_used, {
"space_used", "nfs.fattr4.space_used", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.fattr4.space_used" }},
NULL, 0, "nfs.fattr4.space_used", HFILL }},
{ &hf_nfs_stateid4_delegate_stateid, {
"delegate_stateid", "nfs.delegate_stateid", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.delegate_stateid" }},
NULL, 0, "nfs.delegate_stateid", HFILL }},
{ &hf_nfs_verifier4, {
"verifier", "nfs.verifier4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.verifier4" }},
NULL, 0, "nfs.verifier4", HFILL }},
{ &hf_nfs_cookie4, {
"cookie", "nfs.cookie4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.cookie4" }},
NULL, 0, "nfs.cookie4", HFILL }},
{ &hf_nfs_cookieverf4, {
"cookieverf", "nfs.cookieverf4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.cookieverf4" }},
NULL, 0, "nfs.cookieverf4", HFILL }},
{ &hf_nfs_cb_location, {
"cb_location", "nfs.cb_location", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.cb_location" }},
NULL, 0, "nfs.cb_location", HFILL }},
{ &hf_nfs_cb_program, {
"cb_program", "nfs.cb_program", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.cb_program" }},
NULL, 0, "nfs.cb_program", HFILL }},
{ &hf_nfs_recall4, {
"recall", "nfs.recall4", FT_BOOLEAN,
BASE_NONE, &yesno, 0, "nfs.recall4" }},
BASE_NONE, &yesno, 0, "nfs.recall4", HFILL }},
{ &hf_nfs_filesize, {
"filesize", "nfs.filesize", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.filesize" }},
NULL, 0, "nfs.filesize", HFILL }},
{ &hf_nfs_count4, {
"count", "nfs.count4", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.count4" }},
NULL, 0, "nfs.count4", HFILL }},
{ &hf_nfs_count4_dircount, {
"dircount", "nfs.dircount", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.dircount" }},
NULL, 0, "nfs.dircount", HFILL }},
{ &hf_nfs_count4_maxcount, {
"maxcount", "nfs.maxcount", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.maxcount" }},
NULL, 0, "nfs.maxcount", HFILL }},
{ &hf_nfs_minorversion, {
"minorversion", "nfs.minorversion", FT_UINT32, BASE_DEC,
NULL, 0, "nfs.minorversion" }},
NULL, 0, "nfs.minorversion", HFILL }},
};
static gint *ett[] = {

230
packet-nisplus.c
View File

@ -1,7 +1,7 @@
/* packet-nisplus.c
* 2001 Ronnie Sahlberg <rsahlber@bigpond.net.au>
*
* $Id: packet-nisplus.c,v 1.6 2001/06/12 06:31:14 guy Exp $
* $Id: packet-nisplus.c,v 1.7 2001/06/18 02:17:50 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -1317,480 +1317,480 @@ proto_register_nis(void)
static hf_register_info hf[] = {
{ &hf_nisplus_object, {
"NIS Object", "nisplus.object", FT_NONE, BASE_NONE,
NULL, 0, "NIS Object" }},
NULL, 0, "NIS Object", HFILL }},
{ &hf_nisplus_oid, {
"Object Identity Verifier", "nisplus.object.oid", FT_NONE, BASE_NONE,
NULL, 0, "NIS Object Identity Verifier" }},
NULL, 0, "NIS Object Identity Verifier", HFILL }},
{ &hf_nisplus_object_name, {
"name", "nisplus.object.name", FT_STRING, BASE_DEC,
NULL, 0, "NIS Name For This Object" }},
NULL, 0, "NIS Name For This Object", HFILL }},
{ &hf_nisplus_object_owner, {
"owner", "nisplus.object.owner", FT_STRING, BASE_DEC,
NULL, 0, "NIS Name Of Object Owner" }},
NULL, 0, "NIS Name Of Object Owner", HFILL }},
{ &hf_nisplus_object_group, {
"group", "nisplus.object.group", FT_STRING, BASE_DEC,
NULL, 0, "NIS Name Of Access Group" }},
NULL, 0, "NIS Name Of Access Group", HFILL }},
{ &hf_nisplus_object_domain, {
"domain", "nisplus.object.domain", FT_STRING, BASE_DEC,
NULL, 0, "NIS Administrator For This Object" }},
NULL, 0, "NIS Administrator For This Object", HFILL }},
{ &hf_nisplus_object_ttl, {
"ttl", "nisplus.object.ttl", FT_UINT32, BASE_DEC,
NULL, 0, "NIS Time To Live For This Object" }},
NULL, 0, "NIS Time To Live For This Object", HFILL }},
{ &hf_nisplus_object_private, {
"private", "nisplus.object.private", FT_BYTES, BASE_DEC,
NULL, 0, "NIS Private Object" }},
NULL, 0, "NIS Private Object", HFILL }},
{ &hf_nisplus_directory, {
"directory", "nisplus.directory", FT_NONE, BASE_NONE,
NULL, 0, "NIS Directory Object" }},
NULL, 0, "NIS Directory Object", HFILL }},
{ &hf_nisplus_directory_name, {
"directory name", "nisplus.directory.name", FT_STRING, BASE_DEC,
NULL, 0, "Name Of Directory Being Served" }},
NULL, 0, "Name Of Directory Being Served", HFILL }},
{ &hf_nisplus_directory_type, {
"type", "nisplus.directory.type", FT_UINT32, BASE_DEC,
VALS(ns_type), 0, "NIS Type Of Name Service" }},
VALS(ns_type), 0, "NIS Type Of Name Service", HFILL }},
{ &hf_nisplus_directory_ttl, {
"ttl", "nisplus.directory.ttl", FT_UINT32, BASE_DEC,
NULL, 0, "Time To Live" }},
NULL, 0, "Time To Live", HFILL }},
{ &hf_nisplus_directory_mask, {
"mask", "nisplus.directory.mask", FT_NONE, BASE_NONE,
NULL, 0, "NIS Directory Create/Destroy Rights" }},
NULL, 0, "NIS Directory Create/Destroy Rights", HFILL }},
{ &hf_nisplus_directory_mask_list, {
"mask list", "nisplus.directory.mask_list", FT_NONE, BASE_NONE,
NULL, 0, "List Of Directory Create/Destroy Rights" }},
NULL, 0, "List Of Directory Create/Destroy Rights", HFILL }},
{ &hf_nisplus_mask_world_read, {
"WORLD READ", "nisplus.directory.mask.world_read",
FT_BOOLEAN, 32, TFS(&tfs_world_read),
NIS_MASK_WORLD_READ, "World Read Flag" }},
NIS_MASK_WORLD_READ, "World Read Flag", HFILL }},
{ &hf_nisplus_mask_world_modify, {
"WORLD MODIFY", "nisplus.directory.mask.world_modify",
FT_BOOLEAN, 32, TFS(&tfs_world_modify),
NIS_MASK_WORLD_MODIFY, "World Modify Flag" }},
NIS_MASK_WORLD_MODIFY, "World Modify Flag", HFILL }},
{ &hf_nisplus_mask_world_create, {
"WORLD CREATE", "nisplus.directory.mask.world_create",
FT_BOOLEAN, 32, TFS(&tfs_world_create),
NIS_MASK_WORLD_CREATE, "World Create Flag" }},
NIS_MASK_WORLD_CREATE, "World Create Flag", HFILL }},
{ &hf_nisplus_mask_world_destroy, {
"WORLD DESTROY", "nisplus.directory.mask.world_destroy",
FT_BOOLEAN, 32, TFS(&tfs_world_destroy),
NIS_MASK_WORLD_DESTROY, "World Destroy Flag" }},
NIS_MASK_WORLD_DESTROY, "World Destroy Flag", HFILL }},
{ &hf_nisplus_mask_group_read, {
"GROUP READ", "nisplus.directory.mask.group_read",
FT_BOOLEAN, 32, TFS(&tfs_group_read),
NIS_MASK_GROUP_READ, "Group Read Flag" }},
NIS_MASK_GROUP_READ, "Group Read Flag", HFILL }},
{ &hf_nisplus_mask_group_modify, {
"GROUP MODIFY", "nisplus.directory.mask.group_modify",
FT_BOOLEAN, 32, TFS(&tfs_group_modify),
NIS_MASK_GROUP_MODIFY, "Group Modify Flag" }},
NIS_MASK_GROUP_MODIFY, "Group Modify Flag", HFILL }},
{ &hf_nisplus_mask_group_create, {
"GROUP CREATE", "nisplus.directory.mask.group_create",
FT_BOOLEAN, 32, TFS(&tfs_group_create),
NIS_MASK_GROUP_CREATE, "Group Create Flag" }},
NIS_MASK_GROUP_CREATE, "Group Create Flag", HFILL }},
{ &hf_nisplus_mask_group_destroy, {
"GROUP DESTROY", "nisplus.directory.mask.group_destroy",
FT_BOOLEAN, 32, TFS(&tfs_group_destroy),
NIS_MASK_GROUP_DESTROY, "Group Destroy Flag" }},
NIS_MASK_GROUP_DESTROY, "Group Destroy Flag", HFILL }},
{ &hf_nisplus_mask_owner_read, {
"OWNER READ", "nisplus.directory.mask.owner_read",
FT_BOOLEAN, 32, TFS(&tfs_owner_read),
NIS_MASK_OWNER_READ, "Owner Read Flag" }},
NIS_MASK_OWNER_READ, "Owner Read Flag", HFILL }},
{ &hf_nisplus_mask_owner_modify, {
"OWNER MODIFY", "nisplus.directory.mask.owner_modify",
FT_BOOLEAN, 32, TFS(&tfs_owner_modify),
NIS_MASK_OWNER_MODIFY, "Owner Modify Flag" }},
NIS_MASK_OWNER_MODIFY, "Owner Modify Flag", HFILL }},
{ &hf_nisplus_mask_owner_create, {
"OWNER CREATE", "nisplus.directory.mask.owner_create",
FT_BOOLEAN, 32, TFS(&tfs_owner_create),
NIS_MASK_OWNER_CREATE, "Owner Create Flag" }},
NIS_MASK_OWNER_CREATE, "Owner Create Flag", HFILL }},
{ &hf_nisplus_mask_owner_destroy, {
"OWNER DESTROY", "nisplus.directory.mask.owner_destroy",
FT_BOOLEAN, 32, TFS(&tfs_owner_destroy),
NIS_MASK_OWNER_DESTROY, "Owner Destroy Flag" }},
NIS_MASK_OWNER_DESTROY, "Owner Destroy Flag", HFILL }},
{ &hf_nisplus_mask_nobody_read, {
"NOBODY READ", "nisplus.directory.mask.nobody_read",
FT_BOOLEAN, 32, TFS(&tfs_nobody_read),
NIS_MASK_NOBODY_READ, "Nobody Read Flag" }},
NIS_MASK_NOBODY_READ, "Nobody Read Flag", HFILL }},
{ &hf_nisplus_mask_nobody_modify, {
"NOBODY MODIFY", "nisplus.directory.mask.nobody_modify",
FT_BOOLEAN, 32, TFS(&tfs_nobody_modify),
NIS_MASK_NOBODY_MODIFY, "Nobody Modify Flag" }},
NIS_MASK_NOBODY_MODIFY, "Nobody Modify Flag", HFILL }},
{ &hf_nisplus_mask_nobody_create, {
"NOBODY CREATE", "nisplus.directory.mask.nobody_create",
FT_BOOLEAN, 32, TFS(&tfs_nobody_create),
NIS_MASK_NOBODY_CREATE, "Nobody Create Flag" }},
NIS_MASK_NOBODY_CREATE, "Nobody Create Flag", HFILL }},
{ &hf_nisplus_mask_nobody_destroy, {
"NOBODY DESTROY", "nisplus.directory.mask.nobody_destroy",
FT_BOOLEAN, 32, TFS(&tfs_nobody_destroy),
NIS_MASK_NOBODY_DESTROY, "Nobody Destroy Flag" }},
NIS_MASK_NOBODY_DESTROY, "Nobody Destroy Flag", HFILL }},
{ &hf_nisplus_access_mask, {
"access mask", "nisplus.access.mask", FT_NONE, BASE_NONE,
NULL, 0, "NIS Access Mask" }},
NULL, 0, "NIS Access Mask", HFILL }},
{ &hf_nisplus_object_type, {
"type", "nisplus.object.type", FT_UINT32, BASE_DEC,
VALS(obj_type), 0, "NIS Type Of Object" }},
VALS(obj_type), 0, "NIS Type Of Object", HFILL }},
{ &hf_nisplus_servers, {
"nis servers", "nisplus.servers", FT_NONE, BASE_NONE,
NULL, 0, "NIS Servers For This Directory" }},
NULL, 0, "NIS Servers For This Directory", HFILL }},
{ &hf_nisplus_cbservers, {
"nis servers", "nisplus.servers", FT_NONE, BASE_NONE,
NULL, 0, "Optional Callback Server" }},
NULL, 0, "Optional Callback Server", HFILL }},
{ &hf_nisplus_server, {
"server", "nisplus.server", FT_NONE, BASE_NONE,
NULL, 0, "NIS Server For This Directory" }},
NULL, 0, "NIS Server For This Directory", HFILL }},
{ &hf_nisplus_server_name, {
"name", "nisplus.server.name", FT_STRING, BASE_DEC,
NULL, 0, "Name Of NIS Server" }},
NULL, 0, "Name Of NIS Server", HFILL }},
{ &hf_nisplus_key_type, {
"type", "nisplus.key.type", FT_UINT32, BASE_DEC,
VALS(key_type), 0, "Type Of Key" }},
VALS(key_type), 0, "Type Of Key", HFILL }},
{ &hf_nisplus_key_data, {
"key data", "nisplus.key.data", FT_BYTES, BASE_DEC,
NULL, 0, "Encryption Key" }},
NULL, 0, "Encryption Key", HFILL }},
{ &hf_nisplus_endpoints, {
"nis endpoints", "nisplus.endpoints", FT_NONE, BASE_NONE,
NULL, 0, "Endpoints For This NIS Server" }},
NULL, 0, "Endpoints For This NIS Server", HFILL }},
{ &hf_nisplus_endpoint, {
"endpoint", "nisplus.endpoint", FT_NONE, BASE_NONE,
NULL, 0, "Endpoint For This NIS Server" }},
NULL, 0, "Endpoint For This NIS Server", HFILL }},
{ &hf_nisplus_endpoint_uaddr, {
"addr", "nisplus.endpoint.uaddr", FT_STRING, BASE_DEC,
NULL, 0, "Address" }},
NULL, 0, "Address", HFILL }},
{ &hf_nisplus_endpoint_family, {
"family", "nisplus.endpoint.family", FT_STRING, BASE_DEC,
NULL, 0, "Transport Family" }},
NULL, 0, "Transport Family", HFILL }},
{ &hf_nisplus_endpoint_proto, {
"proto", "nisplus.endpoint.proto", FT_STRING, BASE_DEC,
NULL, 0, "Protocol" }},
NULL, 0, "Protocol", HFILL }},
{ &hf_nisplus_link, {
"link", "nisplus.link", FT_NONE, BASE_NONE,
NULL, 0, "NIS Link Object" }},
NULL, 0, "NIS Link Object", HFILL }},
{ &hf_nisplus_attrs_array, {
"Attributes", "nisplus.attributes", FT_NONE, BASE_NONE,
NULL, 0, "List Of Attributes" }},
NULL, 0, "List Of Attributes", HFILL }},
{ &hf_nisplus_attr, {
"Attribute", "nisplus.attr", FT_NONE, BASE_NONE,
NULL, 0, "Attribute" }},
NULL, 0, "Attribute", HFILL }},
{ &hf_nisplus_attr_name, {
"name", "nisplus.attr.name", FT_STRING, BASE_DEC,
NULL, 0, "Attribute Name" }},
NULL, 0, "Attribute Name", HFILL }},
{ &hf_nisplus_attr_val, {
"val", "nisplus.attr.val", FT_BYTES, BASE_HEX,
NULL, 0, "Attribute Value" }},
NULL, 0, "Attribute Value", HFILL }},
{ &hf_nisplus_entry, {
"entry", "nisplus.entry", FT_NONE, BASE_NONE,
NULL, 0, "Entry Object" }},
NULL, 0, "Entry Object", HFILL }},
{ &hf_nisplus_entry_type, {
"type", "nisplus.entry.type", FT_STRING, BASE_DEC,
NULL, 0, "Entry Type" }},
NULL, 0, "Entry Type", HFILL }},
{ &hf_nisplus_entry_cols, {
"columns", "nisplus.entry.cols", FT_NONE, BASE_NONE,
NULL, 0, "Entry Columns" }},
NULL, 0, "Entry Columns", HFILL }},
{ &hf_nisplus_entry_col, {
"column", "nisplus.entry.col", FT_NONE, BASE_NONE,
NULL, 0, "Entry Column" }},
NULL, 0, "Entry Column", HFILL }},
{ &hf_nisplus_entry_flags, {
"flags", "nisplus.entry.flags", FT_UINT32, BASE_HEX,
NULL, 0, "Entry Col Flags" }},
NULL, 0, "Entry Col Flags", HFILL }},
{ &hf_nisplus_entry_val, {
"val", "nisplus.entry.val", FT_STRING, BASE_DEC,
NULL, 0, "Entry Value" }},
NULL, 0, "Entry Value", HFILL }},
{ &hf_nisplus_entry_mask, {
"flags", "nisplus.entry.flags", FT_NONE, BASE_NONE,
NULL, 0, "Entry Col Flags" }},
NULL, 0, "Entry Col Flags", HFILL }},
{ &hf_nisplus_entry_mask_binary, {
"BINARY", "nisplus.entry.flags.binary",
FT_BOOLEAN, 32, TFS(&tfs_entry_binary),
NIS_MASK_ENTRY_BINARY, "Is This Entry BINARY Flag" }},
NIS_MASK_ENTRY_BINARY, "Is This Entry BINARY Flag", HFILL }},
{ &hf_nisplus_entry_mask_crypt, {
"ENCRYPTED", "nisplus.entry.flags.encrypted",
FT_BOOLEAN, 32, TFS(&tfs_entry_crypt),
NIS_MASK_ENTRY_CRYPT, "Is This Entry ENCRYPTED Flag" }},
NIS_MASK_ENTRY_CRYPT, "Is This Entry ENCRYPTED Flag", HFILL }},
{ &hf_nisplus_entry_mask_xdr, {
"XDR", "nisplus.entry.flags.xdr",
FT_BOOLEAN, 32, TFS(&tfs_entry_xdr),
NIS_MASK_ENTRY_XDR, "Is This Entry XDR Encoded Flag" }},
NIS_MASK_ENTRY_XDR, "Is This Entry XDR Encoded Flag", HFILL }},
{ &hf_nisplus_entry_mask_modified, {
"MODIFIED", "nisplus.entry.flags.modified",
FT_BOOLEAN, 32, TFS(&tfs_entry_modified),
NIS_MASK_ENTRY_MODIFIED, "Is This Entry MODIFIED Flag" }},
NIS_MASK_ENTRY_MODIFIED, "Is This Entry MODIFIED Flag", HFILL }},
{ &hf_nisplus_entry_mask_asn, {
"ASN.1", "nisplus.entry.flags.asn",
FT_BOOLEAN, 32, TFS(&tfs_entry_asn),
NIS_MASK_ENTRY_ASN, "Is This Entry ASN.1 Encoded Flag" }},
NIS_MASK_ENTRY_ASN, "Is This Entry ASN.1 Encoded Flag", HFILL }},
{ &hf_nisplus_table, {
"table", "nisplus.table", FT_NONE, BASE_NONE,
NULL, 0, "Table Object" }},
NULL, 0, "Table Object", HFILL }},
{ &hf_nisplus_table_type, {
"type", "nisplus.table.type", FT_STRING, BASE_DEC,
NULL, 0, "Table Type" }},
NULL, 0, "Table Type", HFILL }},
{ &hf_nisplus_table_maxcol, {
"max columns", "nisplus.table.maxcol", FT_UINT16, BASE_DEC,
NULL, 0, "Maximum Number Of Columns For Table" }},
NULL, 0, "Maximum Number Of Columns For Table", HFILL }},
{ &hf_nisplus_table_sep, {
"separator", "nisplus.table.separator", FT_UINT8, BASE_HEX,
NULL, 0, "Separator Character" }},
NULL, 0, "Separator Character", HFILL }},
{ &hf_nisplus_table_cols, {
"columns", "nisplus.table.cols", FT_NONE, BASE_NONE,
NULL, 0, "Table Columns" }},
NULL, 0, "Table Columns", HFILL }},
{ &hf_nisplus_table_col, {
"column", "nisplus.table.col", FT_NONE, BASE_NONE,
NULL, 0, "Table Column" }},
NULL, 0, "Table Column", HFILL }},
{ &hf_nisplus_table_path, {
"path", "nisplus.table.path", FT_STRING, BASE_DEC,
NULL, 0, "Table Path" }},
NULL, 0, "Table Path", HFILL }},
{ &hf_nisplus_table_col_name, {
"column name", "nisplus.table.col.name", FT_STRING, BASE_DEC,
NULL, 0, "Column Name" }},
NULL, 0, "Column Name", HFILL }},
{ &hf_nisplus_table_col_mask, {
"flags", "nisplus.table.col.flags", FT_NONE, BASE_NONE,
NULL, 0, "Flags For This Column" }},
NULL, 0, "Flags For This Column", HFILL }},
{ &hf_nisplus_table_col_mask_binary, {
"binary", "nisplus.table.flags.binary",
FT_BOOLEAN, 32, TFS(&tfs_col_binary),
NIS_MASK_TABLE_BINARY, "Is This Column BINARY" }},
NIS_MASK_TABLE_BINARY, "Is This Column BINARY", HFILL }},
{ &hf_nisplus_table_col_mask_encrypted, {
"encrypted", "nisplus.table.flags.encrypted",
FT_BOOLEAN, 32, TFS(&tfs_col_encrypted),
NIS_MASK_TABLE_CRYPT, "Is This Column ENCRYPTED" }},
NIS_MASK_TABLE_CRYPT, "Is This Column ENCRYPTED", HFILL }},
{ &hf_nisplus_table_col_mask_xdr, {
"xdr", "nisplus.table.flags.xdr",
FT_BOOLEAN, 32, TFS(&tfs_col_xdr),
NIS_MASK_TABLE_XDR, "Is This Column XDR Encoded" }},
NIS_MASK_TABLE_XDR, "Is This Column XDR Encoded", HFILL }},
{ &hf_nisplus_table_col_mask_searchable, {
"searchable", "nisplus.table.flags.searchable",
FT_BOOLEAN, 32, TFS(&tfs_col_searchable),
NIS_MASK_TABLE_SRCH, "Is This Column SEARCHABLE" }},
NIS_MASK_TABLE_SRCH, "Is This Column SEARCHABLE", HFILL }},
{ &hf_nisplus_table_col_mask_casesensitive, {
"casesensitive", "nisplus.table.flags.casesensitive",
FT_BOOLEAN, 32, TFS(&tfs_col_casesensitive),
NIS_MASK_TABLE_CASE, "Is This Column CASESENSITIVE" }},
NIS_MASK_TABLE_CASE, "Is This Column CASESENSITIVE", HFILL }},
{ &hf_nisplus_table_col_mask_modified, {
"modified", "nisplus.table.flags.modified",
FT_BOOLEAN, 32, TFS(&tfs_col_modified),
NIS_MASK_TABLE_MODIFIED, "Is This Column MODIFIED" }},
NIS_MASK_TABLE_MODIFIED, "Is This Column MODIFIED", HFILL }},
{ &hf_nisplus_table_col_mask_asn, {
"asn", "nisplus.table.flags.asn",
FT_BOOLEAN, 32, TFS(&tfs_col_asn),
NIS_MASK_TABLE_ASN, "Is This Column ASN.1 Encoded" }},
NIS_MASK_TABLE_ASN, "Is This Column ASN.1 Encoded", HFILL }},
{ &hf_nisplus_group, {
"Group", "nisplus.group", FT_NONE, BASE_NONE,
NULL, 0, "Group Object" }},
NULL, 0, "Group Object", HFILL }},
{ &hf_nisplus_grps, {
"Groups", "nisplus.grps", FT_NONE, BASE_NONE,
NULL, 0, "List Of Groups" }},
NULL, 0, "List Of Groups", HFILL }},
{ &hf_nisplus_group_flags, {
"flags", "nisplus.group.flags", FT_UINT32, BASE_HEX,
NULL, 0, "Group Object Flags" }},
NULL, 0, "Group Object Flags", HFILL }},
{ &hf_nisplus_group_name, {
"group name", "nisplus.group.name", FT_STRING, BASE_DEC,
NULL, 0, "Name Of Group Member" }},
NULL, 0, "Name Of Group Member", HFILL }},
{ &hf_nisplus_object_ctime, {
"ctime", "nisplus.ctime", FT_ABSOLUTE_TIME, BASE_NONE,
NULL, 0, "Time Of Creation" }},
NULL, 0, "Time Of Creation", HFILL }},
{ &hf_nisplus_object_mtime, {
"mtime", "nisplus.mtime", FT_ABSOLUTE_TIME, BASE_NONE,
NULL, 0, "Time Last Modified" }},
NULL, 0, "Time Last Modified", HFILL }},
{ &hf_nisplus_ib_flags, {
"flags", "nisplus.ib.flags", FT_UINT32, BASE_HEX,
NULL, 0, "Information Base Flags" }},
NULL, 0, "Information Base Flags", HFILL }},
{ &hf_nisplus_ib_bufsize, {
"bufsize", "nisplus.ib.bufsize", FT_UINT32, BASE_HEX,
NULL, 0, "Optional First/NextBufSize" }},
NULL, 0, "Optional First/NextBufSize", HFILL }},
{ &hf_nisplus_cookie, {
"cookie", "nisplus.cookie", FT_BYTES, BASE_HEX,
NULL, 0, "Cookie" }},
NULL, 0, "Cookie", HFILL }},
{ &hf_nisplus_fd_dirname, {
"dirname", "nisplus.fd.dirname", FT_STRING, BASE_DEC,
NULL, 0, "Directory Name" }},
NULL, 0, "Directory Name", HFILL }},
{ &hf_nisplus_fd_requester, {
"requester", "nisplus.fd.requester", FT_STRING, BASE_DEC,
NULL, 0, "Host Principal Name For Signature" }},
NULL, 0, "Host Principal Name For Signature", HFILL }},
{ &hf_nisplus_taglist, {
"taglist", "nisplus.taglist", FT_NONE, BASE_NONE,
NULL, 0, "List Of Tags" }},
NULL, 0, "List Of Tags", HFILL }},
{ &hf_nisplus_tag, {
"tag", "nisplus.tag", FT_NONE, BASE_NONE,
NULL, 0, "Tag" }},
NULL, 0, "Tag", HFILL }},
{ &hf_nisplus_tag_type, {
"type", "nisplus.tag.type", FT_UINT32, BASE_DEC,
NULL, 0, "Type Of Statistics Tag" }},
NULL, 0, "Type Of Statistics Tag", HFILL }},
{ &hf_nisplus_tag_val, {
"value", "nisplus.tag.value", FT_STRING, BASE_DEC,
NULL, 0, "Value Of Statistics Tag" }},
NULL, 0, "Value Of Statistics Tag", HFILL }},
{ &hf_nisplus_dump_dir, {
"directory", "nisplus.dump.dir", FT_STRING, BASE_DEC,
NULL, 0, "Directory To Dump" }},
NULL, 0, "Directory To Dump", HFILL }},
{ &hf_nisplus_dump_time, {
"time", "nisplus.dump.time", FT_ABSOLUTE_TIME, BASE_NONE,
NULL, 0, "From This Timestamp" }},
NULL, 0, "From This Timestamp", HFILL }},
{ &hf_nisplus_dummy, {
" ", ".nisplus.dummy", FT_BYTES, BASE_NONE,
NULL, 0, " " }},
NULL, 0, " ", HFILL }},
{ &hf_nisplus_ping_time, {
"time", "nisplus.ping.time", FT_ABSOLUTE_TIME, BASE_NONE,
NULL, 0, "Timestamp Of The Transaction" }},
NULL, 0, "Timestamp Of The Transaction", HFILL }},
{ &hf_nisplus_ping_dir, {
"directory", "nisplus.ping.dir", FT_STRING, BASE_DEC,
NULL, 0, "Directory That Had The Change" }},
NULL, 0, "Directory That Had The Change", HFILL }},
{ &hf_nisplus_error, {
"status", "nisplus.status", FT_UINT32, BASE_DEC,
VALS(nis_error), 0, "NIS Status Code" }},
VALS(nis_error), 0, "NIS Status Code", HFILL }},
{ &hf_nisplus_dir_data, {
"data", "nisplus.fd.dir.data", FT_BYTES, BASE_HEX,
NULL, 0, "Directory Data In XDR Format" }},
NULL, 0, "Directory Data In XDR Format", HFILL }},
{ &hf_nisplus_signature, {
"signature", "nisplus.fd.sig", FT_BYTES, BASE_HEX,
NULL, 0, "Signature Of The Source" }},
NULL, 0, "Signature Of The Source", HFILL }},
{ &hf_nisplus_log_entries, {
"log entries", "nisplus.log.entries", FT_NONE, BASE_NONE,
NULL, 0, "Log Entries" }},
NULL, 0, "Log Entries", HFILL }},
{ &hf_nisplus_log_entry, {
"log entry", "nisplus.log.entry", FT_NONE, BASE_NONE,
NULL, 0, "Log Entry" }},
NULL, 0, "Log Entry", HFILL }},
{ &hf_nisplus_log_time, {
"time", "nisplus.log.time", FT_ABSOLUTE_TIME, BASE_NONE,
NULL, 0, "Time Of Log Entry" }},
NULL, 0, "Time Of Log Entry", HFILL }},
{ &hf_nisplus_log_type, {
"type", "nisplus.log.entry.type", FT_UINT32, BASE_DEC,
VALS(entry_type), 0, "Type Of Entry In Transaction Log" }},
VALS(entry_type), 0, "Type Of Entry In Transaction Log", HFILL }},
{ &hf_nisplus_log_principal, {
"principal", "nisplus.log.principal", FT_STRING, BASE_DEC,
NULL, 0, "Principal Making The Change" }},
NULL, 0, "Principal Making The Change", HFILL }},
{ &hf_nisplus_callback_status, {
"status", "nisplus.callback.status",
FT_BOOLEAN, 0, TFS(&tfs_callback_status),
0, "Status Of Callback Thread" }},
0, "Status Of Callback Thread", HFILL }},
{ &hf_nisplus_cp_status, {
"status", "nisplus.checkpoint.status", FT_UINT32, BASE_DEC,
NULL, 0, "Checkpoint Status" }},
NULL, 0, "Checkpoint Status", HFILL }},
{ &hf_nisplus_cp_zticks, {
"zticks", "nisplus.checkpoint.zticks", FT_UINT32, BASE_DEC,
NULL, 0, "Service Ticks" }},
NULL, 0, "Service Ticks", HFILL }},
{ &hf_nisplus_cp_dticks, {
"dticks", "nisplus.checkpoint.dticks", FT_UINT32, BASE_DEC,
NULL, 0, "Database Ticks" }},
NULL, 0, "Database Ticks", HFILL }},
{ &hf_nisplus_zticks, {
"zticks", "nisplus.zticks", FT_UINT32, BASE_DEC,
NULL, 0, "" }},
NULL, 0, "", HFILL }},
{ &hf_nisplus_dticks, {
"dticks", "nisplus.dticks", FT_UINT32, BASE_DEC,
NULL, 0, "" }},
NULL, 0, "", HFILL }},
{ &hf_nisplus_aticks, {
"aticks", "nisplus.aticks", FT_UINT32, BASE_DEC,
NULL, 0, "" }},
NULL, 0, "", HFILL }},
{ &hf_nisplus_cticks, {
"cticks", "nisplus.cticks", FT_UINT32, BASE_DEC,
NULL, 0, "" }},
NULL, 0, "", HFILL }},
};
@ -1895,11 +1895,11 @@ proto_register_niscb(void)
static hf_register_info hf[] = {
{ &hf_nispluscb_entries, {
"entries", "nispluscb.entries", FT_NONE, BASE_NONE,
NULL, 0, "NIS Callback Entries" }},
NULL, 0, "NIS Callback Entries", HFILL }},
{ &hf_nispluscb_entry, {
"entry", "nispluscb.entry", FT_NONE, BASE_NONE,
NULL, 0, "NIS Callback Entry" }},
NULL, 0, "NIS Callback Entry", HFILL }},
};

40
packet-nlm.c
View File

@ -1,7 +1,7 @@
/* packet-nlm.c
* Routines for nlm dissection
*
* $Id: packet-nlm.c,v 1.17 2001/05/30 06:01:02 guy Exp $
* $Id: packet-nlm.c,v 1.18 2001/06/18 02:17:50 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -688,61 +688,61 @@ proto_register_nlm(void)
static hf_register_info hf[] = {
{ &hf_nlm_cookie, {
"cookie", "nlm.cookie", FT_BYTES, BASE_DEC,
NULL, 0, "cookie" }},
NULL, 0, "cookie", HFILL }},
{ &hf_nlm_block, {
"block", "nlm.block", FT_BOOLEAN, BASE_NONE,
&yesno, 0, "block" }},
&yesno, 0, "block", HFILL }},
{ &hf_nlm_exclusive, {
"exclusive", "nlm.exclusive", FT_BOOLEAN, BASE_NONE,
&yesno, 0, "exclusive" }},
&yesno, 0, "exclusive", HFILL }},
{ &hf_nlm_lock, {
"lock", "nlm.lock", FT_NONE, 0,
NULL, 0, "lock" }},
NULL, 0, "lock", HFILL }},
{ &hf_nlm_lock_caller_name, {
"caller_name", "nlm.lock.caller_name", FT_STRING, BASE_NONE,
NULL, 0, "caller_name" }},
NULL, 0, "caller_name", HFILL }},
{ &hf_nlm_lock_owner, {
"owner", "nlm.lock.owner", FT_BYTES, BASE_DEC,
NULL, 0, "owner" }},
NULL, 0, "owner", HFILL }},
{ &hf_nlm_lock_svid, {
"svid", "nlm.lock.svid", FT_UINT32, BASE_DEC,
NULL, 0, "svid" }},
NULL, 0, "svid", HFILL }},
{ &hf_nlm_lock_l_offset, {
"l_offset", "nlm.lock.l_offset", FT_UINT32, BASE_DEC,
NULL, 0, "l_offset" }},
NULL, 0, "l_offset", HFILL }},
{ &hf_nlm_lock_l_len, {
"l_len", "nlm.lock.l_len", FT_UINT32, BASE_DEC,
NULL, 0, "l_len" }},
NULL, 0, "l_len", HFILL }},
{ &hf_nlm_reclaim, {
"reclaim", "nlm.reclaim", FT_BOOLEAN, BASE_NONE,
&yesno, 0, "reclaim" }},
&yesno, 0, "reclaim", HFILL }},
{ &hf_nlm_state, {
"state", "nlm.state", FT_UINT32, BASE_DEC,
VALS(names_nlm_state), 0, "state" }},
VALS(names_nlm_state), 0, "state", HFILL }},
{ &hf_nlm_test_stat, {
"test_stat", "nlm.test_stat", FT_NONE, 0,
NULL, 0, "test_stat" }},
NULL, 0, "test_stat", HFILL }},
{ &hf_nlm_test_stat_stat, {
"stat", "nlm.test_stat.stat", FT_UINT32, BASE_DEC,
VALS(names_nlm_state), 0, "stat" }},
VALS(names_nlm_state), 0, "stat", HFILL }},
{ &hf_nlm_holder, {
"holder", "nlm.holder", FT_NONE, 0,
NULL, 0, "holder" }},
NULL, 0, "holder", HFILL }},
{ &hf_nlm_share, {
"share", "nlm.share", FT_NONE, 0,
NULL, 0, "share" }},
NULL, 0, "share", HFILL }},
{ &hf_nlm_share_mode, {
"mode", "nlm.share.mode", FT_UINT32, BASE_DEC,
VALS(names_fsh_mode), 0, "mode" }},
VALS(names_fsh_mode), 0, "mode", HFILL }},
{ &hf_nlm_share_access, {
"access", "nlm.share.access", FT_UINT32, BASE_DEC,
VALS(names_fsh_access), 0, "access" }},
VALS(names_fsh_access), 0, "access", HFILL }},
{ &hf_nlm_share_name, {
"name", "nlm.share.name", FT_STRING, BASE_NONE,
NULL, 0, "name" }},
NULL, 0, "name", HFILL }},
{ &hf_nlm_sequence, {
"sequence", "nlm.sequence", FT_INT32, BASE_DEC,
NULL, 0, "sequence" }},
NULL, 0, "sequence", HFILL }},
};
static gint *ett[] = {

6
packet-nntp.c
View File

@ -2,7 +2,7 @@
* Routines for nntp packet dissection
* Copyright 1999, Richard Sharpe <rsharpe@ns.aus.com>
*
* $Id: packet-nntp.c,v 1.19 2001/01/22 08:03:45 guy Exp $
* $Id: packet-nntp.c,v 1.20 2001/06/18 02:17:50 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -127,12 +127,12 @@ proto_register_nntp(void)
{ &hf_nntp_response,
{ "Response", "nntp.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if NNTP response" }},
"TRUE if NNTP response", HFILL }},
{ &hf_nntp_request,
{ "Request", "nntp.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if NNTP request" }}
"TRUE if NNTP request", HFILL }}
};
static gint *ett[] = {
&ett_nntp,

34
packet-ntp.c
View File

@ -2,7 +2,7 @@
* Routines for NTP packet dissection
* Copyright 1999, Nathan Neulinger <nneul@umr.edu>
*
* $Id: packet-ntp.c,v 1.27 2001/04/09 21:42:01 guy Exp $
* $Id: packet-ntp.c,v 1.28 2001/06/18 02:17:50 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -437,52 +437,52 @@ proto_register_ntp(void)
static hf_register_info hf[] = {
{ &hf_ntp_flags, {
"Flags", "ntp.flags", FT_UINT8, BASE_HEX,
NULL, 0, "Flags (Leap/Version/Mode)" }},
NULL, 0, "Flags (Leap/Version/Mode)", HFILL }},
{ &hf_ntp_flags_li, {
"Leap Indicator", "ntp.flags.li", FT_UINT8, BASE_DEC,
VALS(li_types), NTP_LI_MASK, "Leap Indicator" }},
VALS(li_types), NTP_LI_MASK, "Leap Indicator", HFILL }},
{ &hf_ntp_flags_vn, {
"Version number", "ntp.flags.vn", FT_UINT8, BASE_DEC,
VALS(ver_nums), NTP_VN_MASK, "Version number" }},
VALS(ver_nums), NTP_VN_MASK, "Version number", HFILL }},
{ &hf_ntp_flags_mode, {
"Mode", "ntp.flags.mode", FT_UINT8, BASE_DEC,
VALS(mode_types), NTP_MODE_MASK, "Mode" }},
VALS(mode_types), NTP_MODE_MASK, "Mode", HFILL }},
{ &hf_ntp_stratum, {
"Peer Clock Stratum", "ntp.stratum", FT_UINT8, BASE_DEC,
NULL, 0, "Peer Clock Stratum" }},
NULL, 0, "Peer Clock Stratum", HFILL }},
{ &hf_ntp_ppoll, {
"Peer Polling Interval", "ntp.ppoll", FT_UINT8, BASE_DEC,
NULL, 0, "Peer Polling Interval" }},
NULL, 0, "Peer Polling Interval", HFILL }},
{ &hf_ntp_precision, {
"Peer Clock Precision", "ntp.precision", FT_UINT8, BASE_DEC,
NULL, 0, "Peer Clock Precision" }},
NULL, 0, "Peer Clock Precision", HFILL }},
{ &hf_ntp_rootdelay, {
"Root Delay", "ntp.rootdelay", FT_DOUBLE, BASE_DEC,
NULL, 0, "Root Delay" }},
NULL, 0, "Root Delay", HFILL }},
{ &hf_ntp_rootdispersion, {
"Clock Dispersion", "ntp.rootdispersion", FT_DOUBLE, BASE_DEC,
NULL, 0, "Clock Dispersion" }},
NULL, 0, "Clock Dispersion", HFILL }},
{ &hf_ntp_refid, {
"Reference Clock ID", "ntp.refid", FT_BYTES, BASE_NONE,
NULL, 0, "Reference Clock ID" }},
NULL, 0, "Reference Clock ID", HFILL }},
{ &hf_ntp_reftime, {
"Reference Clock Update Time", "ntp.reftime", FT_BYTES, BASE_NONE,
NULL, 0, "Reference Clock Update Time" }},
NULL, 0, "Reference Clock Update Time", HFILL }},
{ &hf_ntp_org, {
"Originate Time Stamp", "ntp.org", FT_BYTES, BASE_NONE,
NULL, 0, "Originate Time Stamp" }},
NULL, 0, "Originate Time Stamp", HFILL }},
{ &hf_ntp_rec, {
"Receive Time Stamp", "ntp.rec", FT_BYTES, BASE_NONE,
NULL, 0, "Receive Time Stamp" }},
NULL, 0, "Receive Time Stamp", HFILL }},
{ &hf_ntp_xmt, {
"Transmit Time Stamp", "ntp.xmt", FT_BYTES, BASE_NONE,
NULL, 0, "Transmit Time Stamp" }},
NULL, 0, "Transmit Time Stamp", HFILL }},
{ &hf_ntp_keyid, {
"Key ID", "ntp.keyid", FT_BYTES, BASE_HEX,
NULL, 0, "Key ID" }},
NULL, 0, "Key ID", HFILL }},
{ &hf_ntp_mac, {
"Message Authentication Code", "ntp.mac", FT_BYTES, BASE_HEX,
NULL, 0, "Message Authentication Code" }},
NULL, 0, "Message Authentication Code", HFILL }},
};
static gint *ett[] = {
&ett_ntp,

6
packet-null.c
View File

@ -1,7 +1,7 @@
/* packet-null.c
* Routines for null packet disassembly
*
* $Id: packet-null.c,v 1.45 2001/04/23 18:19:03 guy Exp $
* $Id: packet-null.c,v 1.46 2001/06/18 02:17:50 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -290,11 +290,11 @@ proto_register_null(void)
/* registered here but handled in ethertype.c */
{ &hf_null_etype,
{ "Type", "null.type", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0,
"" }},
"", HFILL }},
{ &hf_null_family,
{ "Family", "null.family", FT_UINT32, BASE_HEX, VALS(family_vals), 0x0,
"" }}
"", HFILL }}
};
static gint *ett[] = {
&ett_null,

8
packet-pim.c
View File

@ -2,7 +2,7 @@
* Routines for PIM disassembly
* (c) Copyright Jun-ichiro itojun Hagino <itojun@itojun.org>
*
* $Id: packet-pim.c,v 1.28 2001/05/07 20:26:25 guy Exp $
* $Id: packet-pim.c,v 1.29 2001/06/18 02:17:50 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -683,13 +683,13 @@ proto_register_pim(void)
static hf_register_info hf[] = {
{ &hf_pim_version,
{ "Version", "pim.version",
FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_pim_type,
{ "Type", "pim.type",
FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
{ &hf_pim_cksum,
{ "Checksum", "pim.cksum",
FT_UINT16, BASE_HEX, NULL, 0x0, "" }},
FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
};
static gint *ett[] = {
&ett_pim,

6
packet-pop.c
View File

@ -2,7 +2,7 @@
* Routines for pop packet dissection
* Copyright 1999, Richard Sharpe <rsharpe@ns.aus.com>
*
* $Id: packet-pop.c,v 1.24 2001/01/22 08:03:45 guy Exp $
* $Id: packet-pop.c,v 1.25 2001/06/18 02:17:50 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@zing.org>
@ -203,12 +203,12 @@ proto_register_pop(void)
{ &hf_pop_response,
{ "Response", "pop.response",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if POP response" }},
"TRUE if POP response", HFILL }},
{ &hf_pop_request,
{ "Request", "pop.request",
FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"TRUE if POP request" }}
"TRUE if POP request", HFILL }}
};
static gint *ett[] = {
&ett_pop,

32
packet-portmap.c
View File

@ -1,7 +1,7 @@
/* packet-portmap.c
* Routines for portmap dissection
*
* $Id: packet-portmap.c,v 1.30 2001/05/30 06:01:02 guy Exp $
* $Id: packet-portmap.c,v 1.31 2001/06/18 02:17:50 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -453,49 +453,49 @@ proto_register_portmap(void)
static hf_register_info hf[] = {
{ &hf_portmap_prog, {
"Program", "portmap.prog", FT_UINT32, BASE_DEC,
NULL, 0, "Program" }},
NULL, 0, "Program", HFILL }},
{ &hf_portmap_port, {
"Port", "portmap.port", FT_UINT32, BASE_DEC,
NULL, 0, "Port" }},
NULL, 0, "Port", HFILL }},
{ &hf_portmap_proc, {
"Procedure", "portmap.proc", FT_UINT32, BASE_DEC,
NULL, 0, "Procedure" }},
NULL, 0, "Procedure", HFILL }},
{ &hf_portmap_proto, {
"Protocol", "portmap.proto", FT_UINT32, BASE_DEC,
NULL, 0, "Protocol" }},
NULL, 0, "Protocol", HFILL }},
{ &hf_portmap_version, {
"Version", "portmap.version", FT_UINT32, BASE_DEC,
NULL, 0, "Version" }},
NULL, 0, "Version", HFILL }},
{ &hf_portmap_answer, {
"Answer", "portmap.answer", FT_BOOLEAN, BASE_DEC,
NULL, 0, "Answer" }},
NULL, 0, "Answer", HFILL }},
{ &hf_portmap_args, {
"Arguments", "portmap.args", FT_BYTES, BASE_HEX,
NULL, 0, "Arguments" }},
NULL, 0, "Arguments", HFILL }},
{ &hf_portmap_result, {
"Result", "portmap.result", FT_BYTES, BASE_HEX,
NULL, 0, "Result" }},
NULL, 0, "Result", HFILL }},
{ &hf_portmap_rpcb, {
"RPCB", "portmap.rpcb", FT_NONE, 0,
NULL, 0, "RPCB" }},
NULL, 0, "RPCB", HFILL }},
{ &hf_portmap_rpcb_prog, {
"Program", "portmap.rpcb.prog", FT_UINT32, BASE_DEC,
NULL, 0, "Program" }},
NULL, 0, "Program", HFILL }},
{ &hf_portmap_rpcb_version, {
"Version", "portmap.rpcb.version", FT_UINT32, BASE_DEC,
NULL, 0, "Version" }},
NULL, 0, "Version", HFILL }},
{ &hf_portmap_rpcb_netid, {
"Network Id", "portmap.rpcb.netid", FT_STRING, BASE_DEC,
NULL, 0, "Network Id" }},
NULL, 0, "Network Id", HFILL }},
{ &hf_portmap_rpcb_addr, { /* address in rpcb structure in request */
"Universal Address", "portmap.rpcb.addr", FT_STRING, BASE_DEC,
NULL, 0, "Universal Address" }},
NULL, 0, "Universal Address", HFILL }},
{ &hf_portmap_rpcb_owner, {
"Owner of this Service", "portmap.rpcb.owner", FT_STRING, BASE_DEC,
NULL, 0, "Owner of this Service" }},
NULL, 0, "Owner of this Service", HFILL }},
{ &hf_portmap_uaddr, { /* address in RPCBPROC_GETADDR reply */
"Universal Address", "portmap.uaddr", FT_STRING, BASE_DEC,
NULL, 0, "Universal Address" }},
NULL, 0, "Universal Address", HFILL }},
};
static gint *ett[] = {
&ett_portmap,

8
packet-ppp.c
View File

@ -1,7 +1,7 @@
/* packet-ppp.c
* Routines for ppp packet disassembly
*
* $Id: packet-ppp.c,v 1.67 2001/06/16 00:51:45 guy Exp $
* $Id: packet-ppp.c,v 1.68 2001/06/18 02:17:50 guy Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
@ -1564,15 +1564,15 @@ proto_register_mp(void)
static hf_register_info hf[] = {
{ &hf_mp_frag_first,
{ "First fragment", "mp.first", FT_BOOLEAN, 8,
TFS(&frag_truth), MP_FRAG_FIRST, "" }},
TFS(&frag_truth), MP_FRAG_FIRST, "", HFILL }},
{ &hf_mp_frag_last,
{ "Last fragment", "mp.last", FT_BOOLEAN, 8,
TFS(&frag_truth), MP_FRAG_LAST, "" }},
TFS(&frag_truth), MP_FRAG_LAST, "", HFILL }},
{ &hf_mp_sequence_num,
{ "Sequence number", "mp.seq", FT_UINT24, BASE_DEC, NULL, 0x0,
"" }}
"", HFILL }}
};
static gint *ett[] = {
&ett_mp,

Some files were not shown because too many files have changed in this diff Show More