path: root/source4/librpc/idl/dcom.idl

#include "idl_types.h"

/**
  DCOM interfaces
  http://www.grimes.demon.co.uk/DCOM/DCOMSpec.htm
 */

#define HRESULT uint32
#define OLESTR unistr

[
	uuid(18f70770-8e64-11cf-9af1-0020af6e72f4),
	version(0.0)
] interface dcom_Unknown
{
	void dcomu_UseProtSeq();
	void dcomu_GetCustomProtseqInfo();
	void dcomu_UpdateResolverBindings();
}

[
	uuid(99fcfe60-5260-101b-bbcb-00aa0021347a),
	pointer_default(unique)
]
interface ObjectRpcBaseTypes
{
	WERROR stub();
	
	// Machine Identifier
#define MID HYPER_T

	 // Object Exporter Identifier
#define OXID HYPER_T
	
	 // Object Identifer
#define OID HYPER_T
	
	// Ping Set Identifier
#define SETID HYPER_T

	// Interface Pointer Identifier
#define IPID GUID
	
	// Causality Identifier
#define CID GUID

	// Class ID
#define CLSID GUID

	// Interface identifier
#define IID GUID

#define LCID uint32

#define DISPID uint32

	//////////////////////////////////////////////////////////////////
	// ORPC Call Packet Format
	//////////////////////////////////////////////////////////////////
	// COM_MINOR_VERSION = 1 (NT4.0, SP1, SP2, DCOM95).
	// - Initial Release
	// - Must be used when talking to downlevel machines, including
	// on Remote Activation calls.
	// COM_MINOR_VERSION = 2 (NT4.0 SP3 and beyond).
	// - Added ResolveOxid2 to IObjectExporter to retrieve the
	// COM version number of the server. Passed to the NDR engine
	// to fix fatal endian-ness flaw in the way OLEAUTOMATION marshals
	// BSTRS. Previous way used trailing padding, which is not NDR
	// compatible. See Bug# 69189.
	// COM_MINOR_VERSION = 3 (NT4.0 SP4 and DCOM95 builds 1018 and beyond)
	// - OLEAUT32 added two new types to the SAFEARRAY, but SAFEARRAY
	// previously included the "default" keyword, which prevented
	// downlevel NDR engines from correctly handling any extensions.
	// Machines with version >=5.3 don't use "default" and will
	// gracefully handle future extensions to SAFEARRAY.
	// old constants (for convenience)
	const uint16 COM_MINOR_VERSION_1 = 1;
	const uint16 COM_MINOR_VERSION_2 = 2;

	// current version
	const uint16 COM_MAJOR_VERSION = 5;
	const uint16 COM_MINOR_VERSION = 3;
	// Component Object Model version number

	typedef [public] struct 
	{
		uint16 MajorVersion; // Major version number
		uint16 MinorVersion; // Minor version number
	} COMVERSION;

	typedef [public] struct 
	{
		uint32 reserved1;
		uint32 reserved2;
	} COSERVERINFO;

	typedef [public] struct
	{
		uint32 FIXME;
	} MULTI_QI;

	// enumeration of additional information present in the call packet.
	// Should be an enum but DCE IDL does not support sparse enumerators.
	typedef enum {
		ORPCF_NULL = 0, // no additional info in packet
		ORPCF_LOCAL = 1, // call is local to this machine
		ORPCF_RESERVED1 = 2, // reserved for local use
		ORPCF_RESERVED2 = 4, // reserved for local use
		ORPCF_RESERVED3 = 8, // reserved for local use
		ORPCF_RESERVED4 = 16 // reserved for local use
	} ORPC_FLAGS;

	// Extension to implicit parameters.
	typedef [public] struct 
	{ 	
		GUID id; // Extension identifier.
		uint32 size; // Extension size.
		//FIXME[size_is((size+7)&~7)] uint8 data[]; // Extension data.
		[size_is(size)] uint8 data[];
	} 	ORPC_EXTENT;


