1970 lines
48 KiB
C++
1970 lines
48 KiB
C++
//+------------------------------------------------------------------------
|
|
//
|
|
// 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);
|
|
}
|
|
|