205 lines
6.7 KiB
C++
205 lines
6.7 KiB
C++
/*++
|
|
|
|
Copyright (C) 1997-2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
IOPN.H
|
|
|
|
Abstract:
|
|
|
|
Declares the fundamental protocol-independent operation class
|
|
|
|
History:
|
|
|
|
alanbos 18-Dec-97 Created.
|
|
|
|
--*/
|
|
|
|
#ifndef _IOPN_H_
|
|
#define _IOPN_H_
|
|
|
|
#if 0
|
|
typedef enum tag_WBEM_LOGIN_TYPE
|
|
{
|
|
WBEM_FLAG_INPROC_LOGIN = 0,
|
|
WBEM_FLAG_LOCAL_LOGIN = 1,
|
|
WBEM_FLAG_REMOTE_LOGIN = 2,
|
|
WBEM_AUTHENTICATION_METHOD_MASK = 0xF,
|
|
|
|
WBEM_FLAG_USE_MULTIPLE_CHALLENGES = 0x10,
|
|
} WBEM_LOGIN_TYPE;
|
|
#endif
|
|
|
|
typedef enum tag_WBEM_COM_METHOD_MASK
|
|
{
|
|
WBEM_METHOD_OpenNamespace = 0x1,
|
|
WBEM_METHOD_CancelAsyncCall = 0x2,
|
|
WBEM_METHOD_QueryObjectSink = 0x4,
|
|
|
|
// Class & instance retrieval.
|
|
// ===========================
|
|
|
|
WBEM_METHOD_GetObject = 0x8,
|
|
WBEM_METHOD_GetObjectAsync = 0x10,
|
|
|
|
// Class Manipulation Methods
|
|
// ==========================
|
|
WBEM_METHOD_PutClass = 0x20,
|
|
WBEM_METHOD_PutClassAsync = 0x40,
|
|
WBEM_METHOD_DeleteClass = 0x80,
|
|
WBEM_METHOD_DeleteClassAsync = 0x100,
|
|
WBEM_METHOD_CreateClassEnum = 0x200,
|
|
WBEM_METHOD_CreateClassEnumAsync = 0x400,
|
|
|
|
// Instance manipulation.
|
|
// ============================
|
|
WBEM_METHOD_PutInstance = 0x800,
|
|
WBEM_METHOD_PutInstanceAsync = 0x1000,
|
|
WBEM_METHOD_DeleteInstance = 0x2000,
|
|
WBEM_METHOD_DeleteInstanceAsync = 0x4000,
|
|
WBEM_METHOD_CreateInstanceEnum = 0x8000,
|
|
WBEM_METHOD_CreateInstanceEnumAsync = 0x10000,
|
|
|
|
// Queries.
|
|
// ========
|
|
WBEM_METHOD_ExecQuery = 0x20000,
|
|
WBEM_METHOD_ExecQueryAsync = 0x40000,
|
|
WBEM_METHOD_ExecNotificationQuery = 0x80000,
|
|
WBEM_METHOD_ExecNotificationQueryAsync = 0x100000,
|
|
|
|
// Methods
|
|
// =======
|
|
WBEM_METHOD_ExecMethod = 0x400000,
|
|
WBEM_METHOD_ExecMethodAsync = 0x800000,
|
|
|
|
} WBEM_COM_METHOD_MASK;
|
|
|
|
// Base class (abstract) for any proxied operation irrespective
|
|
// of interface or protocol. This encapsulates both the
|
|
// operation request and the response.
|
|
class IOperation
|
|
{
|
|
private:
|
|
CTransportStream m_decodeStream; // for decoding MSG_RETURN
|
|
static RequestId m_id; // per-call unique id generator
|
|
RequestId m_requestId; // the unique id for this call (app global)
|
|
bool m_async; // whether the API call was async
|
|
bool m_moreData; // if there is more data to encode (sending only)
|
|
HRESULT m_status; // the call status (to be returned to caller)
|
|
IWbemContext* m_pContext; // any context info for the call
|
|
IWbemCallResult** m_ppCallResult; // The caller's pointer for semisynchronous mode
|
|
IErrorInfo* m_pErrorInfo; // In case of error; this may be decoded and set
|
|
// in different threads
|
|
IStubAddress* m_addr [LASTONE]; // any returned stub addresses
|
|
|
|
protected:
|
|
inline IOperation (IWbemContext* pContext = NULL, IWbemCallResult** ppResult = NULL,
|
|
bool isAsync = FALSE) :
|
|
m_async (isAsync),
|
|
m_moreData (false),
|
|
m_requestId (InterlockedIncrement (&m_id)),
|
|
m_pContext (pContext),
|
|
m_ppCallResult (ppResult),
|
|
m_status (WBEM_NO_ERROR),
|
|
m_pErrorInfo (NULL)
|
|
{
|
|
if (m_pContext)
|
|
m_pContext->AddRef ();
|
|
|
|
for (DWORD i = 0; i < LASTONE; i++) m_addr [i] = NULL;
|
|
}
|
|
|
|
|
|
// Some operations need to create a proxy on return - this sets the address
|
|
void SetProxyAddress (ObjType type, IStubAddress& stubAddr)
|
|
{
|
|
if (m_addr [type])
|
|
delete m_addr [type];
|
|
m_addr [type] = stubAddr.Clone ();
|
|
}
|
|
|
|
// The following methods are intended to be called by the CProvProxy subclasses
|
|
// only. The first determines whether the caller expected an IWbemCallResult
|
|
// to be returned, and the second is used to determine the proxy address (in the
|
|
// case the the corresponding COM API call returns another proxied interface pointer).
|
|
void SetResultObjectPP (IWbemCallResult** ppCallResult)
|
|
{ m_ppCallResult = ppCallResult; }
|
|
|
|
IWbemContext* GetContext () { return m_pContext; }
|
|
void SetContext (IWbemContext* pContext);
|
|
|
|
|
|
// Set by subclasses to indicate whether there is more data to come
|
|
inline void SetMoreData (bool moreData) { m_moreData = moreData; }
|
|
inline bool IsMoreData () { return m_moreData; }
|
|
|
|
// Get and Set IErrorInfo helper methods used by subclasses
|
|
IErrorInfo* GetErrorInfoFromObject ();
|
|
void SetErrorInfoIntoObject (IErrorInfo* pInfo);
|
|
|
|
// Used on stub side to set the current thread IErrorInfo (if any)
|
|
// into this object.
|
|
void SetErrorInfoIntoObject ();
|
|
|
|
public:
|
|
inline virtual ~IOperation ()
|
|
{
|
|
if (m_pContext) m_pContext->Release ();
|
|
if (m_pErrorInfo) m_pErrorInfo->Release ();
|
|
|
|
for (DWORD i = 0; i < LASTONE; i++) delete m_addr [i];
|
|
}
|
|
|
|
// These must be overriden in the subclass. Decode functions assume
|
|
// no packet header, whereas Encode functions will encode the packet
|
|
// header. Note that proxies implement
|
|
virtual bool DecodeRequest (CTransportStream& decodeStream,
|
|
ISecurityHelper& securityHelper) PURE;
|
|
virtual bool DecodeResponse (CTransportStream& decodeStream,
|
|
ISecurityHelper& securityHelper) PURE;
|
|
virtual bool EncodeRequest (CTransportStream& encodeStream,
|
|
ISecurityHelper& securityHelper) PURE;
|
|
virtual bool EncodeResponse (CTransportStream& encodeStream,
|
|
ISecurityHelper& securityHelper) PURE;
|
|
|
|
// Used on stubs; comlink calls this to initiate the stub handling.
|
|
inline virtual void HandleCall (CComLink& comLink) {};
|
|
|
|
// Return the request id unique to this operation
|
|
inline RequestId GetRequestId () { return m_requestId; }
|
|
inline void SetRequestId (RequestId requestId) { m_requestId = requestId; }
|
|
|
|
// Access to the COM operation response status
|
|
inline HRESULT GetStatus () { return m_status; }
|
|
inline void SetStatus (HRESULT status) { m_status = status; }
|
|
|
|
// Indicates whether the operation as requested by the client is asynchronous
|
|
inline bool IsAsync () { return m_async; }
|
|
|
|
// Indicates whether the COMLink should wait for a protocol-level response
|
|
// before returning on the send thread, or whether a simple transport-level
|
|
// dispatch of the request is all that is required.
|
|
inline virtual bool WaitForAck () { return TRUE; }
|
|
|
|
// Used on the proxy side to set the error info decoded into this operation
|
|
// into the current thread.
|
|
void SetErrorInfoOnThread ();
|
|
|
|
inline IStubAddress* GetProxyAddress (ObjType type) { return m_addr [type]; }
|
|
|
|
inline IWbemCallResult** GetResultObjectPP () { return m_ppCallResult; }
|
|
|
|
inline CTransportStream& GetDecodeStream () { return m_decodeStream; }
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|