able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/mtscript/scrhost/automation.cxx

1970 lines
48 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+------------------------------------------------------------------------
//
// Microsoft Forms
// Copyright (C) Microsoft Corporation, 1996
//
// File: bsauto.cxx
//
//-------------------------------------------------------------------------
#include "headers.hxx"
#include <mapi.h>
#undef ASSERT
DeclareTag(tagSync, "MTScript", "Trace Thread Sync events");
DeclareTag(tagLock, "MTScript", "Trace Thread Lock events");
ExternTag(tagProcess);
AutoCriticalSection CScriptHost::s_csSync;
CStackDataAry<CScriptHost::SYNCEVENT, 5> CScriptHost::s_arySyncEvents;
CScriptHost::THREADLOCK CScriptHost::s_aThreadLocks[MAX_LOCKS];
UINT CScriptHost::s_cThreadLocks = 0;
static const wchar_t *g_pszListDeliminator = L";,";
static wchar_t *g_pszAtomicSyncLock = L"g_pszAtomicSyncLock";
//---------------------------------------------------------------------------
//
// Member: CScriptHost::GetTypeInfo, IDispatch
//
//---------------------------------------------------------------------------
HRESULT
CScriptHost::GetTypeInfo(UINT itinfo, ULONG lcid, ITypeInfo ** pptinfo)
{
VERIFY_THREAD();
HRESULT hr;
hr = LoadTypeLibrary();
if (hr)
goto Cleanup;
*pptinfo = _pTypeInfoIGlobalMTScript;
(*pptinfo)->AddRef();
Cleanup:
return hr;
}
//---------------------------------------------------------------------------
//
// Member: CScriptHost::GetTypeInfoCount, IDispatch
//
//---------------------------------------------------------------------------
HRESULT
CScriptHost::GetTypeInfoCount(UINT * pctinfo)
{
VERIFY_THREAD();
*pctinfo = 1;
return S_OK;
}
//---------------------------------------------------------------------------
//
// Member: CScriptHost::GetIDsOfNames, IDispatch
//
//---------------------------------------------------------------------------
HRESULT
CScriptHost::GetIDsOfNames(REFIID riid, LPOLESTR * rgszNames, UINT cNames, LCID lcid, DISPID * rgdispid)
{
VERIFY_THREAD();
HRESULT hr;
hr = THR(LoadTypeLibrary());
if (hr)
goto Cleanup;
hr = _pTypeInfoIGlobalMTScript->GetIDsOfNames(rgszNames, cNames, rgdispid);
Cleanup:
return hr;
}
//---------------------------------------------------------------------------
//
// Member: CScriptHost::Invoke, IDispatch
//
//---------------------------------------------------------------------------
HRESULT
CScriptHost::Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags,DISPPARAMS * pdispparams, VARIANT * pvarResult,EXCEPINFO * pexcepinfo, UINT * puArgErr)
{
VERIFY_THREAD();
HRESULT hr;
hr = LoadTypeLibrary();
if (hr)
goto Cleanup;
hr = _pTypeInfoIGlobalMTScript->Invoke((IGlobalMTScript *)this, dispidMember, wFlags, pdispparams, pvarResult, pexcepinfo, puArgErr);
Cleanup:
return hr;
}
//***************************************************************************
//
// IGlobalMTScript implementation
//
//***************************************************************************
HRESULT
CScriptHost::get_PublicData(VARIANT * pvData)
{
VERIFY_THREAD();
HRESULT hr = S_OK;
// NOTE: We assume that the output parameter pvData is an empty or
// uninitialized VARIANT. This should be safe because it is defined as
// the return value for this method to the scripting engines and is
// a pure [out] parameter.
VariantInit(pvData);
// Check to see if the data has changed since we last got it.
// _dwPublicSerialNum is a DWORD so we are guaranteed an atomic read.
if (_pMT->_dwPublicSerialNum != _dwPublicSN)
{
LOCK_LOCALS(_pMT);
VariantClear(&_vPubCache);
// If the data is an IDispatch pointer (how the scripting engines
// implement most objects) we must get a marshalled copy to this thread.
// Otherwise we can just copy the data into the return value.
if (V_VT(&_pMT->_vPublicData) == VT_DISPATCH)
{
IDispatch *pDisp;
Assert(_pMT->_dwPublicDataCookie != 0);
hr = _pMT->_pGIT->GetInterfaceFromGlobal(_pMT->_dwPublicDataCookie,
IID_IDispatch,
(LPVOID*)&pDisp);
if (!hr)
{
V_VT(&_vPubCache) = VT_DISPATCH;
V_DISPATCH(&_vPubCache) = pDisp;
}
}
else
{
hr = VariantCopy(&_vPubCache, &_pMT->_vPublicData);
}
_dwPublicSN = _pMT->_dwPublicSerialNum;
}
if (!hr)
{
hr = VariantCopy(pvData, &_vPubCache);
}
return hr;
}
HRESULT
CScriptHost::put_PublicData(VARIANT vData)
{
VERIFY_THREAD();
HRESULT hr = S_OK;
// Check for data types which we don't support.
if ( V_ISBYREF(&vData)
|| V_ISARRAY(&vData)
|| V_ISVECTOR(&vData)
|| V_VT(&vData) == VT_UNKNOWN)
{
return E_INVALIDARG;
}
LOCK_LOCALS(_pMT);
// If the previous data is an IDispatch pointer revoke it from the
// GlobalInterfaceTable.
if (V_VT(&_pMT->_vPublicData) == VT_DISPATCH)
{
Assert(_pMT->_dwPublicDataCookie != 0);
hr = _pMT->_pGIT->RevokeInterfaceFromGlobal(_pMT->_dwPublicDataCookie);
AssertSz(!hr, "Unexpected failure revoking itf from GIT");
_pMT->_dwPublicDataCookie = 0;
}
// If the new data is an IDispatch pointer then we must register it.
if (V_VT(&vData) == VT_DISPATCH)
{
Assert(_pMT->_dwPublicDataCookie == 0);
hr = _pMT->_pGIT->RegisterInterfaceInGlobal(V_DISPATCH(&vData),
IID_IDispatch,
&_pMT->_dwPublicDataCookie);
AssertSz(!hr, "Unexpected failure registering itf in GIT");
}
// Update the global copy of the data.
//$ FUTURE: This can be optimized to reduce memory usage (by not making
// a copy of a string in every thread, for example).
_pMT->_dwPublicSerialNum++;
hr = VariantCopy(&_pMT->_vPublicData, &vData);
if (!hr)
{
// Even if it's an IDispatch, we don't need to marshal it for
// ourselves because we're running in the same thread as the script
// engine that gave it to us.
hr = VariantCopy(&_vPubCache, &vData);
_dwPublicSN = _pMT->_dwPublicSerialNum;
}
return S_OK;
}
HRESULT
CScriptHost::get_PrivateData(VARIANT * pvData)
{
VERIFY_THREAD();
HRESULT hr = S_OK;
// NOTE: We assume that the output parameter pvData is an empty or
// uninitialized VARIANT. This should be safe because it is defined as
// the return value for this method to the scripting engines and is
// a pure [out] parameter.
VariantInit(pvData);
// Check to see if the data has changed since we last got it.
// _dwPrivateSerialNum is a DWORD so we are guaranteed an atomic read.
if (_pMT->_dwPrivateSerialNum != _dwPrivateSN)
{
LOCK_LOCALS(_pMT);
VariantClear(&_vPrivCache);
// If the data is an IDispatch pointer (how the scripting engines
// implement most objects) we must get a marshalled copy to this thread.
// Otherwise we can just copy the data into the return value.
if (V_VT(&_pMT->_vPrivateData) == VT_DISPATCH)
{
IDispatch *pDisp;
Assert(_pMT->_dwPrivateDataCookie != 0);
hr = _pMT->_pGIT->GetInterfaceFromGlobal(_pMT->_dwPrivateDataCookie,
IID_IDispatch,
(LPVOID*)&pDisp);
if (!hr)
{
V_VT(&_vPrivCache) = VT_DISPATCH;
V_DISPATCH(&_vPrivCache) = pDisp;
}
}
else
{
hr = VariantCopy(&_vPrivCache, &_pMT->_vPrivateData);
}
_dwPrivateSN = _pMT->_dwPrivateSerialNum;
}
if (!hr)
{
hr = VariantCopy(pvData, &_vPrivCache);
}
return hr;
}
HRESULT
CScriptHost::put_PrivateData(VARIANT vData)
{
VERIFY_THREAD();
HRESULT hr = S_OK;
// Check for data types which we don't support.
if ( V_ISBYREF(&vData)
|| V_ISARRAY(&vData)
|| V_ISVECTOR(&vData)
|| V_VT(&vData) == VT_UNKNOWN)
{
return E_INVALIDARG;
}
LOCK_LOCALS(_pMT);
// If the previous data is an IDispatch pointer revoke it from the
// GlobalInterfaceTable.
if (V_VT(&_pMT->_vPrivateData) == VT_DISPATCH)
{
Assert(_pMT->_dwPrivateDataCookie != 0);
hr = _pMT->_pGIT->RevokeInterfaceFromGlobal(_pMT->_dwPrivateDataCookie);
AssertSz(!hr, "Unexpected failure revoking itf from GIT");
_pMT->_dwPrivateDataCookie = 0;
}
// If the new data is an IDispatch pointer then we must register it.
if (V_VT(&vData) == VT_DISPATCH)
{
Assert(_pMT->_dwPrivateDataCookie == 0);
hr = _pMT->_pGIT->RegisterInterfaceInGlobal(V_DISPATCH(&vData),
IID_IDispatch,
&_pMT->_dwPrivateDataCookie);
AssertSz(!hr, "Unexpected failure registering itf in GIT");
}
// Update the global copy of the data.
//$ FUTURE: This can be optimized to reduce memory usage (by not making
// a copy of a string in every thread, for example).
_pMT->_dwPrivateSerialNum++;
hr = VariantCopy(&_pMT->_vPrivateData, &vData);
if (!hr)
{
// Even if it's an IDispatch, we don't need to marshal it for
// ourselves because we're running in the same thread as the script
// engine that gave it to us.
hr = VariantCopy(&_vPrivCache, &vData);
_dwPrivateSN = _pMT->_dwPrivateSerialNum;
}
return S_OK;
}
HRESULT
CScriptHost::ExitProcess()
{
VERIFY_THREAD();
PostToThread(_pMT, MD_PLEASEEXIT);
return S_OK;
}
HRESULT
CScriptHost::Restart()
{
VERIFY_THREAD();
PostToThread(_pMT, MD_RESTART);
return S_OK;
}
HRESULT
CScriptHost::get_LocalMachine(BSTR *pbstrName)
{
TCHAR achCompName[MAX_COMPUTERNAME_LENGTH+1];
DWORD dwLen = MAX_COMPUTERNAME_LENGTH+1;
VERIFY_THREAD();
if (!pbstrName)
return E_POINTER;
GetComputerName(achCompName, &dwLen);
achCompName[dwLen] = '\0';
*pbstrName = SysAllocString(achCompName);
if (!*pbstrName)
return E_OUTOFMEMORY;
return S_OK;
}
HRESULT
CScriptHost::Include(BSTR bstrPath)
{
VERIFY_THREAD();
HRESULT hr;
if(!bstrPath)
return E_INVALIDARG;
if (!_fIsPrimaryScript)
MessageEventPump(FALSE);
//$ TODO: Define a new named item context for the included file for better
// debugging.
hr = THR(GetSite()->ExecuteScriptFile(bstrPath));
return hr;
}
HRESULT
CScriptHost::CallScript(BSTR bstrPath, VARIANT *pvarScriptParam)
{
VERIFY_THREAD();
HRESULT hr;
if(!bstrPath)
return E_INVALIDARG;
if (!_fIsPrimaryScript)
MessageEventPump(FALSE);
hr = THR(PushScript(_tcsrchr(bstrPath, _T('.'))));
if(hr)
goto Cleanup;
if (pvarScriptParam && pvarScriptParam->vt != VT_ERROR)
{
hr = THR(VariantCopy(&GetSite()->_varParam, pvarScriptParam));
if (hr)
goto Cleanup;
}
hr = THR(GetSite()->ExecuteScriptFile(bstrPath));
hr = THR(GetSite()->SetScriptState(SCRIPTSTATE_CONNECTED));
if (hr)
goto Cleanup;
FireEvent(DISPID_MTScript_ScriptMain, 0, NULL);
PopScript();
Cleanup:
return hr;
}
HRESULT
CScriptHost::SpawnScript(BSTR bstrPath, VARIANT *pvarScriptParam)
{
VERIFY_THREAD();
HRESULT hr = S_OK;
VARIANT *pvarParam = NULL;
DWORD dwCookie = 0;
BOOL fRegistered = false;
// Check for data types which we don't support.
if ( !bstrPath
|| SysStringLen(bstrPath) == 0
|| V_ISBYREF(pvarScriptParam)
|| V_ISARRAY(pvarScriptParam)
|| V_ISVECTOR(pvarScriptParam)
|| V_VT(pvarScriptParam) == VT_UNKNOWN)
{
return E_INVALIDARG;
}
if (!_fIsPrimaryScript)
MessageEventPump(FALSE);
if (pvarScriptParam && pvarScriptParam->vt != VT_ERROR)
{
pvarParam = new VARIANT;
if (!pvarParam)
return E_OUTOFMEMORY;
VariantInit(pvarParam);
if (V_VT(pvarScriptParam) == VT_DISPATCH)
{
// Stick the pointer in the GlobalInterfaceTable, so the other
// thread can pull it out safely.
hr = _pMT->_pGIT->RegisterInterfaceInGlobal(V_DISPATCH(pvarScriptParam),
IID_IDispatch,
&dwCookie);
if (hr)
goto Cleanup;
// Stick the cookie in the variant we hand to the other thread.
V_VT(pvarParam) = VT_DISPATCH;
V_I4(pvarParam) = dwCookie;
fRegistered = true;
}
else
{
hr = THR(VariantCopy(pvarParam, pvarScriptParam));
if (hr)
goto Cleanup;
}
}
hr = _pMT->RunScript(bstrPath, pvarParam);
Cleanup:
if (pvarParam)
{
if (fRegistered)
{
Verify(_pMT->_pGIT->RevokeInterfaceFromGlobal(dwCookie) == S_OK);
}
if (V_VT(pvarParam) != VT_DISPATCH)
VariantClear(pvarParam);
delete pvarParam;
}
return hr;
}
HRESULT
CScriptHost::get_ScriptParam(VARIANT *pvarScriptParam)
{
VERIFY_THREAD();
HRESULT hr;
if (!_fIsPrimaryScript)
MessageEventPump(FALSE);
if (GetSite())
{
hr = THR(VariantCopy(pvarScriptParam, &GetSite()->_varParam));
}
else
{
hr = E_FAIL;
}
return hr;
}
HRESULT
CScriptHost::get_ScriptPath(BSTR *pbstrPath)
{
CStr cstrPath;
VERIFY_THREAD();
if (!_fIsPrimaryScript)
MessageEventPump(FALSE);
_pMT->_options.GetScriptPath(&cstrPath);
return cstrPath.AllocBSTR(pbstrPath);
}
typedef HRESULT (TestExternal_Func)(VARIANT *pParam, long *plRetVal);
HRESULT
CScriptHost::CallExternal(BSTR bstrDLLName,
BSTR bstrFunctionName,
VARIANT *pParam,
long * plRetVal)
{
VERIFY_THREAD();
HRESULT hr = S_OK;
HINSTANCE hInstDLL = NULL;
TestExternal_Func *pfn = NULL;
if (!_fIsPrimaryScript)
MessageEventPump(FALSE);
if (!plRetVal || !bstrDLLName || !bstrFunctionName)
return E_POINTER;
*plRetVal = -1;
hInstDLL = LoadLibrary(bstrDLLName);
if (NULL == hInstDLL)
{
return S_FALSE; // Can't return error codes or the script will abort
}
int cchLen = SysStringLen(bstrFunctionName);
char *pchBuf = new char[cchLen+1];
if (pchBuf)
{
WideCharToMultiByte(CP_ACP, 0, bstrFunctionName, cchLen, pchBuf, cchLen+1, NULL, NULL);
pchBuf[cchLen] = '\0';
pfn = (TestExternal_Func *)GetProcAddress(hInstDLL, pchBuf);
delete pchBuf;
}
if (NULL == pfn)
{
hr = S_FALSE;
}
else
{
*plRetVal = 0;
hr = (*pfn)(pParam, plRetVal);
}
FreeLibrary(hInstDLL);
return hr;
}
HRESULT
CScriptHost::GetSyncEventName(int nEvent, CStr *pCStr, HANDLE *phEvent)
{
HRESULT hr = S_OK;
*phEvent = NULL;
if (nEvent < 0)
return E_INVALIDARG;
EnterCriticalSection(&s_csSync);
if (nEvent >= s_arySyncEvents.Size())
{
hr = E_INVALIDARG;
goto Cleanup;
}
pCStr->Set(s_arySyncEvents[nEvent]._cstrName);
*phEvent = s_arySyncEvents[nEvent]._hEvent;
Cleanup:
LeaveCriticalSection(&s_csSync);
RRETURN(hr);
}
HRESULT
CScriptHost::GetSyncEvent(LPCTSTR pszName, HANDLE *phEvent)
{
int i;
SYNCEVENT *pse;
HRESULT hr = S_OK;
*phEvent = NULL;
if (_tcslen(pszName) < 1)
return E_INVALIDARG;
EnterCriticalSection(&s_csSync);
for (i = s_arySyncEvents.Size(), pse = s_arySyncEvents;
i > 0;
i--, pse++)
{
if (_tcsicmp(pszName, pse->_cstrName) == 0)
{
*phEvent = pse->_hEvent;
break;
}
}
if (i == 0)
{
//
// The event doesn't exist yet. Create one. The primary script thread
// owns cleaning all this stuff up.
//
SYNCEVENT se;
se._hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!se._hEvent)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
else
{
se._cstrName.Set(pszName);
s_arySyncEvents.AppendIndirect(&se);
//
// The cstr in 'se' will destroy its memory unless we take it away.
// It's now owned by the cstrName member of the array.
//
(void)se._cstrName.TakePch();
*phEvent = se._hEvent;
}
}
Cleanup:
LeaveCriticalSection(&s_csSync);
RRETURN(hr);
}
HRESULT
CScriptHost::StringToEventArray(const wchar_t *pszNameList, CStackPtrAry<HANDLE, 5> *pAryEvents)
{
HRESULT hr = S_OK;
if (wcspbrk(pszNameList, g_pszListDeliminator))
{
CStr cstrNameList;
HRESULT hr = cstrNameList.Set(pszNameList);
wchar_t *pch = NULL;
if (hr == S_OK)
pch = wcstok(cstrNameList, g_pszListDeliminator);
while (hr == S_OK && pch)
{
HANDLE hEvent;
hr = THR(GetSyncEvent(pch, &hEvent));
if (hr != S_OK)
break;
// Don't allow duplicates. MsgWaitForMultipleObjects will barf.
if (pAryEvents->Find(hEvent) != -1)
{
hr = E_INVALIDARG;
break;
}
hr = pAryEvents->Append(hEvent);
pch = wcstok(NULL, g_pszListDeliminator);
}
}
else
{
HANDLE hEvent;
hr = THR(GetSyncEvent(pszNameList, &hEvent));
if (hr == S_OK)
hr = pAryEvents->Append(hEvent);
}
RRETURN(hr);
}
HRESULT
CScriptHost::ResetSync(const BSTR bstrName)
{
VERIFY_THREAD();
HRESULT hr;
if (!_fIsPrimaryScript)
MessageEventPump(FALSE);
CStackPtrAry<HANDLE, 5> aryEvents;
hr = StringToEventArray(bstrName, &aryEvents);
if (hr == S_OK)
{
for(int i = aryEvents.Size() - 1; i>= 0; --i)
ResetEvent(aryEvents[i]);
}
return hr;
}
HRESULT
CScriptHost::WaitForSync(BSTR bstrName, long nTimeout, VARIANT_BOOL *pfSignaled)
{
VERIFY_THREAD();
HANDLE hEvent;
HRESULT hr;
if (!pfSignaled)
return E_POINTER;
*pfSignaled = VB_TRUE;
hr = THR(GetSyncEvent(bstrName, &hEvent));
if (hr)
RRETURN(hr);
TraceTag((tagSync, "Thread 0x%x is starting a wait for sync %ls",
_dwThreadId, bstrName));
if (MessageEventPump(TRUE,
1,
&hEvent,
FALSE,
(nTimeout > 0) ? nTimeout : INFINITE) != MEP_EVENT_0)
{
*pfSignaled = VB_FALSE;
}
// Now make sure that SignalThreadSync() and ResetSync()
// are atomic when manipulating multiple syncs.
TakeThreadLock(g_pszAtomicSyncLock);
ReleaseThreadLock(g_pszAtomicSyncLock);
TraceTag((tagSync, "Thread 0x%x has returned from a wait for sync %ls (signaled=%s)",
_dwThreadId,
bstrName,
(*pfSignaled==VB_FALSE) ? "false" : "true"));
return S_OK;
}
HRESULT
CScriptHost::WaitForMultipleSyncs(const BSTR bstrNameList,
VARIANT_BOOL fWaitForAll,
long nTimeout,
long *plSignal)
{
VERIFY_THREAD();
HRESULT hr;
DWORD dwRet;
*plSignal = 0;
CStackPtrAry<HANDLE, 5> aryEvents;
hr = StringToEventArray(bstrNameList, &aryEvents);
if (hr == S_OK)
{
TraceTag((tagSync, "Thread 0x%x is starting a multiwait for sync %ls",
_dwThreadId, bstrNameList));
dwRet = MessageEventPump(TRUE,
aryEvents.Size(),
aryEvents,
(fWaitForAll == VB_TRUE) ? TRUE : FALSE,
(nTimeout > 0) ? nTimeout : INFINITE);
if (dwRet >= MEP_EVENT_0)
{
*plSignal = dwRet - MEP_EVENT_0 + 1; // result is 1-based, not zero-based
// Now make sure that SignalThreadSync() and ResetSync()
// are atomic when manipulating multiple syncs.
TakeThreadLock(g_pszAtomicSyncLock);
ReleaseThreadLock(g_pszAtomicSyncLock);
}
TraceTag((tagSync, "Thread 0x%x has returned from a multiwait for sync %ls (signaled=%d)",
_dwThreadId,
bstrNameList,
*plSignal));
}
return hr;
}
HRESULT
CScriptHost::SignalThreadSync(BSTR bstrName)
{
HRESULT hr;
if (!_fIsPrimaryScript)
MessageEventPump(FALSE);
TraceTag((tagSync, "Thread 0x%x is signalling sync %ls",
_dwThreadId, bstrName));
CStackPtrAry<HANDLE, 5> aryEvents;
hr = StringToEventArray(bstrName, &aryEvents);
if (hr == S_OK)
{
if (aryEvents.Size() > 1)
TakeThreadLock(g_pszAtomicSyncLock);
for(int i = aryEvents.Size() - 1; i>= 0; --i)
SetEvent(aryEvents[i]);
if (aryEvents.Size() > 1)
ReleaseThreadLock(g_pszAtomicSyncLock);
}
return S_OK;
}
HRESULT
CScriptHost::GetLockCritSec(LPTSTR pszName,
CRITICAL_SECTION **ppcs,
DWORD **ppdwOwner)
{
int i;
THREADLOCK *ptl;
HRESULT hr = S_OK;
if (_tcslen(pszName) < 1)
return E_INVALIDARG;
*ppcs = NULL;
EnterCriticalSection(&s_csSync);
for (i = s_cThreadLocks, ptl = s_aThreadLocks;
i > 0;
i--, ptl++)
{
if (_tcsicmp(pszName, ptl->_cstrName) == 0)
{
*ppcs = &ptl->_csLock;
*ppdwOwner = &ptl->_dwOwner;
break;
}
}
if (i == 0)
{
//
// The critical section doesn't exist yet. Create one. The primary
// script thread owns cleaning all this stuff up.
//
if (s_cThreadLocks == MAX_LOCKS)
{
// BUGBUG -- SetErrorInfo
hr = E_OUTOFMEMORY;
goto Cleanup;
}
ptl = &s_aThreadLocks[s_cThreadLocks++];
InitializeCriticalSection(&ptl->_csLock);
ptl->_cstrName.Set(pszName);
ptl->_dwOwner = 0;
*ppcs = &ptl->_csLock;
*ppdwOwner = &ptl->_dwOwner;
}
Cleanup:
LeaveCriticalSection(&s_csSync);
RRETURN(hr);
}
HRESULT
CScriptHost::TakeThreadLock(BSTR bstrName)
{
HRESULT hr;
CRITICAL_SECTION *pcs;
DWORD *pdwOwner;
VERIFY_THREAD();
if (!_fIsPrimaryScript)
MessageEventPump(FALSE);
hr = THR(GetLockCritSec(bstrName, &pcs, &pdwOwner));
if (hr)
RRETURN(hr);
TraceTag((tagLock, "Thread 0x%x is trying to obtain lock %ls",
_dwThreadId, bstrName));
while (!TryEnterCriticalSection(pcs))
{
// Make sure we don't get hung here if the thread's trying to exit
if (MessageEventPump(TRUE, 0, NULL, FALSE, 100, TRUE) == MEP_EXIT)
return E_FAIL;
}
TraceTag((tagLock, "Thread 0x%x has obtained lock %ls",
_dwThreadId, bstrName));
*pdwOwner = GetCurrentThreadId();
return S_OK;
}
HRESULT
CScriptHost::ReleaseThreadLock(BSTR bstrName)
{
HRESULT hr;
CRITICAL_SECTION *pcs;
DWORD *pdwOwner;
VERIFY_THREAD();
if (!_fIsPrimaryScript)
MessageEventPump(FALSE);
hr = THR(GetLockCritSec(bstrName, &pcs, &pdwOwner));
if (hr)
RRETURN(hr);
// LeaveCriticalSection can cause other threads to lock indefinitely on
// the critical section if we don't actually own it.
if (*pdwOwner != GetCurrentThreadId())
{
return HRESULT_FROM_WIN32(ERROR_NOT_OWNER);
}
LeaveCriticalSection(pcs);
TraceTag((tagLock, "Thread 0x%x has released lock %ls",
_dwThreadId, bstrName));
return S_OK;
}
HRESULT
CScriptHost::DoEvents()
{
VERIFY_THREAD();
MessageEventPump(FALSE);
return S_OK;
}
HRESULT
CScriptHost::MessageBoxTimeout(BSTR bstrMessage, // Message Text
long cButtons, // Number of buttons (max 5)
BSTR bstrButtonText, // Comma separated list of button text. Number must match cButtons
long lTimeout, // Timeout in minutes. If zero then no timeout.
long lEventInterval, // Fire a OnMessageBoxInterval event every lEventInterval minutes
VARIANT_BOOL fCanCancel, // If TRUE then timeout can be canceled.
VARIANT_BOOL fConfirm, // If TRUE then confirm the button pushed before returning.
long *plSelected) // Returns button pushed. 0=timeout, 1=Button1, 2=Button2, etc.
{
VERIFY_THREAD();
HANDLE hEvent;
MBTIMEOUT mbt = { 0 };
BOOL fExit = FALSE;
HRESULT hr = S_OK;
if (!plSelected)
return E_POINTER;
*plSelected = -1;
if (cButtons < 1 || cButtons > 5)
return E_INVALIDARG;
hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!hEvent)
return HRESULT_FROM_WIN32(GetLastError());
mbt.bstrMessage = bstrMessage;
mbt.cButtons = cButtons;
mbt.bstrButtonText = bstrButtonText;
mbt.lTimeout = lTimeout;
mbt.lEventInterval = lEventInterval;
mbt.fCanCancel = (fCanCancel == VB_TRUE) ? TRUE : FALSE;
mbt.fConfirm = (fConfirm == VB_TRUE) ? TRUE : FALSE;
mbt.hEvent = hEvent;
CMessageBoxTimeout *pmbt = new CMessageBoxTimeout(&mbt);
if (!pmbt)
return E_OUTOFMEMORY;
pmbt->StartThread(NULL);
while (!fExit)
{
// Make sure it was our event being signaled that caused the loop to end
if (MessageEventPump(TRUE, 1, &hEvent) != MEP_EVENT_0)
{
hr = S_FALSE;
fExit = TRUE;
break;
}
switch (mbt.mbts)
{
case MBTS_BUTTON1:
case MBTS_BUTTON2:
case MBTS_BUTTON3:
case MBTS_BUTTON4:
case MBTS_BUTTON5:
case MBTS_TIMEOUT:
*plSelected = (long)mbt.mbts;
fExit = TRUE;
break;
case MBTS_INTERVAL:
FireEvent(DISPID_MTScript_OnMessageBoxInterval, 0, NULL);
ResetEvent(hEvent);
break;
case MBTS_ERROR:
hr = E_FAIL;
fExit = TRUE;
break;
default:
AssertSz(FALSE, "FATAL: Invalid value for mbts!");
fExit = TRUE;
break;
}
}
if (pmbt->_hwnd != NULL)
{
EndDialog(pmbt->_hwnd, 0);
}
pmbt->Release();
CloseHandle(hEvent);
return hr;
}
HRESULT
CScriptHost::RunLocalCommand(BSTR bstrCommand,
BSTR bstrDir,
BSTR bstrTitle,
VARIANT_BOOL fMinimize,
VARIANT_BOOL fGetOutput,
VARIANT_BOOL fWait,
VARIANT_BOOL fNoCrashPopup,
VARIANT_BOOL fNoEnviron,
long * plErrorCode)
{
VERIFY_THREAD();
CProcessThread *pProc;
PROCESS_PARAMS pp;
if (!_fIsPrimaryScript)
MessageEventPump(FALSE);
if (!plErrorCode)
return E_POINTER;
pp.pszCommand = bstrCommand;
pp.pszDir = bstrDir;
pp.pszTitle = bstrTitle;
pp.fMinimize = (fMinimize == VB_TRUE) ? TRUE : FALSE;
pp.fGetOutput = (fGetOutput == VB_TRUE) ? TRUE : FALSE;
pp.fNoCrashPopup = (fNoCrashPopup == VB_TRUE) ? TRUE : FALSE;
pp.fNoEnviron = (fNoEnviron == VB_TRUE) ? TRUE : FALSE;
_hrLastRunLocalError = S_OK;
pProc = new CProcessThread(this);
if (!pProc)
{
_hrLastRunLocalError = E_OUTOFMEMORY;
*plErrorCode = 0;
return S_FALSE;
}
_hrLastRunLocalError = pProc->StartThread(&pp);
if (FAILED(_hrLastRunLocalError))
{
*plErrorCode = 0;
pProc->Release();
// Don't cause a script error by returning a failure code.
return S_FALSE;
}
_pMT->AddProcess(pProc);
if (fWait == VB_TRUE)
{
HANDLE hEvent = pProc->hThread();
// The actual return code here doesn't matter. We'll do the same thing
// no matter what causes MessageEventPump to exit.
MessageEventPump(TRUE, 1, &hEvent);
}
TraceTag((tagProcess, "RunLocalCommand PID=%d, %s", pProc->ProcId(), bstrCommand));
*plErrorCode = pProc->ProcId();
return S_OK;
}
HRESULT
CScriptHost::GetLastRunLocalError(long *plErrorCode)
{
VERIFY_THREAD();
*plErrorCode = _hrLastRunLocalError;
return S_OK;
}
HRESULT
CScriptHost::GetProcessOutput(long lProcessID, BSTR *pbstrData)
{
VERIFY_THREAD();
CProcessThread *pProc;
pProc = _pMT->FindProcess((DWORD)lProcessID);
if (!pProc)
{
return E_INVALIDARG;
}
return pProc->GetProcessOutput(pbstrData);
}
HRESULT
CScriptHost::GetProcessExitCode(long lProcessID, long *plExitCode)
{
VERIFY_THREAD();
CProcessThread *pProc;
pProc = _pMT->FindProcess((DWORD)lProcessID);
if (!pProc)
{
return E_INVALIDARG;
}
*plExitCode = pProc->GetExitCode();
return S_OK;
}
HRESULT
CScriptHost::TerminateProcess(long lProcessID)
{
VERIFY_THREAD();
CProcessThread *pProc;
pProc = _pMT->FindProcess((DWORD)lProcessID);
if (!pProc)
{
return E_INVALIDARG;
}
PostToThread(pProc, MD_PLEASEEXIT);
return S_OK;
}
HRESULT
CScriptHost::SendToProcess(long lProcessID,
BSTR bstrType,
BSTR bstrData,
long *plReturn)
{
VERIFY_THREAD();
MACHPROC_EVENT_DATA med;
MACHPROC_EVENT_DATA *pmed;
VARIANT vRet;
HRESULT hr = S_OK;
CProcessThread *pProc;
pProc = _pMT->FindProcess((DWORD)lProcessID);
//$ TODO -- Fix these error return codes to not cause script errors.
if (!pProc || !plReturn)
{
return E_INVALIDARG;
}
else if (pProc->GetExitCode() != STILL_ACTIVE)
{
*plReturn = -1;
return S_FALSE;
}
VariantInit(&vRet);
med.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (med.hEvent == NULL)
{
return HRESULT_FROM_WIN32(GetLastError());
}
med.bstrCmd = bstrType;
med.bstrParams = bstrData;
med.dwProcId = (DWORD)lProcessID;
med.pvReturn = &vRet;
med.dwGITCookie = 0;
med.hrReturn = S_OK;
pmed = &med;
PostToThread(_pMT, MD_SENDTOPROCESS, &pmed, sizeof(MACHPROC_EVENT_DATA*));
// BUGBUG - we could get a crash if something causes us to exit before
// the CMTScript thread handles the MD_SENDTOPROCESS message.
MessageEventPump(TRUE, 1, &med.hEvent);
hr = med.hrReturn;
*plReturn = V_I4(&vRet);
VariantClear(&vRet);
CloseHandle(med.hEvent);
return hr;
}
#define USERPROFILESTRING_SZ (256 * sizeof(TCHAR))
TCHAR UserProfileString[USERPROFILESTRING_SZ];
HRESULT
CScriptHost::SendMail(BSTR bstrTo,
BSTR bstrCC,
BSTR bstrBCC,
BSTR bstrSubject,
BSTR bstrMessage,
BSTR bstrAttachmentPath,
BSTR bstrUsername,
BSTR bstrPassword,
long * plErrorCode)
{
// This implementation was stolen from the execmail.exe source code.
// Handles to MAPI32.DLL library, host name registry key, email session.
//$ FUTURE -- Cache this stuff instead of reloading the library every
// time.
HINSTANCE hLibrary;
LHANDLE hSession;
// Function pointers for MAPI calls we use.
LPMAPILOGON fnMAPILogon;
LPMAPISENDMAIL fnMAPISendMail;
LPMAPILOGOFF fnMAPILogoff;
// MAPI structures and counters.
MapiRecipDesc rgRecipDescStruct[30];
MapiMessage MessageStruct = {0, NULL, NULL, NULL, NULL, NULL, 0, NULL, 0, NULL, 0, NULL};
MapiFileDesc MAPIFileDesc = {0, 0, 0, NULL, NULL, NULL};
FLAGS MAPIFlags = MAPI_NEW_SESSION;
// Pointers to email parameter strings.
char *pszToList = NULL;
char *pszCCList = NULL;
char *pszBCCList = NULL;
ULONG ulErrorCode;
if (!plErrorCode)
return E_POINTER;
///////////////////////////////////////////////////////////////////////////
// No point going any farther if MAPI32.DLL isn't available.
hLibrary = LoadLibrary(L"MAPI32.DLL");
if (hLibrary == NULL)
{
DWORD dwError = GetLastError();
TraceTag((tagError, "Error: MAPI32.DLL not found on this machine!"));
*plErrorCode = HRESULT_FROM_WIN32(dwError);
return S_FALSE;
}
// Must convert all parameters to ANSI
ANSIString szTo(bstrTo);
ANSIString szCC(bstrCC);
ANSIString szBCC(bstrBCC);
ANSIString szSubject(bstrSubject);
ANSIString szMessage(bstrMessage);
ANSIString szAttachment(bstrAttachmentPath);
ANSIString szUsername(bstrUsername);
ANSIString szPassword(bstrPassword);
// Set up MAPI function pointers.
fnMAPILogon = (LPMAPILOGON)GetProcAddress(hLibrary, "MAPILogon");
fnMAPISendMail = (LPMAPISENDMAIL)GetProcAddress(hLibrary, "MAPISendMail");
fnMAPILogoff = (LPMAPILOGOFF)GetProcAddress(hLibrary, "MAPILogoff");
// Hook the recipient structure array into the message structure.
MessageStruct.lpRecips = rgRecipDescStruct;
// Get the default user parameters if none were specified.
if (SysStringLen(bstrUsername) == 0)
{
HKEY hkey;
WCHAR KeyPath[] = L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows Messaging Subsystem\\Profiles";
WCHAR Value[] = L"DefaultProfile";
DWORD buf_sz = USERPROFILESTRING_SZ;
DWORD val_type;
if( RegOpenKeyEx( HKEY_CURRENT_USER, KeyPath, 0, KEY_READ, &hkey ) == ERROR_SUCCESS )
{
if ( RegQueryValueEx( hkey, Value, NULL, &val_type, (BYTE*)UserProfileString, &buf_sz ) == ERROR_SUCCESS )
{
if ( val_type == REG_SZ )
{
szUsername.Set(UserProfileString);
}
}
RegCloseKey( hkey );
}
}
pszToList = szTo;
// Parse ToList into rgRecipDescStruct.
while (*pszToList && (MessageStruct.nRecipCount < 30))
{
// Strip leading spaces from recipient name and terminate preceding
// name string.
if (isspace(*pszToList))
{
*pszToList=0;
pszToList++;
}
// Add a name to the array and increment the number of recipients.
else
{
rgRecipDescStruct[MessageStruct.nRecipCount].ulReserved = 0;
rgRecipDescStruct[MessageStruct.nRecipCount].ulRecipClass = MAPI_TO;
rgRecipDescStruct[MessageStruct.nRecipCount].lpszName = pszToList;
rgRecipDescStruct[MessageStruct.nRecipCount].lpszAddress = NULL;
rgRecipDescStruct[MessageStruct.nRecipCount].ulEIDSize = 0;
rgRecipDescStruct[MessageStruct.nRecipCount].lpEntryID = NULL;
MessageStruct.nRecipCount++;
// Move beginning of string to next name in ToList.
do
{
pszToList++;
} while (isgraph(*pszToList));
}
}
pszCCList = szCC;
// Parse CCList into rgRecipDescStruct.
while (*pszCCList && (MessageStruct.nRecipCount < 30))
{
// Strip leading spaces from recipient name and terminate preceding
// name string.
if (isspace(*pszCCList))
{
*pszCCList=0;
pszCCList++;
}
// Add a name to the array and increment the number of recipients.
else
{
rgRecipDescStruct[MessageStruct.nRecipCount].ulReserved = 0;
rgRecipDescStruct[MessageStruct.nRecipCount].ulRecipClass = MAPI_CC;
rgRecipDescStruct[MessageStruct.nRecipCount].lpszName = pszCCList;
rgRecipDescStruct[MessageStruct.nRecipCount].lpszAddress = NULL;
rgRecipDescStruct[MessageStruct.nRecipCount].ulEIDSize = 0;
rgRecipDescStruct[MessageStruct.nRecipCount].lpEntryID = NULL;
MessageStruct.nRecipCount++;
// Move beginning of string to next name in CCList.
do
{
pszCCList++;
} while (isgraph(*pszCCList));
}
}
pszBCCList = szBCC;
// Parse BCCList into rgRecipDescStruct.
while (*pszBCCList && (MessageStruct.nRecipCount < 30))
{
// Strip leading spaces from recipient name and terminate preceding
// name string.
if (isspace(*pszBCCList))
{
*pszBCCList=0;
pszBCCList++;
}
// Add a name to the array and increment the number of recipients.
else
{
rgRecipDescStruct[MessageStruct.nRecipCount].ulReserved = 0;
rgRecipDescStruct[MessageStruct.nRecipCount].ulRecipClass = MAPI_BCC;
rgRecipDescStruct[MessageStruct.nRecipCount].lpszName = pszBCCList;
rgRecipDescStruct[MessageStruct.nRecipCount].lpszAddress = NULL;
rgRecipDescStruct[MessageStruct.nRecipCount].ulEIDSize = 0;
rgRecipDescStruct[MessageStruct.nRecipCount].lpEntryID = NULL;
MessageStruct.nRecipCount++;
// Move beginning of string to next name in BCCList.
do
{
pszBCCList++;
} while (isgraph(*pszBCCList));
}
}
if (strlen(szAttachment) > 0)
{
MAPIFileDesc.ulReserved = 0;
MAPIFileDesc.flFlags = 0;
MAPIFileDesc.nPosition = 0;
MAPIFileDesc.lpszPathName = szAttachment;
MAPIFileDesc.lpszFileName = NULL;
MAPIFileDesc.lpFileType = NULL;
MessageStruct.nFileCount = 1;
MessageStruct.lpFiles = &MAPIFileDesc;
// muck around with the message text (The attachment
// will be attached at the beginning of the mail message
// but it replaces the character at that position)
// BUGBUG -- Do we need to do this? (lylec)
//strcpy(szMessageText," \n");
}
MessageStruct.lpszSubject = szSubject;
MessageStruct.lpszNoteText = szMessage;
*plErrorCode = 0;
// Send the message!
ulErrorCode = fnMAPILogon(0L, szUsername, szPassword, MAPIFlags, 0L, &hSession);
if (ulErrorCode != SUCCESS_SUCCESS)
{
*plErrorCode = (long)ulErrorCode;
}
else
{
ulErrorCode = fnMAPISendMail(hSession, 0L, &MessageStruct, 0L, 0L);
if (ulErrorCode != SUCCESS_SUCCESS)
{
*plErrorCode = (long)ulErrorCode;
}
fnMAPILogoff(hSession, 0L, 0L, 0L);
}
FreeLibrary(hLibrary);
return S_OK;
}
HRESULT
CScriptHost::OUTPUTDEBUGSTRING(BSTR bstrMessage)
{
VERIFY_THREAD();
if (!_fIsPrimaryScript)
MessageEventPump(FALSE);
TCHAR szText[ (MSGDATABUFSIZE-1) / sizeof(TCHAR) ];
CScriptSite *site = GetSite();
const TCHAR *pszScriptName = L"";
if (site)
{
pszScriptName = _tcsrchr((LPTSTR)site->_cstrName, _T('\\'));
if (!pszScriptName)
pszScriptName = (LPTSTR)site->_cstrName;
}
int cChars = _snwprintf(szText, ARRAY_SIZE(szText), L"%.12s \t%s", pszScriptName, bstrMessage);
szText[ARRAY_SIZE(szText) - 1] = 0;
if (cChars < 0)
cChars = ARRAY_SIZE(szText);
else
cChars++;
PostToThread(_pMT,
MD_OUTPUTDEBUGSTRING,
szText,
cChars * sizeof(TCHAR));
return S_OK;
}
HRESULT
CScriptHost::UnevalString(BSTR bstrInput, BSTR *pbstrOutput)
{
int nInputLength = SysStringLen(bstrInput);
OLECHAR tmpBuf[512];
OLECHAR *pTmp = 0;
OLECHAR *pOutputBuffer;
*pbstrOutput = 0;
if (sizeof(OLECHAR) * (nInputLength * 2 + 2) > sizeof(tmpBuf))
{
pTmp = (OLECHAR *)MemAlloc(sizeof(OLECHAR) * (nInputLength * 2 + 2));
if (!pTmp)
return E_OUTOFMEMORY;
pOutputBuffer = pTmp;
}
else
{
pOutputBuffer = tmpBuf;
}
int j = 0;
pOutputBuffer[j++] = L'"';
for(OLECHAR *pInputEnd = bstrInput + nInputLength; bstrInput < pInputEnd; ++bstrInput)
{
switch(*bstrInput)
{
case L'\\':
case L'"':
case L'\'':
pOutputBuffer[j] = L'\\';
pOutputBuffer[j+1] = *bstrInput;
j += 2;
break;
case L'\n':
pOutputBuffer[j] = L'\\';
pOutputBuffer[j+1] = L'n';
j += 2;
break;
case L'\r':
pOutputBuffer[j] = L'\\';
pOutputBuffer[j+1] = L'r';
j += 2;
break;
case L'\t':
pOutputBuffer[j] = L'\\';
pOutputBuffer[j+1] = L't';
j += 2;
break;
default:
pOutputBuffer[j++] = *bstrInput;
break;
}
}
pOutputBuffer[j++] = L'"';
*pbstrOutput = SysAllocStringLen(pOutputBuffer, j);
if (pTmp)
MemFree(pTmp);
if (!*pbstrOutput)
return E_OUTOFMEMORY;
return S_OK;
}
HRESULT
CScriptHost::CopyOrAppendFile(BSTR bstrSrc,
BSTR bstrDst,
long nSrcOffset,
long nSrcLength,
VARIANT_BOOL fAppend,
long *pnSrcFilePosition)
{
HRESULT hr = S_OK;
HANDLE hDst = INVALID_HANDLE_VALUE;
HANDLE hSrcFile = INVALID_HANDLE_VALUE;
BY_HANDLE_FILE_INFORMATION fi = {0};
long nEndPos;
long nLen;
DWORD nBytesRead;
DWORD nBytesWritten;
char rgBuffer[4096];
hDst = CreateFile(
bstrDst,
GENERIC_WRITE,
FILE_SHARE_READ,
0,
(fAppend ? OPEN_ALWAYS : CREATE_ALWAYS),
FILE_ATTRIBUTE_NORMAL,
0);
if (hDst == INVALID_HANDLE_VALUE)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
hSrcFile = CreateFile(bstrSrc,
GENERIC_READ,
FILE_SHARE_WRITE,
0,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
0);
if (hSrcFile == INVALID_HANDLE_VALUE)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
GetFileInformationByHandle(hSrcFile, &fi);
if (fi.nFileSizeHigh != 0 || (fi.nFileSizeLow & 0x80000000) != 0)
{
hr = E_FAIL;//HRESULT_FROM_WIN32(?????);
goto Cleanup;
}
if (nSrcLength == -1)
nEndPos = (long)fi.nFileSizeLow;
else
{
if ( ((_int64)nSrcOffset + nSrcLength) > 0x7f000000)
{
hr = E_INVALIDARG;
goto Cleanup;
}
nEndPos = nSrcOffset + nSrcLength;
}
if (nEndPos > (long)fi.nFileSizeLow)
nEndPos = (long)fi.nFileSizeLow;
if (SetFilePointer(hSrcFile, nSrcOffset, 0, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
if (SetFilePointer(hDst, 0, 0, FILE_END) == INVALID_SET_FILE_POINTER)
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
while (nSrcOffset < nEndPos)
{
nLen = nEndPos - nSrcOffset;
if (nLen > sizeof(rgBuffer))
nLen = sizeof(rgBuffer);
if (!ReadFile(hSrcFile, rgBuffer, nLen, &nBytesRead, 0))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
if (!WriteFile(hDst, rgBuffer, nBytesRead, &nBytesWritten, 0))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto Cleanup;
}
nSrcOffset += nBytesRead;
}
if (pnSrcFilePosition)
*pnSrcFilePosition = nSrcOffset;
Cleanup:
if (hDst != INVALID_HANDLE_VALUE)
CloseHandle(hDst);
if (hSrcFile != INVALID_HANDLE_VALUE)
CloseHandle(hSrcFile);
return hr;
}
HRESULT
CScriptHost::ASSERT(VARIANT_BOOL fAssert, BSTR bstrMessage)
{
VERIFY_THREAD();
if (!_fIsPrimaryScript)
MessageEventPump(FALSE);
if (!fAssert)
{
CHAR ach[1024];
// Add name of currently executing script to the assert message.
if (!GetSite() || !GetSite()->_achPath[0])
{
ach[0] = 0;
}
else
{
// Try to chop off directory name.
TCHAR * pchName = wcsrchr(GetSite()->_achPath, _T('\\'));
if (pchName)
pchName += 1;
else
pchName = GetSite()->_achPath;
WideCharToMultiByte(
CP_ACP,
0,
pchName,
-1,
ach,
MAX_PATH,
NULL,
NULL);
strcat(ach, ": ");
}
// Add message to the assert.
if (!bstrMessage || !*bstrMessage)
{
strcat(ach, "MTScript Script Assert");
}
else
{
WideCharToMultiByte(
CP_ACP,
0,
bstrMessage,
-1,
&ach[strlen(ach)],
ARRAY_SIZE(ach) - MAX_PATH - 3,
NULL,
NULL);
}
#if DBG == 1
AssertSz(FALSE, ach);
#else
if (MessageBoxA(NULL, ach, "MTScript Script Assert", MB_OKCANCEL | MB_SETFOREGROUND) == IDCANCEL)
return E_FAIL;
#endif
}
return S_OK;
}
HRESULT
CScriptHost::Sleep (int nTimeout)
{
VERIFY_THREAD();
MessageEventPump(TRUE, 0, NULL, FALSE, (DWORD)nTimeout);
return S_OK;
}
HRESULT
CScriptHost::Reboot()
{
VERIFY_THREAD();
PostToThread(_pMT, MD_REBOOT);
return S_OK;
}
HRESULT
CScriptHost::NotifyScript(BSTR bstrEvent, VARIANT vData)
{
HRESULT hr = S_OK;
VARIANT *pvar;
VERIFY_THREAD();
// Check for data types which we don't support.
if ( V_ISBYREF(&vData)
|| V_ISARRAY(&vData)
|| V_ISVECTOR(&vData)
|| V_VT(&vData) == VT_DISPATCH //$ FUTURE: Support this later
|| V_VT(&vData) == VT_UNKNOWN)
{
return E_INVALIDARG;
}
if (!_pMT->_pMachine)
{
return S_OK;
}
pvar = new VARIANT[2];
VariantInit(&pvar[0]);
VariantInit(&pvar[1]);
V_VT(&pvar[0]) = VT_BSTR;
V_BSTR(&pvar[0]) = SysAllocString(bstrEvent);
VariantCopy(&pvar[1], &vData);
PostToThread(_pMT->_pMachine, MD_NOTIFYSCRIPT, &pvar, sizeof(VARIANT*));
return hr;
}
HRESULT
CScriptHost::RegisterEventSource(IDispatch *pDisp, BSTR bstrProgID)
{
HRESULT hr;
CScriptEventSink *pSink = NULL;
pSink = new CScriptEventSink(this);
if (!pSink)
return E_OUTOFMEMORY;
hr = pSink->Connect(pDisp, bstrProgID);
if (!hr)
{
_aryEvtSinks.Append(pSink);
}
else
pSink->Release();
return hr;
}
HRESULT
CScriptHost::UnregisterEventSource(IDispatch *pDisp)
{
int i;
BOOL fFound = FALSE;
for (i = 0; i < _aryEvtSinks.Size(); i++)
{
if (_aryEvtSinks[i]->IsThisYourSource(pDisp))
{
_aryEvtSinks[i]->Disconnect();
_aryEvtSinks.ReleaseAndDelete(i);
fFound = TRUE;
break;
}
}
return (fFound) ? S_OK : E_INVALIDARG;
}
HRESULT
CScriptHost::get_HostMajorVer(long *plMajorVer)
{
if (!plMajorVer)
return E_POINTER;
*plMajorVer = IConnectedMachine_lVersionMajor;
return S_OK;
}
HRESULT
CScriptHost::get_HostMinorVer(long *plMinorVer)
{
if (!plMinorVer)
return E_POINTER;
*plMinorVer = IConnectedMachine_lVersionMinor;
return S_OK;
}
HRESULT CScriptHost::get_StatusValue(long nIndex, long *pnStatus)
{
return _pMT->get_StatusValue(nIndex, pnStatus);
}
HRESULT CScriptHost::put_StatusValue(long nIndex, long nStatus)
{
return _pMT->put_StatusValue(nIndex, nStatus);
}
Reference in a new issue Copy permalink