forked from osmocom/wireshark
Split into a separate files. Started adding a bunch more decoding of
structures. Renamed decoding macros to get them more consistent and in line with AFS data types wherever possible. svn path=/trunk/; revision=2553
This commit is contained in:
Nathan Neulinger
parent
e636484bf2
commit
83547932cf
|
|
@ -0,0 +1,654 @@
|
|||
/* packet-afs-defs.h
|
||||
* Routines for AFS packet dissection
|
||||
* Copyright 1999, Nathan Neulinger <nneul@umr.edu>
|
||||
* Based on routines from tcpdump patches by
|
||||
* Ken Hornstein <kenh@cmf.nrl.navy.mil>
|
||||
* Portions based on information retrieved from the RX definitions
|
||||
* in Arla, the free AFS client at http://www.stacken.kth.se/project/arla/
|
||||
* Portions based on information/specs retrieved from the OpenAFS sources at
|
||||
* www.openafs.org, Copyright IBM.
|
||||
*
|
||||
* $Id: packet-afs-defs.h,v 1.1 2000/11/03 17:32:51 nneul Exp $
|
||||
*
|
||||
* Ethereal - Network traffic analyzer
|
||||
* By Gerald Combs <gerald@zing.org>
|
||||
* Copyright 1998 Gerald Combs
|
||||
*
|
||||
* Copied from packet-tftp.c
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
|
||||
static const value_string fs_req[] = {
|
||||
{ 130, "fetch-data" },
|
||||
{ 131, "fetch-acl" },
|
||||
{ 132, "fetch-status" },
|
||||
{ 133, "store-data" },
|
||||
{ 134, "store-acl" },
|
||||
{ 135, "store-status" },
|
||||
{ 136, "remove-file" },
|
||||
{ 137, "create-file" },
|
||||
{ 138, "rename" },
|
||||
{ 139, "symlink" },
|
||||
{ 140, "link" },
|
||||
{ 141, "makedir" },
|
||||
{ 142, "rmdir" },
|
||||
{ 143, "old-set-lock" },
|
||||
{ 144, "old-extend-lock" },
|
||||
{ 145, "old-release-lock" },
|
||||
{ 146, "get-stats" },
|
||||
{ 147, "give-up-callbacks" },
|
||||
{ 148, "get-volume-info" },
|
||||
{ 149, "get-volume-status" },
|
||||
{ 150, "set-volume-status" },
|
||||
{ 151, "get-root-volume" },
|
||||
{ 152, "check-token" },
|
||||
{ 153, "get-time" },
|
||||
{ 154, "nget-volume-info" },
|
||||
{ 155, "bulk-status" },
|
||||
{ 156, "set-lock" },
|
||||
{ 157, "extend-lock" },
|
||||
{ 158, "release-lock" },
|
||||
{ 159, "xstats-version" },
|
||||
{ 160, "get-xstats" },
|
||||
{ 161, "dfs-lookup" },
|
||||
{ 162, "dfs-flushcps" },
|
||||
{ 163, "dfs-symlink" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string cb_req[] = {
|
||||
{ 204, "callback" },
|
||||
{ 205, "init-callback-state" },
|
||||
{ 206, "probe" },
|
||||
{ 207, "get-lock" },
|
||||
{ 208, "get-ce" },
|
||||
{ 209, "xstats-version" },
|
||||
{ 210, "get-xstats" },
|
||||
{ 211, "init-callback-state2" },
|
||||
{ 212, "who-are-you" },
|
||||
{ 213, "init-callback-state3" },
|
||||
{ 214, "probeuuid" },
|
||||
{ 215, "get-server-prefs" },
|
||||
{ 216, "get-cellservdb" },
|
||||
{ 217, "get-local-cell" },
|
||||
{ 218, "get-cache-config" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string prot_req[] = {
|
||||
{ 500, "new-user" },
|
||||
{ 501, "where-is-it" },
|
||||
{ 502, "dump-entry" },
|
||||
{ 503, "add-to-group" },
|
||||
{ 504, "name-to-id" },
|
||||
{ 505, "id-to-name" },
|
||||
{ 506, "delete" },
|
||||
{ 507, "remove-from-group" },
|
||||
{ 508, "get-cps" },
|
||||
{ 509, "new-entry" },
|
||||
{ 510, "list-max" },
|
||||
{ 511, "set-max" },
|
||||
{ 512, "list-entry" },
|
||||
{ 513, "change-entry" },
|
||||
{ 514, "list-elements" },
|
||||
{ 515, "is-member-of" },
|
||||
{ 516, "set-fld-sentry" },
|
||||
{ 517, "list-owned" },
|
||||
{ 518, "get-cps2" },
|
||||
{ 519, "get-host-cps" },
|
||||
{ 520, "update-entry" },
|
||||
{ 521, "list-entries" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string vldb_req[] = {
|
||||
{ 501, "create-entry" },
|
||||
{ 502, "delete-entry" },
|
||||
{ 503, "get-entry-by-id" },
|
||||
{ 504, "get-entry-by-name" },
|
||||
{ 505, "get-new-volume-id" },
|
||||
{ 506, "replace-entry" },
|
||||
{ 507, "update-entry" },
|
||||
{ 508, "set-lock" },
|
||||
{ 509, "release-lock" },
|
||||
{ 510, "list-entry" },
|
||||
{ 511, "list-attributes" },
|
||||
{ 512, "linked-list" },
|
||||
{ 513, "get-stats" },
|
||||
{ 514, "probe" },
|
||||
{ 515, "get-addrs" },
|
||||
{ 516, "change-addr" },
|
||||
{ 517, "create-entry-n" },
|
||||
{ 518, "get-entry-by-id-n" },
|
||||
{ 519, "get-entry-by-name-n" },
|
||||
{ 520, "replace-entry-n" },
|
||||
{ 521, "list-entry-n" },
|
||||
{ 522, "list-attrib-n" },
|
||||
{ 523, "linked-list-n" },
|
||||
{ 524, "update-entry-by-name" },
|
||||
{ 525, "create-entry-u" },
|
||||
{ 526, "get-entry-by-id-u" },
|
||||
{ 527, "get-entry-by-name-u" },
|
||||
{ 528, "replace-entry-u" },
|
||||
{ 529, "list-entry-u" },
|
||||
{ 530, "list-attrib-u" },
|
||||
{ 531, "linked-list-u" },
|
||||
{ 532, "regaddr" },
|
||||
{ 533, "get-addrs-u" },
|
||||
{ 534, "list-attrib-n2" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string kauth_req[] = {
|
||||
{ 1, "auth-old" },
|
||||
{ 21, "authenticate" },
|
||||
{ 22, "authenticate-v2" },
|
||||
{ 2, "change-pw" },
|
||||
{ 3, "get-ticket-old" },
|
||||
{ 23, "get-ticket" },
|
||||
{ 4, "set-pw" },
|
||||
{ 5, "set-fields" },
|
||||
{ 6, "create-user" },
|
||||
{ 7, "delete-user" },
|
||||
{ 8, "get-entry" },
|
||||
{ 9, "list-entry" },
|
||||
{ 10, "get-stats" },
|
||||
{ 11, "debug" },
|
||||
{ 12, "get-pw" },
|
||||
{ 13, "get-random-key" },
|
||||
{ 14, "unlock" },
|
||||
{ 15, "lock-status" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string vol_req[] = {
|
||||
{ 100, "create-volume" },
|
||||
{ 101, "delete-volume" },
|
||||
{ 102, "restore" },
|
||||
{ 103, "forward" },
|
||||
{ 104, "end-trans" },
|
||||
{ 105, "clone" },
|
||||
{ 106, "set-flags" },
|
||||
{ 107, "get-flags" },
|
||||
{ 108, "trans-create" },
|
||||
{ 109, "dump" },
|
||||
{ 110, "get-nth-volume" },
|
||||
{ 111, "set-forwarding" },
|
||||
{ 112, "get-name" },
|
||||
{ 113, "get-status" },
|
||||
{ 114, "sig-restore" },
|
||||
{ 115, "list-partitions" },
|
||||
{ 116, "list-volumes" },
|
||||
{ 117, "set-id-types" },
|
||||
{ 118, "monitor" },
|
||||
{ 119, "partition-info" },
|
||||
{ 120, "reclone" },
|
||||
{ 121, "list-one-volume" },
|
||||
{ 122, "nuke" },
|
||||
{ 123, "set-date" },
|
||||
{ 124, "x-list-volumes" },
|
||||
{ 125, "x-list-one-volume" },
|
||||
{ 126, "set-info" },
|
||||
{ 127, "x-list-partitions" },
|
||||
{ 128, "forward-multiple" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string bos_req[] = {
|
||||
{ 80, "create-bnode" },
|
||||
{ 81, "delete-bnode" },
|
||||
{ 82, "set-status" },
|
||||
{ 83, "get-status" },
|
||||
{ 84, "enumerate-instance" },
|
||||
{ 85, "get-instance-info" },
|
||||
{ 86, "get-instance-parm" },
|
||||
{ 87, "add-superuser" },
|
||||
{ 88, "delete-superuser" },
|
||||
{ 89, "list-superusers" },
|
||||
{ 90, "list-keys" },
|
||||
{ 91, "add-key" },
|
||||
{ 92, "delete-key" },
|
||||
{ 93, "set-cell-name" },
|
||||
{ 94, "get-cell-name" },
|
||||
{ 95, "get-cell-host" },
|
||||
{ 96, "add-cell-host" },
|
||||
{ 97, "delete-cell-host" },
|
||||
{ 98, "set-t-status" },
|
||||
{ 99, "shutdown-all" },
|
||||
{ 100, "restart-all" },
|
||||
{ 101, "startup-all" },
|
||||
{ 102, "set-noauth-flag" },
|
||||
{ 103, "re-bozo" },
|
||||
{ 104, "restart" },
|
||||
{ 105, "install" },
|
||||
{ 106, "uninstall" },
|
||||
{ 107, "get-dates" },
|
||||
{ 108, "exec" },
|
||||
{ 109, "prune" },
|
||||
{ 110, "set-restart-time" },
|
||||
{ 111, "get-restart-time" },
|
||||
{ 112, "get-log" },
|
||||
{ 113, "wait-all" },
|
||||
{ 114, "get-instance-strings" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string update_req[] = {
|
||||
{ 1, "fetch-file" },
|
||||
{ 2, "fetch-info" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string rmtsys_req[] = {
|
||||
{ 1, "setpag" },
|
||||
{ 2, "pioctl" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string backup_req[] = {
|
||||
{ 100, "perform-dump" },
|
||||
{ 101, "perform-restore" },
|
||||
{ 102, "check-dump" },
|
||||
{ 103, "abort-dump" },
|
||||
{ 104, "wait-for-dump" },
|
||||
{ 105, "end-dump" },
|
||||
{ 106, "get-tm-info" },
|
||||
{ 107, "label-tape" },
|
||||
{ 108, "scan-nodes" },
|
||||
{ 109, "read-label" },
|
||||
{ 110, "scan-dumps" },
|
||||
{ 111, "get-tc-info" },
|
||||
{ 112, "save-database" },
|
||||
{ 113, "restore-database" },
|
||||
{ 114, "get-status" },
|
||||
{ 115, "request-abort" },
|
||||
{ 116, "end-status" },
|
||||
{ 117, "scan-status" },
|
||||
{ 118, "delete-dump" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string ubik_req[] = {
|
||||
{ 10000, "vote-beacon" },
|
||||
{ 10001, "vote-debug-old" },
|
||||
{ 10002, "vote-sdebug-old" },
|
||||
{ 10003, "vote-getsyncsite" },
|
||||
{ 10004, "vote-debug" },
|
||||
{ 10005, "vote-sdebug" },
|
||||
{ 20000, "disk-begin" },
|
||||
{ 20001, "disk-commit" },
|
||||
{ 20002, "disk-lock" },
|
||||
{ 20003, "disk-write" },
|
||||
{ 20004, "disk-getversion" },
|
||||
{ 20005, "disk-getfile" },
|
||||
{ 20006, "disk-sendfile" },
|
||||
{ 20007, "disk-abort" },
|
||||
{ 20008, "disk-releaselocks" },
|
||||
{ 20009, "disk-truncate" },
|
||||
{ 20010, "disk-probe" },
|
||||
{ 20011, "disk-writev" },
|
||||
{ 20012, "disk-interfaceaddr" },
|
||||
{ 20013, "disk-setversion" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string cb_types[] = {
|
||||
{ CB_TYPE_EXCLUSIVE, "exclusive" },
|
||||
{ CB_TYPE_SHARED, "shared" },
|
||||
{ CB_TYPE_DROPPED, "dropped" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string afs_errors[] = {
|
||||
/* VOL Errors */
|
||||
{ 363520, "ID Exists"},
|
||||
{ 363521, "IO Error"},
|
||||
{ 363522, "Name Exists"},
|
||||
{ 363523, "Create Failed"},
|
||||
{ 363524, "Entry Not Found"},
|
||||
{ 363525, "Empty"},
|
||||
{ 363526, "Entry Deleted"},
|
||||
{ 363527, "Bad Name"},
|
||||
{ 363528, "Bad Index"},
|
||||
{ 363529, "Bad Volume Type"},
|
||||
{ 363530, "Bad Partition"},
|
||||
{ 363531, "Bad Server"},
|
||||
{ 363532, "Bad Replicate Server"},
|
||||
{ 363533, "No Replicate Server"},
|
||||
{ 363534, "Duplicate Replicate Server"},
|
||||
{ 363535, "ReadWrite Volume Not Found"},
|
||||
{ 363536, "Bad Reference Count"},
|
||||
{ 363537, "Size Exceeded"},
|
||||
{ 363538, "Bad Entry"},
|
||||
{ 363539, "Bad Volume ID Bump"},
|
||||
{ 363540, "Already has edit"},
|
||||
{ 363541, "Entry Locked"},
|
||||
{ 363542, "Bad Volume Operation"},
|
||||
{ 363543, "Bad Rel Lock Type"},
|
||||
{ 363544, "Rerelease"},
|
||||
{ 363545, "Bad Server"},
|
||||
{ 363546, "Permission Denied"},
|
||||
{ 363547, "Out of Memory"},
|
||||
|
||||
/* KAUTH Errors */
|
||||
{ 180480, "Database Inconsistent"},
|
||||
{ 180481, "Exists"},
|
||||
{ 180482, "IO"},
|
||||
{ 180483, "Create Failed"},
|
||||
{ 180484, "noent"},
|
||||
{ 180485, "Empty"},
|
||||
{ 180486, "Bad Name"},
|
||||
{ 180487, "Bad Index"},
|
||||
{ 180488, "No auth"},
|
||||
{ 180489, "Answer too long"},
|
||||
{ 180490, "Bad Request"},
|
||||
{ 180491, "Old Interface"},
|
||||
{ 180492, "Bad Argument"},
|
||||
{ 180493, "Bad Command"},
|
||||
{ 180494, "No keys"},
|
||||
{ 180495, "Read PW"},
|
||||
{ 180496, "Bad key"},
|
||||
{ 180497, "Ubik Init"},
|
||||
{ 180498, "Ubik Call"},
|
||||
{ 180499, "Bad Protocol"},
|
||||
{ 180500, "No cells"},
|
||||
{ 180501, "No cell"},
|
||||
{ 180502, "Too many ubiks"},
|
||||
{ 180503, "Too many keys"},
|
||||
{ 180504, "Bad ticket"},
|
||||
{ 180505, "Unknown Key"},
|
||||
{ 180506, "Key Cache Invalid"},
|
||||
{ 180507, "Bad Server"},
|
||||
{ 180508, "Bad User"},
|
||||
{ 180509, "Bad CPW"},
|
||||
{ 180510, "Bad Create"},
|
||||
{ 180511, "No ticket"},
|
||||
{ 180512, "Assoc user"},
|
||||
{ 180513, "Not special"},
|
||||
{ 180514, "Clock skew too great"},
|
||||
{ 180515, "No recursion"},
|
||||
{ 180516, "RX failed"},
|
||||
{ 180517, "Null password"},
|
||||
{ 180518, "Internal error"},
|
||||
{ 180519, "Password expired"},
|
||||
{ 180520, "Reused"},
|
||||
{ 180521, "Too soon"},
|
||||
{ 180522, "Locked"},
|
||||
|
||||
/* PT Errors */
|
||||
{ 267264, "Exists"},
|
||||
{ 267265, "ID Exists"},
|
||||
{ 267266, "No IDs"},
|
||||
{ 267267, "DB Failed"},
|
||||
{ 267268, "No such entry"},
|
||||
{ 267269, "Permission denied"},
|
||||
{ 267270, "Not group"},
|
||||
{ 267271, "Not user"},
|
||||
{ 267272, "Bad name"},
|
||||
{ 267273, "Bad argument"},
|
||||
{ 267274, "No more"},
|
||||
{ 267275, "Bad DB"},
|
||||
{ 267276, "Group empty"},
|
||||
{ 267277, "Inconsistent"},
|
||||
{ 267278, "DB Address"},
|
||||
{ 267279, "Too many"},
|
||||
{ 267280, "No memory"},
|
||||
|
||||
/* Volume server errors */
|
||||
{ 1492325120, "Release error"},
|
||||
{ 1492325121, "No op"},
|
||||
{ 1492325122, "Read dump error"},
|
||||
{ 1492325123, "Dump error"},
|
||||
{ 1492325124, "Attach error"},
|
||||
{ 1492325125, "Illegal partition"},
|
||||
{ 1492325126, "Detach error"},
|
||||
{ 1492325127, "Bad access"},
|
||||
{ 1492325128, "VLDB error"},
|
||||
{ 1492325129, "Bad Name"},
|
||||
{ 1492325130, "Volume moved"},
|
||||
{ 1492325131, "Bad operation"},
|
||||
{ 1492325132, "Bad release"},
|
||||
{ 1492325133, "Volume busy"},
|
||||
{ 1492325134, "No memory"},
|
||||
{ 1492325135, "No volume"},
|
||||
{ 1492325136, "Multiple RW volumes"},
|
||||
{ 1492325137, "Failed operation"},
|
||||
|
||||
/* add more of these errors to decode the errcode responses */
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string port_types[] = {
|
||||
{ AFS_PORT_FS, "File Server" },
|
||||
{ AFS_PORT_CB, "Callback Server" },
|
||||
{ AFS_PORT_BOS, "BOS Server" },
|
||||
{ AFS_PORT_PROT, "Protection Server" },
|
||||
{ AFS_PORT_VLDB, "Volume Location Database Server" },
|
||||
{ AFS_PORT_KAUTH, "Kerberos Authentication Server" },
|
||||
{ AFS_PORT_ERROR, "Error Server" },
|
||||
{ AFS_PORT_VOL, "Volume Server" },
|
||||
{ AFS_PORT_RMTSYS, "Rmtsys? Server" },
|
||||
{ AFS_PORT_UPDATE, "Update? Server" },
|
||||
{ AFS_PORT_BACKUP, "Backup Server" },
|
||||
{ 0, NULL }
|
||||
};
|
||||
|
||||
static const value_string port_types_short[] = {
|
||||
{ AFS_PORT_FS, "FS" },
|
||||
{ AFS_PORT_CB, "CB" },
|
||||
{ AFS_PORT_BOS, "BOS" },
|
||||
{ AFS_PORT_PROT, "PROT" },
|
||||
{ AFS_PORT_VLDB, "VLDB" },
|
||||
{ AFS_PORT_KAUTH, "KAUTH" },
|
||||
{ AFS_PORT_ERROR, "ERR" },
|
||||
{ AFS_PORT_VOL, "VOL" },
|
||||
{ AFS_PORT_RMTSYS, "RMT" },
|
||||
{ AFS_PORT_UPDATE, "UPD" },
|
||||
{ AFS_PORT_BACKUP, "BKUP" },
|
||||
{ 0, NULL }
|
||||
};
|
||||
|
||||
static const value_string ubik_lock_types[] = {
|
||||
{ 1, "read" },
|
||||
{ 2, "write" },
|
||||
{ 3, "wait" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const value_string volume_types[] = {
|
||||
{ 0, "read-write" },
|
||||
{ 1, "read-only" },
|
||||
{ 2, "backup" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static int proto_afs = -1;
|
||||
static int hf_afs_fs = -1;
|
||||
static int hf_afs_cb = -1;
|
||||
static int hf_afs_prot = -1;
|
||||
static int hf_afs_vldb = -1;
|
||||
static int hf_afs_kauth = -1;
|
||||
static int hf_afs_vol = -1;
|
||||
static int hf_afs_error = -1;
|
||||
static int hf_afs_bos = -1;
|
||||
static int hf_afs_update = -1;
|
||||
static int hf_afs_rmtsys = -1;
|
||||
static int hf_afs_ubik = -1;
|
||||
static int hf_afs_backup = -1;
|
||||
|
||||
static int hf_afs_fs_opcode = -1;
|
||||
static int hf_afs_cb_opcode = -1;
|
||||
static int hf_afs_prot_opcode = -1;
|
||||
static int hf_afs_vldb_opcode = -1;
|
||||
static int hf_afs_kauth_opcode = -1;
|
||||
static int hf_afs_vol_opcode = -1;
|
||||
static int hf_afs_error_opcode = -1;
|
||||
static int hf_afs_bos_opcode = -1;
|
||||
static int hf_afs_update_opcode = -1;
|
||||
static int hf_afs_rmtsys_opcode = -1;
|
||||
static int hf_afs_ubik_opcode = -1;
|
||||
static int hf_afs_backup_opcode = -1;
|
||||
|
||||
static int hf_afs_fs_fid_volume = -1;
|
||||
static int hf_afs_fs_fid_vnode = -1;
|
||||
static int hf_afs_fs_fid_uniqifier = -1;
|
||||
static int hf_afs_fs_offset = -1;
|
||||
static int hf_afs_fs_length = -1;
|
||||
static int hf_afs_fs_flength = -1;
|
||||
static int hf_afs_fs_errcode = -1;
|
||||
static int hf_afs_fs_data = -1;
|
||||
static int hf_afs_fs_name = -1;
|
||||
static int hf_afs_fs_oldname = -1;
|
||||
static int hf_afs_fs_newname = -1;
|
||||
static int hf_afs_fs_symlink_name = -1;
|
||||
static int hf_afs_fs_symlink_content = -1;
|
||||
static int hf_afs_fs_volid = -1;
|
||||
static int hf_afs_fs_volname = -1;
|
||||
static int hf_afs_fs_timestamp = -1;
|
||||
|
||||
static int hf_afs_fs_status_anonymousaccess = -1;
|
||||
static int hf_afs_fs_status_author = -1;
|
||||
static int hf_afs_fs_status_calleraccess = -1;
|
||||
static int hf_afs_fs_status_clientmodtime = -1;
|
||||
static int hf_afs_fs_status_dataversion = -1;
|
||||
static int hf_afs_fs_status_dataversionhigh = -1;
|
||||
static int hf_afs_fs_status_filetype = -1;
|
||||
static int hf_afs_fs_status_group = -1;
|
||||
static int hf_afs_fs_status_interfaceversion = -1;
|
||||
static int hf_afs_fs_status_length = -1;
|
||||
static int hf_afs_fs_status_linkcount = -1;
|
||||
static int hf_afs_fs_status_mask = -1;
|
||||
static int hf_afs_fs_status_mask_fsync = -1;
|
||||
static int hf_afs_fs_status_mask_setgroup = -1;
|
||||
static int hf_afs_fs_status_mask_setmode = -1;
|
||||
static int hf_afs_fs_status_mask_setmodtime = -1;
|
||||
static int hf_afs_fs_status_mask_setowner = -1;
|
||||
static int hf_afs_fs_status_mask_setsegsize = -1;
|
||||
static int hf_afs_fs_status_mode = -1;
|
||||
static int hf_afs_fs_status_owner = -1;
|
||||
static int hf_afs_fs_status_parentunique = -1;
|
||||
static int hf_afs_fs_status_parentvnode = -1;
|
||||
static int hf_afs_fs_status_segsize = -1;
|
||||
static int hf_afs_fs_status_servermodtime = -1;
|
||||
static int hf_afs_fs_status_spare2 = -1;
|
||||
static int hf_afs_fs_status_spare3 = -1;
|
||||
static int hf_afs_fs_status_spare4 = -1;
|
||||
static int hf_afs_fs_status_synccounter = -1;
|
||||
|
||||
|
||||
static int hf_afs_fs_acl_datasize = -1;
|
||||
static int hf_afs_fs_acl_count_negative = -1;
|
||||
static int hf_afs_fs_acl_count_positive = -1;
|
||||
static int hf_afs_fs_acl_entity = -1;
|
||||
static int hf_afs_fs_acl_r = -1;
|
||||
static int hf_afs_fs_acl_l = -1;
|
||||
static int hf_afs_fs_acl_i = -1;
|
||||
static int hf_afs_fs_acl_d = -1;
|
||||
static int hf_afs_fs_acl_w = -1;
|
||||
static int hf_afs_fs_acl_k = -1;
|
||||
static int hf_afs_fs_acl_a = -1;
|
||||
|
||||
static int hf_afs_fs_callback_version = -1;
|
||||
static int hf_afs_fs_callback_expires = -1;
|
||||
static int hf_afs_fs_callback_type = -1;
|
||||
|
||||
static int hf_afs_bos_errcode = -1;
|
||||
static int hf_afs_bos_type = -1;
|
||||
static int hf_afs_bos_instance = -1;
|
||||
static int hf_afs_bos_status = -1;
|
||||
static int hf_afs_bos_num = -1;
|
||||
static int hf_afs_bos_size = -1;
|
||||
static int hf_afs_bos_flags = -1;
|
||||
static int hf_afs_bos_date = -1;
|
||||
static int hf_afs_bos_content = -1;
|
||||
|
||||
static int hf_afs_vldb_errcode = -1;
|
||||
static int hf_afs_vldb_name = -1;
|
||||
static int hf_afs_vldb_id = -1;
|
||||
static int hf_afs_vldb_type = -1;
|
||||
static int hf_afs_vldb_bump = -1;
|
||||
static int hf_afs_vldb_index = -1;
|
||||
static int hf_afs_vldb_nextindex = -1;
|
||||
static int hf_afs_vldb_count = -1;
|
||||
static int hf_afs_vldb_numservers = -1;
|
||||
static int hf_afs_vldb_server = -1;
|
||||
static int hf_afs_vldb_serveruuid = -1;
|
||||
static int hf_afs_vldb_partition = -1;
|
||||
static int hf_afs_vldb_rovol = -1;
|
||||
static int hf_afs_vldb_rwvol = -1;
|
||||
static int hf_afs_vldb_bkvol = -1;
|
||||
|
||||
static int hf_afs_kauth_errcode = -1;
|
||||
static int hf_afs_kauth_princ = -1;
|
||||
static int hf_afs_kauth_realm = -1;
|
||||
static int hf_afs_kauth_domain = -1;
|
||||
static int hf_afs_kauth_kvno = -1;
|
||||
static int hf_afs_kauth_name = -1;
|
||||
static int hf_afs_kauth_data = -1;
|
||||
|
||||
static int hf_afs_vol_errcode = -1;
|
||||
static int hf_afs_vol_count = -1;
|
||||
static int hf_afs_vol_id = -1;
|
||||
static int hf_afs_vol_name = -1;
|
||||
|
||||
static int hf_afs_cb_errcode = -1;
|
||||
static int hf_afs_cb_callback_version = -1;
|
||||
static int hf_afs_cb_callback_type = -1;
|
||||
static int hf_afs_cb_callback_expires = -1;
|
||||
static int hf_afs_cb_fid_volume = -1;
|
||||
static int hf_afs_cb_fid_vnode = -1;
|
||||
static int hf_afs_cb_fid_uniqifier = -1;
|
||||
|
||||
static int hf_afs_prot_errcode = -1;
|
||||
static int hf_afs_prot_name = -1;
|
||||
static int hf_afs_prot_id = -1;
|
||||
static int hf_afs_prot_count = -1;
|
||||
static int hf_afs_prot_oldid = -1;
|
||||
static int hf_afs_prot_newid = -1;
|
||||
static int hf_afs_prot_pos = -1;
|
||||
static int hf_afs_prot_flag = -1;
|
||||
static int hf_afs_prot_uid = -1;
|
||||
static int hf_afs_prot_gid = -1;
|
||||
static int hf_afs_prot_maxuid = -1;
|
||||
static int hf_afs_prot_maxgid = -1;
|
||||
|
||||
static int hf_afs_backup_errcode = -1;
|
||||
|
||||
static int hf_afs_ubik_errcode = -1;
|
||||
static int hf_afs_ubik_version_epoch = -1;
|
||||
static int hf_afs_ubik_version_counter = -1;
|
||||
static int hf_afs_ubik_votestart = -1;
|
||||
static int hf_afs_ubik_syncsite = -1;
|
||||
static int hf_afs_ubik_site = -1;
|
||||
static int hf_afs_ubik_file = -1;
|
||||
static int hf_afs_ubik_pos = -1;
|
||||
static int hf_afs_ubik_length = -1;
|
||||
static int hf_afs_ubik_locktype = -1;
|
||||
static int hf_afs_ubik_voteend = -1;
|
||||
static int hf_afs_ubik_votetype = -1;
|
||||
|
||||
static gint ett_afs = -1;
|
||||
static gint ett_afs_op = -1;
|
||||
static gint ett_afs_acl = -1;
|
||||
static gint ett_afs_fid = -1;
|
||||
static gint ett_afs_callback = -1;
|
||||
static gint ett_afs_ubikver = -1;
|
||||
static gint ett_afs_status = -1;
|
||||
static gint ett_afs_status_mask = -1;
|
||||
static gint ett_afs_volsync = -1;
|
||||
static gint ett_afs_volumeinfo = -1;
|
||||
static gint ett_afs_vicestat = -1;
|
||||
|
|
@ -0,0 +1,345 @@
|
|||
/* packet-afs-macros.h
|
||||
* Helper macros for AFS packet dissection
|
||||
* Copyright 1999, Nathan Neulinger <nneul@umr.edu>
|
||||
* Based on routines from tcpdump patches by
|
||||
* Ken Hornstein <kenh@cmf.nrl.navy.mil>
|
||||
* Portions based on information retrieved from the RX definitions
|
||||
* in Arla, the free AFS client at http://www.stacken.kth.se/project/arla/
|
||||
* Portions based on information/specs retrieved from the OpenAFS sources at
|
||||
* www.openafs.org, Copyright IBM.
|
||||
*
|
||||
* $Id: packet-afs-macros.h,v 1.1 2000/11/03 17:32:51 nneul Exp $
|
||||
*
|
||||
* Ethereal - Network traffic analyzer
|
||||
* By Gerald Combs <gerald@zing.org>
|
||||
* Copyright 1998 Gerald Combs
|
||||
*
|
||||
* Copied from packet-tftp.c
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Macros for helper dissection routines
|
||||
*
|
||||
* The macros are here to save on coding. They assume that
|
||||
* the current offset is in 'curoffset', and that the offset
|
||||
* should be incremented after performing the macro's operation.
|
||||
*/
|
||||
|
||||
/* Get the next available integer, be sure and call TRUNC beforehand */
|
||||
#define GETINT() (pntohl(&pd[curoffset]))
|
||||
|
||||
/* Check if enough bytes are present, if not, return to caller
|
||||
after adding a 'Truncated' message to tree */
|
||||
#define TRUNC(bytes) \
|
||||
if(!BYTES_ARE_IN_FRAME(curoffset,(bytes))) \
|
||||
{ proto_tree_add_text(tree, NullTVB,curoffset,END_OF_FRAME,"Truncated"); \
|
||||
return; }
|
||||
|
||||
/* Output a unsigned integer, stored into field 'field'
|
||||
Assumes it is in network byte order, converts to host before using */
|
||||
#define OUT_UINT(field) \
|
||||
TRUNC(sizeof(guint32)) \
|
||||
proto_tree_add_uint(tree,field, NullTVB,curoffset,sizeof(guint32), GETINT()); \
|
||||
curoffset += 4;
|
||||
|
||||
/* Output a unsigned integer, stored into field 'field'
|
||||
Assumes it is in network byte order, converts to host before using,
|
||||
Note - does not increment offset, so can be used repeatedly for bitfields */
|
||||
#define DISP_UINT(field) \
|
||||
TRUNC(sizeof(guint32)) \
|
||||
proto_tree_add_uint(tree,field, NullTVB,curoffset,sizeof(guint32), GETINT());
|
||||
|
||||
/* Output an IPv4 address, stored into field 'field' */
|
||||
#define OUT_IP(field) \
|
||||
TRUNC(sizeof(gint32)) \
|
||||
proto_tree_add_ipv4(tree,field, NullTVB,curoffset,sizeof(gint32),\
|
||||
*((int*)&pd[curoffset]));\
|
||||
curoffset += 4;
|
||||
|
||||
/* Output a UNIX seconds/microseconds timestamp, after converting to a timeval */
|
||||
#define OUT_TIMESTAMP(field) \
|
||||
{ struct timeval tv; \
|
||||
TRUNC(2*sizeof(guint32)); \
|
||||
tv.tv_sec = GETINT(); \
|
||||
tv.tv_usec = GETINT(); \
|
||||
proto_tree_add_time(tree,field, NullTVB,curoffset,2*sizeof(guint32),&tv); \
|
||||
curoffset += 8; \
|
||||
}
|
||||
|
||||
/* Output a UNIX seconds-only timestamp, after converting to a timeval */
|
||||
#define OUT_DATE(field) \
|
||||
{ struct timeval tv; \
|
||||
TRUNC(sizeof(guint32)); \
|
||||
tv.tv_sec = GETINT(); \
|
||||
tv.tv_usec = 0; \
|
||||
proto_tree_add_time(tree,field, NullTVB,curoffset,sizeof(guint32),&tv); \
|
||||
curoffset += 4; \
|
||||
}
|
||||
|
||||
/* Output a callback */
|
||||
#define OUT_FS_AFSCallBack() \
|
||||
{ proto_tree *save, *ti; \
|
||||
ti = proto_tree_add_text(tree, NullTVB, curoffset, 3*4, "Callback"); \
|
||||
save = tree; \
|
||||
tree = proto_item_add_subtree(ti, ett_afs_callback); \
|
||||
TRUNC(3*sizeof(guint32)); \
|
||||
OUT_UINT(hf_afs_fs_callback_version); \
|
||||
OUT_TIMESTAMP(hf_afs_fs_callback_expires); \
|
||||
OUT_UINT(hf_afs_fs_callback_type); \
|
||||
tree = save; \
|
||||
}
|
||||
|
||||
/* Output a callback */
|
||||
#define CB_CALLBACKOUT() \
|
||||
{ proto_tree *save, *ti; \
|
||||
ti = proto_tree_add_text(tree, NullTVB, curoffset, 3*4, "Callback"); \
|
||||
save = tree; \
|
||||
tree = proto_item_add_subtree(ti, ett_afs_callback); \
|
||||
TRUNC(3*sizeof(guint32)); \
|
||||
OUT_UINT(hf_afs_cb_callback_version); \
|
||||
OUT_DATE(hf_afs_cb_callback_expires); \
|
||||
OUT_UINT(hf_afs_cb_callback_type); \
|
||||
tree = save; \
|
||||
}
|
||||
|
||||
|
||||
/* Output a File ID */
|
||||
#define OUT_FS_AFSFid(label) \
|
||||
{ proto_tree *save, *ti; \
|
||||
ti = proto_tree_add_text(tree, NullTVB, curoffset, 3*4, \
|
||||
"FileID (%s)", label); \
|
||||
save = tree; \
|
||||
tree = proto_item_add_subtree(ti, ett_afs_fid); \
|
||||
OUT_UINT(hf_afs_fs_fid_volume); \
|
||||
OUT_UINT(hf_afs_fs_fid_vnode); \
|
||||
OUT_UINT(hf_afs_fs_fid_uniqifier); \
|
||||
tree = save; \
|
||||
}
|
||||
|
||||
/* Output a Status mask */
|
||||
#define OUT_FS_STATUSMASK() \
|
||||
{ proto_tree *save, *ti; \
|
||||
guint32 mask; \
|
||||
TRUNC(sizeof(guint32)); \
|
||||
mask = GETINT(); \
|
||||
ti = proto_tree_add_uint(tree, hf_afs_fs_status_mask, NullTVB, curoffset, \
|
||||
sizeof(guint32), mask); \
|
||||
save = tree; \
|
||||
tree = proto_item_add_subtree(ti, ett_afs_status_mask); \
|
||||
proto_tree_add_uint(tree, hf_afs_fs_status_mask_setmodtime, \
|
||||
NullTVB,curoffset,sizeof(guint32), mask); \
|
||||
proto_tree_add_uint(tree, hf_afs_fs_status_mask_setowner, \
|
||||
NullTVB,curoffset,sizeof(guint32), mask); \
|
||||
proto_tree_add_uint(tree, hf_afs_fs_status_mask_setgroup, \
|
||||
NullTVB,curoffset,sizeof(guint32), mask); \
|
||||
proto_tree_add_uint(tree, hf_afs_fs_status_mask_setmode, \
|
||||
NullTVB,curoffset,sizeof(guint32), mask); \
|
||||
proto_tree_add_uint(tree, hf_afs_fs_status_mask_setsegsize, \
|
||||
NullTVB,curoffset,sizeof(guint32), mask); \
|
||||
proto_tree_add_uint(tree, hf_afs_fs_status_mask_fsync, \
|
||||
NullTVB,curoffset,sizeof(guint32), mask); \
|
||||
curoffset += 4; \
|
||||
tree = save; \
|
||||
}
|
||||
|
||||
/* Output a File ID */
|
||||
#define OUT_CB_AFSFid(label) \
|
||||
{ proto_tree *save, *ti; \
|
||||
ti = proto_tree_add_text(tree, NullTVB, curoffset, 3*4, \
|
||||
"FileID (%s)", label); \
|
||||
save = tree; \
|
||||
tree = proto_item_add_subtree(ti, ett_afs_fid); \
|
||||
OUT_UINT(hf_afs_cb_fid_volume); \
|
||||
OUT_UINT(hf_afs_cb_fid_vnode); \
|
||||
OUT_UINT(hf_afs_cb_fid_uniqifier); \
|
||||
tree = save; \
|
||||
}
|
||||
|
||||
/* Output a StoreStatus */
|
||||
#define OUT_FS_AFSStoreStatus(label) \
|
||||
{ proto_tree *save, *ti; \
|
||||
ti = proto_tree_add_text(tree, NullTVB, curoffset, 6*4, \
|
||||
label); \
|
||||
save = tree; \
|
||||
tree = proto_item_add_subtree(ti, ett_afs_status); \
|
||||
OUT_FS_STATUSMASK(); \
|
||||
OUT_DATE(hf_afs_fs_status_clientmodtime); \
|
||||
OUT_UINT(hf_afs_fs_status_owner); \
|
||||
OUT_UINT(hf_afs_fs_status_group); \
|
||||
OUT_UINT(hf_afs_fs_status_mode); \
|
||||
OUT_UINT(hf_afs_fs_status_segsize); \
|
||||
tree = save; \
|
||||
}
|
||||
|
||||
/* Output a FetchStatus */
|
||||
#define OUT_FS_AFSFetchStatus(label) \
|
||||
{ proto_tree *save, *ti; \
|
||||
ti = proto_tree_add_text(tree, NullTVB, curoffset, 6*4, \
|
||||
label); \
|
||||
save = tree; \
|
||||
tree = proto_item_add_subtree(ti, ett_afs_status); \
|
||||
OUT_UINT(hf_afs_fs_status_interfaceversion); \
|
||||
OUT_UINT(hf_afs_fs_status_filetype); \
|
||||
OUT_UINT(hf_afs_fs_status_linkcount); \
|
||||
OUT_UINT(hf_afs_fs_status_length); \
|
||||
OUT_UINT(hf_afs_fs_status_dataversion); \
|
||||
OUT_UINT(hf_afs_fs_status_author); \
|
||||
OUT_UINT(hf_afs_fs_status_owner); \
|
||||
OUT_UINT(hf_afs_fs_status_calleraccess); \
|
||||
OUT_UINT(hf_afs_fs_status_anonymousaccess); \
|
||||
OUT_UINT(hf_afs_fs_status_mode); \
|
||||
OUT_UINT(hf_afs_fs_status_parentvnode); \
|
||||
OUT_UINT(hf_afs_fs_status_parentunique); \
|
||||
OUT_UINT(hf_afs_fs_status_segsize); \
|
||||
OUT_DATE(hf_afs_fs_status_clientmodtime); \
|
||||
OUT_DATE(hf_afs_fs_status_servermodtime); \
|
||||
OUT_UINT(hf_afs_fs_status_group); \
|
||||
OUT_UINT(hf_afs_fs_status_synccounter); \
|
||||
OUT_UINT(hf_afs_fs_status_dataversionhigh); \
|
||||
OUT_UINT(hf_afs_fs_status_spare2); \
|
||||
OUT_UINT(hf_afs_fs_status_spare3); \
|
||||
OUT_UINT(hf_afs_fs_status_spare4); \
|
||||
tree = save; \
|
||||
}
|
||||
|
||||
/* Output a VolSync */
|
||||
#define OUT_FS_AFSVolSync() \
|
||||
{ \
|
||||
SKIP(6*sizeof(guint32)); \
|
||||
}
|
||||
|
||||
/* Output a AFSCBFids */
|
||||
#define OUT_FS_AFSCBFids()
|
||||
|
||||
/* Output a AFSCBs */
|
||||
#define OUT_FS_AFSCBs()
|
||||
|
||||
/* Output a ViceLockType */
|
||||
#define OUT_FS_ViceLockType()
|
||||
|
||||
/* Output a AFS acl */
|
||||
#define ACLOUT(who, positive, acl, bytes) \
|
||||
{ proto_tree *save, *ti; \
|
||||
int tmpoffset; \
|
||||
int acllen; \
|
||||
char tmp[10]; \
|
||||
tmp[0] = 0; \
|
||||
if ( acl & PRSFS_READ ) strcat(tmp, "r"); \
|
||||
if ( acl & PRSFS_LOOKUP ) strcat(tmp, "l"); \
|
||||
if ( acl & PRSFS_INSERT ) strcat(tmp, "i"); \
|
||||
if ( acl & PRSFS_DELETE ) strcat(tmp, "d"); \
|
||||
if ( acl & PRSFS_WRITE ) strcat(tmp, "w"); \
|
||||
if ( acl & PRSFS_LOCK ) strcat(tmp, "k"); \
|
||||
if ( acl & PRSFS_ADMINISTER ) strcat(tmp, "a"); \
|
||||
ti = proto_tree_add_text(tree, NullTVB, curoffset, bytes, \
|
||||
"ACL: %s %s%s", \
|
||||
who, tmp, positive ? "" : " (negative)"); \
|
||||
save = tree; \
|
||||
tree = proto_item_add_subtree(ti, ett_afs_acl); \
|
||||
proto_tree_add_string(tree,hf_afs_fs_acl_entity, NullTVB,curoffset,strlen(who), who);\
|
||||
tmpoffset = curoffset + strlen(who) + 1; \
|
||||
acllen = bytes - strlen(who) - 1; \
|
||||
proto_tree_add_uint(tree,hf_afs_fs_acl_r, NullTVB,tmpoffset,acllen,acl);\
|
||||
proto_tree_add_uint(tree,hf_afs_fs_acl_l, NullTVB,tmpoffset,acllen,acl);\
|
||||
proto_tree_add_uint(tree,hf_afs_fs_acl_i, NullTVB,tmpoffset,acllen,acl);\
|
||||
proto_tree_add_uint(tree,hf_afs_fs_acl_d, NullTVB,tmpoffset,acllen,acl);\
|
||||
proto_tree_add_uint(tree,hf_afs_fs_acl_w, NullTVB,tmpoffset,acllen,acl);\
|
||||
proto_tree_add_uint(tree,hf_afs_fs_acl_k, NullTVB,tmpoffset,acllen,acl);\
|
||||
proto_tree_add_uint(tree,hf_afs_fs_acl_a, NullTVB,tmpoffset,acllen,acl);\
|
||||
tree = save; \
|
||||
}
|
||||
|
||||
/* Skip a certain number of bytes */
|
||||
#define SKIP(bytes) \
|
||||
TRUNC(bytes) \
|
||||
curoffset += bytes;
|
||||
|
||||
/* Raw data - to end of frame */
|
||||
#define OUT_BYTES_ALL(field) OUT_BYTES(field, offset+END_OF_FRAME-curoffset)
|
||||
|
||||
/* Raw data */
|
||||
#define OUT_BYTES(field, bytes) \
|
||||
TRUNC(bytes); \
|
||||
proto_tree_add_bytes(tree,field, NullTVB,curoffset,bytes,\
|
||||
(void *)&pd[curoffset]); \
|
||||
curoffset += bytes;
|
||||
|
||||
/* Output a rx style string, up to a maximum length first
|
||||
4 bytes - length, then char data */
|
||||
#define OUT_STRING(field) \
|
||||
{ int i; \
|
||||
TRUNC(4); \
|
||||
i = pntohl(&pd[curoffset]); \
|
||||
curoffset += 4; \
|
||||
TRUNC(i); \
|
||||
if ( i > 0 ) { \
|
||||
proto_tree_add_string(tree, field, NullTVB, curoffset-4, i+4, \
|
||||
(void *)&pd[curoffset]); \
|
||||
} else { \
|
||||
proto_tree_add_string(tree, field, NullTVB, curoffset-4, 4, \
|
||||
""); \
|
||||
} \
|
||||
curoffset += i; \
|
||||
}
|
||||
|
||||
/* Output a fixed length vectorized string (each char is a 32 bit int) */
|
||||
#define VECOUT(field, length) \
|
||||
{ char tmp[length+1]; \
|
||||
int i,soff; \
|
||||
soff = curoffset;\
|
||||
TRUNC(length * sizeof(guint32));\
|
||||
for (i=0; i<length; i++)\
|
||||
{\
|
||||
tmp[i] = (char) GETINT();\
|
||||
curoffset += sizeof(guint32);\
|
||||
}\
|
||||
tmp[length] = '\0';\
|
||||
proto_tree_add_string(tree, field, NullTVB, soff, length, tmp);\
|
||||
}
|
||||
|
||||
/* Skip the opcode */
|
||||
#define SKIP_OPCODE() \
|
||||
{ \
|
||||
SKIP(sizeof(guint32)); \
|
||||
}
|
||||
|
||||
/* Output a UBIK version code */
|
||||
#define OUT_UBIKVERSION(label) \
|
||||
{ proto_tree *save, *ti; \
|
||||
unsigned int epoch,counter; \
|
||||
struct timeval tv; \
|
||||
TRUNC(8); \
|
||||
epoch = GETINT(); \
|
||||
curoffset += 4; \
|
||||
counter = GETINT(); \
|
||||
curoffset += 4; \
|
||||
tv.tv_sec = epoch; \
|
||||
tv.tv_usec = 0; \
|
||||
ti = proto_tree_add_text(tree, NullTVB, curoffset, 3*4, \
|
||||
"UBIK Version (%s): %u.%u", label, epoch, counter ); \
|
||||
save = tree; \
|
||||
tree = proto_item_add_subtree(ti, ett_afs_ubikver); \
|
||||
proto_tree_add_time(tree,hf_afs_ubik_version_epoch, NullTVB,curoffset-8, \
|
||||
sizeof(guint32),&tv); \
|
||||
proto_tree_add_uint(tree,hf_afs_ubik_version_counter, NullTVB,curoffset-4, \
|
||||
sizeof(guint32),counter); \
|
||||
tree = save; \
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,465 @@
|
|||
/* packet-afs-register-info.h
|
||||
* Routines for AFS packet dissection
|
||||
* Copyright 1999, Nathan Neulinger <nneul@umr.edu>
|
||||
* Based on routines from tcpdump patches by
|
||||
* Ken Hornstein <kenh@cmf.nrl.navy.mil>
|
||||
* Portions based on information retrieved from the RX definitions
|
||||
* in Arla, the free AFS client at http://www.stacken.kth.se/project/arla/
|
||||
* Portions based on information/specs retrieved from the OpenAFS sources at
|
||||
* www.openafs.org, Copyright IBM.
|
||||
*
|
||||
* $Id: packet-afs-register-info.h,v 1.1 2000/11/03 17:32:51 nneul Exp $
|
||||
*
|
||||
* Ethereal - Network traffic analyzer
|
||||
* By Gerald Combs <gerald@zing.org>
|
||||
* Copyright 1998 Gerald Combs
|
||||
*
|
||||
* Copied from packet-tftp.c
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*/
|
||||
|
||||
{ &hf_afs_fs, { "File Server", "afs.fs",
|
||||
FT_BOOLEAN, BASE_NONE, 0, 0, "File Server" }},
|
||||
{ &hf_afs_cb, { "Callback", "afs.cb",
|
||||
FT_BOOLEAN, BASE_NONE, 0, 0, "Callback" }},
|
||||
{ &hf_afs_prot, { "Protection", "afs.prot",
|
||||
FT_BOOLEAN, BASE_NONE, 0, 0, "Protection Server" }},
|
||||
{ &hf_afs_vldb, { "VLDB", "afs.vldb",
|
||||
FT_BOOLEAN, BASE_NONE, 0, 0, "Volume Location Database Server" }},
|
||||
{ &hf_afs_kauth, { "KAuth", "afs.kauth",
|
||||
FT_BOOLEAN, BASE_NONE, 0, 0, "Kerberos Auth Server" }},
|
||||
{ &hf_afs_vol, { "Volume Server", "afs.vol",
|
||||
FT_BOOLEAN, BASE_NONE, 0, 0, "Volume Server" }},
|
||||
{ &hf_afs_error, { "Error", "afs.error",
|
||||
FT_BOOLEAN, BASE_NONE, 0, 0, "Error" }},
|
||||
{ &hf_afs_bos, { "BOS", "afs.bos",
|
||||
FT_BOOLEAN, BASE_NONE, 0, 0, "Basic Oversee Server" }},
|
||||
{ &hf_afs_update, { "Update", "afs.update",
|
||||
FT_BOOLEAN, BASE_NONE, 0, 0, "Update Server" }},
|
||||
{ &hf_afs_rmtsys, { "Rmtsys", "afs.rmtsys",
|
||||
FT_BOOLEAN, BASE_NONE, 0, 0, "Rmtsys" }},
|
||||
{ &hf_afs_ubik, { "Ubik", "afs.ubik",
|
||||
FT_BOOLEAN, BASE_NONE, 0, 0, "Ubik" }},
|
||||
{ &hf_afs_backup, { "Backup", "afs.backup",
|
||||
FT_BOOLEAN, BASE_NONE, 0, 0, "Backup Server" }},
|
||||
|
||||
{ &hf_afs_fs_opcode, { "Operation", "afs.fs.opcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(fs_req), 0, "Operation" }},
|
||||
{ &hf_afs_cb_opcode, { "Operation", "afs.cb.opcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(cb_req), 0, "Operation" }},
|
||||
{ &hf_afs_prot_opcode, { "Operation", "afs.prot.opcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(prot_req), 0, "Operation" }},
|
||||
{ &hf_afs_vldb_opcode, { "Operation", "afs.vldb.opcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(vldb_req), 0, "Operation" }},
|
||||
{ &hf_afs_kauth_opcode, { "Operation", "afs.kauth.opcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(kauth_req), 0, "Operation" }},
|
||||
{ &hf_afs_vol_opcode, { "Operation", "afs.vol.opcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(vol_req), 0, "Operation" }},
|
||||
{ &hf_afs_bos_opcode, { "Operation", "afs.bos.opcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(bos_req), 0, "Operation" }},
|
||||
{ &hf_afs_update_opcode, { "Operation", "afs.update.opcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(update_req), 0, "Operation" }},
|
||||
{ &hf_afs_rmtsys_opcode, { "Operation", "afs.rmtsys.opcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(rmtsys_req), 0, "Operation" }},
|
||||
{ &hf_afs_error_opcode, { "Operation", "afs.error.opcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Operation" }},
|
||||
{ &hf_afs_backup_opcode, {
|
||||
"Operation", "afs.backup.opcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(backup_req), 0, "Operation" }},
|
||||
{ &hf_afs_ubik_opcode, {
|
||||
"Operation", "afs.ubik.opcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(ubik_req), 0, "Operation" }},
|
||||
|
||||
|
||||
/* File Server Fields */
|
||||
{ &hf_afs_fs_fid_volume, { "FileID (Volume)", "afs.fs.fid.volume",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "File ID (Volume)" }},
|
||||
{ &hf_afs_fs_fid_vnode, { "FileID (VNode)", "afs.fs.fid.vnode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "File ID (VNode)" }},
|
||||
{ &hf_afs_fs_fid_uniqifier, { "FileID (Uniqifier)", "afs.fs.fid.uniq",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "File ID (Uniqifier)" }},
|
||||
{ &hf_afs_fs_offset, { "Offset", "afs.fs.offset",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Offset" }},
|
||||
{ &hf_afs_fs_length, { "Length", "afs.fs.length",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Length" }},
|
||||
{ &hf_afs_fs_flength, { "FLength", "afs.fs.flength",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "FLength" }},
|
||||
{ &hf_afs_fs_errcode, { "Error Code", "afs.fs.errcode",
|
||||
FT_UINT32, BASE_DEC, VALS(afs_errors), 0, "Error Code" }},
|
||||
{ &hf_afs_fs_data, { "Data", "afs.fs.data",
|
||||
FT_BYTES, BASE_HEX, 0, 0, "Data" }},
|
||||
{ &hf_afs_fs_oldname, { "Old Name", "afs.fs.oldname",
|
||||
FT_STRING, BASE_HEX, 0, 0, "Old Name" }},
|
||||
{ &hf_afs_fs_newname, { "New Name", "afs.fs.newname",
|
||||
FT_STRING, BASE_HEX, 0, 0, "New Name" }},
|
||||
{ &hf_afs_fs_name, { "Name", "afs.fs.name",
|
||||
FT_STRING, BASE_HEX, 0, 0, "Name" }},
|
||||
{ &hf_afs_fs_symlink_name, { "Symlink Name", "afs.fs.symlink.name",
|
||||
FT_STRING, BASE_HEX, 0, 0, "Symlink Name" }},
|
||||
{ &hf_afs_fs_symlink_content, { "Symlink Content", "afs.fs.symlink.content",
|
||||
FT_STRING, BASE_HEX, 0, 0, "Symlink Content" }},
|
||||
{ &hf_afs_fs_volid, { "Volume ID", "afs.fs.volid",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Volume ID" }},
|
||||
{ &hf_afs_fs_volname, { "Volume Name", "afs.fs.volname",
|
||||
FT_STRING, BASE_HEX, 0, 0, "Volume Name" }},
|
||||
{ &hf_afs_fs_timestamp, { "Timestamp", "afs.fs.timestamp",
|
||||
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Timestamp" }},
|
||||
|
||||
{ &hf_afs_fs_status_mask, { "Mask", "afs.fs.status.mask",
|
||||
FT_UINT32, BASE_HEX, 0, 0, "Mask" }},
|
||||
{ &hf_afs_fs_status_mask_setmodtime, { "Set Modification Time", "afs.fs.status.mask.setmodtime",
|
||||
FT_UINT32, BASE_BIN, 0, 1, "Set Modification Time" }},
|
||||
{ &hf_afs_fs_status_mask_setowner, { "Set Owner", "afs.fs.status.mask.setowner",
|
||||
FT_UINT32, BASE_BIN, 0, 2, "Set Owner" }},
|
||||
{ &hf_afs_fs_status_mask_setgroup, { "Set Group", "afs.fs.status.mask.setgroup",
|
||||
FT_UINT32, BASE_BIN, 0, 4, "Set Group" }},
|
||||
{ &hf_afs_fs_status_mask_setmode, { "Set Mode", "afs.fs.status.mask.setmode",
|
||||
FT_UINT32, BASE_BIN, 0, 8, "Set Mode" }},
|
||||
{ &hf_afs_fs_status_mask_setsegsize, { "Set Segment Size", "afs.fs.status.mask.setsegsize",
|
||||
FT_UINT32, BASE_BIN, 0, 16, "Set Segment Size" }},
|
||||
{ &hf_afs_fs_status_mask_fsync, { "FSync", "afs.fs.status.mask.fsync",
|
||||
FT_UINT32, BASE_BIN, 0, 1024, "FSync" }},
|
||||
{ &hf_afs_fs_status_clientmodtime, { "Client Modification Time", "afs.fs.status.clientmodtime",
|
||||
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Client Modification Time" }},
|
||||
{ &hf_afs_fs_status_servermodtime, { "Server Modification Time", "afs.fs.status.servermodtime",
|
||||
FT_ABSOLUTE_TIME, BASE_DEC, 0, 0, "Server Modification Time" }},
|
||||
{ &hf_afs_fs_status_owner, { "Owner", "afs.fs.status.owner",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Owner" }},
|
||||
{ &hf_afs_fs_status_group, { "Group", "afs.fs.status.group",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Group" }},
|
||||
{ &hf_afs_fs_status_mode, { "Unix Mode", "afs.fs.status.mode",
|
||||
FT_UINT32, BASE_OCT, 0, 0, "Unix Mode" }},
|
||||
{ &hf_afs_fs_status_segsize, { "Segment Size", "afs.fs.status.segsize",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Segment Size" }},
|
||||
{ &hf_afs_fs_status_interfaceversion, { "Interface Version", "afs.fs.status.interfaceversion",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Interface Version" }},
|
||||
{ &hf_afs_fs_status_filetype, { "File Type", "afs.fs.status.filetype",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "File Type" }},
|
||||
{ &hf_afs_fs_status_author, { "Author", "afs.fs.status.author",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Author" }},
|
||||
{ &hf_afs_fs_status_calleraccess, { "Caller Access", "afs.fs.status.calleraccess",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Caller Access" }},
|
||||
{ &hf_afs_fs_status_anonymousaccess, { "Anonymous Access", "afs.fs.status.anonymousaccess",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Anonymous Access" }},
|
||||
{ &hf_afs_fs_status_parentvnode, { "Parent VNode", "afs.fs.status.parentvnode",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Parent VNode" }},
|
||||
{ &hf_afs_fs_status_parentunique, { "Parent Unique", "afs.fs.status.parentunique",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Parent Unique" }},
|
||||
{ &hf_afs_fs_status_dataversion, { "Data Version", "afs.fs.status.dataversion",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Data Version" }},
|
||||
{ &hf_afs_fs_status_dataversionhigh, { "Data Version (High)", "afs.fs.status.dataversionhigh",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Data Version (High)" }},
|
||||
{ &hf_afs_fs_status_linkcount, { "Link Count", "afs.fs.status.linkcount",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Link Count" }},
|
||||
{ &hf_afs_fs_status_spare2, { "Spare 2", "afs.fs.status.spare2",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Spare 2" }},
|
||||
{ &hf_afs_fs_status_spare3, { "Spare 3", "afs.fs.status.spare3",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Spare 3" }},
|
||||
{ &hf_afs_fs_status_spare4, { "Spare 4", "afs.fs.status.spare4",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Spare 4" }},
|
||||
{ &hf_afs_fs_status_synccounter, { "Sync Counter", "afs.fs.status.synccounter",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Sync Counter" }},
|
||||
{ &hf_afs_fs_status_length, { "Length", "afs.fs.status.length",
|
||||
FT_UINT32, BASE_DEC, 0, 0, "Length" }},
|
||||
|
||||
|
||||
{ &hf_afs_fs_acl_count_positive, {
|
||||
"ACL Count (Positive)", "afs.fs.acl.count.positive",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Number of Positive ACLs" }},
|
||||
{ &hf_afs_fs_acl_count_negative, {
|
||||
"ACL Count (Negative)", "afs.fs.acl.count.negative",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Number of Negative ACLs" }},
|
||||
{ &hf_afs_fs_acl_datasize, {
|
||||
"ACL Size", "afs.fs.acl.datasize",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "ACL Data Size" }},
|
||||
{ &hf_afs_fs_acl_entity, {
|
||||
"Entity (User/Group)", "afs.fs.acl.entity",
|
||||
FT_STRING, BASE_HEX,
|
||||
0, 0, "ACL Entity (User/Group)" }},
|
||||
{ &hf_afs_fs_acl_r, {
|
||||
"_R_ead", "afs.fs.acl.r",
|
||||
FT_UINT8, BASE_BIN,
|
||||
0, PRSFS_READ, "Read" }},
|
||||
{ &hf_afs_fs_acl_l, {
|
||||
"_L_ookup", "afs.fs.acl.l",
|
||||
FT_UINT8, BASE_BIN,
|
||||
0, PRSFS_LOOKUP, "Lookup" }},
|
||||
{ &hf_afs_fs_acl_i, {
|
||||
"_I_nsert", "afs.fs.acl.i",
|
||||
FT_UINT8, BASE_BIN,
|
||||
0, PRSFS_INSERT, "Insert" }},
|
||||
{ &hf_afs_fs_acl_d, {
|
||||
"_D_elete", "afs.fs.acl.d",
|
||||
FT_UINT8, BASE_BIN,
|
||||
0, PRSFS_DELETE, "Delete" }},
|
||||
{ &hf_afs_fs_acl_w, {
|
||||
"_W_rite", "afs.fs.acl.w",
|
||||
FT_UINT8, BASE_BIN,
|
||||
0, PRSFS_WRITE, "Write" }},
|
||||
{ &hf_afs_fs_acl_k, {
|
||||
"_L_ock", "afs.fs.acl.k",
|
||||
FT_UINT8, BASE_BIN,
|
||||
0, PRSFS_LOCK, "Lock" }},
|
||||
{ &hf_afs_fs_acl_a, {
|
||||
"_A_dminister", "afs.fs.acl.a",
|
||||
FT_UINT8, BASE_BIN,
|
||||
0, PRSFS_ADMINISTER, "Administer" }},
|
||||
|
||||
{ &hf_afs_fs_callback_version, { "Version", "afs.fs.callback.version",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Version" }},
|
||||
{ &hf_afs_fs_callback_expires, { "Expires", "afs.fs.callback.expires",
|
||||
FT_ABSOLUTE_TIME, BASE_DEC,
|
||||
0, 0, "Expires" }},
|
||||
{ &hf_afs_fs_callback_type, { "Type", "afs.fs.callback.type",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(cb_types), 0, "Type" }},
|
||||
|
||||
/* BOS Server Fields */
|
||||
{ &hf_afs_bos_errcode, {
|
||||
"Error Code", "afs.bos.errcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(afs_errors), 0, "Error Code" }},
|
||||
{ &hf_afs_bos_type, { "Type", "afs.bos.type",
|
||||
FT_STRING, BASE_HEX,
|
||||
0, 0, "Type" }},
|
||||
{ &hf_afs_bos_content, { "Content", "afs.bos.content",
|
||||
FT_STRING, BASE_HEX,
|
||||
0, 0, "Content" }},
|
||||
{ &hf_afs_bos_instance, { "Instance", "afs.bos.instance",
|
||||
FT_STRING, BASE_HEX,
|
||||
0, 0, "Instance" }},
|
||||
{ &hf_afs_bos_status, { "Status", "afs.bos.status",
|
||||
FT_INT32, BASE_DEC,
|
||||
0, 0, "Status" }},
|
||||
{ &hf_afs_bos_num, { "Number", "afs.bos.number",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Number" }},
|
||||
{ &hf_afs_bos_size, { "Size", "afs.bos.size",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Size" }},
|
||||
{ &hf_afs_bos_flags, { "Flags", "afs.bos.flags",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Flags" }},
|
||||
{ &hf_afs_bos_date, { "Date", "afs.bos.date",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Date" }},
|
||||
|
||||
/* KAUTH Server Fields */
|
||||
{ &hf_afs_kauth_errcode, { "Error Code", "afs.kauth.errcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(afs_errors), 0, "Error Code" }},
|
||||
{ &hf_afs_kauth_princ, { "Principal", "afs.kauth.princ",
|
||||
FT_STRING, BASE_HEX,
|
||||
0, 0, "Principal" }},
|
||||
{ &hf_afs_kauth_realm, { "Realm", "afs.kauth.realm",
|
||||
FT_STRING, BASE_HEX,
|
||||
0, 0, "Realm" }},
|
||||
{ &hf_afs_kauth_domain, { "Domain", "afs.kauth.domain",
|
||||
FT_STRING, BASE_HEX,
|
||||
0, 0, "Domain" }},
|
||||
{ &hf_afs_kauth_name, { "Name", "afs.kauth.name",
|
||||
FT_STRING, BASE_HEX,
|
||||
0, 0, "Name" }},
|
||||
{ &hf_afs_kauth_data, { "Data", "afs.kauth.data",
|
||||
FT_BYTES, BASE_HEX,
|
||||
0, 0, "Data" }},
|
||||
{ &hf_afs_kauth_kvno, { "Key Version Number", "afs.kauth.kvno",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Key Version Number" }},
|
||||
|
||||
/* VOL Server Fields */
|
||||
{ &hf_afs_vol_errcode, { "Error Code", "afs.vol.errcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(afs_errors), 0, "Error Code" }},
|
||||
{ &hf_afs_vol_id, { "Volume ID", "afs.vol.id",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Volume ID" }},
|
||||
{ &hf_afs_vol_count, { "Volume Count", "afs.vol.count",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Volume Count" }},
|
||||
{ &hf_afs_vol_name, { "Volume Name", "afs.vol.name",
|
||||
FT_STRING, BASE_HEX,
|
||||
0, 0, "Volume Name" }},
|
||||
|
||||
/* VLDB Server Fields */
|
||||
{ &hf_afs_vldb_errcode, { "Error Code", "afs.vldb.errcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(afs_errors), 0, "Error Code" }},
|
||||
{ &hf_afs_vldb_type, { "Volume Type", "afs.vldb.type",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(volume_types), 0, "Volume Type" }},
|
||||
{ &hf_afs_vldb_id, { "Volume ID", "afs.vldb.id",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Volume ID" }},
|
||||
{ &hf_afs_vldb_bump, { "Bumped Volume ID", "afs.vldb.bump",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Bumped Volume ID" }},
|
||||
{ &hf_afs_vldb_index, { "Volume Index", "afs.vldb.index",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Volume Index" }},
|
||||
{ &hf_afs_vldb_count, { "Volume Count", "afs.vldb.count",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Volume Count" }},
|
||||
{ &hf_afs_vldb_numservers, { "Number of Servers", "afs.vldb.numservers",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Number of Servers" }},
|
||||
{ &hf_afs_vldb_nextindex, { "Next Volume Index", "afs.vldb.nextindex",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Next Volume Index" }},
|
||||
{ &hf_afs_vldb_rovol, { "Read-Only Volume ID", "afs.vldb.rovol",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Read-Only Volume ID" }},
|
||||
{ &hf_afs_vldb_rwvol, { "Read-Write Volume ID", "afs.vldb.rwvol",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Read-Only Volume ID" }},
|
||||
{ &hf_afs_vldb_bkvol, { "Backup Volume ID", "afs.vldb.bkvol",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Read-Only Volume ID" }},
|
||||
{ &hf_afs_vldb_name, { "Volume Name", "afs.vldb.name",
|
||||
FT_STRING, BASE_HEX,
|
||||
0, 0, "Volume Name" }},
|
||||
{ &hf_afs_vldb_partition, { "Partition", "afs.vldb.partition",
|
||||
FT_STRING, BASE_HEX,
|
||||
0, 0, "Partition" }},
|
||||
{ &hf_afs_vldb_server, { "Server", "afs.vldb.server",
|
||||
FT_IPv4, BASE_HEX,
|
||||
0, 0, "Server" }},
|
||||
{ &hf_afs_vldb_serveruuid, { "Server UUID", "afs.vldb.serveruuid",
|
||||
FT_BYTES, BASE_HEX,
|
||||
0, 0, "Server UUID" }},
|
||||
|
||||
/* BACKUP Server Fields */
|
||||
{ &hf_afs_backup_errcode, { "Error Code", "afs.backup.errcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(afs_errors), 0, "Error Code" }},
|
||||
|
||||
/* CB Server Fields */
|
||||
{ &hf_afs_cb_errcode, { "Error Code", "afs.cb.errcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(afs_errors), 0, "Error Code" }},
|
||||
{ &hf_afs_cb_callback_version, { "Version", "afs.cb.callback.version",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Version" }},
|
||||
{ &hf_afs_cb_callback_expires, { "Expires", "afs.cb.callback.expires",
|
||||
FT_ABSOLUTE_TIME, BASE_DEC,
|
||||
0, 0, "Expires" }},
|
||||
{ &hf_afs_cb_callback_type, { "Type", "afs.cb.callback.type",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(cb_types), 0, "Type" }},
|
||||
{ &hf_afs_cb_fid_volume, { "FileID (Volume)", "afs.cb.fid.volume",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "File ID (Volume)" }},
|
||||
{ &hf_afs_cb_fid_vnode, { "FileID (VNode)", "afs.cb.fid.vnode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "File ID (VNode)" }},
|
||||
{ &hf_afs_cb_fid_uniqifier, { "FileID (Uniqifier)", "afs.cb.fid.uniq",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "File ID (Uniqifier)" }},
|
||||
|
||||
/* PROT Server Fields */
|
||||
{ &hf_afs_prot_errcode, { "Error Code", "afs.prot.errcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(afs_errors), 0, "Error Code" }},
|
||||
{ &hf_afs_prot_name, { "Name", "afs.prot.name",
|
||||
FT_STRING, BASE_HEX,
|
||||
0, 0, "Name" }},
|
||||
{ &hf_afs_prot_id, { "ID", "afs.prot.id",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "ID" }},
|
||||
{ &hf_afs_prot_oldid, { "Old ID", "afs.prot.oldid",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Old ID" }},
|
||||
{ &hf_afs_prot_newid, { "New ID", "afs.prot.newid",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "New ID" }},
|
||||
{ &hf_afs_prot_gid, { "Group ID", "afs.prot.gid",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Group ID" }},
|
||||
{ &hf_afs_prot_uid, { "User ID", "afs.prot.uid",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "User ID" }},
|
||||
{ &hf_afs_prot_count, { "Count", "afs.prot.count",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Count" }},
|
||||
{ &hf_afs_prot_maxgid, { "Maximum Group ID", "afs.prot.maxgid",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Maximum Group ID" }},
|
||||
{ &hf_afs_prot_maxuid, { "Maximum User ID", "afs.prot.maxuid",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Maximum User ID" }},
|
||||
{ &hf_afs_prot_pos, { "Position", "afs.prot.pos",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Position" }},
|
||||
{ &hf_afs_prot_flag, { "Flag", "afs.prot.flag",
|
||||
FT_UINT32, BASE_HEX,
|
||||
0, 0, "Flag" }},
|
||||
|
||||
/* UBIK Fields */
|
||||
{ &hf_afs_ubik_errcode, { "Error Code", "afs.ubik.errcode",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(afs_errors), 0, "Error Code" }},
|
||||
{ &hf_afs_ubik_version_epoch, { "Epoch", "afs.ubik.version.epoch",
|
||||
FT_ABSOLUTE_TIME, BASE_DEC,
|
||||
0, 0, "Epoch" }},
|
||||
{ &hf_afs_ubik_votestart, { "Vote Started", "afs.ubik.votestart",
|
||||
FT_ABSOLUTE_TIME, BASE_DEC,
|
||||
0, 0, "Vote Started" }},
|
||||
{ &hf_afs_ubik_voteend, { "Vote Ends", "afs.ubik.voteend",
|
||||
FT_ABSOLUTE_TIME, BASE_DEC,
|
||||
0, 0, "Vote Ends" }},
|
||||
{ &hf_afs_ubik_version_counter, { "Counter", "afs.ubik.version.counter",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Counter" }},
|
||||
{ &hf_afs_ubik_file, { "File", "afs.ubik.file",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "File" }},
|
||||
{ &hf_afs_ubik_pos, { "Position", "afs.ubik.position",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Position" }},
|
||||
{ &hf_afs_ubik_length, { "Length", "afs.ubik.length",
|
||||
FT_UINT32, BASE_DEC,
|
||||
0, 0, "Length" }},
|
||||
{ &hf_afs_ubik_locktype, { "Lock Type", "afs.ubik.locktype",
|
||||
FT_UINT32, BASE_DEC,
|
||||
VALS(ubik_lock_types), 0, "Lock Type" }},
|
||||
{ &hf_afs_ubik_votetype, { "Vote Type", "afs.ubik.votetype",
|
||||
FT_BOOLEAN, BASE_HEX,
|
||||
0, 0, "Vote Type" }},
|
||||
{ &hf_afs_ubik_syncsite, { "Syncsite", "afs.ubik.syncsite",
|
||||
FT_BOOLEAN, BASE_HEX,
|
||||
0, 0, "Syncsite" }},
|
||||
{ &hf_afs_ubik_site, { "Site", "afs.ubik.site",
|
||||
FT_IPv4, BASE_HEX, 0, 0, "Site" }},
|
||||
1598
packet-afs.c
1598
packet-afs.c
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue