819 lines
26 KiB
C++
819 lines
26 KiB
C++
/*++
|
|
|
|
Copyright (C) 1997-2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
PIPESTBO.CPP
|
|
|
|
Abstract:
|
|
|
|
Declares the stub pipe operation classes
|
|
|
|
History:
|
|
|
|
alanbos 18-Dec-97 Created.
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#include "wmishared.h"
|
|
|
|
// CStubOperation_LPipe_CancelAsyncCall
|
|
void CStubOperation_LPipe_CancelAsyncCall::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
IWbemServices *pObj = (IWbemServices *) pStub;
|
|
CStubAddress_WinMgmt sinkAddr (m_pSink);
|
|
|
|
// Get the local object sink proxy corresponding to the client sink.
|
|
// If not found don't bother creating one as that would defeat the
|
|
// purpose of CancelAsyncCall.
|
|
CObjectSinkProxy *pNoteProxy =
|
|
comLink.GetObjectSinkProxy (sinkAddr, pObj, false);
|
|
|
|
if (pNoteProxy)
|
|
{
|
|
SetStatus (pObj->CancelAsyncCall ((IWbemObjectSink *) pNoteProxy));
|
|
pNoteProxy->Release (); // balance GetObjectSinkProxy
|
|
}
|
|
else
|
|
SetStatus (WBEM_E_INVALID_PARAMETER);
|
|
}
|
|
|
|
// CStubOperation_LPipe_CreateEnum
|
|
void CStubOperation_LPipe_CreateEnum::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadBSTR (&m_parent);
|
|
dwInSt |= decodeStream.ReadLong (&m_flags);
|
|
DecodeContext (decodeStream);
|
|
|
|
if (IsAsync ())
|
|
dwInSt |= decodeStream.ReadDWORD (&m_handler);
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_CreateEnum::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
IWbemServices* pObj = (IWbemServices *) pStub;
|
|
|
|
if (IsAsync ())
|
|
{
|
|
CStubAddress_WinMgmt sinkAddr (m_handler);
|
|
CObjectSinkProxy *pNoteProxy =
|
|
comLink.GetObjectSinkProxy (sinkAddr, pObj);
|
|
|
|
if (pNoteProxy)
|
|
{
|
|
SetStatus ((WBEM_METHOD_CreateClassEnumAsync == m_stubFunc) ?
|
|
pObj->CreateClassEnumAsync (m_parent, m_flags,
|
|
GetContext (), pNoteProxy) :
|
|
pObj->CreateInstanceEnumAsync (m_parent, m_flags,
|
|
GetContext (), pNoteProxy));
|
|
pNoteProxy->Release (); // balances GetObjectSinkProxy
|
|
}
|
|
else
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
else
|
|
{
|
|
IEnumWbemClassObject *pEnum = NULL;
|
|
SetStatus ((WBEM_METHOD_CreateClassEnum == m_stubFunc) ?
|
|
pObj->CreateClassEnum (m_parent, m_flags, GetContext (), &pEnum) :
|
|
pObj->CreateInstanceEnum (m_parent, m_flags, GetContext (), &pEnum));
|
|
|
|
if (WBEM_NO_ERROR == GetStatus ())
|
|
{
|
|
CStubAddress_WinMgmt stubAddr ( pEnum);
|
|
SetProxyAddress (ENUMERATOR, stubAddr);
|
|
comLink.AddRef2 (pEnum, ENUMERATOR, RELEASEIT);
|
|
}
|
|
}
|
|
}
|
|
|
|
// CStubOperation_LPipe_Delete
|
|
void CStubOperation_LPipe_Delete::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadBSTR (&m_path);
|
|
dwInSt |= decodeStream.ReadLong (&m_flags);
|
|
DecodeContext (decodeStream);
|
|
|
|
if (IsAsync ())
|
|
dwInSt |= decodeStream.ReadDWORD (&m_pHandler);
|
|
else
|
|
{
|
|
IWbemCallResult **ppResObj = NULL;
|
|
dwInSt |= decodeStream.ReadLong ((long *) &ppResObj);
|
|
SetResultObjectPP (ppResObj);
|
|
}
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_Delete::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
IWbemServices* pObj = (IWbemServices *) pStub;
|
|
|
|
if (IsAsync ())
|
|
{
|
|
CStubAddress_WinMgmt sinkAddr (m_pHandler);
|
|
CObjectSinkProxy *pNoteProxy =
|
|
comLink.GetObjectSinkProxy (sinkAddr, pObj);
|
|
|
|
if (pNoteProxy)
|
|
{
|
|
SetStatus ((WBEM_METHOD_DeleteClassAsync == m_stubFunc) ?
|
|
pObj->DeleteClassAsync (m_path, m_flags,
|
|
GetContext (), pNoteProxy) :
|
|
pObj->DeleteInstanceAsync (m_path, m_flags,
|
|
GetContext (), pNoteProxy));
|
|
pNoteProxy->Release (); // Balances GetObjectSinkProxy
|
|
}
|
|
else
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
else
|
|
{
|
|
IWbemCallResult *pResult = NULL;
|
|
|
|
SetStatus ((WBEM_METHOD_DeleteClass == m_stubFunc) ?
|
|
pObj->DeleteClass (m_path, m_flags, GetContext (),
|
|
(GetResultObjectPP ()) ? &pResult : NULL) :
|
|
pObj->DeleteInstance (m_path, m_flags, GetContext (),
|
|
(GetResultObjectPP ()) ? &pResult : NULL));
|
|
|
|
if (pResult)
|
|
{
|
|
CStubAddress_WinMgmt stubAddr ( pResult);
|
|
SetProxyAddress (CALLRESULT, stubAddr);
|
|
comLink.AddRef2 (pResult, CALLRESULT, RELEASEIT);
|
|
}
|
|
}
|
|
}
|
|
|
|
// CStubOperation_LPipe_ExecQuery
|
|
void CStubOperation_LPipe_ExecQuery::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadBSTR (&m_queryLanguage);
|
|
dwInSt |= decodeStream.ReadBSTR (&m_query);
|
|
dwInSt |= decodeStream.ReadLong (&m_flags);
|
|
DecodeContext (decodeStream);
|
|
|
|
if (IsAsync ())
|
|
dwInSt |= decodeStream.ReadDWORD (&m_pHandler);
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_ExecQuery::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
IWbemServices* pObj = (IWbemServices *) pStub;
|
|
|
|
if (IsAsync ())
|
|
{
|
|
CStubAddress_WinMgmt sinkAddr (m_pHandler);
|
|
CObjectSinkProxy *pNoteProxy =
|
|
comLink.GetObjectSinkProxy (sinkAddr, pObj);
|
|
|
|
if (pNoteProxy)
|
|
{
|
|
SetStatus ((WBEM_METHOD_ExecQueryAsync == m_stubFunc) ?
|
|
pObj->ExecQueryAsync (m_queryLanguage, m_query,
|
|
m_flags, GetContext (), pNoteProxy) :
|
|
pObj->ExecNotificationQueryAsync (m_queryLanguage, m_query,
|
|
m_flags, GetContext (), pNoteProxy)
|
|
);
|
|
pNoteProxy->Release (); // Balances GetObjectSinkProxy
|
|
}
|
|
else
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
else
|
|
{
|
|
IEnumWbemClassObject *pEnum = NULL;
|
|
SetStatus ((WBEM_METHOD_ExecQuery == m_stubFunc) ?
|
|
pObj->ExecQuery (m_queryLanguage, m_query,
|
|
m_flags, GetContext (), &pEnum) :
|
|
pObj->ExecNotificationQuery (m_queryLanguage, m_query,
|
|
m_flags, GetContext (), &pEnum)
|
|
);
|
|
|
|
if (WBEM_NO_ERROR == GetStatus ())
|
|
{
|
|
CStubAddress_WinMgmt stubAddr (pEnum);
|
|
SetProxyAddress (ENUMERATOR, stubAddr);
|
|
comLink.AddRef2 (pEnum, ENUMERATOR, RELEASEIT);
|
|
}
|
|
}
|
|
}
|
|
|
|
// CStubOperation_LPipe_GetObject
|
|
void CStubOperation_LPipe_GetObject::EncodeOp (CTransportStream& encodeStream)
|
|
{
|
|
if (!IsAsync ())
|
|
{
|
|
if ((WBEM_NO_ERROR == GetStatus ()) && m_pObject)
|
|
{
|
|
if (CTransportStream::no_error !=
|
|
((CWbemObject *) m_pObject)->WriteToStream (&encodeStream))
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
EncodeStubAddress (CALLRESULT, encodeStream);
|
|
}
|
|
}
|
|
|
|
void CStubOperation_LPipe_GetObject::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadBSTR (&m_path);
|
|
dwInSt |= decodeStream.ReadLong (&m_flags);
|
|
DecodeContext (decodeStream);
|
|
|
|
if (IsAsync ())
|
|
dwInSt |= decodeStream.ReadDWORD (&m_pHandler);
|
|
else
|
|
{
|
|
dwInSt |= decodeStream.ReadLong ((long *) &m_pObject);
|
|
IWbemCallResult **ppResObj = NULL;
|
|
dwInSt |= decodeStream.ReadLong ((long *) &ppResObj);
|
|
SetResultObjectPP (ppResObj);
|
|
}
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_GetObject::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
IWbemServices* pObj = (IWbemServices *) pStub;
|
|
|
|
if (IsAsync ())
|
|
{
|
|
CStubAddress_WinMgmt sinkAddr (m_pHandler);
|
|
CObjectSinkProxy *pNoteProxy =
|
|
comLink.GetObjectSinkProxy (sinkAddr, pObj);
|
|
|
|
if (pNoteProxy)
|
|
{
|
|
SetStatus (pObj->GetObjectAsync (m_path, m_flags,
|
|
GetContext (), pNoteProxy));
|
|
pNoteProxy->Release (); // Balances GetObjectSinkProxy
|
|
}
|
|
else
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
else
|
|
{
|
|
IWbemCallResult *pResult = NULL;
|
|
|
|
SetStatus (pObj->GetObject (m_path, m_flags, GetContext (),
|
|
(m_pObject) ? &m_pObject : NULL,
|
|
(GetResultObjectPP ()) ? &pResult : NULL));
|
|
|
|
if (pResult)
|
|
{
|
|
CStubAddress_WinMgmt stubAddr ( pResult);
|
|
SetProxyAddress (CALLRESULT, stubAddr);
|
|
comLink.AddRef2 (pResult, CALLRESULT, RELEASEIT);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// CStubOperation_LPipe_OpenNamespace
|
|
void CStubOperation_LPipe_OpenNamespace::EncodeOp (CTransportStream& encodeStream)
|
|
{
|
|
if (WBEM_NO_ERROR == GetStatus ())
|
|
EncodeStubAddress (PROVIDER, encodeStream);
|
|
EncodeStubAddress (CALLRESULT, encodeStream);
|
|
}
|
|
|
|
void CStubOperation_LPipe_OpenNamespace::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadBSTR (&m_path);
|
|
dwInSt |= decodeStream.ReadLong (&m_flags);
|
|
DecodeContext (decodeStream);
|
|
IWbemCallResult **ppResObj = NULL;
|
|
dwInSt |= decodeStream.ReadLong ((long *) &ppResObj);
|
|
SetResultObjectPP (ppResObj);
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_OpenNamespace::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
IWbemServices* pObj = (IWbemServices *) pStub;
|
|
IWbemCallResult *pResult = NULL;
|
|
|
|
IWbemServices* pProv = NULL; // The new pointer
|
|
SetStatus (pObj->OpenNamespace (m_path, m_flags, GetContext (),
|
|
&pProv, (GetResultObjectPP ()) ? &pResult : NULL));
|
|
|
|
if (WBEM_NO_ERROR == GetStatus ())
|
|
{
|
|
CStubAddress_WinMgmt stubAddr ( pProv);
|
|
SetProxyAddress (PROVIDER, stubAddr);
|
|
comLink.AddRef2 (pProv, PROVIDER, RELEASEIT);
|
|
}
|
|
|
|
if (pResult)
|
|
{
|
|
CStubAddress_WinMgmt stubAddr ( pResult);
|
|
SetProxyAddress (CALLRESULT, stubAddr);
|
|
comLink.AddRef2 (pResult, CALLRESULT, RELEASEIT);
|
|
}
|
|
}
|
|
|
|
// CStubOperation_LPipe_Put
|
|
void CStubOperation_LPipe_Put::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
m_pObject = CreateClassObject (&decodeStream);
|
|
dwInSt |= decodeStream.ReadLong (&m_flags);
|
|
DecodeContext (decodeStream);
|
|
|
|
if (IsAsync ())
|
|
dwInSt |= decodeStream.ReadDWORD (&m_pHandler);
|
|
else
|
|
{
|
|
IWbemCallResult **ppResObj = NULL;
|
|
dwInSt |= decodeStream.ReadLong ((long *) &ppResObj);
|
|
SetResultObjectPP (ppResObj);
|
|
}
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_Put::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
IWbemServices* pObj = (IWbemServices *) pStub;
|
|
|
|
if (IsAsync ())
|
|
{
|
|
CStubAddress_WinMgmt sinkAddr (m_pHandler);
|
|
CObjectSinkProxy *pNoteProxy =
|
|
comLink.GetObjectSinkProxy (sinkAddr, pObj);
|
|
|
|
if (pNoteProxy)
|
|
{
|
|
SetStatus ((WBEM_METHOD_PutClassAsync == m_stubFunc) ?
|
|
pObj->PutClassAsync (m_pObject, m_flags, GetContext (),
|
|
pNoteProxy) :
|
|
pObj->PutInstanceAsync (m_pObject, m_flags, GetContext (),
|
|
pNoteProxy));
|
|
pNoteProxy->Release (); // Balances GetObjectSinkProxy
|
|
}
|
|
else
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
else
|
|
{
|
|
IWbemCallResult *pResult = NULL;
|
|
|
|
SetStatus ((WBEM_METHOD_PutClass == m_stubFunc) ?
|
|
pObj->PutClass (m_pObject, m_flags, GetContext (),
|
|
(GetResultObjectPP ()) ? &pResult : NULL) :
|
|
pObj->PutInstance (m_pObject, m_flags, GetContext (),
|
|
(GetResultObjectPP ()) ? &pResult : NULL));
|
|
|
|
if (pResult)
|
|
{
|
|
CStubAddress_WinMgmt stubAddr (pResult);
|
|
SetProxyAddress (CALLRESULT, stubAddr);
|
|
comLink.AddRef2 (pResult, CALLRESULT, RELEASEIT);
|
|
}
|
|
}
|
|
}
|
|
|
|
// CStubOperation_LPipe_QueryObjectSink
|
|
void CStubOperation_LPipe_QueryObjectSink::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
IWbemServices* pObj = (IWbemServices *) pStub;
|
|
|
|
IWbemObjectSink *pObjectSink = NULL;
|
|
SetStatus (pObj->QueryObjectSink (m_flags, &pObjectSink));
|
|
|
|
if (WBEM_NO_ERROR == GetStatus ())
|
|
{
|
|
CStubAddress_WinMgmt stubAddr ( pObjectSink);
|
|
SetProxyAddress (OBJECTSINK, stubAddr);
|
|
comLink.AddRef2 (pObjectSink, OBJECTSINK, RELEASEIT);
|
|
}
|
|
}
|
|
|
|
// CStubOperation_LPipe_ExecMethod
|
|
void CStubOperation_LPipe_ExecMethod::EncodeOp (CTransportStream& encodeStream)
|
|
{
|
|
if (!IsAsync ())
|
|
{
|
|
if (WBEM_NO_ERROR == GetStatus () && m_pOutParams)
|
|
{
|
|
if (CTransportStream::no_error !=
|
|
((CWbemObject *)m_pOutParams)->WriteToStream (&encodeStream))
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
EncodeStubAddress (CALLRESULT, encodeStream);
|
|
}
|
|
}
|
|
|
|
void CStubOperation_LPipe_ExecMethod::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadBSTR (&m_path);
|
|
dwInSt |= decodeStream.ReadBSTR (&m_method);
|
|
dwInSt |= decodeStream.ReadLong (&m_flags);
|
|
DecodeContext (decodeStream);
|
|
|
|
// In parameters is an optional field
|
|
long inParams = 0;
|
|
dwInSt |= decodeStream.ReadLong (&inParams);
|
|
|
|
if (inParams)
|
|
m_pInParams = CreateClassObject (&decodeStream);
|
|
|
|
if (IsAsync ())
|
|
dwInSt |= decodeStream.ReadDWORD (&m_pHandler);
|
|
else
|
|
{
|
|
dwInSt |= decodeStream.ReadLong ((long *) &m_pOutParams);
|
|
IWbemCallResult **ppResObj = NULL;
|
|
dwInSt |= decodeStream.ReadLong ((long *) &ppResObj);
|
|
SetResultObjectPP (ppResObj);
|
|
}
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_ExecMethod::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
IWbemServices* pObj = (IWbemServices *) pStub;
|
|
|
|
if (IsAsync ())
|
|
{
|
|
CStubAddress_WinMgmt sinkAddr (m_pHandler);
|
|
CObjectSinkProxy *pNoteProxy =
|
|
comLink.GetObjectSinkProxy (sinkAddr, pObj);
|
|
|
|
if (pNoteProxy)
|
|
{
|
|
SetStatus (pObj->ExecMethodAsync (m_path, m_method, m_flags,
|
|
GetContext (), m_pInParams, pNoteProxy));
|
|
pNoteProxy->Release (); // balances GetObjectSinkProxy
|
|
}
|
|
else
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
else
|
|
{
|
|
IWbemCallResult *pResult = NULL;
|
|
|
|
SetStatus (pObj->ExecMethod (m_path, m_method, m_flags, GetContext (),
|
|
m_pInParams,
|
|
(m_pOutParams) ? &m_pOutParams : NULL,
|
|
(GetResultObjectPP ()) ? &pResult : NULL));
|
|
|
|
if (pResult)
|
|
{
|
|
CStubAddress_WinMgmt stubAddr ( pResult);
|
|
SetProxyAddress (CALLRESULT, stubAddr);
|
|
comLink.AddRef2 (pResult, CALLRESULT, RELEASEIT);
|
|
}
|
|
}
|
|
}
|
|
|
|
// CStubOperation_LPipe_RequestChallenge
|
|
void CStubOperation_LPipe_RequestChallenge::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadBSTR(&m_networkResource);
|
|
dwInSt |= decodeStream.ReadBSTR(&m_user);
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_RequestChallenge::EncodeOp (CTransportStream& encodeStream)
|
|
{
|
|
if (WBEM_NO_ERROR == GetStatus ())
|
|
encodeStream.WriteBytes (m_nonce, DIGEST_SIZE);
|
|
}
|
|
|
|
void CStubOperation_LPipe_RequestChallenge::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
SetStatus (((IServerLogin *) pStub)->RequestChallenge
|
|
(m_networkResource, m_user, m_nonce));
|
|
}
|
|
|
|
// CStubOperation_LPipe_EstablishPosition
|
|
void CStubOperation_LPipe_EstablishPosition::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadBSTR(&m_clientMachineName);
|
|
dwInSt |= decodeStream.ReadDWORD(&m_processId);
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_EstablishPosition::EncodeOp (CTransportStream& encodeStream)
|
|
{
|
|
if (WBEM_NO_ERROR == GetStatus ())
|
|
encodeStream.WriteDWORD (m_authEventHandle);
|
|
}
|
|
|
|
void CStubOperation_LPipe_EstablishPosition::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
SetStatus (((IServerLogin *) pStub)->EstablishPosition
|
|
(m_clientMachineName, m_processId, &m_authEventHandle));
|
|
}
|
|
|
|
// CStubOperation_LPipe_WBEMLogin
|
|
void CStubOperation_LPipe_WBEMLogin::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadBSTR(&m_preferredLocale);
|
|
dwInSt |= decodeStream.ReadBytes (m_accessToken, DIGEST_SIZE);
|
|
dwInSt |= decodeStream.ReadLong (&m_flags);
|
|
DecodeContext (decodeStream);
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_WBEMLogin::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
IServerLogin *pObj = (IServerLogin *) pStub;
|
|
IWbemServices *pProv = NULL; // The new pointer
|
|
SetStatus (pObj->WBEMLogin (m_preferredLocale, m_accessToken,
|
|
m_flags, GetContext (), &pProv));
|
|
|
|
if (WBEM_NO_ERROR == GetStatus ())
|
|
{
|
|
CStubAddress_WinMgmt stubAddr ( pProv);
|
|
SetProxyAddress (PROVIDER, stubAddr);
|
|
comLink.AddRef2 (pProv, PROVIDER, RELEASEIT);
|
|
}
|
|
}
|
|
|
|
// CStubOperation_LPipe_SspiPreLogin
|
|
void CStubOperation_LPipe_SspiPreLogin::EncodeOp (CTransportStream& encodeStream)
|
|
{
|
|
// NB: We don't check for WBEM_NO_ERROR explicitly because
|
|
// there are other S_ codes that can be returned by this call
|
|
if ( ! FAILED ( GetStatus () ) )
|
|
{
|
|
encodeStream.WriteLong (m_outBufSize);
|
|
encodeStream.WriteBytes (m_pOutToken, m_outBufSize);
|
|
encodeStream.WriteDWORD (m_authEventHandle);
|
|
}
|
|
}
|
|
|
|
void CStubOperation_LPipe_SspiPreLogin::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadLPSTR (&m_pszSSPIPkg);
|
|
dwInSt |= decodeStream.ReadLong (&m_flags);
|
|
dwInSt |= decodeStream.ReadLong (&m_bufSize);
|
|
|
|
if ((CTransportStream::no_error == dwInSt) && (0 < m_bufSize))
|
|
{
|
|
if (!(m_pInToken = new BYTE [m_bufSize]))
|
|
SetStatus (WBEM_E_OUT_OF_MEMORY);
|
|
else
|
|
dwInSt |= decodeStream.ReadBytes (m_pInToken, m_bufSize);
|
|
}
|
|
|
|
dwInSt |= decodeStream.ReadLong (&m_outBufSize);
|
|
|
|
if ((CTransportStream::no_error == dwInSt) && (0 < m_outBufSize))
|
|
{
|
|
if (!(m_pOutToken = new BYTE [m_outBufSize]))
|
|
SetStatus (WBEM_E_OUT_OF_MEMORY);
|
|
}
|
|
|
|
dwInSt |= decodeStream.ReadBSTR(&m_clientMachineName);
|
|
dwInSt |= decodeStream.ReadDWORD (&m_dwProcessID);
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_SspiPreLogin::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
SetStatus (((IServerLogin *) pStub)->SspiPreLogin
|
|
(m_pszSSPIPkg, m_flags,
|
|
m_bufSize, m_pInToken, m_outBufSize, &m_outBufSize, m_pOutToken,
|
|
m_clientMachineName, m_dwProcessID, &m_authEventHandle));
|
|
}
|
|
|
|
// CStubOperation_LPipe_Login
|
|
void CStubOperation_LPipe_Login::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadBSTR(&m_networkResource);
|
|
dwInSt |= decodeStream.ReadBSTR(&m_preferredLocale);
|
|
dwInSt |= decodeStream.ReadBytes (m_accessToken, DIGEST_SIZE);
|
|
dwInSt |= decodeStream.ReadLong (&m_flags);
|
|
DecodeContext (decodeStream);
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_Login::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
IServerLogin *pObj = (IServerLogin *) pStub;
|
|
IWbemServices *pProv = NULL; // The new pointer
|
|
SetStatus (pObj->Login (m_networkResource, m_preferredLocale,
|
|
m_accessToken, m_flags, GetContext (), &pProv));
|
|
|
|
if (WBEM_NO_ERROR == GetStatus ())
|
|
{
|
|
CStubAddress_WinMgmt stubAddr ( pProv);
|
|
SetProxyAddress (PROVIDER, stubAddr);
|
|
comLink.AddRef2 (pProv, PROVIDER, RELEASEIT);
|
|
}
|
|
}
|
|
|
|
// CStubOperation_LPipe_Reset
|
|
|
|
void CStubOperation_LPipe_Reset::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
SetStatus (((IEnumWbemClassObject *) pStub)->Reset ());
|
|
}
|
|
|
|
// CStubOperation_LPipe_Next
|
|
|
|
void CStubOperation_LPipe_Next::EncodeOp (CTransportStream& encodeStream)
|
|
{
|
|
encodeStream.WriteDWORD (m_returned);
|
|
|
|
for (DWORD dwLoop = 0; dwLoop < m_returned; dwLoop++)
|
|
{
|
|
((CWbemObject *)(m_objArray [dwLoop]))->WriteToStream (&encodeStream);
|
|
m_objArray [dwLoop]->Release ();
|
|
}
|
|
}
|
|
|
|
void CStubOperation_LPipe_Next::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadLong (&m_timeout);
|
|
dwInSt |= decodeStream.ReadDWORD (&m_count);
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
else if (!(m_objArray = (IWbemClassObject **) (new CWbemObject * [m_count])))
|
|
SetStatus (WBEM_E_OUT_OF_MEMORY);
|
|
}
|
|
|
|
void CStubOperation_LPipe_Next::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
SetStatus (((IEnumWbemClassObject *) pStub)->Next
|
|
(m_timeout, m_count, m_objArray, &m_returned));
|
|
}
|
|
|
|
// CStubOperation_LPipe_Clone
|
|
void CStubOperation_LPipe_Clone::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
IEnumWbemClassObject* pEnum = NULL;
|
|
SetStatus (((IEnumWbemClassObject*) pStub)->Clone (&pEnum));
|
|
|
|
if (WBEM_NO_ERROR == GetStatus ())
|
|
{
|
|
CStubAddress_WinMgmt stubAddr ( pEnum);
|
|
SetProxyAddress (ENUMERATOR, stubAddr);
|
|
comLink.AddRef2 (pEnum, ENUMERATOR, RELEASEIT);
|
|
}
|
|
}
|
|
|
|
// CStubOperation_LPipe_NextAsync
|
|
void CStubOperation_LPipe_NextAsync::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadLong(&m_count);
|
|
dwInSt |= decodeStream.ReadDWORD(&m_pSink);
|
|
dwInSt |= decodeStream.ReadDWORD(&m_pServiceStub);
|
|
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_NextAsync::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
CStubAddress_WinMgmt sinkAddr (m_pSink);
|
|
IWbemServices *pServices = (IWbemServices *) (comLink.GetStub (m_pServiceStub, PROVIDER));
|
|
|
|
CObjectSinkProxy *pNoteProxy = comLink.GetObjectSinkProxy (sinkAddr, pServices);
|
|
|
|
if (pNoteProxy)
|
|
{
|
|
SetStatus (((IEnumWbemClassObject *) pStub)->NextAsync (m_count, pNoteProxy));
|
|
pNoteProxy->Release (); // balances GetObjectSinkProxy
|
|
}
|
|
else
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
|
|
if (pServices)
|
|
pServices->Release (); // Balances GetStub call above
|
|
}
|
|
|
|
// CStubOperation_LPipe_Skip
|
|
void CStubOperation_LPipe_Skip::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
DWORD dwInSt = CTransportStream::no_error;
|
|
dwInSt |= decodeStream.ReadLong(&m_timeout);
|
|
dwInSt |= decodeStream.ReadDWORD(&m_number);
|
|
if (CTransportStream::no_error != dwInSt)
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_Skip::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
SetStatus (((IEnumWbemClassObject *) pStub)->Skip (m_timeout, m_number));
|
|
}
|
|
|
|
// CStubOperation_LPipe_CallResult
|
|
void CStubOperation_LPipe_CallResult::EncodeOp (CTransportStream& encodeStream)
|
|
{
|
|
if (WBEM_NO_ERROR == GetStatus ())
|
|
{
|
|
switch (m_stubFunc)
|
|
{
|
|
case GETRESULTOBJECT:
|
|
if (m_pStatusObject && (CTransportStream::no_error !=
|
|
(((CWbemObject *) m_pStatusObject)->WriteToStream (&encodeStream))))
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
break;
|
|
|
|
case GETRESULTSTRING:
|
|
encodeStream.WriteBSTR (m_resultString);
|
|
break;
|
|
|
|
case GETCALLSTATUS:
|
|
encodeStream.WriteLong (m_status);
|
|
break;
|
|
|
|
case GETSERVICES:
|
|
EncodeStubAddress (PROVIDER, encodeStream);
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void CStubOperation_LPipe_CallResult::DecodeOp (CTransportStream& decodeStream)
|
|
{
|
|
if (CTransportStream::no_error != decodeStream.ReadLong(&m_timeout))
|
|
SetStatus (WBEM_E_INVALID_STREAM);
|
|
}
|
|
|
|
void CStubOperation_LPipe_CallResult::Execute (CComLink& comLink, IUnknown *pStub)
|
|
{
|
|
IWbemCallResult *pObj = (IWbemCallResult *) pStub;
|
|
|
|
switch (m_stubFunc)
|
|
{
|
|
case GETRESULTOBJECT:
|
|
SetStatus (pObj->GetResultObject (m_timeout, &m_pStatusObject));
|
|
break;
|
|
|
|
case GETRESULTSTRING:
|
|
SetStatus (pObj->GetResultString (m_timeout, &m_resultString));
|
|
break;
|
|
|
|
case GETCALLSTATUS:
|
|
SetStatus (pObj->GetCallStatus (m_timeout, &m_status));
|
|
break;
|
|
|
|
case GETSERVICES:
|
|
{
|
|
IWbemServices *pProv = NULL;
|
|
SetStatus (pObj->GetResultServices (m_timeout, &pProv));
|
|
|
|
if (WBEM_NO_ERROR == GetStatus ())
|
|
{
|
|
CStubAddress_WinMgmt stubAddr (pProv);
|
|
SetProxyAddress (PROVIDER, stubAddr);
|
|
comLink.AddRef2 (pProv, PROVIDER, RELEASEIT);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|