	// Array of extensions.
	typedef struct 
	{
		uint32 size; // Num extents.
		uint32 reserved; // Must be zero.
		//FIXME[size_is((size+1)&~1,), unique] ORPC_EXTENT **extent; // extents
		[size_is(size),unique] ORPC_EXTENT extent[];
	} 	ORPC_EXTENT_ARRAY;


	// implicit 'this' pointer which is the first [in] parameter on
	// every ORPC call.
	typedef [public] struct 
	{
		COMVERSION version; // COM version number
		uint32 flags; // ORPCF flags for presence of other data
		uint32 reserved1; // set to zero
		CID cid; // causality id of caller
		// Extensions.
		[unique] ORPC_EXTENT_ARRAY *extensions;
	} 	ORPCTHIS;


	// implicit 'that' pointer which is the first [out] parameter on
	// every ORPC call.
	typedef [public] struct 
	{
		uint32 flags; // ORPCF flags for presence of other data
		// Extensions.
		[unique] ORPC_EXTENT_ARRAY *extensions;
	} 	ORPCTHAT;


	// DUALSTRINGARRAYS are the return type for arrays of network addresses,
	// arrays of endpoints and arrays of both used in many ORPC interfaces
	typedef struct 
	{
		uint16 wTowerId; // Cannot be zero.
		uint16 aNetworkAddr; // Zero terminated.
	} 	STRINGBINDING;


	const uint16 COM_C_AUTHZ_NONE = 0xffff;
	typedef struct 
	{
		uint16 wAuthnSvc; // Cannot be zero.
		uint16 wAuthzSvc; // Must not be zero.
		uint16 aPrincName; // Zero terminated.
	} 	SECURITYBINDING;


	typedef [public] struct 
	{
		uint16 wNumEntries; // Number of entries in array.
		uint16 wSecurityOffset; // Offset of security info.
		// The array contains two parts, a set of STRINGBINDINGs
		// and a set of SECURITYBINDINGs. Each set is terminated by an
		// extra zero. The shortest array contains four zeros.
		[size_is(wNumEntries)] uint16 aStringArray[];
	} 	DUALSTRINGARRAY;


	// signature value for OBJREF (object reference, actually the
	// marshaled form of a COM interface).
	const uint32 OBJREF_SIGNATURE = 0x574f454d; // 'MEOW'

	// flag values for OBJREF
	typedef enum {
		OBJREF_STANDARD = 0x1, // standard marshaled objref
		OBJREF_HANDLER = 0x2, // handler marshaled objref
		OBJREF_CUSTOM = 0x4 // custom marshaled objref
	} OBJREF_FLAGS;

	// Flag values for a STDOBJREF (standard part of an OBJREF).
	// SORF_OXRES1 - SORF_OXRES8 are reserved for the object exporters
	// use only, object importers must ignore them and must not enforce MBZ.
	typedef enum {
		SORF_NULL   = 0x0000, // convenient for initializing SORF
		SORF_OXRES1 = 0x0001, // reserved for exporter
		SORF_OXRES2 = 0x0020, // reserved for exporter
		SORF_OXRES3 = 0x0040, // reserved for exporter
		SORF_OXRES4 = 0x0080, // reserved for exporter
		SORF_OXRES5 = 0x0100, // reserved for exporter
		SORF_OXRES6 = 0x0200, // reserved for exporter
		SORF_OXRES7 = 0x0400, // reserved for exporter
		SORF_OXRES8 = 0x0800, // reserved for exporter
		SORF_NOPING = 0x1000  // Pinging is not required 
	} STDOBJREF_FLAGS;

	// standard object reference
	typedef [public] struct 
	{
		uint32 flags; // STDOBJREF flags (see above)
		uint32 cPublicRefs; // count of references passed
		OXID oxid; // oxid of server with this oid
		OID oid; // oid of object with this ipid
		IPID ipid; // ipid of Interface
	} 	STDOBJREF;

	typedef struct
	{
		STDOBJREF std; // standard objref
		DUALSTRINGARRAY saResAddr; // resolver address
	} u_standard;

	typedef struct
		{
			STDOBJREF std; // standard objref
			CLSID clsid; // Clsid of handler code
			DUALSTRINGARRAY saResAddr; // resolver address
		} u_handler;

