From Joerg Mayer: explicitly fill in all members of a
authorguy <guy@f5534014-38df-0310-8fa8-9805f1628bb7>
Mon, 18 Jun 2001 02:18:27 +0000 (02:18 +0000)
committerguy <guy@f5534014-38df-0310-8fa8-9805f1628bb7>
Mon, 18 Jun 2001 02:18:27 +0000 (02:18 +0000)
"header_field_info" structure, including the ones that are later set by
the routines to register fields.

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

162 files changed:
epan/proto.h
make-reg-dotc.py
ncp2222.py
packet-aarp.c
packet-afs-register-info.h
packet-aim.c
packet-arp.c
packet-ascend.c
packet-atalk.c
packet-atm.c
packet-auto_rp.c
packet-bacapp.c
packet-bacnet.c
packet-bgp.c
packet-bootp.c
packet-bootparams.c
packet-bpdu.c
packet-bvlc.c
packet-bxxp.c
packet-cdp.c
packet-cgmp.c
packet-chdlc.c
packet-clnp.c
packet-cops.c
packet-cups.c
packet-dcerpc.c
packet-ddtp.c
packet-diameter.c
packet-dns.c
packet-dsi.c
packet-dvmrp.c
packet-eigrp.c
packet-esis.c
packet-eth.c
packet-fddi.c
packet-fr.c
packet-frame.c
packet-ftp.c
packet-giop.c
packet-gnutella.c
packet-gre.c
packet-gtp.c
packet-gvrp.c
packet-h1.c
packet-h261.c
packet-hclnfsd.c
packet-hsrp.c
packet-http.c
packet-icmpv6.c
packet-icp.c
packet-icq.c
packet-ieee80211.c
packet-igmp.c
packet-igrp.c
packet-imap.c
packet-ip.c
packet-ipsec.c
packet-ipv6.c
packet-ipx.c
packet-irc.c
packet-iscsi.c
packet-isis-hello.c
packet-isis-lsp.c
packet-isis-snp.c
packet-isis.c
packet-isl.c
packet-isup.c
packet-iua.c
packet-klm.c
packet-l2tp.c
packet-lapb.c
packet-lapbether.c
packet-lapd.c
packet-ldap.c
packet-ldp.c
packet-llc.c
packet-lmi.c
packet-lpd.c
packet-m3ua.c
packet-mapi.c
packet-mbtcp.c
packet-mip.c
packet-mount.c
packet-mpeg1.c
packet-mpls.c
packet-msproxy.c
packet-mtp3.c
packet-nbns.c
packet-ncp.c
packet-netbios.c
packet-nfs.c
packet-nisplus.c
packet-nlm.c
packet-nntp.c
packet-ntp.c
packet-null.c
packet-pim.c
packet-pop.c
packet-portmap.c
packet-ppp.c
packet-pptp.c
packet-q2931.c
packet-q931.c
packet-quake.c
packet-radius.c
packet-ranap.c
packet-ripng.c
packet-rlogin.c
packet-rpc.c
packet-rquota.c
packet-rsh.c
packet-rsvp.c
packet-rtcp.c
packet-rtp.c
packet-rtsp.c
packet-rwall.c
packet-rx.c
packet-sap.c
packet-sctp.c
packet-sip.c
packet-sll.c
packet-smb.c
packet-smtp.c
packet-sna.c
packet-snmp.c
packet-socks.c
packet-spray.c
packet-srvloc.c
packet-stat-notify.c
packet-stat.c
packet-sual.c
packet-syslog.c
packet-tacacs.c
packet-tcp.c
packet-tftp.c
packet-time.c
packet-tns.c
packet-tpkt.c
packet-tr.c
packet-trmac.c
packet-udp.c
packet-v120.c
packet-vines.c
packet-vlan.c
packet-vrrp.c
packet-vtp.c
packet-wccp.c
packet-wcp.c
packet-who.c
packet-wsp.c
packet-wtls.c
packet-wtp.c
packet-x11-keysym.h
packet-x11.c
packet-x25.c
packet-yhoo.c
packet-yppasswd.c
packet-ypserv.c
packet-zebra.c
plugins/gryphon/packet-gryphon.c
plugins/mgcp/packet-mgcp.c
process-x11-fields.pl

index e3be5efb61aeb6d85ce9d658fa1c74521a90b781..ff373f464737cd8bffa88c4550b3a36fdc859dfc 100644 (file)
@@ -1,7 +1,7 @@
 /* proto.h
  * Definitions for protocol display
  *
- * $Id: proto.h,v 1.12 2001/06/05 07:38:35 guy Exp $
+ * $Id: proto.h,v 1.13 2001/06/18 02:18:24 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -102,7 +102,12 @@ struct _header_field_info {
        header_field_info               *same_name_prev; /* Link to previous hfinfo with same abbrev*/
 };
 
-
+/*
+ * HFILL initializes all the "set by proto routines" fields in a
+ * "header_field_info"; if new fields are added or removed, it should
+ * be changed as necessary.
+ */
+#define HFILL 0, 0, 0, NULL, NULL
 
 /* Used when registering many fields at once */
 typedef struct hf_register_info {
index 09c1c8fa85aa0b02e52769481c839abf027f08f0..c6555a3922a7cf70df26cc78b5f6ed1498665628 100755 (executable)
@@ -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()
index 2556cc0f2192bc72282e309a76e7be600bb92b8e..5a26ddbca9125aa884b46b34dcab482ac5878d68 100755 (executable)
@@ -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())
index 0619e746bc2291a4e57401e2274d01ef05d3f408..a105d0e8e771c13072f6091bc0364c67058570c5 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-aarp.c
  * Routines for Appletalk ARP packet disassembly
  *
- * $Id: packet-aarp.c,v 1.30 2001/03/15 09:11:00 guy Exp $
+ * $Id: packet-aarp.c,v 1.31 2001/06/18 02:17:44 guy Exp $
  *
  * Simon Wilkinson <sxw@dcs.ed.ac.uk>
  *
@@ -232,47 +232,47 @@ proto_register_aarp(void)
     { &hf_aarp_hard_type,
       { "Hardware type",       "aarp.hard.type",       
        FT_UINT16,      BASE_HEX,       VALS(hrd_vals), 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_aarp_proto_type,
       { "Protocol type",       "aarp.proto.type",      
        FT_UINT16,      BASE_HEX,       VALS(etype_vals),       0x0,
-       "" }},    
+       "", HFILL }},    
 
     { &hf_aarp_hard_size,
       { "Hardware size",       "aarp.hard.size",       
        FT_UINT8,       BASE_DEC,       NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_aarp_proto_size,
       { "Protocol size",       "aarp.proto.size",      
        FT_UINT8,       BASE_DEC,       NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_aarp_opcode,
       { "Opcode",              "aarp.opcode",
        FT_UINT16,      BASE_DEC,       VALS(op_vals),  0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_aarp_src_ether,
       { "Sender ether",                "aarp.src.ether",
        FT_BYTES,       BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_aarp_src_id,
       { "Sender ID",           "aarp.src.id",
        FT_BYTES,       BASE_HEX,       NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_aarp_dst_ether,
       { "Target ether",                "aarp.dst.ether",
        FT_BYTES,       BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_aarp_dst_id,
       { "Target ID",           "aarp.dst.id",          
        FT_BYTES,       BASE_HEX,       NULL,   0x0,
-       "" }},
+       "", HFILL }},
   };
   static gint *ett[] = {
     &ett_aarp,
index 42fc1c81e5be6398b9146cc3d217d117a61b5eea..4f03d216dbe346208815da3d3fceb88b2006ccce 100644 (file)
@@ -8,7 +8,7 @@
  * Portions based on information/specs retrieved from the OpenAFS sources at
  *   www.openafs.org, Copyright IBM. 
  *
- * $Id: packet-afs-register-info.h,v 1.7 2001/03/26 15:27:55 nneul Exp $
+ * $Id: packet-afs-register-info.h,v 1.8 2001/06/18 02:17:44 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
  */
 
 { &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 }},
 
 
 
index 5598da46a7753f6a3ab8f335b4264991f2b7fd4e..77214e7dcd19135a006e37024a5d50f923611c33 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for AIM Instant Messenger (OSCAR) dissection
  * Copyright 2000, Ralf Hoelzer <ralf@well.com>
  *
- * $Id: packet-aim.c,v 1.8 2001/04/20 20:34:28 guy Exp $
+ * $Id: packet-aim.c,v 1.9 2001/06/18 02:17:44 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -576,22 +576,22 @@ proto_register_aim(void)
 /* Setup list of header fields */
   static hf_register_info hf[] = {
     { &hf_aim_cmd_start,
-      { "Command Start", "aim.cmd_start", FT_UINT8, BASE_HEX, NULL, 0x0, "" }
+      { "Command Start", "aim.cmd_start", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }
     },
     { &hf_aim_channel,
-      { "Channel ID", "aim.channel", FT_UINT8, BASE_HEX, NULL, 0x0, "" }
+      { "Channel ID", "aim.channel", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }
     },
     { &hf_aim_seqno,
-      { "Sequence Number", "aim.seqno", FT_UINT16, BASE_DEC, NULL, 0x0, "" }
+      { "Sequence Number", "aim.seqno", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }
     },
     { &hf_aim_data_len,
-      { "Data Field Length", "aim.datalen", FT_UINT16, BASE_DEC, NULL, 0x0, "" }
+      { "Data Field Length", "aim.datalen", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }
     },
     { &hf_aim_fnac_family,
-      { "FNAC Family ID", "aim.fnac.family", FT_UINT16, BASE_HEX, NULL, 0x0, "" }
+      { "FNAC Family ID", "aim.fnac.family", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }
     },
     { &hf_aim_fnac_subtype,
-      { "FNAC Subtype ID", "aim.fnac.subtype", FT_UINT16, BASE_HEX, NULL, 0x0, "" }
+      { "FNAC Subtype ID", "aim.fnac.subtype", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }
     },
   };
 
index e95a76d25cab883bdf328a8712c0b21bba348316..62a20d5255456d56cb1fb1ce7335cceb890af33e 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-arp.c
  * Routines for ARP packet disassembly
  *
- * $Id: packet-arp.c,v 1.43 2001/03/13 21:34:23 gram Exp $
+ * $Id: packet-arp.c,v 1.44 2001/06/18 02:17:44 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -806,127 +806,127 @@ proto_register_arp(void)
     { &hf_arp_hard_type,
       { "Hardware type",               "arp.hw.type",   
        FT_UINT16,      BASE_HEX,       VALS(hrd_vals), 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_arp_proto_type,
       { "Protocol type",               "arp.proto.type",
        FT_UINT16,      BASE_HEX,       VALS(etype_vals),       0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_arp_hard_size,
       { "Hardware size",               "arp.hw.size",
        FT_UINT8,       BASE_DEC,       NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_sht,
       { "Sender ATM number type",      "arp.src.htype",
        FT_BOOLEAN,     8,              &type_bit,      ATMARP_IS_E164,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_shl,
       { "Sender ATM number length",    "arp.src.hlen",
        FT_UINT8,       BASE_DEC,       NULL,           ATMARP_LEN_MASK,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_sst,
       { "Sender ATM subaddress type",  "arp.src.stype",
        FT_BOOLEAN,     8,              &type_bit,      ATMARP_IS_E164,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_ssl,
       { "Sender ATM subaddress length",        "arp.src.slen",
        FT_UINT8,       BASE_DEC,       NULL,           ATMARP_LEN_MASK,
-       "" }},
+       "", HFILL }},
 
     { &hf_arp_proto_size,
       { "Protocol size",               "arp.proto.size",
        FT_UINT8,       BASE_DEC,       NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_arp_opcode,
       { "Opcode",                      "arp.opcode",
        FT_UINT16,      BASE_HEX,       VALS(op_vals),  0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_spln,
       { "Sender protocol size",                "arp.src.pln",
        FT_UINT8,       BASE_DEC,       NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_tht,
       { "Target ATM number type",      "arp.dst.htype",
        FT_BOOLEAN,     8,              &type_bit,      ATMARP_IS_E164,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_thl,
       { "Target ATM number length",    "arp.dst.hlen",
        FT_UINT8,       BASE_DEC,       NULL,           ATMARP_LEN_MASK,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_tst,
       { "Target ATM subaddress type",  "arp.dst.stype",
        FT_BOOLEAN,     8,              &type_bit,      ATMARP_IS_E164,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_tsl,
       { "Target ATM subaddress length",        "arp.dst.slen",
        FT_UINT8,       BASE_DEC,       NULL,           ATMARP_LEN_MASK,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_tpln,
       { "Target protocol size",                "arp.dst.pln",
        FT_UINT8,       BASE_DEC,       NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_arp_src_ether,
       { "Sender hardware address",     "arp.src.hw",
        FT_BYTES,       BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_src_atm_num_e164,
       { "Sender ATM number (E.164)",   "arp.src.atm_num_e164",
        FT_STRING,      BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_src_atm_num_nsap,
       { "Sender ATM number (NSAP)",    "arp.src.atm_num_nsap",
        FT_BYTES,       BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_src_atm_subaddr,
       { "Sender ATM subaddress",       "arp.src.atm_subaddr",
        FT_BYTES,       BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_arp_src_proto,
       { "Sender protocol address",     "arp.src.proto", 
        FT_BYTES,       BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_arp_dst_ether,
       { "Target hardware address",     "arp.dst.hw",
        FT_BYTES,       BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_dst_atm_num_e164,
       { "Target ATM number (E.164)",   "arp.dst.atm_num_e164",
        FT_STRING,      BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_dst_atm_num_nsap,
       { "Target ATM number (NSAP)",    "arp.dst.atm_num_nsap",
        FT_BYTES,       BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_atmarp_dst_atm_subaddr,
       { "Target ATM subaddress",       "arp.dst.atm_subaddr",
        FT_BYTES,       BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_arp_dst_proto,
       { "Target protocol address",     "arp.dst.proto", 
        FT_BYTES,       BASE_NONE,      NULL,   0x0,
-      "" }}
+      "", HFILL }}
   };
   static gint *ett[] = {
     &ett_arp,
index ce351ce6b283a3d2fac242c081a56cb54f271d90..b0b5d40b73223d35f24b3633397c3207e59fd816 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-ascend.c
  * Routines for decoding Lucent/Ascend packet traces
  *
- * $Id: packet-ascend.c,v 1.25 2001/03/30 06:10:54 guy Exp $
+ * $Id: packet-ascend.c,v 1.26 2001/06/18 02:17:44 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -113,27 +113,27 @@ proto_register_ascend(void)
   static hf_register_info hf[] = {
     { &hf_link_type,
     { "Link type",     "ascend.type",  FT_UINT32, BASE_DEC,    VALS(encaps_vals),      0x0,
-      "" }},
+      "", HFILL }},
 
     { &hf_session_id,
     { "Session ID",    "ascend.sess",  FT_UINT32, BASE_DEC,    NULL, 0x0,
-      "" }},
+      "", HFILL }},
 
     { &hf_called_number,
     { "Called number", "ascend.number", FT_STRING, BASE_NONE,  NULL, 0x0,
-      "" }},
+      "", HFILL }},
 
     { &hf_chunk,
     { "WDD Chunk",     "ascend.chunk", FT_UINT32, BASE_HEX,    NULL, 0x0,
-      "" }},
+      "", HFILL }},
 
     { &hf_task,
     { "Task",          "ascend.task",  FT_UINT32, BASE_HEX,    NULL, 0x0,
-      "" }},
+      "", HFILL }},
 
     { &hf_user_name,
     { "User name",             "ascend.user",  FT_STRING, BASE_NONE,   NULL, 0x0,
-      "" }},
+      "", HFILL }},
   };
   static gint *ett[] = {
     &ett_raw,
index 9a2bb39acdee59710d3602080df97c95f285a749..98a91c767c26f5060bc3b9c5cd30d771e3671468 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-atalk.c
  * Routines for Appletalk packet disassembly (DDP, currently).
  *
- * $Id: packet-atalk.c,v 1.54 2001/04/27 01:27:36 guy Exp $
+ * $Id: packet-atalk.c,v 1.55 2001/06/18 02:17:44 guy Exp $
  *
  * Simon Wilkinson <sxw@dcs.ed.ac.uk>
  *
@@ -427,106 +427,106 @@ proto_register_atalk(void)
   static hf_register_info hf_ddp[] = {
     { &hf_ddp_hopcount,
       { "Hop count",           "ddp.hopcount", FT_UINT8,  BASE_DEC, NULL, 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_ddp_len,
       { "Datagram length",     "ddp.len",      FT_UINT16, BASE_DEC, NULL, 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_ddp_checksum,
       { "Checksum",            "ddp.checksum", FT_UINT16, BASE_DEC, NULL, 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_ddp_dst_net,
       { "Destination Net",     "ddp.dst.net",  FT_UINT16, BASE_DEC, NULL, 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_ddp_src_net,
       { "Source Net",          "ddp.src.net",  FT_UINT16, BASE_DEC, NULL, 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_ddp_dst_node,
       { "Destination Node",    "ddp.dst.node", FT_UINT8,  BASE_DEC, NULL, 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_ddp_src_node,
       { "Source Node",         "ddp.src.node", FT_UINT8,  BASE_DEC, NULL, 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_ddp_dst_socket,
       { "Destination Socket",  "ddp.dst.socket", FT_UINT8,  BASE_DEC, NULL, 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_ddp_src_socket,
       { "Source Socket",               "ddp.src.socket", FT_UINT8,  BASE_DEC, NULL, 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_ddp_type,
       { "Protocol type",               "ddp.type",     FT_UINT8,  BASE_DEC, VALS(op_vals), 0x0,
-       "" }},
+       "", HFILL }},
   };
 
   static hf_register_info hf_nbp[] = {
     { &hf_nbp_op,
       { "Operation",           "nbp.op",       FT_UINT8,  BASE_DEC, 
-               VALS(nbp_op_vals), 0xF0, "Operation" }},
+               VALS(nbp_op_vals), 0xF0, "Operation", HFILL }},
     { &hf_nbp_info,
       { "Info",                "nbp.info",     FT_UINT8,  BASE_HEX, 
-               NULL, 0x0, "Info" }},
+               NULL, 0x0, "Info", HFILL }},
     { &hf_nbp_count,
       { "Count",               "nbp.count",    FT_UINT8,  BASE_DEC, 
-               NULL, 0x0F, "Count" }},
+               NULL, 0x0F, "Count", HFILL }},
     { &hf_nbp_node_net,
       { "Network",             "nbp.net",      FT_UINT16,  BASE_DEC, 
-               NULL, 0x0, "Network" }},
+               NULL, 0x0, "Network", HFILL }},
     { &hf_nbp_node_node,
       { "Node",                "nbp.node",     FT_UINT8,  BASE_DEC, 
-               NULL, 0x0, "Node" }},
+               NULL, 0x0, "Node", HFILL }},
     { &hf_nbp_node_port,
       { "Port",                "nbp.port",     FT_UINT8,  BASE_DEC, 
-               NULL, 0x0, "Port" }},
+               NULL, 0x0, "Port", HFILL }},
     { &hf_nbp_node_enum,
       { "Enumerator",          "nbp.enum",     FT_UINT8,  BASE_DEC, 
-               NULL, 0x0, "Enumerator" }},
+               NULL, 0x0, "Enumerator", HFILL }},
     { &hf_nbp_node_object,
       { "Object",              "nbp.object",   FT_STRING,  BASE_DEC, 
-               NULL, 0x0, "Object" }},
+               NULL, 0x0, "Object", HFILL }},
     { &hf_nbp_node_type,
       { "Type",                "nbp.type",     FT_STRING,  BASE_DEC, 
-               NULL, 0x0, "Type" }},
+               NULL, 0x0, "Type", HFILL }},
     { &hf_nbp_node_zone,
       { "Zone",                "nbp.zone",     FT_STRING,  BASE_DEC, 
-               NULL, 0x0, "Zone" }},
+               NULL, 0x0, "Zone", HFILL }},
     { &hf_nbp_tid,
       { "Transaction ID",              "nbp.tid",      FT_UINT8,  BASE_DEC, 
-               NULL, 0x0, "Transaction ID" }}
+               NULL, 0x0, "Transaction ID", HFILL }}
   };
 
   static hf_register_info hf_rtmp[] = {
     { &hf_rtmp_net,
       { "Net",         "rtmp.net",     FT_UINT16,  BASE_DEC, 
-               NULL, 0x0, "Net" }},
+               NULL, 0x0, "Net", HFILL }},
     { &hf_rtmp_node,
       { "Node",                "nbp.nodeid",   FT_UINT8,  BASE_DEC, 
-               NULL, 0x0, "Node" }},
+               NULL, 0x0, "Node", HFILL }},
     { &hf_rtmp_node_len,
       { "Node Length",         "nbp.nodeid.length",    FT_UINT8,  BASE_DEC, 
-               NULL, 0x0, "Node Length" }},
+               NULL, 0x0, "Node Length", HFILL }},
     { &hf_rtmp_tuple_net,
       { "Net",         "rtmp.tuple.net",       FT_UINT16,  BASE_DEC, 
-               NULL, 0x0, "Net" }},
+               NULL, 0x0, "Net", HFILL }},
     { &hf_rtmp_tuple_range_start,
       { "Range Start",         "rtmp.tuple.range_start",       FT_UINT16,  BASE_DEC, 
-               NULL, 0x0, "Range Start" }},
+               NULL, 0x0, "Range Start", HFILL }},
     { &hf_rtmp_tuple_range_end,
       { "Range End",           "rtmp.tuple.range_end", FT_UINT16,  BASE_DEC, 
-               NULL, 0x0, "Range End" }},
+               NULL, 0x0, "Range End", HFILL }},
     { &hf_rtmp_tuple_dist,
       { "Distance",            "rtmp.tuple.dist",      FT_UINT16,  BASE_DEC, 
-               NULL, 0x0, "Distance" }},
+               NULL, 0x0, "Distance", HFILL }},
     { &hf_rtmp_function,
       { "Function",            "rtmp.function",        FT_UINT8,  BASE_DEC, 
-               VALS(rtmp_function_vals), 0x0, "Request Function" }}
+               VALS(rtmp_function_vals), 0x0, "Request Function", HFILL }}
   };
 
 
index a4bbde3801fd5d09476af9b5db8d239b87a6aa7d..0304a30613ba3c535dbfe14f0ddc0665282618cd 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-atm.c
  * Routines for ATM packet disassembly
  *
