/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2016 by Delphix. All rights reserved.
 */

#ifndef	_REPCACHE_PROTOCOL_H
#define	_REPCACHE_PROTOCOL_H

/*
 * The Repository Cache Protocol
 * -----------------------------
 *
 * 1. Introduction
 * ---------------
 * This header file defines the private protocols between libscf(3lib) and
 * svc.configd(8).  There are two separate protocols:
 *
 * 1.	The 'global' protocol, accessible via an fattach(3C)ed door located
 *	at REPOSITORY_DOOR_NAME.
 *
 * 2.	The 'client' protocol, accessible through a door created using the
 *	global protocol, which allows access to the repository.
 *
 * 1.1 Design restrictions
 * -----------------------
 * A basic constraint of the door IPC mechanism is that there is no reliable
 * delivery.  In particular:
 *
 * 1.	If libscf(3lib) recieves an EINTR from door_call(), it doesn't know
 *      whether or not the server recieved (and is processing) its request.
 *
 * 2.	When svc.configd(8) calls door_return(), the client may have already
 *	received an EINTR, aborting its door_call().  In this case, the
 *	returned values are dropped on the floor.
 *
 * The practical upshot of all of this is simple:
 *
 *	Every individual protocol action must be idempotent.
 *
 * That is, a client must be able to retry any single request multiple times,
 * and get the correct results.
 *
 * 1.2. Protocol shorthand
 * -----------------------
 * We represent by "REQUEST(arg1, arg2) -> result, res1, [desc]" a request code
 * of REP_PROTOCOL_REQUEST (or REPOSITORY_DOOR_REQUEST), which takes two
 * additional arguments, arg1 and arg2, and returns a result code, res1, and
 * a file descriptor desc.
 *
 * If an error occurs, the server will usually only send the result code. (a
 * short return)
 *
 * Inside the protocol destription, <foo> indicates the type foo indicates.
 *
 * 2. The Global protocol
 * ----------------------
 * Everything starting with "REPOSITORY_DOOR" or "repository_door" belongs
 * to the global protocol.
 *
 * 2.1. Global requests
 * --------------------
 *
 * REQUEST_CONNECT(rdr_flags, ...) -> result, [new_door]
 *	Request a new Client door.  rdr_flags determines attributes of the
 *	connection:
 *
 *	    FLAG_DEBUG
 *		Sets connection debugging flags to those in rdr_debug.
 *
 *	The new door is returned with DOOR_RELEASE set, so if the client does
 *	not recieve the response, the new door will recieve an unref
 *	notification.  This makes this request idempotent.
 *
 * 2.2. Global reponse codes
 * -------------------------
 * GLXXX: This needs to be thought through.
 *
 * SUCCESS
 * FAIL_BAD_REQUEST
 * FAIL_VERSION_MISMATCH
 * FAIL_BAD_FLAG
 * FAIL_BAD_USER
 * FAIL_NO_RESOURCES
 *
 * 3. The Client protocol
 * ----------------------
 * Everything starting with "REP_PROTOCOL" or "rep_protocol" belongs to the
 * client protocol.
 *
 * 3.1. Techniques used
 * --------------------
 * 3.1.1. Client-controlled identifiers
 *
 * An idiom the protocol uses to lower the number of round trips is
 * client-controlled identifiers.  The basic idea is this:  whenever a
 * client wants to set up and use a piece of server state, it picks an
 * integer *which it knows is not in use* to identify it.  The server then
 * maintains per-client, per-resource id->resource maps.  This has a number
 * of advantages:
 *
 * 1.	Since the client allocates the identifiers, we don't need to do
 *	a round-trip just to allocate a number.
 *
 * 2.	Since it is the client's job to make sure identifiers don't collide,
 *	idempotency for setup (destroy) are simple:  If the identifier
 *	already exists (does not exist), we just return success.
 *
 * 3.	Since the identifiers are per-client, the design automatically
 *	precludes clients being able to manipulate other client's state.
 *
 * 3.1.2 Sequence numbers
 *
 * A standard way of gaining idempotency is introducing sequence numbers.
 * These are simply integers which get incremented at points in the protocol,
 * and make sure the client and server are in sync.
 *
 * In this protocol, we use sequence numbers for requests (like ITER_READ)
 * which are repeated, returning different data each time.  Since requests
 * can also be repeated due to unreliable dispatch, the client increments
 * the sequence number after every successful request.  This allows the server
 * to differentiate the two cases. (note that this means that failing
 * requests have no side effects and are repeatable)
 *
 * 3.2. Client abstractions
 * ------------------------
 * 3.2.1 Entities
 *
 * An "entity" is a typed register which the client can manipulate.
 * Entities are named in the protocol by client-controlled identifiers.
 * They have a fixed type for their entire lifetime, and may be in one
 * of two states:
 *
 * valid
 *	The entity has a valid value, and may be read from.  This state
 *	is reached by a successful write to the entity by some protocol
 *	step.
 *
 * invalid
 *	The entity does not contain a valid value.  There are a number
 *	of ways to reach this state:
 *
 *	1.  The entity was just created.
 *	2.  The underlying object that this entity refers to was destroyed.
 *	3.  A protocol request which would have modified this entity
 *	    failed.
 *
 * An entity is an element in the tree of repository data.  Every entity
 * (except for the most distant SCOPE) has exactly one parent.  Entities
 * can have multiple children of different types, restricted by its base
 * type.
 *
 * The ENTITY_GET call is used to get the root of the tree (the most local
 * scope)
 *
 * 3.2.2. The entity tree
 * ----------------------
 * The structure of a scope is as follows:
 *
 *	 _______
 *	| SCOPE |
 *	|_______|
 *	    \ .
 *	     \ .
 *	      \_________
 *	      | SERVICE |
 *	      |_________|
 *		/.    \ .
 *	       /.      \ .
 *	  ____/		\__________
 *	 | PG |		| INSTANCE |
 *	 |____|		|__________|
 *			  /.	 \ .
 *			 /.	  \ .
 *		    ____/	   \__________
 *		   | PG |	   | SNAPSHOT |
 *		   |____|	   |__________|
 *					\ .
 *					 \ .
 *					  \___________
 *					  | SNAPLEVEL |
 *					  |___________|
 *					     /.
 *					    /.
 *				       ____/
 *				      | PG |
 *				      |____|
 *
 * Where the dots indicate an arbitrary number (including 0) of children.
 *
 * For a given scope, the next scope (in the sense of distance) is its
 * TYPE_SCOPE parent.  The furthest out scope has no parent.
 *
 * 3.2.2 Iterators
 *
 * GLXXX
 *
 * 3.3. Client requests
 * --------------------
 *
 * CLOSE() -> result
 *	Closes the connection, revoking the door.  After this call completes,
 *	no further calls will succeed.
 *
 * ENTITY_SETUP(entity_id, type) -> result
 *	Sets up an entity, identified by entity_id, to identify a single
 *	<type>.  <type> may not be TYPE_NONE.
 *
 * ENTITY_NAME(entity_id, name_type) -> result, name
 *	Returns the name of entity_id.  name_type determines which type of
 *	name to get.
 *
 * ENTITY_PARENT_TYPE(entity_id) -> result, parent_type
 *	Retrieves the type of entity_id's parent
 *
 * ENTITY_GET_CHILD(entity_id, child_id, name) -> result
 *	Puts entity_id's child (of child_id's type) named 'name' into child_id.
 *
 * ENTITY_GET_PARENT(entity_id, out_id) -> result
 *	Puts entity_id's parent into out_id.
 *
 * ENTITY_GET(entity_id, number) -> result
 *	Makes entity_id point to a particular object.  If any error
 *	occurs, dest_id will be invalid.
 *
 * ENTITY_UPDATE(entity_id, changeid) -> result
 *	Updates the entity to pick up any new changes.
 *
 * ENTITY_CREATE_CHILD(entity_id, type, name, child_id, changeid) -> result
 *	Attaches the object of type /type/ in child_id as the child of
 *	entity_id named 'name'.
 *
 * ENTITY_CREATE_PG(entity_id, name, type, flags, child_id, changeid) -> result
 *	Creates a property group child of entity_id named 'name', type 'type'
 *	and flags 'flags', and puts the resulting object in child_id.
 *
 * ENTITY_DELETE(entity_id, changeid) -> result
 *	Deletes the entity represented by entity_id.
 *
 * ENTITY_RESET(entity_id) -> result
 *	Resets the entity.
 *
 * ENTITY_TEARDOWN(entity_id) -> result
 *	Destroys the entity entity_id.
 *
 * ITER_SETUP(iter_id) -> result
 *	Sets up an iterator id.
 *
 * ITER_START(iter_id, entity_id, itertype, flags, pattern) -> result
 *	Sets up an iterator, identified by iter_id, which will iterate the
 *	<itertype> children of entity_id whose names match 'pattern',
 *	with the matching controlled by flags.  Initializing an iterator
 *	counts as the first sequence number (1).
 *
 * ITER_READ(iter_id, sequence, entity_id) -> result
 *	Retrieves the next element of iterator iter_id.  Sequence starts at 2,
 *	and is incremented by the client after each successful iteration.
 *	The result is written to entity_id, which must be of the same type
 *	as the iterator result.  The iterator must not be iterating values.
 *
 * ITER_READ_VALUE(iter_id, sequence) -> result, type, value
 *	Retrieves the next value for iterator iter_id.  Sequence starts at 2,
 *	and is incremented by the client after each successful iteration.
 *	The iterator must be iterating a property's values.
 *
 * ITER_RESET(iter_id) -> result
 *	Throws away any accumulated state.
 *
 * ITER_TEARDOWN(iter_id) -> result
 *	Destroys the iterator iter_id.
 *
 * NEXT_SNAPLEVEL(entity_src, entity_dst) -> result
 *	If entity_src is a snapshot, set entity_dst to the first snaplevel
 *	in it.  If entity_src is a snaplevel, set entity_dst to the next
 *	snaplevel, or fail if there isn't one.
 *
 * SNAPSHOT_TAKE(entity_id, name, dest_id, flags) -> result
 *	Takes a snapshot of entity_id, creating snaplevels for the instance and
 *	its parent service.  If flags is REP_SNAPSHOT_NEW, a new snapshot named
 *	'name' is created as a child of entity_id, dest_id is pointed to it,
 *	and the new snaplevels are attached to it.  If flags is
 *	REP_SNAPSHOT_ATTACH, name must be empty, and the new snaplevels are
 *	attached to the snapshot dest_id points to.
 *
 * SNAPSHOT_TAKE_NAMED(entity_id, instname, svcname, name, dest_id) -> result
 *	Like SNAPSHOT_TAKE, but always acts as if REP_SNAPSHOT_NEW is
 *	specified, and instname and svcname override the actual service and
 *	instance names, respectively, written into the snaplevels.
 *
 *	Note that this is only useful for writing snapshots which will later
 *	be transferred to another instance (svc:/svcname:instname/)
 *
 * SNAPSHOT_ATTACH(source_id, dest_id) -> result
 *	The snaplevels attached to the snapshot referenced by source_id are
 *	attached to the snapshot dest_id is pointed at.
 *
 * PROPERTY_GET_TYPE(entity_id) -> result, value type
 *	Finds the value type of entity_id, which must be a property.
 *
 * PROPERTY_GET_VALUE(entity_id) -> result, type, value
 *	If the property contains a single value, returns it and its type.
 *
 * PROPERTYGRP_SETUP_WAIT(entity_id) -> result, [pipe fd]
 *	Sets up a notification for changes to the object entity_id currently
 *	references.  On success, returns one side of a pipe -- when there
 *	has been a change (or the daemon dies), the other end of the pipe will
 *	be closed.
 *
 *	Only one of these can be set up per client -- attempts to set up more
 *	than one will cause the previous one to get closed.
 *
 * PROPERTYGRP_TX_START(entity_id_tx, entity_id) -> result
 *	Makes entity_id_tx point to the same property group as entity_id,
 *	then attempts to set up entity_id_tx as a transaction on that group.
 *	entity_id and entity_id_tx must be distinct.  On failure, entity_id_tx
 *	is reset.
 *
 * PROPERTYGRP_TX_COMMIT(entity_id, data) -> result
 *	Gives the actual steps to follow, and attempts to commit them.
 *
 * CLIENT_ADD_NOTIFY(type, pattern) -> result
 *	Adds a new property group name or type pattern to the notify list
 *	(see CLIENT_WAIT).  If successful, takes effect immediately.
 *
 * CLIENT_WAIT(entity_id) -> result, fmri
 *	Waits for a change to a propertygroup that matches the patterns
 *	set up using CLIENT_ADD_NOTIFY, and puts the resultant propertygroup
 *	in entity_id.  Note that if an error occurs, you can loose
 *	notifications.  Either entity_id is set to a changed propertygroup,
 *	or fmri is a non-zero-length string identifying a deleted thing.
 *
 * BACKUP(name) -> result
 *	Backs up the persistant repository with a particular name.
 *
 * SET_ANNOTATION(operation, file)
 *	Set up a security audit annotation event.  operation is the name of
 *	the operation that is being annotated, and file is the file being
 *	processed.  This will be used to mark operations which comprise
 *	multiple primitive operations such as svccfg import.
 *
 * SWITCH(flag) -> result
 *	The flag is used to indicate the direction of the switch operation.
 *	When the flag is set to 'fast', move the main repository from the
 *	default location (/etc/svc) to the tmpfs locationa (/etc/svc/volatile).
 *	When it is set to 'perm', the switch is reversed.
 */