	typedef struct
		{
			CLSID clsid; // Clsid of unmarshaling code
			uint32 cbExtension; // size of extension data
			uint32 size; // size of data that follows
			[size_is(size), ref] uint8 *pData; // extension + class specific data
		} u_custom;



	typedef union 
	{
		[case(OBJREF_STANDARD)] u_standard u_standard;
		[case(OBJREF_HANDLER)] u_handler u_handler;
		[case(OBJREF_CUSTOM)] u_custom u_custom;
	} OBJREF_Types;

	// OBJREF is the format of a marshaled interface pointer.
	typedef struct 
	{
		uint32 flags; // OBJREF flags (see above)
		GUID iid; // interface identifier
		[switch_is(flags), switch_type(uint32)] OBJREF_Types u_objref;
	} OBJREF;

	// wire representation of a marshalled interface pointer
	typedef [public] struct 
	{
		uint32 ulCntData; // size of data
		[size_is(ulCntData)] uint8 abData[]; // data (OBJREF)
	} MInterfacePointer;
}


[
	object,
	uuid(00000000-0000-0000-C000-000000000046),
	helpstring("Base interface for most COM interfaces")
]
interface IUnknown
{
	/*****************/
	/* Function 0x00 */
	/* Returns the interface with the specified IID 
	   if implemented by this object */
	HRESULT QueryInterface([in] IID *riid
						   /*FIXME, [out] void **data*/);

	/*****************/
	/* Function 0x01 */
	uint32 AddRef();

	/*****************/
	/* Function 0x02 */
	uint32 Release();
}


[
	object,
	uuid(00000001-0000-0000-C000-000000000046),
	pointer_default(unique)
] interface IClassFactory : IUnknown
{
	HRESULT CreateInstance();

	HRESULT RemoteCreateInstance();

	HRESULT LockServer();

	HRESULT RemoteLockServer();
}

//////////////////////////////////////////////////////////////////

// The remote version of IUnknown. This interface exists on every
// OXID (whether an OXID represents either a thread or a process is
// implementation specific). It is used by clients to query for new
// interfaces, get additional references (for marshaling), and release
// outstanding references.
// This interface is passed along during OXID resolution.
//
[
	uuid(00000131-0000-0000-C000-000000000046),
	object,
	version(0.0),
	helpstring("Remote version of IUnknown")
]
interface IRemUnknown : IUnknown
{
	typedef struct 
	{
		HRESULT hResult; // result of call
		STDOBJREF std; // data for returned interface
	}
	REMQIRESULT;

	HRESULT RemQueryInterface (
		 [in] IPID *ripid, // interface to QI on
		 [in] uint32 cRefs, // count of AddRefs requested
		 [in] uint16 cIids, // count of IIDs that follow
		 [in, size_is(cIids)]
		 IID* iids//, // IIDs to QI for
		 /*FIXME: [out, size_is(,cIids)]
		 REMQIRESULT** ppQIResults // results returned*/
		);
	typedef struct 
	{
		IPID ipid; // ipid to AddRef/Release
		uint32 cPublicRefs;
		uint32 cPrivateRefs;
	} REMINTERFACEREF;

	HRESULT RemAddRef (
		 [in] uint16 cInterfaceRefs,
		 [in, size_is(cInterfaceRefs)] REMINTERFACEREF InterfaceRefs[],
		 [out, size_is(cInterfaceRefs)] HRESULT* pResults
		);

	HRESULT RemRelease (
		 [in] uint16 cInterfaceRefs,
		 [in, size_is(cInterfaceRefs)] REMINTERFACEREF InterfaceRefs[]
		);
}



// Derived from IRemUnknown, this interface supports Remote Query interface
// for objects that supply additional data beyond the STDOBJREF in their
// marshaled interface packets.
[
	object,
	uuid(00000143-0000-0000-C000-000000000046),
	version(0.0)
]

