/* 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 11410 2004-07-18 18:06:47Z gram $
 *
 * Ethereal - Network traffic analyzer
 * By Gerald Combs <gerald@ethereal.com>
 * 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 'offset', and that the offset
 * should be incremented after performing the macro's operation.
 */


/* Output a unsigned integer, stored into field 'field'
   Assumes it is in network byte order, converts to host before using */
#define OUT_UINT(field) \
	proto_tree_add_uint(tree, field, tvb, offset, sizeof(guint32), tvb_get_ntohl(tvb, offset)); \
	offset += 4;

/* Output a unsigned integer, stored into field 'field'
   Assumes it is in network byte order, converts to host before using */
#define OUT_INT(field) \
	proto_tree_add_int(tree, field, tvb, offset, sizeof(gint32), tvb_get_ntohl(tvb, offset)); \
	offset += 4;

/* Output a unsigned integer, stored into field 'field'
   Assumes it is in network byte order, converts to host before using */
#define OUT_UINT64(field) \
	proto_tree_add_item(tree, field, tvb, offset, 8, FALSE); \
	offset += 8;

/* Output a unsigned integer, stored into field 'field'
   Assumes it is in network byte order, converts to host before using */
#define OUT_INT64(field) \
	proto_tree_add_item(tree, field, tvb, offset, 8, FALSE); \
	offset += 8;

/* 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) \
	proto_tree_add_uint(tree,field,tvb,offset,sizeof(guint32),tvb_get_ntohl(tvb, offset));

/* Output an IPv4 address, stored into field 'field' */
#define OUT_IP(field) \
	proto_tree_add_ipv4(tree,field,tvb,offset,sizeof(gint32),\
		tvb_get_letohl(tvb, offset));\
	offset += 4;

/* Output a simple rx array */
#define OUT_RXArray8(func) \
	{ \
		unsigned int j,i; \
		j = tvb_get_guint8(tvb, offset); \
		offset += 1; \
		for (i=0; i<j; i++) { \
			func; \
		} \
	}

/* Output a simple rx array */
#define OUT_RXArray32(func) \
	{ \
		unsigned int j,i; \
		j = tvb_get_ntohl(tvb, offset); \
		offset += sizeof(guint32); \
		for (i=0; i<j; i++) { \
			func; \
		} \
	}

/* Output a UNIX seconds/microseconds timestamp, after converting to an
   nstime_t */
#define OUT_TIMESTAMP(field) \
	{ nstime_t ts; \
	ts.secs = tvb_get_ntohl(tvb, offset); \
	ts.nsecs = tvb_get_ntohl(tvb, offset)*1000; \
	proto_tree_add_time(tree,field, tvb,offset,2*sizeof(guint32),&ts); \
	offset += 8; \
	}

/* Output a seconds-only time value, after converting to an nstime_t;
   this can be an absolute time as a UNIX time-since-epoch, or a
   relative time in seconds */
#define OUT_TIMESECS(field) \
	{ nstime_t ts; \
	ts.secs = tvb_get_ntohl(tvb, offset); \
	ts.nsecs = 0; \
	proto_tree_add_time(tree,field, tvb,offset,sizeof(guint32),&ts); \
	offset += 4; \
	}

/* Output a rx style string, up to a maximum length first
   4 bytes - length, then char data */
#define OUT_RXString(field) \
	{	guint32 i,len; \
		char *tmp; \
		const guint8 *p; \
		i = tvb_get_ntohl(tvb, offset); \
		offset += 4; \
		p = tvb_get_ptr(tvb,offset,i); \
		len = ((i+4-1)/4)*4; \
		tmp = g_malloc(i+1); \
		memcpy(tmp, p, i); \
		tmp[i] = '\0'; \
		proto_tree_add_string(tree, field, tvb, offset-4, len+4, \
		(void *)tmp); \
		g_free(tmp); \
		offset += len; \
	}

/* Output a fixed length vectorized string (each char is a 32 bit int) */
#define OUT_RXStringV(field, length) \
	{ 	char tmp[length+1]; \
		int i,soff; \
		soff = offset;\
		for (i=0; i<length; i++)\
		{\
			tmp[i] = (char) tvb_get_ntohl(tvb, offset);\
			offset += sizeof(guint32);\
		}\
		tmp[length] = '\0';\
		proto_tree_add_string(tree, field, tvb, soff, length*sizeof(guint32), tmp);\
	}