#include <door.h>
#include <stddef.h>
#include <sys/sysmacros.h>

#ifdef	__cplusplus
extern "C" {
#endif

/*
 * svc.configd initial protocol details
 */
#define	REPOSITORY_DOOR_BASEVER	(('R' << 24) | ('e' << 16) | ('p' << 8))
#define	REPOSITORY_DOOR_NAME	"/etc/svc/volatile/repository_door"
#define	REPOSITORY_DOOR_COOKIE	((void *)REPOSITORY_DOOR_BASEVER)

#define	REPOSITORY_BOOT_BACKUP	((const char *)"boot")

/*
 * This value should be incremented any time the protocol changes.  When in
 * doubt, bump it.
 */
#define	REPOSITORY_DOOR_VERSION			(21 + REPOSITORY_DOOR_BASEVER)

/*
 * flags for rdr_flags
 */
#define	REPOSITORY_DOOR_FLAG_DEBUG		0x00000001	/* rdr_debug */

#define	REPOSITORY_DOOR_FLAG_ALL		0x00000001	/* all flags */

/*
 * Request IDs
 */
enum repository_door_requestid {
	REPOSITORY_DOOR_REQUEST_CONNECT = (('M' << 8) | 1)
};

enum repository_door_statusid {
	REPOSITORY_DOOR_SUCCESS			= 0,
	REPOSITORY_DOOR_FAIL_BAD_REQUEST	= 1,
	REPOSITORY_DOOR_FAIL_VERSION_MISMATCH	= 2,
	REPOSITORY_DOOR_FAIL_BAD_FLAG		= 3,
	REPOSITORY_DOOR_FAIL_NO_RESOURCES	= 4,
	REPOSITORY_DOOR_FAIL_PERMISSION_DENIED	= 5
};

/*
 * You may only add elements to the end of this structure.
 */
typedef struct repository_door_request {
	uint32_t rdr_version;			/* must be first element */
	enum repository_door_requestid rdr_request;
	uint32_t rdr_flags;
	uint32_t rdr_debug;
} repository_door_request_t;

typedef struct repository_door_response {
	enum repository_door_statusid rdr_status;
} repository_door_response_t;

/*
 * Client interface.  Used on doors returned by REQUEST_CONNECT
 */

#define	REP_PROTOCOL_NAME_LEN		120	/* maximum name length */
#define	REP_PROTOCOL_VALUE_LEN		4096	/* maximum value length */

#define	REP_PROTOCOL_FMRI_LEN		(6 * REP_PROTOCOL_NAME_LEN)

#define	REP_PROTOCOL_BASE		('C' << 8)

/*
 * Request codes
 */
enum rep_protocol_requestid {
	REP_PROTOCOL_CLOSE		= REP_PROTOCOL_BASE,

	REP_PROTOCOL_ENTITY_SETUP,
	REP_PROTOCOL_ENTITY_NAME,
	REP_PROTOCOL_ENTITY_PARENT_TYPE,
	REP_PROTOCOL_ENTITY_GET_CHILD,
	REP_PROTOCOL_ENTITY_GET_PARENT,
	REP_PROTOCOL_ENTITY_GET,
	REP_PROTOCOL_ENTITY_UPDATE,
	REP_PROTOCOL_ENTITY_CREATE_CHILD,
	REP_PROTOCOL_ENTITY_CREATE_PG,
	REP_PROTOCOL_ENTITY_DELETE,
	REP_PROTOCOL_ENTITY_RESET,
	REP_PROTOCOL_ENTITY_TEARDOWN,

	REP_PROTOCOL_ITER_SETUP,
	REP_PROTOCOL_ITER_START,
	REP_PROTOCOL_ITER_READ,
	REP_PROTOCOL_ITER_READ_VALUE,
	REP_PROTOCOL_ITER_RESET,
	REP_PROTOCOL_ITER_TEARDOWN,

	REP_PROTOCOL_NEXT_SNAPLEVEL,

	REP_PROTOCOL_SNAPSHOT_TAKE,
	REP_PROTOCOL_SNAPSHOT_TAKE_NAMED,
	REP_PROTOCOL_SNAPSHOT_ATTACH,

	REP_PROTOCOL_PROPERTY_GET_TYPE,
	REP_PROTOCOL_PROPERTY_GET_VALUE,

	REP_PROTOCOL_PROPERTYGRP_SETUP_WAIT,
	REP_PROTOCOL_PROPERTYGRP_TX_START,
	REP_PROTOCOL_PROPERTYGRP_TX_COMMIT,

	REP_PROTOCOL_CLIENT_ADD_NOTIFY,
	REP_PROTOCOL_CLIENT_WAIT,

	REP_PROTOCOL_BACKUP,

	REP_PROTOCOL_SET_AUDIT_ANNOTATION,

	REP_PROTOCOL_SWITCH,

	REP_PROTOCOL_MAX_REQUEST
};

/*
 * Response codes.  These are returned to the client, and the errors are
 * translated into scf_error_t's by libscf (see proto_error()).
 */
typedef int32_t rep_protocol_responseid_t;
enum rep_protocol_responseid {
	REP_PROTOCOL_SUCCESS =			0,
	/* iterators: No more values. */
	REP_PROTOCOL_DONE =			1,

	/* Request from client was malformed. */
	REP_PROTOCOL_FAIL_BAD_REQUEST =		-1,
	/* Prerequisite call has not been made. */
	REP_PROTOCOL_FAIL_MISORDERED =		-2,
	/* Register for ID has not been created. */
	REP_PROTOCOL_FAIL_UNKNOWN_ID =		-3,
	/* Out of memory or other resource. */
	REP_PROTOCOL_FAIL_NO_RESOURCES =	-4,
	/* Type argument is invalid. */
	REP_PROTOCOL_FAIL_INVALID_TYPE =	-5,
	/* Requested object does not exist. */
	REP_PROTOCOL_FAIL_NOT_FOUND =		-6,
	/* Register for given ID does not point to an object. */
	REP_PROTOCOL_FAIL_NOT_SET =		-7,

	/* Requested name is longer than supplied buffer. */
	REP_PROTOCOL_FAIL_TRUNCATED =		-8,
	/* Operation requires different type. */
	REP_PROTOCOL_FAIL_TYPE_MISMATCH =	-9,

	/* Changeable object has been changed since last update. */
	REP_PROTOCOL_FAIL_NOT_LATEST =		-10,
	/* Creation failed because object with given name exists. */
	REP_PROTOCOL_FAIL_EXISTS =		-11,
	/* Transaction is invalid. */
	REP_PROTOCOL_FAIL_BAD_TX =		-12,
	/* Operation is not applicable to indicated object. */
	REP_PROTOCOL_FAIL_NOT_APPLICABLE =	-13,
	/* Two IDs for operation were unexpectedly equal. */
	REP_PROTOCOL_FAIL_DUPLICATE_ID =	-14,

	/* Permission denied. */
	REP_PROTOCOL_FAIL_PERMISSION_DENIED =	-15,
	/* Backend does not exist or otherwise refused access. */
	REP_PROTOCOL_FAIL_BACKEND_ACCESS =	-16,
	/* Backend is read-only. */
	REP_PROTOCOL_FAIL_BACKEND_READONLY =	-17,

	/* Object has been deleted. */
	REP_PROTOCOL_FAIL_DELETED =		-18,

	REP_PROTOCOL_FAIL_UNKNOWN =		-0xfd
};

/*
 * Types
 */
typedef enum rep_protocol_entity {
	REP_PROTOCOL_ENTITY_NONE,
	REP_PROTOCOL_ENTITY_SCOPE,
	REP_PROTOCOL_ENTITY_SERVICE,
	REP_PROTOCOL_ENTITY_INSTANCE,
	REP_PROTOCOL_ENTITY_SNAPSHOT,
	REP_PROTOCOL_ENTITY_SNAPLEVEL,
	REP_PROTOCOL_ENTITY_PROPERTYGRP,
	REP_PROTOCOL_ENTITY_CPROPERTYGRP,	/* "composed" property group */
	REP_PROTOCOL_ENTITY_PROPERTY,
	REP_PROTOCOL_ENTITY_VALUE,

	REP_PROTOCOL_ENTITY_MAX
} rep_protocol_entity_t;

typedef enum rep_protocol_value_type {
	REP_PROTOCOL_TYPE_INVALID	= '\0',
	REP_PROTOCOL_TYPE_BOOLEAN	= 'b',
	REP_PROTOCOL_TYPE_COUNT		= 'c',
	REP_PROTOCOL_TYPE_INTEGER	= 'i',
	REP_PROTOCOL_TYPE_TIME		= 't',
	REP_PROTOCOL_TYPE_STRING	= 's',
	REP_PROTOCOL_TYPE_OPAQUE	= 'o',

	REP_PROTOCOL_SUBTYPE_USTRING	= REP_PROTOCOL_TYPE_STRING|('u' << 8),
	REP_PROTOCOL_SUBTYPE_URI	= REP_PROTOCOL_TYPE_STRING|('U' << 8),
	REP_PROTOCOL_SUBTYPE_FMRI	= REP_PROTOCOL_TYPE_STRING|('f' << 8),

	REP_PROTOCOL_SUBTYPE_HOST	= REP_PROTOCOL_TYPE_STRING|('h' << 8),
	REP_PROTOCOL_SUBTYPE_HOSTNAME	= REP_PROTOCOL_TYPE_STRING|('N' << 8),
	REP_PROTOCOL_SUBTYPE_NETADDR	= REP_PROTOCOL_TYPE_STRING|('n' << 8),
	REP_PROTOCOL_SUBTYPE_NETADDR_V4	= REP_PROTOCOL_TYPE_STRING|('4' << 8),
	REP_PROTOCOL_SUBTYPE_NETADDR_V6	= REP_PROTOCOL_TYPE_STRING|('6' << 8)
} rep_protocol_value_type_t;


#define	REP_PROTOCOL_BASE_TYPE(t)	((t) & 0x00ff)
#define	REP_PROTOCOL_SUBTYPE(t)		(((t) & 0xff00) >> 8)

/*
 * Request structures
 */
typedef struct rep_protocol_request {
	enum rep_protocol_requestid rpr_request;
} rep_protocol_request_t;

struct rep_protocol_iter_request {
	enum rep_protocol_requestid rpr_request;
	uint32_t rpr_iterid;
};

struct rep_protocol_iter_start {
	enum rep_protocol_requestid rpr_request;	/* ITER_START */
	uint32_t rpr_iterid;

	uint32_t rpr_entity;
	uint32_t rpr_itertype;
	uint32_t rpr_flags;
	char	rpr_pattern[REP_PROTOCOL_NAME_LEN];
};
#define	RP_ITER_START_ALL	0x00000001	/* ignore pattern, match all */
#define	RP_ITER_START_EXACT	0x00000002	/* exact match with pattern */
#define	RP_ITER_START_PGTYPE	0x00000003	/* exact match pg type */
#define	RP_ITER_START_FILT_MASK	0x00000003
#define	RP_ITER_START_COMPOSED	0x00000004	/* composed */

struct rep_protocol_iter_read {
	enum rep_protocol_requestid rpr_request;	/* ITER_READ */
	uint32_t rpr_iterid;
	uint32_t rpr_sequence;		/* client increments upon success */
	uint32_t rpr_entityid;		/* entity to write result to */
};

struct rep_protocol_iter_read_value {
	enum rep_protocol_requestid rpr_request;	/* ITER_READ_VALUE */
	uint32_t rpr_iterid;
	uint32_t rpr_sequence;		/* client increments upon success */
};

struct rep_protocol_entity_setup {
	enum rep_protocol_requestid rpr_request;	/* ENTITY_SETUP */
	uint32_t rpr_entityid;
	uint32_t rpr_entitytype;
};

struct rep_protocol_entity_name {
	enum rep_protocol_requestid rpr_request;	/* ENTITY_NAME */
	uint32_t rpr_entityid;
	uint32_t rpr_answertype;
};
#define	RP_ENTITY_NAME_NAME			0
#define	RP_ENTITY_NAME_PGTYPE			1
#define	RP_ENTITY_NAME_PGFLAGS			2
#define	RP_ENTITY_NAME_SNAPLEVEL_SCOPE		3
#define	RP_ENTITY_NAME_SNAPLEVEL_SERVICE	4
#define	RP_ENTITY_NAME_SNAPLEVEL_INSTANCE	5
#define	RP_ENTITY_NAME_PGREADPROT		6

struct rep_protocol_entity_update {
	enum rep_protocol_requestid rpr_request;	/* ENTITY_UPDATE */
	uint32_t rpr_entityid;
	uint32_t rpr_changeid;
};

struct rep_protocol_entity_parent_type {
	enum rep_protocol_requestid rpr_request;	/* ENTITY_PARENT_TYPE */
	uint32_t rpr_entityid;
};

struct rep_protocol_entity_parent {
	enum rep_protocol_requestid rpr_request;	/* ENTITY_GET_PARENT */
	uint32_t rpr_entityid;
	uint32_t rpr_outid;
};

struct rep_protocol_entity_get {
	enum rep_protocol_requestid rpr_request;	/* ENTITY_SET */
	uint32_t rpr_entityid;
	uint32_t rpr_object;
};
#define	RP_ENTITY_GET_INVALIDATE	1
#define	RP_ENTITY_GET_MOST_LOCAL_SCOPE	2

struct rep_protocol_entity_create_child {
	enum rep_protocol_requestid rpr_request; /* ENTITY_CREATE_CHILD */
	uint32_t rpr_entityid;
	uint32_t rpr_childtype;
	uint32_t rpr_childid;
	uint32_t rpr_changeid;
	char	rpr_name[REP_PROTOCOL_NAME_LEN];
};

struct rep_protocol_entity_create_pg {
	enum rep_protocol_requestid rpr_request; /* ENTITY_CREATE_PG */
	uint32_t rpr_entityid;
	uint32_t rpr_childtype;
	uint32_t rpr_childid;
	uint32_t rpr_changeid;
	char	rpr_name[REP_PROTOCOL_NAME_LEN];
	char	rpr_type[REP_PROTOCOL_NAME_LEN];
	uint32_t rpr_flags;
};

struct rep_protocol_entity_get_child {
	enum rep_protocol_requestid rpr_request;	/* ENTITY_GET_CHILD */
	uint32_t rpr_entityid;
	uint32_t rpr_childid;
	char	rpr_name[REP_PROTOCOL_NAME_LEN];
};

struct rep_protocol_entity_delete {
	enum rep_protocol_requestid rpr_request; /* ENTITY_DELETE_CHILD */
	uint32_t rpr_entityid;
	uint32_t rpr_changeid;
};

struct rep_protocol_entity_reset {
	enum rep_protocol_requestid rpr_request;	/* ENTITY_NAME */
	uint32_t rpr_entityid;
};

struct rep_protocol_entity_request {
	enum rep_protocol_requestid rpr_request;	/* ENTITY_NAME */
	uint32_t rpr_entityid;
};

struct rep_protocol_entity_teardown {
	enum rep_protocol_requestid rpr_request;	/* ENTITY_TEARDOWN */
	uint32_t rpr_entityid;
};

struct rep_protocol_entity_pair {
	enum rep_protocol_requestid rpr_request;	/* NEXT_SNAPLEVEL */
	uint32_t rpr_entity_src;
	uint32_t rpr_entity_dst;
};

struct rep_protocol_transaction_start {
	enum rep_protocol_requestid rpr_request;	/* TX_SETUP */
	uint32_t rpr_entityid_tx;		/* property group tx entity */
	uint32_t rpr_entityid;			/* property group entity */
};

struct rep_protocol_transaction_commit {
	enum rep_protocol_requestid rpr_request; /* TX_COMMIT */
	uint32_t rpr_entityid;
	uint32_t rpr_size;			/* size of entire structure */
	uint8_t rpr_cmd[1];
};

#define	REP_PROTOCOL_TRANSACTION_COMMIT_SIZE(sz) \
	    (offsetof(struct rep_protocol_transaction_commit, rpr_cmd[sz]))

#define	REP_PROTOCOL_TRANSACTION_COMMIT_MIN_SIZE \
	    REP_PROTOCOL_TRANSACTION_COMMIT_SIZE(0)

enum rep_protocol_transaction_action {
	REP_PROTOCOL_TX_ENTRY_INVALID,	/* N/A */
	REP_PROTOCOL_TX_ENTRY_NEW,	/* new property */
	REP_PROTOCOL_TX_ENTRY_CLEAR,	/* clear old property */
	REP_PROTOCOL_TX_ENTRY_REPLACE,	/* change type of old property */
	REP_PROTOCOL_TX_ENTRY_DELETE	/* delete property (no values) */
};

struct rep_protocol_transaction_cmd {
	enum	rep_protocol_transaction_action rptc_action;
	uint32_t rptc_type;
	uint32_t rptc_size;		/* size of entire structure */
	uint32_t rptc_name_len;
	uint8_t	rptc_data[1];
};

#define	REP_PROTOCOL_TRANSACTION_CMD_SIZE(sz) \
	    (offsetof(struct rep_protocol_transaction_cmd, rptc_data[sz]))

#define	REP_PROTOCOL_TRANSACTION_CMD_MIN_SIZE \
	    REP_PROTOCOL_TRANSACTION_CMD_SIZE(0)

#define	TX_SIZE(x)	P2ROUNDUP((x), sizeof (uint32_t))

struct rep_protocol_transaction_request {
	enum rep_protocol_requestid rpr_request; /* SETUP, ABORT or TEARDOWN */
	uint32_t rpr_txid;
};

struct rep_protocol_property_request {
	enum rep_protocol_requestid rpr_request;
	uint32_t rpr_entityid;
};

struct rep_protocol_propertygrp_request {
	enum rep_protocol_requestid rpr_request;
	uint32_t rpr_entityid;
};

struct rep_protocol_notify_request {
	enum rep_protocol_requestid rpr_request;
	uint32_t rpr_type;
	char	rpr_pattern[REP_PROTOCOL_NAME_LEN];
};
#define	REP_PROTOCOL_NOTIFY_PGNAME 1
#define	REP_PROTOCOL_NOTIFY_PGTYPE 2

struct rep_protocol_wait_request {
	enum rep_protocol_requestid rpr_request;
	uint32_t rpr_entityid;
};

struct rep_protocol_snapshot_take {
	enum rep_protocol_requestid rpr_request;	/* SNAPSHOT_TAKE */
	uint32_t rpr_entityid_src;
	uint32_t rpr_entityid_dest;
	int	rpr_flags;
	char	rpr_name[REP_PROTOCOL_NAME_LEN];
};
#define	REP_SNAPSHOT_NEW	0x00000001
#define	REP_SNAPSHOT_ATTACH	0x00000002

struct rep_protocol_snapshot_take_named {
	enum rep_protocol_requestid rpr_request; /* SNAPSHOT_TAKE_NAMED */
	uint32_t rpr_entityid_src;
	uint32_t rpr_entityid_dest;
	char	rpr_svcname[REP_PROTOCOL_NAME_LEN];
	char	rpr_instname[REP_PROTOCOL_NAME_LEN];
	char	rpr_name[REP_PROTOCOL_NAME_LEN];
};

struct rep_protocol_snapshot_attach {
	enum rep_protocol_requestid rpr_request;	/* SNAPSHOT_ATTACH */
	uint32_t rpr_entityid_src;
	uint32_t rpr_entityid_dest;
};

struct rep_protocol_backup_request {
	enum rep_protocol_requestid rpr_request;	/* BACKUP */
	uint32_t rpr_changeid;
	char rpr_name[REP_PROTOCOL_NAME_LEN];
};

struct rep_protocol_annotation {
	enum rep_protocol_requestid rpr_request;	/* SET_ANNOTATION */
	char rpr_operation[REP_PROTOCOL_NAME_LEN];
	char rpr_file[MAXPATHLEN];
};

struct rep_protocol_switch_request {
	enum rep_protocol_requestid rpr_request;	/* SWITCH */
	uint32_t rpr_changeid;
	int rpr_flag;
};

/*
 * Response structures
 */
typedef struct rep_protocol_response {
	rep_protocol_responseid_t rpr_response;
} rep_protocol_response_t;

struct rep_protocol_integer_response {
	rep_protocol_responseid_t rpr_response;
	uint32_t rpr_value;
};

struct rep_protocol_name_response {	/* response to ENTITY_NAME */
	rep_protocol_responseid_t rpr_response;
	char rpr_name[REP_PROTOCOL_NAME_LEN];
};

struct rep_protocol_fmri_response {
	rep_protocol_responseid_t rpr_response;
	char rpr_fmri[REP_PROTOCOL_FMRI_LEN];
};

struct rep_protocol_value_response {
	rep_protocol_responseid_t rpr_response;
	rep_protocol_value_type_t rpr_type;
	char			rpr_value[2 * REP_PROTOCOL_VALUE_LEN + 1];
};

#ifdef	__cplusplus
}
#endif

#endif	/* _REPCACHE_PROTOCOL_H */