- * $Id: packet-atm.c,v 1.35 2001/05/27 07:46:57 guy Exp $
+ * $Id: packet-atm.c,v 1.36 2001/06/18 02:17:44 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -765,11 +765,11 @@ proto_register_atm(void)
        static hf_register_info hf[] = {
                { &hf_atm_vpi,
                { "VPI",                "atm.vpi", FT_UINT8, BASE_DEC, NULL, 0x0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_atm_vci,
                { "VCI",                "atm.vci", FT_UINT16, BASE_DEC, NULL, 0x0,
-                       "" }},
+                       "", HFILL }},
        };
        static gint *ett[] = {
                &ett_atm,
index 8c1375308590ad288e2ef288543040a5783078ea..ca113e983630795068f88d79d4b5f1429793f043 100644 (file)
@@ -4,7 +4,7 @@
  *
  * Heikki Vatiainen <hessu@cs.tut.fi>
  *
- * $Id: packet-auto_rp.c,v 1.13 2001/01/25 06:14:13 guy Exp $
+ * $Id: packet-auto_rp.c,v 1.14 2001/06/18 02:17:44 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -182,47 +182,47 @@ void proto_register_auto_rp(void)
                 { &hf_auto_rp_version,
                   {"Protocol version", "auto_rp.version",
                    FT_UINT8, BASE_DEC, VALS(auto_rp_ver_vals), AUTO_RP_VERSION_MASK,
-                   "Auto-RP protocol version"}},
+                   "Auto-RP protocol version", HFILL }},
 
                 { &hf_auto_rp_type,
                   {"Packet type", "auto_rp.type",
                    FT_UINT8, BASE_DEC, VALS(auto_rp_type_vals), AUTO_RP_TYPE_MASK,
-                   "Auto-RP packet type"}},
+                   "Auto-RP packet type", HFILL }},
 
                 { &hf_auto_rp_count,
                   {"RP count", "auto_rp.rp_count",
                    FT_UINT8, BASE_DEC, NULL, 0,
-                   "The number of RP addresses contained in this message"}},
+                   "The number of RP addresses contained in this message", HFILL }},
 
                 { &hf_auto_rp_holdtime,
                   {"Holdtime", "auto_rp.holdtime",
                    FT_UINT16, BASE_DEC, NULL, 0,
-                   "The amount of time in seconds this announcement is valid"}},
+                   "The amount of time in seconds this announcement is valid", HFILL }},
 
                 { &hf_auto_rp_pim_ver,
                   {"Version", "auto_rp.pim_ver",
                    FT_UINT8, BASE_DEC, VALS(auto_rp_pim_ver_vals), AUTO_RP_PIM_VER_MASK,
-                   "RP's highest PIM version"}},
+                   "RP's highest PIM version", HFILL }},
 
                 { &hf_auto_rp_rp_addr,
                   {"RP address", "auto_rp.rp_addr",
                    FT_IPv4, 0, NULL, 0,
-                   "The unicast IP address of the RP"}},
+                   "The unicast IP address of the RP", HFILL }},
 
                 { &hf_auto_rp_prefix_sgn,
                   {"Sign", "auto_rp.prefix_sign",
                    FT_UINT8, BASE_DEC, VALS(auto_rp_mask_sign_vals), AUTO_RP_SIGN_MASK,
-                   "Group prefix sign"}},
+                   "Group prefix sign", HFILL }},
 
                 { &hf_auto_rp_mask_len,
                   {"Mask length", "auto_rp.mask_len",
                    FT_UINT8, BASE_BIN, NULL, 0x0,
-                   "Length of group prefix"}},
+                   "Length of group prefix", HFILL }},
 
                 { &hf_auto_rp_group_prefix,
                   {"Prefix", "auto_rp.group_prefix",
                    FT_IPv4, 0, NULL, 0,
-                   "Group prefix"}}
+                   "Group prefix", HFILL }}
         };
 
         static gint *ett[] = {
index f455c604160ccb8fd4bf13367ed74c2ed479776f..44dc7efb446a8a876e6f838b0ef3af8260be7a82 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for BACnet (APDU) dissection
  * Copyright 2001, Hartmut Mueller <hartmut@abmlinux.org>, FH Dortmund
  *
- * $Id: packet-bacapp.c,v 1.3 2001/05/30 07:48:23 guy Exp $
+ * $Id: packet-bacapp.c,v 1.4 2001/06/18 02:17:44 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -111,7 +111,7 @@ proto_register_bacapp(void)
        static hf_register_info hf[] = {
                { &hf_bacapp_type,
                        { "APDU Type",           "bacapp.bacapp_type",
-                       FT_UINT8, BASE_DEC, NULL, 0xf0, "APDU Type" }
+                       FT_UINT8, BASE_DEC, NULL, 0xf0, "APDU Type", HFILL }
                },
        };
        static gint *ett[] = {
index c5ea2731b69832dd2838a1944356d8ffd50284f3..a583bdba666ea3762c2f1e19200310a0e9b08e06 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for BACnet (NPDU) dissection
  * Copyright 2001, Hartmut Mueller <hartmut@abmlinux.org>, FH Dortmund
  *
- * $Id: packet-bacnet.c,v 1.3 2001/05/30 07:48:23 guy Exp $
+ * $Id: packet-bacnet.c,v 1.4 2001/06/18 02:17:44 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -438,145 +438,145 @@ proto_register_bacnet(void)
                { &hf_bacnet_version,
                        { "Version",           "bacnet.version",
                        FT_UINT8, BASE_DEC, NULL, 0,
-                       "BACnet Version" }
+                       "BACnet Version", HFILL }
                },
                { &hf_bacnet_control,
                        { "Control",           "bacnet.control",
                        FT_UINT8, BASE_HEX, NULL, 0xff,
-                       "BACnet Control" }
+                       "BACnet Control", HFILL }
                },
                { &hf_bacnet_control_net,
                        { "NSDU contains",           
                        "bacnet.control_net",
                        FT_BOOLEAN, 8, TFS(&control_net_set_high),
-                       BAC_CONTROL_NET, "BACnet Control" }
+                       BAC_CONTROL_NET, "BACnet Control", HFILL }
                },
                { &hf_bacnet_control_res1,
                        { "Reserved",           
                        "bacnet.control_res1",
                        FT_BOOLEAN, 8, TFS(&control_res_high),
-                       BAC_CONTROL_RES1, "BACnet Control" }
+                       BAC_CONTROL_RES1, "BACnet Control", HFILL }
                },
                { &hf_bacnet_control_dest,
                        { "Destination Specifier",           
                        "bacnet.control_dest",
                        FT_BOOLEAN, 8, TFS(&control_dest_high),
-                       BAC_CONTROL_DEST, "BACnet Control" }
+                       BAC_CONTROL_DEST, "BACnet Control", HFILL }
                },
                { &hf_bacnet_control_res2,
                        { "Reserved",           
                        "bacnet.control_res2",
                        FT_BOOLEAN, 8, TFS(&control_res_high),
-                       BAC_CONTROL_RES2, "BACnet Control" }
+                       BAC_CONTROL_RES2, "BACnet Control", HFILL }
                },
                { &hf_bacnet_control_src,
                        { "Source specifier",           
                        "bacnet.control_src",
                        FT_BOOLEAN, 8, TFS(&control_src_high),
-                       BAC_CONTROL_SRC, "BACnet Control" }
+                       BAC_CONTROL_SRC, "BACnet Control", HFILL }
                },
                { &hf_bacnet_control_expect,
                        { "Expecting Reply",           
                        "bacnet.control_expect",
                        FT_BOOLEAN, 8, TFS(&control_expect_high),
-                       BAC_CONTROL_EXPECT, "BACnet Control" }
+                       BAC_CONTROL_EXPECT, "BACnet Control", HFILL }
                },
                { &hf_bacnet_control_prio_high,
                        { "Priority",           
                        "bacnet.control_prio_high",
                        FT_BOOLEAN, 8, TFS(&control_prio_high_high),
-                       BAC_CONTROL_PRIO_HIGH, "BACnet Control" }
+                       BAC_CONTROL_PRIO_HIGH, "BACnet Control", HFILL }
                },
                { &hf_bacnet_control_prio_low,
                        { "Priority",           
                        "bacnet.control_prio_low",
                        FT_BOOLEAN, 8, TFS(&control_prio_low_high),
-                       BAC_CONTROL_PRIO_LOW, "BACnet Control" }
+                       BAC_CONTROL_PRIO_LOW, "BACnet Control", HFILL }
                },
                { &hf_bacnet_dnet,
                        { "Destination Network Address", "bacnet.dnet",
                        FT_UINT16, BASE_HEX, NULL, 0,
-                       "Destination Network Address" }
+                       "Destination Network Address", HFILL }
                },
                { &hf_bacnet_dlen,
                        { "Destination MAC Layer Address Length", "bacnet.dlen",
                        FT_UINT8, BASE_DEC, NULL, 0,
-                       "Destination MAC Layer Address Length" }
+                       "Destination MAC Layer Address Length", HFILL }
                },
                { &hf_bacnet_dadr_eth,
                        { "Destination ISO 8802-3 MAC Address", "bacnet.dadr_eth",
                        FT_ETHER, BASE_HEX, NULL, 0,
-                       "Destination ISO 8802-3 MAC Address" }
+                       "Destination ISO 8802-3 MAC Address", HFILL }
                },
                { &hf_bacnet_dadr_tmp,
                        { "Unknown Destination MAC", "bacnet.dadr_tmp",
                        FT_BYTES, BASE_HEX, NULL, 0,
-                       "Unknown Destination MAC" }
+                       "Unknown Destination MAC", HFILL }
                },
                { &hf_bacnet_snet,
                        { "Source Network Address", "bacnet.snet",
                        FT_UINT16, BASE_HEX, NULL, 0,
-                       "Source Network Address" }
+                       "Source Network Address", HFILL }
                },
                { &hf_bacnet_slen,
                        { "Source MAC Layer Address Length", "bacnet.slen",
                        FT_UINT8, BASE_DEC, NULL, 0,
-                       "Source MAC Layer Address Length" }
+                       "Source MAC Layer Address Length", HFILL }
                },
                { &hf_bacnet_sadr_eth,
                        { "SADR", "bacnet.sadr_eth",
                        FT_ETHER, BASE_HEX, NULL, 0,
-                       "Source ISO 8802-3 MAC Address" }
+                       "Source ISO 8802-3 MAC Address", HFILL }
                },
                { &hf_bacnet_sadr_tmp,
                        { "Unknown Source MAC", "bacnet.sadr_tmp",
                        FT_BYTES, BASE_HEX, NULL, 0,
-                       "Unknown Source MAC" }
+                       "Unknown Source MAC", HFILL }
                },
                { &hf_bacnet_hopc,
                        { "Hop Count", "bacnet.hopc",
                        FT_UINT8, BASE_DEC, NULL, 0,
-                       "Hop Count" }
+                       "Hop Count", HFILL }
                },
                { &hf_bacnet_mesgtyp,
                        { "Message Type", "bacnet.mesgtyp",
                        FT_UINT8, BASE_HEX, NULL, 0,
-                       "Message Type" }
+                       "Message Type", HFILL }
                },
                { &hf_bacnet_vendor,
                        { "Vendor ID", "bacnet.vendor",
                        FT_UINT16, BASE_HEX, NULL, 0,
-                       "Vendor ID" }
+                       "Vendor ID", HFILL }
                },
                { &hf_bacnet_perf,
                        { "Performance Index", "bacnet.perf",
                        FT_UINT8, BASE_DEC, NULL, 0,
-                       "Performance Index" }
+                       "Performance Index", HFILL }
                },
                { &hf_bacnet_rejectreason,
                        { "Reject Reason", "bacnet.rejectreason",
                        FT_UINT8, BASE_DEC, NULL, 0,
-                       "Reject Reason" }
+                       "Reject Reason", HFILL }
                },
                { &hf_bacnet_rportnum,
                        { "Number of Port Mappings", "bacnet.rportnum",
                        FT_UINT8, BASE_DEC, NULL, 0,
-                       "Number of Port Mappings" }
+                       "Number of Port Mappings", HFILL }
                },
                { &hf_bacnet_pinfolen,
                        { "Port Info Length", "bacnet.pinfolen",
                        FT_UINT8, BASE_DEC, NULL, 0,
-                       "Port Info Length" }
+                       "Port Info Length", HFILL }
                },
                { &hf_bacnet_portid,
                        { "Port ID", "bacnet.portid",
                        FT_UINT8, BASE_HEX, NULL, 0,
-                       "Port ID" }
+                       "Port ID", HFILL }
                },
                { &hf_bacnet_pinfo,
                        { "Port Info", "bacnet.pinfo",
                        FT_UINT8, BASE_HEX, NULL, 0,
-                       "Port Info" }
+                       "Port Info", HFILL }
                },
        };
 
index 18a9d7c5a63bdaa3adebda082e13d3e3ee71a965..08e6d285a40e02d52797d8d0fa60801e0878a6ac 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for BGP packet dissection.
  * Copyright 1999, Jun-ichiro itojun Hagino <itojun@itojun.org>
  *
- * $Id: packet-bgp.c,v 1.40 2001/06/15 08:01:31 guy Exp $
+ * $Id: packet-bgp.c,v 1.41 2001/06/18 02:17:44 guy Exp $
  *
  * Supports:
  * RFC1771 A Border Gateway Protocol 4 (BGP-4)
@@ -1701,7 +1701,7 @@ proto_register_bgp(void)
     static hf_register_info hf[] = {
       { &hf_bgp_type,
        { "BGP message type", "bgp.type", FT_UINT8, BASE_HEX,
-         VALS(bgptypevals), 0x0, "BGP message type" }},
+         VALS(bgptypevals), 0x0, "BGP message type", HFILL }},
     };
 
     static gint *ett[] = {
index 21ab5f2c7eb078feb6f9d592e7137220de8e9cd2..74d123954b08c4f81c9c443539d9cbebec4ba490 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for BOOTP/DHCP packet disassembly
  * Gilbert Ramirez <gram@xiexie.org>
  *
- * $Id: packet-bootp.c,v 1.53 2001/05/25 06:56:53 guy Exp $
+ * $Id: packet-bootp.c,v 1.54 2001/06/18 02:17:45 guy Exp $
  *
  * The information used comes from:
  * RFC  951: Bootstrap Protocol
@@ -1178,82 +1178,82 @@ proto_register_bootp(void)
     { &hf_bootp_dhcp,
       { "Frame is DHCP",                "bootp.dhcp",    FT_BOOLEAN,
         BASE_NONE,                     NULL,            0x0,
-        "" }},                            
+        "", HFILL }},                            
                       
     { &hf_bootp_type,
       { "Message type",                        "bootp.type",    FT_UINT8,
          BASE_DEC,                     VALS(op_vals),   0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_hw_type,
       { "Hardware type",               "bootp.hw.type", FT_UINT8,
         BASE_HEX,                      NULL,            0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_hw_len,
       { "Hardware address length",     "bootp.hw.len",  FT_UINT8,
         BASE_DEC,                      NULL,            0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_hops,
       { "Hops",                                "bootp.hops",    FT_UINT8,
         BASE_DEC,                      NULL,            0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_id,
       { "Transaction ID",              "bootp.id",      FT_UINT32,
         BASE_HEX,                       NULL,           0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_secs,
       { "Seconds elapsed",             "bootp.secs",    FT_UINT16,
         BASE_DEC,                       NULL,           0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_flag,
       { "Broadcast flag",              "bootp.flag",    FT_UINT16,
         BASE_HEX,                      NULL,            0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_ip_client,
       { "Client IP address",           "bootp.ip.client",FT_IPv4,
         BASE_NONE,                     NULL,             0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_ip_your,
       { "Your (client) IP address",    "bootp.ip.your",  FT_IPv4,
         BASE_NONE,                     NULL,             0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_ip_server,
       { "Next server IP address",      "bootp.ip.server",FT_IPv4,
         BASE_NONE,                     NULL,             0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_ip_relay,
       { "Relay agent IP address",      "bootp.ip.relay", FT_IPv4,
         BASE_NONE,                     NULL,             0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_hw_addr,
       { "Client hardware address",     "bootp.hw.addr", FT_BYTES,
         BASE_NONE,                     NULL,            0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_server,
       { "Server host name",            "bootp.server",  FT_STRING,
         BASE_NONE,                     NULL,            0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_file,
       { "Boot file name",              "bootp.file",    FT_STRING,
         BASE_NONE,                     NULL,            0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_bootp_cookie,
       { "Magic cookie",                        "bootp.cookie",  FT_IPv4,
          BASE_NONE,                    NULL,            0x0,
-       "" }},
+       "", HFILL }},
   };
   static gint *ett[] = {
     &ett_bootp,
index d2ae45bf3810ea33b382a7e6a07cd58b100b8a80..8eb3495190674a3b09e0b8cd852ec93e045e7489 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-bootparams.c
  * Routines for bootparams dissection
  *
- * $Id: packet-bootparams.c,v 1.18 2001/05/30 06:01:01 guy Exp $
+ * $Id: packet-bootparams.c,v 1.19 2001/06/18 02:17:45 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -159,25 +159,25 @@ proto_register_bootparams(void)
        static hf_register_info hf[] = {
                { &hf_bootparams_host, {
                        "Client Host", "bootparams.host", FT_STRING, BASE_DEC,
-                       NULL, 0, "Client Host" }},
+                       NULL, 0, "Client Host", HFILL }},
                { &hf_bootparams_domain, {
                        "Client Domain", "bootparams.domain", FT_STRING, BASE_DEC,
-                       NULL, 0, "Client Domain" }},
+                       NULL, 0, "Client Domain", HFILL }},
                { &hf_bootparams_fileid, {
                        "File ID", "bootparams.fileid", FT_STRING, BASE_DEC,
-                       NULL, 0, "File ID" }},
+                       NULL, 0, "File ID", HFILL }},
                { &hf_bootparams_filepath, {
                        "File Path", "bootparams.filepath", FT_STRING, BASE_DEC,
-                       NULL, 0, "File Path" }},
+                       NULL, 0, "File Path", HFILL }},
                { &hf_bootparams_hostaddr, {
                        "Client Address", "bootparams.hostaddr", FT_IPv4, BASE_DEC,
-                       NULL, 0, "Address" }},
+                       NULL, 0, "Address", HFILL }},
                { &hf_bootparams_routeraddr, {
                        "Router Address", "bootparams.routeraddr", FT_IPv4, BASE_DEC,
-                       NULL, 0, "Router Address" }},
+                       NULL, 0, "Router Address", HFILL }},
                { &hf_bootparams_addresstype, {
                        "Address Type", "bootparams.type", FT_UINT32, BASE_DEC,
-                       VALS(addr_type), 0, "Address Type" }},
+                       VALS(addr_type), 0, "Address Type", HFILL }},
        };
        static gint *ett[] = {
                &ett_bootparams,
index 4265a77628375af92c9216b0b83541004356ab34..0d86b92884944d2b25a41faaf598dec0237d223c 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-bpdu.c
  * Routines for BPDU (Spanning Tree Protocol) disassembly
  *
- * $Id: packet-bpdu.c,v 1.25 2001/05/27 07:07:34 guy Exp $
+ * $Id: packet-bpdu.c,v 1.26 2001/06/18 02:17:45 guy Exp $
  *
  * Copyright 1999 Christophe Tronche <ch.tronche@computer.org>
  * 
@@ -275,51 +275,51 @@ proto_register_bpdu(void)
     { &hf_bpdu_proto_id,
       { "Protocol Identifier",         "stp.protocol",
        FT_UINT16,      BASE_HEX,       NULL,   0x0,
-       "" }},
+       "", HFILL }},
     { &hf_bpdu_version_id,
       { "Protocol Version Identifier", "stp.version",
        FT_UINT8,       BASE_DEC,       NULL,   0x0,
-       "" }},
+       "", HFILL }},
     { &hf_bpdu_type,
       { "BPDU type",                   "stp.type",
        FT_UINT8,       BASE_HEX,       NULL,   0x0,
-       "" }},
+       "", HFILL }},
     { &hf_bpdu_flags,
       { "BPDU flags",                  "stp.flags",
        FT_UINT8,       BASE_HEX,       NULL,   0x0,
-       "" }},
+       "", HFILL }},
     { &hf_bpdu_root_mac,
       { "Root Identifier",             "stp.root.hw",
        FT_ETHER,       BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
     { &hf_bpdu_root_cost,
       { "Root Path Cost",              "stp.root.cost",
        FT_UINT32,      BASE_DEC,       NULL,   0x0,
-       "" }},
+       "", HFILL }},
     { &hf_bpdu_bridge_mac,
       { "Bridge Identifier",           "stp.bridge.hw",
        FT_ETHER,       BASE_NONE,      NULL,   0x0,
-       ""}},
+       "", HFILL }},
     { &hf_bpdu_port_id,
       { "Port identifier",             "stp.port",
        FT_UINT16,      BASE_HEX,       NULL,   0x0,
-       ""}},
+       "", HFILL }},
     { &hf_bpdu_msg_age,
       { "Message Age",                 "stp.msg_age",
        FT_DOUBLE,      BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
     { &hf_bpdu_max_age,
       { "Max Age",                     "stp.max_age",
        FT_DOUBLE,      BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
     { &hf_bpdu_hello_time,
       { "Hello Time",                  "stp.hello",
        FT_DOUBLE,      BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
     { &hf_bpdu_forward_delay,
       { "Forward Delay",               "stp.forward",
        FT_DOUBLE,      BASE_NONE,      NULL,   0x0,
-       "" }},
+       "", HFILL }},
   };
   static gint *ett[] = {
     &ett_bpdu,
index 9527f3d7a401d37f34cf90abe8a8465b14de2d38..5dd638f463de2e3e5485ed938501801d6169c2cd 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for BACnet/IP (BVLL, BVLC) dissection
  * Copyright 2001, Hartmut Mueller <hartmut@abmlinux.org>, FH Dortmund
  *
- * $Id: packet-bvlc.c,v 1.3 2001/05/30 07:48:23 guy Exp $
+ * $Id: packet-bvlc.c,v 1.4 2001/06/18 02:17:45 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -304,74 +304,74 @@ proto_register_bvlc(void)
                { &hf_bvlc_type,
                        { "Type",           "bvlc.type",
                        FT_UINT8, BASE_HEX, NULL, 0,
-                       "Type" }
+                       "Type", HFILL }
                },
                { &hf_bvlc_function,
                        { "Function",           "bvlc.function",
                        FT_UINT8, BASE_HEX, NULL, 0,
-                       "BLVC Function" }
+                       "BLVC Function", HFILL }
                },
                { &hf_bvlc_length,
                        { "Length",           "bvlc.length",
                        FT_UINT16, BASE_DEC, NULL, 0,
-                       "Length of BVLC" }
+                       "Length of BVLC", HFILL }
                },
                /* We should bitmask the result correctly when we have a
                 * packet to dissect */
                { &hf_bvlc_result,
                        { "Result",           "bvlc.result",
                        FT_UINT16, BASE_HEX, NULL, 0xffff,
-                       "Result Code" }
+                       "Result Code", HFILL }
                },
                { &hf_bvlc_bdt_ip,
                        { "IP",           "bvlc.bdt_ip",
                        FT_IPv4, BASE_NONE, NULL, 0,
-                       "BDT IP" }
+                       "BDT IP", HFILL }
                },
                { &hf_bvlc_bdt_port,
                        { "Port",           "bvlc.bdt_port",
                        FT_UINT16, BASE_DEC, NULL, 0,
-                       "BDT Port" }
+                       "BDT Port", HFILL }
                },
                { &hf_bvlc_bdt_mask,
                        { "Mask",           "bvlc.bdt_mask",
                        FT_BYTES, BASE_HEX, NULL, 0,
-                       "BDT Broadcast Distribution Mask" }
+                       "BDT Broadcast Distribution Mask", HFILL }
                },
                { &hf_bvlc_reg_ttl,
                        { "TTL",           "bvlc.reg_ttl",
                        FT_UINT16, BASE_DEC, NULL, 0,
-                       "Foreign Device Time To Live" }
+                       "Foreign Device Time To Live", HFILL }
                },
                { &hf_bvlc_fdt_ip,
                        { "IP",           "bvlc.fdt_ip",
                        FT_IPv4, BASE_NONE, NULL, 0,
-                       "FDT IP" }
+                       "FDT IP", HFILL }
                },
                { &hf_bvlc_fdt_port,
                        { "Port",           "bvlc.fdt_port",
                        FT_UINT16, BASE_DEC, NULL, 0,
-                       "FDT Port" }
+                       "FDT Port", HFILL }
                },
                { &hf_bvlc_fdt_ttl,
                        { "TTL",           "bvlc.fdt_ttl",
                        FT_UINT16, BASE_DEC, NULL, 0,
-                       "Foreign Device Time To Live" }
+                       "Foreign Device Time To Live", HFILL }
                },
                { &hf_bvlc_fdt_timeout,
                        { "Timeout",           "bvlc.fdt_timeout",
                        FT_UINT16, BASE_DEC, NULL, 0,
-                       "Foreign Device Timeout (seconds)" }
+                       "Foreign Device Timeout (seconds)", HFILL }
                },
                { &hf_bvlc_fwd_ip,
                        { "IP",           "bvlc.fwd_ip",
                        FT_IPv4, BASE_NONE, NULL, 0,
-                       "FWD IP" }
+                       "FWD IP", HFILL }
                },
                { &hf_bvlc_fwd_port,
                        { "Port",           "bvlc.fwd_port",
                        FT_UINT16, BASE_DEC, NULL, 0,
-                       "FWD Port" }
+                       "FWD Port", HFILL }
                },
        };
 
index 6df53c345f667316b540ab97d5a9f5fda85a3124..6d8d2a18c52d3611a8866d4ae8b31b31acb6e6d2 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-bxxp.c
  * Routines for BXXP packet disassembly
  *
- * $Id: packet-bxxp.c,v 1.18 2001/04/27 01:27:36 guy Exp $
+ * $Id: packet-bxxp.c,v 1.19 2001/06/18 02:17:45 guy Exp $
  *
  * Copyright (c) 2000 by Richard Sharpe <rsharpe@ns.aus.com>
  *