/* Output a callback */
#define OUT_FS_AFSCallBack() \
	{ 	proto_tree *save, *ti; \
		ti = proto_tree_add_text(tree, tvb, offset, 3*4, "Callback"); \
		save = tree; \
		tree = proto_item_add_subtree(ti, ett_afs_callback); \
		OUT_UINT(hf_afs_fs_callback_version); \
		OUT_TIMESECS(hf_afs_fs_callback_expires); \
		OUT_UINT(hf_afs_fs_callback_type); \
		tree = save; \
	}

/* Output a callback */
#define OUT_CB_AFSCallBack() \
	{ 	proto_tree *save, *ti; \
		ti = proto_tree_add_text(tree, tvb, offset, 3*4, "Callback"); \
		save = tree; \
		tree = proto_item_add_subtree(ti, ett_afs_callback); \
		OUT_UINT(hf_afs_cb_callback_version); \
		OUT_TIMESECS(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, tvb, offset, 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; \
		mask = tvb_get_ntohl(tvb, offset); \
		ti = proto_tree_add_uint(tree, hf_afs_fs_status_mask, tvb, offset, \
			sizeof(guint32), mask); \
		save = tree; \
		tree = proto_item_add_subtree(ti, ett_afs_status_mask); \
		proto_tree_add_boolean(tree, hf_afs_fs_status_mask_setmodtime, \
			tvb,offset,sizeof(guint32), mask); \
		proto_tree_add_boolean(tree, hf_afs_fs_status_mask_setowner, \
			tvb,offset,sizeof(guint32), mask); \
		proto_tree_add_boolean(tree, hf_afs_fs_status_mask_setgroup, \
			tvb,offset,sizeof(guint32), mask); \
		proto_tree_add_boolean(tree, hf_afs_fs_status_mask_setmode, \
			tvb,offset,sizeof(guint32), mask); \
		proto_tree_add_boolean(tree, hf_afs_fs_status_mask_setsegsize, \
			tvb,offset,sizeof(guint32), mask); \
		proto_tree_add_boolean(tree, hf_afs_fs_status_mask_fsync, \
			tvb,offset,sizeof(guint32), mask); \
		offset += 4; \
		tree = save; \
	}

/* Output vldb flags */
#define OUT_VLDB_Flags() \
	{ 	proto_tree *save, *ti; \
		guint32 flags; \
		flags = tvb_get_ntohl(tvb, offset); \
		ti = proto_tree_add_uint(tree, hf_afs_vldb_flags, tvb, offset, \
			sizeof(guint32), flags); \
		save = tree; \
		tree = proto_item_add_subtree(ti, ett_afs_vldb_flags); \
		proto_tree_add_boolean(tree, hf_afs_vldb_flags_rwexists, \
			tvb,offset,sizeof(guint32), flags); \
		proto_tree_add_boolean(tree, hf_afs_vldb_flags_roexists, \
			tvb,offset,sizeof(guint32), flags); \
		proto_tree_add_boolean(tree, hf_afs_vldb_flags_bkexists, \
			tvb,offset,sizeof(guint32), flags); \
		proto_tree_add_boolean(tree, hf_afs_vldb_flags_dfsfileset, \
			tvb,offset,sizeof(guint32), flags); \
		offset += 4; \
		tree = save; \
	}



/* Output a File ID */
#define OUT_CB_AFSFid(label) \
	{ 	proto_tree *save, *ti; \
		ti = proto_tree_add_text(tree, tvb, offset, 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, tvb, offset, 6*4, \
			label); \
		save = tree; \
		tree = proto_item_add_subtree(ti, ett_afs_status); \
		OUT_FS_STATUSMASK(); \
		OUT_TIMESECS(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, tvb, offset, 21*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_TIMESECS(hf_afs_fs_status_clientmodtime); \
		OUT_TIMESECS(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() \
	{ 	proto_tree *save, *ti; \
		ti = proto_tree_add_text(tree, tvb, offset, 6*4, \
			"VolSync"); \
		save = tree; \
		tree = proto_item_add_subtree(ti, ett_afs_volsync); \
		OUT_TIMESECS(hf_afs_fs_volsync_spare1); \
		OUT_UINT(hf_afs_fs_volsync_spare2); \
		OUT_UINT(hf_afs_fs_volsync_spare3); \
		OUT_UINT(hf_afs_fs_volsync_spare4); \
		OUT_UINT(hf_afs_fs_volsync_spare5); \
		OUT_UINT(hf_afs_fs_volsync_spare6); \
		tree = save; \
	}

/* Output a AFSCBFids */
#define OUT_FS_AFSCBFids() \
	OUT_RXArray32(OUT_FS_AFSFid("Target"));

/* Output a ViceIds */
#define OUT_FS_ViceIds() \
	OUT_RXArray8(OUT_UINT(hf_afs_fs_viceid));

/* Output a IPAddrs */
#define OUT_FS_IPAddrs() \
	OUT_RXArray8(OUT_IP(hf_afs_fs_ipaddr));

/* Output a AFSCBs */
#define OUT_FS_AFSCBs()	\
	OUT_RXArray32(OUT_FS_AFSCallBack());

/* Output a AFSBulkStats */
#define OUT_FS_AFSBulkStats() \
	OUT_RXArray32(OUT_FS_AFSFetchStatus("Status"));

/* Output a AFSFetchVolumeStatus */
#define OUT_FS_AFSFetchVolumeStatus()

/* Output a AFSStoreVolumeStatus */
#define OUT_FS_AFSStoreVolumeStatus()

/* Output a ViceStatistics structure */
#define OUT_FS_ViceStatistics()

/* Output a AFS_CollData structure */
#define OUT_FS_AFS_CollData()

/* Output a VolumeInfo structure */
#define OUT_FS_VolumeInfo()

/* Output an AFS Token - might just be bytes though */
#define OUT_FS_AFSTOKEN() OUT_RXStringV(hf_afs_fs_token, 1024)

/* 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, tvb, offset, 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, tvb,offset,strlen(who), who);\
		tmpoffset = offset + strlen(who) + 1; \
		acllen = bytes - strlen(who) - 1; \
		proto_tree_add_boolean(tree,hf_afs_fs_acl_r, tvb,tmpoffset,acllen,acl);\
		proto_tree_add_boolean(tree,hf_afs_fs_acl_l, tvb,tmpoffset,acllen,acl);\
		proto_tree_add_boolean(tree,hf_afs_fs_acl_i, tvb,tmpoffset,acllen,acl);\
		proto_tree_add_boolean(tree,hf_afs_fs_acl_d, tvb,tmpoffset,acllen,acl);\
		proto_tree_add_boolean(tree,hf_afs_fs_acl_w, tvb,tmpoffset,acllen,acl);\
		proto_tree_add_boolean(tree,hf_afs_fs_acl_k, tvb,tmpoffset,acllen,acl);\
		proto_tree_add_boolean(tree,hf_afs_fs_acl_a, tvb,tmpoffset,acllen,acl);\
		tree = save; \
	}

/* Output a UUID */
#define OUT_UUID(x) \
	OUT_BYTES(x, 11*sizeof(guint32));
#define SKIP_UUID() \
	SKIP(11*sizeof(guint32));


/* Output a bulkaddr */
#define OUT_VLDB_BulkAddr() \
	OUT_RXArray32(OUT_IP(hf_afs_vldb_serverip));

/* output a bozo_key */
#define OUT_BOS_KEY() \
	OUT_BYTES(hf_afs_bos_key, 8);

/* output a bozo_key */
#define OUT_BOS_KEYINFO() \
	OUT_TIMESTAMP(hf_afs_bos_keymodtime); \
	OUT_UINT(hf_afs_bos_keychecksum); \
	OUT_UINT(hf_afs_bos_keyspare2);

/* output a bozo_netKTime */
#define OUT_BOS_TIME() \
	SKIP(4); SKIP(2); SKIP(2); SKIP(2); SKIP(2);

/* output a bozo_status */
#define OUT_BOS_STATUS() \
	SKIP(10 * 4);

/* output a ubik interface addr array */
#define OUT_UBIK_InterfaceAddrs() \
    { \
        unsigned int i,j,seen_null=0; \
        for (i=0; i<255; i++) { \
		j = tvb_get_ntohl(tvb, offset); \
		if ( j != 0 ) { \
			OUT_IP(hf_afs_ubik_interface); \
			seen_null = 0; \
		} else { \
			if ( ! seen_null ) { \
			proto_tree_add_text(tree, tvb, offset, \
				tvb_length_remaining(tvb, offset), \
				"Null Interface Addresses"); \
				seen_null = 1; \
			} \
			offset += 4; \
		}\
        } \
    }

#define OUT_UBIK_DebugOld() \
	{ \
		OUT_TIMESECS(hf_afs_ubik_now); \
		OUT_TIMESECS(hf_afs_ubik_lastyestime); \
		OUT_IP(hf_afs_ubik_lastyeshost); \
		OUT_UINT(hf_afs_ubik_lastyesstate); \
		OUT_TIMESECS(hf_afs_ubik_lastyesclaim); \
		OUT_IP(hf_afs_ubik_lowesthost); \
		OUT_TIMESECS(hf_afs_ubik_lowesttime); \
		OUT_IP(hf_afs_ubik_synchost); \
		OUT_TIMESECS(hf_afs_ubik_synctime); \
		OUT_UBIKVERSION("Sync Version"); \
		OUT_UBIKVERSION("Sync TID"); \
		OUT_UINT(hf_afs_ubik_amsyncsite); \
		OUT_TIMESECS(hf_afs_ubik_syncsiteuntil); \
		OUT_UINT(hf_afs_ubik_nservers); \
		OUT_UINT(hf_afs_ubik_lockedpages); \
		OUT_UINT(hf_afs_ubik_writelockedpages); \
		OUT_UBIKVERSION("Local Version"); \
		OUT_UINT(hf_afs_ubik_activewrite); \
		OUT_UINT(hf_afs_ubik_tidcounter); \
		OUT_UINT(hf_afs_ubik_anyreadlocks); \
		OUT_UINT(hf_afs_ubik_anywritelocks); \
		OUT_UINT(hf_afs_ubik_recoverystate); \
		OUT_UINT(hf_afs_ubik_currenttrans); \
		OUT_UINT(hf_afs_ubik_writetrans); \
		OUT_TIMESECS(hf_afs_ubik_epochtime); \
	}

#define OUT_UBIK_SDebugOld() \
	{ \
		OUT_IP(hf_afs_ubik_addr); \
		OUT_TIMESECS(hf_afs_ubik_lastvotetime); \
		OUT_TIMESECS(hf_afs_ubik_lastbeaconsent); \
		OUT_UINT(hf_afs_ubik_lastvote); \
		OUT_UBIKVERSION("Remote Version"); \
		OUT_UINT(hf_afs_ubik_currentdb); \
		OUT_UINT(hf_afs_ubik_beaconsincedown); \
		OUT_UINT(hf_afs_ubik_up); \
	}

/* Skip a certain number of bytes */
#define SKIP(bytes) \
	offset += bytes;

/* Raw data - to end of frame */
#define OUT_BYTES_ALL(field) OUT_BYTES(field, tvb_length_remaining(tvb,offset))

/* Raw data */
#define OUT_BYTES(field, bytes) \
	proto_tree_add_item(tree, field, tvb, offset, bytes, FALSE);\
	offset += bytes;



/* 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; \
		nstime_t ts; \
		epoch = tvb_get_ntohl(tvb, offset); \
		offset += 4; \
		counter = tvb_get_ntohl(tvb, offset); \
		offset += 4; \
		ts.secs = epoch; \
		ts.nsecs = 0; \
		ti = proto_tree_add_text(tree, tvb, offset-8, 8, \
			"UBIK Version (%s): %u.%u", label, epoch, counter ); \
		save = tree; \
		tree = proto_item_add_subtree(ti, ett_afs_ubikver); \
		if ( epoch != 0 ) \
		proto_tree_add_time(tree,hf_afs_ubik_version_epoch, tvb,offset-8, \
			sizeof(guint32),&ts); \
		else \
			proto_tree_add_text(tree, tvb, offset-8, \
			sizeof(guint32),"Epoch: 0"); \
		proto_tree_add_uint(tree,hf_afs_ubik_version_counter, tvb,offset-4, \
			sizeof(guint32),counter); \
		tree = save; \
	}

/* Output a kauth getticket request */
#define OUT_KAUTH_GetTicket() \
	{ \
		int len = 0; \
		OUT_UINT(hf_afs_kauth_kvno); \
		OUT_RXString(hf_afs_kauth_domain); \
		len = tvb_get_ntohl(tvb, offset); \
		offset += 4; \
		OUT_BYTES(hf_afs_kauth_data, len); \
		OUT_RXString(hf_afs_kauth_princ); \
		OUT_RXString(hf_afs_kauth_realm); \
	}