interface IRemUnknown2 : IRemUnknown
{
	HRESULT RemQueryInterface2 (
		 [in] IPID *ripid,
		 [in] uint16 cIids,
		 [in, size_is(cIids)] IID *iids,
		 [out, size_is(cIids)] HRESULT *phr,
		 [out, size_is(cIids)] MInterfacePointer *ppMIF[*]
		);
}

[ 
	uuid(99fcfec4-5260-101b-bbcb-00aa0021347a),
	helpstring("Object Exporter ID Resolver"),
	pointer_default(unique)
]
interface IOXIDResolver
{
	// Method to get the protocol sequences, string bindings
	// and machine id for an object server given its OXID.

	typedef [public] struct {
		DUALSTRINGARRAY *ppdsaOxidBindings;
	} ppdsaOxidBindingsArray;

	[idempotent] WERROR ResolveOxid (
		 [in] OXID *pOxid,
		 [in] uint16 cRequestedProtseqs,
		 [in, size_is(cRequestedProtseqs)] uint16 arRequestedProtseqs[],
		 [out, ref] ppdsaOxidBindingsArray *ppdsaOxidBindings,
		 [out, ref] IPID *pipidRemUnknown,
		 [out, ref] uint32 *pAuthnHint
			 );

	// Simple ping is used to ping a Set. Client machines use this
	// to inform the object exporter that it is still using the
	// members of the set.
	// Returns S_TRUE if the SetId is known by the object exporter,
	// S_FALSE if not.
	[idempotent] WERROR SimplePing (
		 [in] SETID *pSetId // Must not be zero
		);
	
	// Complex ping is used to create sets of OIDs to ping. The
	// whole set can subsequently be pinged using SimplePing,
	// thus reducing network traffic.
	[idempotent] WERROR ComplexPing (
		 [in, out] SETID *pSetId, // In of 0 on first call for new set.
		 [in] uint16 SequenceNum,
		 [in] uint16 cAddToSet,
		 [in] uint16 cDelFromSet,
		 // add these OIDs to the set
		 [in, unique, size_is(cAddToSet)] OID AddToSet[],
		 //remove these OIDs from the set
		 [in, unique, size_is(cDelFromSet)] OID DelFromSet[],
		 [out] uint16 *pPingBackoffFactor// 2^factor = multipler
			 );
	// In some cases the client maybe unsure that a particular
	// binding will reach the server. (For example, when the oxid
	// bindings have more then one TCP/IP binding) This call
	// can be used to validate the binding
	// from the client.
	[idempotent] WERROR ServerAlive ();

	// Method to get the protocol sequences, string bindings,
	// RemoteUnknown IPID and COM version for an object server
	// given its OXID. Supported by DCOM
	// version 5.2 and above.
	[idempotent] WERROR ResolveOxid2 (
											  [in] OXID *pOxid,
											  [in] uint16 cRequestedProtseqs,
											  [in, size_is(cRequestedProtseqs)]
											  uint16 arRequestedProtseqs[],
											  [out, ref] ppdsaOxidBindingsArray *ppdsaOxidBindings,
											  [out, ref] IPID *pipidRemUnknown,
											  [out, ref] uint32 *pAuthnHint,
											  [out, ref] COMVERSION *pComVersion
											 );

	[idempotent] WERROR ServerAlive2 (
									  [out] COMVERSION version,
									  [out] uint8 unknown1[4],
									  [out] DUALSTRINGARRAY dualstring,
									  [out] uint8 unknown2[5]);

}

[
	uuid(4d9f4ab8-7d1c-11cf-861e-0020af6e7c57),
	version(0.0),
	object,
	pointer_default(unique)
]
interface IRemoteActivation
{
	typedef [public] struct {
		MInterfacePointer *ppInterfaceData;
	} ppInterfaceDataArray;

	typedef [public] struct {
		DUALSTRINGARRAY *dualstringarray;
	} REF_DUALSTRINGARRAY;

	typedef struct {
		/* Looks very much like a protocol tower to me, but it appears 
		   to be aligned differently then it is in epmapper -jelmer
		  */
		uint8 FIXME[12];
	} floor_tmp;