@@ -1150,58 +1150,58 @@ proto_register_bxxp(void)
 {
   static hf_register_info hf[] = {
     { &hf_bxxp_proto_viol,
-      { "Protocol Violation", "bxxp.violation", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
+      { "Protocol Violation", "bxxp.violation", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_req,
-      { "Request", "bxxp.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
+      { "Request", "bxxp.req", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_req_chan,
-      { "Request Channel Number", "bxxp.req.channel", FT_UINT32, BASE_DEC, NULL, 0x0, ""}},
+      { "Request Channel Number", "bxxp.req.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_rsp,
-      { "Response", "bxxp.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
+      { "Response", "bxxp.rsp", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_rsp_chan,
-      { "Response Channel Number", "bxxp.rsp.channel", FT_UINT32, BASE_DEC, NULL, 0x0, ""}},
+      { "Response Channel Number", "bxxp.rsp.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_seq,
-      { "Sequence", "bxxp.seq", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
+      { "Sequence", "bxxp.seq", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_seq_chan,
-      { "Sequence Channel Number", "bxxp.seq.channel", FT_UINT32, BASE_DEC, NULL, 0x0, ""}},
+      { "Sequence Channel Number", "bxxp.seq.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_end,
-      { "End", "bxxp.end", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
+      { "End", "bxxp.end", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_complete,
-      { "Complete", "bxxp.more.complete", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
+      { "Complete", "bxxp.more.complete", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_intermediate,
-      { "Intermediate", "bxxp.more.intermediate", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "" }},
+      { "Intermediate", "bxxp.more.intermediate", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_serial,
-      { "Serial", "bxxp.serial", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
+      { "Serial", "bxxp.serial", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_seqno,
-      { "Seqno", "bxxp.seqno", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
+      { "Seqno", "bxxp.seqno", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_size,
-      { "Size", "bxxp.size", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
+      { "Size", "bxxp.size", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_channel,
-      { "Channel", "bxxp.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
+      { "Channel", "bxxp.channel", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_negative,
-      { "Negative", "bxxp.status.negative", FT_BOOLEAN, BASE_NONE, NULL, 0x0, ""}},
+      { "Negative", "bxxp.status.negative", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_positive,
-      { "Positive", "bxxp.status.positive", FT_BOOLEAN, BASE_NONE, NULL, 0x0, ""}},
+      { "Positive", "bxxp.status.positive", FT_BOOLEAN, BASE_NONE, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_ackno,
-      { "Ackno", "bxxp.seq.ackno", FT_UINT32, BASE_DEC, NULL, 0x0, ""}},
+      { "Ackno", "bxxp.seq.ackno", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_bxxp_window,
-      { "Window", "bxxp.seq.window", FT_UINT32, BASE_DEC, NULL, 0x0, ""}},
+      { "Window", "bxxp.seq.window", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
 
   };
   static gint *ett[] = {
index 04b39573a80616b23689d153430494a928ba50e4..cb96c4e75b2c5fda1e2b556091c31dc9e85f60f7 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for the disassembly of the "Cisco Discovery Protocol"
  * (c) Copyright Hannes R. Boehm <hannes@boehm.org>
  *
- * $Id: packet-cdp.c,v 1.36 2001/03/15 09:11:00 guy Exp $
+ * $Id: packet-cdp.c,v 1.37 2001/06/18 02:17:45 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -539,23 +539,23 @@ proto_register_cdp(void)
     static hf_register_info hf[] = {
        { &hf_cdp_version,
        { "Version",            "cdp.version",  FT_UINT8, BASE_DEC, NULL, 0x0,
-         "" }},
+         "", HFILL }},
 
        { &hf_cdp_ttl,
        { "TTL",                "cdp.ttl", FT_UINT16, BASE_DEC, NULL, 0x0,
-         "" }},
+         "", HFILL }},
 
        { &hf_cdp_checksum,
        { "Checksum",           "cdp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
-         "" }},
+         "", HFILL }},
 
        { &hf_cdp_tlvtype,
        { "Type",               "cdp.tlv.type", FT_UINT16, BASE_HEX, VALS(type_vals), 0x0,
-         "" }},
+         "", HFILL }},
 
        { &hf_cdp_tlvlength,
        { "Length",             "cdp.tlv.len", FT_UINT16, BASE_DEC, NULL, 0x0,
-         "" }},
+         "", HFILL }},
     };
     static gint *ett[] = {
        &ett_cdp,
index 9a5d50baba3d928a1d221859c761cd0da6323aa6..2fa52de7320760ef909197a500121953f753bfc4 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-cgmp.c
  * Routines for the disassembly of the Cisco Group Management Protocol
  *
- * $Id: packet-cgmp.c,v 1.9 2001/01/25 06:14:13 guy Exp $
+ * $Id: packet-cgmp.c,v 1.10 2001/06/18 02:17:45 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -109,23 +109,23 @@ proto_register_cgmp(void)
        static hf_register_info hf[] = {
                { &hf_cgmp_version,
                { "Version",    "cgmp.version", FT_UINT8, BASE_DEC, NULL, 0xF0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_cgmp_type,
                { "Type",       "cgmp.type",    FT_UINT8, BASE_DEC, VALS(type_vals), 0x0F,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_cgmp_count,
                { "Count",      "cgmp.count", FT_UINT8, BASE_DEC, NULL, 0x0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_cgmp_gda,
                { "Group Destination Address",  "cgmp.gda", FT_ETHER, BASE_NONE, NULL, 0x0,
-                       "Group Destination Address" }},
+                       "Group Destination Address", HFILL }},
 
                { &hf_cgmp_usa,
                { "Unicast Source Address",     "cgmp.usa", FT_ETHER, BASE_NONE, NULL, 0x0,
-                       "Unicast Source Address" }},
+                       "Unicast Source Address", HFILL }},
         };
        static gint *ett[] = {
                &ett_cgmp,
index da78406aa39d1df29a9bdd907fd33dd6f6b3d4ad..12d4ca84ae664a893283a32d8b2296fcc85f6c47 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-chdlc.c
  * Routines for Cisco HDLC packet disassembly
  *
- * $Id: packet-chdlc.c,v 1.3 2001/04/10 14:04:31 guy Exp $
+ * $Id: packet-chdlc.c,v 1.4 2001/06/18 02:17:45 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -168,10 +168,10 @@ proto_register_chdlc(void)
   static hf_register_info hf[] = {
     { &hf_chdlc_addr,
       { "Address", "chdlc.address", FT_UINT8, BASE_HEX,
-        VALS(chdlc_address_vals), 0x0, "" }},
+        VALS(chdlc_address_vals), 0x0, "", HFILL }},
     { &hf_chdlc_proto,
       { "Protocol", "chdlc.protocol", FT_UINT16, BASE_HEX,
-        VALS(chdlc_vals), 0x0, "" }},
+        VALS(chdlc_vals), 0x0, "", HFILL }},
   };
   static gint *ett[] = {
     &ett_chdlc,
@@ -278,18 +278,18 @@ proto_register_slarp(void)
   static hf_register_info hf[] = {
     { &hf_slarp_ptype,
       { "Packet type", "slarp.ptype", FT_UINT32, BASE_DEC,
-        VALS(slarp_ptype_vals), 0x0, "" }},
+        VALS(slarp_ptype_vals), 0x0, "", HFILL }},
     { &hf_slarp_address,
       { "Address", "slarp.address", FT_IPv4, BASE_NONE,
-        NULL, 0x0, "" }},
+        NULL, 0x0, "", HFILL }},
     /* XXX - need an FT_ for netmasks, which is like FT_IPV4 but doesn't
        get translated to a host name. */
     { &hf_slarp_mysequence,
       { "Outgoing sequence number", "slarp.mysequence", FT_UINT32, BASE_DEC,
-        NULL, 0x0, "" }},
+        NULL, 0x0, "", HFILL }},
     { &hf_slarp_yoursequence,
       { "Returned sequence number", "slarp.yoursequence", FT_UINT32, BASE_DEC,
-        NULL, 0x0, "" }},
+        NULL, 0x0, "", HFILL }},
   };
   static gint *ett[] = {
     &ett_chdlc,
index 40ce8fbdf38b97e8d1ebf2aa09cc24f0fed20686..c5216410fe8e49b21b4c79986d81af499974e24e 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-clnp.c
  * Routines for ISO/OSI network and transport protocol packet disassembly
  *
- * $Id: packet-clnp.c,v 1.32 2001/06/18 01:49:16 guy Exp $
+ * $Id: packet-clnp.c,v 1.33 2001/06/18 02:17:45 guy Exp $
  * Laurent Deniel <deniel@worldnet.fr>
  * Ralf Schneider <Ralf.Schneider@t-online.de>
  *
@@ -2062,65 +2062,65 @@ void proto_register_clnp(void)
   static hf_register_info hf[] = {
     { &hf_clnp_id,
       { "Network Layer Protocol Identifier", "clnp.nlpi", FT_UINT8, BASE_HEX, 
-        VALS(nlpid_vals), 0x0, "" }},
+        VALS(nlpid_vals), 0x0, "", HFILL }},
 
     { &hf_clnp_length,
-      { "HDR Length   ", "clnp.len",      FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+      { "HDR Length   ", "clnp.len",      FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_clnp_version,
-      { "Version      ", "clnp.version",  FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+      { "Version      ", "clnp.version",  FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_clnp_ttl,
-      { "Holding Time ", "clnp.ttl",      FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+      { "Holding Time ", "clnp.ttl",      FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_clnp_type,
-      { "PDU Type     ", "clnp.type",     FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+      { "PDU Type     ", "clnp.type",     FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_clnp_pdu_length,
-      { "PDU length   ", "clnp.pdu.len",  FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+      { "PDU length   ", "clnp.pdu.len",  FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_clnp_checksum,
-      { "Checksum     ", "clnp.checksum", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+      { "Checksum     ", "clnp.checksum", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_clnp_dest_length,
-      { "DAL ", "clnp.dsap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+      { "DAL ", "clnp.dsap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_clnp_dest,
-      { " DA ", "clnp.dsap",     FT_BYTES, BASE_NONE, NULL, 0x0, "" }},
+      { " DA ", "clnp.dsap",     FT_BYTES, BASE_NONE, NULL, 0x0, "", HFILL }},
 
     { &hf_clnp_src_length,
-      { "SAL ", "clnp.ssap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+      { "SAL ", "clnp.ssap.len", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
 
     { &hf_clnp_src,
-      { " SA ", "clnp.ssap",     FT_BYTES, BASE_NONE, NULL, 0x0, "" }},
+      { " SA ", "clnp.ssap",     FT_BYTES, BASE_NONE, NULL, 0x0, "", HFILL }},
 
     { &hf_clnp_segment_overlap,
       { "Segment overlap", "clnp.segment.overlap", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
-       "Segment overlaps with other segments" }},
+       "Segment overlaps with other segments", HFILL }},
 
     { &hf_clnp_segment_overlap_conflict,
       { "Conflicting data in segment overlap", "clnp.segment.overlap.conflict", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
-       "Overlapping segments contained conflicting data" }},
+       "Overlapping segments contained conflicting data", HFILL }},
 
     { &hf_clnp_segment_multiple_tails,
       { "Multiple tail segments found", "clnp.segment.multipletails", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
-       "Several tails were found when reassembling the packet" }},
+       "Several tails were found when reassembling the packet", HFILL }},
 
     { &hf_clnp_segment_too_long_segment,
       { "Segment too long", "clnp.segment.toolongsegment", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
-       "Segment contained data past end of packet" }},
+       "Segment contained data past end of packet", HFILL }},
 
     { &hf_clnp_segment_error,
       { "Reassembly error", "clnp.segment.error", FT_NONE, BASE_DEC, NULL, 0x0,
-       "Reassembly error due to illegal segments" }},
+       "Reassembly error due to illegal segments", HFILL }},
 
     { &hf_clnp_segment,
       { "CLNP Segment", "clnp.segment", FT_NONE, BASE_DEC, NULL, 0x0,
-       "CLNP Segment" }},
+       "CLNP Segment", HFILL }},
 
     { &hf_clnp_segments,
       { "CLNP Segments", "clnp.segments", FT_NONE, BASE_DEC, NULL, 0x0,
-       "CLNP Segments" }},
+       "CLNP Segments", HFILL }},
   };
   static gint *ett[] = {
     &ett_clnp,
index 45344ba345f5a180621c4cc8789c80c42914ce46..e062bd0a140ad28c49f30e405f46d67dbb258610 100644 (file)
@@ -4,7 +4,7 @@
  *
  * Copyright 2000, Heikki Vatiainen <hessu@cs.tut.fi>
  *
- * $Id: packet-cops.c,v 1.12 2001/04/23 18:19:03 guy Exp $
+ * $Id: packet-cops.c,v 1.13 2001/06/18 02:17:45 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -637,167 +637,167 @@ void proto_register_cops(void)
                 { &hf_cops_ver_flags,
                         { "Version and Flags",           "cops.ver_flags",
                         FT_UINT8, BASE_HEX, NULL, 0x0,
-                        "Version and Flags in COPS Common Header" }
+                        "Version and Flags in COPS Common Header", HFILL }
                 },
                 { &hf_cops_version,
                         { "Version",           "cops.version",
                         FT_UINT8, BASE_DEC, NULL, 0xF0,
-                        "Version in COPS Common Header" }
+                        "Version in COPS Common Header", HFILL }
                 },
                 { &hf_cops_flags,
                         { "Flags",           "cops.flags",
                         FT_UINT8, BASE_HEX, VALS(cops_flags_vals), 0x0F,
-                        "Flags in COPS Common Header" }
+                        "Flags in COPS Common Header", HFILL }
                 },
                 { &hf_cops_op_code,
                         { "Op Code",           "cops.op_code",
                         FT_UINT8, BASE_DEC, VALS(cops_op_code_vals), 0x0,
-                        "Op Code in COPS Common Header" }
+                        "Op Code in COPS Common Header", HFILL }
                 },
                 { &hf_cops_client_type,
                         { "Client Type",           "cops.client_type",
                         FT_UINT16, BASE_DEC, NULL, 0x0,
-                        "Client Type in COPS Common Header" }
+                        "Client Type in COPS Common Header", HFILL }
                 },
                 { &hf_cops_msg_len,
                         { "Message Length",           "cops.msg_len",
                         FT_UINT32, BASE_DEC, NULL, 0x0,
-                        "Message Length in COPS Common Header" }
+                        "Message Length in COPS Common Header", HFILL }
                 },
                 { &hf_cops_obj_len,
                         { "Object Length",           "cops.obj.len",
                         FT_UINT32, BASE_DEC, NULL, 0x0,
-                        "Object Length in COPS Object Header" }
+                        "Object Length in COPS Object Header", HFILL }
                 },
                 { &hf_cops_obj_c_num,
                         { "C-Num",           "cops.c_num",
                         FT_UINT8, BASE_DEC, VALS(cops_c_num_vals), 0x0,
-                        "C-Num in COPS Object Header" }
+                        "C-Num in COPS Object Header", HFILL }
                 },
                 { &hf_cops_obj_c_type,
                         { "C-Type",           "cops.c_type",
                         FT_UINT8, BASE_DEC, NULL, 0x0,
-                        "C-Type in COPS Object Header" }
+                        "C-Type in COPS Object Header", HFILL }
                 },
                 { &hf_cops_r_type_flags,
                         { "R-Type",           "cops.context.r_type",
                         FT_UINT16, BASE_HEX, VALS(cops_r_type_vals), 0xFFFF,
-                        "R-Type in COPS Context Object" }
+                        "R-Type in COPS Context Object", HFILL }
                 },
                 { &hf_cops_m_type_flags,
                         { "M-Type",           "cops.context.m_type",
                         FT_UINT16, BASE_HEX, NULL, 0xFFFF,
-                        "M-Type in COPS Context Object" }
+                        "M-Type in COPS Context Object", HFILL }
                 },
                 { &hf_cops_in_int_ipv4,
                         { "IPv4 address",           "cops.in-int.ipv4",
                         FT_IPv4, 0, NULL, 0xFFFF,
-                        "IPv4 address in COPS IN-Int object" }
+                        "IPv4 address in COPS IN-Int object", HFILL }
                 },
                 { &hf_cops_in_int_ipv6,
                         { "IPv6 address",           "cops.in-int.ipv6",
                         FT_IPv6, 0, NULL, 0xFFFF,
-                        "IPv6 address in COPS IN-Int object" }
+                        "IPv6 address in COPS IN-Int object", HFILL }
                 },
                 { &hf_cops_out_int_ipv4,
                         { "IPv4 address",           "cops.out-int.ipv4",
                         FT_IPv4, 0, NULL, 0xFFFF,
-                        "IPv4 address in COPS OUT-Int object" }
+                        "IPv4 address in COPS OUT-Int object", HFILL }
                 },
                 { &hf_cops_out_int_ipv6,
                         { "IPv6 address",           "cops.out-int.ipv6",
                         FT_IPv6, 0, NULL, 0xFFFF,
-                        "IPv6 address in COPS OUT-Int" }
+                        "IPv6 address in COPS OUT-Int", HFILL }
                 },
                 { &hf_cops_int_ifindex,
                         { "ifIndex",           "cops.in-out-int.ifindex",
                         FT_UINT32, BASE_DEC, NULL, 0x0,
-                        "If SNMP is supported, corresponds to MIB-II ifIndex" } 
+                        "If SNMP is supported, corresponds to MIB-II ifIndex", HFILL }
                 },
                 { &hf_cops_reason,
                         { "Reason",           "cops.reason",
                         FT_UINT16, BASE_DEC, VALS(cops_reason_vals), 0,
-                        "Reason in Reason object" }
+                        "Reason in Reason object", HFILL }
                 },
                 { &hf_cops_reason_sub,
                         { "Reason Sub-code",           "cops.reason_sub",
                         FT_UINT16, BASE_HEX, NULL, 0,
-                        "Reason Sub-code in Reason object" }
+                        "Reason Sub-code in Reason object", HFILL }
                 },
                 { &hf_cops_dec_cmd_code,
                         { "Command-Code",           "cops.decision.cmd",
                         FT_UINT16, BASE_DEC, VALS(cops_dec_cmd_code_vals), 0,
-                        "Command-Code in Decision/LPDP Decision object" }
+                        "Command-Code in Decision/LPDP Decision object", HFILL }
                 },
                 { &hf_cops_dec_flags,
                         { "Flags",           "cops.decision.flags",
                         FT_UINT16, BASE_HEX, VALS(cops_dec_cmd_flag_vals), 0xffff,
-                        "Flags in Decision/LPDP Decision object" }
+                        "Flags in Decision/LPDP Decision object", HFILL }
                 },
                 { &hf_cops_error,
                         { "Error",           "cops.error",
                         FT_UINT16, BASE_DEC, VALS(cops_error_vals), 0,
-                        "Error in Error object" }
+                        "Error in Error object", HFILL }
                 },
                 { &hf_cops_error_sub,
                         { "Error Sub-code",           "cops.error_sub",
                         FT_UINT16, BASE_HEX, NULL, 0,
-                        "Error Sub-code in Error object" }
+                        "Error Sub-code in Error object", HFILL }
                 },
                 { &hf_cops_katimer,
                         { "Contents: KA Timer Value",           "cops.katimer.value",
                         FT_UINT16, BASE_DEC, NULL, 0,
-                        "Keep-Alive Timer Value in KATimer object" }
+                        "Keep-Alive Timer Value in KATimer object", HFILL }
                 },
                 { &hf_cops_pepid,
                         { "Contents: PEP Id",           "cops.pepid.id",
                         FT_STRING, BASE_NONE, NULL, 0,
-                        "PEP Id in PEPID object" }
+                        "PEP Id in PEPID object", HFILL }
                 },
                 { &hf_cops_report_type,
                         { "Contents: Report-Type",           "cops.report_type",
                         FT_UINT16, BASE_DEC, VALS(cops_report_type_vals), 0,
-                        "Report-Type in Report-Type object" }
+                        "Report-Type in Report-Type object", HFILL }
                 },
                 { &hf_cops_pdprediraddr_ipv4,
                         { "IPv4 address",           "cops.pdprediraddr.ipv4",
                         FT_IPv4, 0, NULL, 0xFFFF,
-                        "IPv4 address in COPS PDPRedirAddr object" }
+                        "IPv4 address in COPS PDPRedirAddr object", HFILL }
                 },
                 { &hf_cops_pdprediraddr_ipv6,
                         { "IPv6 address",           "cops.pdprediraddr.ipv6",
                         FT_IPv6, 0, NULL, 0xFFFF,
-                        "IPv6 address in COPS PDPRedirAddr object" }
+                        "IPv6 address in COPS PDPRedirAddr object", HFILL }
                 },
                 { &hf_cops_lastpdpaddr_ipv4,
                         { "IPv4 address",           "cops.lastpdpaddr.ipv4",
                         FT_IPv4, 0, NULL, 0xFFFF,
-                        "IPv4 address in COPS LastPDPAddr object" }
+                        "IPv4 address in COPS LastPDPAddr object", HFILL }
                 },
                 { &hf_cops_lastpdpaddr_ipv6,
                         { "IPv6 address",           "cops.lastpdpaddr.ipv6",
                         FT_IPv6, 0, NULL, 0xFFFF,
-                        "IPv6 address in COPS LastPDPAddr object" }
+                        "IPv6 address in COPS LastPDPAddr object", HFILL }
                 },
                 { &hf_cops_pdp_tcp_port,
                         { "TCP Port Number",           "cops.pdp.tcp_port",
                         FT_UINT32, BASE_DEC, NULL, 0x0,
-                         "TCP Port Number of PDP in PDPRedirAddr/LastPDPAddr object" }
+                         "TCP Port Number of PDP in PDPRedirAddr/LastPDPAddr object", HFILL }
                 },
                 { &hf_cops_accttimer,
                         { "Contents: ACCT Timer Value",           "cops.accttimer.value",
                         FT_UINT16, BASE_DEC, NULL, 0,
-                        "Accounting Timer Value in AcctTimer object" }
+                        "Accounting Timer Value in AcctTimer object", HFILL }
                 },
                 { &hf_cops_key_id,
                         { "Contents: Key ID",           "cops.integrity.key_id",
                         FT_UINT32, BASE_DEC, NULL, 0,
-                        "Key ID in Integrity object" }
+                        "Key ID in Integrity object", HFILL }
                 },
                 { &hf_cops_seq_num,
                         { "Contents: Sequence Number",           "cops.integrity.seq_num",
                         FT_UINT32, BASE_DEC, NULL, 0,
-                        "Sequence Number in Integrity object" }
+                        "Sequence Number in Integrity object", HFILL }
                 },
         };
 
index e87dda7fcd2466c38fe22204cdc41f398a689a1f..9525dcb884085b29528971fb3a3f837a0644f182 100644 (file)
@@ -5,7 +5,7 @@
 * Charles Levert <charles@comm.polymtl.ca>
 * Copyright 2001 Charles Levert
 *
-* $Id: packet-cups.c,v 1.4 2001/03/15 07:03:13 guy Exp $
+* $Id: packet-cups.c,v 1.5 2001/06/18 02:17:45 guy Exp $
 *
 * 
 * This program is free software; you can redistribute it and/or
