452 lines
15 KiB
Plaintext
452 lines
15 KiB
Plaintext
//+-------------------------------------------------------------------------
|
|
//
|
|
// 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("")
|
|
|
|
|