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

#include "idl_types.h"

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

#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
	
	/* Interface Pointer Identifier */
#define IPID GUID
	
	/* Causality Identifier */
#define CID 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) */

	/* current version */
	const uint16 COM_MAJOR_VERSION = 5;
	const uint16 COM_MINOR_VERSION = 6;

	/* Body Extensions */
	const string dcom_ext_debugging = "f1f19680-4d2a-11ce-a66a-0020af6e72f4";
	const string dcom_ext_extended_error = "f1f19681-4d2a-11ce-a66a-0020af6e72f4";

	/* 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_NULL = 0x0, /* NULL pointer */
		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 */
		GUID clsid; /* Clsid of handler code */
		DUALSTRINGARRAY saResAddr; /* resolver address */
	} u_handler;

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

	typedef struct
	{
	} u_null;

	typedef [nodiscriminant] union 
	{
		[case(OBJREF_NULL)] u_null u_null;
		[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 [public] struct 
	{
		uint32 signature;
		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 size;
		uint32 sizex;
		[subcontext(4),align(1)] OBJREF obj;
	} MInterfacePointer;
}


[
	object,
	uuid("00000000-0000-0000-C000-000000000046"),
	helpstring("Base interface for all COM interfaces")
]
interface IUnknown
{
	/*****************/
	/* Function 0x00 */
	/* Returns the interface with the specified IID 
	   if implemented by this object */
	[local] WERROR IUnknown_QueryInterface([in] IID *riid,
	   [out,iid_is(riid)] MInterfacePointer *data);

	/*****************/
	/* Function 0x01 */
	[local] uint32 IUnknown_AddRef();

	/*****************/
	/* Function 0x02 */
	[local] uint32 IUnknown_Release();
}


[
	object,
	uuid("00000001-0000-0000-C000-000000000046"),
	pointer_default(unique)
] interface IClassFactory : IUnknown
{
	[local] WERROR CreateInstance(/*FIXME[in] IUnknown *pUnknown*/, 
			       [in] IID *riid,
			       [out, iid_is(riid)] MInterfacePointer *ppv);

	[call_as(CreateInstance)] WERROR RemoteCreateInstance();

	/* Set lock to TRUE when you want to do a lock
	and set it to FALSE when you want to unlock */
	[local] WERROR LockServer([in] uint8 lock);

	[call_as(LockServer)] WERROR 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,
	helpstring("Remote version of IUnknown")
]
interface IRemUnknown : IUnknown
{
	typedef [public] struct 
	{
		WERROR hResult; /* result of call */
		STDOBJREF std; /* data for returned interface */
	}
	REMQIRESULT;

	[call_as(QueryInterface)] WERROR 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 */
		[out, size_is(cIids)] MInterfacePointer *ip
		);

	typedef struct 
	{
		IPID ipid; /* ipid to AddRef/Release */
		uint32 cPublicRefs;
		uint32 cPrivateRefs;
	} REMINTERFACEREF;

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

	[call_as(Release)] WERROR RemRelease (
		 [in] uint16 cInterfaceRefs,
		 [in, size_is(cInterfaceRefs)] REMINTERFACEREF InterfaceRefs[]
		);
}

[
	uuid("00000140-0000-0000-c000-000000000046"),
	object
] interface IClassActivator : IUnknown
{
	void RemoteGetClassObject([in] GUID clsid, 
											  [in] uint32 context,
											  [in] LCID locale,
											  [in] GUID iid,
											  [out, iid_is(iid)] MInterfacePointer data);
}

/* Looks like this is the equivalent of .NET's 
   System.Activator class */
[
	uuid("000001a0-0000-0000-c000-000000000046"),
	object
]
	interface ISystemActivator : IClassActivator
{
	WERROR ISystemActivatorRemoteCreateInstance([in] HYPER_T unknown1,  /* IPID ? */
											  [in] MInterfacePointer iface,
											  [in] HYPER_T unknown2,
											  [out] uint32 unknown3, 
											  [out] MInterfacePointer iface);
}



/* 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")
]

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

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

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

	typedef struct {
		uint8 FIXME;
	} ITypeInfo;

	typedef struct {
		ITypeInfo *pTInfo;
	} REF_ITypeInfo;

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

	/*****************/
	/* Function 0x05 */
	WERROR 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 */
	WERROR 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("00000003-0000-0000-C000-000000000046")
] interface IMarshal : IUnknown
{
	WERROR MarshalInterface();
	WERROR UnMarshalInterface();
}


[
uuid(DB7C21F8-FE33-4C11-AEA5-CEB56F076FBB),
	helpstring("CoffeeMachine Class")
] coclass CoffeeMachine
{
	[
	uuid(DA23F6DB-6F45-466C-9EED-0B65286F2D78),
	helpstring("ICoffeeMachine Interface"),
	pointer_default(unique)
	]

	interface ICoffeeMachine : IUnknown
	{
		[helpstring("method MakeCoffee")] HRESULT MakeCoffee(BSTR *flavor);
	}
}

[
	object,
	uuid("0000000C-0000-0000-C000-000000000046"),
	helpstring("Stream")
]
interface IStream : IUnknown
{
	WERROR IStream_Read([in] uint32 num_requested, 
				[out,size_is(*num_read)] uint8 *data, 
				[out] uint32 *num_read);

	WERROR IStream_Write([in,size_is(num_requested)] uint8 *data,
				 [in] uint32 num_requested,
				 [out] uint32 *num_written);
}