@@ -353,11 +353,11 @@ proto_register_cups(void)
                /* This one could be split in separate fields. */
                { &hf_cups_ptype,
                        { "Type",       "cups.ptype", FT_UINT32, BASE_HEX,
-                         NULL, 0x0, ""}},
+                         NULL, 0x0, "", HFILL }},
 
                { &hf_cups_state,
                        { "State",      "cups.state", FT_UINT8, BASE_HEX,
-                         VALS(cups_state_values), 0x0, "" }}
+                         VALS(cups_state_values), 0x0, "", HFILL }}
        };
 
        static gint *ett[] = {
index 8ecd2cec499da09edc6efd62b2dea0c96725b344..9534a23d3f5b64bed1bd4c2233ccb48c1429a18b 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for DCERPC packet disassembly
  * Copyright 2001, Todd Sabin <tas@webspan.net>
  *
- * $Id: packet-dcerpc.c,v 1.4 2001/04/27 01:27:36 guy Exp $
+ * $Id: packet-dcerpc.c,v 1.5 2001/06/18 02:17:45 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -735,129 +735,129 @@ proto_register_dcerpc(void)
 {
     static hf_register_info hf[] = {
         { &hf_dcerpc_ver,
-          { "Version", "dcerpc.ver", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+          { "Version", "dcerpc.ver", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_ver_minor,
-          { "Version (minor)", "dcerpc.ver_minor", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+          { "Version (minor)", "dcerpc.ver_minor", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_packet_type,
-          { "Packet type", "dcerpc.pkt_type", FT_UINT8, BASE_HEX, VALS (pckt_vals), 0x0, "" }},
+          { "Packet type", "dcerpc.pkt_type", FT_UINT8, BASE_HEX, VALS (pckt_vals), 0x0, "", HFILL }},
         { &hf_dcerpc_cn_flags,
-          { "Packet Flags", "dcerpc.cn_flags", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
+          { "Packet Flags", "dcerpc.cn_flags", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_flags_first_frag,
-          { "First Frag", "dcerpc.cn_flags.first_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x1, "" }},
+          { "First Frag", "dcerpc.cn_flags.first_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x1, "", HFILL }},
         { &hf_dcerpc_cn_flags_last_frag,
-          { "Last Frag", "dcerpc.cn_flags.last_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x2, "" }},
+          { "Last Frag", "dcerpc.cn_flags.last_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x2, "", HFILL }},
         { &hf_dcerpc_cn_flags_cancel_pending,
-          { "Cancel Pending", "dcerpc.cn_flags.cancel_pending", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x4, "" }},
+          { "Cancel Pending", "dcerpc.cn_flags.cancel_pending", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x4, "", HFILL }},
         { &hf_dcerpc_cn_flags_reserved,
-          { "Reserved", "dcerpc.cn_flags.reserved", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x8, "" }},
+          { "Reserved", "dcerpc.cn_flags.reserved", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x8, "", HFILL }},
         { &hf_dcerpc_cn_flags_mpx,
-          { "Multiplex", "dcerpc.cn_flags.mpx", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x10, "" }},
+          { "Multiplex", "dcerpc.cn_flags.mpx", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x10, "", HFILL }},
         { &hf_dcerpc_cn_flags_dne,
-          { "Did Not Execute", "dcerpc.cn_flags.dne", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x20, "" }},
+          { "Did Not Execute", "dcerpc.cn_flags.dne", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x20, "", HFILL }},
         { &hf_dcerpc_cn_flags_maybe,
-          { "Maybe", "dcerpc.cn_flags.maybe", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x40, "" }},
+          { "Maybe", "dcerpc.cn_flags.maybe", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x40, "", HFILL }},
         { &hf_dcerpc_cn_flags_object,
-          { "Object", "dcerpc.cn_flags.object", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x80, "" }},
+          { "Object", "dcerpc.cn_flags.object", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x80, "", HFILL }},
         { &hf_dcerpc_cn_frag_len,
-          { "Frag Length", "dcerpc.cn_frag_len", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+          { "Frag Length", "dcerpc.cn_frag_len", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_auth_len,
-          { "Auth Length", "dcerpc.cn_auth_len", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+          { "Auth Length", "dcerpc.cn_auth_len", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_call_id,
-          { "Call ID", "dcerpc.cn_call_id", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
+          { "Call ID", "dcerpc.cn_call_id", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_max_xmit,
-          { "Max Xmit Frag", "dcerpc.cn_max_xmit", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+          { "Max Xmit Frag", "dcerpc.cn_max_xmit", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_max_recv,
-          { "Max Recv Frag", "dcerpc.cn_max_recv", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+          { "Max Recv Frag", "dcerpc.cn_max_recv", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_assoc_group,
-          { "Assoc Group", "dcerpc.cn_assoc_group", FT_UINT32, BASE_HEX, NULL, 0x0, "" }},
+          { "Assoc Group", "dcerpc.cn_assoc_group", FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_num_ctx_items,
-          { "Num Ctx Items", "dcerpc.cn_num_ctx_items", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+          { "Num Ctx Items", "dcerpc.cn_num_ctx_items", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_ctx_id,
-          { "Context ID", "dcerpc.cn_ctx_id", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+          { "Context ID", "dcerpc.cn_ctx_id", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_num_trans_items,
-          { "Num Trans Items", "dcerpc.cn_num_trans_items", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+          { "Num Trans Items", "dcerpc.cn_num_trans_items", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_bind_if_id,
-          { "Interface UUID", "dcerpc.cn_bind_to_uuid", FT_STRING, BASE_NONE, NULL, 0x0, "" }},
+          { "Interface UUID", "dcerpc.cn_bind_to_uuid", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_bind_if_ver,
-          { "Interface Ver", "dcerpc.cn_bind_if_ver", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
+          { "Interface Ver", "dcerpc.cn_bind_if_ver", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_bind_trans_id,
-          { "Transfer Syntax", "dcerpc.cn_bind_trans_id", FT_STRING, BASE_NONE, NULL, 0x0, "" }},
+          { "Transfer Syntax", "dcerpc.cn_bind_trans_id", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_bind_trans_ver,
-          { "Syntax ver", "dcerpc.cn_bind_trans_ver", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
+          { "Syntax ver", "dcerpc.cn_bind_trans_ver", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_alloc_hint,
-          { "Alloc hint", "dcerpc.cn_alloc_hint", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
+          { "Alloc hint", "dcerpc.cn_alloc_hint", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_sec_addr_len,
-          { "Scndry Addr len", "dcerpc.cn_sec_addr_len", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+          { "Scndry Addr len", "dcerpc.cn_sec_addr_len", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_num_results,
-          { "Num results", "dcerpc.cn_num_results", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+          { "Num results", "dcerpc.cn_num_results", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_ack_result,
-          { "Ack result", "dcerpc.cn_ack_result", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+          { "Ack result", "dcerpc.cn_ack_result", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_cn_ack_reason,
-          { "Ack reason", "dcerpc.cn_ack_reason", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+          { "Ack reason", "dcerpc.cn_ack_reason", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_flags1,
-          { "Flags1", "dcerpc.dg_flags1", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
+          { "Flags1", "dcerpc.dg_flags1", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_flags1_rsrvd_01,
-          { "Reserved", "dcerpc.dg_flags1_rsrvd_01", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x01, "" }},
+          { "Reserved", "dcerpc.dg_flags1_rsrvd_01", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x01, "", HFILL }},
         { &hf_dcerpc_dg_flags1_last_frag,
-          { "Last Fragment", "dcerpc.dg_flags1_last_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x02, "" }},
+          { "Last Fragment", "dcerpc.dg_flags1_last_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x02, "", HFILL }},
         { &hf_dcerpc_dg_flags1_frag,
-          { "Fragment", "dcerpc.dg_flags1_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x04, "" }},
+          { "Fragment", "dcerpc.dg_flags1_frag", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x04, "", HFILL }},
         { &hf_dcerpc_dg_flags1_nofack,
-          { "No Fack", "dcerpc.dg_flags1_nofack", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x08, "" }},
+          { "No Fack", "dcerpc.dg_flags1_nofack", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x08, "", HFILL }},
         { &hf_dcerpc_dg_flags1_maybe,
-          { "Maybe", "dcerpc.dg_flags1_maybe", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x10, "" }},
+          { "Maybe", "dcerpc.dg_flags1_maybe", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x10, "", HFILL }},
         { &hf_dcerpc_dg_flags1_idempotent,
-          { "Idempotent", "dcerpc.dg_flags1_idempotent", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x20, "" }},
+          { "Idempotent", "dcerpc.dg_flags1_idempotent", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x20, "", HFILL }},
         { &hf_dcerpc_dg_flags1_broadcast,
-          { "Broadcast", "dcerpc.dg_flags1_broadcast", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x40, "" }},
+          { "Broadcast", "dcerpc.dg_flags1_broadcast", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x40, "", HFILL }},
         { &hf_dcerpc_dg_flags1_rsrvd_80,
-          { "Reserved", "dcerpc.dg_flags1_rsrvd_80", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x80, "" }},
+          { "Reserved", "dcerpc.dg_flags1_rsrvd_80", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x80, "", HFILL }},
         { &hf_dcerpc_dg_flags2,
-          { "Flags2", "dcerpc.dg_flags2", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
+          { "Flags2", "dcerpc.dg_flags2", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_flags2_rsrvd_01,
-          { "Reserved", "dcerpc.dg_flags2_rsrvd_01", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x01, "" }},
+          { "Reserved", "dcerpc.dg_flags2_rsrvd_01", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x01, "", HFILL }},
         { &hf_dcerpc_dg_flags2_cancel_pending,
-          { "Cancel Pending", "dcerpc.dg_flags2_cancel_pending", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x02, "" }},
+          { "Cancel Pending", "dcerpc.dg_flags2_cancel_pending", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x02, "", HFILL }},
         { &hf_dcerpc_dg_flags2_rsrvd_04,
-          { "Reserved", "dcerpc.dg_flags2_rsrvd_04", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x04, "" }},
+          { "Reserved", "dcerpc.dg_flags2_rsrvd_04", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x04, "", HFILL }},
         { &hf_dcerpc_dg_flags2_rsrvd_08,
-          { "Reserved", "dcerpc.dg_flags2_rsrvd_08", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x08, "" }},
+          { "Reserved", "dcerpc.dg_flags2_rsrvd_08", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x08, "", HFILL }},
         { &hf_dcerpc_dg_flags2_rsrvd_10,
-          { "Reserved", "dcerpc.dg_flags2_rsrvd_10", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x10, "" }},
+          { "Reserved", "dcerpc.dg_flags2_rsrvd_10", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x10, "", HFILL }},
         { &hf_dcerpc_dg_flags2_rsrvd_20,
-          { "Reserved", "dcerpc.dg_flags2_rsrvd_20", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x20, "" }},
+          { "Reserved", "dcerpc.dg_flags2_rsrvd_20", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x20, "", HFILL }},
         { &hf_dcerpc_dg_flags2_rsrvd_40,
-          { "Reserved", "dcerpc.dg_flags2_rsrvd_40", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x40, "" }},
+          { "Reserved", "dcerpc.dg_flags2_rsrvd_40", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x40, "", HFILL }},
         { &hf_dcerpc_dg_flags2_rsrvd_80,
-          { "Reserved", "dcerpc.dg_flags2_rsrvd_80", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x80, "" }},
+          { "Reserved", "dcerpc.dg_flags2_rsrvd_80", FT_BOOLEAN, 8, TFS (&flags_set_truth), 0x80, "", HFILL }},
         { &hf_dcerpc_dg_serial_lo,
-          { "Serial Low", "dcerpc.dg_serial_lo", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
+          { "Serial Low", "dcerpc.dg_serial_lo", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_serial_hi,
-          { "Serial High", "dcerpc.dg_serial_hi", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
+          { "Serial High", "dcerpc.dg_serial_hi", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_ahint,
-          { "Activity Hint", "dcerpc.dg_ahint", FT_UINT16, BASE_HEX, NULL, 0x0, "" }},
+          { "Activity Hint", "dcerpc.dg_ahint", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_ihint,
-          { "Interface Hint", "dcerpc.dg_ihint", FT_UINT16, BASE_HEX, NULL, 0x0, "" }},
+          { "Interface Hint", "dcerpc.dg_ihint", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_frag_len,
-          { "Fragment len", "dcerpc.dg_frag_len", FT_UINT16, BASE_HEX, NULL, 0x0, "" }},
+          { "Fragment len", "dcerpc.dg_frag_len", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_frag_num,
-          { "Fragment num", "dcerpc.dg_frag_num", FT_UINT16, BASE_HEX, NULL, 0x0, "" }},
+          { "Fragment num", "dcerpc.dg_frag_num", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_auth_proto,
-          { "Auth proto", "dcerpc.dg_auth_proto", FT_UINT8, BASE_HEX, NULL, 0x0, "" }},
+          { "Auth proto", "dcerpc.dg_auth_proto", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_seqnum,
-          { "Sequence num", "dcerpc.dg_seqnum", FT_UINT32, BASE_HEX, NULL, 0x0, "" }},
+          { "Sequence num", "dcerpc.dg_seqnum", FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_server_boot,
-          { "Server boot time", "dcerpc.dg_server_boot", FT_UINT32, BASE_HEX, NULL, 0x0, "" }},
+          { "Server boot time", "dcerpc.dg_server_boot", FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_if_ver,
-          { "Interface Ver", "dcerpc.dg_if_ver", FT_UINT32, BASE_DEC, NULL, 0x0, "" }},
+          { "Interface Ver", "dcerpc.dg_if_ver", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_obj_id,
-          { "Object", "dcerpc.obj_id", FT_STRING, BASE_NONE, NULL, 0x0, "" }},
+          { "Object", "dcerpc.obj_id", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_if_id,
-          { "Interface", "dcerpc.dg_if_id", FT_STRING, BASE_NONE, NULL, 0x0, "" }},
+          { "Interface", "dcerpc.dg_if_id", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_dg_act_id,
-          { "Activitiy", "dcerpc.dg_act_id", FT_STRING, BASE_NONE, NULL, 0x0, "" }},
+          { "Activitiy", "dcerpc.dg_act_id", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }},
         { &hf_dcerpc_opnum,
-          { "Opnum", "dcerpc.opnum", FT_UINT16, BASE_DEC, NULL, 0x0, "" }},
+          { "Opnum", "dcerpc.opnum", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
 
 
     };
index d63b0520b80928790ab4ab81fb4ee52c3e040970..59c7d6d16aa883669b16d78a648d9758b5261892 100644 (file)
@@ -3,7 +3,7 @@
  * see http://ddt.sourceforge.net/
  * Olivier Abad <oabad@cybercable.fr>
  *
- * $Id: packet-ddtp.c,v 1.15 2001/01/22 08:03:45 guy Exp $
+ * $Id: packet-ddtp.c,v 1.16 2001/06/18 02:17:45 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -181,25 +181,25 @@ proto_register_ddtp(void)
     static hf_register_info hf_ddtp[] = {
        { &hf_ddtp_version,
            { "Version", "ddtp.version", FT_UINT32, BASE_DEC, VALS(vals_ddtp_version), 0x0,
-               "Version" } },
+               "Version", HFILL }},
        { &hf_ddtp_encrypt,
            { "Encryption", "ddtp.encrypt", FT_UINT32, BASE_DEC, VALS(vals_ddtp_encrypt), 0x0,
-               "Encryption type" } },
+               "Encryption type", HFILL }},
        { &hf_ddtp_hostid,
            { "Hostid", "ddtp.hostid", FT_UINT32, BASE_DEC, NULL, 0x0,
-               "Host ID" } },
+               "Host ID", HFILL }},
        { &hf_ddtp_msgtype,
            { "Message type", "ddtp.msgtype", FT_UINT32, BASE_DEC, VALS(vals_ddtp_msgtype), 0x0,
-               "Message Type" } },
+               "Message Type", HFILL }},
        { &hf_ddtp_opcode,
            { "Opcode", "ddtp.opcode", FT_UINT32, BASE_DEC, VALS(vals_ddtp_opcode), 0x0,
-               "Update query opcode" } },
+               "Update query opcode", HFILL }},
        { &hf_ddtp_ipaddr,
            { "IP address", "ddtp.ipaddr", FT_IPv4, BASE_NONE, NULL, 0x0,
-               "IP address" } },
+               "IP address", HFILL }},
        { &hf_ddtp_status,
            { "Status", "ddtp.status", FT_UINT32, BASE_DEC, VALS(vals_ddtp_status), 0x0,
-               "Update reply status" } }
+               "Update reply status", HFILL }}
     };
 
     static gint *ett[] = { &ett_ddtp };
index 7dcd9d63426dcc9bab4605371aacd2675ac50130..77a50cab08bb6faea1240246e7c4daa76ade3dae 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-diameter.c
  * Routines for DIAMETER packet disassembly
  *
- * $Id: packet-diameter.c,v 1.22 2001/05/27 21:38:46 guy Exp $
+ * $Id: packet-diameter.c,v 1.23 2001/06/18 02:17:45 guy Exp $
  *
  * Copyright (c) 2001 by David Frascone <dave@frascone.com>
  *
@@ -778,76 +778,76 @@ proto_register_diameter(void)
        static hf_register_info hf[] = {
                { &hf_diameter_reserved,
                  { "Reserved", "diameter.reserved", FT_UINT8, BASE_HEX, NULL, 0x0,
-                   "Should be zero" }},
+                   "Should be zero", HFILL }},
                { &hf_diameter_flags,
                  { "Flags", "diameter.flags", FT_UINT8, BASE_HEX, NULL, 0xf8,
-                   "" }},
+                   "", HFILL }},
                { &hf_diameter_version,
                  { "Version", "diameter.version", FT_UINT8, BASE_HEX, NULL, 0x07,
-                   "" }},
+                   "", HFILL }},
                { &hf_diameter_length,
                  { "Length","diameter.length", FT_UINT16, BASE_DEC, NULL, 0x0,
-                   "" }},
+                   "", HFILL }},
                { &hf_diameter_hopbyhopid,
                  { "Hop-by-Hop Identifier", "diameter.hopbyhopid", FT_UINT32,
-                   BASE_HEX, NULL, 0x0, "" }},
+                   BASE_HEX, NULL, 0x0, "", HFILL }},
                { &hf_diameter_endtoendid,
                  { "End-to-End Identifier", "diameter.endtoendid", FT_UINT32, 
-                   BASE_HEX, NULL, 0x0, "" }},
+                   BASE_HEX, NULL, 0x0, "", HFILL }},
                { &hf_diameter_code,
                  { "Command Code","diameter.code", FT_UINT32, BASE_DEC,
-                   VALS(diameter_command_code_vals), 0x0, "" }},
+                   VALS(diameter_command_code_vals), 0x0, "", HFILL }},
                { &hf_diameter_vendor_id,
                  { "VendorId", "diameter.vendorId", FT_UINT32, BASE_DEC, NULL, 0x0,
-                   "" }},
+                   "", HFILL }},
 
                { &hf_diameter_avp_code,
                  { "AVP Code","diameter.avp.code", FT_UINT32, BASE_DEC,
-                   VALS(diameter_attrib_type_vals), 0x0, "" }},
+                   VALS(diameter_attrib_type_vals), 0x0, "", HFILL }},
                { &hf_diameter_avp_length,
                  { "AVP length","diameter.avp.length", FT_UINT16, BASE_DEC,
-                   NULL, 0x0, "" }},
+                   NULL, 0x0, "", HFILL }},
                { &hf_diameter_avp_reserved,
                  { "AVP Reserved","diameter.avp.reserved", FT_UINT8, BASE_HEX,
-                   NULL, 0x0, "Should be Zero" }},
+                   NULL, 0x0, "Should be Zero", HFILL }},
                { &hf_diameter_avp_flags,
                  { "AVP Flags","diameter.avp.flags", FT_UINT8, BASE_HEX,
-                   NULL, 0x1f, "" }},
+                   NULL, 0x1f, "", HFILL }},
                { &hf_diameter_avp_vendor_id,
                  { "AVP Vendor Id","diameter.avp.vendorId", FT_UINT32, BASE_DEC,
-                   NULL, 0x0, "" }},
+                   NULL, 0x0, "", HFILL }},
                { &hf_diameter_avp_data_uint32,
                  { "AVP Data","diameter.avp.data.uint32", FT_UINT32, BASE_DEC,
-                   NULL, 0x0, "" }},
+                   NULL, 0x0, "", HFILL }},
 #if 0
                { &hf_diameter_avp_data_uint64,
                  { "AVP Data","diameter.avp.data.uint64", FT_UINT64, BASE_DEC,
-                   NULL, 0x0, "" }},
+                   NULL, 0x0, "", HFILL }},
 #endif
                { &hf_diameter_avp_data_int32,
                  { "AVP Data","diameter.avp.data.int32", FT_INT32, BASE_DEC,
-                   NULL, 0x0, "" }},
+                   NULL, 0x0, "", HFILL }},
 #if 0
                { &hf_diameter_avp_data_int64,
                  { "AVP Data","diameter.avp.data.int64", FT_INT_64, BASE_DEC,
-                   NULL, 0x0, "" }},
+                   NULL, 0x0, "", HFILL }},
 #endif
                { &hf_diameter_avp_data_bytes,
                  { "AVP Data","diameter.avp.data.bytes", FT_BYTES, BASE_NONE,
-                   NULL, 0x0, "" }},
+                   NULL, 0x0, "", HFILL }},
 
                { &hf_diameter_avp_data_string,
                  { "AVP Data","diameter.avp.data.string", FT_STRING, BASE_NONE,
-                   NULL, 0x0, "" }},
+                   NULL, 0x0, "", HFILL }},
                { &hf_diameter_avp_data_v4addr,
                  { "AVP Data","diameter.avp.data.v4addr", FT_IPv4, BASE_NONE,
-                   NULL, 0x0, "" }},
+                   NULL, 0x0, "", HFILL }},
                { &hf_diameter_avp_data_v6addr,
                  { "AVP Data","diameter.avp.data.v6addr", FT_IPv6, BASE_NONE,
-                   NULL, 0x0, "" }},
+                   NULL, 0x0, "", HFILL }},
                { &hf_diameter_avp_data_time,
                  { "AVP Data","diameter.avp.data.time", FT_ABSOLUTE_TIME, BASE_NONE,
-                   NULL, 0x0, "" }},
+                   NULL, 0x0, "", HFILL }},
 
        };
        static gint *ett[] = {
index 39f2fbe58b26fd246139ef64ee6cdf3a07469edd..9822b02a7ceca0c72674b264d226bcd3bf4ea812 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-dns.c
  * Routines for DNS packet disassembly
  *
- * $Id: packet-dns.c,v 1.67 2001/06/18 01:49:16 guy Exp $
+ * $Id: packet-dns.c,v 1.68 2001/06/18 02:17:45 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -2493,35 +2493,35 @@ proto_register_dns(void)
     { &hf_dns_response,
       { "Response",            "dns.response",  
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
-       "TRUE if DNS response" }},
+       "TRUE if DNS response", HFILL }},
     { &hf_dns_query,
       { "Query",               "dns.query",  
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
-       "TRUE if DNS query" }},
+       "TRUE if DNS query", HFILL }},
     { &hf_dns_flags,
       { "Flags",               "dns.flags",  
        FT_UINT16, BASE_HEX, NULL, 0x0,
-       "" }},
+       "", HFILL }},
     { &hf_dns_transaction_id,
       { "Transaction ID",              "dns.id",  
        FT_UINT16, BASE_HEX, NULL, 0x0,
-       "Identification of transaction" }},
+       "Identification of transaction", HFILL }},
     { &hf_dns_count_questions,
       { "Questions",           "dns.count.queries",  
        FT_UINT16, BASE_DEC, NULL, 0x0,
-       "Number of queries in packet" }},
+       "Number of queries in packet", HFILL }},
     { &hf_dns_count_answers,
       { "Answer RRs",          "dns.count.answers",  
        FT_UINT16, BASE_DEC, NULL, 0x0,
-       "Number of answers in packet" }},
+       "Number of answers in packet", HFILL }},
     { &hf_dns_count_auth_rr,
       { "Authority RRs",               "dns.count.auth_rr",  
        FT_UINT16, BASE_DEC, NULL, 0x0,
-       "Number of authoritative records in packet" }},
+       "Number of authoritative records in packet", HFILL }},
     { &hf_dns_count_add_rr,
       { "Additional RRs",              "dns.count.add_rr",  
        FT_UINT16, BASE_DEC, NULL, 0x0,
-       "Number of additional records in packet" }}
+       "Number of additional records in packet", HFILL }}
   };
   static gint *ett[] = {
     &ett_dns,
index 4335d0b82f8c84b8de1f1a973d2e2513addc3e74..0c1d72f44d7219f06c03f127f94d8c88c76f2662 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for dsi packet dissection
  * Copyright 2001, Randy McEoin <rmceoin@pe.com>
  *
- * $Id: packet-dsi.c,v 1.1 2001/05/24 20:25:24 guy Exp $
+ * $Id: packet-dsi.c,v 1.2 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -443,32 +443,32 @@ proto_register_dsi(void)
     { &hf_dsi_flags,
       { "Flags",            "dsi.flags",
        FT_UINT8, BASE_HEX, VALS(flag_vals), 0x0,
-       "Indicates request or reply." }},
+       "Indicates request or reply.", HFILL }},
 
     { &hf_dsi_command,
       { "Command",           "dsi.command",
        FT_UINT8, BASE_DEC, VALS(func_vals), 0x0,
-       "Represents a DSI command." }},
+       "Represents a DSI command.", HFILL }},
 
     { &hf_dsi_requestid,
       { "Request ID",           "dsi.requestid",
        FT_UINT16, BASE_DEC, NULL, 0x0,
-       "Keeps track of which request this is.  Replies must match a Request.  IDs must be generated in sequential order." }},
+       "Keeps track of which request this is.  Replies must match a Request.  IDs must be generated in sequential order.", HFILL }},
 
     { &hf_dsi_code,
       { "Code",           "dsi.code",
        FT_UINT32, BASE_HEX, NULL, 0x0,
-       "In Reply packets this is an error code.  In Request Write packets this is a data offset." }},
+       "In Reply packets this is an error code.  In Request Write packets this is a data offset.", HFILL }},
 
     { &hf_dsi_length,
       { "Length",           "dsi.length",
        FT_UINT32, BASE_DEC, NULL, 0x0,
-       "Total length of the data that follows the DSI header." }},
+       "Total length of the data that follows the DSI header.", HFILL }},
 
     { &hf_dsi_reserved,
       { "Reserved",           "dsi.reserved",
        FT_UINT32, BASE_HEX, NULL, 0x0,
-       "Reserved for future use.  Should be set to zero." }},
+       "Reserved for future use.  Should be set to zero.", HFILL }},
 
   };
   static gint *ett[] = {
index 51728ac1c3849e05708473eb30431b7ee84f8bdb..3b60a68b7424caa4068196d22c7c85295348a76c 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-dvmrp.c   2001 Ronnie Sahlberg <rsahlber@bigpond.net.au>
  * Routines for IGMP/DVMRP packet disassembly
  *
- * $Id: packet-dvmrp.c,v 1.1 2001/06/12 06:21:55 guy Exp $
+ * $Id: packet-dvmrp.c,v 1.2 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -684,135 +684,135 @@ proto_register_dvmrp(void)
        static hf_register_info hf[] = {
                { &hf_version,
                        { "DVMRP Version", "dvmrp.version", FT_UINT8, BASE_DEC,
-                         NULL, 0, "DVMRP Version" }},
+                         NULL, 0, "DVMRP Version", HFILL }},
 
                { &hf_type,
                        { "Type", "dvmrp.type", FT_UINT8, BASE_HEX,
-                         VALS(dvmrp_type), 0, "DVMRP Packet Type" }},
+                         VALS(dvmrp_type), 0, "DVMRP Packet Type", HFILL }},
 
                { &hf_code_v1,
                        { "Code", "dvmrp.v1.code", FT_UINT8, BASE_HEX,
-                         VALS(code_v1), 0, "DVMRP Packet Code" }},
+                         VALS(code_v1), 0, "DVMRP Packet Code", HFILL }},
 
                { &hf_checksum,
                        { "Checksum", "dvmrp.checksum", FT_UINT16, BASE_HEX,
-                         NULL, 0, "DVMRP Checksum" }},
+                         NULL, 0, "DVMRP Checksum", HFILL }},
 
                { &hf_checksum_bad,
                        { "Bad Checksum", "dvmrp.checksum_bad", FT_BOOLEAN, BASE_NONE,
-                         NULL, 0, "Bad DVMRP Checksum" }},
+                         NULL, 0, "Bad DVMRP Checksum", HFILL }},
 
                { &hf_commands,
                        { "Commands", "dvmrp.commands", FT_NONE, BASE_NONE,
-                         NULL, 0, "DVMRP V1 Commands" }},
+                         NULL, 0, "DVMRP V1 Commands", HFILL }},
 
                { &hf_command,
                        { "Command", "dvmrp.command", FT_UINT8, BASE_HEX,
-                         VALS(command), 0, "DVMRP V1 Command" }},
+                         VALS(command), 0, "DVMRP V1 Command", HFILL }},
 
                { &hf_afi,
                        { "Address Family", "dvmrp.afi", FT_UINT8, BASE_HEX,
-                         VALS(afi), 0, "DVMRP Address Family Indicator" }},
+                         VALS(afi), 0, "DVMRP Address Family Indicator", HFILL }},
 
                { &hf_count,
                        { "Count", "dvmrp.count", FT_UINT8, BASE_HEX,
-                         NULL, 0, "Count" }},
+                         NULL, 0, "Count", HFILL }},
 
                { &hf_netmask,
                        { "Netmask", "igmp.netmask", FT_IPv4, BASE_NONE,
-                         NULL, 0, "DVMRP Netmask" }},
+                         NULL, 0, "DVMRP Netmask", HFILL }},
 
                { &hf_metric,
                        { "Metric", "dvmrp.metric", FT_UINT8, BASE_DEC,
-                         NULL, 0, "DVMRP Metric" }},
+                         NULL, 0, "DVMRP Metric", HFILL }},
 
                {&hf_dest_unr,
                        { "Destination Unreachable", "dvmrp.dest_unreach", FT_BOOLEAN, 8,
-                       TFS(&tfs_dest_unreach), 0x01, "Destination Unreachable" }},
+                       TFS(&tfs_dest_unreach), 0x01, "Destination Unreachable", HFILL }},
 
                {&hf_split_horiz,
                        { "Split Horizon", "dvmrp.split_horiz", FT_BOOLEAN, 8,
-                       TFS(&tfs_split_horiz), 0x02, "Split Horizon concealed route" }},
+                       TFS(&tfs_split_horiz), 0x02, "Split Horizon concealed route", HFILL }},
 
                { &hf_infinity,
                        { "Infinity", "dvmrp.infinity", FT_UINT8, BASE_DEC,
-                         NULL, 0, "DVMRP Infinity" }},
+                         NULL, 0, "DVMRP Infinity", HFILL }},
 
                { &hf_daddr,
                        { "Dest Addr", "igmp.daddr", FT_IPv4, BASE_NONE,
-                         NULL, 0, "DVMRP Destination Address" }},
+                         NULL, 0, "DVMRP Destination Address", HFILL }},
 
                { &hf_maddr,
                        { "Multicast Addr", "igmp.maddr", FT_IPv4, BASE_NONE,
-                         NULL, 0, "DVMRP Multicast Address" }},
+                         NULL, 0, "DVMRP Multicast Address", HFILL }},
 
                { &hf_hold,
                        { "Hold Time", "dvmrp.hold", FT_UINT32, BASE_DEC,
-                         NULL, 0, "DVMRP Hold Time in seconds" }},
+                         NULL, 0, "DVMRP Hold Time in seconds", HFILL }},
 
                { &hf_code_v3,
                        { "Code", "dvmrp.v3.code", FT_UINT8, BASE_HEX,
-                         VALS(code_v3), 0, "DVMRP Packet Code" }},
+                         VALS(code_v3), 0, "DVMRP Packet Code", HFILL }},
 
                { &hf_capabilities,
                        { "Capabilities", "dvmrp.capabilities", FT_NONE, BASE_NONE,
-                         NULL, 0, "DVMRP V3 Capabilities" }},
+                         NULL, 0, "DVMRP V3 Capabilities", HFILL }},
 
                {&hf_cap_leaf,
                        { "Leaf", "dvmrp.cap.leaf", FT_BOOLEAN, 8,
-                       TFS(&tfs_cap_leaf), DVMRP_V3_CAP_LEAF, "Leaf" }},
+                       TFS(&tfs_cap_leaf), DVMRP_V3_CAP_LEAF, "Leaf", HFILL }},
 
                {&hf_cap_prune,
                        { "Prune", "dvmrp.cap.prune", FT_BOOLEAN, 8,
-                       TFS(&tfs_cap_prune), DVMRP_V3_CAP_PRUNE, "Prune capability" }},
+                       TFS(&tfs_cap_prune), DVMRP_V3_CAP_PRUNE, "Prune capability", HFILL }},
 
                {&hf_cap_genid,
                        { "Genid", "dvmrp.cap.genid", FT_BOOLEAN, 8,
-                       TFS(&tfs_cap_genid), DVMRP_V3_CAP_GENID, "Genid capability" }},
+                       TFS(&tfs_cap_genid), DVMRP_V3_CAP_GENID, "Genid capability", HFILL }},
 
                {&hf_cap_mtrace,
                        { "Mtrace", "dvmrp.cap.mtrace", FT_BOOLEAN, 8,
-                       TFS(&tfs_cap_mtrace), DVMRP_V3_CAP_MTRACE, "Mtrace capability" }},
+                       TFS(&tfs_cap_mtrace), DVMRP_V3_CAP_MTRACE, "Mtrace capability", HFILL }},
 
                {&hf_cap_snmp,
                        { "SNMP", "dvmrp.cap.snmp", FT_BOOLEAN, 8,
-                       TFS(&tfs_cap_snmp), DVMRP_V3_CAP_SNMP, "SNMP capability" }},
+                       TFS(&tfs_cap_snmp), DVMRP_V3_CAP_SNMP, "SNMP capability", HFILL }},
 
                {&hf_cap_netmask,
                        { "Netmask", "dvmrp.cap.netmask", FT_BOOLEAN, 8,
-                       TFS(&tfs_cap_netmask), DVMRP_V3_CAP_NETMASK, "Netmask capability" }},
+                       TFS(&tfs_cap_netmask), DVMRP_V3_CAP_NETMASK, "Netmask capability", HFILL }},
 
                { &hf_min_ver,
                        { "Minor Version", "dvmrp.min_ver", FT_UINT8, BASE_HEX,
-                         NULL, 0, "DVMRP Minor Version" }},
+                         NULL, 0, "DVMRP Minor Version", HFILL }},
 
                { &hf_maj_ver,
                        { "Major Version", "dvmrp.maj_ver", FT_UINT8, BASE_HEX,
-                         NULL, 0, "DVMRP Major Version" }},
+                         NULL, 0, "DVMRP Major Version", HFILL }},
 
                { &hf_genid,
                        { "Generation ID", "dvmrp.genid", FT_UINT32, BASE_DEC,
-                         NULL, 0, "DVMRP Generation ID" }},
+                         NULL, 0, "DVMRP Generation ID", HFILL }},
 
                { &hf_naddr,
                        { "Neighbor Addr", "igmp.naddr", FT_IPv4, BASE_NONE,
-                         NULL, 0, "DVMRP Neighbor Address" }},
+                         NULL, 0, "DVMRP Neighbor Address", HFILL }},
 
                { &hf_route,
                        { "Route", "dvmrp.route", FT_NONE, BASE_NONE,
-                         NULL, 0, "DVMRP V3 Route Report" }},
+                         NULL, 0, "DVMRP V3 Route Report", HFILL }},
 
                { &hf_saddr,
                        { "Source Addr", "igmp.saddr", FT_IPv4, BASE_NONE,
-                         NULL, 0, "DVMRP Source Address" }},
+                         NULL, 0, "DVMRP Source Address", HFILL }},
 
                { &hf_life,
                        { "Prune lifetime", "dvmrp.lifetime", FT_UINT32, BASE_DEC,
-                         NULL, 0, "DVMRP Prune Lifetime" }},
+                         NULL, 0, "DVMRP Prune Lifetime", HFILL }},
 
                { &hf_neighbor,
                        { "Neighbor Addr", "igmp.neighbor", FT_IPv4, BASE_NONE,
-                         NULL, 0, "DVMRP Neighbor Address" }},
+                         NULL, 0, "DVMRP Neighbor Address", HFILL }},
 
        };
        static gint *ett[] = {
index 6c85c338a02934546d7ddf93e8283eb6b2d53481..9125486f9682cab9228a43a3713b465ca1bffad0 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for EIGRP dissection
  * Copyright 2000, Paul Ionescu <paul@acorp.ro>
  *
- * $Id: packet-eigrp.c,v 1.16 2001/05/03 22:50:33 guy Exp $
+ * $Id: packet-eigrp.c,v 1.17 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -449,17 +449,17 @@ proto_register_eigrp(void)
    { &hf_eigrp_opcode,
     { "Opcode", "eigrp.opcode",
      FT_UINT8, BASE_DEC, NULL, 0x0 ,
-     "Opcode number" },
+     "Opcode number", HFILL }
      },
    { &hf_eigrp_as,
     { "Autonomous System  ", "eigrp.as",
       FT_UINT16, BASE_DEC, NULL, 0x0 ,
-     "Autonomous System number" }
+     "Autonomous System number", HFILL }
     },
    { &hf_eigrp_tlv,
     { "Entry  ",           "eigrp.tlv",
       FT_UINT16, BASE_DEC, NULL, 0x0 ,
-     "Type/Length/Value" }
+     "Type/Length/Value", HFILL }
     },
    };
                                                        
