windows-nt/Source/XPSP1/NT/com/ole32/idl/private/activate.idl

452 lines
15 KiB
Plaintext
Raw Normal View History

2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1998.
//
// File:
// activate.idl
//
// Contents:
// Definition of (currently) private COM system activation interfaces.
//
// History:
// VinayKr 01-16-98 Created
// SatishT 01-23-98 Added property interfaces
// SatishT 02-03-98 Separated
// JimLyon 02-18-98 Reworked and joined
//
//--------------------------------------------------------------------------
#ifndef DO_NO_IMPORTS
import "obase.idl";
import "wtypes.idl";
import "objidl.idl";
import "contxt.idl";
#endif
//--------------------------------------------------------------------------
// A custom activator supports:
// ISystemActivator
//
// The activation properties object passed to an activator supports:
// IInitActivationPropertiesIn
// IActivationPropertiesIn
// IServerLocationInfo
// IActivationContextInfo
// IActivationSecurityInfo
// IActivationAgentInfo
// IActivationStageInfo
// IOpaqueDataInfo
//
// The activation properties object returned by an activator supports:
// IActivationPropertiesOut
// IOpaqueDataInfo
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
//
// Memory Management notes:
//
// 1. Whenever any of the methods defined here return interface pointers,
// they return counted references. The caller must eventually call Release ().
//
// 2. Whenever any of the methods defined here have [out] parameters whose
// type is something**, the method will set the caller's pointer to point to
// data owned by the called object. The caller MUST NOT alter or free this data.
// For example, IActivationPropertiesIn::GetActivationID returns a pointer to
// a GUID. The actual GUID is in memory owned by the ActivationPropertiesIn
// object; the caller must not alter the GUID or free the memory it occupies.
//
// 3. Whenever any of these methods accept pointers to data structures from
// their caller, they perform a deap copy of the data. The activation properties
// objects NEVER retain pointers to data structures owned by their callers.
//
//--------------------------------------------------------------------------
// forward references:
interface IActivationPropertiesIn;
interface IActivationPropertiesOut;
[
object,
uuid(000001A0-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface ISystemActivator : IUnknown
{
HRESULT GetClassObject(
[in,unique] IActivationPropertiesIn *pActProperties,
[out] IActivationPropertiesOut **ppActProperties
);
HRESULT CreateInstance(
[in,unique] IUnknown *pUnkOuter,
[in,unique] IActivationPropertiesIn *pActProperties,
[out] IActivationPropertiesOut **ppActProperties
);
}
// These flags are used to indicate special activation requirements.
typedef enum tagACTIVATION_FLAGS {
ACTVFLAGS_NONE = 0,
ACTVFLAGS_WX86_CALLER = 1,
ACTVFLAGS_DISABLE_AAA = 2
} ACTIVATION_FLAGS;
[
object,
local,
uuid(000001A1-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface IInitActivationPropertiesIn : IUnknown
{
// These methods are legal only if IActivationPropertiesIn::Delegate...
// has never been called.
HRESULT SetClsctx ([in] DWORD clsctx);
HRESULT SetActivationFlags([in] DWORD actvflags);
HRESULT SetClassInfo ([in,unique] IUnknown* pUnkClassInfo);
HRESULT SetContextInfo ([in,unique] IContext* pClientContext,
[in] IContext* pPrototypeContext);
HRESULT SetConstructFromStorage ([in,unique] IStorage* pStorage);
HRESULT SetConstructFromFile ([in] WCHAR* wszFileName, [in] DWORD dwMode);
}
[
object,
local,
uuid(000001A2-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface IActivationPropertiesIn : IUnknown
{
HRESULT GetActivationID([out] GUID *pActivationID);
HRESULT GetClassInfo([in] REFIID riid, [out,iid_is(riid)] void** ppv);
HRESULT GetClsctx([out] DWORD *pclsctx);
HRESULT GetActivationFlags([out] DWORD *pactvflags);
HRESULT AddRequestedIIDs([in] DWORD cIfs,
[in, size_is(cIfs)] IID *rgIID);
HRESULT GetRequestedIIDs ([out] ULONG* pulCount, [out] IID** prgIID);
// The following three methods are for activators who delegate onward.
HRESULT DelegateGetClassObject([out] IActivationPropertiesOut **pActPropsOut);
HRESULT DelegateCreateInstance([in] IUnknown *pUnkOuter,
[out] IActivationPropertiesOut **pActPropsOut);
// Following can only be used in Server Context Stage
// and returns ClassFactory used in the Create Instance
HRESULT DelegateCIAndGetCF([in] IUnknown *pUnkOuter,
[out] IActivationPropertiesOut **pActPropsOut,
[out] IClassFactory **ppCf);
// The following method is for activators who do NOT delegate onward.
HRESULT GetReturnActivationProperties([in] IUnknown *pUnk,
[out] IActivationPropertiesOut **ppActOut);
}
[
object,
local,
uuid(000001A3-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface IActivationPropertiesOut : IUnknown
{
HRESULT GetActivationID([out] GUID *pActivationID);
HRESULT GetObjectInterface([in] REFIID riid,
[in] DWORD actvflags,
[out, iid_is(riid)] void **ppv);
HRESULT GetObjectInterfaces([in] DWORD cIfs,
[in] DWORD actvflags,
[in, size_is(cIfs)] MULTI_QI *multiQi);
HRESULT RemoveRequestedIIDs([in] DWORD cIfs,
[in, size_is(cIfs)] IID *rgIID);
}
// Enumeration of activation stage constants
typedef enum tagACTIVATION_STAGE {
CLIENT_CONTEXT_STAGE = 1,
CLIENT_MACHINE_STAGE = 2,
SERVER_MACHINE_STAGE = 3,
SERVER_PROCESS_STAGE = 4,
SERVER_CONTEXT_STAGE = 5
} ACTIVATION_STAGE;
[
object,
uuid (000001A8-0000-0000-C000-000000000046),
pointer_default (unique)
]
interface IActivationStageInfo : IUnknown
{
HRESULT SetStageAndIndex ([in] ACTIVATION_STAGE stage, [in] int index);
HRESULT GetStage ([out] ACTIVATION_STAGE* pstage);
HRESULT GetIndex ([out] int* pindex);
}
//
// Flags for the dwPRT parameter of Set/GetProcess
//
typedef enum _PRT
{
PRT_IGNORE = 0,
PRT_CREATE_NEW = 1,
PRT_USE_THIS = 2,
PRT_USE_THIS_ONLY = 3
} PROCESS_REQUEST_TYPE;
[
object,
local,
uuid(000001A4-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface IServerLocationInfo : IUnknown
{
// SetRemoteServerName is allowed only prior to the server Machine stage.
HRESULT SetRemoteServerName([in, string, unique] WCHAR *pswzMachineName);
HRESULT GetRemoteServerName([out, string] WCHAR **pswzMachineName);
// SetProcess
HRESULT SetProcess([in] DWORD pid, DWORD dwPRT);
HRESULT GetProcess([out] DWORD* ppid, DWORD* pdwPRT);
// SetApartment is allowed only in server process stage.
HRESULT SetApartment([in] APTID apartmentId);
HRESULT GetApartment([out] APTID *pApartmentId);
// SetContext is allowed only in server process and server apartment stages.
HRESULT SetContext([in] IObjContext* pContext);
HRESULT GetContext([out] IObjContext** ppContext);
}
[
object,
local,
uuid(000001A5-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface IActivationContextInfo : IUnknown
{
// None of these methods is allowed in the server context stage.
HRESULT GetClientContext([out] IContext **ppClientContext);
HRESULT GetPrototypeContext([out] IContext **ppContext);
HRESULT IsClientContextOK([out] BOOL *fYes);
HRESULT SetClientContextNotOK();
}
[
object,
local,
uuid(000001BA-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface IOverrideTargetContext : IUnknown
{
HRESULT OverrideTargetContext([in] REFGUID guidTargetCtxtId);
}
[
object,
local,
uuid(000001A6-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface IActivationSecurityInfo : IUnknown
{
// These methods are only allowed prior to the server process stage.
HRESULT SetAuthnFlags([in] DWORD dwAuthnFlags); // e.g., static/dynamic
HRESULT GetAuthnFlags([out] DWORD *pdwAuthnFlags);
HRESULT SetAuthnSvc([in] DWORD dwAuthnSvc);
HRESULT GetAuthnSvc([out] DWORD *pdwAuthnSvc);
HRESULT SetAuthzSvc([in] DWORD dwAuthzSvc);
HRESULT GetAuthzSvc([out] DWORD *pdwAuthzSvc);
HRESULT SetAuthnLevel([in] DWORD dwAuthnLevel);
HRESULT GetAuthnLevel([out] DWORD *pdwAuthnLevel);
HRESULT SetImpLevel([in] DWORD dwImpLevel);
HRESULT GetImpLevel([out] DWORD *pdwImpLevel);
HRESULT SetCapabilities([in] DWORD dwCapabilities);
HRESULT GetCapabilities([out] DWORD *pdwCapabilities);
HRESULT SetAuthIdentity([in, unique] COAUTHIDENTITY *pAuthIdentityData);
HRESULT GetAuthIdentity([out] COAUTHIDENTITY **pAuthIdentityData);
HRESULT SetServerPrincipalName([in, unique] WCHAR* pwszServerPrincName);
HRESULT GetServerPrincipalName([out] WCHAR** pwszServerPrincName);
}
// A SIDLIST is a buffer composed as follows:
// ULONG number of SIDs in the list
// For each SID, the following:
// ULONG number of bytes for the SID
// contents of the SID
// The first SID in a SIDLIST is a user SID; the rest are GROUP SIDs.
//BUGBUG: needs definition
typedef LONG* PSIDLIST; // pointer to a SIDLIST
[
object,
uuid (000001A7-0000-0000-C000-000000000046),
pointer_default (unique)
]
interface IActivationAgentInfo : IUnknown
{
HRESULT AddActivationAgent ([in] PSIDLIST pSidList);
HRESULT GetActivationAgentCount ([out] ULONG* pulCount);
HRESULT GetActivationAgents ([out] PSIDLIST** prgSidList);
}
//
// ServerType -- an enumeration describing the various
// types of servers that can be registered with the scm
//
typedef enum
{
ST_SERVER = 1, // normal server
ST_OLDSURROGATE, // legacy surrogate-style application
ST_COMPLUSAPP, // new COM+ application
ST_SERVICE // server implemented as an NT service
} ServerType;
//
// ServerIDType -- an enumeration to differentiate
// between run-as-a-specific-user server and a run-as-
// interactive-user server. Does not apply to servers
// implemented as NT services.
//
typedef enum
{
SIT_RUNAS_SPECIFIC_USER = 1,
SIT_RUNAS_INTERACTIVE
} ServerIDType;
//
// SCMProcessInfoFlags -- an enumeration containing various
// state bits for the dwState member of the SCMProcessInfo
// struct.
//
typedef enum
{
SPIF_COMPLUS = 1, // process is a com+ server
SPIF_SUSPENDED = 2, // process has been suspended by an activator
SPIF_RETIRED = 4, // process has been retired by an activator
SPIF_READY = 8, // process is started and is ready for activations (if not set
// the process is in a sort-of "started-but-suspended" state)
SPIF_PAUSED = 16 // the process has paused itself (due to user action)
} SCMProcessInfoFlags;
//
// SCMProcessInfo -- describes a server process registered with
// the scm.
//
typedef struct
{
ULONG ulNumClasses;
GUID* pCLSIDs;
DWORD pidProcess;
HANDLE hProcess; // will almost never be NULL, but caller should check anyway
HANDLE hImpersonationToken;
WCHAR* pwszWinstaDesktop;
DWORD dwState; // see SCMProcessInfoFlags
GUID AppId; // valid only if SPIF_COMPLUS bit is set
ServerType ServerType;
ServerIDType ServerID;
FILETIME ftCreated;
} SCMProcessInfo, *PSCMProcessInfo;
//
// IEnumSCMProcessInfo
//
// Interface for walking through a view of the SCM's server tables
//
[
local,
object,
uuid(8bbbd026-de4d-46b7-8a90-72c66eb64ad6),
pointer_default(unique)
]
interface IEnumSCMProcessInfo : IUnknown
{
// Fetch process info for next cElems processes
HRESULT Next([in] ULONG cElems,
[out, size_is (cElems), length_is (*pcFetched)] SCMProcessInfo** ppSCMProcessInfo,
[out] ULONG *pcFetched);
// advance cursor past cElems elements
HRESULT Skip([in]ULONG cElems);
// reset cursor to first element
HRESULT Reset();
// duplicate this enumerator
HRESULT Clone([out]IEnumSCMProcessInfo **ppESPI);
}
//
// ISCMProcessControl
//
// Interface for querying & changing the SCM's server tables
//
[
local,
object,
uuid(7629798c-f1e6-4ef0-b521-dc466fded209),
pointer_default(unique)
]
interface ISCMProcessControl : IUnknown
{
// Find info for processes implementing an application
HRESULT FindApplication ([in] REFGUID rappid, [out] IEnumSCMProcessInfo **ppESPI);
// Find info for processes implementing a class
HRESULT FindClass ([in] REFCLSID rclsid, [out] IEnumSCMProcessInfo **ppESPI);
// Find info for a particular PID.
HRESULT FindProcess ([in] DWORD pid, [out] SCMProcessInfo** pSCMProcessInfo);
// Send no activations to COM+ applications implementing this APPID.
HRESULT SuspendApplication ([in] REFGUID rappid);
// Send no activations to processes implementing this CLSID.
HRESULT SuspendClass ([in] REFCLSID rclsid);
// Send no activations to this process.
HRESULT SuspendProcess ([in] DWORD ppid);
// Resume sending activations to COM+ applications implementing this APPID
HRESULT ResumeApplication([in] REFGUID rappid);
// Resume sending activations to processes implementing this CLSID
HRESULT ResumeClass([in] REFCLSID rclsid);
// Resumt sending activations to this process
HRESULT ResumeProcess([in] DWORD pid);
// Send no more activations to COM+ applications implementing this APPID.
HRESULT RetireApplication ([in] REFGUID rappid);
// Send no more activations to processes implementing this CLSID.
HRESULT RetireClass ([in] REFCLSID rclsid);
// Send no more activations to this process.
HRESULT RetireProcess ([in] DWORD pid);
// Free a SCMProcessInfo structure
HRESULT FreeSCMProcessInfo(SCMProcessInfo** ppSCMProcessInfo);
}
// This clsid gets defined in prvidl.lib
cpp_quote("")
cpp_quote("EXTERN_C const CLSID CLSID_RPCSSInfo;")
cpp_quote("")
cpp_quote("")
cpp_quote("////////////////////////////////////////////////////////////////////////")
cpp_quote("//")
cpp_quote("// API for accessing SCM's objects (exported from rpcss.dll)")
cpp_quote("//")
cpp_quote("typedef HRESULT (__stdcall *PFNGETRPCSSINFO)(REFCLSID, REFIID, void**);")
cpp_quote("//")
cpp_quote("////////////////////////////////////////////////////////////////////////")
cpp_quote("")