diff options
| author | Guy Harris <guy@alum.mit.edu> | 2001-06-18 02:18:27 +0000 |
|---|---|---|
| committer | Guy Harris <guy@alum.mit.edu> | 2001-06-18 02:18:27 +0000 |
| commit | 84123931970a8a0f1af281e7351eadabba3c0908 (patch) | |
| tree | 90c18fd2b2f7ddb3e9eac08059e59c3e0068f743 | |
| parent | b9222c0011e362d2ba9895af4eaef04a3d72c8c6 (diff) | |
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
162 files changed, 3028 insertions, 3023 deletions
diff --git a/epan/proto.h b/epan/proto.h index e3be5efb61..ff373f4647 100644 --- a/epan/proto.h +++ b/epan/proto.h @@ -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 { diff --git a/make-reg-dotc.py b/make-reg-dotc.py index 09c1c8fa85..c6555a3922 100755 --- a/make-reg-dotc.py +++ b/make-reg-dotc.py @@ -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() diff --git a/ncp2222.py b/ncp2222.py index 2556cc0f21..5a26ddbca9 100755 --- a/ncp2222.py +++ b/ncp2222.py @@ -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()) diff --git a/packet-aarp.c b/packet-aarp.c index 0619e746bc..a105d0e8e7 100644 --- a/packet-aarp.c +++ b/packet-aarp.c @@ -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, diff --git a/packet-afs-register-info.h b/packet-afs-register-info.h index 42fc1c81e5..4f03d216db 100644 --- a/packet-afs-register-info.h +++ b/packet-afs-register-info.h @@ -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 }}, diff --git a/packet-aim.c b/packet-aim.c index 5598da46a7..77214e7dcd 100644 --- a/packet-aim.c +++ b/packet-aim.c @@ -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 } }, }; diff --git a/packet-arp.c b/packet-arp.c index e95a76d25c..62a20d5255 100644 --- a/packet-arp.c +++ b/packet-arp.c @@ -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, diff --git a/packet-ascend.c b/packet-ascend.c index ce351ce6b2..b0b5d40b73 100644 --- a/packet-ascend.c +++ b/packet-ascend.c @@ -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, diff --git a/packet-atalk.c b/packet-atalk.c index 9a2bb39acd..98a91c767c 100644 --- a/packet-atalk.c +++ b/packet-atalk.c @@ -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 }} }; diff --git a/packet-atm.c b/packet-atm.c index a4bbde3801..0304a30613 100644 --- a/packet-atm.c +++ b/packet-atm.c @@ -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, diff --git a/packet-auto_rp.c b/packet-auto_rp.c index 8c13753085..ca113e9836 100644 --- a/packet-auto_rp.c +++ b/packet-auto_rp.c @@ -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[] = { diff --git a/packet-bacapp.c b/packet-bacapp.c index f455c60416..44dc7efb44 100644 --- a/packet-bacapp.c +++ b/packet-bacapp.c @@ -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[] = { diff --git a/packet-bacnet.c b/packet-bacnet.c index c5ea2731b6..a583bdba66 100644 --- a/packet-bacnet.c +++ b/packet-bacnet.c @@ -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 } }, }; diff --git a/packet-bgp.c b/packet-bgp.c index 18a9d7c5a6..08e6d285a4 100644 --- a/packet-bgp.c +++ b/packet-bgp.c @@ -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[] = { diff --git a/packet-bootp.c b/packet-bootp.c index 21ab5f2c7e..74d123954b 100644 --- a/packet-bootp.c +++ b/packet-bootp.c @@ -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, diff --git a/packet-bootparams.c b/packet-bootparams.c index d2ae45bf38..8eb3495190 100644 --- a/packet-bootparams.c +++ b/packet-bootparams.c @@ -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, diff --git a/packet-bpdu.c b/packet-bpdu.c index 4265a77628..0d86b92884 100644 --- a/packet-bpdu.c +++ b/packet-bpdu.c @@ -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, diff --git a/packet-bvlc.c b/packet-bvlc.c index 9527f3d7a4..5dd638f463 100644 --- a/packet-bvlc.c +++ b/packet-bvlc.c @@ -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 } }, }; diff --git a/packet-bxxp.c b/packet-bxxp.c index 6df53c345f..6d8d2a18c5 100644 --- a/packet-bxxp.c +++ b/packet-bxxp.c @@ -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[] = { diff --git a/packet-cdp.c b/packet-cdp.c index 04b39573a8..cb96c4e75b 100644 --- a/packet-cdp.c +++ b/packet-cdp.c @@ -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, diff --git a/packet-cgmp.c b/packet-cgmp.c index 9a5d50baba..2fa52de732 100644 --- a/packet-cgmp.c +++ b/packet-cgmp.c @@ -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, diff --git a/packet-chdlc.c b/packet-chdlc.c index da78406aa3..12d4ca84ae 100644 --- a/packet-chdlc.c +++ b/packet-chdlc.c @@ -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, diff --git a/packet-clnp.c b/packet-clnp.c index 40ce8fbdf3..c5216410fe 100644 --- a/packet-clnp.c +++ b/packet-clnp.c @@ -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, diff --git a/packet-cops.c b/packet-cops.c index 45344ba345..e062bd0a14 100644 --- a/packet-cops.c +++ b/packet-cops.c @@ -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 } }, }; diff --git a/packet-cups.c b/packet-cups.c index e87dda7fcd..9525dcb884 100644 --- a/packet-cups.c +++ b/packet-cups.c @@ -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[] = { diff --git a/packet-dcerpc.c b/packet-dcerpc.c index 8ecd2cec49..9534a23d3f 100644 --- a/packet-dcerpc.c +++ b/packet-dcerpc.c @@ -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 }}, }; diff --git a/packet-ddtp.c b/packet-ddtp.c index d63b0520b8..59c7d6d16a 100644 --- a/packet-ddtp.c +++ b/packet-ddtp.c @@ -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 }; diff --git a/packet-diameter.c b/packet-diameter.c index 7dcd9d6342..77a50cab08 100644 --- a/packet-diameter.c +++ b/packet-diameter.c @@ -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[] = { diff --git a/packet-dns.c b/packet-dns.c index 39f2fbe58b..9822b02a7c 100644 --- a/packet-dns.c +++ b/packet-dns.c @@ -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, diff --git a/packet-dsi.c b/packet-dsi.c index 4335d0b82f..0c1d72f44d 100644 --- a/packet-dsi.c +++ b/packet-dsi.c @@ -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[] = { diff --git a/packet-dvmrp.c b/packet-dvmrp.c index 51728ac1c3..3b60a68b74 100644 --- a/packet-dvmrp.c +++ b/packet-dvmrp.c @@ -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[] = { diff --git a/packet-eigrp.c b/packet-eigrp.c index 6c85c338a0..9125486f96 100644 --- a/packet-eigrp.c +++ b/packet-eigrp.c @@ -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 } }, }; diff --git a/packet-esis.c b/packet-esis.c index 51b78a0183..61512164b1 100644 --- a/packet-esis.c +++ b/packet-esis.c @@ -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 }} }; /* * diff --git a/packet-eth.c b/packet-eth.c index 6fac1813da..ec2aea8e63 100644 --- a/packet-eth.c +++ b/packet-eth.c @@ -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[] = { diff --git a/packet-fddi.c b/packet-fddi.c index 159f01bfef..cffa8115ff 100644 --- a/packet-fddi.c +++ b/packet-fddi.c @@ -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[] = { diff --git a/packet-fr.c b/packet-fr.c index b38d6c786a..d79628f6b1 100644 --- a/packet-fr.c +++ b/packet-fr.c @@ -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 }}, }; diff --git a/packet-frame.c b/packet-frame.c index cd698e7280..419bca6994 100644 --- a/packet-frame.c +++ b/packet-frame.c @@ -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, diff --git a/packet-ftp.c b/packet-ftp.c index a3ef9f5294..645b754663 100644 --- a/packet-ftp.c +++ b/packet-ftp.c @@ -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, diff --git a/packet-giop.c b/packet-giop.c index 8cb4a320a0..20ac19ed8f 100644 --- a/packet-giop.c +++ b/packet-giop.c @@ -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 } } , }; diff --git a/packet-gnutella.c b/packet-gnutella.c index 54ff88fab7..8f67f2eddb 100644 --- a/packet-gnutella.c +++ b/packet-gnutella.c @@ -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 } }, }; diff --git a/packet-gre.c b/packet-gre.c index 11a71b6f72..0f145c4aa1 100644 --- a/packet-gre.c +++ b/packet-gre.c @@ -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[] = { diff --git a/packet-gtp.c b/packet-gtp.c index 8955c8a306..9580413ed5 100644 --- a/packet-gtp.c +++ b/packet-gtp.c @@ -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 }}, }; diff --git a/packet-gvrp.c b/packet-gvrp.c index 1fb574353a..470f557795 100644 --- a/packet-gvrp.c +++ b/packet-gvrp.c @@ -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 } } }; diff --git a/packet-h1.c b/packet-h1.c index 0519cd85ec..d03a333660 100644 --- a/packet-h1.c +++ b/packet-h1.c @@ -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[] = { diff --git a/packet-h261.c b/packet-h261.c index eb6ea020c1..e96d354a6c 100644 --- a/packet-h261.c +++ b/packet-h261.c @@ -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 } }, }; diff --git a/packet-hclnfsd.c b/packet-hclnfsd.c index 396e8896b9..bf0b9320cd 100644 --- a/packet-hclnfsd.c +++ b/packet-hclnfsd.c @@ -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, diff --git a/packet-hsrp.c b/packet-hsrp.c index 9e6f1cbbd4..c4c32c0569 100644 --- a/packet-hsrp.c +++ b/packet-hsrp.c @@ -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 }}, }; diff --git a/packet-http.c b/packet-http.c index eb535b210a..6aed5204e2 100644 --- a/packet-http.c +++ b/packet-http.c @@ -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, diff --git a/packet-icmpv6.c b/packet-icmpv6.c index 0dfcd962e9..ee3ccba5d8 100644 --- a/packet-icmpv6.c +++ b/packet-icmpv6.c @@ -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, diff --git a/packet-icp.c b/packet-icp.c index b6500a6302..84ab7e228c 100644 --- a/packet-icp.c +++ b/packet-icp.c @@ -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, diff --git a/packet-icq.c b/packet-icq.c index 4fc673e0a2..1822d3bcdb 100644 --- a/packet-icq.c +++ b/packet-icq.c @@ -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, diff --git a/packet-ieee80211.c b/packet-ieee80211.c index 22b49dd528..6a1736b6b9 100644 --- a/packet-ieee80211.c +++ b/packet-ieee80211.c @@ -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 }} }; diff --git a/packet-igmp.c b/packet-igmp.c index 0f477ef5bd..d54660ccdb 100644 --- a/packet-igmp.c +++ b/packet-igmp.c @@ -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[] = { diff --git a/packet-igrp.c b/packet-igrp.c index e4bd8001f6..d7869569ec 100644 --- a/packet-igrp.c +++ b/packet-igrp.c @@ -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 } } }; diff --git a/packet-imap.c b/packet-imap.c index e595586e63..8a1c506f42 100644 --- a/packet-imap.c +++ b/packet-imap.c @@ -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, diff --git a/packet-ip.c b/packet-ip.c index 6113ffda78..bec3b3451a 100644 --- a/packet-ip.c +++ b/packet-ip.c @@ -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, diff --git a/packet-ipsec.c b/packet-ipsec.c index 7da8beb201..51c18021ac 100644 --- a/packet-ipsec.c +++ b/packet-ipsec.c @@ -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, diff --git a/packet-ipv6.c b/packet-ipv6.c index 935ccf1f7e..5db7bf13e7 100644 --- a/packet-ipv6.c +++ b/packet-ipv6.c @@ -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[] = { diff --git a/packet-ipx.c b/packet-ipx.c index ac71eed557..ce24ff9320 100644 --- a/packet-ipx.c +++ b/packet-ipx.c @@ -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[] = { diff --git a/packet-irc.c b/packet-irc.c index 8a09ac5ffd..2a4b821a96 100644 --- a/packet-irc.c +++ b/packet-irc.c @@ -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[] = { diff --git a/packet-iscsi.c b/packet-iscsi.c index ff8aae9718..fd5e1fe325 100644 --- a/packet-iscsi.c +++ b/packet-iscsi.c @@ -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 } }, }; diff --git a/packet-isis-hello.c b/packet-isis-hello.c index 5526a397d1..2859c75796 100644 --- a/packet-isis-hello.c +++ b/packet-isis-hello.c @@ -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[] = { diff --git a/packet-isis-lsp.c b/packet-isis-lsp.c index c2990ef2be..cd2b3f741f 100644 --- a/packet-isis-lsp.c +++ b/packet-isis-lsp.c @@ -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, diff --git a/packet-isis-snp.c b/packet-isis-snp.c index 8a0904c559..39e41191a9 100644 --- a/packet-isis-snp.c +++ b/packet-isis-snp.c @@ -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, diff --git a/packet-isis.c b/packet-isis.c index cda0923a1f..b8895b30c5 100644 --- a/packet-isis.c +++ b/packet-isis.c @@ -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 }}, }; /* diff --git a/packet-isl.c b/packet-isl.c index b704156031..768cce1897 100644 --- a/packet-isl.c +++ b/packet-isl.c @@ -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, diff --git a/packet-isup.c b/packet-isup.c index 63615fd512..b968fb01f3 100644 --- a/packet-isup.c +++ b/packet-isup.c @@ -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 */ diff --git a/packet-iua.c b/packet-iua.c index 729bb2a282..37661fec22 100644 --- a/packet-iua.c +++ b/packet-iua.c @@ -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 */ diff --git a/packet-klm.c b/packet-klm.c index adf0325b15..a5dcf9914e 100644 --- a/packet-klm.c +++ b/packet-klm.c @@ -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 }}, }; diff --git a/packet-l2tp.c b/packet-l2tp.c index de662413d8..a659372fec 100644 --- a/packet-l2tp.c +++ b/packet-l2tp.c @@ -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[] = { diff --git a/packet-lapb.c b/packet-lapb.c index fe540bfff0..f9383b99d0 100644 --- a/packet-lapb.c +++ b/packet-lapb.c @@ -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, diff --git a/packet-lapbether.c b/packet-lapbether.c index d9e4164382..ad1616a1b0 100644 --- a/packet-lapbether.c +++ b/packet-lapbether.c @@ -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[] = { diff --git a/packet-lapd.c b/packet-lapd.c index 0ab5fef88a..20265f0248 100644 --- a/packet-lapd.c +++ b/packet-lapd.c @@ -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, diff --git a/packet-ldap.c b/packet-ldap.c index f592fd91c9..409c12eaf6 100644 --- a/packet-ldap.c +++ b/packet-ldap.c @@ -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[] = { diff --git a/packet-ldp.c b/packet-ldp.c index ad286cae5f..dde055b989 100644 --- a/packet-ldp.c +++ b/packet-ldp.c @@ -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[] = { diff --git a/packet-llc.c b/packet-llc.c index b911247562..d13fcde952 100644 --- a/packet-llc.c +++ b/packet-llc.c @@ -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, diff --git a/packet-lmi.c b/packet-lmi.c index 299057182f..67fa7749e3 100644 --- a/packet-lmi.c +++ b/packet-lmi.c @@ -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, diff --git a/packet-lpd.c b/packet-lpd.c index 5d06fd9c7c..4a2de0b8e4 100644 --- a/packet-lpd.c +++ b/packet-lpd.c @@ -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, diff --git a/packet-m3ua.c b/packet-m3ua.c index fd3457b57e..a713480d53 100644 --- a/packet-m3ua.c +++ b/packet-m3ua.c @@ -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 } }, }; diff --git a/packet-mapi.c b/packet-mapi.c index d5089af8a0..78e104850e 100644 --- a/packet-mapi.c +++ b/packet-mapi.c @@ -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[] = { diff --git a/packet-mbtcp.c b/packet-mbtcp.c index fc223236d7..5248e1de71 100644 --- a/packet-mbtcp.c +++ b/packet-mbtcp.c @@ -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 } } }; diff --git a/packet-mip.c b/packet-mip.c index 6389df9632..3b129cc421 100644 --- a/packet-mip.c +++ b/packet-mip.c @@ -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 } }, }; diff --git a/packet-mount.c b/packet-mount.c index e7f5e22d52..106409356b 100644 --- a/packet-mount.c +++ b/packet-mount.c @@ -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, diff --git a/packet-mpeg1.c b/packet-mpeg1.c index e9cf500bd0..6a8187936c 100644 --- a/packet-mpeg1.c +++ b/packet-mpeg1.c @@ -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 } }, diff --git a/packet-mpls.c b/packet-mpls.c index b42d5517df..7e1bd55a12 100644 --- a/packet-mpls.c +++ b/packet-mpls.c @@ -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; diff --git a/packet-msproxy.c b/packet-msproxy.c index 0beb325758..1eaeb89558 100644 --- a/packet-msproxy.c +++ b/packet-msproxy.c @@ -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 } } diff --git a/packet-mtp3.c b/packet-mtp3.c index a315d06957..15992a6461 100644 --- a/packet-mtp3.c +++ b/packet-mtp3.c @@ -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 */ diff --git a/packet-nbns.c b/packet-nbns.c index 6a6084b274..763828e9ea 100644 --- a/packet-nbns.c +++ b/packet-nbns.c @@ -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, diff --git a/packet-ncp.c b/packet-ncp.c index f3ab871fd0..5ad6bdb543 100644 --- a/packet-ncp.c +++ b/packet-ncp.c @@ -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, diff --git a/packet-netbios.c b/packet-netbios.c index 06dd5ad3be..4a2f5ca98e 100644 --- a/packet-netbios.c +++ b/packet-netbios.c @@ -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"); diff --git a/packet-nfs.c b/packet-nfs.c index 297f80a40c..19c032d2c3 100644 --- a/packet-nfs.c +++ b/packet-nfs.c @@ -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[] = { diff --git a/packet-nisplus.c b/packet-nisplus.c index f1052c8182..79cf345f75 100644 --- a/packet-nisplus.c +++ b/packet-nisplus.c @@ -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 }}, }; diff --git a/packet-nlm.c b/packet-nlm.c index d3fd61666a..7232bf1866 100644 --- a/packet-nlm.c +++ b/packet-nlm.c @@ -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[] = { diff --git a/packet-nntp.c b/packet-nntp.c index 3036d1ae2f..add8a14149 100644 --- a/packet-nntp.c +++ b/packet-nntp.c @@ -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, diff --git a/packet-ntp.c b/packet-ntp.c index 388d69266c..7b7fa3c4d0 100644 --- a/packet-ntp.c +++ b/packet-ntp.c @@ -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, diff --git a/packet-null.c b/packet-null.c index 37c649e4cc..d51d904c2d 100644 --- a/packet-null.c +++ b/packet-null.c @@ -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, diff --git a/packet-pim.c b/packet-pim.c index 5da7d9da6e..df2582a1cb 100644 --- a/packet-pim.c +++ b/packet-pim.c @@ -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, diff --git a/packet-pop.c b/packet-pop.c index bf07f700e2..1ca93ecb7e 100644 --- a/packet-pop.c +++ b/packet-pop.c @@ -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, diff --git a/packet-portmap.c b/packet-portmap.c index 57e8c4ebd1..4cfe351972 100644 --- a/packet-portmap.c +++ b/packet-portmap.c @@ -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, diff --git a/packet-ppp.c b/packet-ppp.c index 22e3fea188..12bdcebde5 100644 --- a/packet-ppp.c +++ b/packet-ppp.c @@ -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, diff --git a/packet-pptp.c b/packet-pptp.c index 2caa3b7ff0..a996657c69 100644 --- a/packet-pptp.c +++ b/packet-pptp.c @@ -2,7 +2,7 @@ * Routines for the Point-to-Point Tunnelling Protocol (PPTP) (RFC 2637) * Brad Robel-Forrest <brad.robel-forrest@watchguard.com> * - * $Id: packet-pptp.c,v 1.18 2001/01/22 08:03:45 guy Exp $ + * $Id: packet-pptp.c,v 1.19 2001/06/18 02:17:50 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -816,7 +816,7 @@ proto_register_pptp(void) { &hf_pptp_message_type, { "Message type", "pptp.type", FT_UINT16, BASE_DEC, VALS(msgtype_vals), 0x0, - "PPTP message type" }} + "PPTP message type", HFILL }} }; proto_pptp = proto_register_protocol("Point-to-Point Tunnelling Protocol", diff --git a/packet-q2931.c b/packet-q2931.c index 6538890bc0..06aa06b6bf 100644 --- a/packet-q2931.c +++ b/packet-q2931.c @@ -2,7 +2,7 @@ * Routines for Q.2931 frame disassembly * Guy Harris <guy@alum.mit.edu> * - * $Id: packet-q2931.c,v 1.17 2001/05/27 07:18:08 guy Exp $ + * $Id: packet-q2931.c,v 1.18 2001/06/18 02:17:50 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -2086,35 +2086,35 @@ proto_register_q2931(void) static hf_register_info hf[] = { { &hf_q2931_discriminator, { "Protocol discriminator", "q2931.disc", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_q2931_call_ref_len, { "Call reference value length", "q2931.call_ref_len", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_q2931_call_ref, { "Call reference value", "q2931.call_ref", FT_BYTES, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_q2931_message_type, { "Message type", "q2931.message_type", FT_UINT8, BASE_HEX, VALS(q2931_message_type_vals), 0x0, - "" }}, + "", HFILL }}, { &hf_q2931_message_type_ext, { "Message type extension", "q2931.message_type_ext", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_q2931_message_flag, { "Flag", "q2931.message_flag", FT_BOOLEAN, 8, TFS(&tos_msg_flag), Q2931_MSG_TYPE_EXT_FOLLOW_INST, - "" }}, + "", HFILL }}, { &hf_q2931_message_action_indicator, { "Action indicator", "q2931.message_action_indicator", FT_UINT8, BASE_DEC, VALS(msg_action_ind_vals), Q2931_MSG_TYPE_EXT_ACTION_IND, - "" }}, + "", HFILL }}, { &hf_q2931_message_len, { "Message length", "q2931.message_len", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, }; static gint *ett[] = { diff --git a/packet-q931.c b/packet-q931.c index 17a24c2760..fd6cb8a293 100644 --- a/packet-q931.c +++ b/packet-q931.c @@ -2,7 +2,7 @@ * Routines for Q.931 frame disassembly * Guy Harris <guy@alum.mit.edu> * - * $Id: packet-q931.c,v 1.29 2001/05/27 07:27:21 guy Exp $ + * $Id: packet-q931.c,v 1.30 2001/06/18 02:17:50 guy Exp $ * * Modified by Andreas Sikkema for possible use with H.323 * @@ -2618,19 +2618,19 @@ proto_register_q931(void) static hf_register_info hf[] = { { &hf_q931_discriminator, { "Protocol discriminator", "q931.disc", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_q931_call_ref_len, { "Call reference value length", "q931.call_ref_len", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_q931_call_ref, { "Call reference value", "q931.call_ref", FT_BYTES, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_q931_message_type, { "Message type", "q931.message_type", FT_UINT8, BASE_HEX, VALS(q931_message_type_vals), 0x0, - "" }}, + "", HFILL }}, }; static gint *ett[] = { diff --git a/packet-quake.c b/packet-quake.c index 75c839cf26..e9856d2ee8 100644 --- a/packet-quake.c +++ b/packet-quake.c @@ -4,7 +4,7 @@ * Uwe Girlich <uwe@planetquake.com> * http://www.idsoftware.com/q1source/q1source.zip * - * $Id: packet-quake.c,v 1.14 2001/04/15 09:05:17 guy Exp $ + * $Id: packet-quake.c,v 1.15 2001/06/18 02:17:51 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -604,107 +604,107 @@ proto_register_quake(void) { &hf_quake_header_flags, { "Flags", "quake.header.flags", FT_UINT16, BASE_HEX, NULL, 0x0, - "Flags" }}, + "Flags", HFILL }}, { &hf_quake_header_length, { "Length", "quake.header.length", FT_UINT16, BASE_DEC, NULL, 0x0, - "full data length" }}, + "full data length", HFILL }}, { &hf_quake_header_sequence, { "Sequence", "quake.header.sequence", FT_UINT32, BASE_HEX, NULL, 0x0, - "Sequence Number" }}, + "Sequence Number", HFILL }}, { &hf_quake_control_command, { "Command", "quake.control.command", FT_UINT8, BASE_HEX, VALS(names_control_command), 0x0, - "Control Command" }}, + "Control Command", HFILL }}, { &hf_quake_CCREQ_CONNECT_game, { "Game", "quake.control.connect.game", FT_STRING, BASE_DEC, NULL, 0x0, - "Game Name" }}, + "Game Name", HFILL }}, { &hf_quake_CCREQ_CONNECT_version, { "Version", "quake.control.connect.version", FT_UINT8, BASE_DEC, NULL, 0x0, - "Game Protocol Version Number" }}, + "Game Protocol Version Number", HFILL }}, { &hf_quake_CCREQ_SERVER_INFO_game, { "Game", "quake.control.server_info.game", FT_STRING, BASE_DEC, NULL, 0x0, - "Game Name" }}, + "Game Name", HFILL }}, { &hf_quake_CCREQ_SERVER_INFO_version, { "Version", "quake.control.server_info.version", FT_UINT8, BASE_DEC, NULL, 0x0, - "Game Protocol Version Number" }}, + "Game Protocol Version Number", HFILL }}, { &hf_quake_CCREQ_PLAYER_INFO_player, { "Player", "quake.control.player_info.player", FT_UINT8, BASE_DEC, NULL, 0x0, - "Player" }}, + "Player", HFILL }}, { &hf_quake_CCREQ_RULE_INFO_lastrule, { "Last Rule", "quake.control.rule_info.lastrule", FT_STRING, BASE_DEC, NULL, 0x0, - "Last Rule Name" }}, + "Last Rule Name", HFILL }}, { &hf_quake_CCREP_ACCEPT_port, { "Port", "quake.control.accept.port", FT_UINT32, BASE_DEC, NULL, 0x0, - "Game Data Port" }}, + "Game Data Port", HFILL }}, { &hf_quake_CCREP_REJECT_reason, { "Reason", "quake.control.reject.reason", FT_STRING, BASE_DEC, NULL, 0x0, - "Reject Reason" }}, + "Reject Reason", HFILL }}, { &hf_quake_CCREP_SERVER_INFO_address, { "Address", "quake.control.server_info.address", FT_STRING, BASE_DEC, NULL, 0x0, - "Server Address" }}, + "Server Address", HFILL }}, { &hf_quake_CCREP_SERVER_INFO_server, { "Server", "quake.control.server_info.server", FT_STRING, BASE_DEC, NULL, 0x0, - "Server Name" }}, + "Server Name", HFILL }}, { &hf_quake_CCREP_SERVER_INFO_map, { "Map", "quake.control.server_info.map", FT_STRING, BASE_DEC, NULL, 0x0, - "Map Name" }}, + "Map Name", HFILL }}, { &hf_quake_CCREP_SERVER_INFO_num_player, { "Number of Players", "quake.control.server_info.num_player", FT_UINT8, BASE_DEC, NULL, 0x0, - "Current Number of Players" }}, + "Current Number of Players", HFILL }}, { &hf_quake_CCREP_SERVER_INFO_max_player, { "Maximal Number of Players", "quake.control.server_info.max_player", FT_UINT8, BASE_DEC, NULL, 0x0, - "Maximal Number of Players" }}, + "Maximal Number of Players", HFILL }}, { &hf_quake_CCREP_PLAYER_INFO_name, { "Name", "quake.control.player_info.name", FT_STRING, BASE_DEC, NULL, 0x0, - "Player Name" }}, + "Player Name", HFILL }}, { &hf_quake_CCREP_PLAYER_INFO_colors, { "Colors", "quake.control.player_info.colors", FT_UINT32, BASE_HEX, NULL, 0x0, - "Player Colors" }}, + "Player Colors", HFILL }}, { &hf_quake_CCREP_PLAYER_INFO_colors_shirt, { "Shirt", "quake.control.player_info.colors.shirt", FT_UINT8, BASE_DEC, VALS(names_colors), 0x0, - "Shirt Color" }}, + "Shirt Color", HFILL }}, { &hf_quake_CCREP_PLAYER_INFO_colors_pants, { "Pants", "quake.control.player_info.colors.pants", FT_UINT8, BASE_DEC, VALS(names_colors), 0x0, - "Pants Color" }}, + "Pants Color", HFILL }}, { &hf_quake_CCREP_PLAYER_INFO_frags, { "Frags", "quake.control.player_info.frags", FT_UINT32, BASE_DEC, NULL, 0x0, - "Player Frags" }}, + "Player Frags", HFILL }}, { &hf_quake_CCREP_PLAYER_INFO_connect_time, { "Connect Time", "quake.control.player_info.connect_time", FT_UINT32, BASE_DEC, NULL, 0x0, - "Player Connect Time" }}, + "Player Connect Time", HFILL }}, { &hf_quake_CCREP_PLAYER_INFO_address, { "Address", "quake.control.player_info.address", FT_STRING, BASE_DEC, NULL, 0x0, - "Player Address" }}, + "Player Address", HFILL }}, { &hf_quake_CCREP_RULE_INFO_rule, { "Rule", "quake.control.rule_info.rule", FT_STRING, BASE_DEC, NULL, 0x0, - "Rule Name" }}, + "Rule Name", HFILL }}, { &hf_quake_CCREP_RULE_INFO_value, { "Value", "quake.control.rule_info.value", FT_STRING, BASE_DEC, NULL, 0x0, - "Rule Value" }}, + "Rule Value", HFILL }}, }; static gint *ett[] = { &ett_quake, diff --git a/packet-radius.c b/packet-radius.c index cf423bfaba..432baadc23 100644 --- a/packet-radius.c +++ b/packet-radius.c @@ -2,7 +2,7 @@ * Routines for RADIUS packet disassembly * Copyright 1999 Johan Feyaerts * - * $Id: packet-radius.c,v 1.30 2001/06/14 08:23:50 guy Exp $ + * $Id: packet-radius.c,v 1.31 2001/06/18 02:17:51 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -748,15 +748,15 @@ proto_register_radius(void) static hf_register_info hf[] = { { &hf_radius_code, { "Code","radius.code", FT_UINT8, BASE_DEC, VALS(radius_vals), 0x0, - "" }}, + "", HFILL }}, { &hf_radius_id, { "Identifier", "radius.id", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_radius_length, { "Length","radius.length", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }} + "", HFILL }} }; static gint *ett[] = { &ett_radius, diff --git a/packet-ranap.c b/packet-ranap.c index 88b1e45d2b..8ba191296d 100644 --- a/packet-ranap.c +++ b/packet-ranap.c @@ -3,7 +3,7 @@ * Based on 3GPP TS 25.413 V3.4.0 * Copyright 2001, Martin Held <Martin.Held@icn.siemens.de> * - * $Id: packet-ranap.c,v 1.5 2001/06/06 18:53:27 guy Exp $ + * $Id: packet-ranap.c,v 1.6 2001/06/18 02:17:51 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -4110,667 +4110,667 @@ proto_register_ranap(void) { "RANAP-PDU Index", "ranap.ranap_pdu_index", FT_UINT8, BASE_HEX, VALS(&ranap_pdu_index_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_procedure_code, { "Procedure Code", "ranap.procedure_code", FT_UINT8, BASE_DEC, VALS(&ranap_procedure_code_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_pdu_criticality, { "Criticality of PDU", "ranap.pdu.criticality", FT_UINT8, BASE_HEX, VALS(&ranap_criticality_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_pdu_number_of_octets, { "Number of Octets in PDU", "ranap.pdu.num_of_octets", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_ie_protocol_extension, { "Protocol Extension", "ranap.ie.protocol_extension_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_number_of_ies, { "Number of IEs in PDU", "ranap.pdu.number_of_ies", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_number_of_ProtocolExtensionFields, { "Number of Protocol Extension Fields", "ranap.ie.number_of_ProtocolExtensionFields", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_number_of_ies_in_list, { "Number of IEs in list", "ranap.number_of_ies", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_ie_ie_id, { "IE-ID", "ranap.ie.ie_id", FT_UINT16, BASE_DEC, VALS(&ranap_ie_id_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_ext_field_id, { "ProtocolExtensionField ID", "ranap.ie.ProtocolExtensionFields.Id", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_ie_criticality, { "Criticality of IE", "ranap.ie.criticality", FT_UINT8, BASE_HEX, VALS(&ranap_criticality_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_ext_field_criticality, { "Criticality of ProtocolExtensionField", "ranap.ie.ProtocolExtensionFields.criticality", FT_UINT8, BASE_HEX, VALS(&ranap_criticality_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_ie_pair_first_criticality, { "First Criticality", "ranap.ie_pair.first_criticality", FT_UINT8, BASE_HEX, VALS(&ranap_criticality_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_ie_pair_second_criticality, { "Second Criticality", "ranap.ie_pair.second_criticality", FT_UINT8, BASE_HEX, VALS(&ranap_criticality_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_ie_number_of_octets, { "Number of Octets in IE", "ranap.ie.number_of_octets", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_first_value_number_of_octets, { "Number of Octets in first value", "ranap.ie_pair.first_value.number_of_octets", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_second_value_number_of_octets, { "Number of Octets in second value", "ranap.ie_pair.second_value.number_of_octets", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_rab_id, { "RAB-ID", "ranap.RAB_ID", FT_UINT8, BASE_HEX, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_nas_pdu, { "NAS-PDU", "ranap.NAS_PDU", FT_BYTES, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_extension_field, { "Extension Field Value", "ranap.Extension_Field_Value", FT_BYTES, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_plmn_id, { "PLMN-ID", "ranap.PLMN_ID", FT_BYTES, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_lac, { "LAC", "ranap.PLMN_ID", FT_BYTES, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_plmn_id, { "PLMN-ID", "ranap.PLMN_ID", FT_BYTES, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_lac, { "LAC", "ranap.PLMN_ID", FT_BYTES, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_sac, { "SAC", "ranap.SAC", FT_BYTES, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_rac, { "RAC", "ranap.RAC", FT_BYTES, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_num_rabs, { "Number of RABs", "ranap.number_of_RABs", FT_UINT8, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_nAS_SynchronisationIndicator_present, { "nAS-SynchronisationIndicator", "ranap.nAS-SynchronisationIndicator_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_rAB_Parameters_present, { "rAB-Parameters", "ranap.rAB_Parameters_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_userPlaneInformation_present, { "userPlaneInformation", "ranap.userPlaneInformation_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_transportLayerInformation_present, { "transportLayerInformation", "ranap.transportLayerInformation_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_service_Handover_present, { "service-Handover", "ranap.service_Handover_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_iE_Extensions_present, { "iE-Extensions", "ranap.ie.iE-Extensions_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_nAS_SynchronisationIndicator, { "nAS-SynchronisationIndicator", "ranap.nAS-SynchronisationIndicator", FT_UINT8, BASE_HEX, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_guaranteedBitRate_present, { "guaranteedBitRate", "ranap.guaranteedBitRate_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_transferDelay_present, { "transferDelay", "ranap.transferDelay_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_trafficHandlingPriority_present, { "trafficHandlingPriority", "ranap.trafficHandlingPriority_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_allocationOrRetentionPriority_present, { "allocationOrRetentionPriority", "ranap.allocationOrRetentionPriority_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_sourceStatisticsDescriptor_present, { "sourceStatisticsDescriptor", "ranap.sourceStatisticsDescriptor_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_relocationRequirement_present, { "relocationRequirement", "ranap.relocationRequirement_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_trafficClass, { "Traffic Class", "ranap.rab_Parameters.trafficClass", FT_UINT8, BASE_DEC, VALS(&ranap_trafficClass_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_rAB_AsymmetryIndicator, { "rAB_AsymmetryIndicator", "ranap.rab_Parameters.rAB_AsymmetryIndicator", FT_UINT8, BASE_DEC, VALS(&ranap_rAB_AsymmetryIndicator_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_maxBitrate, { "maxBitrate", "ranap.rab_Parameters.maxBitrate", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_guaranteedBitrate, { "guaranteedBitrate", "ranap.rab_Parameters.guaranteedBitrate", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_deliveryOrder, { "deliveryOrder", "ranap.rab_Parameters.deliveryOrder", FT_UINT8, BASE_DEC, VALS(&ranap_DeliveryOrder_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_maxSDU_Size, { "maxSDU_Size", "ranap.rab_Parameters.maxSDU_Size", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_sDU_ErrorRatio_mantissa, { "sDU_ErrorRatio: mantissa", "ranap.rab_Parameters.sDU_ErrorRatio.mantissa", FT_UINT8, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_sDU_ErrorRatio_exponent, { "sDU_ErrorRatio: exponent", "ranap.rab_Parameters.sDU_ErrorRatio.exponent", FT_UINT8, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_residualBitErrorRatio_mantissa, { "residualBitErrorRatio: mantissa", "ranap.rab_Parameters.residualBitErrorRatio.mantissa", FT_UINT8, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_residualBitErrorRatio_exponent, { "residualBitErrorRatio: exponent", "ranap.rab_Parameters.residualBitErrorRatio.exponent", FT_UINT8, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_deliveryOfErroneousSDU, { "deliveryOfErroneousSDU", "ranap.rab_Parameters.ranap_deliveryOfErroneousSDU", FT_UINT8, BASE_DEC, VALS(&ranap_deliveryOfErroneousSDU_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_subflowSDU_Size, { "subflowSDU_Size", "ranap.rab_Parameters.subflowSDU_Size", FT_UINT8, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_rAB_SubflowCombinationBitRate, { "rAB_SubflowCombinationBitRate", "ranap.rab_Parameters.rAB_SubflowCombinationBitRate", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_sDU_ErrorRatio_present, { "sDU_ErrorRatio", "ranap.sDU_ErrorRatio_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_sDU_FormatInformationParameters_present, { "sDU_FormatInformationParameters", "ranap.sDU_FormatInformationParameters_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_subflowSDU_Size_present, { "subflowSDU_Size", "ranap.subflowSDU_Size_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_rAB_SubflowCombinationBitRate_present, { "subflowSDU_Size", "ranap.rAB_SubflowCombinationBitRate_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_transferDelay, { "transferDelay", "ranap.rab_Parameters.transferDelay", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_trafficHandlingPriority, { "trafficHandlingPriority", "ranap.rab_Parameters.trafficHandlingPriority", FT_UINT8, BASE_DEC, VALS(&ranap_priority_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_priorityLevel, { "priorityLevel", "ranap.rab_Parameters.allocationOrRetentionPriority.priorityLevel", FT_UINT8, BASE_DEC, VALS(&ranap_priority_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_pre_emptionCapability, { "pre-emptionCapability", "ranap.rab_Parameters.allocationOrRetentionPriority.pre_emptionCapability", FT_UINT8, BASE_DEC, VALS(&ranap_pre_emptionCapability_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_pre_emptionVulnerability, { "pre-emptionVulnerability", "ranap.rab_Parameters.allocationOrRetentionPriority.pre_emptionVulnerability", FT_UINT8, BASE_DEC, VALS(&ranap_pre_emptionVulnerability_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_queuingAllowed, { "queuingAllowed", "ranap.rab_Parameters.allocationOrRetentionPriority.queuingAllowed", FT_UINT8, BASE_DEC, VALS(&ranap_queuingAllowed_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_sourceStatisticsDescriptor, { "sourceStatisticsDescriptor", "ranap.rab_Parameters.sourceStatisticsDescriptor", FT_UINT8, BASE_DEC, VALS(&ranap_sourceStatisticsDescriptor_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_relocationRequirement, { "relocationRequirement", "ranap.rab_Parameters.relocationRequirement", FT_UINT8, BASE_DEC, VALS(&ranap_relocationRequirement_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_userPlaneMode, { "userPlaneMode", "ranap.userPlaneMode", FT_UINT8, BASE_DEC, VALS(&ranap_userPlaneMode_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_uP_ModeVersions, { "uP_ModeVersions", "ranap.uP_ModeVersions", FT_BYTES, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_number_of_ProtocolExtensionFields, { "Number of ProtocolExtensionFields", "ranap.number_of_ProtocolExtensionFields", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_ext_field_number_of_octets, { "Number of octets", "ranap.ProtocolExtensionFields.octets", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_transportLayerAddress_length, { "bit length of transportLayerAddress", "ranap.transportLayerAddress_length", FT_UINT8, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_transportLayerAddress, { "transportLayerAddress", "ranap.transportLayerAddress", FT_BYTES, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_gTP_TEI, { "gTP_TEI", "ranap.gTP_TEI", FT_BYTES, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_bindingID, { "bindingID", "ranap.bindingID", FT_BYTES, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_pDP_TypeInformation_present, { "pDP_TypeInformation", "ranap.pDP_TypeInformation_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_dataVolumeReportingIndication_present, { "dataVolumeReportingIndication", "ranap.dataVolumeReportingIndication_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_dl_GTP_PDU_SequenceNumber_present, { "dl_GTP_PDU_SequenceNumber", "ranap.dl_GTP_PDU_SequenceNumber_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_ul_GTP_PDU_SequenceNumber_present, { "ul_GTP_PDU_SequenceNumber", "ranap.ul_GTP_PDU_SequenceNumber_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_dl_N_PDU_SequenceNumber_present, { "dl_N_PDU_SequenceNumber", "ranap.dl_N_PDU_SequenceNumber_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_ul_N_PDU_SequenceNumber_present, { "ul_N_PDU_SequenceNumber", "ranap.ul_N_PDU_SequenceNumber_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_PDP_Type, { "PDP-Type", "ranap.RAB_SetupOrModifyItemSecond.PDP_Type", FT_UINT8, BASE_HEX, VALS(&ranap_PDP_Type_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_dataVolumeReportingIndication, { "dataVolumeReportingIndication", "ranap.RAB_SetupOrModifyItemSecond.dataVolumeReportingIndication", FT_UINT8, BASE_HEX, VALS(&ranap_dataVolumeReportingIndication_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_dl_GTP_PDU_SequenceNumber, { "dl_GTP_PDU_SequenceNumber", "ranap.RAB_SetupOrModifyItemSecond.dl_GTP_PDU_SequenceNumber", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_ul_GTP_PDU_SequenceNumber, { "ul_GTP_PDU_SequenceNumber", "ranap.RAB_SetupOrModifyItemSecond.ul_GTP_PDU_SequenceNumber", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_dl_N_PDU_SequenceNumber, { "ul_GTP_PDU_SequenceNumber", "ranap.RAB_SetupOrModifyItemSecond.ul_GTP_PDU_SequenceNumber", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_ul_N_PDU_SequenceNumber, { "ul_GTP_PDU_SequenceNumber", "ranap.RAB_SetupOrModifyItemSecond.ul_GTP_PDU_SequenceNumber", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_cause_choice, { "cause choice", "ranap.cause_choice", FT_UINT8, BASE_HEX, VALS(&ranap_cause_choice_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_cause_value, { "cause value", "ranap.cause_value", FT_UINT8, BASE_DEC,VALS(&ranap_cause_value_str), 0x0, - ""} + "", HFILL } }, { &hf_ranap_transportLayerAddress_present, { "transportLayerAddress", "ranap.transportLayerAddress_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_iuTransportAssociation_present, { "iuTransportAssociation", "ranap.iuTransportAssociation_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_dl_dataVolumes_present, { "dl_dataVolumes", "ranap.dl_dataVolumes_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_dataVolumeReference_present, { "dataVolumeReference", "ranap.dataVolumeReference_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_dl_UnsuccessfullyTransmittedDataVolume, { "dl-UnsuccessfullyTransmittedDataVolume", "ranap.dl-UnsuccessfullyTransmittedDataVolume", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_dataVolumeReference, { "dataVolumeReference", "ranap.dataVolumeReference", FT_UINT8, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_procedureCode_present, { "procedureCode", "ranap.procedureCode_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_triggeringMessage_present, { "triggeringMessage", "ranap.triggeringMessage_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_procedureCriticality_present, { "procedureCriticality", "ranap.procedureCriticality_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_iEsCriticalityDiagnostics_present, { "iEsCriticalityDiagnostics", "ranap.iEsCriticalityDiagnostics_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_triggeringMessage, { "triggeringMessage", "ranap.triggeringMessage", FT_UINT8, BASE_HEX, VALS(&ranap_pdu_index_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_procedureCriticality, { "procedureCriticality", "ranap.procedureCriticality", FT_UINT8, BASE_HEX, VALS(&ranap_criticality_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_iECriticality, { "iECriticality", "ranap.iECriticality", FT_UINT8, BASE_HEX, VALS(&ranap_criticality_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_repetitionNumber, { "repetitionNumber", "ranap.repetitionNumber", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_num_of_CriticalityDiagnostics_IEs, { "Number of CriticalityDiagnostics-IEs", "ranap.num_of_CriticalityDiagnostics_IEs", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_repetitionNumber_present, { "repetitionNumber", "ranap.repetitionNumber_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_dl_UnsuccessfullyTransmittedDataVolume_present, { "dl-UnsuccessfullyTransmittedDataVolume", "ranap.dl_UnsuccessfullyTransmittedDataVolume_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_CN_DomainIndicator, { "CN-DomainIndicator", "ranap.CN_DomainIndicator", FT_UINT8, BASE_HEX, VALS(&ranap_CN_DomainIndicator_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_service_Handover, { "service-Handover", "ranap.service_Handover", FT_UINT8, BASE_HEX, VALS(&ranap_service_Handover_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_IuSigConId, { "IuSigConId", "ranap.IuSigConId", FT_BYTES, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, { &hf_ranap_SAPI, { "SAPI", "ranap.IuSigConId", FT_UINT8, BASE_HEX, VALS(&ranap_SAPI_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_msg_extension_present, { "Message Extension", "ranap.msg_extension_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_ProtocolExtensionContainer_present, { "ProtocolExtensionContainer", "ranap.ProtocolExtensionContainer_present", FT_UINT8, BASE_HEX, VALS(&ranap_presence_values), 0x0, - ""} + "", HFILL } }, { &hf_ranap_nas_pdu_length, { "length of NAS-PDU", "ranap.nas_pdu_length", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } } }; diff --git a/packet-ripng.c b/packet-ripng.c index 2c6fe6221b..763bb82e47 100644 --- a/packet-ripng.c +++ b/packet-ripng.c @@ -3,7 +3,7 @@ * (c) Copyright Jun-ichiro itojun Hagino <itojun@itojun.org> * derived from packet-rip.c * - * $Id: packet-ripng.c,v 1.20 2001/04/24 02:50:00 guy Exp $ + * $Id: packet-ripng.c,v 1.21 2001/06/18 02:17:51 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -139,11 +139,11 @@ proto_register_ripng(void) { &hf_ripng_cmd, { "Command", "ripng.cmd", FT_UINT8, BASE_DEC, VALS(cmdvals), - 0x0, "" }}, + 0x0, "", HFILL }}, { &hf_ripng_version, { "Version", "ripng.version", FT_UINT8, BASE_DEC, NULL, - 0x0, "" }}, + 0x0, "", HFILL }}, }; static gint *ett[] = { &ett_ripng, diff --git a/packet-rlogin.c b/packet-rlogin.c index 43b93591d2..e523eec16b 100644 --- a/packet-rlogin.c +++ b/packet-rlogin.c @@ -2,7 +2,7 @@ * Routines for unix rlogin packet dissection * Copyright 2000, Jeffrey C. Foster <jfoste@woodward.com> * - * $Id: packet-rlogin.c,v 1.15 2001/06/08 08:38:52 guy Exp $ + * $Id: packet-rlogin.c,v 1.16 2001/06/18 02:17:51 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -444,32 +444,32 @@ proto_register_rlogin( void){ { &hf_user_info, { "User Info", "rlogin.user_info", FT_NONE, BASE_NONE, - NULL, 0x0, "" + NULL, 0x0, "", HFILL } }, { &hf_window_info, { "Window Info", "rlogin.window_size", FT_NONE, BASE_NONE, - NULL, 0x0, "" + NULL, 0x0, "", HFILL } }, { &hf_window_info_rows, { "Rows", "rlogin.window_size.rows", FT_UINT16, BASE_DEC, - NULL, 0x0, "" + NULL, 0x0, "", HFILL } }, { &hf_window_info_cols, { "Columns", "rlogin.window_size.cols", FT_UINT16, BASE_DEC, - NULL, 0x0, "" + NULL, 0x0, "", HFILL } }, { &hf_window_info_x_pixels, { "X Pixels", "rlogin.window_size.x_pixels", FT_UINT16, BASE_DEC, - NULL, 0x0, "" + NULL, 0x0, "", HFILL } }, { &hf_window_info_y_pixels, { "Y Pixels", "rlogin.window_size.y_pixels", FT_UINT16, BASE_DEC, - NULL, 0x0, "" + NULL, 0x0, "", HFILL } } }; diff --git a/packet-rpc.c b/packet-rpc.c index 6c75d5ad2d..c6379b5d5a 100644 --- a/packet-rpc.c +++ b/packet-rpc.c @@ -2,7 +2,7 @@ * Routines for rpc dissection * Copyright 1999, Uwe Girlich <Uwe.Girlich@philosys.de> * - * $Id: packet-rpc.c,v 1.61 2001/05/30 06:01:02 guy Exp $ + * $Id: packet-rpc.c,v 1.62 2001/06/18 02:17:51 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -1923,145 +1923,145 @@ proto_register_rpc(void) static hf_register_info hf[] = { { &hf_rpc_lastfrag, { "Last Fragment", "rpc.lastfrag", FT_BOOLEAN, BASE_NONE, - &yesno, 0, "Last Fragment" }}, + &yesno, 0, "Last Fragment", HFILL }}, { &hf_rpc_fraglen, { "Fragment Length", "rpc.fraglen", FT_UINT32, BASE_DEC, - NULL, 0, "Fragment Length" }}, + NULL, 0, "Fragment Length", HFILL }}, { &hf_rpc_xid, { "XID", "rpc.xid", FT_UINT32, BASE_HEX, - NULL, 0, "XID" }}, + NULL, 0, "XID", HFILL }}, { &hf_rpc_msgtype, { "Message Type", "rpc.msgtyp", FT_UINT32, BASE_DEC, - VALS(rpc_msg_type), 0, "Message Type" }}, + VALS(rpc_msg_type), 0, "Message Type", HFILL }}, { &hf_rpc_state_reply, { "Reply State", "rpc.replystat", FT_UINT32, BASE_DEC, - VALS(rpc_reply_state), 0, "Reply State" }}, + VALS(rpc_reply_state), 0, "Reply State", HFILL }}, { &hf_rpc_state_accept, { "Accept State", "rpc.state_accept", FT_UINT32, BASE_DEC, - VALS(rpc_accept_state), 0, "Accept State" }}, + VALS(rpc_accept_state), 0, "Accept State", HFILL }}, { &hf_rpc_state_reject, { "Reject State", "rpc.state_reject", FT_UINT32, BASE_DEC, - VALS(rpc_reject_state), 0, "Reject State" }}, + VALS(rpc_reject_state), 0, "Reject State", HFILL }}, { &hf_rpc_state_auth, { "Auth State", "rpc.state_auth", FT_UINT32, BASE_DEC, - VALS(rpc_auth_state), 0, "Auth State" }}, + VALS(rpc_auth_state), 0, "Auth State", HFILL }}, { &hf_rpc_version, { "RPC Version", "rpc.version", FT_UINT32, BASE_DEC, - NULL, 0, "RPC Version" }}, + NULL, 0, "RPC Version", HFILL }}, { &hf_rpc_version_min, { "RPC Version (Minimum)", "rpc.version.min", FT_UINT32, - BASE_DEC, NULL, 0, "Program Version (Minimum)" }}, + BASE_DEC, NULL, 0, "Program Version (Minimum)", HFILL }}, { &hf_rpc_version_max, { "RPC Version (Maximum)", "rpc.version.max", FT_UINT32, - BASE_DEC, NULL, 0, "RPC Version (Maximum)" }}, + BASE_DEC, NULL, 0, "RPC Version (Maximum)", HFILL }}, { &hf_rpc_program, { "Program", "rpc.program", FT_UINT32, BASE_DEC, - NULL, 0, "Program" }}, + NULL, 0, "Program", HFILL }}, { &hf_rpc_programversion, { "Program Version", "rpc.programversion", FT_UINT32, - BASE_DEC, NULL, 0, "Program Version" }}, + BASE_DEC, NULL, 0, "Program Version", HFILL }}, { &hf_rpc_programversion_min, { "Program Version (Minimum)", "rpc.programversion.min", FT_UINT32, - BASE_DEC, NULL, 0, "Program Version (Minimum)" }}, + BASE_DEC, NULL, 0, "Program Version (Minimum)", HFILL }}, { &hf_rpc_programversion_max, { "Program Version (Maximum)", "rpc.programversion.max", FT_UINT32, - BASE_DEC, NULL, 0, "Program Version (Maximum)" }}, + BASE_DEC, NULL, 0, "Program Version (Maximum)", HFILL }}, { &hf_rpc_procedure, { "Procedure", "rpc.procedure", FT_UINT32, BASE_DEC, - NULL, 0, "Procedure" }}, + NULL, 0, "Procedure", HFILL }}, { &hf_rpc_auth_flavor, { "Flavor", "rpc.auth.flavor", FT_UINT32, BASE_DEC, - VALS(rpc_auth_flavor), 0, "Flavor" }}, + VALS(rpc_auth_flavor), 0, "Flavor", HFILL }}, { &hf_rpc_auth_length, { "Length", "rpc.auth.length", FT_UINT32, BASE_DEC, - NULL, 0, "Length" }}, + NULL, 0, "Length", HFILL }}, { &hf_rpc_auth_stamp, { "Stamp", "rpc.auth.stamp", FT_UINT32, BASE_HEX, - NULL, 0, "Stamp" }}, + NULL, 0, "Stamp", HFILL }}, { &hf_rpc_auth_uid, { "UID", "rpc.auth.uid", FT_UINT32, BASE_DEC, - NULL, 0, "UID" }}, + NULL, 0, "UID", HFILL }}, { &hf_rpc_auth_gid, { "GID", "rpc.auth.gid", FT_UINT32, BASE_DEC, - NULL, 0, "GID" }}, + NULL, 0, "GID", HFILL }}, { &hf_rpc_authgss_v, { "GSS Version", "rpc.authgss.version", FT_UINT32, - BASE_DEC, NULL, 0, "GSS Version" }}, + BASE_DEC, NULL, 0, "GSS Version", HFILL }}, { &hf_rpc_authgss_proc, { "GSS Procedure", "rpc.authgss.procedure", FT_UINT32, - BASE_DEC, VALS(rpc_authgss_proc), 0, "GSS Procedure" }}, + BASE_DEC, VALS(rpc_authgss_proc), 0, "GSS Procedure", HFILL }}, { &hf_rpc_authgss_seq, { "GSS Sequence Number", "rpc.authgss.seqnum", FT_UINT32, - BASE_DEC, NULL, 0, "GSS Sequence Number" }}, + BASE_DEC, NULL, 0, "GSS Sequence Number", HFILL }}, { &hf_rpc_authgss_svc, { "GSS Service", "rpc.authgss.service", FT_UINT32, - BASE_DEC, VALS(rpc_authgss_svc), 0, "GSS Service" }}, + BASE_DEC, VALS(rpc_authgss_svc), 0, "GSS Service", HFILL }}, { &hf_rpc_authgss_ctx, { "GSS Context", "rpc.authgss.context", FT_BYTES, - BASE_HEX, NULL, 0, "GSS Context" }}, + BASE_HEX, NULL, 0, "GSS Context", HFILL }}, { &hf_rpc_authgss_major, { "GSS Major Status", "rpc.authgss.major", FT_UINT32, - BASE_DEC, NULL, 0, "GSS Major Status" }}, + BASE_DEC, NULL, 0, "GSS Major Status", HFILL }}, { &hf_rpc_authgss_minor, { "GSS Minor Status", "rpc.authgss.minor", FT_UINT32, - BASE_DEC, NULL, 0, "GSS Minor Status" }}, + BASE_DEC, NULL, 0, "GSS Minor Status", HFILL }}, { &hf_rpc_authgss_window, { "GSS Sequence Window", "rpc.authgss.window", FT_UINT32, - BASE_DEC, NULL, 0, "GSS Sequence Window" }}, + BASE_DEC, NULL, 0, "GSS Sequence Window", HFILL }}, { &hf_rpc_authgss_token, { "GSS Token", "rpc.authgss.token", FT_BYTES, - BASE_HEX, NULL, 0, "GSS Token" }}, + BASE_HEX, NULL, 0, "GSS Token", HFILL }}, { &hf_rpc_authgss_data_length, { "Length", "rpc.authgss.data.length", FT_UINT32, - BASE_DEC, NULL, 0, "Length" }}, + BASE_DEC, NULL, 0, "Length", HFILL }}, { &hf_rpc_authgss_data, { "GSS Data", "rpc.authgss.data", FT_BYTES, - BASE_HEX, NULL, 0, "GSS Data" }}, + BASE_HEX, NULL, 0, "GSS Data", HFILL }}, { &hf_rpc_authgss_checksum, { "GSS Checksum", "rpc.authgss.checksum", FT_BYTES, - BASE_HEX, NULL, 0, "GSS Checksum" }}, + BASE_HEX, NULL, 0, "GSS Checksum", HFILL }}, { &hf_rpc_authdes_namekind, { "Namekind", "rpc.authdes.namekind", FT_UINT32, BASE_DEC, - VALS(rpc_authdes_namekind), 0, "Namekind" }}, + VALS(rpc_authdes_namekind), 0, "Namekind", HFILL }}, { &hf_rpc_authdes_netname, { "Netname", "rpc.authdes.netname", FT_STRING, - BASE_DEC, NULL, 0, "Netname" }}, + BASE_DEC, NULL, 0, "Netname", HFILL }}, { &hf_rpc_authdes_convkey, { "Conversation Key (encrypted)", "rpc.authdes.convkey", FT_UINT32, - BASE_HEX, NULL, 0, "Conversation Key (encrypted)" }}, + BASE_HEX, NULL, 0, "Conversation Key (encrypted)", HFILL }}, { &hf_rpc_authdes_window, { "Window (encrypted)", "rpc.authdes.window", FT_UINT32, - BASE_HEX, NULL, 0, "Windows (encrypted)" }}, + BASE_HEX, NULL, 0, "Windows (encrypted)", HFILL }}, { &hf_rpc_authdes_nickname, { "Nickname", "rpc.authdes.nickname", FT_UINT32, - BASE_HEX, NULL, 0, "Nickname" }}, + BASE_HEX, NULL, 0, "Nickname", HFILL }}, { &hf_rpc_authdes_timestamp, { "Timestamp (encrypted)", "rpc.authdes.timestamp", FT_UINT32, - BASE_HEX, NULL, 0, "Timestamp (encrypted)" }}, + BASE_HEX, NULL, 0, "Timestamp (encrypted)", HFILL }}, { &hf_rpc_authdes_windowverf, { "Window verifier (encrypted)", "rpc.authdes.windowverf", FT_UINT32, - BASE_HEX, NULL, 0, "Window verifier (encrypted)" }}, + BASE_HEX, NULL, 0, "Window verifier (encrypted)", HFILL }}, { &hf_rpc_authdes_timeverf, { "Timestamp verifier (encrypted)", "rpc.authdes.timeverf", FT_UINT32, - BASE_HEX, NULL, 0, "Timestamp verifier (encrypted)" }}, + BASE_HEX, NULL, 0, "Timestamp verifier (encrypted)", HFILL }}, { &hf_rpc_auth_machinename, { "Machine Name", "rpc.auth.machinename", FT_STRING, - BASE_DEC, NULL, 0, "Machine Name" }}, + BASE_DEC, NULL, 0, "Machine Name", HFILL }}, { &hf_rpc_dup, { "Duplicate Transaction", "rpc.dup", FT_UINT32, BASE_DEC, - NULL, 0, "Duplicate Transaction" }}, + NULL, 0, "Duplicate Transaction", HFILL }}, { &hf_rpc_call_dup, { "Duplicate Call", "rpc.call.dup", FT_UINT32, BASE_DEC, - NULL, 0, "Duplicate Call" }}, + NULL, 0, "Duplicate Call", HFILL }}, { &hf_rpc_reply_dup, { "Duplicate Reply", "rpc.reply.dup", FT_UINT32, BASE_DEC, - NULL, 0, "Duplicate Reply" }}, + NULL, 0, "Duplicate Reply", HFILL }}, { &hf_rpc_value_follows, { "Value Follows", "rpc.value_follows", FT_BOOLEAN, BASE_NONE, - &yesno, 0, "Value Follows" }}, + &yesno, 0, "Value Follows", HFILL }}, { &hf_rpc_array_len, { "num", "rpc.array.len", FT_UINT32, BASE_DEC, - NULL, 0, "Length of RPC array" }}, + NULL, 0, "Length of RPC array", HFILL }}, }; static gint *ett[] = { &ett_rpc, diff --git a/packet-rquota.c b/packet-rquota.c index fd2430e3b0..8b32befad3 100644 --- a/packet-rquota.c +++ b/packet-rquota.c @@ -2,7 +2,7 @@ * Routines for rquota dissection * Copyright 2001, Mike Frisch <frisch@hummingbird.com> * - * $Id: packet-rquota.c,v 1.3 2001/05/30 06:01:02 guy Exp $ + * $Id: packet-rquota.c,v 1.4 2001/06/18 02:17:51 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -164,59 +164,59 @@ proto_register_rquota(void) static hf_register_info hf[] = { { &hf_rquota_uid, { "uid", "rquota.uid", FT_UINT32, BASE_DEC, - NULL, 0, "User ID" }}, + NULL, 0, "User ID", HFILL }}, { &hf_rquota_pathp, { "pathp", "rquota.pathp", FT_STRING, BASE_DEC, - NULL, 0, "Filesystem of interest" }}, + NULL, 0, "Filesystem of interest", HFILL }}, { &hf_rquota_status, { "status", "rquota.status", FT_UINT32, BASE_DEC, - VALS(names_rquota_status), 0, "Status code" }}, + VALS(names_rquota_status), 0, "Status code", HFILL }}, { &hf_rquota_rquota, { "rquota", "rquota.rquota", FT_NONE, BASE_NONE, - NULL, 0, "Rquota structure" }}, + NULL, 0, "Rquota structure", HFILL }}, { &hf_rquota_bsize, { "bsize", "rquota.bsize", FT_UINT32, BASE_DEC, - NULL, 0, "Block size" }}, + NULL, 0, "Block size", HFILL }}, { &hf_rquota_active, { "active", "rquota.active", FT_BOOLEAN, BASE_NONE, - &tfs_active, 0, "Indicates whether quota is active" }}, + &tfs_active, 0, "Indicates whether quota is active", HFILL }}, { &hf_rquota_bhardlimit, { "bhardlimit", "rquota.bhardlimit", FT_UINT32, BASE_DEC, - NULL, 0, "Hard limit for blocks" }}, + NULL, 0, "Hard limit for blocks", HFILL }}, { &hf_rquota_bsoftlimit, { "bsoftlimit", "rquota.bsoftlimit", FT_UINT32, BASE_DEC, - NULL, 0, "Soft limit for blocks" }}, + NULL, 0, "Soft limit for blocks", HFILL }}, { &hf_rquota_curblocks, { "curblocks", "rquota.curblocks", FT_UINT32, BASE_DEC, - NULL, 0, "Current block count" }}, + NULL, 0, "Current block count", HFILL }}, { &hf_rquota_fhardlimit, { "fhardlimit", "rquota.fhardlimit", FT_UINT32, BASE_DEC, - NULL, 0, "Hard limit on allocated files" }}, + NULL, 0, "Hard limit on allocated files", HFILL }}, { &hf_rquota_fsoftlimit, { "fsoftlimit", "rquota.fsoftlimit", FT_UINT32, BASE_DEC, - NULL, 0, "Soft limit of allocated files" }}, + NULL, 0, "Soft limit of allocated files", HFILL }}, { &hf_rquota_curfiles, { "curfiles", "rquota.curfiles", FT_UINT32, BASE_DEC, - NULL, 0, "Current # allocated files" }}, + NULL, 0, "Current # allocated files", HFILL }}, { &hf_rquota_btimeleft, { "btimeleft", "rquota.btimeleft", FT_UINT32, BASE_DEC, - NULL, 0, "Time left for excessive disk use" }}, + NULL, 0, "Time left for excessive disk use", HFILL }}, { &hf_rquota_ftimeleft, { "ftimeleft", "rquota.ftimeleft", FT_UINT32, BASE_DEC, - NULL, 0, "Time left for excessive files" }}, + NULL, 0, "Time left for excessive files", HFILL }}, }; diff --git a/packet-rsh.c b/packet-rsh.c index 2a549fdf8f..dd5a375745 100644 --- a/packet-rsh.c +++ b/packet-rsh.c @@ -4,7 +4,7 @@ * Robert Tsai <rtsai@netapp.com> * Liberally copied from packet-http.c, by Guy Harris <guy@alum.mit.edu> * - * $Id: packet-rsh.c,v 1.10 2001/01/22 08:03:46 guy Exp $ + * $Id: packet-rsh.c,v 1.11 2001/06/18 02:17:51 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -113,11 +113,11 @@ proto_register_rsh(void) { &hf_rsh_response, { "Response", "rsh.response", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "TRUE if rsh response" }}, + "TRUE if rsh response", HFILL }}, { &hf_rsh_request, { "Request", "rsh.request", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "TRUE if rsh request" }}, + "TRUE if rsh request", HFILL }}, }; static gint *ett[] = { diff --git a/packet-rsvp.c b/packet-rsvp.c index faaf140f3a..b7ce1184bb 100644 --- a/packet-rsvp.c +++ b/packet-rsvp.c @@ -3,7 +3,7 @@ * * (c) Copyright Ashok Narayanan <ashokn@cisco.com> * - * $Id: packet-rsvp.c,v 1.43 2001/06/14 18:26:04 ashokn Exp $ + * $Id: packet-rsvp.c,v 1.44 2001/06/18 02:17:51 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -423,172 +423,172 @@ static hf_register_info rsvpf_info[] = { /* Message type number */ {&rsvp_filter[RSVPF_MSG], { "Message Type", "rsvp.msg", FT_UINT8, BASE_DEC, VALS(message_type_vals), 0x0, - "" }}, + "", HFILL }}, /* Message type shorthands */ {&rsvp_filter[RSVPF_PATH], { "Path Message", "rsvp.path", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_RESV], { "Resv Message", "rsvp.resv", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_PATHERR], { "Path Error Message", "rsvp.perr", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_RESVERR], { "Resv Error Message", "rsvp.rerr", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_PATHTEAR], { "Path Tear Message", "rsvp.ptear", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_RESVTEAR], { "Resv Tear Message", "rsvp.rtear", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_RCONFIRM], { "Resv Confirm Message", "rsvp.resvconf", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_RTEARCONFIRM], { "Resv Tear Confirm Message", "rsvp.rtearconf", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, /* Object class */ {&rsvp_filter[RSVPF_OBJECT], { "Object class", "rsvp.object", FT_UINT8, BASE_DEC, VALS(rsvp_class_vals), 0x0, - "" }}, + "", HFILL }}, /* Object present shorthands */ {&rsvp_filter[RSVPF_SESSION], { "SESSION", "rsvp.session", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_HOP], { "HOP", "rsvp.hop", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_INTEGRITY], { "INTEGRITY", "rsvp.integrity", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_TIME_VALUES], { "TIME VALUES", "rsvp.time", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_ERROR], { "ERROR", "rsvp.error", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_SCOPE], { "SCOPE", "rsvp.scope", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_STYLE], { "STYLE", "rsvp.style", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_FLOWSPEC], { "FLOWSPEC", "rsvp.flowspec", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_FILTER_SPEC], { "FILTERSPEC", "rsvp.filter", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_SENDER], { "SENDER TEMPLATE", "rsvp.sender", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_TSPEC], { "SENDER TSPEC", "rsvp.tspec", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_ADSPEC], { "ADSPEC", "rsvp.adspec", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_POLICY], { "POLICY", "rsvp.policy", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_CONFIRM], { "CONFIRM", "rsvp.confirm", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_LABEL], { "LABEL", "rsvp.label", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_LABEL_REQUEST], { "LABEL REQUEST", "rsvp.label_request", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_SESSION_ATTRIBUTE], { "SESSION ATTRIBUTE", "rsvp.session_attribute", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_EXPLICIT_ROUTE], { "EXPLICIT ROUTE", "rsvp.explicit_route", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_RECORD_ROUTE], { "RECORD ROUTE", "rsvp.record_route", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_MESSAGE_ID], { "MESSAGE-ID", "rsvp.msgid", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_MESSAGE_ID_ACK], { "MESSAGE-ID ACK", "rsvp.ack", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_MESSAGE_ID_LIST], { "MESSAGE-ID LIST", "rsvp.msgid_list", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_UNKNOWN_OBJ], { "Unknown object", "rsvp.obj_unknown", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, /* Session fields */ {&rsvp_filter[RSVPF_SESSION_IP], { "Destination address", "rsvp.session.ip", FT_IPv4, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_SESSION_PORT], { "Port number", "rsvp.session.port", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_SESSION_PROTO], { "Protocol", "rsvp.session.proto", FT_UINT8, BASE_DEC, VALS(proto_vals), 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_SESSION_TUNNEL_ID], { "Tunnel ID", "rsvp.session.tunnel_id", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_SESSION_EXT_TUNNEL_ID], { "Extended tunnel ID", "rsvp.session.ext_tunnel_id", FT_UINT32, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, /* Sender template/Filterspec fields */ {&rsvp_filter[RSVPF_SENDER_IP], { "Sender IPv4 address", "rsvp.sender.ip", FT_IPv4, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_SENDER_PORT], { "Sender port number", "rsvp.sender.port", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, {&rsvp_filter[RSVPF_SENDER_LSP_ID], { "Sender LSP ID", "rsvp.sender.lsp_id", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }} + "", HFILL }} }; static inline int rsvp_class_to_filter_num(int classnum) diff --git a/packet-rtcp.c b/packet-rtcp.c index 7e170f331c..c708dfdaed 100644 --- a/packet-rtcp.c +++ b/packet-rtcp.c @@ -1,6 +1,6 @@ /* packet-rtcp.c * - * $Id: packet-rtcp.c,v 1.15 2001/06/12 06:31:14 guy Exp $ + * $Id: packet-rtcp.c,v 1.16 2001/06/18 02:17:51 guy Exp $ * * Routines for RTCP dissection * RTCP = Real-time Transport Control Protocol @@ -808,7 +808,7 @@ proto_register_rtcp(void) BASE_DEC, VALS(rtcp_version_vals), 0x0, - "" + "", HFILL } }, { @@ -820,7 +820,7 @@ proto_register_rtcp(void) BASE_NONE, NULL, 0x0, - "" + "", HFILL } }, { @@ -832,7 +832,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -844,7 +844,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -856,7 +856,7 @@ proto_register_rtcp(void) BASE_DEC, VALS( rtcp_packet_type_vals ), 0x0, - "" + "", HFILL } }, { @@ -868,7 +868,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -880,7 +880,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -892,7 +892,7 @@ proto_register_rtcp(void) BASE_NONE, NULL, 0x0, - "" + "", HFILL } }, { @@ -904,7 +904,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -916,7 +916,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -928,7 +928,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -940,7 +940,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -952,7 +952,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -964,7 +964,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -976,7 +976,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -988,7 +988,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -1000,7 +1000,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -1012,7 +1012,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -1024,7 +1024,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -1036,7 +1036,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -1048,7 +1048,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -1060,7 +1060,7 @@ proto_register_rtcp(void) BASE_DEC, VALS( rtcp_sdes_type_vals ), 0x0, - "" + "", HFILL } }, { @@ -1072,7 +1072,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -1084,7 +1084,7 @@ proto_register_rtcp(void) BASE_NONE, NULL, 0x0, - "" + "", HFILL } }, { @@ -1096,7 +1096,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -1108,7 +1108,7 @@ proto_register_rtcp(void) BASE_NONE, NULL, 0x0, - "" + "", HFILL } }, { @@ -1120,7 +1120,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -1132,7 +1132,7 @@ proto_register_rtcp(void) BASE_NONE, NULL, 0x0, - "" + "", HFILL } }, { @@ -1144,7 +1144,7 @@ proto_register_rtcp(void) BASE_NONE, NULL, 0x0, - "" + "", HFILL } }, { @@ -1156,7 +1156,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -1168,7 +1168,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -1180,7 +1180,7 @@ proto_register_rtcp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -1192,7 +1192,7 @@ proto_register_rtcp(void) BASE_NONE, NULL, 0x0, - "" + "", HFILL } }, }; diff --git a/packet-rtp.c b/packet-rtp.c index daa4d60bb2..cf1abac6b7 100644 --- a/packet-rtp.c +++ b/packet-rtp.c @@ -6,7 +6,7 @@ * Copyright 2000, Philips Electronics N.V. * Written by Andreas Sikkema <andreas.sikkema@philips.com> * - * $Id: packet-rtp.c,v 1.20 2001/06/15 00:42:39 guy Exp $ + * $Id: packet-rtp.c,v 1.21 2001/06/18 02:17:51 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -563,7 +563,7 @@ proto_register_rtp(void) BASE_DEC, VALS(rtp_version_vals), 0x0, - "" + "", HFILL } }, { @@ -575,7 +575,7 @@ proto_register_rtp(void) BASE_NONE, NULL, 0x0, - "" + "", HFILL } }, { @@ -587,7 +587,7 @@ proto_register_rtp(void) BASE_NONE, NULL, 0x0, - "" + "", HFILL } }, { @@ -599,7 +599,7 @@ proto_register_rtp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -611,7 +611,7 @@ proto_register_rtp(void) BASE_NONE, NULL, 0x0, - "" + "", HFILL } }, { @@ -623,7 +623,7 @@ proto_register_rtp(void) BASE_DEC, VALS(rtp_payload_type_vals), 0x0, - "" + "", HFILL } }, { @@ -635,7 +635,7 @@ proto_register_rtp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -647,7 +647,7 @@ proto_register_rtp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -659,7 +659,7 @@ proto_register_rtp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -671,7 +671,7 @@ proto_register_rtp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -683,7 +683,7 @@ proto_register_rtp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -695,7 +695,7 @@ proto_register_rtp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -707,7 +707,7 @@ proto_register_rtp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -719,7 +719,7 @@ proto_register_rtp(void) BASE_HEX, NULL, 0x0, - "" + "", HFILL } }, { @@ -731,7 +731,7 @@ proto_register_rtp(void) BASE_HEX, NULL, 0x0, - "" + "", HFILL } }, { @@ -743,7 +743,7 @@ proto_register_rtp(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, }; diff --git a/packet-rtsp.c b/packet-rtsp.c index cb0e7612d9..439156ef40 100644 --- a/packet-rtsp.c +++ b/packet-rtsp.c @@ -4,7 +4,7 @@ * Jason Lango <jal@netapp.com> * Liberally copied from packet-http.c, by Guy Harris <guy@alum.mit.edu> * - * $Id: packet-rtsp.c,v 1.37 2001/05/31 20:40:29 guy Exp $ + * $Id: packet-rtsp.c,v 1.38 2001/06/18 02:17:51 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -698,11 +698,11 @@ proto_register_rtsp(void) }; static hf_register_info hf[] = { { &hf_rtsp_method, - { "Method", "rtsp.method", FT_STRING, BASE_NONE, NULL, 0 }}, + { "Method", "rtsp.method", FT_STRING, BASE_NONE, NULL, 0, "", HFILL }}, { &hf_rtsp_url, - { "URL", "rtsp.url", FT_STRING, BASE_NONE, NULL, 0 }}, + { "URL", "rtsp.url", FT_STRING, BASE_NONE, NULL, 0, "", HFILL }}, { &hf_rtsp_status, - { "Status", "rtsp.status", FT_UINT32, BASE_DEC, NULL, 0 }}, + { "Status", "rtsp.status", FT_UINT32, BASE_DEC, NULL, 0, "", HFILL }}, }; proto_rtsp = proto_register_protocol("Real Time Streaming Protocol", diff --git a/packet-rwall.c b/packet-rwall.c index 6d1ce42ab5..dbe2c1d83f 100644 --- a/packet-rwall.c +++ b/packet-rwall.c @@ -1,6 +1,6 @@ /* packet-rwall.c * - * $Id: packet-rwall.c,v 1.3 2001/06/12 06:31:14 guy Exp $ + * $Id: packet-rwall.c,v 1.4 2001/06/18 02:17:52 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -60,7 +60,7 @@ proto_register_rwall(void) static hf_register_info hf[] = { { &hf_rwall_message, { "Message", "rwall.message", FT_STRING, BASE_DEC, - NULL, 0, "Message" }}, + NULL, 0, "Message", HFILL }}, }; static gint *ett[] = { diff --git a/packet-rx.c b/packet-rx.c index bd919a7205..a0dbd51e9d 100644 --- a/packet-rx.c +++ b/packet-rx.c @@ -4,7 +4,7 @@ * Based on routines from tcpdump patches by * Ken Hornstein <kenh@cmf.nrl.navy.mil> * - * $Id: packet-rx.c,v 1.21 2001/05/27 05:00:17 guy Exp $ + * $Id: packet-rx.c,v 1.22 2001/06/18 02:17:52 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -531,143 +531,143 @@ proto_register_rx(void) static hf_register_info hf[] = { { &hf_rx_epoch, { "Epoch", "rx.epoch", FT_ABSOLUTE_TIME, BASE_DEC, - NULL, 0, "Epoch" }}, + NULL, 0, "Epoch", HFILL }}, { &hf_rx_cid, { "CID", "rx.cid", FT_UINT32, BASE_DEC, - NULL, 0, "CID" }}, + NULL, 0, "CID", HFILL }}, { &hf_rx_callnumber, { "Call Number", "rx.callnumber", FT_UINT32, BASE_DEC, - NULL, 0, "Call Number" }}, + NULL, 0, "Call Number", HFILL }}, { &hf_rx_seq, { "Sequence Number", "rx.seq", FT_UINT32, BASE_DEC, - NULL, 0, "Sequence Number" }}, + NULL, 0, "Sequence Number", HFILL }}, { &hf_rx_serial, { "Serial", "rx.serial", FT_UINT32, BASE_DEC, - NULL, 0, "Serial" }}, + NULL, 0, "Serial", HFILL }}, { &hf_rx_type, { "Type", "rx.type", FT_UINT8, BASE_DEC, - VALS(rx_types), 0, "Type" }}, + VALS(rx_types), 0, "Type", HFILL }}, { &hf_rx_flags, { "Flags", "rx.flags", FT_UINT8, BASE_HEX, - NULL, 0, "Flags" }}, + NULL, 0, "Flags", HFILL }}, { &hf_rx_flags_clientinit, { "Client Initiated", "rx.flags.client_init", FT_UINT8, BASE_BIN, - NULL, RX_CLIENT_INITIATED, "Client Initiated" }}, + NULL, RX_CLIENT_INITIATED, "Client Initiated", HFILL }}, { &hf_rx_flags_request_ack, { "Request Ack", "rx.flags.request_ack", FT_UINT8, BASE_BIN, - NULL, RX_REQUEST_ACK, "Request Ack" }}, + NULL, RX_REQUEST_ACK, "Request Ack", HFILL }}, { &hf_rx_flags_last_packet, { "Last Packet", "rx.flags.last_packet", FT_UINT8, BASE_BIN, - NULL, RX_LAST_PACKET, "Last Packet" }}, + NULL, RX_LAST_PACKET, "Last Packet", HFILL }}, { &hf_rx_flags_more_packets, { "More Packets", "rx.flags.more_packets", FT_UINT8, BASE_BIN, - NULL, RX_MORE_PACKETS, "More Packets" }}, + NULL, RX_MORE_PACKETS, "More Packets", HFILL }}, { &hf_rx_flags_free_packet, { "Free Packet", "rx.flags.free_packet", FT_UINT8, BASE_BIN, - NULL, RX_FREE_PACKET, "Free Packet" }}, + NULL, RX_FREE_PACKET, "Free Packet", HFILL }}, { &hf_rx_userstatus, { "User Status", "rx.userstatus", FT_UINT32, BASE_DEC, - NULL, 0, "User Status" }}, + NULL, 0, "User Status", HFILL }}, { &hf_rx_securityindex, { "Security Index", "rx.securityindex", FT_UINT32, BASE_DEC, - NULL, 0, "Security Index" }}, + NULL, 0, "Security Index", HFILL }}, { &hf_rx_spare, { "Spare/Checksum", "rx.spare", FT_UINT16, BASE_DEC, - NULL, 0, "Spare/Checksum" }}, + NULL, 0, "Spare/Checksum", HFILL }}, { &hf_rx_serviceid, { "Service ID", "rx.serviceid", FT_UINT16, BASE_DEC, - NULL, 0, "Service ID" }}, + NULL, 0, "Service ID", HFILL }}, { &hf_rx_bufferspace, { "Bufferspace", "rx.bufferspace", FT_UINT16, BASE_DEC, - NULL, 0, "Number Of Packets Available" }}, + NULL, 0, "Number Of Packets Available", HFILL }}, { &hf_rx_maxskew, { "Max Skew", "rx.maxskew", FT_UINT16, BASE_DEC, - NULL, 0, "Max Skew" }}, + NULL, 0, "Max Skew", HFILL }}, { &hf_rx_first_packet, { "First Packet", "rx.first", FT_UINT32, BASE_DEC, - NULL, 0, "First Packet" }}, + NULL, 0, "First Packet", HFILL }}, { &hf_rx_prev_packet, { "Prev Packet", "rx.prev", FT_UINT32, BASE_DEC, - NULL, 0, "Previous Packet" }}, + NULL, 0, "Previous Packet", HFILL }}, { &hf_rx_reason, { "Reason", "rx.reason", FT_UINT8, BASE_DEC, - VALS(rx_reason), 0, "Reason For This ACK" }}, + VALS(rx_reason), 0, "Reason For This ACK", HFILL }}, { &hf_rx_numacks, { "Num ACKs", "rx.num_acks", FT_UINT8, BASE_DEC, - NULL, 0, "Number Of ACKs" }}, + NULL, 0, "Number Of ACKs", HFILL }}, { &hf_rx_ack_type, { "ACK Type", "rx.ack_type", FT_UINT8, BASE_DEC, - VALS(rx_ack_type), 0, "Type Of ACKs" }}, + VALS(rx_ack_type), 0, "Type Of ACKs", HFILL }}, { &hf_rx_ack, { "ACK Packet", "rx.ack", FT_NONE, BASE_NONE, - NULL, 0, "ACK Packet" }}, + NULL, 0, "ACK Packet", HFILL }}, { &hf_rx_challenge, { "CHALLENGE Packet", "rx.challenge", FT_NONE, BASE_NONE, - NULL, 0, "CHALLENGE Packet" }}, + NULL, 0, "CHALLENGE Packet", HFILL }}, { &hf_rx_version, { "Version", "rx.version", FT_UINT32, BASE_DEC, - NULL, 0, "Version Of Challenge/Response" }}, + NULL, 0, "Version Of Challenge/Response", HFILL }}, { &hf_rx_nonce, { "Nonce", "rx.nonce", FT_UINT32, BASE_HEX, - NULL, 0, "Nonce" }}, + NULL, 0, "Nonce", HFILL }}, { &hf_rx_inc_nonce, { "Inc Nonce", "rx.inc_nonce", FT_UINT32, BASE_HEX, - NULL, 0, "Incremented Nonce" }}, + NULL, 0, "Incremented Nonce", HFILL }}, { &hf_rx_min_level, { "Min Level", "rx.min_level", FT_UINT32, BASE_DEC, - NULL, 0, "Min Level" }}, + NULL, 0, "Min Level", HFILL }}, { &hf_rx_level, { "Level", "rx.level", FT_UINT32, BASE_DEC, - NULL, 0, "Level" }}, + NULL, 0, "Level", HFILL }}, { &hf_rx_response, { "RESPONSE Packet", "rx.response", FT_NONE, BASE_NONE, - NULL, 0, "RESPONSE Packet" }}, + NULL, 0, "RESPONSE Packet", HFILL }}, { &hf_rx_encrypted, { "Encrypted", "rx.encrypted", FT_NONE, BASE_NONE, - NULL, 0, "Encrypted part of response packet" }}, + NULL, 0, "Encrypted part of response packet", HFILL }}, { &hf_rx_kvno, { "kvno", "rx.kvno", FT_UINT32, BASE_DEC, - NULL, 0, "kvno" }}, + NULL, 0, "kvno", HFILL }}, { &hf_rx_ticket_len, { "Ticket len", "rx.ticket_len", FT_UINT32, BASE_DEC, - NULL, 0, "Ticket Length" }}, + NULL, 0, "Ticket Length", HFILL }}, { &hf_rx_ticket, { "ticket", "rx.ticket", FT_BYTES, BASE_HEX, - NULL, 0, "Ticket" }}, + NULL, 0, "Ticket", HFILL }}, }; static gint *ett[] = { diff --git a/packet-sap.c b/packet-sap.c index 9a7f417c09..48f187c9cc 100644 --- a/packet-sap.c +++ b/packet-sap.c @@ -4,7 +4,7 @@ * * Heikki Vatiainen <hessu@cs.tut.fi> * - * $Id: packet-sap.c,v 1.22 2001/04/23 18:19:03 guy Exp $ + * $Id: packet-sap.c,v 1.23 2001/06/18 02:17:52 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -292,62 +292,62 @@ void proto_register_sap(void) { &hf_sap_flags, { "Flags", "sap.flags", FT_UINT8, BASE_HEX, NULL, 0x0, - "Bits in the beginning of the SAP header" }}, + "Bits in the beginning of the SAP header", HFILL }}, { &hf_sap_flags_v, { "Version Number", "sap.flags.v", FT_UINT8, BASE_DEC, VALS(mcast_sap_ver), MCAST_SAP_VERSION_MASK, - "3 bit version field in the SAP header" }}, + "3 bit version field in the SAP header", HFILL }}, { &hf_sap_flags_a, { "Address Type", "sap.flags.a", FT_BOOLEAN, 8, TFS(&mcast_sap_address_type), MCAST_SAP_BIT_A, - "Originating source address type" }}, + "Originating source address type", HFILL }}, { &hf_sap_flags_r, { "Reserved", "sap.flags.r", FT_BOOLEAN, 8, TFS(&flags_set_truth), MCAST_SAP_BIT_R, - "Reserved" }}, + "Reserved", HFILL }}, { &hf_sap_flags_t, { "Message Type", "sap.flags.t", FT_BOOLEAN, 8, TFS(&mcast_sap_message_type), MCAST_SAP_BIT_T, - "Announcement type" }}, + "Announcement type", HFILL }}, { &hf_sap_flags_e, { "Encryption Bit", "sap.flags.e", FT_BOOLEAN, 8, TFS(&mcast_sap_crypt_type), MCAST_SAP_BIT_E, - "Encryption" }}, + "Encryption", HFILL }}, { &hf_sap_flags_c, { "Compression Bit", "sap.flags.c", FT_BOOLEAN, 8, TFS(&mcast_sap_comp_type), MCAST_SAP_BIT_C, - "Compression" }}, + "Compression", HFILL }}, { &hf_auth_data, { "Authentication data", "sap.auth", FT_NONE, BASE_NONE, NULL, 0x0, - "Auth data" }}, + "Auth data", HFILL }}, { &hf_auth_flags, { "Authentication data flags", "sap.auth.flags", FT_UINT8, BASE_HEX, NULL, 0x0, - "Auth flags" }}, + "Auth flags", HFILL }}, { &hf_auth_flags_v, { "Version Number", "sap.auth.flags.v", FT_UINT8, BASE_DEC, VALS(&mcast_sap_auth_ver), MCAST_SAP_VERSION_MASK, - "Version" }}, + "Version", HFILL }}, { &hf_auth_flags_p, { "Padding Bit", "sap.auth.flags.p", FT_BOOLEAN, 8, TFS(&mcast_sap_auth_pad), MCAST_SAP_AUTH_BIT_P, - "Compression" }}, + "Compression", HFILL }}, { &hf_auth_flags_t, { "Authentication Type", "sap.auth.flags.t", FT_UINT8, BASE_DEC, VALS(&mcast_sap_auth_type), MCAST_SAP_AUTH_TYPE_MASK, - "Auth type" }} + "Auth type", HFILL }} }; static gint *ett[] = { &ett_sap, diff --git a/packet-sctp.c b/packet-sctp.c index 7ab680d69a..2a99e32142 100644 --- a/packet-sctp.c +++ b/packet-sctp.c @@ -2,7 +2,7 @@ * Routines for Stream Control Transmission Protocol dissection * Copyright 2000, Michael Tüxen <Michael.Tuexen@icn.siemens.de> * - * $Id: packet-sctp.c,v 1.16 2001/04/23 17:51:33 guy Exp $ + * $Id: packet-sctp.c,v 1.17 2001/06/18 02:17:52 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -1690,227 +1690,227 @@ proto_register_sctp(void) { &hf_sctp_source_port, { "Source port", "sctp.srcport", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sctp_destination_port, { "Destination port", "sctp.dstport", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sctp_verification_tag, { "Verification tag", "sctp.verfication_tag", FT_UINT32, BASE_HEX, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sctp_checksum, { "Adler-32 checksum", "sctp.checksum", FT_UINT32, BASE_HEX, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sctp_chunk_type, { "Identifier", "sctp.chunk_type", FT_UINT8, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sctp_chunk_flags, { "Flags", "sctp.chunk_flags", FT_UINT8, BASE_BIN, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sctp_chunk_length, { "Length", "sctp.chunk_length", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sctp_init_chunk_initiate_tag, { "Initiate tag", "sctp.init.chunk.initiate.tag", FT_UINT32, BASE_HEX, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sctp_init_chunk_adv_rec_window_credit, { "Advertised reciever window credit (a_rwnd)", "sctp.init.chunk.credit", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sctp_init_chunk_number_of_outbound_streams, { "Number of outbound streams", "sctp.init.chunk.nr.out.streams", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sctp_init_chunk_number_of_inbound_streams, { "Number of inbound streams", "sctp.init.chunk.nr.in.streams", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_init_chunk_initial_tsn, { "Initial TSN", "sctp.init.chunk.initial.tsn", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_cumulative_tsn_ack, { "Cumulative TSN Ack", "sctp.cumulative.tsn.ack", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_data_chunk_tsn, { "TSN", "sctp.tsn", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_data_chunk_stream_id, { "Stream Identifier", "sctp.stream_id", FT_UINT16, BASE_HEX, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_data_chunk_stream_seq_number, { "Stream sequence number", "sctp.stream_seq_number", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_data_chunk_payload_proto_id, { "Payload Protocol identifier", "sctp.payload_proto_id", FT_UINT32, BASE_HEX, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_data_chunk_e_bit, { "E-Bit", "sctp.data.e_bit", FT_BOOLEAN, 8, TFS(&sctp_data_chunk_e_bit_value), SCTP_DATA_CHUNK_E_BIT, - ""} + "", HFILL } }, {&hf_sctp_data_chunk_b_bit, { "B-Bit", "sctp.data.b_bit", FT_BOOLEAN, 8, TFS(&sctp_data_chunk_b_bit_value), SCTP_DATA_CHUNK_B_BIT, - ""} + "", HFILL } }, {&hf_sctp_data_chunk_u_bit, { "U-Bit", "sctp.data.u.bit", FT_BOOLEAN, 8, TFS(&sctp_data_chunk_u_bit_value), SCTP_DATA_CHUNK_U_BIT, - ""} + "", HFILL } }, {&hf_sctp_sack_chunk_cumulative_tsn_ack, { "Cumulative TSN ACK", "sctp.sack.cumulative_tsn_ack", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_sack_chunk_adv_rec_window_credit, { "Advertised receiver window credit (a_rwnd)", "sctp.sack.a_rwnd", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_sack_chunk_number_of_gap_blocks, { "Number of gap acknowldgement blocks ", "sctp.sack.number_of_gap_blocks", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_sack_chunk_number_of_dup_tsns, { "Number of duplicated TSNs", "sctp.sack.number_of_duplicated_tsns", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_sack_chunk_gap_block_start, { "Start", "sctp.sack.gap_block_start", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_sack_chunk_gap_block_end, { "End", "sctp.sack.gap_block_end", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_sack_chunk_duplicate_tsn, { "Duplicate TSN", "sctp.sack.duplicate.tsn", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_shutdown_chunk_cumulative_tsn_ack, { "Cumulative TSN Ack", "sctp.shutdown.cumulative_tsn_ack", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_ecne_chunk_lowest_tsn, { "Lowest TSN", "sctp.ecne.lowest_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_cwr_chunk_lowest_tsn, { "Lowest TSN", "sctp.cwr.lowest_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_shutdown_complete_chunk_t_bit, { "E-Bit", "sctp.shutdown_complete.t_bit", FT_BOOLEAN, 8, TFS(&sctp_shutdown_complete_chunk_t_bit_value), SCTP_SHUTDOWN_COMPLETE_CHUNK_T_BIT, - ""} + "", HFILL } }, {&hf_sctp_chunk_parameter_type, { "Parameter type", "sctp.parameter.type", FT_UINT16, BASE_HEX, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_chunk_parameter_length, { "Parameter length", "sctp.parameter.length", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_parameter_ipv4_address, { "IP Version 4 address", "sctp.parameter.ipv4_address", FT_IPv4, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_parameter_ipv6_address, { "IP Version 6 address", "sctp.parameter.ipv6_address", FT_IPv6, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_parameter_cookie_preservative_increment, { "Suggested Cookie life-span increment (msec)", "sctp.parameter.cookie_preservative_incr", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_parameter_hostname_hostname, { "Hostname", "sctp.parameter.hostname.hostname", FT_STRING, BASE_NONE, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_supported_address_types_parameter, { "Supported address type", "sctp.parameter.supported_addres_type", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_cause_code, { "Cause code", "sctp.cause.code", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_cause_length, { "Cause length", "sctp.cause.length", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_cause_stream_identifier, { "Stream identifier", "sctp.cause.stream_identifier", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_cause_number_of_missing_parameters, { "Number of missing parameters", "sctp.cause.nr_of_missing_parameters", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_cause_missing_parameter_type, { "Missing parameters type", "sctp.cause.missing_parameter_type", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_cause_measure_of_staleness, { "Measure of staleness in usec", "sctp.cause.measure_of_staleness", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, {&hf_sctp_cause_tsn, { "TSN", "sctp.cause.tsn", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, }; diff --git a/packet-sip.c b/packet-sip.c index 93dcc6517c..f8edbf3f74 100644 --- a/packet-sip.c +++ b/packet-sip.c @@ -7,7 +7,7 @@ * * Copyright 2000, Heikki Vatiainen <hessu@cs.tut.fi> * - * $Id: packet-sip.c,v 1.14 2001/03/09 04:35:22 guy Exp $ + * $Id: packet-sip.c,v 1.15 2001/06/18 02:17:52 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -186,7 +186,7 @@ void proto_register_sip(void) { &hf_msg_hdr, { "Message Header", "sip.msg_hdr", FT_NONE, 0, NULL, 0, - "Message Header in SIP message" } + "Message Header in SIP message", HFILL } }, }; diff --git a/packet-sll.c b/packet-sll.c index 3a8d2df62d..559995ccac 100644 --- a/packet-sll.c +++ b/packet-sll.c @@ -1,7 +1,7 @@ /* packet-sll.c * Routines for disassembly of packets from Linux "cooked mode" captures * - * $Id: packet-sll.c,v 1.9 2001/04/17 06:43:19 guy Exp $ + * $Id: packet-sll.c,v 1.10 2001/06/18 02:17:52 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -231,40 +231,40 @@ proto_register_sll(void) static hf_register_info hf[] = { { &hf_sll_pkttype, { "Packet type", "sll.pkttype", FT_UINT16, BASE_DEC, - VALS(packet_type_vals), 0x0, "Packet type" }}, + VALS(packet_type_vals), 0x0, "Packet type", HFILL }}, /* ARP hardware type? With Linux extensions? */ { &hf_sll_hatype, { "Link-layer address type", "sll.hatype", FT_UINT16, BASE_DEC, - NULL, 0x0, "Link-layer address type" }}, + NULL, 0x0, "Link-layer address type", HFILL }}, { &hf_sll_halen, { "Link-layer address length", "sll.halen", FT_UINT16, BASE_DEC, - NULL, 0x0, "Link-layer address length" }}, + NULL, 0x0, "Link-layer address length", HFILL }}, /* Source address if it's an Ethernet-type address */ { &hf_sll_src_eth, { "Source", "sll.src.eth", FT_ETHER, BASE_NONE, NULL, 0x0, - "Source link-layer address" }}, + "Source link-layer address", HFILL }}, /* Source address if it's not an Ethernet-type address */ { &hf_sll_src_other, { "Source", "sll.src.other", FT_BYTES, BASE_HEX, NULL, 0x0, - "Source link-layer address" }}, + "Source link-layer address", HFILL }}, /* if the protocol field is an internal Linux protocol type */ { &hf_sll_ltype, { "Protocol", "sll.ltype", FT_UINT16, BASE_HEX, - VALS(ltype_vals), 0x0, "Linux protocol type" }}, + VALS(ltype_vals), 0x0, "Linux protocol type", HFILL }}, /* registered here but handled in ethertype.c */ { &hf_sll_etype, { "Protocol", "sll.etype", FT_UINT16, BASE_HEX, - VALS(etype_vals), 0x0, "Ethernet protocol type" }}, + VALS(etype_vals), 0x0, "Ethernet protocol type", HFILL }}, { &hf_sll_trailer, { "Trailer", "sll.trailer", FT_BYTES, BASE_NONE, NULL, 0x0, - "Trailer" }}, + "Trailer", HFILL }}, }; static gint *ett[] = { &ett_sll, diff --git a/packet-smb.c b/packet-smb.c index 4708daa3df..03710c0da6 100644 --- a/packet-smb.c +++ b/packet-smb.c @@ -2,7 +2,7 @@ * Routines for smb packet dissection * Copyright 1999, Richard Sharpe <rsharpe@ns.aus.com> * - * $Id: packet-smb.c,v 1.83 2001/06/05 23:40:34 guy Exp $ + * $Id: packet-smb.c,v 1.84 2001/06/18 02:17:52 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -10936,7 +10936,7 @@ proto_register_smb(void) static hf_register_info hf[] = { { &hf_smb_cmd, { "SMB Command", "smb.cmd", - FT_UINT8, BASE_HEX, VALS(smb_cmd_vals), 0x0, "" }} + FT_UINT8, BASE_HEX, VALS(smb_cmd_vals), 0x0, "", HFILL }} }; diff --git a/packet-smtp.c b/packet-smtp.c index 9ec1fdbb24..cd5740b8ef 100644 --- a/packet-smtp.c +++ b/packet-smtp.c @@ -1,7 +1,7 @@ /* packet-smtp.c * Routines for SMTP packet disassembly * - * $Id: packet-smtp.c,v 1.17 2001/04/23 04:29:53 guy Exp $ + * $Id: packet-smtp.c,v 1.18 2001/06/18 02:17:52 guy Exp $ * * Copyright (c) 2000 by Richard Sharpe <rsharpe@ns.aus.com> * @@ -552,10 +552,10 @@ proto_register_smtp(void) { static hf_register_info hf[] = { { &hf_smtp_req, - { "Request", "smtp.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0, ""}}, + { "Request", "smtp.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }}, { &hf_smtp_rsp, - { "Response", "smtp.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0, ""}}, + { "Response", "smtp.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }}, }; static gint *ett[] = { &ett_smtp diff --git a/packet-sna.c b/packet-sna.c index 3348e1a832..c8a2b6eda7 100644 --- a/packet-sna.c +++ b/packet-sna.c @@ -2,7 +2,7 @@ * Routines for SNA * Gilbert Ramirez <gram@xiexie.org> * - * $Id: packet-sna.c,v 1.29 2001/06/02 22:18:17 gram Exp $ + * $Id: packet-sna.c,v 1.30 2001/06/18 02:17:52 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -873,310 +873,310 @@ proto_register_sna(void) static hf_register_info hf[] = { { &hf_sna_th, { "Transmission Header", "sna.th", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_th_0, { "Transmission Header Byte 0", "sna.th.0", FT_UINT8, BASE_HEX, NULL, 0x0, "Byte 0 of Tranmission Header contains FID, MPF, ODAI," - " and EFI as bitfields." }}, + " and EFI as bitfields.", HFILL }}, { &hf_sna_th_fid, { "Format Identifer", "sna.th.fid", FT_UINT8, BASE_HEX, VALS(sna_th_fid_vals), 0xf0, - "Format Identification" }}, + "Format Identification", HFILL }}, { &hf_sna_th_mpf, { "Mapping Field", "sna.th.mpf", FT_UINT8, BASE_DEC, VALS(sna_th_mpf_vals), 0x0c, "The Mapping Field specifies whether the information field" - " associated with the TH is a complete or partial BIU." }}, + " associated with the TH is a complete or partial BIU.", HFILL }}, { &hf_sna_th_odai, { "ODAI Assignment Indicator", "sna.th.odai", FT_UINT8, BASE_DEC, NULL, 0x02, "The ODAI indicates which node assigned the OAF'-DAF' values" - " carried in the TH." }}, + " carried in the TH.", HFILL }}, { &hf_sna_th_efi, { "Expedited Flow Indicator", "sna.th.efi", FT_UINT8, BASE_DEC, VALS(sna_th_efi_vals), 0x01, "The EFI designates whether the PIU belongs to the normal" - " or expedited flow." }}, + " or expedited flow.", HFILL }}, { &hf_sna_th_daf, { "Destination Address Field", "sna.th.daf", FT_UINT16, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_th_oaf, { "Origin Address Field", "sna.th.oaf", FT_UINT16, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_th_snf, { "Sequence Number Field", "sna.th.snf", FT_UINT16, BASE_DEC, NULL, 0x0, "The Sequence Number Field contains a numerical identifier for" - " the associated BIU."}}, + " the associated BIU.", HFILL }}, { &hf_sna_th_dcf, { "Data Count Field", "sna.th.dcf", FT_UINT16, BASE_DEC, NULL, 0x0, "A binary count of the number of bytes in the BIU or BIU segment associated " "with the tranmission header. The count does not include any of the bytes " - "in the transmission header."}}, + "in the transmission header.", HFILL }}, { &hf_sna_th_lsid, { "Local Session Identification", "sna.th.lsid", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_th_tg_sweep, { "Transmission Group Sweep", "sna.th.tg_sweep", FT_UINT8, BASE_DEC, VALS(sna_th_tg_sweep_vals), 0x08, - "" }}, + "", HFILL }}, { &hf_sna_th_er_vr_supp_ind, { "ER and VR Support Indicator", "sna.th.er_vr_supp_ind", FT_UINT8, BASE_DEC, VALS(sna_th_er_vr_supp_ind_vals), 0x04, - "" }}, + "", HFILL }}, { &hf_sna_th_vr_pac_cnt_ind, { "Virtual Route Pacing Count Indicator", "sna.th.vr_pac_cnt_ind", FT_UINT8, BASE_DEC, VALS(sna_th_vr_pac_cnt_ind_vals), 0x02, - "" }}, + "", HFILL }}, { &hf_sna_th_ntwk_prty, { "Network Priority", "sna.th.ntwk_prty", FT_UINT8, BASE_DEC, VALS(sna_th_ntwk_prty_vals), 0x01, - "" }}, + "", HFILL }}, { &hf_sna_th_tgsf, { "Transmission Group Segmenting Field", "sna.th.tgsf", FT_UINT8, BASE_HEX, VALS(sna_th_tgsf_vals), 0xc0, - "" }}, + "", HFILL }}, { &hf_sna_th_mft, { "MPR FID4 Type", "sna.th.mft", FT_BOOLEAN, BASE_NONE, NULL, 0x04, - "" }}, + "", HFILL }}, { &hf_sna_th_piubf, { "PIU Blocking Field", "sna.th.piubf", FT_UINT8, BASE_HEX, VALS(sna_th_piubf_vals), 0x03, - "Specifies whether this frame contains a single PIU or multiple PIUs." }}, + "Specifies whether this frame contains a single PIU or multiple PIUs.", HFILL }}, { &hf_sna_th_iern, { "Initial Explicit Route Number", "sna.th.iern", FT_UINT8, BASE_DEC, NULL, 0xf0, - "" }}, + "", HFILL }}, { &hf_sna_th_nlpoi, { "NLP Offset Indicator", "sna.th.nlpoi", FT_UINT8, BASE_DEC, VALS(sna_th_nlpoi_vals), 0x80, - "" }}, + "", HFILL }}, { &hf_sna_th_nlp_cp, { "NLP Count or Padding", "sna.th.nlp_cp", FT_UINT8, BASE_DEC, NULL, 0x70, - "" }}, + "", HFILL }}, { &hf_sna_th_ern, { "Explicit Route Number", "sna.th.ern", FT_UINT8, BASE_DEC, NULL, 0x0f, - "The ERN in a TH identifies an explicit route direction of flow." }}, + "The ERN in a TH identifies an explicit route direction of flow.", HFILL }}, { &hf_sna_th_vrn, { "Virtual Route Number", "sna.th.vrn", FT_UINT8, BASE_DEC, NULL, 0xf0, - "" }}, + "", HFILL }}, { &hf_sna_th_tpf, { "Transmission Priority Field", "sna.th.tpf", FT_UINT8, BASE_HEX, VALS(sna_th_tpf_vals), 0x03, - "" }}, + "", HFILL }}, { &hf_sna_th_vr_cwi, { "Virtual Route Change Window Indicator", "sna.th.vr_cwi", FT_UINT16, BASE_DEC, VALS(sna_th_vr_cwi_vals), 0x8000, - "Used to change the window size of the virtual route by 1." }}, + "Used to change the window size of the virtual route by 1.", HFILL }}, { &hf_sna_th_tg_nonfifo_ind, { "Transmission Group Non-FIFO Indicator", "sna.th.tg_nonfifo_ind", FT_BOOLEAN, 16, TFS(&sna_th_tg_nonfifo_ind_truth), 0x4000, "Indicates whether or not FIFO discipline is to enforced in " "transmitting PIUs through the tranmission groups to prevent the PIUs " - "getting out of sequence during transmission over the TGs." }}, + "getting out of sequence during transmission over the TGs.", HFILL }}, { &hf_sna_th_vr_sqti, { "Virtual Route Sequence and Type Indicator", "sna.th.vr_sqti", FT_UINT16, BASE_HEX, VALS(sna_th_vr_sqti_vals), 0x3000, - "Specifies the PIU type." }}, + "Specifies the PIU type.", HFILL }}, { &hf_sna_th_tg_snf, { "Transmission Group Sequence Number Field", "sna.th.tg_snf", FT_UINT16, BASE_DEC, NULL, 0x0fff, - "" }}, + "", HFILL }}, { &hf_sna_th_vrprq, { "Virtual Route Pacing Request", "sna.th.vrprq", FT_BOOLEAN, 16, TFS(&sna_th_vrprq_truth), 0x8000, - "" }}, + "", HFILL }}, { &hf_sna_th_vrprs, { "Virtual Route Pacing Response", "sna.th.vrprs", FT_BOOLEAN, 16, TFS(&sna_th_vrprs_truth), 0x4000, - "" }}, + "", HFILL }}, { &hf_sna_th_vr_cwri, { "Virtual Route Change Window Reply Indicator", "sna.th.vr_cwri", FT_UINT16, BASE_DEC, VALS(sna_th_vr_cwri_vals), 0x2000, "Permits changing of the window size by 1 for PIUs received by the " - "sender of this bit." }}, + "sender of this bit.", HFILL }}, { &hf_sna_th_vr_rwi, { "Virtual Route Reset Window Indicator", "sna.th.vr_rwi", FT_BOOLEAN, 16, TFS(&sna_th_vr_rwi_truth), 0x1000, - "Indicates severe congestion in a node on the virtual route." }}, + "Indicates severe congestion in a node on the virtual route.", HFILL }}, { &hf_sna_th_vr_snf_send, { "Virtual Route Send Sequence Number Field", "sna.th.vr_snf_send", FT_UINT16, BASE_DEC, NULL, 0x0fff, - "" }}, + "", HFILL }}, { &hf_sna_th_dsaf, { "Destination Subarea Address Field", "sna.th.dsaf", FT_UINT32, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_th_osaf, { "Origin Subarea Address Field", "sna.th.osaf", FT_UINT32, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_th_snai, { "SNA Indicator", "sna.th.snai", FT_BOOLEAN, 8, NULL, 0x10, "Used to identify whether the PIU originated or is destined for " - "an SNA or non-SNA device." }}, + "an SNA or non-SNA device.", HFILL }}, { &hf_sna_th_def, { "Destination Element Field", "sna.th.def", FT_UINT16, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_th_oef, { "Origin Element Field", "sna.th.oef", FT_UINT16, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_th_sa, { "Session Address", "sna.th.sa", FT_BYTES, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_th_cmd_fmt, { "Command Format", "sna.th.cmd_fmt", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_th_cmd_type, { "Command Type", "sna.th.cmd_type", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_th_cmd_sn, { "Command Sequence Number", "sna.th.cmd_sn", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_rh, { "Request/Response Header", "sna.rh", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_rh_0, { "Request/Response Header Byte 0", "sna.rh.0", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_rh_1, { "Request/Response Header Byte 1", "sna.rh.1", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_rh_2, { "Request/Response Header Byte 2", "sna.rh.2", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_sna_rh_rri, { "Request/Response Indicator", "sna.rh.rri", FT_UINT8, BASE_DEC, VALS(sna_rh_rri_vals), 0x80, - "Denotes whether this is a request or a response." }}, + "Denotes whether this is a request or a response.", HFILL }}, { &hf_sna_rh_ru_category, { "Request/Response Unit Category", "sna.rh.ru_category", FT_UINT8, BASE_HEX, VALS(sna_rh_ru_category_vals), 0x60, - "" }}, + "", HFILL }}, { &hf_sna_rh_fi, { "Format Indicator", "sna.rh.fi", FT_BOOLEAN, 8, TFS(&sna_rh_fi_truth), 0x08, - "" }}, + "", HFILL }}, { &hf_sna_rh_sdi, { "Sense Data Included", "sna.rh.sdi", FT_BOOLEAN, 8, TFS(&sna_rh_sdi_truth), 0x04, - "Indicates that a 4-byte sense data field is included in the associated RU." }}, + "Indicates that a 4-byte sense data field is included in the associated RU.", HFILL }}, { &hf_sna_rh_bci, { "Begin Chain Indicator", "sna.rh.bci", FT_BOOLEAN, 8, TFS(&sna_rh_bci_truth), 0x02, - "" }}, + "", HFILL }}, { &hf_sna_rh_eci, { "End Chain Indicator", "sna.rh.eci", FT_BOOLEAN, 8, TFS(&sna_rh_eci_truth), 0x01, - "" }}, + "", HFILL }}, { &hf_sna_rh_dr1, { "Definite Response 1 Indicator", "sna.rh.dr1", FT_BOOLEAN, 8, NULL, 0x80, - "" }}, + "", HFILL }}, { &hf_sna_rh_lcci, { "Length-Checked Compression Indicator", "sna.rh.lcci", FT_BOOLEAN, 8, TFS(&sna_rh_lcci_truth), 0x40, - "" }}, + "", HFILL }}, { &hf_sna_rh_dr2, { "Definite Response 2 Indicator", "sna.rh.dr2", FT_BOOLEAN, 8, NULL, 0x20, - "" }}, + "", HFILL }}, { &hf_sna_rh_eri, { "Exception Response Indicator", "sna.rh.eri", FT_BOOLEAN, 8, NULL, 0x10, "Used in conjunction with DR1I and DR2I to indicate, in a request, " - "the form of response requested." }}, + "the form of response requested.", HFILL }}, { &hf_sna_rh_rti, { "Response Type Indicator", "sna.rh.rti", FT_BOOLEAN, 8, TFS(&sna_rh_rti_truth), 0x10, - "" }}, + "", HFILL }}, { &hf_sna_rh_rlwi, { "Request Larger Window Indicator", "sna.rh.rlwi", FT_BOOLEAN, 8, NULL, 0x04, - "Indicates whether a larger pacing window was requested." }}, + "Indicates whether a larger pacing window was requested.", HFILL }}, { &hf_sna_rh_qri, { "Queued Response Indicator", "sna.rh.qri", FT_BOOLEAN, 8, TFS(&sna_rh_qri_truth), 0x02, - "" }}, + "", HFILL }}, { &hf_sna_rh_pi, { "Pacing Indicator", "sna.rh.pi", FT_BOOLEAN, 8, NULL, 0x01, - "" }}, + "", HFILL }}, { &hf_sna_rh_bbi, { "Begin Bracket Indicator", "sna.rh.bbi", FT_BOOLEAN, 8, NULL, 0x80, - "" }}, + "", HFILL }}, { &hf_sna_rh_ebi, { "End Bracket Indicator", "sna.rh.ebi", FT_BOOLEAN, 8, NULL, 0x40, - "" }}, + "", HFILL }}, { &hf_sna_rh_cdi, { "Change Direction Indicator", "sna.rh.cdi", FT_BOOLEAN, 8, NULL, 0x20, - "" }}, + "", HFILL }}, { &hf_sna_rh_csi, { "Code Selection Indicator", "sna.rh.csi", FT_UINT8, BASE_DEC, VALS(sna_rh_csi_vals), 0x08, - "Specifies the encoding used for the associated FMD RU." }}, + "Specifies the encoding used for the associated FMD RU.", HFILL }}, { &hf_sna_rh_edi, { "Enciphered Data Indicator", "sna.rh.edi", FT_BOOLEAN, 8, NULL, 0x04, "Indicates that information in the associated RU is enciphered under " - "session-level cryptography protocols." }}, + "session-level cryptography protocols.", HFILL }}, { &hf_sna_rh_pdi, { "Padded Data Indicator", "sna.rh.pdi", FT_BOOLEAN, 8, NULL, 0x02, "Indicates that the RU was padded at the end, before encipherment, to the next " - "integral multiple of 8 bytes." }}, + "integral multiple of 8 bytes.", HFILL }}, { &hf_sna_rh_cebi, { "Conditional End Bracket Indicator", "sna.rh.cebi", FT_BOOLEAN, 8, NULL, 0x01, "Used to indicate the beginning or end of a group of exchanged " - "requests and responses called a bracket. Only used on LU-LU sessions." }}, + "requests and responses called a bracket. Only used on LU-LU sessions.", HFILL }}, /* { &hf_sna_ru, { "Request/Response Unit", "sna.ru", FT_NONE, BASE_NONE, NULL, 0x0, - ""}},*/ + "", HFILL }},*/ }; static gint *ett[] = { &ett_sna, diff --git a/packet-snmp.c b/packet-snmp.c index 0ec3a93a98..9452c5e683 100644 --- a/packet-snmp.c +++ b/packet-snmp.c @@ -8,7 +8,7 @@ * * See RFCs 1905, 1906, 1909, and 1910 for SNMPv2u. * - * $Id: packet-snmp.c,v 1.68 2001/06/10 09:50:18 guy Exp $ + * $Id: packet-snmp.c,v 1.69 2001/06/18 02:17:52 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -2156,16 +2156,16 @@ proto_register_snmp(void) static hf_register_info hf[] = { { &hf_snmpv3_flags, { "SNMPv3 Flags", "snmpv3.flags", FT_UINT8, BASE_HEX, NULL, - 0x0, "" }}, + 0x0, "", HFILL }}, { &hf_snmpv3_flags_auth, { "Authenticated", "snmpv3.flags.auth", FT_BOOLEAN, 8, - TFS(&flags_set_truth), TH_AUTH, "" }}, + TFS(&flags_set_truth), TH_AUTH, "", HFILL }}, { &hf_snmpv3_flags_crypt, { "Encrypted", "snmpv3.flags.crypt", FT_BOOLEAN, 8, - TFS(&flags_set_truth), TH_CRYPT, "" }}, + TFS(&flags_set_truth), TH_CRYPT, "", HFILL }}, { &hf_snmpv3_flags_report, { "Reportable", "snmpv3.flags.report", FT_BOOLEAN, 8, - TFS(&flags_set_truth), TH_REPORT, "" }}, + TFS(&flags_set_truth), TH_REPORT, "", HFILL }}, }; static gint *ett[] = { &ett_snmp, diff --git a/packet-socks.c b/packet-socks.c index 1e0eb8b5cc..97a7faadc3 100644 --- a/packet-socks.c +++ b/packet-socks.c @@ -2,7 +2,7 @@ * Routines for socks versions 4 &5 packet dissection * Copyright 2000, Jeffrey C. Foster <jfoste@woodward.com> * - * $Id: packet-socks.c,v 1.20 2001/06/08 08:39:58 guy Exp $ + * $Id: packet-socks.c,v 1.21 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -1112,33 +1112,33 @@ proto_register_socks( void){ { &hf_socks_ver, { "Version", "socks.ver", FT_UINT8, BASE_DEC, NULL, - 0x0, "" + 0x0, "", HFILL } }, { &hf_socks_ip_dst, { "Remote Address", "socks.dst", FT_IPv4, BASE_NONE, NULL, - 0x0, "" + 0x0, "", HFILL } }, { &hf_socks_ip6_dst, { "Remote Address", "socks.dstV6", FT_IPv6, BASE_NONE, NULL, - 0x0, "" + 0x0, "", HFILL } }, { &hf_user_name, { "User Name", "socks.username", FT_STRING, BASE_NONE, - NULL, 0x0, "" + NULL, 0x0, "", HFILL } }, { &hf_socks_dstport, { "Remote Port", "socks.dstport", FT_UINT16, - BASE_DEC, NULL, 0x0, "" + BASE_DEC, NULL, 0x0, "", HFILL } }, { &hf_socks_command, { "Command", "socks.command", FT_UINT16, - BASE_DEC, NULL, 0x0, "" + BASE_DEC, NULL, 0x0, "", HFILL } } diff --git a/packet-spray.c b/packet-spray.c index 8a74bb9798..dc1a1f53c3 100644 --- a/packet-spray.c +++ b/packet-spray.c @@ -1,7 +1,7 @@ /* packet-spray.c * 2001 Ronnie Sahlberg <rsahlber@bigpond.net.au> * - * $Id: packet-spray.c,v 1.4 2001/06/12 06:31:14 guy Exp $ + * $Id: packet-spray.c,v 1.5 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -98,23 +98,23 @@ proto_register_spray(void) static hf_register_info hf[] = { { &hf_spray_sprayarr, { "Data", "spray.sprayarr", FT_BYTES, BASE_DEC, - NULL, 0, "Sprayarr data" }}, + NULL, 0, "Sprayarr data", HFILL }}, { &hf_spray_counter, { "counter", "spray.counter", FT_UINT32, BASE_DEC, - NULL, 0, "Counter" }}, + NULL, 0, "Counter", HFILL }}, { &hf_spray_clock, { "clock", "spray.clock", FT_NONE, BASE_NONE, - NULL, 0, "Clock" }}, + NULL, 0, "Clock", HFILL }}, { &hf_spray_sec, { "sec", "spray.sec", FT_UINT32, BASE_DEC, - NULL, 0, "Seconds" }}, + NULL, 0, "Seconds", HFILL }}, { &hf_spray_usec, { "usec", "spray.usec", FT_UINT32, BASE_DEC, - NULL, 0, "Microseconds" }}, + NULL, 0, "Microseconds", HFILL }}, }; diff --git a/packet-srvloc.c b/packet-srvloc.c index 9396c0650c..1d0a3f4854 100644 --- a/packet-srvloc.c +++ b/packet-srvloc.c @@ -6,7 +6,7 @@ * In particular I have not had an opportunity to see how it * responds to SRVLOC over TCP. * - * $Id: packet-srvloc.c,v 1.23 2001/04/23 18:19:03 guy Exp $ + * $Id: packet-srvloc.c,v 1.24 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -496,25 +496,25 @@ proto_register_srvloc(void) { &hf_srvloc_version, { "Version", "srvloc.version", FT_UINT8, BASE_DEC, NULL, 0x0, - "" } + "", HFILL } }, {&hf_srvloc_function, {"Function", "srvloc.function", FT_UINT8, BASE_DEC, VALS(srvloc_functions), 0x0, - ""} + "", HFILL } }, {&hf_srvloc_flags, {"Flags", "srvloc.flags", FT_UINT8, BASE_HEX, NULL, 0x0, - ""} + "", HFILL } }, {&hf_srvloc_error, {"Error Code", "srvloc.err", FT_UINT16, BASE_DEC, VALS(srvloc_errs), 0x0, - ""} + "", HFILL } }, }; diff --git a/packet-stat-notify.c b/packet-stat-notify.c index 1c4a900a68..c68a333349 100644 --- a/packet-stat-notify.c +++ b/packet-stat-notify.c @@ -2,7 +2,7 @@ * Routines for async NSM stat callback dissection * 2001 Ronnie Sahlberg <rsahlber@bigpond.net.au> * - * $Id: packet-stat-notify.c,v 1.4 2001/06/12 06:31:14 guy Exp $ + * $Id: packet-stat-notify.c,v 1.5 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -75,13 +75,13 @@ proto_register_statnotify(void) static hf_register_info hf[] = { { &hf_statnotify_name, { "Name", "statnotify.name", FT_STRING, BASE_DEC, - NULL, 0, "Name of client that changed" }}, + NULL, 0, "Name of client that changed", HFILL }}, { &hf_statnotify_state, { "State", "statnotify.state", FT_UINT32, BASE_DEC, - NULL, 0, "New state of client that changed" }}, + NULL, 0, "New state of client that changed", HFILL }}, { &hf_statnotify_priv, { "Priv", "statnotify.priv", FT_BYTES, BASE_HEX, - NULL, 0, "Client supplied opaque data" }}, + NULL, 0, "Client supplied opaque data", HFILL }}, }; static gint *ett[] = { diff --git a/packet-stat.c b/packet-stat.c index 598c36bb9c..6a019ea002 100644 --- a/packet-stat.c +++ b/packet-stat.c @@ -1,7 +1,7 @@ /* packet-stat.c * Routines for stat dissection * - * $Id: packet-stat.c,v 1.9 2001/05/30 06:01:02 guy Exp $ + * $Id: packet-stat.c,v 1.10 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -272,46 +272,46 @@ proto_register_stat(void) static hf_register_info hf[] = { { &hf_stat_mon_name, { "Name", "stat.name", FT_STRING, BASE_DEC, - NULL, 0, "Name" }}, + NULL, 0, "Name", HFILL }}, { &hf_stat_stat_res, { "Status Result", "stat.stat_res", FT_NONE,0, - NULL, 0, "Status Result" }}, + NULL, 0, "Status Result", HFILL }}, { &hf_stat_stat_res_res, { "Result", "stat.stat_res.res", FT_UINT32, BASE_DEC, - VALS(stat_res), 0, "Result" }}, + VALS(stat_res), 0, "Result", HFILL }}, { &hf_stat_stat_res_state, { "State", "stat.stat_res.state", FT_UINT32, BASE_DEC, - NULL, 0, "State" }}, + NULL, 0, "State", HFILL }}, { &hf_stat_mon, { "Monitor", "stat.mon", FT_NONE, 0, - NULL, 0, "Monitor Host" }}, + NULL, 0, "Monitor Host", HFILL }}, { &hf_stat_mon_id_name, { "Monitor ID Name", "stat.mon_id.name", FT_STRING, BASE_DEC, - NULL, 0, "Monitor ID Name" }}, + NULL, 0, "Monitor ID Name", HFILL }}, { &hf_stat_my_id, { "My ID", "stat.my_id", FT_NONE,0, - NULL, 0, "My_ID structure" }}, + NULL, 0, "My_ID structure", HFILL }}, { &hf_stat_my_id_hostname, { "Hostname", "stat.my_id.hostname", FT_STRING, BASE_DEC, - NULL, 0, "My_ID Host to callback" }}, + NULL, 0, "My_ID Host to callback", HFILL }}, { &hf_stat_my_id_prog, { "Program", "stat.my_id.prog", FT_UINT32, BASE_DEC, - NULL, 0, "My_ID Program to callback" }}, + NULL, 0, "My_ID Program to callback", HFILL }}, { &hf_stat_my_id_vers, { "Version", "stat.my_id.vers", FT_UINT32, BASE_DEC, - NULL, 0, "My_ID Version of callback" }}, + NULL, 0, "My_ID Version of callback", HFILL }}, { &hf_stat_my_id_proc, { "Procedure", "stat.my_id.proc", FT_UINT32, BASE_DEC, - NULL, 0, "My_ID Procedure to callback" }}, + NULL, 0, "My_ID Procedure to callback", HFILL }}, { &hf_stat_priv, { "Priv", "stat.priv", FT_BYTES, BASE_HEX, - NULL, 0, "Private client supplied opaque data" }}, + NULL, 0, "Private client supplied opaque data", HFILL }}, { &hf_stat_state, { "State", "stat.state", FT_UINT32, BASE_DEC, - NULL, 0, "State of local NSM" }}, + NULL, 0, "State of local NSM", HFILL }}, { &hf_stat_stat_chge, { "Status Change", "stat.stat_chge", FT_NONE, 0, - NULL, 0, "Status Change structure" }}, + NULL, 0, "Status Change structure", HFILL }}, }; static gint *ett[] = { diff --git a/packet-sual.c b/packet-sual.c index e6187c1fdf..e8476d4b7c 100644 --- a/packet-sual.c +++ b/packet-sual.c @@ -4,7 +4,7 @@ * Copyright 2001, Martin Held <Martin.Held@icn.siemens.de> * Michael Tüxen <Michael.Tuexen@icn.siemens.de> * - * $Id: packet-sual.c,v 1.5 2001/04/25 05:32:16 guy Exp $ + * $Id: packet-sual.c,v 1.6 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -271,37 +271,37 @@ proto_register_sual(void) { &hf_sual_version, { "Version", "sual.version", FT_UINT8, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sual_spare_1, { "Spare", "sual.spare_1", FT_UINT8, BASE_HEX, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sual_message_type, { "Message Type", "sual.message_type", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sual_subsystem_number, { "Subsystem number", "sual.subsystem_number", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sual_spare_2, { "Spare", "sual.spare_2", FT_UINT16, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sual_message_length, { "Message length", "sual.message_length", FT_UINT32, BASE_DEC, NULL, 0x0, - ""} + "", HFILL } }, { &hf_sual_error_code, { "Error Code", "sual.error_code", FT_UINT16, BASE_HEX, VALS(&sual_error_code_values), 0x0, - ""} + "", HFILL } } }; diff --git a/packet-syslog.c b/packet-syslog.c index dba6252a6e..c6767078b7 100644 --- a/packet-syslog.c +++ b/packet-syslog.c @@ -3,7 +3,7 @@ * * Copyright 2000, Gerald Combs <gerald@zing.org> * - * $Id: packet-syslog.c,v 1.10 2001/01/25 06:14:14 guy Exp $ + * $Id: packet-syslog.c,v 1.11 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -218,17 +218,17 @@ void proto_register_syslog(void) { &hf_syslog_facility, { "Facility", "syslog.facility", FT_UINT8, BASE_DEC, VALS(long_fac), FACILITY_MASK, - "Message facility" } + "Message facility", HFILL } }, { &hf_syslog_level, { "Level", "syslog.level", FT_UINT8, BASE_DEC, VALS(long_lev), PRIORITY_MASK, - "Message level" } + "Message level", HFILL } }, { &hf_syslog_msg_len, { "Message length", "syslog.msg_len", FT_UINT32, BASE_DEC, NULL, 0x0, - "Message length, excluding priority descriptor" } + "Message length, excluding priority descriptor", HFILL } }, }; diff --git a/packet-tacacs.c b/packet-tacacs.c index 8dcd337edb..aebd3c3e06 100644 --- a/packet-tacacs.c +++ b/packet-tacacs.c @@ -1,7 +1,7 @@ /* packet-tacacs.c * Routines for cisco tacacs/tacplus/AAA packet dissection * - * $Id: packet-tacacs.c,v 1.11 2001/02/28 10:28:55 guy Exp $ + * $Id: packet-tacacs.c,v 1.12 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -138,15 +138,15 @@ proto_register_tacacs(void) { &hf_tacacs_version, { "Tacacs Version", "tacacs.version", FT_STRING, BASE_NONE, NULL, 0x0, - "xtacacs or tacplus" }}, + "xtacacs or tacplus", HFILL }}, { &hf_tacacs_response, { "Response", "tacacs.response", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "TRUE if TACACS response" }}, + "TRUE if TACACS response", HFILL }}, { &hf_tacacs_request, { "Request", "tacacs.request", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "TRUE if TACACS request" }} + "TRUE if TACACS request", HFILL }} }; static gint *ett[] = { diff --git a/packet-tcp.c b/packet-tcp.c index a2107325e6..3d0319239f 100644 --- a/packet-tcp.c +++ b/packet-tcp.c @@ -1,7 +1,7 @@ /* packet-tcp.c * Routines for TCP packet disassembly * - * $Id: packet-tcp.c,v 1.104 2001/06/14 08:09:59 guy Exp $ + * $Id: packet-tcp.c,v 1.105 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -659,83 +659,83 @@ proto_register_tcp(void) { &hf_tcp_srcport, { "Source Port", "tcp.srcport", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tcp_dstport, { "Destination Port", "tcp.dstport", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tcp_port, { "Source or Destination Port", "tcp.port", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tcp_seq, { "Sequence number", "tcp.seq", FT_UINT32, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tcp_nxtseq, { "Next sequence number", "tcp.nxtseq", FT_UINT32, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tcp_ack, { "Acknowledgement number", "tcp.ack", FT_UINT32, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tcp_hdr_len, { "Header Length", "tcp.hdr_len", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tcp_flags, { "Flags", "tcp.flags", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tcp_flags_cwr, { "Congestion Window Reduced (CWR)", "tcp.flags.cwr", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_CWR, - "" }}, + "", HFILL }}, { &hf_tcp_flags_ecn, { "ECN-Echo", "tcp.flags.ecn", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_ECN, - "" }}, + "", HFILL }}, { &hf_tcp_flags_urg, { "Urgent", "tcp.flags.urg", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_URG, - "" }}, + "", HFILL }}, { &hf_tcp_flags_ack, { "Acknowledgment", "tcp.flags.ack", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_ACK, - "" }}, + "", HFILL }}, { &hf_tcp_flags_push, { "Push", "tcp.flags.push", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_PUSH, - "" }}, + "", HFILL }}, { &hf_tcp_flags_reset, { "Reset", "tcp.flags.reset", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_RST, - "" }}, + "", HFILL }}, { &hf_tcp_flags_syn, { "Syn", "tcp.flags.syn", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_SYN, - "" }}, + "", HFILL }}, { &hf_tcp_flags_fin, { "Fin", "tcp.flags.fin", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_FIN, - "" }}, + "", HFILL }}, { &hf_tcp_window_size, { "Window size", "tcp.window_size", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tcp_checksum, { "Checksum", "tcp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tcp_checksum_bad, { "Bad Checksum", "tcp.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tcp_urgent_pointer, { "Urgent pointer", "tcp.urgent_pointer", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, }; static gint *ett[] = { &ett_tcp, diff --git a/packet-tftp.c b/packet-tftp.c index eaef370b72..0a39e99bb7 100644 --- a/packet-tftp.c +++ b/packet-tftp.c @@ -5,7 +5,7 @@ * Craig Newell <CraigN@cheque.uq.edu.au> * RFC2347 TFTP Option Extension * - * $Id: packet-tftp.c,v 1.25 2001/06/10 09:50:18 guy Exp $ + * $Id: packet-tftp.c,v 1.26 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -238,37 +238,37 @@ proto_register_tftp(void) { &hf_tftp_opcode, { "Opcode", "tftp.opcode", FT_UINT16, BASE_DEC, VALS(tftp_opcode_vals), 0x0, - "TFTP message type" }}, + "TFTP message type", HFILL }}, { &hf_tftp_source_file, { "Source File", "tftp.source_file", FT_STRINGZ, BASE_DEC, NULL, 0x0, - "TFTP source file name" }}, + "TFTP source file name", HFILL }}, { &hf_tftp_destination_file, { "DESTINATION File", "tftp.destination_file", FT_STRINGZ, BASE_DEC, NULL, 0x0, - "TFTP source file name" }}, + "TFTP source file name", HFILL }}, { &hf_tftp_transfer_type, { "Type", "tftp.type", FT_STRINGZ, BASE_DEC, NULL, 0x0, - "TFTP transfer type" }}, + "TFTP transfer type", HFILL }}, { &hf_tftp_blocknum, { "Block", "tftp.block", FT_UINT16, BASE_DEC, NULL, 0x0, - "Block number" }}, + "Block number", HFILL }}, { &hf_tftp_error_code, { "Error code", "tftp.error.code", FT_UINT16, BASE_DEC, VALS(tftp_error_code_vals), 0x0, - "Error code in case of TFTP error message" }}, + "Error code in case of TFTP error message", HFILL }}, { &hf_tftp_error_string, { "Error message", "tftp.error.message", FT_STRINGZ, BASE_DEC, NULL, 0x0, - "Error string in case of TFTP error message" }} + "Error string in case of TFTP error message", HFILL }} }; static gint *ett[] = { &ett_tftp, diff --git a/packet-time.c b/packet-time.c index 4f1bb40f5f..bd18cd28f5 100644 --- a/packet-time.c +++ b/packet-time.c @@ -3,7 +3,7 @@ * * Richard Sharpe <rsharpe@ns.aus.com> * - * $Id: packet-time.c,v 1.13 2001/01/25 06:14:14 guy Exp $ + * $Id: packet-time.c,v 1.14 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -78,7 +78,7 @@ proto_register_time(void) { &hf_time_time, { "Time", "time.time", FT_UINT32, BASE_DEC, NULL, 0x0, - "Seconds since 00:00 (midnight) 1 January 1900 GMT" }} + "Seconds since 00:00 (midnight) 1 January 1900 GMT", HFILL }} }; static gint *ett[] = { &ett_time, diff --git a/packet-tns.c b/packet-tns.c index c790df8d94..f865aa939f 100644 --- a/packet-tns.c +++ b/packet-tns.c @@ -1,7 +1,7 @@ /* packet-tns.c * Routines for Oracle TNS packet dissection * - * $Id: packet-tns.c,v 1.14 2001/04/19 23:02:44 guy Exp $ + * $Id: packet-tns.c,v 1.15 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -287,43 +287,43 @@ void proto_register_tns(void) static hf_register_info hf[] = { { &hf_tns_sns, { "Secure Network Services", "tns.sns", FT_BOOLEAN, BASE_NONE, - NULL, 0x0, "Secure Network Services" }}, + NULL, 0x0, "Secure Network Services", HFILL }}, { &hf_tns_connect, { "Connect", "tns.connect", FT_BOOLEAN, BASE_NONE, - NULL, 0x0, "Connect" }}, + NULL, 0x0, "Connect", HFILL }}, { &hf_tns_response, { "Response", "tns.response", FT_BOOLEAN, BASE_NONE, - NULL, 0x0, "TRUE if TNS response" }}, + NULL, 0x0, "TRUE if TNS response", HFILL }}, { &hf_tns_request, { "Request", "tns.request", FT_BOOLEAN, BASE_NONE, - NULL, 0x0, "TRUE if TNS request" }}, + NULL, 0x0, "TRUE if TNS request", HFILL }}, { &hf_tns_length, { "Packet Length", "tns.length", FT_UINT32, BASE_DEC, - NULL, 0x0, "Length of TNS packet" }}, + NULL, 0x0, "Length of TNS packet", HFILL }}, { &hf_tns_packet_checksum, { "Packet Checksum", "tns.packet_checksum", FT_UINT16, BASE_HEX, - NULL, 0x0, "Checksum of Packet Data" }}, + NULL, 0x0, "Checksum of Packet Data", HFILL }}, { &hf_tns_header_checksum, { "Header Checksum", "tns.header_checksum", FT_UINT16, BASE_HEX, - NULL, 0x0, "Checksum of Header Data" }}, + NULL, 0x0, "Checksum of Header Data", HFILL }}, { &hf_tns_data_flag, { "Data Flag", "tns.data_flag", FT_UINT16, BASE_HEX, - NULL, 0x0, "Data Flag" }}, + NULL, 0x0, "Data Flag", HFILL }}, { &hf_tns_version, { "Version", "tns.version", FT_UINT16, BASE_DEC, - NULL, 0x0, "Version" }}, + NULL, 0x0, "Version", HFILL }}, { &hf_tns_compat_version, { "Version (Compatible)", "tns.compat_version", FT_UINT16, BASE_DEC, - NULL, 0x0, "Version (Compatible)" }}, + NULL, 0x0, "Version (Compatible)", HFILL }}, { &hf_tns_service_options, { "Service Options", "tns.service_options", FT_UINT16, BASE_HEX, - NULL, 0x0, "Service Options" }}, + NULL, 0x0, "Service Options", HFILL }}, { &hf_tns_reserved_byte, { "Reserved Byte", "tns.reserved_byte", FT_BYTES, BASE_HEX, - NULL, 0x0, "Reserved Byte" }}, + NULL, 0x0, "Reserved Byte", HFILL }}, { &hf_tns_packet_type, { "Packet Type", "tns.type", FT_UINT8, BASE_DEC, - VALS(tns_type_vals), 0x0, "Type of TNS packet" }} + VALS(tns_type_vals), 0x0, "Type of TNS packet", HFILL }} }; static gint *ett[] = { diff --git a/packet-tpkt.c b/packet-tpkt.c index 3ac45c31e5..ce7ffaefa9 100644 --- a/packet-tpkt.c +++ b/packet-tpkt.c @@ -7,7 +7,7 @@ * Routine to dissect RFC 1006 TPKT packet containing OSI TP PDU * Copyright 2001, Martin Thomas <Martin_A_Thomas@yahoo.com> * - * $Id: packet-tpkt.c,v 1.6 2001/06/12 06:31:14 guy Exp $ + * $Id: packet-tpkt.c,v 1.7 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -188,7 +188,7 @@ proto_register_tpkt(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -200,7 +200,7 @@ proto_register_tpkt(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, { @@ -212,7 +212,7 @@ proto_register_tpkt(void) BASE_DEC, NULL, 0x0, - "" + "", HFILL } }, }; diff --git a/packet-tr.c b/packet-tr.c index de256211c2..af6add0ef2 100644 --- a/packet-tr.c +++ b/packet-tr.c @@ -2,7 +2,7 @@ * Routines for Token-Ring packet disassembly * Gilbert Ramirez <gram@xiexie.org> * - * $Id: packet-tr.c,v 1.61 2001/03/13 21:34:24 gram Exp $ + * $Id: packet-tr.c,v 1.62 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -583,81 +583,81 @@ proto_register_tr(void) static hf_register_info hf[] = { { &hf_tr_ac, { "Access Control", "tr.ac", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tr_priority, { "Priority", "tr.priority", FT_UINT8, BASE_DEC, NULL, 0xe0, - "" }}, + "", HFILL }}, { &hf_tr_frame, { "Frame", "tr.frame", FT_BOOLEAN, 8, TFS(&ac_truth), 0x10, - "" }}, + "", HFILL }}, { &hf_tr_monitor_cnt, { "Monitor Count", "tr.monitor_cnt", FT_UINT8, BASE_DEC, NULL, 0x08, - "" }}, + "", HFILL }}, { &hf_tr_priority_reservation, { "Priority Reservation","tr.priority_reservation", FT_UINT8, BASE_DEC, NULL, 0x07, - "" }}, + "", HFILL }}, { &hf_tr_fc, { "Frame Control", "tr.fc", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tr_fc_type, { "Frame Type", "tr.frame_type", FT_UINT8, BASE_DEC, VALS(frame_vals), 0xc0, - "" }}, + "", HFILL }}, { &hf_tr_fc_pcf, { "Frame PCF", "tr.frame_pcf", FT_UINT8, BASE_DEC, VALS(pcf_vals), 0x0f, - "" }}, + "", HFILL }}, { &hf_tr_dst, { "Destination", "tr.dst", FT_ETHER, BASE_NONE, NULL, 0x0, - "Destination Hardware Address" }}, + "Destination Hardware Address", HFILL }}, { &hf_tr_src, { "Source", "tr.src", FT_ETHER, BASE_NONE, NULL, 0x0, - "Source Hardware Address" }}, + "Source Hardware Address", HFILL }}, { &hf_tr_addr, { "Source or Destination Address", "tr.addr", FT_ETHER, BASE_NONE, NULL, 0x0, - "Source or Destination Hardware Address" }}, + "Source or Destination Hardware Address", HFILL }}, { &hf_tr_sr, { "Source Routed", "tr.sr", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "Source Routed" }}, + "Source Routed", HFILL }}, { &hf_tr_rif_bytes, { "RIF Bytes", "tr.rif_bytes", FT_UINT8, BASE_DEC, NULL, 0x0, "Number of bytes in Routing Information Fields, including " - "the two bytes of Routing Control Field" }}, + "the two bytes of Routing Control Field", HFILL }}, { &hf_tr_broadcast, { "Broadcast Type", "tr.broadcast", FT_UINT8, BASE_DEC, VALS(broadcast_vals), 0x0, - "Type of Token-Ring Broadcast" }}, + "Type of Token-Ring Broadcast", HFILL }}, { &hf_tr_max_frame_size, { "Maximum Frame Size", "tr.max_frame_size", FT_UINT8, BASE_DEC, VALS(max_frame_size_vals), 0x0, - "" }}, + "", HFILL }}, { &hf_tr_direction, { "Direction", "tr.direction", FT_UINT8, BASE_DEC, VALS(direction_vals), 0x0, - "Direction of RIF" }}, + "Direction of RIF", HFILL }}, { &hf_tr_rif, { "Ring-Bridge Pairs", "tr.rif", FT_STRING, BASE_NONE, NULL, 0x0, - "String representing Ring-Bridge Pairs" }}, + "String representing Ring-Bridge Pairs", HFILL }}, { &hf_tr_rif_ring, { "RIF Ring", "tr.rif.ring", FT_UINT16, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_tr_rif_bridge, { "RIF Bridge", "tr.rif.bridge", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, }; static gint *ett[] = { &ett_token_ring, diff --git a/packet-trmac.c b/packet-trmac.c index 3f3907d037..78dff05e70 100644 --- a/packet-trmac.c +++ b/packet-trmac.c @@ -2,7 +2,7 @@ * Routines for Token-Ring Media Access Control * Gilbert Ramirez <gram@xiexie.org> * - * $Id: packet-trmac.c,v 1.31 2001/01/21 22:51:46 guy Exp $ + * $Id: packet-trmac.c,v 1.32 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -325,75 +325,75 @@ proto_register_trmac(void) static hf_register_info hf[] = { { &hf_trmac_mv, { "Major Vector", "trmac.mvec", FT_UINT8, BASE_HEX, major_vector_vs, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_length, { "Total Length", "trmac.length", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_srcclass, { "Source Class", "trmac.srcclass", FT_UINT8, BASE_HEX, classes_vs, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_dstclass, { "Destination Class", "trmac.dstclass", FT_UINT8, BASE_HEX, classes_vs, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_sv, { "Sub-Vector", "trmac.svec", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_errors_iso, { "Isolating Errors", "trmac.errors.iso", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_errors_line, { "Line Errors", "trmac.errors.line", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_errors_internal, { "Internal Errors", "trmac.errors.internal", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_errors_burst, { "Burst Errors", "trmac.errors.burst", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_errors_ac, { "A/C Errors", "trmac.errors.ac", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_errors_abort, { "Abort Delimiter Transmitted Errors", "trmac.errors.abort", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_errors_noniso, { "Non-Isolating Errors", "trmac.errors.noniso", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_errors_lost, { "Lost Frame Errors", "trmac.errors.lost", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_errors_congestion, { "Receiver Congestion Errors", "trmac.errors.congestion", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_errors_fc, { "Frame-Copied Errors", "trmac.errors.fc", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_errors_freq, { "Frequency Errors", "trmac.errors.freq", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_errors_token, { "Token Errors", "trmac.errors.token", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_trmac_naun, { "NAUN", "trmac.naun", FT_ETHER, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, }; static gint *ett[] = { &ett_tr_mac, diff --git a/packet-udp.c b/packet-udp.c index 1dec90b8f9..de0db83c55 100644 --- a/packet-udp.c +++ b/packet-udp.c @@ -1,7 +1,7 @@ /* packet-udp.c * Routines for UDP packet disassembly * - * $Id: packet-udp.c,v 1.93 2001/06/08 08:43:48 guy Exp $ + * $Id: packet-udp.c,v 1.94 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -235,27 +235,27 @@ proto_register_udp(void) static hf_register_info hf[] = { { &hf_udp_srcport, { "Source Port", "udp.srcport", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_udp_dstport, { "Destination Port", "udp.dstport", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_udp_port, { "Source or Destination Port", "udp.port", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_udp_length, { "Length", "udp.length", FT_UINT16, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_udp_checksum_bad, { "Bad Checksum", "udp.checksum_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_udp_checksum, { "Checksum", "udp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, }; static gint *ett[] = { &ett_udp, diff --git a/packet-v120.c b/packet-v120.c index 353ef40b72..3f31267fdc 100644 --- a/packet-v120.c +++ b/packet-v120.c @@ -2,7 +2,7 @@ * Routines for v120 frame disassembly * Bert Driehuis <driehuis@playbeing.org> * - * $Id: packet-v120.c,v 1.18 2001/01/22 00:20:29 guy Exp $ + * $Id: packet-v120.c,v 1.19 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -209,13 +209,13 @@ proto_register_v120(void) static hf_register_info hf[] = { { &hf_v120_address, { "Link Address", "v120.address", FT_UINT16, BASE_HEX, NULL, - 0x0, "" }}, + 0x0, "", HFILL }}, { &hf_v120_control, { "Control Field", "v120.control", FT_UINT16, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_v120_header, { "Header Field", "v120.header", FT_STRING, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, }; static gint *ett[] = { &ett_v120, diff --git a/packet-vines.c b/packet-vines.c index 241fce4bc4..8ab47fc37a 100644 --- a/packet-vines.c +++ b/packet-vines.c @@ -1,7 +1,7 @@ /* packet-vines.c * Routines for Banyan VINES protocol packet disassembly * - * $Id: packet-vines.c,v 1.32 2001/06/02 08:15:57 guy Exp $ + * $Id: packet-vines.c,v 1.33 2001/06/18 02:17:53 guy Exp $ * * Don Lafontaine <lafont02@cn.ca> * @@ -331,7 +331,7 @@ proto_register_vines(void) { &hf_vines_protocol, { "Protocol", "vines.protocol", FT_UINT8, BASE_HEX, NULL, 0x0, - "Vines protocol" }} + "Vines protocol", HFILL }} }; proto_vines = proto_register_protocol("Banyan Vines", "Vines", "vines"); diff --git a/packet-vlan.c b/packet-vlan.c index d0430b0a20..6205a0c184 100644 --- a/packet-vlan.c +++ b/packet-vlan.c @@ -1,7 +1,7 @@ /* packet-vlan.c * Routines for VLAN 802.1Q ethernet header disassembly * - * $Id: packet-vlan.c,v 1.33 2001/02/08 07:08:05 guy Exp $ + * $Id: packet-vlan.c,v 1.34 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -137,22 +137,22 @@ proto_register_vlan(void) static hf_register_info hf[] = { { &hf_vlan_priority, { "Priority", "vlan.priority", FT_UINT16, BASE_BIN, - 0, 0xE000, "Priority" }}, + 0, 0xE000, "Priority", HFILL }}, { &hf_vlan_cfi, { "CFI", "vlan.cfi", FT_UINT16, BASE_BIN, - 0, 0x1000, "CFI" }}, /* XXX - Boolean? */ + 0, 0x1000, "CFI", HFILL }}, /* XXX - Boolean? */ { &hf_vlan_id, { "ID", "vlan.id", FT_UINT16, BASE_BIN, - 0, 0x0FFF, "ID" }}, + 0, 0x0FFF, "ID", HFILL }}, { &hf_vlan_etype, { "Type", "vlan.etype", FT_UINT16, BASE_HEX, - VALS(etype_vals), 0x0, "Type" }}, + VALS(etype_vals), 0x0, "Type", HFILL }}, { &hf_vlan_len, { "Length", "vlan.len", FT_UINT16, BASE_DEC, - NULL, 0x0, "Length" }}, + NULL, 0x0, "Length", HFILL }}, { &hf_vlan_trailer, { "Trailer", "vlan.trailer", FT_BYTES, BASE_NONE, - NULL, 0x0, "VLAN Trailer" }} + NULL, 0x0, "VLAN Trailer", HFILL }} }; static gint *ett[] = { &ett_vlan, diff --git a/packet-vrrp.c b/packet-vrrp.c index e022a07118..9453dd3bde 100644 --- a/packet-vrrp.c +++ b/packet-vrrp.c @@ -4,7 +4,7 @@ * * Heikki Vatiainen <hessu@cs.tut.fi> * - * $Id: packet-vrrp.c,v 1.15 2001/04/23 17:51:34 guy Exp $ + * $Id: packet-vrrp.c,v 1.16 2001/06/18 02:17:53 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -205,17 +205,17 @@ void proto_register_vrrp(void) { &hf_vrrp_ver_type, {"VRRP message version and type", "vrrp.typever", FT_UINT8, BASE_DEC, NULL, 0x0, - "VRRP version and type"}}, + "VRRP version and type", HFILL }}, { &hf_vrrp_version, {"VRRP protocol version", "vrrp.version", FT_UINT8, BASE_DEC, NULL, VRRP_VERSION_MASK, - "VRRP version"}}, + "VRRP version", HFILL }}, { &hf_vrrp_type, {"VRRP packet type", "vrrp.type", FT_UINT8, BASE_DEC, VALS(vrrp_type_vals), VRRP_TYPE_MASK, - "VRRP type"}} + "VRRP type", HFILL }} }; static gint *ett[] = { diff --git a/packet-vtp.c b/packet-vtp.c index a7b1fc4c25..6a5ae644b8 100644 --- a/packet-vtp.c +++ b/packet-vtp.c @@ -1,7 +1,7 @@ /* packet-vtp.c * Routines for the disassembly of Cisco's Virtual Trunking Protocol * - * $Id: packet-vtp.c,v 1.13 2001/03/13 21:34:24 gram Exp $ + * $Id: packet-vtp.c,v 1.14 2001/06/18 02:17:54 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -600,87 +600,87 @@ proto_register_vtp(void) static hf_register_info hf[] = { { &hf_vtp_version, { "Version", "vtp.version", FT_UINT8, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_vtp_code, { "Code", "vtp.code", FT_UINT8, BASE_HEX, VALS(type_vals), 0x0, - "" }}, + "", HFILL }}, { &hf_vtp_followers, { "Followers", "vtp.followers", FT_UINT8, BASE_DEC, NULL, 0x0, - "Number of following Subset-Advert messages" }}, + "Number of following Subset-Advert messages", HFILL }}, { &hf_vtp_md_len, { "Management Domain Length", "vtp.md_len", FT_UINT8, BASE_DEC, NULL, 0x0, - "Length of management domain string" }}, + "Length of management domain string", HFILL }}, { &hf_vtp_md, { "Management Domain", "vtp.md", FT_STRING, BASE_DEC, NULL, 0, - "Management domain" }}, + "Management domain", HFILL }}, { &hf_vtp_conf_rev_num, { "Configuration Revision Number", "vtp.conf_rev_num", FT_UINT32, BASE_DEC, NULL, 0x0, - "Revision number of the configuration information" }}, + "Revision number of the configuration information", HFILL }}, { &hf_vtp_upd_id, { "Updater Identity", "vtp.upd_id", FT_IPv4, BASE_NONE, NULL, 0x0, - "IP address of the updater" }}, + "IP address of the updater", HFILL }}, { &hf_vtp_upd_ts, { "Update Timestamp", "vtp.upd_ts", FT_STRING, BASE_DEC, NULL, 0, - "Time stamp of the current configuration revision" }}, + "Time stamp of the current configuration revision", HFILL }}, { &hf_vtp_md5_digest, { "MD5 Digest", "vtp.md5_digest", FT_BYTES, BASE_HEX, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_vtp_seq_num, { "Sequence Number", "vtp.seq_num", FT_UINT8, BASE_DEC, NULL, 0x0, - "Order of this frame in the sequence of Subset-Advert frames" }}, + "Order of this frame in the sequence of Subset-Advert frames", HFILL }}, { &hf_vtp_start_value, { "Start Value", "vtp.start_value", FT_UINT16, BASE_HEX, NULL, 0x0, - "Virtual LAN ID of first VLAN for which information is requested" }}, + "Virtual LAN ID of first VLAN for which information is requested", HFILL }}, { &hf_vtp_vlan_info_len, { "VLAN Information Length", "vtp.vlan_info.len", FT_UINT8, BASE_DEC, NULL, 0x0, - "Length of the VLAN information field" }}, + "Length of the VLAN information field", HFILL }}, { &hf_vtp_vlan_status_vlan_susp, { "VLAN suspended", "vtp.vlan_info.status.vlan_susp", FT_BOOLEAN, 8, NULL, VLAN_SUSPENDED, - "VLAN suspended" }}, + "VLAN suspended", HFILL }}, { &hf_vtp_vlan_type, { "VLAN Type", "vtp.vlan_info.vlan_type", FT_UINT8, BASE_HEX, VALS(vlan_type_vals), 0x0, - "Type of VLAN" }}, + "Type of VLAN", HFILL }}, { &hf_vtp_vlan_name_len, { "VLAN Name Length", "vtp.vlan_info.vlan_name_len", FT_UINT8, BASE_DEC, NULL, 0x0, - "Length of VLAN name string" }}, + "Length of VLAN name string", HFILL }}, { &hf_vtp_isl_vlan_id, { "ISL VLAN ID", "vtp.vlan_info.isl_vlan_id", FT_UINT16, BASE_HEX, NULL, 0x0, - "ID of this VLAN on ISL trunks" }}, + "ID of this VLAN on ISL trunks", HFILL }}, { &hf_vtp_mtu_size, { "MTU Size", "vtp.vlan_info.mtu_size", FT_UINT16, BASE_DEC, NULL, 0x0, - "MTU for this VLAN" }}, + "MTU for this VLAN", HFILL }}, { &hf_vtp_802_10_index, { "802.10 Index", "vtp.vlan_info.802_10_index", FT_UINT32, BASE_HEX, NULL, 0x0, - "IEEE 802.10 security association identifier for this VLAN" }}, + "IEEE 802.10 security association identifier for this VLAN", HFILL }}, { &hf_vtp_vlan_name, { "VLAN Name", "vtp.vlan_info.vlan_name", FT_STRING, BASE_DEC, NULL, 0, - "VLAN name" }}, + "VLAN name", HFILL }}, { &hf_vtp_vlan_tlvtype, { "Type", "vtp.vlan_info.tlv_type", FT_UINT8, BASE_HEX, VALS(vlan_tlv_type_vals), 0x0, - "" }}, + "", HFILL }}, { &hf_vtp_vlan_tlvlength, { "Length", "vtp.vlan_info.tlv_len", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, }; static gint *ett[] = { &ett_vtp, diff --git a/packet-wccp.c b/packet-wccp.c index 90723b25c0..eca6f3a381 100644 --- a/packet-wccp.c +++ b/packet-wccp.c @@ -2,7 +2,7 @@ * Routines for Web Cache Coordination Protocol dissection * Jerry Talkington <jerryt@netapp.com> * - * $Id: packet-wccp.c,v 1.19 2001/03/20 04:30:09 guy Exp $ + * $Id: packet-wccp.c,v 1.20 2001/06/18 02:17:54 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -1195,27 +1195,27 @@ proto_register_wccp(void) static hf_register_info hf[] = { { &hf_wccp_message_type, { "WCCP Message Type", "wccp.message", FT_UINT32, BASE_DEC, VALS(wccp_type_vals), 0x0, - "The WCCP message that was sent"} + "The WCCP message that was sent", HFILL } }, { &hf_wccp_version, { "WCCP Version", "wccp.version", FT_UINT32, BASE_DEC, VALS(wccp_version_val), 0x0, - "The WCCP version"} + "The WCCP version", HFILL } }, { &hf_hash_revision, { "Hash Revision", "wccp.hash_revision", FT_UINT32, BASE_DEC, 0x0, 0x0, - "The cache hash revision"} + "The cache hash revision", HFILL } }, { &hf_change_num, { "Change Number", "wccp.change_num", FT_UINT32, BASE_DEC, 0x0, 0x0, - "The Web-Cache list entry change number"} + "The Web-Cache list entry change number", HFILL } }, { &hf_recvd_id, { "Received ID", "wccp.recvd_id", FT_UINT32, BASE_DEC, 0x0, 0x0, - "The number of I_SEE_YOU's that have been sent"} + "The number of I_SEE_YOU's that have been sent", HFILL } }, { &hf_cache_ip, { "Web Cache IP address", "wccp.cache_ip", FT_IPv4, BASE_NONE, NULL, 0x0, - "The IP address of a Web cache"} + "The IP address of a Web cache", HFILL } }, }; static gint *ett[] = { diff --git a/packet-wcp.c b/packet-wcp.c index afbe8e5af8..f8490021fe 100644 --- a/packet-wcp.c +++ b/packet-wcp.c @@ -2,7 +2,7 @@ * Routines for Wellfleet Compression frame disassembly * Copyright 2001, Jeffrey C. Foster <jfoste@woodward.com> * - * $Id: packet-wcp.c,v 1.9 2001/04/10 19:10:09 guy Exp $ + * $Id: packet-wcp.c,v 1.10 2001/06/18 02:17:54 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -648,79 +648,79 @@ proto_register_wcp(void) static hf_register_info hf[] = { { &hf_wcp_cmd, { "Command", "wcp.cmd", FT_UINT8, BASE_HEX, VALS(cmd_string), WCP_CMD, - "Compression Command" }}, + "Compression Command", HFILL }}, { &hf_wcp_ext_cmd, { "Extended Command", "wcp.ext_cmd", FT_UINT8, BASE_HEX, VALS(ext_cmd_string), WCP_EXT_CMD, - "Extended Compression Command" }}, + "Extended Compression Command", HFILL }}, { &hf_wcp_seq, { "SEQ", "wcp.seq", FT_UINT16, BASE_HEX, NULL, WCP_SEQ, - "Sequence Number" }}, + "Sequence Number", HFILL }}, { &hf_wcp_chksum, { "Checksum", "wcp.checksum", FT_UINT8, BASE_DEC, NULL, 0, - "Packet Checksum" }}, + "Packet Checksum", HFILL }}, { &hf_wcp_tid, { "TID", "wcp.tid", FT_UINT16, BASE_DEC, NULL, 0, - "TID" }}, + "TID", HFILL }}, { &hf_wcp_rev, { "Revision", "wcp.rev", FT_UINT8, BASE_DEC, NULL, 0, - "Revision" }}, + "Revision", HFILL }}, { &hf_wcp_init, { "Initiator", "wcp.init", FT_UINT8, BASE_DEC, NULL, 0, - "Initiator" }}, + "Initiator", HFILL }}, { &hf_wcp_seq_size, { "Seq Size", "wcp.seq_size", FT_UINT8, BASE_DEC, NULL, 0, - "Sequence Size"}}, + "Sequence Size", HFILL }}, { &hf_wcp_alg_cnt, { "Alg Count", "wcp.alg_cnt", FT_UINT8, BASE_DEC, NULL, 0, - "Algorithm Count"}}, + "Algorithm Count", HFILL }}, { &hf_wcp_alg_a, { "Alg 1", "wcp.alg1", FT_UINT8, BASE_DEC, NULL, 0, - "Algorithm #1"}}, + "Algorithm #1", HFILL }}, { &hf_wcp_alg_b, { "Alg 2", "wcp.alg2", FT_UINT8, BASE_DEC, NULL, 0, - "Algorithm #2"}}, + "Algorithm #2", HFILL }}, { &hf_wcp_alg_c, { "Alg 3", "wcp.alg3", FT_UINT8, BASE_DEC, NULL, 0, - "Algorithm #3"}}, + "Algorithm #3", HFILL }}, { &hf_wcp_alg_d, { "Alg 4", "wcp.alg4", FT_UINT8, BASE_DEC, NULL, 0, - "Algorithm #4"}}, + "Algorithm #4", HFILL }}, { &hf_wcp_alg, { "Alg", "wcp.alg", FT_UINT8, BASE_DEC, NULL, 0, - "Algorithm"}}, + "Algorithm", HFILL }}, { &hf_wcp_rexmit, { "Rexmit", "wcp.rexmit", FT_UINT8, BASE_DEC, NULL, 0, - "Retransmit"}}, + "Retransmit", HFILL }}, { &hf_wcp_hist_size, { "History", "wcp.hist", FT_UINT8, BASE_DEC, NULL, 0, - "History Size"}}, + "History Size", HFILL }}, { &hf_wcp_ppc, { "PerPackComp", "wcp.ppc", FT_UINT8, BASE_DEC, NULL, 0, - "Per Packet Compression"}}, + "Per Packet Compression", HFILL }}, { &hf_wcp_pib, { "PIB", "wcp.pib", FT_UINT8, BASE_DEC, NULL, 0, - "PIB"}}, + "PIB", HFILL }}, { &hf_wcp_comp_bits, { "Compress Flag", "wcp.flag", FT_UINT8, BASE_HEX, NULL, 0, - "Compressed byte flag"}}, + "Compressed byte flag", HFILL }}, { &hf_wcp_comp_marker, { "Compress Marker", "wcp.mark", FT_UINT8, BASE_BIN, NULL, 0, - "Compressed marker"}}, + "Compressed marker", HFILL }}, { &hf_wcp_offset, { "Source offset", "wcp.off", FT_UINT16, BASE_HEX, NULL, WCP_OFFSET_MASK, - "Data source offset"}}, + "Data source offset", HFILL }}, { &hf_wcp_short_len, { "Compress Length", "wcp.short_len", FT_UINT8, BASE_HEX, NULL, 0xf0, - "Compressed length"}}, + "Compressed length", HFILL }}, { &hf_wcp_long_len, { "Compress Length", "wcp.long_len", FT_UINT8, BASE_HEX, NULL, 0, - "Compressed length"}}, + "Compressed length", HFILL }}, { &hf_wcp_long_run, { "Long Compression", "wcp.long_comp", FT_UINT16, BASE_HEX, NULL, 0, - "Long Compression type"}}, + "Long Compression type", HFILL }}, { &hf_wcp_short_run, { "Short Compression", "wcp.short_comp", FT_UINT8, BASE_HEX, NULL, 0, - "Short Compression type"}}, + "Short Compression type", HFILL }}, }; diff --git a/packet-who.c b/packet-who.c index ae8455e930..ddc1dc2d19 100644 --- a/packet-who.c +++ b/packet-who.c @@ -2,7 +2,7 @@ * Routines for who protocol (see man rwhod) * Gilbert Ramirez <gram@xiexie.org> * - * $Id: packet-who.c,v 1.16 2001/04/19 23:02:44 guy Exp $ + * $Id: packet-who.c,v 1.17 2001/06/18 02:17:54 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -238,59 +238,59 @@ proto_register_who(void) static hf_register_info hf[] = { { &hf_who_vers, { "Version", "who.vers", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_who_type, { "Type", "who.type", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_who_sendtime, { "Send Time", "who.sendtime", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_who_recvtime, { "Receive Time", "who.recvtime", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_who_hostname, { "Hostname", "who.hostname", FT_STRING, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_who_loadav_5, { "Load Average Over Past 5 Minutes", "who.loadav_5", FT_DOUBLE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_who_loadav_10, { "Load Average Over Past 10 Minutes", "who.loadav_10", FT_DOUBLE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_who_loadav_15, { "Load Average Over Past 15 Minutes", "who.loadav_15", FT_DOUBLE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_who_boottime, { "Boot Time", "who.boottime", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_who_whoent, { "Who utmp Entry", "who.whoent", FT_NONE, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_who_tty, { "TTY Name", "who.tty", FT_STRING, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_who_uid, { "User ID", "who.uid", FT_STRING, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_who_timeon, { "Time On", "who.timeon", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_who_idle, { "Time Idle", "who.idle", FT_UINT32, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, }; static gint *ett[] = { diff --git a/packet-wsp.c b/packet-wsp.c index f6c3cd7944..4bb2dddff0 100644 --- a/packet-wsp.c +++ b/packet-wsp.c @@ -2,7 +2,7 @@ * * Routines to dissect WSP component of WAP traffic. * - * $Id: packet-wsp.c,v 1.20 2001/04/23 04:29:54 guy Exp $ + * $Id: packet-wsp.c,v 1.21 2001/06/18 02:17:54 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -1503,112 +1503,112 @@ proto_register_wsp(void) { "Transmission ID", "wsp.TID", FT_UINT8, BASE_HEX, NULL, 0x00, - "Transmission ID" + "Transmission ID", HFILL } }, { &hf_wsp_header_pdu_type, { "PDU Type", "wsp.pdu_type", FT_UINT8, BASE_HEX, VALS( vals_pdu_type ), 0x00, - "PDU Type" + "PDU Type", HFILL } }, { &hf_wsp_version_major, { "Version (Major)", "wsp.version.major", FT_UINT8, BASE_DEC, NULL, 0xF0, - "Version (Major)" + "Version (Major)", HFILL } }, { &hf_wsp_version_minor, { "Version (Minor)", "wsp.version.minor", FT_UINT8, BASE_DEC, NULL, 0x0F, - "Version (Minor)" + "Version (Minor)", HFILL } }, { &hf_wsp_capability_length, { "Capability Length", "wsp.capability.length", FT_UINT32, BASE_DEC, NULL, 0x00, - "Capability Length" + "Capability Length", HFILL } }, { &hf_wsp_header_length, { "Headers Length", "wsp.headers_length", FT_UINT32, BASE_DEC, NULL, 0x00, - "Headers Length" + "Headers Length", HFILL } }, { &hf_wsp_capabilities_section, { "Capabilities", "wsp.capabilities", FT_NONE, BASE_DEC, NULL, 0x00, - "Capabilities" + "Capabilities", HFILL } }, { &hf_wsp_headers_section, { "Headers", "wsp.headers", FT_NONE, BASE_DEC, NULL, 0x00, - "Headers" + "Headers", HFILL } }, { &hf_wsp_header, { "Header", "wsp.headers.header", FT_NONE, BASE_DEC, NULL, 0x00, - "Header" + "Header", HFILL } }, { &hf_wsp_header_uri_len, { "URI Length", "wsp.uri_length", FT_UINT32, BASE_DEC, NULL, 0x00, - "URI Length" + "URI Length", HFILL } }, { &hf_wsp_header_uri, { "URI", "wsp.uri", FT_STRING, BASE_NONE, NULL, 0x00, - "URI" + "URI", HFILL } }, { &hf_wsp_server_session_id, { "Server Session ID", "wsp.server.session_id", FT_UINT32, BASE_DEC, NULL, 0x00, - "Server Session ID" + "Server Session ID", HFILL } }, { &hf_wsp_header_status, { "Status", "wsp.reply.status", FT_UINT8, BASE_HEX, VALS( vals_status ), 0x00, - "Status" + "Status", HFILL } }, { &hf_wsp_content_type, { "Content Type", "wsp.content_type.type", FT_UINT8, BASE_HEX, VALS ( vals_content_types ), 0x00, - "Content Type" + "Content Type", HFILL } }, { &hf_wsp_parameter_well_known_charset, { "Charset", "wsp.content_type.parameter.charset", FT_UINT16, BASE_HEX, VALS ( vals_character_sets ), 0x00, - "Charset" + "Charset", HFILL } }, { &hf_wsp_reply_data, { "Data", "wsp.reply.data", FT_NONE, BASE_NONE, NULL, 0x00, - "Data" + "Data", HFILL } }, { &hf_wsp_header_accept, @@ -1616,77 +1616,77 @@ proto_register_wsp(void) "wsp.header.accept", /*FT_NONE, BASE_DEC, NULL, 0x00,*/ FT_UINT8, BASE_HEX, VALS ( vals_content_types ), 0x00, - "Accept" + "Accept", HFILL } }, { &hf_wsp_header_accept_str, { "Accept", "wsp.header.accept.string", FT_STRING, BASE_NONE, NULL, 0x00, - "Accept" + "Accept", HFILL } }, { &hf_wsp_header_accept_charset, { "Accept-Charset", "wsp.header.accept_charset", FT_UINT16, BASE_HEX, VALS ( vals_character_sets ), 0x00, - "Accept-Charset" + "Accept-Charset", HFILL } }, { &hf_wsp_header_accept_charset_str, { "Accept-Charset", "wsp.header.accept_charset.string", FT_STRING, BASE_NONE, NULL, 0x00, - "Accept-Charset" + "Accept-Charset", HFILL } }, { &hf_wsp_header_accept_language, { "Accept-Language", "wsp.header.accept_language", FT_UINT8, BASE_HEX, VALS ( vals_languages ), 0x00, - "Accept-Language" + "Accept-Language", HFILL } }, { &hf_wsp_header_accept_language_str, { "Accept-Language", "wsp.header.accept_language.string", FT_STRING, BASE_NONE, NULL, 0x00, - "Accept-Language" + "Accept-Language", HFILL } }, { &hf_wsp_header_accept_ranges, { "Accept-Ranges", "wsp.header.accept_ranges", FT_UINT8, BASE_HEX, VALS ( vals_accept_ranges ), 0x00, - "Accept-Ranges" + "Accept-Ranges", HFILL } }, { &hf_wsp_header_age, { "Age", "wsp.header.age", FT_UINT32, BASE_DEC, NULL, 0x00, - "Age" + "Age", HFILL } }, { &hf_wsp_header_cache_control, { "Cache-Control", "wsp.header.cache_control", FT_UINT8, BASE_HEX, VALS ( vals_cache_control ), 0x00, - "Cache-Control" + "Cache-Control", HFILL } }, { &hf_wsp_header_content_length, { "Content-Length", "wsp.header.content_length", FT_UINT32, BASE_DEC, NULL, 0x00, - "Content-Length" + "Content-Length", HFILL } }, { &hf_wsp_header_date, { "Date", "wsp.header.date", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0, - "Date" + "Date", HFILL } }, { &hf_wsp_header_etag, @@ -1694,35 +1694,35 @@ proto_register_wsp(void) "wsp.header.etag", /*FT_NONE, BASE_DEC, NULL, 0x00,*/ FT_STRING, BASE_NONE, NULL, 0x00, - "Etag" + "Etag", HFILL } }, { &hf_wsp_header_expires, { "Expires", "wsp.header.expires", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0, - "Expires" + "Expires", HFILL } }, { &hf_wsp_header_last_modified, { "Last-Modified", "wsp.header.last_modified", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0, - "Last-Modified" + "Last-Modified", HFILL } }, { &hf_wsp_header_location, { "Location", "wsp.header.location", FT_STRING, BASE_NONE, NULL, 0x00, - "Location" + "Location", HFILL } }, { &hf_wsp_header_if_modified_since, { "If-Modified-Since", "wsp.header.if_modified_since", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0, - "If-Modified-Since" + "If-Modified-Since", HFILL } }, { &hf_wsp_header_server, @@ -1730,7 +1730,7 @@ proto_register_wsp(void) "wsp.header.server", /*FT_NONE, BASE_DEC, NULL, 0x00,*/ FT_STRING, BASE_NONE, NULL, 0x00, - "Server" + "Server", HFILL } }, { &hf_wsp_header_transfer_encoding, @@ -1738,14 +1738,14 @@ proto_register_wsp(void) "wsp.header.transfer_enc", /*FT_NONE, BASE_DEC, NULL, 0x00,*/ FT_UINT8, BASE_HEX, VALS ( vals_transfer_encoding ), 0x00, - "Transfer Encoding" + "Transfer Encoding", HFILL } }, { &hf_wsp_header_transfer_encoding_str, { "Transfer Encoding", "wsp.header.transfer_enc_str", FT_STRING, BASE_NONE, NULL, 0x00, - "Transfer Encoding" + "Transfer Encoding", HFILL } }, { &hf_wsp_header_user_agent, @@ -1753,42 +1753,42 @@ proto_register_wsp(void) "wsp.header.user_agent", /*FT_NONE, BASE_DEC, NULL, 0x00,*/ FT_STRING, BASE_NONE, NULL, 0x00, - "User-Agent" + "User-Agent", HFILL } }, { &hf_wsp_header_via, { "Via", "wsp.header.via", FT_STRING, BASE_NONE, NULL, 0x00, - "Via" + "Via", HFILL } }, { &hf_wsp_header_application_header, { "Application Header", "wsp.header.application_header", FT_STRING, BASE_NONE, NULL, 0x00, - "Application Header" + "Application Header", HFILL } }, { &hf_wsp_header_application_value, { "Application Header Value", "wsp.header.application_header.value", FT_STRING, BASE_NONE, NULL, 0x00, - "Application Header Value" + "Application Header Value", HFILL } }, { &hf_wsp_header_x_wap_tod, { "X-WAP.TOD", "wsp.header.x_wap_tod", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0, - "X-WAP.TOD" + "X-WAP.TOD", HFILL } }, { &hf_wsp_post_data, { "Post Data", "wsp.post.data", FT_NONE, BASE_NONE, NULL, 0x00, - "Post Data" + "Post Data", HFILL } }, }; @@ -1806,7 +1806,7 @@ proto_register_wsp(void) proto_wsp = proto_register_protocol( "Wireless Session Protocol", /* protocol name for use by ethereal */ "WSP", /* short version of name */ - "wap-wsp" /* Abbreviated protocol name, should Match IANA + "wap-wsp" /* Abbreviated protocol name, should Match IANA < URL:http://www.isi.edu/in-notes/iana/assignments/port-numbers/ > */ ); diff --git a/packet-wtls.c b/packet-wtls.c index dbd6cd96b6..f9f5d230f9 100644 --- a/packet-wtls.c +++ b/packet-wtls.c @@ -2,7 +2,7 @@ * * Routines to dissect WTLS component of WAP traffic. * - * $Id: packet-wtls.c,v 1.8 2001/05/02 22:37:06 guy Exp $ + * $Id: packet-wtls.c,v 1.9 2001/06/18 02:17:54 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -1142,469 +1142,469 @@ proto_register_wtls(void) { "Record", "wsp.wtls.record", FT_UINT8, BASE_DEC, VALS ( wtls_vals_record_type ), 0x0f, - "Record" + "Record", HFILL } }, { &hf_wtls_record_type, { "Record Type", "wsp.wtls.rec_type", FT_UINT8, BASE_DEC, VALS ( wtls_vals_record_type ), 0x0f, - "Record Type" + "Record Type", HFILL } }, { &hf_wtls_record_length, { "Record Length", "wsp.wtls.rec_length", FT_UINT16, BASE_DEC, NULL, 0x00, - "Record Length" + "Record Length", HFILL } }, { &hf_wtls_record_sequence, { "Record Sequence", "wsp.wtls.rec_seq", FT_UINT16, BASE_DEC, NULL, 0x00, - "Record Sequence" + "Record Sequence", HFILL } }, { &hf_wtls_record_ciphered, { "Record Ciphered", "wsp.wtls.rec_cipher", FT_NONE, BASE_DEC, NULL, 0x00, - "Record Ciphered" + "Record Ciphered", HFILL } }, { &hf_wtls_hands, { "Handshake", "wsp.wtls.handshake", FT_UINT8, BASE_HEX, VALS ( wtls_vals_handshake_type ), 0x00, - "Handshake" + "Handshake", HFILL } }, { &hf_wtls_hands_type, { "Type", "wsp.wtls.handshake.type", FT_UINT8, BASE_HEX, VALS ( wtls_vals_handshake_type ), 0x00, - "Type" + "Type", HFILL } }, { &hf_wtls_hands_length, { "Length", "wsp.wtls.handshake.length", FT_UINT16, BASE_DEC, NULL, 0x00, - "Length" + "Length", HFILL } }, { &hf_wtls_hands_cli_hello, { "Client Hello", "wsp.wtls.handshake.client_hello", FT_NONE, BASE_NONE,NULL, 0x00, - "Client Hello" + "Client Hello", HFILL } }, { &hf_wtls_hands_cli_hello_version, { "Version", "wsp.wtls.handshake.client_hello.version", FT_UINT8, BASE_DEC, NULL, 0x00, - "Version" + "Version", HFILL } }, { &hf_wtls_hands_cli_hello_gmt, { "Time GMT", "wsp.wtls.handshake.client_hello.gmt", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x00, - "Time GMT" + "Time GMT", HFILL } }, { &hf_wtls_hands_cli_hello_random, { "Random", "wsp.wtls.handshake.client_hello.random", FT_NONE, BASE_DEC, NULL, 0x00, - "Random" + "Random", HFILL } }, { &hf_wtls_hands_cli_hello_session, { "Session ID", "wsp.wtls.handshake.client_hello.sessionid", FT_UINT32, BASE_DEC, NULL, 0x00, - "Session ID" + "Session ID", HFILL } }, { &hf_wtls_hands_cli_hello_session_str, { "Session ID", "wsp.wtls.handshake.client_hello.session.str", FT_STRING, BASE_DEC, NULL, 0x00, - "Session ID" + "Session ID", HFILL } }, { &hf_wtls_hands_cli_hello_cli_key_id, { "Client Keys", "wsp.wtls.handshake.client_hello.client_keys_id", FT_NONE, BASE_DEC, NULL, 0x00, - "Client Keys" + "Client Keys" , HFILL } }, { &hf_wtls_hands_cli_hello_cli_key_len, { "Length", "wsp.wtls.handshake.client_hello.client_keys_len", FT_UINT16, BASE_DEC, NULL, 0x00, - "Length" + "Length" , HFILL } }, { &hf_wtls_hands_cli_hello_trust_key_id, { "Trusted Keys", "wsp.wtls.handshake.client_hello.trusted_keys_id", FT_NONE, BASE_DEC, NULL, 0x00, - "Trusted Keys" + "Trusted Keys" , HFILL } }, { &hf_wtls_hands_cli_hello_key_exchange, { "Key Exchange", "wsp.wtls.handshake.client_hello.key.key_exchange", FT_UINT8, BASE_HEX, VALS ( wtls_vals_key_exchange_suite ), 0x00, - "Key Exchange" + "Key Exchange", HFILL } }, { &hf_wtls_hands_cli_hello_key_exchange_suite, { "Suite", "wsp.wtls.handshake.client_hello.key.key_exchange.suite", FT_UINT8, BASE_HEX, VALS ( wtls_vals_key_exchange_suite ), 0x00, - "Suite" + "Suite", HFILL } }, { &hf_wtls_hands_cli_hello_key_parameter_index, { "Parameter Index", "wsp.wtls.handshake.client_hello.parameter_index", FT_UINT8, BASE_DEC, NULL, 0x00, - "Parameter Index" + "Parameter Index", HFILL } }, { &hf_wtls_hands_cli_hello_key_parameter_set, { "Parameter Set", "wsp.wtls.handshake.client_hello.parameter", FT_STRING, BASE_NONE, NULL, 0x00, - "Parameter Set" + "Parameter Set", HFILL } }, { &hf_wtls_hands_cli_hello_key_identifier_type, { "Identifier Type", "wsp.wtls.handshake.client_hello.ident_type", FT_UINT8, BASE_HEX, VALS ( wtls_vals_identifier_type ), 0x00, - "Identifier Type" + "Identifier Type", HFILL } }, { &hf_wtls_hands_cli_hello_key_identifier_charset, { "Identifier CharSet", "wsp.wtls.handshake.client_hello.ident_charset", FT_UINT16, BASE_HEX, VALS ( vals_character_sets ), 0x00, - "Identifier CharSet" + "Identifier CharSet", HFILL } }, { &hf_wtls_hands_cli_hello_key_identifier_size, { "Identifier Size", "wsp.wtls.handshake.client_hello.ident_size", FT_UINT8, BASE_DEC, NULL, 0x00, - "Identifier Size" + "Identifier Size", HFILL } }, { &hf_wtls_hands_cli_hello_key_identifier, { "Identifier", "wsp.wtls.handshake.client_hello.identifier", FT_NONE, BASE_HEX, NULL, 0x00, - "Identifier" + "Identifier", HFILL } }, { &hf_wtls_hands_cli_hello_key_identifier_str, { "Identifier Name", "wsp.wtls.handshake.client_hello.ident_name", FT_STRING, BASE_HEX, NULL, 0x00, - "Identifier Name" + "Identifier Name", HFILL } }, { &hf_wtls_hands_cli_hello_cipher_suite, { "Cipher Suites", "wsp.wtls.handshake.client_hello.ciphers", FT_NONE, BASE_DEC, NULL, 0x00, - "Cipher Suite" + "Cipher Suite", HFILL } }, { &hf_wtls_hands_cli_hello_cipher_suite_item, { "Cipher", "wsp.wtls.handshake.client_hello.cipher", FT_STRING, BASE_DEC, NULL, 0x00, - "Cipher" + "Cipher", HFILL } }, { &hf_wtls_hands_cli_hello_compression_methods, { "Compression Methods", "wsp.wtls.handshake.client_hello.comp_methods", FT_NONE, BASE_DEC, NULL, 0x00, - "Compression Methods" + "Compression Methods", HFILL } }, { &hf_wtls_hands_cli_hello_compression, { "Compression", "wsp.wtls.handshake.client_hello.compression", FT_UINT8, BASE_HEX, VALS ( wtls_vals_compression ), 0x00, - "Compression" + "Compression", HFILL } }, { &hf_wtls_hands_cli_hello_sequence_mode, { "Sequence Mode", "wsp.wtls.handshake.client_hello.sequence_mode", FT_UINT8, BASE_HEX, VALS ( wtls_vals_sequence_mode ), 0x00, - "Sequence Mode" + "Sequence Mode", HFILL } }, { &hf_wtls_hands_cli_hello_key_refresh, { "Refresh", "wsp.wtls.handshake.client_hello.refresh", FT_UINT8, BASE_DEC,NULL, 0x00, - "Refresh" + "Refresh", HFILL } }, { &hf_wtls_hands_serv_hello, { "Server Hello", "wsp.wtls.handshake.server_hello", FT_NONE, BASE_NONE,NULL, 0x00, - "Server Hello" + "Server Hello", HFILL } }, { &hf_wtls_hands_serv_hello_version, { "Version", "wsp.wtls.handshake.server_hello.version", FT_UINT8, BASE_DEC, NULL, 0x00, - "Version" + "Version", HFILL } }, { &hf_wtls_hands_serv_hello_gmt, { "Time GMT", "wsp.wtls.handshake.server_hello.gmt", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x00, - "Time GMT" + "Time GMT", HFILL } }, { &hf_wtls_hands_serv_hello_random, { "Random", "wsp.wtls.handshake.server_hello.random", FT_NONE, BASE_DEC, NULL, 0x00, - "Random" + "Random", HFILL } }, { &hf_wtls_hands_serv_hello_session, { "Session ID", "wsp.wtls.handshake.server_hello.sessionid", FT_UINT32, BASE_DEC, NULL, 0x00, - "Session ID" + "Session ID", HFILL } }, { &hf_wtls_hands_serv_hello_session_str, { "Session ID", "wsp.wtls.handshake.server_hello.session.str", FT_STRING, BASE_DEC, NULL, 0x00, - "Session ID" + "Session ID", HFILL } }, { &hf_wtls_hands_serv_hello_cli_key_id, { "Client Key ID", "wsp.wtls.handshake.server_hello.key", FT_UINT8, BASE_HEX, NULL, 0x00, - "Client Key ID" + "Client Key ID", HFILL } }, { &hf_wtls_hands_serv_hello_cipher_suite_item, { "Cipher", "wsp.wtls.handshake.server_hello.cipher", FT_NONE, BASE_DEC, NULL, 0x00, - "Cipher" + "Cipher", HFILL } }, { &hf_wtls_hands_serv_hello_cipher_bulk, { "Cipher Bulk", "wsp.wtls.handshake.server_hello.cipher.bulk", FT_UINT8, BASE_HEX, VALS ( wtls_vals_cipher_bulk ), 0x00, - "Cipher Bulk" + "Cipher Bulk", HFILL } }, { &hf_wtls_hands_serv_hello_cipher_mac, { "Cipher MAC", "wsp.wtls.handshake.server_hello.cipher.mac", FT_UINT8, BASE_HEX, VALS ( wtls_vals_cipher_mac ), 0x00, - "Cipher MAC" + "Cipher MAC", HFILL } }, { &hf_wtls_hands_serv_hello_compression, { "Compression", "wsp.wtls.handshake.server_hello.compression", FT_UINT8, BASE_HEX, VALS ( wtls_vals_compression ), 0x00, - "Compression" + "Compression", HFILL } }, { &hf_wtls_hands_serv_hello_sequence_mode, { "Sequence Mode", "wsp.wtls.handshake.server_hello.sequence_mode", FT_UINT8, BASE_HEX, VALS ( wtls_vals_sequence_mode ), 0x00, - "Sequence Mode" + "Sequence Mode", HFILL } }, { &hf_wtls_hands_serv_hello_key_refresh, { "Refresh", "wsp.wtls.handshake.server_hello.refresh", FT_UINT8, BASE_DEC,NULL, 0x00, - "Refresh" + "Refresh", HFILL } }, { &hf_wtls_hands_certificates, { "Certificates", "wsp.wtls.handshake.certificates", FT_NONE, BASE_DEC, NULL, 0x00, - "Certificates" + "Certificates", HFILL } }, { &hf_wtls_hands_certificate, { "Certificate", "wsp.wtls.handshake.certificate", FT_NONE, BASE_DEC, NULL, 0x00, - "Certificate" + "Certificate", HFILL } }, { &hf_wtls_hands_certificate_type, { "Type", "wsp.wtls.handshake.certificate.type", FT_UINT8, BASE_HEX, VALS ( wtls_vals_certificate_type ), 0x00, - "Type" + "Type", HFILL } }, { &hf_wtls_hands_certificate_wtls_version, { "Version", "wsp.wtls.handshake.certificate.version", FT_UINT8, BASE_HEX, NULL, 0x00, - "Version" + "Version", HFILL } }, { &hf_wtls_hands_certificate_wtls_signature_type, { "Signature Type", "wsp.wtls.handshake.certificate.signature.type", FT_UINT8, BASE_HEX, VALS ( wtls_vals_certificate_signature ), 0x00, - "Signature Type" + "Signature Type", HFILL } }, { &hf_wtls_hands_certificate_wtls_signature, { "Signature Size", "wsp.wtls.handshake.certificate.signature.signature", FT_UINT32, BASE_DEC, NULL, 0x00, - "Signature Size" + "Signature Size", HFILL } }, { &hf_wtls_hands_certificate_wtls_issuer_type, { "Issuer", "wsp.wtls.handshake.certificate.issuer.type", FT_UINT8, BASE_HEX, VALS ( wtls_vals_identifier_type ), 0x00, - "Issuer" + "Issuer", HFILL } }, { &hf_wtls_hands_certificate_wtls_issuer_charset, { "Charset", "wsp.wtls.handshake.certificate.issuer.charset", FT_UINT16, BASE_HEX, VALS ( vals_character_sets ), 0x00, - "Charset" + "Charset", HFILL } }, { &hf_wtls_hands_certificate_wtls_issuer_name, { "Name", "wsp.wtls.handshake.certificate.issuer.name", FT_STRING, BASE_NONE, NULL, 0x00, - "Name" + "Name", HFILL } }, { &hf_wtls_hands_certificate_wtls_valid_not_before, { "Valid not before", "wsp.wtls.handshake.certificate.before", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x00, - "Valid not before" + "Valid not before", HFILL } }, { &hf_wtls_hands_certificate_wtls_valid_not_after, { "Valid not after", "wsp.wtls.handshake.certificate.after", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x00, - "Valid not after" + "Valid not after", HFILL } }, { &hf_wtls_hands_certificate_wtls_subject_type, { "Subject", "wsp.wtls.handshake.certificate.subject.type", FT_UINT8, BASE_HEX, VALS ( wtls_vals_identifier_type ), 0x00, - "Subject" + "Subject", HFILL } }, { &hf_wtls_hands_certificate_wtls_subject_charset, { "Charset", "wsp.wtls.handshake.certificate.subject.charset", FT_UINT16, BASE_HEX, VALS ( vals_character_sets ), 0x00, - "Charset" + "Charset", HFILL } }, { &hf_wtls_hands_certificate_wtls_subject_name, { "Name", "wsp.wtls.handshake.certificate.subject.name", FT_STRING, BASE_NONE, NULL, 0x00, - "Name" + "Name", HFILL } }, { &hf_wtls_hands_certificate_wtls_public_key_type, { "Public Key Type", "wsp.wtls.handshake.certificate.public.type", FT_UINT8, BASE_HEX, VALS ( wtls_vals_public_key_type ), 0x00, - "Public Key Type" + "Public Key Type", HFILL } }, { &hf_wtls_hands_certificate_wtls_key_parameter_index, { "Parameter Index", "wsp.wtls.handshake.certificate.parameter_index", FT_UINT8, BASE_DEC, NULL, 0x00, - "Parameter Index" + "Parameter Index", HFILL } }, { &hf_wtls_hands_certificate_wtls_key_parameter_set, { "Parameter Set", "wsp.wtls.handshake.certificate.parameter", FT_STRING, BASE_NONE, NULL, 0x00, - "Parameter Set" + "Parameter Set", HFILL } }, { &hf_wtls_hands_certificate_wtls_rsa_exponent, { "RSA Exponent Size", "wsp.wtls.handshake.certificate.rsa.exponent", FT_UINT32, BASE_DEC, NULL, 0x00, - "RSA Exponent Size" + "RSA Exponent Size", HFILL } }, { &hf_wtls_hands_certificate_wtls_rsa_modules, { "RSA Modulus Size", "wsp.wtls.handshake.certificate.rsa.modules", FT_UINT32, BASE_DEC, NULL, 0x00, - "RSA Modulus Size" + "RSA Modulus Size", HFILL } }, { &hf_wtls_alert, { "Alert", "wsp.wtls.alert", FT_NONE, BASE_HEX, NULL, 0x00, - "Alert" + "Alert", HFILL } }, { &hf_wtls_alert_level, { "Level", "wsp.wtls.alert.level", FT_UINT8, BASE_HEX, VALS ( wtls_vals_alert_level ), 0x00, - "Level" + "Level", HFILL } }, { &hf_wtls_alert_description, { "Description", "wsp.wtls.alert.description", FT_UINT8, BASE_HEX, VALS ( wtls_vals_alert_description ), 0x00, - "Description" + "Description", HFILL } }, }; diff --git a/packet-wtp.c b/packet-wtp.c index a1bbd71195..3b5143f79f 100644 --- a/packet-wtp.c +++ b/packet-wtp.c @@ -2,7 +2,7 @@ * * Routines to dissect WTP component of WAP traffic. * - * $Id: packet-wtp.c,v 1.13 2001/04/17 18:57:09 guy Exp $ + * $Id: packet-wtp.c,v 1.14 2001/06/18 02:17:54 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -482,105 +482,105 @@ proto_register_wtp(void) { "Header", "wtp.header_fixed_part", FT_BYTES, BASE_HEX, NULL, 0x0, - "Fixed part of the header" + "Fixed part of the header", HFILL } }, { &hf_wtp_header_flag_continue, { "Continue Flag", "wtp.continue_flag", FT_BOOLEAN, 8, TFS( &continue_truth ), 0x80, - "Continue Flag" + "Continue Flag", HFILL } }, { &hf_wtp_header_pdu_type, { "PDU Type", "wtp.pdu_type", FT_UINT8, BASE_HEX, VALS( vals_pdu_type ), 0x78, - "PDU Type" + "PDU Type", HFILL } }, { &hf_wtp_header_flag_Trailer, { "Trailer Flags", "wtp.trailer_flags", FT_UINT8, BASE_HEX, VALS( vals_transmission_trailer ), 0x06, - "PDU Type" + "PDU Type", HFILL } }, { &hf_wtp_header_flag_RID, { "Re-transmission Indicator", "wtp.RID", FT_BOOLEAN, 8, TFS( &RID_truth ), 0x01, - "Re-transmission Indicator" + "Re-transmission Indicator", HFILL } }, { &hf_wtp_header_flag_TID_response, { "TID Response", "wtp.TID.response", FT_BOOLEAN, 16, TFS( &tid_response_truth ), 0x8000, - "TID Response" + "TID Response", HFILL } }, { &hf_wtp_header_flag_TID, { "Transmission ID", "wtp.TID", FT_UINT16, BASE_HEX, NULL, 0x7FFF, - "Transmission ID" + "Transmission ID", HFILL } }, { &hf_wtp_header_Inv_version, { "Version", "wtp.header.version", FT_UINT8, BASE_HEX, VALS( vals_version ), 0xC0, - "Version" + "Version", HFILL } }, { &hf_wtp_header_Inv_flag_TIDNew, { "TIDNew", "wtp.header.TIDNew", FT_BOOLEAN, 8, TFS( &TIDNew_truth ), 0x20, - "TIDNew" + "TIDNew", HFILL } }, { &hf_wtp_header_Inv_flag_UP, { "U/P flag", "wtp.header.UP", FT_BOOLEAN, 8, TFS( &UP_truth ), 0x10, - "U/P Flag" + "U/P Flag", HFILL } }, { &hf_wtp_header_Inv_Reserved, { "Reserved", "wtp.inv.reserved", FT_UINT8, BASE_HEX, NULL, 0x0C, - "Reserved" + "Reserved", HFILL } }, { &hf_wtp_header_Inv_TransactionClass, { "Transaction Class", "wtp.inv.transaction_class", FT_UINT8, BASE_HEX, NULL, 0x03, - "Transaction Class" + "Transaction Class", HFILL } }, { &hf_wtp_header_Ack_flag_TVETOK, { "Tve/Tok flag", "wtp.ack.tvetok", FT_BOOLEAN, 8, TFS( &TVETOK_truth ), 0x04, - "Tve/Tok flag" + "Tve/Tok flag", HFILL } }, { &hf_wtp_header_Abort_type, { "Abort Type", "wtp.abort.type", FT_UINT8, BASE_HEX, VALS ( vals_abort_type ), 0x07, - "Abort Type" + "Abort Type", HFILL } }, { &hf_wtp_header_Abort_reason_provider, { "Abort Reason", "wtp.abort.reason.provider", FT_UINT8, BASE_HEX, VALS ( vals_abort_reason_provider ), 0x00, - "Abort Reason" + "Abort Reason", HFILL } }, /* Assume WSP is the user and use its reason codes */ @@ -588,35 +588,35 @@ proto_register_wtp(void) { "Abort Reason", "wtp.abort.reason.user", FT_UINT8, BASE_HEX, VALS ( vals_wsp_reason_codes ), 0x00, - "Abort Reason" + "Abort Reason", HFILL } }, { &hf_wtp_header_sequence_number, { "Packet Sequence Number", "wtp.header.sequence", FT_UINT8, BASE_HEX, NULL, 0x00, - "Packet Sequence Number" + "Packet Sequence Number", HFILL } }, { &hf_wtp_header_missing_packets, { "Missing Packets", "wtp.header.missing_packets", FT_UINT8, BASE_HEX, NULL, 0x00, - "Missing Packets" + "Missing Packets", HFILL } }, { &hf_wtp_header_variable_part, { "Header: Variable part", "wtp.header_variable_part", FT_BYTES, BASE_HEX, NULL, 0x0, - "Variable part of the header" + "Variable part of the header", HFILL } }, { &hf_wtp_data, { "Data", "wtp.header_data", FT_BYTES, BASE_HEX, NULL, 0x0, - "Data" + "Data", HFILL } }, }; @@ -631,7 +631,7 @@ proto_register_wtp(void) proto_wtp = proto_register_protocol( "Wireless Transaction Protocol", /* protocol name for use by ethereal */ "WTP", /* short version of name */ - "wap-wsp-wtp" /* Abbreviated protocol name, should Match IANA + "wap-wsp-wtp" /* Abbreviated protocol name, should Match IANA < URL:http://www.isi.edu/in-notes/iana/assignments/port-numbers/ > */ ); diff --git a/packet-x11-keysym.h b/packet-x11-keysym.h index 90e5ab0c06..6bb5abb958 100644 --- a/packet-x11-keysym.h +++ b/packet-x11-keysym.h @@ -1,6 +1,6 @@ /* packet-x11-keysym.h * - * $Id: packet-x11-keysym.h,v 1.2 2000/08/11 13:33:55 deniel Exp $ + * $Id: packet-x11-keysym.h,v 1.3 2001/06/18 02:17:54 guy Exp $ * * Put there so as to make packet-x11.c lighter. See packet-x11.c */ @@ -32,7 +32,7 @@ static const value_string keysym_vals_source[] = { { 0x06f, "o" }, { 0x070, "p" }, { 0x071, "q" }, { 0x072, "r" }, { 0x073, "s" }, { 0x074, "t" }, { 0x075, "u" }, { 0x076, "v" }, { 0x077, "w" }, { 0x078, "x" }, { 0x079, "y" }, { 0x07a, "z" }, - { 0x07b, "{" }, { 0x07c, "|" }, { 0x07d, "}" }, { 0x07e, "~" }, + { 0x07b, "{" }, { 0x07c, "|" }, { 0x07d, ", HFILL }" }, { 0x07e, "~" }, { 0x0a0, "nobreakspace" }, { 0x0a1, "¡" }, { 0x0a2, "¢" }, { 0x0a3, "£" }, { 0x0a4, "¤" }, { 0x0a5, "¥" }, { 0x0a6, "¦" }, { 0x0a7, "§" }, { 0x0a8, "¨" }, { 0x0a9, "©" }, { 0x0aa, "ª" }, { 0x0ab, "«" }, diff --git a/packet-x11.c b/packet-x11.c index 2c8a181e42..a3633d1566 100644 --- a/packet-x11.c +++ b/packet-x11.c @@ -2,7 +2,7 @@ * Routines for X11 dissection * Copyright 2000, Christophe Tronche <ch.tronche@computer.org> * - * $Id: packet-x11.c,v 1.20 2001/04/20 22:31:25 guy Exp $ + * $Id: packet-x11.c,v 1.21 2001/06/18 02:17:54 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -2910,7 +2910,7 @@ void proto_register_x11(void) { &hf_x11_FIELDABBREV, { "FIELDNAME", "x11.FIELDABBREV", FIELDTYPE, FIELDBASE, FIELDCONVERT, BITMASK, - "FIELDDESCR" } + "FIELDDESCR", HFILL } }, */ #include "x11-register-info.h" diff --git a/packet-x25.c b/packet-x25.c index 28faf147b2..d37ed572ea 100644 --- a/packet-x25.c +++ b/packet-x25.c @@ -2,7 +2,7 @@ * Routines for x25 packet disassembly * Olivier Abad <oabad@cybercable.fr> * - * $Id: packet-x25.c,v 1.48 2001/04/07 08:33:12 guy Exp $ + * $Id: packet-x25.c,v 1.49 2001/06/18 02:17:54 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -1925,43 +1925,43 @@ proto_register_x25(void) static hf_register_info hf[] = { { &hf_x25_gfi, { "GFI", "x.25.gfi", FT_UINT16, BASE_BIN, NULL, 0xF000, - "General format identifier" } }, + "General format identifier", HFILL }}, { &hf_x25_abit, { "A Bit", "x.25.a", FT_BOOLEAN, 16, NULL, 0x8000, - "Address Bit" } }, + "Address Bit", HFILL }}, { &hf_x25_qbit, { "Q Bit", "x.25.q", FT_BOOLEAN, 16, NULL, 0x8000, - "Qualifier Bit" } }, + "Qualifier Bit", HFILL }}, { &hf_x25_dbit, { "D Bit", "x.25.d", FT_BOOLEAN, 16, NULL, 0x4000, - "Delivery Confirmation Bit" } }, + "Delivery Confirmation Bit", HFILL }}, { &hf_x25_mod, { "Modulo", "x.25.mod", FT_UINT16, BASE_DEC, VALS(vals_modulo), 0x3000, - "Specifies whether the frame is modulo 8 or 128" } }, + "Specifies whether the frame is modulo 8 or 128", HFILL }}, { &hf_x25_lcn, { "Logical Channel", "x.25.lcn", FT_UINT16, BASE_DEC, NULL, 0x0FFF, - "Logical Channel Number" } }, + "Logical Channel Number", HFILL }}, { &hf_x25_type, { "Packet Type", "x.25.type", FT_UINT8, BASE_HEX, VALS(vals_x25_type), 0x0, - "Packet Type" } }, + "Packet Type", HFILL }}, { &hf_x25_p_r_mod8, { "P(R)", "x.25.p_r", FT_UINT8, BASE_HEX, NULL, 0xE0, - "Packet Receive Sequence Number" } }, + "Packet Receive Sequence Number", HFILL }}, { &hf_x25_p_r_mod128, { "P(R)", "x.25.p_r", FT_UINT8, BASE_HEX, NULL, 0xFE, - "Packet Receive Sequence Number" } }, + "Packet Receive Sequence Number", HFILL }}, { &hf_x25_mbit_mod8, { "M Bit", "x.25.m", FT_BOOLEAN, 8, NULL, 0x10, - "More Bit" } }, + "More Bit", HFILL }}, { &hf_x25_mbit_mod128, { "M Bit", "x.25.m", FT_BOOLEAN, 8, NULL, 0x01, - "More Bit" } }, + "More Bit", HFILL }}, { &hf_x25_p_s_mod8, { "P(S)", "x.25.p_s", FT_UINT8, BASE_HEX, NULL, 0x0E, - "Packet Send Sequence Number" } }, + "Packet Send Sequence Number", HFILL }}, { &hf_x25_p_s_mod128, { "P(S)", "x.25.p_s", FT_UINT8, BASE_HEX, NULL, 0xFE, - "Packet Send Sequence Number" } }, + "Packet Send Sequence Number", HFILL }}, }; static gint *ett[] = { &ett_x25, diff --git a/packet-yhoo.c b/packet-yhoo.c index febe00eddc..0d84c9102d 100644 --- a/packet-yhoo.c +++ b/packet-yhoo.c @@ -2,7 +2,7 @@ * Routines for yahoo messenger packet dissection * Copyright 1999, Nathan Neulinger <nneul@umr.edu> * - * $Id: packet-yhoo.c,v 1.15 2001/04/23 04:29:54 guy Exp $ + * $Id: packet-yhoo.c,v 1.16 2001/06/18 02:17:58 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -203,34 +203,34 @@ proto_register_yhoo(void) static hf_register_info hf[] = { { &hf_yhoo_service, { "Service Type", "yhoo.service", FT_UINT32, BASE_DEC, - VALS(yhoo_service_vals), 0, "Service Type" }}, + VALS(yhoo_service_vals), 0, "Service Type", HFILL }}, { &hf_yhoo_msgtype, { "Message Type", "yhoo.msgtype", FT_UINT32, BASE_DEC, - VALS(yhoo_msgtype_vals), 0, "Message Type Flags" }}, + VALS(yhoo_msgtype_vals), 0, "Message Type Flags", HFILL }}, { &hf_yhoo_connection_id, { "Connection ID", "yhoo.connection_id", FT_UINT32, BASE_HEX, - NULL, 0, "Connection ID" }}, + NULL, 0, "Connection ID", HFILL }}, { &hf_yhoo_magic_id, { "Magic ID", "yhoo.magic_id", FT_UINT32, BASE_HEX, - NULL, 0, "Magic ID" }}, + NULL, 0, "Magic ID", HFILL }}, { &hf_yhoo_unknown1, { "Unknown 1", "yhoo.unknown1", FT_UINT32, BASE_HEX, - NULL, 0, "Unknown 1" }}, + NULL, 0, "Unknown 1", HFILL }}, { &hf_yhoo_len, { "Packet Length", "yhoo.len", FT_UINT32, BASE_DEC, - NULL, 0, "Packet Length" }}, + NULL, 0, "Packet Length", HFILL }}, { &hf_yhoo_nick1, { "Real Nick (nick1)", "yhoo.nick1", FT_STRING, 0, - NULL, 0, "Real Nick (nick1)" }}, + NULL, 0, "Real Nick (nick1)", HFILL }}, { &hf_yhoo_nick2, { "Active Nick (nick2)", "yhoo.nick2", FT_STRING, 0, - NULL, 0, "Active Nick (nick2)" }}, + NULL, 0, "Active Nick (nick2)", HFILL }}, { &hf_yhoo_content, { "Content", "yhoo.content", FT_STRING, 0, - NULL, 0, "Data portion of the packet" }}, + NULL, 0, "Data portion of the packet", HFILL }}, { &hf_yhoo_version, { "Version", "yhoo.version", FT_STRING, 0, - NULL, 0, "Packet version identifier" }}, + NULL, 0, "Packet version identifier", HFILL }}, }; static gint *ett[] = { &ett_yhoo, diff --git a/packet-yppasswd.c b/packet-yppasswd.c index 1c5fb5555b..8bc8428235 100644 --- a/packet-yppasswd.c +++ b/packet-yppasswd.c @@ -1,7 +1,7 @@ /* packet-yppasswd.c * Routines for yppasswd dissection * - * $Id: packet-yppasswd.c,v 1.3 2001/06/12 06:31:14 guy Exp $ + * $Id: packet-yppasswd.c,v 1.4 2001/06/18 02:17:58 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -104,43 +104,43 @@ proto_register_yppasswd(void) static hf_register_info hf[] = { { &hf_yppasswd_status, { "status", "yppasswd.status", FT_UINT32, BASE_DEC, - NULL, 0, "YPPasswd update status" }}, + NULL, 0, "YPPasswd update status", HFILL }}, { &hf_yppasswd_oldpass, { "oldpass", "yppasswd.oldpass", FT_STRING, BASE_DEC, - NULL, 0, "Old encrypted password" }}, + NULL, 0, "Old encrypted password", HFILL }}, { &hf_yppasswd_newpw, { "newpw", "yppasswd.newpw", FT_NONE, 0, - NULL, 0, "New passwd entry" }}, + NULL, 0, "New passwd entry", HFILL }}, { &hf_yppasswd_newpw_name, { "name", "yppasswd.newpw.name", FT_STRING, BASE_DEC, - NULL, 0, "Username" }}, + NULL, 0, "Username", HFILL }}, { &hf_yppasswd_newpw_passwd, { "passwd", "yppasswd.newpw.passwd", FT_STRING, BASE_DEC, - NULL, 0, "Encrypted passwd" }}, + NULL, 0, "Encrypted passwd", HFILL }}, { &hf_yppasswd_newpw_uid, { "uid", "yppasswd.newpw.uid", FT_UINT32, BASE_DEC, - NULL, 0, "UserID" }}, + NULL, 0, "UserID", HFILL }}, { &hf_yppasswd_newpw_gid, { "gid", "yppasswd.newpw.gid", FT_UINT32, BASE_DEC, - NULL, 0, "GroupID" }}, + NULL, 0, "GroupID", HFILL }}, { &hf_yppasswd_newpw_gecos, { "gecos", "yppasswd.newpw.gecos", FT_STRING, BASE_DEC, - NULL, 0, "In real life name" }}, + NULL, 0, "In real life name", HFILL }}, { &hf_yppasswd_newpw_dir, { "dir", "yppasswd.newpw.dir", FT_STRING, BASE_DEC, - NULL, 0, "Home Directory" }}, + NULL, 0, "Home Directory", HFILL }}, { &hf_yppasswd_newpw_shell, { "shell", "yppasswd.newpw.shell", FT_STRING, BASE_DEC, - NULL, 0, "Default shell" }}, + NULL, 0, "Default shell", HFILL }}, }; diff --git a/packet-ypserv.c b/packet-ypserv.c index 75f6b21f66..a56214237b 100644 --- a/packet-ypserv.c +++ b/packet-ypserv.c @@ -1,7 +1,7 @@ /* packet-ypserv.c * Routines for ypserv dissection * - * $Id: packet-ypserv.c,v 1.16 2001/05/30 06:01:02 guy Exp $ + * $Id: packet-ypserv.c,v 1.17 2001/06/18 02:17:58 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@ethereal.com> @@ -374,46 +374,46 @@ proto_register_ypserv(void) static hf_register_info hf[] = { { &hf_ypserv_domain, { "Domain", "ypserv.domain", FT_STRING, BASE_DEC, - NULL, 0, "Domain" }}, + NULL, 0, "Domain", HFILL }}, { &hf_ypserv_servesdomain, { "Serves Domain", "ypserv.servesdomain", FT_BOOLEAN, BASE_DEC, - &yesno, 0, "Serves Domain" }}, + &yesno, 0, "Serves Domain", HFILL }}, { &hf_ypserv_map, { "Map Name", "ypserv.map", FT_STRING, BASE_DEC, - NULL, 0, "Map Name" }}, + NULL, 0, "Map Name", HFILL }}, { &hf_ypserv_peer, { "Peer Name", "ypserv.peer", FT_STRING, BASE_DEC, - NULL, 0, "Peer Name" }}, + NULL, 0, "Peer Name", HFILL }}, { &hf_ypserv_more, { "More", "ypserv.more", FT_BOOLEAN, BASE_NONE, - &yesno, 0, "More" }}, + &yesno, 0, "More", HFILL }}, { &hf_ypserv_ordernum, { "Order Number", "ypserv.ordernum", FT_UINT32, BASE_DEC, - NULL, 0, "Order Number for XFR" }}, + NULL, 0, "Order Number for XFR", HFILL }}, { &hf_ypserv_transid, { "Host Transport ID", "ypserv.transid", FT_IPv4, BASE_DEC, - NULL, 0, "Host Transport ID to use for XFR Callback" }}, + NULL, 0, "Host Transport ID to use for XFR Callback", HFILL }}, { &hf_ypserv_prog, { "Program Number", "ypserv.prog", FT_UINT32, BASE_DEC, - NULL, 0, "Program Number to use for XFR Callback" }}, + NULL, 0, "Program Number to use for XFR Callback", HFILL }}, { &hf_ypserv_port, { "Port", "ypserv.port", FT_UINT32, BASE_DEC, - NULL, 0, "Port to use for XFR Callback" }}, + NULL, 0, "Port to use for XFR Callback", HFILL }}, { &hf_ypserv_key, { "Key", "ypserv.key", FT_STRING, BASE_DEC, - NULL, 0, "Key" }}, + NULL, 0, "Key", HFILL }}, { &hf_ypserv_value, { "Value", "ypserv.value", FT_STRING, BASE_DEC, - NULL, 0, "Value" }}, + NULL, 0, "Value", HFILL }}, { &hf_ypserv_status, { "Status", "ypserv.status", FT_INT32, BASE_DEC, - VALS(ypstat) , 0, "Status" }}, + VALS(ypstat) , 0, "Status", HFILL }}, { &hf_ypserv_map_parms, { "YP Map Parameters", "ypserv.map_parms", FT_NONE, BASE_DEC, - NULL, 0, "YP Map Parameters" }}, + NULL, 0, "YP Map Parameters", HFILL }}, { &hf_ypserv_xfrstat, { "Xfrstat", "ypserv.xfrstat", FT_INT32, BASE_DEC, - VALS(xfrstat), 0, "Xfrstat" }}, + VALS(xfrstat), 0, "Xfrstat", HFILL }}, }; static gint *ett[] = { &ett_ypserv, diff --git a/packet-zebra.c b/packet-zebra.c index d30d632041..11bc950ec9 100644 --- a/packet-zebra.c +++ b/packet-zebra.c @@ -3,7 +3,7 @@ * * Jochen Friedrich <jochen@scram.de> * - * $Id: packet-zebra.c,v 1.12 2001/04/23 04:29:54 guy Exp $ + * $Id: packet-zebra.c,v 1.13 2001/06/18 02:17:58 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs <gerald@zing.org> @@ -529,111 +529,111 @@ proto_register_zebra(void) { &hf_zebra_len, { "Length", "zebra.len", FT_UINT16, BASE_DEC, NULL, 0x0, - "Length of ZEBRA request" }}, + "Length of ZEBRA request", HFILL }}, { &hf_zebra_request, { "Request", "zebra.request", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "TRUE if ZEBRA request" }}, + "TRUE if ZEBRA request", HFILL }}, { &hf_zebra_command, { "Command", "zebra.command", FT_UINT8, BASE_DEC, VALS(messages), 0x0, - "ZEBRA command" }}, + "ZEBRA command", HFILL }}, { &hf_zebra_interface, { "Interface", "zebra.interface", FT_STRING, BASE_NONE, NULL, 0x0, - "Interface name of ZEBRA request" }}, + "Interface name of ZEBRA request", HFILL }}, { &hf_zebra_index, { "Index", "zebra.index", FT_UINT32, BASE_DEC, NULL, 0x0, - "Index of interface" }}, + "Index of interface", HFILL }}, { &hf_zebra_indexnum, { "Index Number", "zebra.indexnum", FT_UINT8, BASE_DEC, NULL, 0x0, - "Number of indices for route" }}, + "Number of indices for route", HFILL }}, { &hf_zebra_intflags, { "Flags", "zebra.intflags", FT_UINT32, BASE_DEC, NULL, 0x0, - "Flags of interface" }}, + "Flags of interface", HFILL }}, { &hf_zebra_rtflags, { "Flags", "zebra.rtflags", FT_UINT8, BASE_DEC, NULL, 0x0, - "Flags of route" }}, + "Flags of route", HFILL }}, { &hf_zebra_message, { "Message", "zebra.message", FT_UINT8, BASE_DEC, NULL, 0x0, - "Message type of route" }}, + "Message type of route", HFILL }}, { &hf_zebra_msg_nexthop, { "Message Nexthop", "zebra.message.nexthop", FT_BOOLEAN, 8, NULL, ZEBRA_ZAPI_MESSAGE_NEXTHOP, - "Message contains nexthop" }}, + "Message contains nexthop", HFILL }}, { &hf_zebra_msg_index, { "Message Index", "zebra.message.index", FT_BOOLEAN, 8, NULL, ZEBRA_ZAPI_MESSAGE_IFINDEX, - "Message contains index" }}, + "Message contains index", HFILL }}, { &hf_zebra_msg_distance, { "Message Distance", "zebra.message.distance", FT_BOOLEAN, 8, NULL, ZEBRA_ZAPI_MESSAGE_DISTANCE, - "Message contains distance" }}, + "Message contains distance", HFILL }}, { &hf_zebra_msg_metric, { "Message Metric", "zebra.message.metric", FT_BOOLEAN, 8, NULL, ZEBRA_ZAPI_MESSAGE_METRIC, - "Message contains metric" }}, + "Message contains metric", HFILL }}, { &hf_zebra_type, { "Type", "zebra.type", FT_UINT8, BASE_DEC, VALS(routes), 0x0, - "Type of route" }}, + "Type of route", HFILL }}, { &hf_zebra_distance, { "Distance", "zebra.distance", FT_UINT8, BASE_DEC, NULL, 0x0, - "Distance of route" }}, + "Distance of route", HFILL }}, { &hf_zebra_metric, { "Metric", "zebra.metric", FT_UINT32, BASE_DEC, NULL, 0x0, - "Metric of interface or route" }}, + "Metric of interface or route", HFILL }}, { &hf_zebra_mtu, { "MTU", "zebra.mtu", FT_UINT32, BASE_DEC, NULL, 0x0, - "MTU of interface" }}, + "MTU of interface", HFILL }}, { &hf_zebra_bandwidth, { "Bandwidth", "zebra.bandwidth", FT_UINT32, BASE_DEC, NULL, 0x0, - "Bandwidth of interface" }}, + "Bandwidth of interface", HFILL }}, { &hf_zebra_family, { "Family", "zebra.family", FT_UINT32, BASE_DEC, NULL, 0x0, - "Family of IP address" }}, + "Family of IP address", HFILL }}, { &hf_zebra_dest4, { "Destination", "zebra.dest4", FT_IPv4, BASE_NONE, NULL, 0x0, - "Destination IPv4 field" }}, + "Destination IPv4 field", HFILL }}, { &hf_zebra_dest6, { "Destination", "zebra.dest6", FT_IPv6, BASE_NONE, NULL, 0x0, - "Destination IPv6 field" }}, + "Destination IPv6 field", HFILL }}, { &hf_zebra_nexthopnum, { "Nexthop Number", "zebra.nexthopnum", FT_UINT8, BASE_DEC, NULL, 0x0, - "Number of nexthops in route" }}, + "Number of nexthops in route", HFILL }}, { &hf_zebra_nexthop4, { "Nexthop", "zebra.nexthop4", FT_IPv4, BASE_NONE, NULL, 0x0, - "Nethop IPv4 field of route" }}, + "Nethop IPv4 field of route", HFILL }}, { &hf_zebra_nexthop6, { "Nexthop", "zebra.nexthop6", FT_IPv6, BASE_NONE, NULL, 0x0, - "Nethop IPv6 field of route" }}, + "Nethop IPv6 field of route", HFILL }}, { &hf_zebra_prefixlen, { "Prefix length", "zebra.prefixlen", FT_UINT32, BASE_DEC, NULL, 0x0, - "Prefix length" }}, + "Prefix length", HFILL }}, { &hf_zebra_prefix4, { "Prefix", "zebra.prefix4", FT_IPv4, BASE_NONE, NULL, 0x0, - "Prefix IPv4" }}, + "Prefix IPv4", HFILL }}, { &hf_zebra_prefix6, { "Prefix", "zebra.prefix6", FT_IPv6, BASE_NONE, NULL, 0x0, - "Prefix IPv6" }}, + "Prefix IPv6", HFILL }}, }; static gint *ett[] = { diff --git a/plugins/gryphon/packet-gryphon.c b/plugins/gryphon/packet-gryphon.c index f491dba583..8ed36992f4 100644 --- a/plugins/gryphon/packet-gryphon.c +++ b/plugins/gryphon/packet-gryphon.c @@ -1,7 +1,7 @@ /* packet-gryphon.c * Routines for Gryphon protocol packet disassembly * - * $Id: packet-gryphon.c,v 1.21 2001/04/25 06:14:53 guy Exp $ + * $Id: packet-gryphon.c,v 1.22 2001/06/18 02:18:25 guy Exp $ * * Ethereal - Network traffic analyzer * By Steve Limkemann <stevelim@dgtech.com> @@ -1822,22 +1822,22 @@ plugin_init(plugin_address_table_t *pat) static hf_register_info hf[] = { { &hf_gryph_src, { "Source", "gryph.src", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_gryph_srcchan, { "Source channel", "gryph.srcchan", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_gryph_dest, { "Destination", "gryph.dest", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_gryph_destchan, { "Destination channel", "gryph.dstchan", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_gryph_type, { "Frame type", "gryph.type", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, { &hf_gryph_cmd, { "Command", "gryph.cmd.cmd", FT_UINT8, BASE_DEC, NULL, 0x0, - "" }}, + "", HFILL }}, }; static gint *ett[] = { diff --git a/plugins/mgcp/packet-mgcp.c b/plugins/mgcp/packet-mgcp.c index 790af794ae..acd96aef13 100644 --- a/plugins/mgcp/packet-mgcp.c +++ b/plugins/mgcp/packet-mgcp.c @@ -2,7 +2,7 @@ * Routines for mgcp packet disassembly * RFC 2705 * - * $Id: packet-mgcp.c,v 1.21 2001/04/23 04:12:51 guy Exp $ + * $Id: packet-mgcp.c,v 1.22 2001/06/18 02:18:27 guy Exp $ * * Copyright (c) 2000 by Ed Warnicke <hagbard@physics.rutgers.edu> * @@ -388,109 +388,109 @@ proto_register_mgcp(void) static hf_register_info hf[] = { { &hf_mgcp_req, { "Request", "mgcp.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "True if MGCP request" }}, + "True if MGCP request", HFILL }}, { &hf_mgcp_rsp, { "Response", "mgcp.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0, - "TRUE if MGCP response" }}, + "TRUE if MGCP response", HFILL }}, { &hf_mgcp_req_verb, { "Verb", "mgcp.req.verb", FT_STRING, BASE_DEC, NULL, 0x0, - "Name of the verb"}}, + "Name of the verb", HFILL }}, { &hf_mgcp_req_endpoint, { "Endpoint", "mgcp.req.endpoint", FT_STRING, BASE_DEC, NULL, 0x0, - "Endpoint referenced by the message"}}, + "Endpoint referenced by the message", HFILL }}, { &hf_mgcp_transid, { "Transaction ID", "mgcp.transid", FT_STRING, BASE_DEC, NULL, 0x0, - "Transaction ID of this message"}}, + "Transaction ID of this message", HFILL }}, { &hf_mgcp_version, { "Version", "mgcp.version", FT_STRING, BASE_DEC, NULL, 0x0, - "MGCP Version"}}, + "MGCP Version", HFILL }}, { &hf_mgcp_rsp_rspcode, { "Response Code", "mgcp.rsp.rspcode", FT_STRING, BASE_DEC, NULL, 0x0, - "Response Code"}}, + "Response Code", HFILL }}, { &hf_mgcp_rsp_rspstring, { "Response String", "mgcp.rsp.rspstring", FT_STRING, BASE_DEC, NULL, - 0x0, "Response String"}}, + 0x0, "Response String", HFILL }}, { &hf_mgcp_param_rspack, { "ResponseAck (K)", "mgcp.param.rspack", FT_STRING, BASE_DEC, NULL, - 0x0, "Response Ack"}}, + 0x0, "Response Ack", HFILL }}, { &hf_mgcp_param_bearerinfo, { "BearerInformation (B)", "mgcp.param.bearerinfo", FT_STRING, BASE_DEC, - NULL, 0x0, "Bearer Information"}}, + NULL, 0x0, "Bearer Information", HFILL }}, { &hf_mgcp_param_callid, { "CallId (C)", "mgcp.param.callid", FT_STRING, BASE_DEC, NULL, 0x0, - "Call Id"}}, + "Call Id", HFILL }}, { &hf_mgcp_param_connectionid, {"ConnectionIdentifier (I)", "mgcp.param.connectionid", FT_STRING, - BASE_DEC, NULL, 0x0, "Connection Identifier"}}, + BASE_DEC, NULL, 0x0, "Connection Identifier", HFILL }}, { &hf_mgcp_param_secondconnectionid, { "SecondConnectionID (I2)", "mgcp.param.secondconnectionid", FT_STRING, - BASE_DEC, NULL, 0x0, "Second Connection Identifier"}}, + BASE_DEC, NULL, 0x0, "Second Connection Identifier", HFILL }}, { &hf_mgcp_param_notifiedentity, { "NotifiedEntity (N)", "mgcp.param.notifiedentity", FT_STRING, BASE_DEC, - NULL, 0x0, "Notified Entity"}}, + NULL, 0x0, "Notified Entity", HFILL }}, { &hf_mgcp_param_requestid, { "RequestIdentifier (X)", "mgcp.param.requestid", FT_STRING, BASE_DEC, - NULL, 0x0, "Request Identifier"}}, + NULL, 0x0, "Request Identifier", HFILL }}, { &hf_mgcp_param_localconnoptions, { "LocalConnectionOptions (L)", "mgcp.param.localconnectionoptions", - FT_STRING, BASE_DEC, NULL, 0x0, "Local Connection Options"}}, + FT_STRING, BASE_DEC, NULL, 0x0, "Local Connection Options", HFILL }}, { &hf_mgcp_param_connectionmode, { "ConnectionMode (M)", "mgcp.param.connectionmode", FT_STRING, BASE_DEC, - NULL, 0x0, "Connection Mode" }}, + NULL, 0x0, "Connection Mode", HFILL }}, { &hf_mgcp_param_reqevents, { "RequestedEvents (R)", "mgcp.param.reqevents", FT_STRING, BASE_DEC, - NULL, 0x0, "Requested Events"}}, + NULL, 0x0, "Requested Events", HFILL }}, { &hf_mgcp_param_signalreq, { "SignalRequests (S)", "mgcp.param.signalreq", FT_STRING, BASE_DEC, - NULL, 0x0, "Signal Request"}}, + NULL, 0x0, "Signal Request", HFILL }}, { &hf_mgcp_param_restartmethod, { "RestartMethod (RM)", "mgcp.param.restartmethod", FT_STRING, BASE_DEC, - NULL, 0x0, "Restart Method"}}, + NULL, 0x0, "Restart Method", HFILL }}, { &hf_mgcp_param_restartdelay, { "RestartDelay (RD)", "mgcp.param.restartdelay", FT_STRING, BASE_DEC, - NULL, 0x0, "Restart Delay"}}, + NULL, 0x0, "Restart Delay", HFILL }}, { &hf_mgcp_param_digitmap, { "DigitMap (D)", "mgcp.param.digitmap", FT_STRING, BASE_DEC, NULL, 0x0, - "Digit Map"}}, + "Digit Map", HFILL }}, { &hf_mgcp_param_observedevent, { "ObservedEvents (O)", "mgcp.param.observedevents", FT_STRING, - BASE_DEC, NULL, 0x0, "Observed Events"}}, + BASE_DEC, NULL, 0x0, "Observed Events", HFILL }}, { &hf_mgcp_param_connectionparam, { "ConnectionParameters (P)", "mgcp.param.connectionparam", FT_STRING, - BASE_DEC, NULL, 0x0, "Connection Parameters"}}, + BASE_DEC, NULL, 0x0, "Connection Parameters", HFILL }}, { &hf_mgcp_param_reasoncode, { "ReasonCode (E)", "mgcp.param.reasoncode", FT_STRING, BASE_DEC, - NULL, 0x0, "Reason Code"}}, + NULL, 0x0, "Reason Code", HFILL }}, { &hf_mgcp_param_eventstates, { "EventStates (ES)", "mgcp.param.eventstates", FT_STRING, BASE_DEC, - NULL, 0x0, "Event States"}}, + NULL, 0x0, "Event States", HFILL }}, { &hf_mgcp_param_specificendpoint, { "SpecificEndpointID (Z)", "mgcp.param.specificendpointid", FT_STRING, - BASE_DEC, NULL, 0x0, "Specific Endpoint ID"}}, + BASE_DEC, NULL, 0x0, "Specific Endpoint ID", HFILL }}, { &hf_mgcp_param_secondendpointid, { "SecondEndpointID (Z2)", "mgcp.param.secondendpointid", FT_STRING, - BASE_DEC, NULL, 0x0, "Second Endpoing ID"}}, + BASE_DEC, NULL, 0x0, "Second Endpoing ID", HFILL }}, { &hf_mgcp_param_reqinfo, { "RequestedInfo (F)", "mgcp.param.reqinfo", FT_STRING, BASE_DEC, - NULL, 0x0,"Requested Info"}}, + NULL, 0x0,"Requested Info", HFILL }}, { &hf_mgcp_param_quarantinehandling, { "QuarantineHandling (Q)", "mgcp.param.quarantinehandling", FT_STRING, - BASE_DEC, NULL, 0x0, "Quarantine Handling"}}, + BASE_DEC, NULL, 0x0, "Quarantine Handling", HFILL }}, { &hf_mgcp_param_detectedevents, { "DetectedEvents (T)", "mgcp.param.detectedevents", FT_STRING, BASE_DEC, - NULL, 0x0, "Detected Events"}}, + NULL, 0x0, "Detected Events", HFILL }}, { &hf_mgcp_param_capabilities, { "Capabilities (A)", "mgcp.param.capabilities", FT_STRING, BASE_DEC, - NULL, 0x0, "Capabilities"}}, + NULL, 0x0, "Capabilities", HFILL }}, { &hf_mgcp_param_extention, { "Extention Parameter (X-*)", "mgcp.param.extention", FT_STRING, - BASE_DEC, NULL, 0x0, "Extension Parameter"}}, + BASE_DEC, NULL, 0x0, "Extension Parameter", HFILL }}, { &hf_mgcp_param_invalid, { "Invalid Parameter", "mgcp.param.invalid", FT_STRING, - BASE_DEC, NULL, 0x0, "Invalid Parameter"}}, + BASE_DEC, NULL, 0x0, "Invalid Parameter", HFILL }}, { &hf_mgcp_messagecount, { "MGCP Message Count", "mgcp.messagecount", FT_UINT32, - BASE_DEC, NULL, 0x0, "Number of MGCP message in a packet"}}, + BASE_DEC, NULL, 0x0, "Number of MGCP message in a packet", HFILL }}, /* Add more fields here */ }; static gint *ett[] = { diff --git a/process-x11-fields.pl b/process-x11-fields.pl index 4408b4cc0f..25b4a9f834 100644 --- a/process-x11-fields.pl +++ b/process-x11-fields.pl @@ -6,7 +6,7 @@ # # Copyright 2000, Christophe Tronche <ch.tronche@computer.org> # -# $Id: process-x11-fields.pl,v 1.4 2001/04/21 08:04:43 guy Exp $ +# $Id: process-x11-fields.pl,v 1.5 2001/06/18 02:17:58 guy Exp $ # # Ethereal - Network traffic analyzer # By Gerald Combs <gerald@ethereal.com> @@ -122,6 +122,6 @@ while(<>) { print DECL "static int hf_x11_$variable = -1;\n"; print REG <<END; -{ &hf_x11_$variable, { "$abbrev", "x11.$field", FT_$type, $fieldDisplay, $fieldStrings, $mask, "$longName" } }, +{ &hf_x11_$variable, { "$abbrev", "x11.$field", FT_$type, $fieldDisplay, $fieldStrings, $mask, "$longName", HFILL }}, END } |