index 51b78a01836c8c4c8b8bfc26799eda85060e175a..61512164b1e06109fe295b33a79b58b2832d6efe 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for ISO/OSI End System to Intermediate System  
  * Routeing Exchange Protocol ISO 9542.
  *
- * $Id: packet-esis.c,v 1.15 2001/06/05 09:06:19 guy Exp $
+ * $Id: packet-esis.c,v 1.16 2001/06/18 02:17:46 guy Exp $
  * Ralf Schneider <Ralf.Schneider@t-online.de>
  *
  * Ethereal - Network traffic analyzer
@@ -418,20 +418,20 @@ proto_register_esis(void) {
   static hf_register_info hf[] = {
     { &hf_esis_nlpi,
       { "Network Layer Protocol Identifier", "esis.nlpi",      
-        FT_UINT8, BASE_HEX, VALS(nlpid_vals), 0x0, ""                       }},
+        FT_UINT8, BASE_HEX, VALS(nlpid_vals), 0x0, "", HFILL }},
     { &hf_esis_length,
-      { "PDU Length    ", "esis.length", FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+      { "PDU Length    ", "esis.length", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
     { &hf_esis_version,
-      { "Version (==1) ", "esis.ver",    FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+      { "Version (==1) ", "esis.ver",    FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
     { &hf_esis_reserved,
-      { "Reserved(==0) ", "esis.res",    FT_UINT8, BASE_DEC, NULL, 0x0, "" }},
+      { "Reserved(==0) ", "esis.res",    FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
     { &hf_esis_type,
       { "PDU Type      ", "esis.type",   FT_UINT8, BASE_DEC, VALS(esis_vals),
-         0xff, "" }},
+         0xff, "", HFILL }},
     { &hf_esis_holdtime,
-      { "Holding Time  ", "esis.htime",  FT_UINT16, BASE_DEC, NULL, 0x0, " s"}},
+      { "Holding Time  ", "esis.htime",  FT_UINT16, BASE_DEC, NULL, 0x0, " s", HFILL }},
     { &hf_esis_checksum,
-      { "Checksum      ", "esis.chksum", FT_UINT16, BASE_HEX, NULL, 0x0, "" }}
+      { "Checksum      ", "esis.chksum", FT_UINT16, BASE_HEX, NULL, 0x0, "", HFILL }}
   };
   /*
    * 
index 6fac1813dadd63e10d9dd0a49fddac8ea36c77d3..ec2aea8e63f996543bcea236b9c1320266e32c02 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-eth.c
  * Routines for ethernet packet disassembly
  *
- * $Id: packet-eth.c,v 1.64 2001/04/17 06:43:18 guy Exp $
+ * $Id: packet-eth.c,v 1.65 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -266,27 +266,27 @@ proto_register_eth(void)
 
                { &hf_eth_dst,
                { "Destination",        "eth.dst", FT_ETHER, BASE_NONE, NULL, 0x0,
-                       "Destination Hardware Address" }},
+                       "Destination Hardware Address", HFILL }},
 
                { &hf_eth_src,
                { "Source",             "eth.src", FT_ETHER, BASE_NONE, NULL, 0x0,
-                       "Source Hardware Address" }},
+                       "Source Hardware Address", HFILL }},
 
                { &hf_eth_len,
                { "Length",             "eth.len", FT_UINT16, BASE_DEC, NULL, 0x0,
-                       "" }},
+                       "", HFILL }},
 
                /* registered here but handled in ethertype.c */
                { &hf_eth_type,
                { "Type",               "eth.type", FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0,
-                       "" }},
+                       "", HFILL }},
                { &hf_eth_addr,
                { "Source or Destination Address", "eth.addr", FT_ETHER, BASE_NONE, NULL, 0x0,
-                       "Source or Destination Hardware Address" }},
+                       "Source or Destination Hardware Address", HFILL }},
 
                 { &hf_eth_trailer,
                { "Trailer", "eth.trailer", FT_BYTES, BASE_NONE, NULL, 0x0,
-                       "Ethernet Trailer or Checksum" }},
+                       "Ethernet Trailer or Checksum", HFILL }},
 
        };
        static gint *ett[] = {
index 159f01bfefe68809b2b3dbdb5ed8b73e9c559f83..cffa8115ff980a6a47cf07f5e5acf9bb13588eaa 100644 (file)
@@ -3,7 +3,7 @@
  *
  * Laurent Deniel <deniel@worldnet.fr>
  *
- * $Id: packet-fddi.c,v 1.48 2001/01/21 22:10:22 guy Exp $
+ * $Id: packet-fddi.c,v 1.49 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -349,19 +349,19 @@ proto_register_fddi(void)
                 */
                { &hf_fddi_fc,
                { "Frame Control",      "fddi.fc", FT_UINT8, BASE_HEX, NULL, 0x0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_fddi_dst,
                { "Destination",        "fddi.dst", FT_ETHER, BASE_NONE, NULL, 0x0,
-                       "Destination Hardware Address" }},
+                       "Destination Hardware Address", HFILL }},
 
                { &hf_fddi_src,
                { "Source",             "fddi.src", FT_ETHER, BASE_NONE, NULL, 0x0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_fddi_addr,
                { "Source or Destination Address", "fddi.addr", FT_ETHER, BASE_NONE, NULL, 0x0,
-                       "Source or Destination Hardware Address" }},
+                       "Source or Destination Hardware Address", HFILL }},
 
        };
        static gint *ett[] = {
index b38d6c786aa11762b84686f813bf03c8928d83bd..d79628f6b1138fa75c4a4a69df08551c808a7c0b 100644 (file)
@@ -3,7 +3,7 @@
  *
  * Copyright 2001, Paul Ionescu        <paul@acorp.ro>
  *
- * $Id: packet-fr.c,v 1.17 2001/04/17 06:43:18 guy Exp $
+ * $Id: packet-fr.c,v 1.18 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -372,41 +372,41 @@ void proto_register_fr(void)
 
         { &hf_fr_dlci, { 
            "DLCI", "fr.dlci", FT_UINT16, BASE_DEC, 
-            NULL, FRELAY_DLCI, "Data-Link Connection Identifier" }},
+            NULL, FRELAY_DLCI, "Data-Link Connection Identifier", HFILL }},
         { &hf_fr_cr, { 
            "CR", "fr.cr", FT_BOOLEAN, 16, TFS(&cmd_string),
-            FRELAY_CR, "Command/Response" }},
+            FRELAY_CR, "Command/Response", HFILL }},
         { &hf_fr_dc, { 
            "DC", "fr.dc", FT_BOOLEAN, 16, TFS(&ctrl_string),
-            FRELAY_CR, "Address/Control" }},
+            FRELAY_CR, "Address/Control", HFILL }},
 
         { &hf_fr_fecn, { 
            "FECN", "fr.fecn", FT_BOOLEAN, 16, 
-            NULL, FRELAY_FECN, "Forward Explicit Congestion Notification" }},
+            NULL, FRELAY_FECN, "Forward Explicit Congestion Notification", HFILL }},
         { &hf_fr_becn, { 
            "BECN", "fr.becn", FT_BOOLEAN, 16, 
-            NULL, FRELAY_BECN, "Backward Explicit Congestion Notification" }},
+            NULL, FRELAY_BECN, "Backward Explicit Congestion Notification", HFILL }},
         { &hf_fr_de, { 
            "DE", "fr.de", FT_BOOLEAN, 16, 
-            NULL, FRELAY_DE, "Discard Eligibility" }},
+            NULL, FRELAY_DE, "Discard Eligibility", HFILL }},
         { &hf_fr_ea, { 
            "EA", "fr.ea", FT_BOOLEAN, 16, TFS(&ea_string),
-            FRELAY_EA, "Extended Address" }},
+            FRELAY_EA, "Extended Address", HFILL }},
         { &hf_fr_nlpid, { 
            "NLPID", "fr.nlpid", FT_UINT8, BASE_HEX, 
-            VALS(fr_nlpid_vals), 0x0, "FrameRelay Encapsulated Protocol NLPID" }},
+            VALS(fr_nlpid_vals), 0x0, "FrameRelay Encapsulated Protocol NLPID", HFILL }},
        { &hf_fr_oui, {
           "Organization Code", "fr.snap.oui", FT_UINT24, BASE_HEX, 
-          VALS(oui_vals), 0x0, ""}},
+          VALS(oui_vals), 0x0, "", HFILL }},
        { &hf_fr_pid, {
           "Protocol ID", "fr.snap.pid", FT_UINT16, BASE_HEX, 
-          NULL, 0x0, ""}},
+          NULL, 0x0, "", HFILL }},
         { &hf_fr_snaptype, { 
            "Type", "fr.snaptype", FT_UINT16, BASE_HEX, 
-            VALS(etype_vals), 0x0, "FrameRelay SNAP Encapsulated Protocol" }},
+            VALS(etype_vals), 0x0, "FrameRelay SNAP Encapsulated Protocol", HFILL }},
         { &hf_fr_chdlctype, { 
            "Type", "fr.chdlctype", FT_UINT16, BASE_HEX, 
-            VALS(chdlc_vals), 0x0, "FrameRelay Cisco HDLC Encapsulated Protocol" }},
+            VALS(chdlc_vals), 0x0, "FrameRelay Cisco HDLC Encapsulated Protocol", HFILL }},
   };
 
 
index cd698e72800a18f51f00ff408f01d9d9e669977c..419bca6994a9b6847223947e071fae80bfd98457 100644 (file)
@@ -2,7 +2,7 @@
  *
  * Top-most dissector. Decides dissector based on Wiretap Encapsulation Type.
  *
- * $Id: packet-frame.c,v 1.7 2001/04/01 21:12:05 hagbard Exp $
+ * $Id: packet-frame.c,v 1.8 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -151,33 +151,33 @@ proto_register_frame(void)
        static hf_register_info hf[] = {
                { &hf_frame_arrival_time,
                { "Arrival Time",               "frame.time", FT_ABSOLUTE_TIME, BASE_NONE, NULL, 0x0,
-                       ""}},
+                       "", HFILL }},
 
                { &hf_frame_time_delta,
                { "Time delta from previous packet",    "frame.time_delta", FT_RELATIVE_TIME, BASE_NONE, NULL,
                        0x0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_frame_time_relative,
                { "Time relative to first packet",      "frame.time_relative", FT_RELATIVE_TIME, BASE_NONE, NULL,
                        0x0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_frame_number,
                { "Frame Number",               "frame.number", FT_UINT32, BASE_DEC, NULL, 0x0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_frame_packet_len,
                { "Total Frame Length",         "frame.pkt_len", FT_UINT32, BASE_DEC, NULL, 0x0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_frame_capture_len,
                { "Capture Frame Length",       "frame.cap_len", FT_UINT32, BASE_DEC, NULL, 0x0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_frame_p2p_dir,
                { "Point-to-Point Direction",   "frame.p2p_dir", FT_UINT8, BASE_DEC, VALS(p2p_dirs), 0x0,
-                       "" }},
+                       "", HFILL }},
        };
        static gint *ett[] = {
                &ett_frame,
index a3ef9f5294db3a908bb87cff1f4895c69a0dc21e..645b754663067cd573d788a386b0156942b4de65 100644 (file)
@@ -3,7 +3,7 @@
  * Copyright 1999, Richard Sharpe <rsharpe@ns.aus.com>
  * Copyright 2001, Juan Toledo <toledo@users.sourceforge.net> (Passive FTP)
  * 
- * $Id: packet-ftp.c,v 1.29 2001/06/10 09:50:18 guy Exp $
+ * $Id: packet-ftp.c,v 1.30 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -264,32 +264,32 @@ proto_register_ftp(void)
     { &hf_ftp_response,
       { "Response",           "ftp.response",
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
-       "TRUE if FTP response" }},
+       "TRUE if FTP response", HFILL }},
 
     { &hf_ftp_request,
       { "Request",            "ftp.request",
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
-       "TRUE if FTP request" }},
+       "TRUE if FTP request", HFILL }},
 
     { &hf_ftp_request_command,
       { "Request command",    "ftp.request.command",
        FT_STRING,  BASE_NONE, NULL, 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_ftp_request_data,
       { "Request data",              "ftp.request.data",
        FT_STRING,  BASE_NONE, NULL, 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_ftp_response_code,
       { "Response code",      "ftp.response.code",
        FT_UINT8,   BASE_DEC, NULL, 0x0,
-       "" }},
+       "", HFILL }},
 
     { &hf_ftp_response_data,
       { "Response data",      "ftp.reponse.data",
        FT_STRING,  BASE_NONE, NULL, 0x0,
-       "" }}
+       "", HFILL }}
   };
   static gint *ett[] = {
     &ett_ftp,
index 8cb4a320a0259c4da79ea3612624855594dd96ca..20ac19ed8f2af210033176fc14c4c3f23d72b1f3 100644 (file)
@@ -4,7 +4,7 @@
  * Laurent Deniel <deniel@worldnet.fr>
  * Craig Rodrigues <rodrigc@mediaone.net>
  *
- * $Id: packet-giop.c,v 1.33 2001/06/18 01:49:16 guy Exp $
+ * $Id: packet-giop.c,v 1.34 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -204,7 +204,7 @@ static const value_string reply_status_types[] = {
    { SYSTEM_EXCEPTION, "System Exception" } ,
    { LOCATION_FORWARD, "Location Forward" } ,
    { LOCATION_FORWARD_PERM, "Location Forward Perm" } ,
-   { NEEDS_ADDRESSING_MODE, "Needs Addressing Mode"} ,
+   { NEEDS_ADDRESSING_MODE, "Needs Addressing Mode" } ,
    { 0, NULL }
 };
 
@@ -1402,14 +1402,14 @@ proto_register_giop (void)
      &hf_giop_message_type,
      {
       "Message type", "giop.type",
-      FT_UINT8, BASE_DEC, NULL, 0x0, ""}
+      FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }
      }
     ,
     {
      &hf_giop_message_size,
      {
       "Message size", "giop.len",
-      FT_UINT32, BASE_DEC, NULL, 0x0, ""}
+      FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }
      }
     ,
   };
index 54ff88fab780abbfa7c496aadb0d4d0c1aed418e..8f67f2eddb53f99827ae153b0a1dc091378175d9 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for gnutella dissection
  * Copyright 2001, B. Johannessen <bob@havoq.com>
  *