	const uint32 MODE_GET_CLASS_OBJECT = 0xffffffff;
	HRESULT RemoteActivation (
							  [in] GUID Clsid,
							  [in, unique] unistr *pwszObjectName,
							  [in, unique] MInterfacePointer *pObjectStorage,
							  [in] uint32 ClientImpLevel,
							  [in] uint32 Mode,
							  [in] uint32 Interfaces,
							  [in, unique,size_is(Interfaces)] IID *pIIDs,
							  [in] uint16 num_protseqs,
							  [in, size_is(num_protseqs)] floor_tmp protseq[],
							  [out] OXID pOxid,
							  [out] DUALSTRINGARRAY *pdsaOxidBindings,
							  [out] IPID ipidRemUnknown,
							  [out] uint32 pAuthnHint,
							  [out] COMVERSION pServerVersion,
							  [out] HRESULT *phr,
							  [out,size_is(Interfaces)] ppInterfaceDataArray *ppInterfaceData,
							  [out,size_is(Interfaces)] HRESULT *pResults
								  );
}


/* The Win2k equivalent of IRemoteActivation */
[
	object,
	uuid(000001a0-0000-0000-c000-000000000046),
	version(0.0)
]
interface ISystemActivator : IUnknown
{
	void ISystemActivatorRemoteGetClassObject();
	void ISystemActivatorRemoteCreateInstance();
}

[
	uuid(00000132-0000-0000-C000-000000000046),
	version(0.0)
] interface ILocalSystemActivator
{
	WERROR ILocalSystemActivator_Unknown();
}

[
	uuid(00000134-0000-0000-C000-000000000046),
	version(0.0)
] interface IRunDown
{
	void IRunDown_Dummy();
}


// Service Control Manager

[
	uuid(),
	version(2.0)
] interface SCM
{
	void SCM_Dummy();
}

[
	object,
	uuid(00000136-0000-0000-C000-000000000046)
] interface ISCMActivator : IUnknown
{
	WERROR SCMActivator_GetClassObject();
	WERROR SCMActivator_CreateInstance();
}

[
	object,
	uuid(00020400-0000-0000-C000-000000000046),
	version(0.0)
] interface IDispatch : IUnknown
{
	/*****************/
	/* Function 0x03 */
	HRESULT GetTypeInfoCount(
						 [out] uint16 *pctinfo);

	typedef struct {
		uint8 FIXME;
	} ITypeInfo;

	typedef struct {
		ITypeInfo *pTInfo;
	} REF_ITypeInfo;

	/*****************/
	/* Function 0x04 */
	HRESULT GetTypeInfo (
					 [in] uint16 iTInfo,
					 [in] LCID lcid,
					 [out] REF_ITypeInfo *ppTInfo);

	/*****************/
	/* Function 0x05 */
	HRESULT GetIDsOfNames(
					  [in] IID *riid,
					  /*FIXME[in,size_is(cNames)] OLESTR *rgszNames[], */
					  [in] uint16 cNames,
					  [in] LCID lcid,
					  [out,size_is(cNames)] DISPID *rgDispId);

	typedef struct {
		uint16 vartype;
		uint16 FIXME;
	} VARIANT;
	
	typedef struct {
		uint16 FIXME;
	} DISPPARAMS;

	/* Exception ? */
	typedef struct {
		uint16 FIXME;
	} EXCEPINFO;
	
	/*****************/
	/* Function 0x06 */
	HRESULT Invoke(
			   [in] DISPID dispIdMember,
			   [in] IID *riid,
			   [in] LCID lcid,
			   [in] uint16 wFlags,
			   [out,in] DISPPARAMS *pDispParams,
			   [out] VARIANT *pVarResult,
			   [out] EXCEPINFO *pExcepInfo,
			   [out] uint16 *puArgErr);
}

[
	object,
	uuid(330E9E75-DF48-11CF-8E2C-00A0C90DC94B),
	pointer_default(unique)
]
interface IDcomEchoServ : IDispatch
{
	HRESULT EchoPlusOne([in] uint32 x, [out] uint32 *y);
}