- * $Id: packet-gnutella.c,v 1.1 2001/06/06 01:30:29 guy Exp $
+ * $Id: packet-gnutella.c,v 1.2 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -635,167 +635,167 @@ void proto_register_gnutella(void) {
                { &hf_gnutella_header,
                        { "Descriptor Header", "gnutella.header",
                        FT_NONE, BASE_NONE, NULL, 0,          
-                       "Gnutella Descriptor Header" }
+                       "Gnutella Descriptor Header", HFILL }
                },
                { &hf_gnutella_pong_payload,
                        { "Pong", "gnutella.pong.payload",
                        FT_NONE, BASE_NONE, NULL, 0,          
-                       "Gnutella Pong Payload" }
+                       "Gnutella Pong Payload", HFILL }
                },
                { &hf_gnutella_push_payload,
                        { "Push", "gnutella.push.payload",
                        FT_NONE, BASE_NONE, NULL, 0,          
-                       "Gnutella Push Payload" }
+                       "Gnutella Push Payload", HFILL }
                },
                { &hf_gnutella_query_payload,
                        { "Query", "gnutella.query.payload",
                        FT_NONE, BASE_NONE, NULL, 0,          
-                       "Gnutella Query Payload" }
+                       "Gnutella Query Payload", HFILL }
                },
                { &hf_gnutella_queryhit_payload,
                        { "QueryHit", "gnutella.queryhit.payload",
                        FT_NONE, BASE_NONE, NULL, 0,          
-                       "Gnutella QueryHit Payload" }
+                       "Gnutella QueryHit Payload", HFILL }
                },
                { &hf_gnutella_truncated,
                        { "Truncated Frame", "gnutella.truncated",
                        FT_NONE, BASE_NONE, NULL, 0,          
-                       "The Gnutella Frame Was Truncated" }
+                       "The Gnutella Frame Was Truncated", HFILL }
                },
                { &hf_gnutella_stream,
                        { "Gnutella Upload / Download Stream", "gnutella.stream",
                        FT_NONE, BASE_NONE, NULL, 0,          
-                       "Gnutella Upload / Download Stream" }
+                       "Gnutella Upload / Download Stream", HFILL }
                },
                { &hf_gnutella_header_id,
                        { "ID", "gnutella.header.id",
                        FT_BYTES, BASE_HEX, NULL, 0,          
-                       "Gnutella Descriptor ID" }
+                       "Gnutella Descriptor ID", HFILL }
                },
                { &hf_gnutella_header_payload,
                        { "Payload", "gnutella.header.payload",
                        FT_UINT8, BASE_DEC, NULL, 0,          
-                       "Gnutella Descriptor Payload" }
+                       "Gnutella Descriptor Payload", HFILL }
                },
                { &hf_gnutella_header_ttl,
                        { "TTL", "gnutella.header.ttl",
                        FT_UINT8, BASE_DEC, NULL, 0,          
-                       "Gnutella Descriptor Time To Live" }
+                       "Gnutella Descriptor Time To Live", HFILL }
                },
                { &hf_gnutella_header_hops,
                        { "Hops", "gnutella.header.hops",
                        FT_UINT8, BASE_DEC, NULL, 0,          
-                       "Gnutella Descriptor Hop Count" }
+                       "Gnutella Descriptor Hop Count", HFILL }
                },
                { &hf_gnutella_header_size,
                        { "Length", "gnutella.header.size",
                        FT_UINT8, BASE_DEC, NULL, 0,          
-                       "Gnutella Descriptor Payload Length" }
+                       "Gnutella Descriptor Payload Length", HFILL }
                },
                { &hf_gnutella_pong_port,
                        { "Port", "gnutella.pong.port",
                        FT_UINT16, BASE_DEC, NULL, 0,          
-                       "Gnutella Pong TCP Port" }
+                       "Gnutella Pong TCP Port", HFILL }
                },
                { &hf_gnutella_pong_ip,
                        { "IP", "gnutella.pong.ip",
                        FT_IPv4, BASE_DEC, NULL, 0,          
-                       "Gnutella Pong IP Address" }
+                       "Gnutella Pong IP Address", HFILL }
                },
                { &hf_gnutella_pong_files,
                        { "Files Shared", "gnutella.pong.files",
                        FT_UINT32, BASE_DEC, NULL, 0,          
-                       "Gnutella Pong Files Shared" }
+                       "Gnutella Pong Files Shared", HFILL }
                },
                { &hf_gnutella_pong_kbytes,
                        { "KBytes Shared", "gnutella.pong.kbytes",
                        FT_UINT32, BASE_DEC, NULL, 0,          
-                       "Gnutella Pong KBytes Shared" }
+                       "Gnutella Pong KBytes Shared", HFILL }
                },
                { &hf_gnutella_query_min_speed,
                        { "Min Speed", "gnutella.query.min_speed",
                        FT_UINT32, BASE_DEC, NULL, 0,          
-                       "Gnutella Query Minimum Speed" }
+                       "Gnutella Query Minimum Speed", HFILL }
                },
                { &hf_gnutella_query_search,
                        { "Search", "gnutella.query.search",
                        FT_STRINGZ, BASE_NONE, NULL, 0,          
-                       "Gnutella Query Search" }
+                       "Gnutella Query Search", HFILL }
                },
                { &hf_gnutella_queryhit_hit,
                        { "Hit", "gnutella.queryhit.hit",
                        FT_NONE, BASE_NONE, NULL, 0,          
-                       "Gnutella QueryHit" }
+                       "Gnutella QueryHit", HFILL }
                },
                { &hf_gnutella_queryhit_hit_index,
                        { "Index", "gnutella.queryhit.hit.index",
                        FT_UINT32, BASE_DEC, NULL, 0,          
-                       "Gnutella QueryHit Index" }
+                       "Gnutella QueryHit Index", HFILL }
                },
                { &hf_gnutella_queryhit_hit_size,
                        { "Size", "gnutella.queryhit.hit.size",
                        FT_UINT32, BASE_DEC, NULL, 0,          
-                       "Gnutella QueryHit Size" }
+                       "Gnutella QueryHit Size", HFILL }
                },
                { &hf_gnutella_queryhit_hit_name,
                        { "Name", "gnutella.queryhit.hit.name",
                        FT_STRING, BASE_NONE, NULL, 0,          
-                       "Gnutella Query Name" }
+                       "Gnutella Query Name", HFILL }
                },
                { &hf_gnutella_queryhit_hit_extra,
                        { "Extra", "gnutella.queryhit.hit.extra",
                        FT_BYTES, BASE_HEX, NULL, 0,          
-                       "Gnutella Query Extra" }
+                       "Gnutella Query Extra", HFILL }
                },
                { &hf_gnutella_queryhit_count,
                        { "Count", "gnutella.queryhit.count",
                        FT_UINT8, BASE_DEC, NULL, 0,          
-                       "Gnutella QueryHit Count" }
+                       "Gnutella QueryHit Count", HFILL }
                },
                { &hf_gnutella_queryhit_port,
                        { "Port", "gnutella.queryhit.port",
                        FT_UINT16, BASE_DEC, NULL, 0,          
-                       "Gnutella QueryHit Port" }
+                       "Gnutella QueryHit Port", HFILL }
                },
                { &hf_gnutella_queryhit_ip,
                        { "IP", "gnutella.queryhit.ip",
                        FT_IPv4, BASE_DEC, NULL, 0,          
-                       "Gnutella QueryHit IP Address" }
+                       "Gnutella QueryHit IP Address", HFILL }
                },
                { &hf_gnutella_queryhit_speed,
                        { "Speed", "gnutella.queryhit.speed",
                        FT_UINT32, BASE_DEC, NULL, 0,          
-                       "Gnutella QueryHit Speed" }
+                       "Gnutella QueryHit Speed", HFILL }
                },
                { &hf_gnutella_queryhit_extra,
                        { "Extra", "gnutella.queryhit.extra",
                        FT_BYTES, BASE_HEX, NULL, 0,          
-                       "Gnutella QueryHit Extra" }
+                       "Gnutella QueryHit Extra", HFILL }
                },
                { &hf_gnutella_queryhit_servent_id,
                        { "Servent ID", "gnutella.queryhit.servent_id",
                        FT_BYTES, BASE_HEX, NULL, 0,          
-                       "Gnutella QueryHit Servent ID" }
+                       "Gnutella QueryHit Servent ID", HFILL }
                },
                { &hf_gnutella_push_servent_id,
                        { "Servent ID", "gnutella.push.servent_id",
                        FT_BYTES, BASE_HEX, NULL, 0,          
-                       "Gnutella Push Servent ID" }
+                       "Gnutella Push Servent ID", HFILL }
                },
                { &hf_gnutella_push_ip,
                        { "IP", "gnutella.push.ip",
                        FT_IPv4, BASE_DEC, NULL, 0,          
-                       "Gnutella Push IP Address" }
+                       "Gnutella Push IP Address", HFILL }
                },
                { &hf_gnutella_push_index,
                        { "Index", "gnutella.push.index",
                        FT_UINT32, BASE_DEC, NULL, 0,          
-                       "Gnutella Push Index" }
+                       "Gnutella Push Index", HFILL }
                },
                { &hf_gnutella_push_port,
                        { "Port", "gnutella.push.port",
                        FT_UINT16, BASE_DEC, NULL, 0,          
-                       "Gnutella Push Port" }
+                       "Gnutella Push Port", HFILL }
                },
        };
 
index 11a71b6f72790394f9bb1da2fc1f4823eb5a3900..0f145c4aa1e40473da211ddef1100ecfae690606 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for the Generic Routing Encapsulation (GRE) protocol
  * Brad Robel-Forrest <brad.robel-forrest@watchguard.com>
  *
- * $Id: packet-gre.c,v 1.43 2001/04/23 18:11:01 guy Exp $
+ * $Id: packet-gre.c,v 1.44 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -340,7 +340,7 @@ proto_register_gre(void)
        static hf_register_info hf[] = {
                { &hf_gre_proto,
                        { "Protocol Type", "gre.proto", FT_UINT16, BASE_HEX, VALS(typevals), 0x0,
-                               "The protocol that is GRE encapsulated"}
+                               "The protocol that is GRE encapsulated", HFILL }
                },
        };
        static gint *ett[] = {
index 8955c8a306566912fda84fa694e50a412c08f8a0..9580413ed5fe66d44a36d2384de300f569d91483 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for GTP dissection
  * Copyright 2001, Michal Melerowicz <michal.melerowicz@nokia.com>
  *
- * $Id: packet-gtp.c,v 1.5 2001/04/23 18:05:18 guy Exp $
+ * $Id: packet-gtp.c,v 1.6 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -1988,84 +1988,84 @@ proto_register_gtp(void)
 
        static hf_register_info hf[] = {
 
-               { &hf_gtp_flags,                { "Flags",                              "gtp.flags",                            FT_UINT8,       BASE_HEX, NULL, 0, "Ver/PT/Res/E/S/PN" }},
-               { &hf_gtp_flags_ver,            { "Version",                    "gtp.flags.version",            FT_UINT8,       BASE_DEC, VALS(ver_types), GTP_VER_MASK, "GTP version" }},
-               { &hf_gtp_flags_pt,             { "Payload Type",               "gtp.flags.payload_type",       FT_UINT8,       BASE_DEC, NULL, GTP_PT_MASK, "Payload types" }},
-               { &hf_gtp_flags_spare,          { "Reserved",                   "gtp.flags.spare",                      FT_UINT8,       BASE_DEC, NULL, GTP_SPARE_MASK, "Reserved" }},
-               { &hf_gtp_flags_snn,            { "Is seq number",              "gtp.flags.snn",                        FT_UINT8,       BASE_DEC, NULL, GTP_SNN_MASK, "Is sequence number present" }},
-               { &hf_gtp_message_type,         { "Message type",               "gtp.message_type",                     FT_UINT8,       BASE_HEX, VALS(message_type), 0x0, "GTP message type" }},
-               { &hf_gtp_length,               { "Length",                     "gtp.length",                           FT_UINT16,      BASE_DEC, NULL, 0, "Length" }},
-               { &hf_gtp_seq_number,           { "Sequence number",    "gtp.seq_number",                       FT_UINT16,      BASE_HEX, NULL, 0, "Sequence number" }},
-               { &hf_gtp_flow_label,           { "Flow label",                 "gtp.flow_label",                       FT_UINT16,      BASE_HEX, NULL, 0, "Flow label" }},
-               { &hf_gtp_sndcp_number,         { "SNDCP N-PDU LLC Number", "gtp.sndcp_number",         FT_UINT8,       BASE_HEX, NULL, 0, "SNDCP N-PDU LLC Number" }},
-               { &hf_gtp_tid,                  { "Tunnel ID",                  "gtp.tid",                                      FT_STRING,      BASE_DEC, NULL, 0, "Tunnel ID" }},
-               { &hf_gtp_ext,                  { "Extension header",   "gtp.ext",                                      FT_UINT8,       BASE_HEX, NULL, 0, "Extension header" }},
+               { &hf_gtp_flags,                { "Flags",                              "gtp.flags",                            FT_UINT8,       BASE_HEX, NULL, 0, "Ver/PT/Res/E/S/PN", HFILL }},
+               { &hf_gtp_flags_ver,            { "Version",                    "gtp.flags.version",            FT_UINT8,       BASE_DEC, VALS(ver_types), GTP_VER_MASK, "GTP version", HFILL }},
+               { &hf_gtp_flags_pt,             { "Payload Type",               "gtp.flags.payload_type",       FT_UINT8,       BASE_DEC, NULL, GTP_PT_MASK, "Payload types", HFILL }},
+               { &hf_gtp_flags_spare,          { "Reserved",                   "gtp.flags.spare",                      FT_UINT8,       BASE_DEC, NULL, GTP_SPARE_MASK, "Reserved", HFILL }},
+               { &hf_gtp_flags_snn,            { "Is seq number",              "gtp.flags.snn",                        FT_UINT8,       BASE_DEC, NULL, GTP_SNN_MASK, "Is sequence number present", HFILL }},
+               { &hf_gtp_message_type,         { "Message type",               "gtp.message_type",                     FT_UINT8,       BASE_HEX, VALS(message_type), 0x0, "GTP message type", HFILL }},
+               { &hf_gtp_length,               { "Length",                     "gtp.length",                           FT_UINT16,      BASE_DEC, NULL, 0, "Length", HFILL }},
+               { &hf_gtp_seq_number,           { "Sequence number",    "gtp.seq_number",                       FT_UINT16,      BASE_HEX, NULL, 0, "Sequence number", HFILL }},
+               { &hf_gtp_flow_label,           { "Flow label",                 "gtp.flow_label",                       FT_UINT16,      BASE_HEX, NULL, 0, "Flow label", HFILL }},
+               { &hf_gtp_sndcp_number,         { "SNDCP N-PDU LLC Number", "gtp.sndcp_number",         FT_UINT8,       BASE_HEX, NULL, 0, "SNDCP N-PDU LLC Number", HFILL }},
+               { &hf_gtp_tid,                  { "Tunnel ID",                  "gtp.tid",                                      FT_STRING,      BASE_DEC, NULL, 0, "Tunnel ID", HFILL }},
+               { &hf_gtp_ext,                  { "Extension header",   "gtp.ext",                                      FT_UINT8,       BASE_HEX, NULL, 0, "Extension header", HFILL }},
                
-               { &hf_gtp_ext_cause,            { "Cause",                              "gtp.ext.cause",                        FT_UINT8,       BASE_DEC, VALS(cause_type), 0, "Cause of operation" }},
+               { &hf_gtp_ext_cause,            { "Cause",                              "gtp.ext.cause",                        FT_UINT8,       BASE_DEC, VALS(cause_type), 0, "Cause of operation", HFILL }},
        
-               { &hf_gtp_ext_imsi,             { "IMSI",                               "gtp.ext.imsi",                         FT_STRING,      BASE_DEC, NULL, 0, "IMSI number" }},
+               { &hf_gtp_ext_imsi,             { "IMSI",                               "gtp.ext.imsi",                         FT_STRING,      BASE_DEC, NULL, 0, "IMSI number", HFILL }},
        
-               { &hf_gtp_ext_rai_mcc,          { "MCC",                                "gtp.ext.mcc",                          FT_UINT16,      BASE_DEC, NULL, 0, "Mobile Country Code" }},
-               { &hf_gtp_ext_rai_mnc,          { "MNC",                                "gtp.ext.mnc",                          FT_UINT8,       BASE_DEC, NULL, 0, "Mobile National Code" }},
-               { &hf_gtp_ext_rai_rac,          { "RAC",                                "gtp.ext.rac",                          FT_UINT8,       BASE_DEC, NULL, 0, "Routing Area" }},
-               { &hf_gtp_ext_rai_lac,          { "LAC",                                "gtp.ext.lac",                          FT_UINT16,      BASE_DEC, NULL, 0, "Location Area" }},
+               { &hf_gtp_ext_rai_mcc,          { "MCC",                                "gtp.ext.mcc",                          FT_UINT16,      BASE_DEC, NULL, 0, "Mobile Country Code", HFILL }},
+               { &hf_gtp_ext_rai_mnc,          { "MNC",                                "gtp.ext.mnc",                          FT_UINT8,       BASE_DEC, NULL, 0, "Mobile National Code", HFILL }},
+               { &hf_gtp_ext_rai_rac,          { "RAC",                                "gtp.ext.rac",                          FT_UINT8,       BASE_DEC, NULL, 0, "Routing Area", HFILL }},
+               { &hf_gtp_ext_rai_lac,          { "LAC",                                "gtp.ext.lac",                          FT_UINT16,      BASE_DEC, NULL, 0, "Location Area", HFILL }},
                
-               { &hf_gtp_ext_tlli,             { "TLLI",                               "gtp.ext.tlli",                         FT_UINT32,      BASE_HEX, NULL, 0, "Temporary Logical Link Identity" }},
+               { &hf_gtp_ext_tlli,             { "TLLI",                               "gtp.ext.tlli",                         FT_UINT32,      BASE_HEX, NULL, 0, "Temporary Logical Link Identity", HFILL }},
                
-               { &hf_gtp_ext_ptmsi,            { "P-TMSI",                             "gtp.ext.ptmsi",                        FT_UINT32,      BASE_HEX, NULL, 0, "Packet TMSI" }},
+               { &hf_gtp_ext_ptmsi,            { "P-TMSI",                             "gtp.ext.ptmsi",                        FT_UINT32,      BASE_HEX, NULL, 0, "Packet TMSI", HFILL }},
                
-               { &hf_gtp_ext_qos_delay,        { "QoS delay",                  "gtp.ext.qos_delay",            FT_UINT8,       BASE_DEC, VALS(qos_delay_type), 0, "QoS delay class" }},
-               { &hf_gtp_ext_qos_reliability,  { "QoS reliability","gtp.ext.qos_reliabilty",   FT_UINT8,       BASE_DEC, VALS(qos_reliability_type), 0, "QoS reliability class" }},
-               { &hf_gtp_ext_qos_peak,         { "QoS peak",                   "gtp.ext.qos_peak",             FT_UINT8,       BASE_DEC, VALS(qos_peak_type), 0, "QoS peak throughput" }},
-               { &hf_gtp_ext_qos_precedence,   { "QoS precedence",     "gtp.ext.qos_precedence",       FT_UINT8,       BASE_DEC, VALS(qos_precedence_type), 0, "QoS precedence class" }},
-               { &hf_gtp_ext_qos_mean,         { "QoS mean",                   "gtp.ext.qos_mean",             FT_UINT8,       BASE_DEC, VALS(qos_mean_type), 0, "QoS mean throughput" }},
+               { &hf_gtp_ext_qos_delay,        { "QoS delay",                  "gtp.ext.qos_delay",            FT_UINT8,       BASE_DEC, VALS(qos_delay_type), 0, "QoS delay class", HFILL }},
+               { &hf_gtp_ext_qos_reliability,  { "QoS reliability","gtp.ext.qos_reliabilty",   FT_UINT8,       BASE_DEC, VALS(qos_reliability_type), 0, "QoS reliability class", HFILL }},
+               { &hf_gtp_ext_qos_peak,         { "QoS peak",                   "gtp.ext.qos_peak",             FT_UINT8,       BASE_DEC, VALS(qos_peak_type), 0, "QoS peak throughput", HFILL }},
+               { &hf_gtp_ext_qos_precedence,   { "QoS precedence",     "gtp.ext.qos_precedence",       FT_UINT8,       BASE_DEC, VALS(qos_precedence_type), 0, "QoS precedence class", HFILL }},
+               { &hf_gtp_ext_qos_mean,         { "QoS mean",                   "gtp.ext.qos_mean",             FT_UINT8,       BASE_DEC, VALS(qos_mean_type), 0, "QoS mean throughput", HFILL }},
                
-               { &hf_gtp_ext_reorder,          { "Reordering required", "gtp.ext.reorder",             FT_BOOLEAN, BASE_NONE, NULL, 0, "Reordering required" }},
+               { &hf_gtp_ext_reorder,          { "Reordering required", "gtp.ext.reorder",             FT_BOOLEAN, BASE_NONE, NULL, 0, "Reordering required", HFILL }},
                
-/*             { &hf_gtp_ext_auth_rand,        { "Authentication RAND", "gtp.ext.auth_rand",           FT_STRING,      BASE_DEC, NULL, 0, "Authentication RAND" }},
-               { &hf_gtp_ext_auth_sres,        { "Authentication SRES", "gtp.ext.auth_sres",           FT_STRING,      BASE_DEC, NULL, 0, "Authentication SRES" }},
-               { &hf_gtp_ext_auth_kc,          { "Authentication Kc",  "gtp.ext.auth_kc",                      FT_STRING,      BASE_DEC, NULL, 0, "Authentication Kc" }},
+/*             { &hf_gtp_ext_auth_rand,        { "Authentication RAND", "gtp.ext.auth_rand",           FT_STRING,      BASE_DEC, NULL, 0, "Authentication RAND", HFILL }},
+               { &hf_gtp_ext_auth_sres,        { "Authentication SRES", "gtp.ext.auth_sres",           FT_STRING,      BASE_DEC, NULL, 0, "Authentication SRES", HFILL }},
+               { &hf_gtp_ext_auth_kc,          { "Authentication Kc",  "gtp.ext.auth_kc",                      FT_STRING,      BASE_DEC, NULL, 0, "Authentication Kc", HFILL }},
 */             
-               { &hf_gtp_ext_map,              { "Ext type",                   "gtp.ext.map",                          FT_UINT8,       BASE_DEC, VALS(map_cause_type), 0, "MAP cause" }},
+               { &hf_gtp_ext_map,              { "Ext type",                   "gtp.ext.map",                          FT_UINT8,       BASE_DEC, VALS(map_cause_type), 0, "MAP cause", HFILL }},
                
-               { &hf_gtp_ext_ptmsi_sig,        { "P-TMSI signature",   "gtp.ext.ptmsi_sig",            FT_UINT24,      BASE_HEX, NULL, 0, "P-TMSI signature" }},
+               { &hf_gtp_ext_ptmsi_sig,        { "P-TMSI signature",   "gtp.ext.ptmsi_sig",            FT_UINT24,      BASE_HEX, NULL, 0, "P-TMSI signature", HFILL }},
                
-               { &hf_gtp_ext_ms,               { "MS validated",               "gtp.ext.ms",                           FT_BOOLEAN,     BASE_NONE, NULL, 0, "MS validated" }},
+               { &hf_gtp_ext_ms,               { "MS validated",               "gtp.ext.ms",                           FT_BOOLEAN,     BASE_NONE, NULL, 0, "MS validated", HFILL }},
                
-               { &hf_gtp_ext_recover,          { "Restart counter",    "gtp.ext.recover",                      FT_UINT8,       BASE_DEC, NULL, 0, "Restart counter" }},
+               { &hf_gtp_ext_recover,          { "Restart counter",    "gtp.ext.recover",                      FT_UINT8,       BASE_DEC, NULL, 0, "Restart counter", HFILL }},
                
-               { &hf_gtp_ext_sel_mode,         { "Selection mode",     "gtp.ext.sel_mode",             FT_UINT8,       BASE_DEC, VALS(sel_mode_type), 0, "Selection mode" }},
+               { &hf_gtp_ext_sel_mode,         { "Selection mode",     "gtp.ext.sel_mode",             FT_UINT8,       BASE_DEC, VALS(sel_mode_type), 0, "Selection mode", HFILL }},
                
-               { &hf_gtp_ext_flow_label,       { "Flow label",                 "gtp.ext.flow_label",           FT_UINT16,      BASE_DEC, NULL, 0, "Flow label" }},
+               { &hf_gtp_ext_flow_label,       { "Flow label",                 "gtp.ext.flow_label",           FT_UINT16,      BASE_DEC, NULL, 0, "Flow label", HFILL }},
                
-               { &hf_gtp_ext_flow_sig,         { "Flow label signature", "gtp.ext.flow_sig",           FT_UINT16,      BASE_DEC, NULL, 0, "Flow label signature" }},
+               { &hf_gtp_ext_flow_sig,         { "Flow label signature", "gtp.ext.flow_sig",           FT_UINT16,      BASE_DEC, NULL, 0, "Flow label signature", HFILL }},
                
-               { &hf_gtp_ext_flow_ii_nsapi,{ "NSAPI",                          "gtp.ext.flow_ii_nsapi",        FT_UINT8,       BASE_HEX, NULL, 0, "NSAPI" }},
-               { &hf_gtp_ext_flow_ii,          { "Downlink flow label data", "gtp.ext.flow_ii",        FT_UINT16,      BASE_DEC, NULL, 0, "Downlink flow label data" }},
+               { &hf_gtp_ext_flow_ii_nsapi,{ "NSAPI",                          "gtp.ext.flow_ii_nsapi",        FT_UINT8,       BASE_HEX, NULL, 0, "NSAPI", HFILL }},
+               { &hf_gtp_ext_flow_ii,          { "Downlink flow label data", "gtp.ext.flow_ii",        FT_UINT16,      BASE_DEC, NULL, 0, "Downlink flow label data", HFILL }},
                
-               { &hf_gtp_ext_tr_comm,          { "Transfer command",   "gtp.ext.tr_comm",                      FT_UINT8,       BASE_DEC, VALS(tr_comm_type), 0, "Packet transfer command" }},
-               { &hf_gtp_ext_chrg_id,          { "Charging ID",                "gtp.ext.chrg_id",                      FT_UINT32,      BASE_HEX, NULL, 0, "Charging ID" }},
+               { &hf_gtp_ext_tr_comm,          { "Transfer command",   "gtp.ext.tr_comm",                      FT_UINT8,       BASE_DEC, VALS(tr_comm_type), 0, "Packet transfer command", HFILL }},
+               { &hf_gtp_ext_chrg_id,          { "Charging ID",                "gtp.ext.chrg_id",                      FT_UINT32,      BASE_HEX, NULL, 0, "Charging ID", HFILL }},
                
-               { &hf_gtp_ext_user_addr,        { "End user address",   "gtp.ext.user_addr",            FT_IPv4,        BASE_DEC, NULL, 0, "End user address" }},
-               { &hf_gtp_ext_user_addr_pdp_type,       { "PDP type",   "gtp.ext.user_addr_pdp_type",           FT_UINT8,       BASE_HEX, VALS(pdp_type), 0, "PDP type" }},
-               { &hf_gtp_ext_user_addr_pdp_org,        { "PDP type organization",      "gtp.ext.user_addr_pdp_org",            FT_UINT8,       BASE_DEC, NULL, 0, "PDP type organization" }},
+               { &hf_gtp_ext_user_addr,        { "End user address",   "gtp.ext.user_addr",            FT_IPv4,        BASE_DEC, NULL, 0, "End user address", HFILL }},
+               { &hf_gtp_ext_user_addr_pdp_type,       { "PDP type",   "gtp.ext.user_addr_pdp_type",           FT_UINT8,       BASE_HEX, VALS(pdp_type), 0, "PDP type", HFILL }},
+               { &hf_gtp_ext_user_addr_pdp_org,        { "PDP type organization",      "gtp.ext.user_addr_pdp_org",            FT_UINT8,       BASE_DEC, NULL, 0, "PDP type organization", HFILL }},
                
-               { &hf_gtp_ext_apn,              { "APN",                                "gtp.ext.apn",                          FT_STRING,      BASE_DEC, NULL, 0, "Access Point Name" }},
+               { &hf_gtp_ext_apn,              { "APN",                                "gtp.ext.apn",                          FT_STRING,      BASE_DEC, NULL, 0, "Access Point Name", HFILL }},
                
-               { &hf_gtp_ext_proto_conf,       { "Protocol configuration", "gtp.ext.proto_conf",       FT_STRING,      BASE_DEC, NULL, 0, "Protocol configuration" }},
+               { &hf_gtp_ext_proto_conf,       { "Protocol configuration", "gtp.ext.proto_conf",       FT_STRING,      BASE_DEC, NULL, 0, "Protocol configuration", HFILL }},
                
-               { &hf_gtp_ext_gsn_addr,         { "GSN address",                "gtp.ext.gsn_addr",             FT_IPv4,        BASE_DEC, NULL, 0, "GSN address" }},
+               { &hf_gtp_ext_gsn_addr,         { "GSN address",                "gtp.ext.gsn_addr",             FT_IPv4,        BASE_DEC, NULL, 0, "GSN address", HFILL }},
                
-               { &hf_gtp_ext_msisdn,           { "MSISDN",                     "gtp.ext.msisdn",                       FT_STRING,      BASE_DEC, NULL, 0, "MSISDN" }},
+               { &hf_gtp_ext_msisdn,           { "MSISDN",                     "gtp.ext.msisdn",                       FT_STRING,      BASE_DEC, NULL, 0, "MSISDN", HFILL }},
 
-               { &hf_gtp_ext_chrg_addr,        { "CG address",                 "gtp.ext.chrg_addr",            FT_IPv4,        BASE_DEC, NULL, 0, "Charging gateway address" }},
+               { &hf_gtp_ext_chrg_addr,        { "CG address",                 "gtp.ext.chrg_addr",            FT_IPv4,        BASE_DEC, NULL, 0, "Charging gateway address", HFILL }},
                
-               { &hf_gtp_ext_node_addr,        { "Node address",               "gtp.ext.node_addr",            FT_IPv4,        BASE_DEC, NULL, 0, "Recommended node address" }},
+               { &hf_gtp_ext_node_addr,        { "Node address",               "gtp.ext.node_addr",            FT_IPv4,        BASE_DEC, NULL, 0, "Recommended node address", HFILL }},
                
-               { &hf_gtp_ext_ext_id,           { "Ext id",                     "gtp.ext.ext_id",                       FT_UINT16,      BASE_DEC, NULL, 0, "Extension id" }},
-               { &hf_gtp_ext_ext_val,          { "Ext val",                    "gtp.ext.ext_val",                      FT_STRING,      BASE_DEC, NULL, 0, "Extension value" }},
+               { &hf_gtp_ext_ext_id,           { "Ext id",                     "gtp.ext.ext_id",                       FT_UINT16,      BASE_DEC, NULL, 0, "Extension id", HFILL }},
+               { &hf_gtp_ext_ext_val,          { "Ext val",                    "gtp.ext.ext_val",                      FT_STRING,      BASE_DEC, NULL, 0, "Extension value", HFILL }},
                
-               { &hf_gtp_ext_unknown,          { "Unknown data (length)", "gtp.ext.unknown",           FT_UINT16,      BASE_DEC, NULL, 0, "Unknown data" }},
+               { &hf_gtp_ext_unknown,          { "Unknown data (length)", "gtp.ext.unknown",           FT_UINT16,      BASE_DEC, NULL, 0, "Unknown data", HFILL }},
 
        };
 
index 1fb574353afbeeced9a57f6ea9b62fa153128c64..470f55779566b9b9933a8e6e2ec3051e0d27251a 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for GVRP (GARP VLAN Registration Protocol) dissection
  * Copyright 2000, Kevin Shi <techishi@ms22.hinet.net>
  *
- * $Id: packet-gvrp.c,v 1.5 2001/05/27 07:07:34 guy Exp $
+ * $Id: packet-gvrp.c,v 1.6 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -303,27 +303,27 @@ proto_register_gvrp(void)
        { &hf_gvrp_proto_id,
            { "Protocol ID", "garp.protocol_id",
            FT_UINT16,      BASE_HEX,      NULL,  0x0,
-           "" }
+           "", HFILL }
        },
        { &hf_gvrp_attribute_type,
            { "Type",        "garp.attribute_type",
            FT_UINT8,        BASE_HEX,      VALS(attribute_type_vals),  0x0,
-           "" }
+           "", HFILL }
        },
        { &hf_gvrp_attribute_length,
            { "Length",      "garp.attribute_length",
            FT_UINT8,        BASE_DEC,      NULL,  0x0,
-           "" }
+           "", HFILL }
        },
        { &hf_gvrp_attribute_event,
            { "Event",       "garp.attribute_event",
            FT_UINT8,        BASE_DEC,      VALS(event_vals),  0x0,
-           "" }
+           "", HFILL }
        },
        { &hf_gvrp_attribute_value,
            { "Value",       "garp.attribute_value",
            FT_UINT16,       BASE_DEC,      NULL,  0x0,
-           "" }
+           "", HFILL }
        }
     };
 
index 0519cd85ec5f2a6059d8891874059cc5a66a352b..d03a333660808299aaf8c568a4a72ff43374ee08 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for Sinec H1 packet disassembly
  * Gerrit Gehnen <G.Gehnen@atrie.de>
  *
- * $Id: packet-h1.c,v 1.19 2001/06/08 08:35:15 guy Exp $
+ * $Id: packet-h1.c,v 1.20 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -257,48 +257,48 @@ proto_register_h1 (void)
   static hf_register_info hf[] = {
     {&hf_h1_header,
      {"H1-Header", "h1.header", FT_UINT16, BASE_HEX, NULL, 0x0,
-      ""}},
+      "", HFILL }},
     {&hf_h1_len,
      {"Length indicator", "h1.len", FT_UINT16, BASE_DEC, NULL, 0x0,
-      ""}},
+      "", HFILL }},
     {&hf_h1_opfield,
      {"Operation identifier", "h1.opfield", FT_UINT8, BASE_HEX, NULL, 0x0,
-      ""}},
+      "", HFILL }},
     {&hf_h1_oplen,
-     {"Operation length", "h1.oplen", FT_UINT8, BASE_HEX, NULL, 0x0, ""}},
+     {"Operation length", "h1.oplen", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
     {&hf_h1_opcode,
      {"Opcode", "h1.opcode", FT_UINT8, BASE_HEX, VALS (opcode_vals), 0x0,
-      ""}},
+      "", HFILL }},
     {&hf_h1_requestblock,
      {"Request identifier", "h1.request", FT_UINT8, BASE_HEX, NULL, 0x0,
-      ""}},
+      "", HFILL }},
     {&hf_h1_requestlen,
      {"Request length", "h1.reqlen", FT_UINT8, BASE_HEX, NULL, 0x0,
-      ""}},
+      "", HFILL }},
     {&hf_h1_org,
      {"Memory type", "h1.org", FT_UINT8, BASE_HEX, VALS (org_vals), 0x0,
-      ""}},
+      "", HFILL }},
     {&hf_h1_dbnr,
-     {"Memory block number", "h1.dbnr", FT_UINT8, BASE_DEC, NULL, 0x0, ""}},
+     {"Memory block number", "h1.dbnr", FT_UINT8, BASE_DEC, NULL, 0x0, "", HFILL }},
     {&hf_h1_dwnr,
      {"Address within memory block", "h1.dwnr", FT_UINT16, BASE_DEC, NULL, 0x0,
-      ""}},
+      "", HFILL }},
     {&hf_h1_dlen,
-     {"Length in words", "h1.dlen", FT_INT16, BASE_DEC, NULL, 0x0, ""}},
+     {"Length in words", "h1.dlen", FT_INT16, BASE_DEC, NULL, 0x0, "", HFILL }},
     {&hf_h1_response,
-     {"Response identifier", "h1.response", FT_UINT8, BASE_HEX, NULL, 0x0, ""}},
+     {"Response identifier", "h1.response", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }},
     {&hf_h1_response_len,
      {"Response length", "h1.reslen", FT_UINT8, BASE_DEC, NULL, 0x0,
-      ""}},
+      "", HFILL }},
     {&hf_h1_response_value,
      {"Response value", "h1.resvalue", FT_UINT8, BASE_DEC,
-      VALS (returncode_vals), 0x0, ""}},
+      VALS (returncode_vals), 0x0, "", HFILL }},
     {&hf_h1_empty,
      {"Empty field", "h1.empty", FT_UINT8, BASE_HEX, NULL, 0x0,
-      ""}},
+      "", HFILL }},
     {&hf_h1_empty_len,
      {"Empty field length", "h1.empty_len", FT_UINT8, BASE_DEC, NULL, 0x0,
-      ""}}
+      "", HFILL }}
   };
 
   static gint *ett[] = {
index eb6ea020c17ca7e77e4144616dd1166bd32169fb..e96d354a6c74b5a6d1687b0a666c8ec7f4730d13 100644 (file)
@@ -2,7 +2,7 @@
  *
  * Routines for ITU-T Recommendation H.261 dissection
  *
- * $Id: packet-h261.c,v 1.7 2001/06/12 06:31:14 guy Exp $
+ * $Id: packet-h261.c,v 1.8 2001/06/18 02:17:46 guy Exp $
  * 
  * Copyright 2000, Philips Electronics N.V.
  * Andreas Sikkema <andreas.sikkema@philips.com>
@@ -135,7 +135,7 @@ proto_register_h261(void)
                                BASE_DEC, 
                                NULL, 
                                0x0,
-                               "" 
+                               "", HFILL 
                        }
                },
                { 
@@ -147,7 +147,7 @@ proto_register_h261(void)
                                BASE_DEC, 
                                NULL, 
                                0x0,
-                               "" 
+                               "", HFILL 
                        }
                },
                { 
@@ -159,7 +159,7 @@ proto_register_h261(void)
                                BASE_NONE, 
                                NULL, 
                                0x0,
-                               "" 
+                               "", HFILL 
                        }
                },
                { 
@@ -171,7 +171,7 @@ proto_register_h261(void)
                                BASE_NONE, 
                                NULL, 
                                0x0,
-                               "" 
+                               "", HFILL 
                        }
                },
                { 
@@ -183,7 +183,7 @@ proto_register_h261(void)
                                BASE_DEC, 
                                NULL, 
                                0x0,
-                               "" 
+                               "", HFILL 
                        }
                },
                { 
@@ -195,7 +195,7 @@ proto_register_h261(void)
                                BASE_DEC, 
                                NULL, 
                                0x0,
-                               "" 
+                               "", HFILL 
                        }
                },
                { 
@@ -207,7 +207,7 @@ proto_register_h261(void)
                                BASE_DEC, 
                                NULL, 
                                0x0,
-                               "" 
+                               "", HFILL 
                        }
                },
                { 
@@ -219,7 +219,7 @@ proto_register_h261(void)
                                BASE_DEC, 
                                NULL, 
                                0x0,
-                               "" 
+                               "", HFILL 
                        }
                },
                { 
@@ -231,7 +231,7 @@ proto_register_h261(void)
                                BASE_DEC, 
                                NULL, 
                                0x0,
-                               "" 
+                               "", HFILL 
                        }
                },
                { 
@@ -243,7 +243,7 @@ proto_register_h261(void)
                                BASE_NONE, 
                                NULL, 
                                0x0,
-                               "" 
+                               "", HFILL 
                        }
                },
 };
index 396e8896b982521a030811d0322e8a861dcaa487..bf0b9320cdf3baca75e72483b038dc62efb23e19 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for hclnfsd (Hummingbird NFS Daemon) dissection
  * Copyright 2001, Mike Frisch <frisch@hummingbird.com>
  *
- * $Id: packet-hclnfsd.c,v 1.6 2001/05/30 06:01:01 guy Exp $
+ * $Id: packet-hclnfsd.c,v 1.7 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -668,139 +668,139 @@ proto_register_hclnfsd(void)
        static hf_register_info hf[] = {
                { &hf_hclnfsd_request_type, {
                        "Request Type", "hclnfsd.request_type", FT_UINT32, BASE_DEC,
-                       VALS(names_request_type), 0, "Request Type" }},
+                       VALS(names_request_type), 0, "Request Type", HFILL }},
 
                { &hf_hclnfsd_device, {
                        "Device", "hclnfsd.device", FT_STRING, BASE_DEC,
-                       NULL, 0, "Device" }},
+                       NULL, 0, "Device", HFILL }},
 
                { &hf_hclnfsd_login, {
                        "Login Text", "hclnfsd.logintext", FT_STRING, BASE_DEC,
-                       NULL, 0, "Login Text" }},
+                       NULL, 0, "Login Text", HFILL }},
 
                { &hf_hclnfsd_lockname, {
                        "Lockname", "hclnfsd.lockname", FT_STRING, BASE_DEC,
-                       NULL, 0, "Lockname" }},
+                       NULL, 0, "Lockname", HFILL }},
 
                { &hf_hclnfsd_unknown_data, {
                        "Unknown", "hclnfsd.unknown_data", FT_BYTES, BASE_DEC,
-                       NULL, 0, "Data" }},
+                       NULL, 0, "Data", HFILL }},
 
                { &hf_hclnfsd_lockowner, {
                        "Lockowner", "hclnfsd.lockowner", FT_BYTES, BASE_DEC,
-                       NULL, 0, "Lockowner" }},
+                       NULL, 0, "Lockowner", HFILL }},
 
                { &hf_hclnfsd_printername, {
                        "Printer Name", "hclnfsd.printername", FT_STRING, BASE_DEC,
-                       NULL, 0, "Printer name" }},
+                       NULL, 0, "Printer name", HFILL }},
 
                { &hf_hclnfsd_filename, {
                        "Filename", "hclnfsd.filename", FT_STRING, BASE_DEC,
-                       NULL, 0, "Filename" }},
+                       NULL, 0, "Filename", HFILL }},
 
                { &hf_hclnfsd_fileext, {
                        "File Extension", "hclnfsd.fileext", FT_UINT32, BASE_DEC,
-                       NULL, 0, "File Extension" }},
+                       NULL, 0, "File Extension", HFILL }},
 
                { &hf_hclnfsd_grpname, {
                        "Group", "hclnfsd.group", FT_STRING, BASE_DEC,
-                       NULL, 0, "Group" }},
+                       NULL, 0, "Group", HFILL }},
 
                { &hf_hclnfsd_hostname, {
                        "Hostname", "hclnfsd.hostname", FT_STRING, BASE_DEC,
-                       NULL, 0, "Hostname" }},
+                       NULL, 0, "Hostname", HFILL }},
 
                { &hf_hclnfsd_username, {
                        "Username", "hclnfsd.username", FT_STRING, BASE_DEC,
-                       NULL, 0, "Username" }},
+                       NULL, 0, "Username", HFILL }},
 
                { &hf_hclnfsd_queuename, {
                        "Name", "hclnfsd.printqueuename", FT_STRING, BASE_DEC,
-                       NULL, 0, "Print Queue Name" }},
+                       NULL, 0, "Print Queue Name", HFILL }},
 
                { &hf_hclnfsd_queuecomment, {
                        "Comment", "hclnfsd.printqueuecomment", FT_STRING, BASE_DEC,
-                       NULL, 0, "Print Queue Comment" }},
+                       NULL, 0, "Print Queue Comment", HFILL }},
 
                { &hf_hclnfsd_printparams, {
                        "Print Parameters", "hclnfsd.printparameters", FT_STRING, BASE_DEC,
-                       NULL, 0, "Print Parameters" }},
+                       NULL, 0, "Print Parameters", HFILL }},
 
                { &hf_hclnfsd_status, {
                        "Status", "hclnfsd.status", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Status" }},
+                       NULL, 0, "Status", HFILL }},
 
                { &hf_hclnfsd_uid, {
                        "UID", "hclnfsd.uid", FT_UINT32, BASE_DEC,
-                       NULL, 0, "User ID" }},
+                       NULL, 0, "User ID", HFILL }},
 
                { &hf_hclnfsd_sequence, {
                        "Sequence", "hclnfsd.sequence", FT_UINT32, BASE_HEX,
-                       NULL, 0, "Sequence" }},
+                       NULL, 0, "Sequence", HFILL }},
 
                { &hf_hclnfsd_cookie, {
                        "Cookie", "hclnfsd.cookie", FT_UINT32, BASE_HEX,
-                       NULL, 0, "Cookie" }},
+                       NULL, 0, "Cookie", HFILL }},
 
                { &hf_hclnfsd_mode, {
                        "Mode", "hclnfsd.mode", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Mode" }},
+                       NULL, 0, "Mode", HFILL }},
 
                { &hf_hclnfsd_access, {
                        "Access", "hclnfsd.access", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Access" }},
+                       NULL, 0, "Access", HFILL }},
 
                { &hf_hclnfsd_exclusive, {
                        "Exclusive", "hclnfsd.exclusive", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Exclusive" }},
+                       NULL, 0, "Exclusive", HFILL }},
 
                { &hf_hclnfsd_offset, {
                        "Offset", "hclnfsd.offset", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Offset" }},
+                       NULL, 0, "Offset", HFILL }},
 
                { &hf_hclnfsd_length, {
                        "Length", "hclnfsd.length", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Length" }},
+                       NULL, 0, "Length", HFILL }},
 
                { &hf_hclnfsd_queuestatus, {
                        "Queue Status", "hclnfsd.queuestatus", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Queue Status" }},
+                       NULL, 0, "Queue Status", HFILL }},
 
                { &hf_hclnfsd_printqueuenumber, {
                        "Print Queue Number", "hclnfsd.pqn", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Print Queue Number" }},
+                       NULL, 0, "Print Queue Number", HFILL }},
 
                { &hf_hclnfsd_numphysicalprinters, {
                        "Number of Physical Printers", "hclnfsd.npp", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Number of Physical Printers" }},
+                       NULL, 0, "Number of Physical Printers", HFILL }},
 
                { &hf_hclnfsd_jobstatus, {
                        "Job Status", "hclnfsd.jobstatus", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Job Status" }},
+                       NULL, 0, "Job Status", HFILL }},
 
                { &hf_hclnfsd_timesubmitted, {
                        "Time Submitted", "hclnfsd.timesubmitted", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Time Submitted" }},
+                       NULL, 0, "Time Submitted", HFILL }},
 
                { &hf_hclnfsd_size, {
                        "Size", "hclnfsd.size", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Size" }},
+                       NULL, 0, "Size", HFILL }},
 
                { &hf_hclnfsd_copies, {
                        "Copies", "hclnfsd.copies", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Copies" }},
+                       NULL, 0, "Copies", HFILL }},
 
                { &hf_hclnfsd_gid, {
                        "GID", "hclnfsd.gid", FT_UINT32, BASE_DEC,
-                       NULL, 0, "Group ID" }},
+                       NULL, 0, "Group ID", HFILL }},
 
                { &hf_hclnfsd_server_ip, {
                        "Server IP", "hclnfsd.server_ip", FT_IPv4, BASE_DEC,
-                       NULL, 0, "Server IP" }},
+                       NULL, 0, "Server IP", HFILL }},
 
                { &hf_hclnfsd_host_ip, {
                        "Host IP", "hclnfsd.host_ip", FT_IPv4, BASE_DEC,
-                       NULL, 0, "Host IP" }},
+                       NULL, 0, "Host IP", HFILL }},
        };
        static gint *ett[] = {
                &ett_hclnfsd,
index 9e6f1cbbd40522b06939f08f9ee470726fb9709b..c4c32c05691fdc1719fc87e0b9560188a7db452e 100644 (file)
@@ -4,7 +4,7 @@
  *
  * Heikki Vatiainen <hessu@cs.tut.fi>
  *
- * $Id: packet-hsrp.c,v 1.16 2001/01/22 03:33:45 guy Exp $
+ * $Id: packet-hsrp.c,v 1.17 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -178,52 +178,52 @@ void proto_register_hsrp(void)
                 { &hf_hsrp_version,
                   { "Version", "hsrp.version",  
                     FT_UINT8, BASE_DEC, NULL, 0x0,
-                    "The version of the HSRP messages"}},
+                    "The version of the HSRP messages", HFILL }},
 
                 { &hf_hsrp_opcode,
                   { "Op Code", "hsrp.opcode",
                     FT_UINT8, BASE_DEC, VALS(hsrp_opcode_vals), 0x0,
-                    "The type of message contained in this packet" }},
+                    "The type of message contained in this packet", HFILL }},
 
                 { &hf_hsrp_state,
                   { "State", "hsrp.state",
                     FT_UINT8, BASE_DEC, VALS(hsrp_state_vals), 0x0,
-                    "The current state of the router sending the message" }},
+                    "The current state of the router sending the message", HFILL }},
 
                 { &hf_hsrp_hellotime,
                   { "Hellotime", "hsrp.hellotime",
                     FT_UINT8, BASE_DEC, NULL, 0x0,
-                    "The approximate period between the Hello messages that the router sends" }},
+                    "The approximate period between the Hello messages that the router sends", HFILL }},
 
                 { &hf_hsrp_holdtime,
                   { "Holdtime", "hsrp.holdtime",
                     FT_UINT8, BASE_DEC, NULL, 0x0,
-                    "Time that the current Hello message should be considered valid" }},
+                    "Time that the current Hello message should be considered valid", HFILL }},
 
                 { &hf_hsrp_priority,
                   { "Priority", "hsrp.priority",
                     FT_UINT8, BASE_DEC, NULL, 0x0,
-                    "Used to elect the active and standby routers. Numerically higher priority wins vote" }},
+                    "Used to elect the active and standby routers. Numerically higher priority wins vote", HFILL }},
 
                 { &hf_hsrp_group,
                   { "Group", "hsrp.group",
                     FT_UINT8, BASE_DEC, NULL, 0x0,
-                    "This field identifies the standby group" }},
+                    "This field identifies the standby group", HFILL }},
 
                 { &hf_hsrp_reserved,
                   { "Reserved", "hsrp.reserved",
                     FT_UINT8, BASE_DEC, NULL, 0x0,
-                    "Reserved" }},
+                    "Reserved", HFILL }},
 
                 { &hf_hsrp_auth_data,
                   { "Authentication Data", "hsrp.auth_data",
                     FT_STRING, 0, NULL, 0x0,
-                    "Contains a clear-text 8 character reused password" }},
+                    "Contains a clear-text 8 character reused password", HFILL }},
 
                 { &hf_hsrp_virt_ip_addr,
                   { "Virtual IP Address", "hsrp.virt_ip",
                     FT_IPv4, 0, NULL, 0x0,
-                    "The virtual IP address used by this group" }},
+                    "The virtual IP address used by this group", HFILL }},
 
         };
 
index eb535b210a54a048c5557edbbe2cbc9636348069..6aed5204e29942ffd377d8bd6d5281cc889f7346 100644 (file)
@@ -3,7 +3,7 @@
  *
  * Guy Harris <guy@alum.mit.edu>
  *
- * $Id: packet-http.c,v 1.37 2001/01/22 08:54:06 guy Exp $
+ * $Id: packet-http.c,v 1.38 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -374,15 +374,15 @@ proto_register_http(void)
            { &hf_http_notification,
              { "Notification",         "http.notification",  
                FT_BOOLEAN, BASE_NONE, NULL, 0x0,
-               "TRUE if HTTP notification" }},
+               "TRUE if HTTP notification", HFILL }},
            { &hf_http_response,
              { "Response",             "http.response",  
                FT_BOOLEAN, BASE_NONE, NULL, 0x0,
-               "TRUE if HTTP response" }},
+               "TRUE if HTTP response", HFILL }},
            { &hf_http_request,
              { "Request",              "http.request",
                FT_BOOLEAN, BASE_NONE, NULL, 0x0,
-               "TRUE if HTTP request" }},
+               "TRUE if HTTP request", HFILL }},
        };
        static gint *ett[] = {
                &ett_http,
index 0dfcd962e95937cd7d6ff72180426098b1acd0af..ee3ccba5d88787d3bf6f03287eb7a0033a9635f2 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-icmpv6.c
  * Routines for ICMPv6 packet disassembly
  *
- * $Id: packet-icmpv6.c,v 1.46 2001/06/02 08:10:02 guy Exp $
+ * $Id: packet-icmpv6.c,v 1.47 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -1346,16 +1346,16 @@ proto_register_icmpv6(void)
   static hf_register_info hf[] = {
     { &hf_icmpv6_type,
       { "Type",           "icmpv6.type",       FT_UINT8,  BASE_DEC, NULL, 0x0,
-       "" }},
+       "", HFILL }},
     { &hf_icmpv6_code,
       { "Code",           "icmpv6.code",       FT_UINT8,  BASE_DEC, NULL, 0x0,
-       "" }},
+       "", HFILL }},
     { &hf_icmpv6_checksum,
       { "Checksum",       "icmpv6.checksum",   FT_UINT16, BASE_HEX, NULL, 0x0,
-       "" }},
+       "", HFILL }},
     { &hf_icmpv6_checksum_bad,
       { "Bad Checksum",   "icmpv6.checksum_bad", FT_BOOLEAN, BASE_NONE,        NULL, 0x0,
-       "" }},
+       "", HFILL }},
   };
   static gint *ett[] = {
     &ett_icmpv6,
index b6500a6302114934e0fc5259b2b3a252cf654923..84ab7e228cde45fb1bef1d7b8c1fdb074703f0bb 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for ICP (internet cache protocol) packet disassembly
  * RFC 2186 && RFC 2187
  *
- * $Id: packet-icp.c,v 1.17 2001/02/28 21:26:58 guy Exp $
+ * $Id: packet-icp.c,v 1.18 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Peter Torvals
@@ -225,19 +225,19 @@ proto_register_icp(void)
        static hf_register_info hf[] = {
                { &hf_icp_opcode,
                { "Opcode", "icp.opcode", FT_UINT8, BASE_HEX, VALS(opcode_vals),
-                       0x0, "" }},
+                       0x0, "", HFILL }},
 
                { &hf_icp_version,
                { "Version", "icp.version", FT_UINT8, BASE_DEC, NULL,
-                       0x0, "" }},
+                       0x0, "", HFILL }},
 
                { &hf_icp_length,
                { "Length", "icp.length", FT_UINT16, BASE_DEC, NULL,
-                       0x0, "" }},
+                       0x0, "", HFILL }},
 
                { &hf_icp_request_nr,
                { "Request Number", "icp.nr", FT_UINT32, BASE_DEC, NULL,
-                       0x0, "" }},
+                       0x0, "", HFILL }},
        };
        static gint *ett[] = {
                &ett_icp,
index 4fc673e0a2d9568743007645fcc64a8f9ff27b52..1822d3bcdb6b1a0328b33819889751d0ed0ae1ba 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-icq.c
  * Routines for ICQ packet disassembly
  *
- * $Id: packet-icq.c,v 1.31 2001/05/27 21:37:23 guy Exp $
+ * $Id: packet-icq.c,v 1.32 2001/06/18 02:17:46 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -2161,17 +2161,17 @@ proto_register_icq(void)
 {
     static hf_register_info hf[] = {
        { &hf_icq_type,
-         {"Type", "icq.type", FT_UINT16, BASE_DEC, NULL, 0x0, ""}},
+         {"Type", "icq.type", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
        { &hf_icq_uin,
-         {"UIN", "icq.uin", FT_UINT32, BASE_DEC, NULL, 0x0, ""}},
+         {"UIN", "icq.uin", FT_UINT32, BASE_DEC, NULL, 0x0, "", HFILL }},
        { &hf_icq_sessionid,
-         {"Session ID", "icq.sessionid", FT_UINT32, BASE_HEX, NULL, 0x0, ""}},
+         {"Session ID", "icq.sessionid", FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }},
        { &hf_icq_cmd,
-         {"Command", "icq.cmd", FT_UINT16, BASE_DEC, NULL, 0x0, ""}},
+         {"Command", "icq.cmd", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL }},
        { &hf_icq_checkcode,
-         {"Checkcode", "icq.checkcode", FT_UINT32, BASE_HEX, NULL, 0x0, ""}},
+         {"Checkcode", "icq.checkcode", FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL }},
        { &hf_icq_decode,
-         {"Decode", "icq.decode", FT_STRING, BASE_NONE, NULL, 0x0, ""}}
+         {"Decode", "icq.decode", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }}
     };
     static gint *ett[] = {
         &ett_icq,
index 22b49dd528aa9867a0e99f314d684c024d98f3fc..6a1736b6b957fc707f2d575dea06bfa9aaeb3226 100644 (file)
@@ -3,7 +3,7 @@
  * Copyright 2000, Axis Communications AB 
  * Inquiries/bugreports should be sent to Johan.Jorgensen@axis.com
  *
- * $Id: packet-ieee80211.c,v 1.22 2001/06/12 05:40:05 guy Exp $
+ * $Id: packet-ieee80211.c,v 1.23 2001/06/18 02:17:47 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -1673,214 +1673,214 @@ proto_register_wlan (void)
   static hf_register_info hf[] = {
     {&hf_fc_field,
      {"Frame Control Field", "wlan.fc", FT_UINT16, BASE_HEX, NULL, 0,
-      "MAC Frame control"}},
+      "MAC Frame control", HFILL }},
 
     {&hf_fc_proto_version,
      {"Version", "wlan.fc.version", FT_UINT8, BASE_DEC, NULL, 0,
-      "MAC Protocol version"}},        /* 0 */
+      "MAC Protocol version", HFILL }},        /* 0 */
 
     {&hf_fc_frame_type,
      {"Type", "wlan.fc.type", FT_UINT8, BASE_DEC, NULL, 0,
-      "Frame type"}},
+      "Frame type", HFILL }},
 
     {&hf_fc_frame_subtype,
      {"Subtype", "wlan.fc.subtype", FT_UINT8, BASE_DEC, NULL, 0,
-      "Frame subtype"}},       /* 2 */
+      "Frame subtype", HFILL }},       /* 2 */
 
     {&hf_fc_flags,
      {"Protocol Flags", "wlan.flags", FT_UINT8, BASE_HEX, NULL, 0,
-      "Protocol flags"}},
+      "Protocol flags", HFILL }},
 
     {&hf_fc_data_ds,
      {"DS status", "wlan.fc.ds", FT_UINT8, BASE_HEX, TFS (&tofrom_ds), 0,
-      "Data-frame DS-traversal status"}},      /* 3 */
+      "Data-frame DS-traversal status", HFILL }},      /* 3 */
 
     {&hf_fc_to_ds,
      {"To DS", "wlan.fc.tods", FT_BOOLEAN, 8, TFS (&tods_flag), 0x1,
-      "To DS flag"}},          /* 4 */
+      "To DS flag", HFILL }},          /* 4 */
 
     {&hf_fc_from_ds,
      {"From DS", "wlan.fc.fromds", FT_BOOLEAN, 8, TFS (&fromds_flag), 0x2,
-      "From DS flag"}},                /* 5 */
+      "From DS flag", HFILL }},                /* 5 */
 
     {&hf_fc_more_frag,
      {"Fragments", "wlan.fc.frag", FT_BOOLEAN, 8, TFS (&more_frags), 0x4,
-      "More Fragments flag"}}, /* 6 */
+      "More Fragments flag", HFILL }}, /* 6 */
 
     {&hf_fc_retry,
      {"Retry", "wlan.fc.retry", FT_BOOLEAN, 8, TFS (&retry_flags), 0x8,
-      "Retransmission flag"}},
+      "Retransmission flag", HFILL }},
 
     {&hf_fc_pwr_mgt,
      {"PWR MGT", "wlan.fc.pwrmgt", FT_BOOLEAN, 8, TFS (&pm_flags), 0x10,
-      "Power management status"}},
+      "Power management status", HFILL }},
 
     {&hf_fc_more_data,
      {"More Data", "wlan.fc.moredata", FT_BOOLEAN, 8, TFS (&md_flags), 0x20,
-      "More data flag"}},
+      "More data flag", HFILL }},
 
     {&hf_fc_wep,
      {"WEP flag", "wlan.fc.wep", FT_BOOLEAN, 8, TFS (&wep_flags), 0x40,
-      "WEP flag"}},
+      "WEP flag", HFILL }},
 
     {&hf_fc_order,
      {"Order flag", "wlan.fc.order", FT_BOOLEAN, 8, TFS (&order_flags), 0x80,
-      "Strictly ordered flag"}},
+      "Strictly ordered flag", HFILL }},
 
     {&hf_assoc_id,
      {"Association ID","wlan.aid",FT_UINT16, BASE_DEC,NULL,0,
-      "Association-ID field" }},
+      "Association-ID field", HFILL }},
 
     {&hf_did_duration,
      {"Duration", "wlan.duration", FT_UINT16, BASE_DEC, NULL, 0,
-      "Duration field"}},
+      "Duration field", HFILL }},
 
     {&hf_addr_da,
      {"Destination address", "wlan.da", FT_ETHER, BASE_NONE, NULL, 0,
-      "Destination Hardware address"}},
+      "Destination Hardware address", HFILL }},
 
     {&hf_addr_sa,
      {"Source address", "wlan.sa", FT_ETHER, BASE_NONE, NULL, 0,
-      "Source Hardware address"}},
+      "Source Hardware address", HFILL }},
 
     {&hf_addr_ra,
      {"Receiver address", "wlan.ra", FT_ETHER, BASE_NONE, NULL, 0,
-      "Receiving Station Hardware Address"}},
+      "Receiving Station Hardware Address", HFILL }},
 
     {&hf_addr_ta,
      {"Transmitter address", "wlan.ta", FT_ETHER, BASE_NONE, NULL, 0,
-      "Transmitting Station Hardware Address"}},
+      "Transmitting Station Hardware Address", HFILL }},
 
     {&hf_addr_bssid,
      {"BSS Id", "wlan.bssid", FT_ETHER, BASE_NONE, NULL, 0,
-      "Basic Service Set ID"}},
+      "Basic Service Set ID", HFILL }},
 
     {&hf_frag_number,
      {"Fragment number", "wlan.frag", FT_UINT16, BASE_HEX, NULL, 0,
-      "Fragment number"}},
+      "Fragment number", HFILL }},
 
     {&hf_seq_number,
      {"Sequence number", "wlan.seq", FT_UINT16, BASE_HEX, NULL, 0,
-      "Fragment number"}},
+      "Fragment number", HFILL }},
 
     {&hf_fcs,
      {"Frame Check Sequence (not verified)", "wlan.fcs", FT_UINT32, BASE_HEX,
-      NULL, 0, ""}},
+      NULL, 0, "", HFILL }},
 
     {&ff_timestamp,
      {"Timestamp", "wlan.fixed.timestamp", FT_STRING, BASE_NONE,
-      NULL, 0, ""}},
+      NULL, 0, "", HFILL }},
 
     {&ff_auth_alg,
      {"Authentication Algorithm", "wlan.fixed.auth.alg",
-      FT_UINT16, BASE_DEC, VALS (&auth_alg), 0, ""}},
+      FT_UINT16, BASE_DEC, VALS (&auth_alg), 0, "", HFILL }},
 
     {&ff_beacon_interval,
      {"Beacon Interval", "wlan.fixed.beacon", FT_DOUBLE, BASE_DEC, NULL, 0,
-      ""}},
+      "", HFILL }},
 
     {&hf_fixed_parameters,
      {"Fixed parameters", "wlan.fixed.all", FT_UINT16, BASE_DEC, NULL, 0,
-      ""}},
+      "", HFILL }},
 
     {&hf_tagged_parameters,
      {"Tagged parameters", "wlan.tagged.all", FT_UINT16, BASE_DEC, NULL, 0,
-      ""}},
+      "", HFILL }},
 
     {&hf_wep_parameters,
      {"WEP parameters", "wlan.wep.all", FT_STRING, BASE_NONE, NULL, 0,
-      ""}},
+      "", HFILL }},
 
     {&hf_wep_iv,
      {"Initialization Vector", "wlan.wep.iv", FT_UINT32, BASE_HEX, NULL, 0,
-      "Initialization Vector"}},
+      "Initialization Vector", HFILL }},
 
     {&hf_wep_key,
      {"Key", "wlan.wep.key", FT_UINT32, BASE_DEC, NULL, 0,
-      "Key"}},
+      "Key", HFILL }},
 
     {&hf_wep_crc,
      {"WEP CRC (not verified)", "wlan.wep.crc", FT_UINT32, BASE_HEX, NULL, 0,
-      "WEP CRC"}},
+      "WEP CRC", HFILL }},
 
     {&ff_capture,
      {"Capabilities", "wlan.fixed.capabilities", FT_UINT16, BASE_HEX, NULL, 0,
-      "Capability information"}},
+      "Capability information", HFILL }},
 
     {&ff_cf_sta_poll,
      {"CFP participation capabilities", "wlan.fixed.capabilities.cfpoll.sta",
       FT_UINT16, BASE_HEX, VALS (&sta_cf_pollable), 0,
-      "CF-Poll capabilities for a STA"}},
+      "CF-Poll capabilities for a STA", HFILL }},
 
     {&ff_cf_ap_poll,
      {"CFP participation capabilities", "wlan.fixed.capabilities.cfpoll.ap",
       FT_UINT16, BASE_HEX, VALS (&ap_cf_pollable), 0,
-      "CF-Poll capabilities for an AP"}},
+      "CF-Poll capabilities for an AP", HFILL }},
 
     {&ff_cf_ess,
      {"ESS capabilities", "wlan.fixed.capabilities.ess",
-      FT_BOOLEAN, 8, TFS (&cf_ess_flags), 0x0001, "ESS capabilities"}},
+      FT_BOOLEAN, 8, TFS (&cf_ess_flags), 0x0001, "ESS capabilities", HFILL }},
 
 
     {&ff_cf_ibss,
      {"IBSS status", "wlan.fixed.capabilities.ibss",
-      FT_BOOLEAN, 8, TFS (&cf_ibss_flags), 0x0002, "IBSS participation"}},
+      FT_BOOLEAN, 8, TFS (&cf_ibss_flags), 0x0002, "IBSS participation", HFILL }},
 
     {&ff_cf_privacy,
      {"Privacy", "wlan.fixed.capabilities.privacy",
-      FT_BOOLEAN, 8, TFS (&cf_privacy_flags), 0x0010, "WEP support"}},
+      FT_BOOLEAN, 8, TFS (&cf_privacy_flags), 0x0010, "WEP support", HFILL }},
 
     {&ff_cf_preamble,
      {"Short Preamble", "wlan.fixed.capabilities.preamble",
-      FT_BOOLEAN, 8, TFS (&cf_preamble_flags), 0x0020, "Short Preamble"}},
+      FT_BOOLEAN, 8, TFS (&cf_preamble_flags), 0x0020, "Short Preamble", HFILL }},
 
     {&ff_cf_pbcc,
      {"PBCC", "wlan.fixed.capabilities.pbcc",
-      FT_BOOLEAN, 8, TFS (&cf_pbcc_flags), 0x0040, "PBCC Modulation"}},
+      FT_BOOLEAN, 8, TFS (&cf_pbcc_flags), 0x0040, "PBCC Modulation", HFILL }},
 
     {&ff_cf_agility,
      {"Channel Agility", "wlan.fixed.capabilities.agility",
-      FT_BOOLEAN, 8, TFS (&cf_agility_flags), 0x0080, "Channel Agility"}},
+      FT_BOOLEAN, 8, TFS (&cf_agility_flags), 0x0080, "Channel Agility", HFILL }},
 
 
     {&ff_auth_seq,
      {"Authentication SEQ", "wlan.fixed.auth_seq",
-      FT_UINT16, BASE_HEX, NULL, 0, "Authentication sequence number"}},
+      FT_UINT16, BASE_HEX, NULL, 0, "Authentication sequence number", HFILL }},
 
     {&ff_assoc_id,
      {"Association ID", "wlan.fixed.aid",
-      FT_UINT16, BASE_HEX, NULL, 0, "Association ID"}},
+      FT_UINT16, BASE_HEX, NULL, 0, "Association ID", HFILL }},
 
     {&ff_listen_ival,
      {"Listen Interval", "wlan.fixed.listen_ival",
-      FT_UINT16, BASE_HEX, NULL, 0, "Listen Interval"}},
+      FT_UINT16, BASE_HEX, NULL, 0, "Listen Interval", HFILL }},
 
     {&ff_current_ap,
      {"Current AP", "wlan.fixed.current_ap",
-      FT_ETHER, BASE_NONE, NULL, 0, "MAC address of current AP"}},
+      FT_ETHER, BASE_NONE, NULL, 0, "MAC address of current AP", HFILL }},
 
     {&ff_reason,
      {"Reason code", "wlan.fixed.reason_code",
       FT_UINT16, BASE_HEX, VALS (&reason_codes), 0,
-      "Reason for unsolicited notification"}},
+      "Reason for unsolicited notification", HFILL }},
 
     {&ff_status_code,
      {"Status code", "wlan.fixed.status_code",
       FT_UINT16, BASE_HEX, VALS (&status_codes), 0,
-      "Status of requested event"}},
+      "Status of requested event", HFILL }},
 
     {&tag_number,
      {"Tag", "wlan.tag.number",
       FT_UINT16, BASE_DEC, NULL, 0,
-      "Element ID"}},
+      "Element ID", HFILL }},
 
     {&tag_length,
      {"Tag length", "wlan.tag.length",
-      FT_UINT16, BASE_DEC, NULL, 0, "Length of tag"}},
+      FT_UINT16, BASE_DEC, NULL, 0, "Length of tag", HFILL }},
 
     {&tag_interpretation,
      {"Tag interpretation", "wlan.tag.interpretation",
-      FT_STRING, BASE_NONE, NULL, 0, "Interpretation of tag"}}
+      FT_STRING, BASE_NONE, NULL, 0, "Interpretation of tag", HFILL }}
 
 
   };
index 0f477ef5bd0108dbffcb0612cd81d646e4b67574..d54660ccdb488e4cd4a696f03937432fe2d3cf45 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-igmp.c   2001 Ronnie Sahlberg <rsahlber@bigpond.net.au>
  * Routines for IGMP packet disassembly
  *
- * $Id: packet-igmp.c,v 1.4 2001/06/12 06:21:55 guy Exp $
+ * $Id: packet-igmp.c,v 1.5 2001/06/18 02:17:47 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -672,91 +672,91 @@ proto_register_igmp(void)
        static hf_register_info hf[] = {
                { &hf_type,
                        { "Type", "igmp.type", FT_UINT8, BASE_HEX,
-                         VALS(commands), 0, "IGMP Packet Type" }},
+                         VALS(commands), 0, "IGMP Packet Type", HFILL }},
 
                { &hf_version,
                        { "IGMP Version", "igmp.version", FT_UINT8, BASE_DEC,
-                         NULL, 0, "IGMP Version" }},
+                         NULL, 0, "IGMP Version", HFILL }},
 
                { &hf_group_type,
                        { "Type Of Group", "igmp.group_type", FT_UINT8, BASE_DEC,
-                         VALS(vs_group_type), 0, "IGMP V0 Type Of Group" }},
+                         VALS(vs_group_type), 0, "IGMP V0 Type Of Group", HFILL }},
 
                { &hf_reply_code,
                        { "Reply", "igmp.reply", FT_UINT8, BASE_DEC,
-                         VALS(vs_reply_code), 0, "IGMP V0 Reply" }},
+                         VALS(vs_reply_code), 0, "IGMP V0 Reply", HFILL }},
 
                { &hf_reply_pending,
                        { "Reply Pending", "igmp.reply.pending", FT_UINT8, BASE_DEC,
-                         NULL, 0, "IGMP V0 Reply Pending, Retry in this many seconds" }},
+                         NULL, 0, "IGMP V0 Reply Pending, Retry in this many seconds", HFILL }},
 
                { &hf_checksum,
                        { "Checksum", "igmp.checksum", FT_UINT16, BASE_HEX,
-                         NULL, 0, "IGMP Checksum" }},
+                         NULL, 0, "IGMP Checksum", HFILL }},
 
                { &hf_checksum_bad,
                        { "Bad Checksum", "igmp.checksum_bad", FT_BOOLEAN, BASE_NONE,
-                         NULL, 0, "Bad IGMP Checksum" }},
+                         NULL, 0, "Bad IGMP Checksum", HFILL }},
 
                { &hf_identifier,
                        { "Identifier", "igmp.identifier", FT_UINT32, BASE_DEC,
-                         NULL, 0, "IGMP V0 Identifier" }},
+                         NULL, 0, "IGMP V0 Identifier", HFILL }},
 
                { &hf_access_key,
                        { "Access Key", "igmp.access_key", FT_BYTES, BASE_HEX,
-                         NULL, 0, "IGMP V0 Access Key" }},
+                         NULL, 0, "IGMP V0 Access Key", HFILL }},
 
                { &hf_max_resp,
                        { "Max Resp Time", "igmp.max_resp", FT_UINT8, BASE_DEC,
-                         NULL, 0, "Max Response Time" }},
+                         NULL, 0, "Max Response Time", HFILL }},
 
                { &hf_supress,
                        { "S", "igmp.s", FT_BOOLEAN, 8,
-                         TFS(&tfs_s), IGMP_V3_S, "Supress Router Side Processing" }},
+                         TFS(&tfs_s), IGMP_V3_S, "Supress Router Side Processing", HFILL }},
 
                { &hf_qrv,
                        { "QRV", "igmp.qrv", FT_UINT8, BASE_DEC,
-                       NULL, IGMP_V3_QRV_MASK, "Querier's Robustness Value"}},
+                       NULL, IGMP_V3_QRV_MASK, "Querier's Robustness Value", HFILL }},
 
                { &hf_qqic,
                        { "QQIC", "igmp.qqic", FT_UINT8, BASE_DEC,
-                         NULL, 0, "Querier's Query Interval Code" }},
+                         NULL, 0, "Querier's Query Interval Code", HFILL }},
 
                { &hf_num_src,
                        { "Num Src", "igmp.num_src", FT_UINT16, BASE_DEC,
-                         NULL, 0, "Number Of Sources" }},
+                         NULL, 0, "Number Of Sources", HFILL }},
 
                { &hf_saddr,
                        { "Source Address", "igmp.saddr", FT_IPv4, BASE_NONE,
-                         NULL, 0, "Source Address" }},
+                         NULL, 0, "Source Address", HFILL }},
 
                { &hf_num_grp_recs,
                        { "Num Group Records", "igmp.num_grp_recs", FT_UINT16, BASE_DEC,
-                         NULL, 0, "Number Of Group Records" }},
+                         NULL, 0, "Number Of Group Records", HFILL }},
 
                { &hf_record_type,
                        { "Record Type", "igmp.record_type", FT_UINT8, BASE_DEC,
-                       VALS(vs_record_type), 0, "Record Type"}},
+                       VALS(vs_record_type), 0, "Record Type", HFILL }},
 
                { &hf_aux_data_len,
                        { "Aux Data Len", "igmp.aux_data_len", FT_UINT8, BASE_DEC,
-                       NULL, 0, "Aux Data Len, In units of 32bit words"}},
+                       NULL, 0, "Aux Data Len, In units of 32bit words", HFILL }},
 
                { &hf_maddr,
                        { "Multicast Address", "igmp.maddr", FT_IPv4, BASE_NONE,
-                         NULL, 0, "Multicast Address" }},
+                         NULL, 0, "Multicast Address", HFILL }},
 
                { &hf_aux_data,
                        { "Aux Data", "igmp.aux_data", FT_BYTES, BASE_HEX,
-                         NULL, 0, "IGMP V3 Auxiliary Data" }},
+                         NULL, 0, "IGMP V3 Auxiliary Data", HFILL }},
 
                { &hf_max_resp_exp,
                        { "Exponent", "igmp.max_resp.exp", FT_UINT8, BASE_HEX,
-                       NULL, IGMP_MAX_RESP_EXP, "Maxmimum Response Time, Exponent"}},
+                       NULL, IGMP_MAX_RESP_EXP, "Maxmimum Response Time, Exponent", HFILL }},
 
                { &hf_max_resp_mant,
                        { "Mantissa", "igmp.max_resp.mant", FT_UINT8, BASE_HEX,
-                       NULL, IGMP_MAX_RESP_MANT, "Maxmimum Response Time, Mantissa"}},
+                       NULL, IGMP_MAX_RESP_MANT, "Maxmimum Response Time, Mantissa", HFILL }},
 
        };
        static gint *ett[] = {
index e4bd8001f609f25cfe1f752e321bbe9b870a5119..d7869569eca5e1f85da80f9fbd5983f51090d676 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for IGRP dissection
  * Copyright 2000, Paul Ionescu <paul@acorp.ro>
  * 
- * $Id: packet-igrp.c,v 1.7 2001/04/23 17:51:33 guy Exp $
+ * $Id: packet-igrp.c,v 1.8 2001/06/18 02:17:47 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -177,12 +177,12 @@ void proto_register_igrp(void)
     { &hf_igrp_update,
       { "Update Release",           "igrp.update",
       FT_UINT8, BASE_DEC, NULL, 0x0 ,
-      "Update Release number" },
+      "Update Release number", HFILL }
     },
     { &hf_igrp_as,
       { "Autonomous System",           "igrp.as",
       FT_UINT16, BASE_DEC, NULL, 0x0 ,
-      "Autonomous System number" }
+      "Autonomous System number", HFILL }
     }
   };
 
index e595586e63f1e21f06052f9c8502911a09c40ffc..8a1c506f429076476a318a5e09961461b50aaac1 100644 (file)
@@ -2,7 +2,7 @@
  * Routines for imap packet dissection
  * Copyright 1999, Richard Sharpe <rsharpe@ns.aus.com>
  *
- * $Id: packet-imap.c,v 1.14 2001/01/22 08:03:45 guy Exp $
+ * $Id: packet-imap.c,v 1.15 2001/06/18 02:17:47 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@zing.org>
@@ -162,12 +162,12 @@ proto_register_imap(void)
     { &hf_imap_response,
       { "Response",           "imap.response",
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
-       "TRUE if IMAP response" }},
+       "TRUE if IMAP response", HFILL }},
 
     { &hf_imap_request,
       { "Request",            "imap.request",
        FT_BOOLEAN, BASE_NONE, NULL, 0x0,
-       "TRUE if IMAP request" }}
+       "TRUE if IMAP request", HFILL }}
   };
   static gint *ett[] = {
     &ett_imap,
index 6113ffda783266015617d01b5e3d9345496ad347..bec3b3451ab837c6b1c795daee9c427c30991f72 100644 (file)
@@ -1,7 +1,7 @@
 /* packet-ip.c
  * Routines for IP and miscellaneous IP protocol packet disassembly
  *
- * $Id: packet-ip.c,v 1.136 2001/06/08 08:29:15 guy Exp $
+ * $Id: packet-ip.c,v 1.137 2001/06/18 02:17:47 guy Exp $
  *
  * Ethereal - Network traffic analyzer
  * By Gerald Combs <gerald@ethereal.com>
@@ -1409,139 +1409,139 @@ proto_register_ip(void)
 
                { &hf_ip_version,
                { "Version",            "ip.version", FT_UINT8, BASE_DEC, NULL, 0x0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_ip_hdr_len,
                { "Header Length",      "ip.hdr_len", FT_UINT8, BASE_DEC, NULL, 0x0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_ip_dsfield,
                { "Differentiated Services field",      "ip.dsfield", FT_UINT8, BASE_DEC, NULL, 0x0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_ip_dsfield_dscp,
                { "Differentiated Services Codepoint",  "ip.dsfield.dscp", FT_UINT8, BASE_HEX,
                        VALS(dscp_vals), IPDSFIELD_DSCP_MASK,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_ip_dsfield_ect,
                { "ECN-Capable Transport (ECT)",        "ip.dsfield.ect", FT_UINT8, BASE_DEC, NULL,
                        IPDSFIELD_ECT_MASK,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_ip_dsfield_ce,
                { "ECN-CE",     "ip.dsfield.ce", FT_UINT8, BASE_DEC, NULL,
                        IPDSFIELD_CE_MASK,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_ip_tos,
                { "Type of Service",    "ip.tos", FT_UINT8, BASE_DEC, NULL, 0x0,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_ip_tos_precedence,
                { "Precedence",         "ip.tos.precedence", FT_UINT8, BASE_DEC, VALS(precedence_vals),
                        IPTOS_PREC_MASK,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_ip_tos_delay,
                { "Delay",              "ip.tos.delay", FT_BOOLEAN, 8, TFS(&tos_set_low),
                        IPTOS_LOWDELAY,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_ip_tos_throughput,
                { "Throughput",         "ip.tos.throughput", FT_BOOLEAN, 8, TFS(&tos_set_high),
                        IPTOS_THROUGHPUT,
-                       "" }},
+                       "", HFILL }},
 
                { &hf_ip_tos_reliability,
                { "Reliability",        "ip.tos.reliability", FT_BOOLEAN, 8, TFS(&tos_set_high),