HRESULT variant_to_jsval(VARIANT *var, jsval_t *r)
{
if(V_VT(var) == (VT_VARIANT|VT_BYREF))
var = V_VARIANTREF(var);
switch(V_VT(var)) {
case VT_EMPTY:
*r = jsval_undefined();
return S_OK;
case VT_NULL:
*r = jsval_null();
return S_OK;
case VT_BOOL:
*r = jsval_bool(V_BOOL(var));
return S_OK;
case VT_I4:
*r = jsval_number(V_I4(var));
return S_OK;
case VT_R8:
*r = jsval_number(V_R8(var));
return S_OK;
case VT_BSTR: {
jsstr_t *str;
if(V_BSTR(var)) {
str = jsstr_alloc_len(V_BSTR(var), SysStringLen(V_BSTR(var)));
if(!str)
return E_OUTOFMEMORY;
}else {
str = jsstr_null_bstr();
}
*r = jsval_string(str);
return S_OK;
}
case VT_DISPATCH: {
if(V_DISPATCH(var))
IDispatch_AddRef(V_DISPATCH(var));
*r = jsval_disp(V_DISPATCH(var));
return S_OK;
}
case VT_I2:
*r = jsval_number(V_I2(var));
return S_OK;
case VT_UI2:
*r = jsval_number(V_UI2(var));
return S_OK;
case VT_INT:
*r = jsval_number(V_INT(var));
return S_OK;
case VT_UI4:
*r = jsval_number(V_UI4(var));
return S_OK;
case VT_UI8:
/*
* Native doesn't support VT_UI8 here, but it's needed for IE9+ APIs
* (native IE9 doesn't use jscript.dll for JavaScript).
*/
*r = jsval_number(V_UI8(var));
return S_OK;
case VT_R4:
*r = jsval_number(V_R4(var));
return S_OK;
case VT_UNKNOWN:
if(V_UNKNOWN(var)) {
IDispatch *disp;
HRESULT hres;
hres = IUnknown_QueryInterface(V_UNKNOWN(var), &IID_IDispatch, (void**)&disp);
if(SUCCEEDED(hres)) {
*r = jsval_disp(disp);
return S_OK;
}
}else {
*r = jsval_disp(NULL);
return S_OK;
}
/* fall through */
default:
return jsval_variant(r, var);
}
}
static void test_mxwriter_flush(void)
{
ISAXContentHandler *content;
IMXWriter *writer;
LARGE_INTEGER pos;
ULARGE_INTEGER pos2;
IStream *stream;
VARIANT dest;
HRESULT hr;
hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER,
&IID_IMXWriter, (void**)&writer);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
EXPECT_REF(stream, 1);
/* detach whe nothing was attached */
V_VT(&dest) = VT_EMPTY;
hr = IMXWriter_put_output(writer, dest);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
/* attach stream */
V_VT(&dest) = VT_UNKNOWN;
V_UNKNOWN(&dest) = (IUnknown*)stream;
hr = IMXWriter_put_output(writer, dest);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
todo_wine EXPECT_REF(stream, 3);
/* detach setting VT_EMPTY destination */
V_VT(&dest) = VT_EMPTY;
hr = IMXWriter_put_output(writer, dest);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
EXPECT_REF(stream, 1);
V_VT(&dest) = VT_UNKNOWN;
V_UNKNOWN(&dest) = (IUnknown*)stream;
hr = IMXWriter_put_output(writer, dest);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
/* flush() doesn't detach a stream */
hr = IMXWriter_flush(writer);
todo_wine {
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
EXPECT_REF(stream, 3);
}
pos.QuadPart = 0;
hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(pos2.QuadPart == 0, "expected stream beginning\n");
hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content);
ok(hr == S_OK, "got %08x\n", hr);
hr = ISAXContentHandler_startDocument(content);
ok(hr == S_OK, "got %08x\n", hr);
pos.QuadPart = 0;
hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
todo_wine ok(pos2.QuadPart != 0, "expected stream beginning\n");
/* already started */
hr = ISAXContentHandler_startDocument(content);
ok(hr == S_OK, "got %08x\n", hr);
hr = ISAXContentHandler_endDocument(content);
todo_wine ok(hr == S_OK, "got %08x\n", hr);
/* flushed on endDocument() */
pos.QuadPart = 0;
hr = IStream_Seek(stream, pos, STREAM_SEEK_CUR, &pos2);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
todo_wine ok(pos2.QuadPart != 0, "expected stream position moved\n");
ISAXContentHandler_Release(content);
IStream_Release(stream);
IMXWriter_Release(writer);
}
static void
ole_set_byref(VARIANT *realvar, VARIANT *var, VARTYPE vt)
{
V_VT(var) = vt;
if (vt == (VT_VARIANT|VT_BYREF)) {
V_VARIANTREF(var) = realvar;
} else {
if (V_VT(realvar) != (vt & ~VT_BYREF)) {
rb_raise(eWIN32OLERuntimeError, "variant type mismatch");
}
switch(vt & ~VT_BYREF) {
case VT_I1:
V_I1REF(var) = &V_I1(realvar);
break;
case VT_UI1:
V_UI1REF(var) = &V_UI1(realvar);
break;
case VT_I2:
V_I2REF(var) = &V_I2(realvar);
break;
case VT_UI2:
V_UI2REF(var) = &V_UI2(realvar);
break;
case VT_I4:
V_I4REF(var) = &V_I4(realvar);
break;
case VT_UI4:
V_UI4REF(var) = &V_UI4(realvar);
break;
case VT_R4:
V_R4REF(var) = &V_R4(realvar);
break;
case VT_R8:
V_R8REF(var) = &V_R8(realvar);
break;
#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
#ifdef V_I8REF
case VT_I8:
V_I8REF(var) = &V_I8(realvar);
break;
#endif
#ifdef V_UI8REF
case VT_UI8:
V_UI8REF(var) = &V_UI8(realvar);
break;
#endif
#endif
case VT_INT:
V_INTREF(var) = &V_INT(realvar);
break;
case VT_UINT:
V_UINTREF(var) = &V_UINT(realvar);
break;
case VT_CY:
V_CYREF(var) = &V_CY(realvar);
break;
case VT_DATE:
V_DATEREF(var) = &V_DATE(realvar);
break;
case VT_BSTR:
V_BSTRREF(var) = &V_BSTR(realvar);
break;
case VT_DISPATCH:
V_DISPATCHREF(var) = &V_DISPATCH(realvar);
break;
case VT_ERROR:
V_ERRORREF(var) = &V_ERROR(realvar);
break;
case VT_BOOL:
V_BOOLREF(var) = &V_BOOL(realvar);
break;
case VT_UNKNOWN:
V_UNKNOWNREF(var) = &V_UNKNOWN(realvar);
break;
case VT_ARRAY:
V_ARRAYREF(var) = &V_ARRAY(realvar);
break;
default:
rb_raise(eWIN32OLERuntimeError, "unknown type specified(setting BYREF):%d", vt);
break;
}
}
}
STDMETHODIMP CXMLDOMDocument::load(VARIANT xmlSource, VARIANT_BOOL *isSuccessful)
{
ATLTRACE(_T("CXMLDOMDocument::load\n"));
if (NULL == isSuccessful)
return E_POINTER;
*isSuccessful = VARIANT_FALSE;
if (V_VT(&xmlSource) != VT_BSTR &&
V_VT(&xmlSource) != VT_DISPATCH &&
V_VT(&xmlSource) != (VT_ARRAY | VT_VARIANT) &&
V_VT(&xmlSource) != (VT_ARRAY | VT_UI1) &&
V_VT(&xmlSource) != VT_UNKNOWN)
return E_INVALIDARG;
// do not start another thread if there is another active
if (NULL != m_hParseThread) {
DWORD exitCode = 0;
BOOL rc = ::GetExitCodeThread(m_hParseThread, &exitCode);
if (!rc || STILL_ACTIVE == exitCode)
return S_OK;
::CloseHandle(m_hParseThread);
m_hParseThread = NULL;
}
HRESULT hr = S_OK;
m_bAbort = false;
m_FileName = _T("");
m_xml = _T("");
m_TmpDocument = 0;
m_bThreadValidate = m_bValidate;
if (V_VT(&xmlSource) == VT_BSTR) {
m_FileName = V_BSTR(&xmlSource);
if (0 == m_FileName.length())
return E_INVALIDARG;
// see if the file is relative path
if (!PathIsURL(m_FileName) && PathIsRelative(m_FileName)) {
// try appending baseurl if exists
_bstr_t baseURL;
if (S_OK == GetBaseURL(baseURL)) {
// change any backslashes to slashes
LPTSTR loc = _tcschr(m_FileName,_T('\\'));
while (loc != NULL) {
*loc = _T('/');
loc = _tcschr(m_FileName,_T('\\'));
}
m_FileName = baseURL + _T("/") + m_FileName;
}
else {
TCHAR szCurDir[MAX_PATH];
GetCurrentDirectory(MAX_PATH,szCurDir);
m_FileName=_bstr_t(szCurDir) + _T("\\") + m_FileName;
}
}
}
else
if (V_VT(&xmlSource) == VT_UNKNOWN) {
CComQIPtr<IStream,&IID_IStream> pS(V_UNKNOWN(&xmlSource));
if (!pS)
return E_INVALIDARG;
CComBSTR b;
hr = b.ReadFromStream(pS);
if (S_OK != hr)
return hr;
m_xml = b;
if (0 == m_xml.length())
return E_INVALIDARG;
}
else
if (V_VT(&xmlSource) == VT_DISPATCH) {
CComQIPtr<IXMLDOMDocument,&IID_IXMLDOMDocument> pDoc(V_DISPATCH(&xmlSource));
if (!pDoc)
return E_INVALIDARG;
BSTR b = NULL;
hr = pDoc->get_xml(&b);
if (S_OK != hr)
return hr;
m_xml = b;
::SysFreeString(b);
if (0 == m_xml.length())
return E_INVALIDARG;
}
else
if (V_VT(&xmlSource) == (VT_ARRAY | VT_VARIANT)) {
SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (xmlSource.byref);
if (NULL == pArray)
return E_INVALIDARG;
long lLBoundVar = 0;
long lUBoundVar = 0;
UINT dims = ::SafeArrayGetDim(pArray);
if (dims == 0)
return E_INVALIDARG;
hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
if (S_OK != hr)
return hr;
hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
if (S_OK != hr)
return hr;
if (lUBoundVar >= lLBoundVar) {
VARIANT *pIndex = NULL;
hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
if (S_OK != hr)
return hr;
int length = lUBoundVar-lLBoundVar+2;
BYTE *body = new BYTE[length];
for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i) {
VARIANT var = pIndex[i];
if (V_VT(&var) != VT_UI1) {
hr = E_INVALIDARG;
break;
}
body[i] = V_UI1(&var);
}
body[length-1] = 0;
::SafeArrayUnaccessData(pArray);
if (S_OK != hr) {
delete [] body;
return hr;
}
m_xml = reinterpret_cast<char*> (body);
delete [] body;
if (0 == m_xml.length())
return E_INVALIDARG;
}
}
else
if (V_VT(&xmlSource) == (VT_ARRAY | VT_UI1)) {
SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (xmlSource.byref);
if (NULL == pArray)
return E_INVALIDARG;
long lLBoundVar = 0;
long lUBoundVar = 0;
UINT dims = ::SafeArrayGetDim(pArray);
if (dims == 0)
return E_INVALIDARG;
hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
if (S_OK != hr)
return hr;
hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
if (S_OK != hr)
return hr;
if (lUBoundVar >= lLBoundVar) {
BYTE *pIndex = NULL;
hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
if (S_OK != hr)
return hr;
int length = lUBoundVar-lLBoundVar+2;
BYTE *body = new BYTE[length];
for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i)
body[i] = pIndex[i];
body[length-1] = 0;
::SafeArrayUnaccessData(pArray);
m_xml = reinterpret_cast<char*> (body);
delete [] body;
if (0 == m_xml.length())
return E_INVALIDARG;
}
}
UINT nthreadID = 0;
m_hParseThread = reinterpret_cast<HANDLE> (_beginthreadex(NULL,
0,
CXMLDOMDocument::ParseThread,
(void *) this,
0,
&nthreadID));
if (NULL == m_hParseThread)
return S_OK;
if (m_bAsync) {
*isSuccessful = VARIANT_TRUE;
return S_OK;
}
bool bWait = true;
while (bWait) {
DWORD dwEvt = MsgWaitForMultipleObjects(1,&m_hParseThread,FALSE,INFINITE,QS_ALLINPUT);
switch(dwEvt) {
case WAIT_OBJECT_0:
bWait = false;
break;
case WAIT_OBJECT_0 + 1:
{
MSG msg;
while(::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
if (WM_CLOSE == msg.message || WM_QUIT == msg.message) {
bWait = false;
m_bAbort = true;
break;
}
else {
PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
break;
}
default:
m_bAbort = true;
bWait = false;
break;
}
}
if (m_bAbort)
return S_OK;
if (m_bParseError)
return hr;
if(m_Document)
delete m_Document;
m_Document = m_TmpDocument;
m_TmpDocument = 0;
m_url = m_FileName;
*isSuccessful = VARIANT_TRUE;
return hr;
}
STDMETHODIMP CXMLHttpRequest::send(VARIANT varBody)
{
ATLTRACE(_T("CXMLHttpRequest::send\n"));
if (V_VT(&varBody) != VT_BSTR &&
V_VT(&varBody) != VT_DISPATCH &&
V_VT(&varBody) != (VT_ARRAY | VT_VARIANT) &&
V_VT(&varBody) != (VT_ARRAY | VT_UI1) &&
V_VT(&varBody) != VT_UNKNOWN)
return E_INVALIDARG;
// do not start another thread if there is another active
if (NULL != m_hThread) {
DWORD exitCode = 0;
BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
if (!rc || STILL_ACTIVE == exitCode)
return E_PENDING;
::CloseHandle(m_hThread);
m_hThread = NULL;
}
HRESULT hr = S_OK;
m_bSuccess = true;
m_bAbort = false;
delete [] m_pBody;
m_pBody = NULL;
m_lBodyLength = 0;
delete [] m_pResponseBody;
m_pResponseBody = NULL;
m_lResponseBodyLength = 0;
m_dwStatus = 0;
m_StatusText = _T("");
m_ResponseHeaders = _T("");
if (V_VT(&varBody) == VT_BSTR) {
_bstr_t body = V_BSTR(&varBody);
m_lBodyLength = body.length() + 1;
m_pBody = new BYTE[m_lBodyLength];
memset(m_pBody,0,m_lBodyLength);
memcpy(m_pBody,static_cast<char*> (body),body.length());
}
else
if (V_VT(&varBody) == VT_UNKNOWN) {
CComQIPtr<IStream,&IID_IStream> pS(V_UNKNOWN(&varBody));
if (!pS)
return E_INVALIDARG;
CComBSTR b;
hr = b.ReadFromStream(pS);
if (S_OK != hr)
return hr;
_bstr_t body = b;
m_lBodyLength = body.length() + 1;
m_pBody = new BYTE[m_lBodyLength];
memset(m_pBody,0,m_lBodyLength);
memcpy(m_pBody,static_cast<char*> (body),body.length());
}
else
if (V_VT(&varBody) == VT_DISPATCH) {
CComQIPtr<IXMLDOMDocument,&IID_IXMLDOMDocument> pDoc(V_DISPATCH(&varBody));
if (!pDoc)
return E_INVALIDARG;
BSTR b = NULL;
hr = pDoc->get_xml(&b);
if (S_OK != hr)
return hr;
_bstr_t body = b;
::SysFreeString(b);
m_lBodyLength = body.length() + 1;
m_pBody = new BYTE[m_lBodyLength];
memset(m_pBody,0,m_lBodyLength);
memcpy(m_pBody,static_cast<char*> (body),body.length());
}
else
if (V_VT(&varBody) == (VT_ARRAY | VT_VARIANT)) {
SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (varBody.byref);
if (NULL == pArray)
return E_INVALIDARG;
long lLBoundVar = 0;
long lUBoundVar = 0;
UINT dims = ::SafeArrayGetDim(pArray);
if (dims == 0)
return E_INVALIDARG;
hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
if (S_OK != hr)
return hr;
hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
if (S_OK != hr)
return hr;
if (lUBoundVar >= lLBoundVar) {
VARIANT *pIndex = NULL;
hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
if (S_OK != hr)
return hr;
m_lBodyLength = lUBoundVar-lLBoundVar+1;
m_pBody = new BYTE[m_lBodyLength];
for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i) {
VARIANT var = pIndex[i];
if (V_VT(&var) != VT_UI1) {
hr = E_INVALIDARG;
break;
}
m_pBody[i] = V_UI1(&var);
}
::SafeArrayUnaccessData(pArray);
if (S_OK != hr) {
delete [] m_pBody;
m_pBody = NULL;
m_lBodyLength = 0;
return hr;
}
}
}
else
if (V_VT(&varBody) == (VT_ARRAY | VT_UI1)) {
SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (varBody.byref);
if (NULL == pArray)
return E_INVALIDARG;
long lLBoundVar = 0;
long lUBoundVar = 0;
UINT dims = ::SafeArrayGetDim(pArray);
if (dims == 0)
return E_INVALIDARG;
hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
if (S_OK != hr)
return hr;
hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
if (S_OK != hr)
return hr;
if (lUBoundVar >= lLBoundVar) {
BYTE *pIndex = NULL;
hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
if (S_OK != hr)
return hr;
m_lBodyLength = lUBoundVar-lLBoundVar+1;
m_pBody = new BYTE[m_lBodyLength];
for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i)
m_pBody[i] = pIndex[i];
::SafeArrayUnaccessData(pArray);
}
}
m_HwndParent = GetParentWindow();
UINT nthreadID = 0;
m_hThread = reinterpret_cast<HANDLE> (_beginthreadex(NULL,
0,
CXMLHttpRequest::SendThread,
(void *) this,
0,
&nthreadID));
if (NULL == m_hThread)
return E_FAIL;
if (m_bAsync)
return S_OK;
bool bWait = true;
while (bWait) {
DWORD dwEvt = MsgWaitForMultipleObjects(1,&m_hThread,FALSE,INFINITE,QS_ALLINPUT);
switch(dwEvt) {
case WAIT_OBJECT_0:
bWait = false;
break;
case WAIT_OBJECT_0 + 1:
{
MSG msg;
while(::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
if (WM_CLOSE == msg.message || WM_QUIT == msg.message) {
bWait = false;
m_bAbort = true;
break;
}
else {
PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
break;
}
default:
m_bAbort = true;
bWait = false;
break;
}
}
return S_OK;
}
/////////////////////////////////////////////////////////////////////////////
//
// [QueryCacheMissPolicy]
//
/////////////////////////////////////////////////////////////////////////////
HRESULT STDMETHODCALLTYPE
CProxyPlugin::QueryCacheMissPolicy( BSTR bstrOriginUrl,
IWMSContext *pUserContext,
IWMSCommandContext *pCommandContext,
IWMSContext *pPresentationContext,
IUnknown *pCachePluginContext,
long QueryType,
IWMSCacheProxyCallback *pCallback,
VARIANT varContext
)
{
VARIANT varContext2;
COpState *pOpState = NULL;
HRESULT hr = S_OK;
BOOL fRet;
if( ( NULL == bstrOriginUrl) ||
( NULL == pCommandContext ) ||
( NULL == pPresentationContext ) ||
( NULL == pCallback ) )
{
return( E_INVALIDARG );
}
if( QueryType & WMS_CACHE_QUERY_REVERSE_PROXY )
{
hr = pCallback->OnQueryCacheMissPolicy( S_OK,
WMS_CACHE_QUERY_MISS_SKIP,
NULL,
NULL,
NULL,
varContext );
return( hr );
}
if( ( QueryType & WMS_CACHE_QUERY_CACHE_EVENT ) ||
( QueryType & WMS_CACHE_QUERY_GET_CONTENT_INFO ) )
{
hr = pCallback->OnQueryCacheMissPolicy( S_OK,
WMS_CACHE_QUERY_MISS_FORWARD_REQUEST,
NULL,
NULL,
NULL,
varContext );
return( hr );
}
pOpState = new COpState;
if( NULL == pOpState )
{
return( E_OUTOFMEMORY );
}
pOpState->m_Op = COpState::OP_QUERY_CACHE_MISS_POLICY;
pOpState->m_bstrOriginUrl = bstrOriginUrl;
pOpState->m_pPresentationContext = pPresentationContext;
pOpState->m_pCacheProxyCallback = pCallback;
pOpState->m_varContext = varContext;
pOpState->m_pPresentationContext->AddRef();
pOpState->m_pCacheProxyCallback->AddRef();
if( NULL == pOpState->m_bstrOriginUrl.m_str )
{
pOpState->Release();
return( E_OUTOFMEMORY );
}
fRet = ParseUrl( bstrOriginUrl,
&pOpState->m_bstrProtocol,
&pOpState->m_bstrHost,
&pOpState->m_bstrPath,
&pOpState->m_wPort );
if( !fRet )
{
pOpState->Release();
return( E_FAIL );
}
// Initiate protocol rollover by calling OnGetContentInformation with an
// appropriate HRESULT
VariantInit( &varContext2 );
V_VT( &varContext2 ) = VT_UNKNOWN;
V_UNKNOWN( &varContext2 ) = (IUnknown *) pOpState;
pOpState->m_dwProtocolIndex = -1;
OnGetContentInformation( NS_E_CONNECTION_FAILURE, NULL, varContext2 );
return( S_OK );
}
static inline HRESULT handle_xml_load(BindStatusCallback *This)
{
static const WCHAR selectW[] = {'p','r','o','c','e','s','s','i','n','g','-',
'i','n','s','t','r','u','c','t','i','o','n','(','\'','x','m','l',
'-','s','t','y','l','e','s','h','e','e','t','\'',')',0};
static const WCHAR hrefW[] = {'h','r','e','f','=',0};
IXMLDOMDocument3 *xml = NULL, *xsl = NULL;
IXMLDOMNode *stylesheet;
IBindCtx *pbc;
IMoniker *mon;
LPOLESTR xsl_url;
LARGE_INTEGER off;
VARIANT_BOOL succ;
VARIANT var;
WCHAR *href = NULL, *p;
BSTR bstr;
HRESULT hres;
off.QuadPart = 0;
hres = IStream_Seek(This->stream, off, STREAM_SEEK_SET, NULL);
if(FAILED(hres))
return display_error_page(This);
hres = DOMDocument_create(MSXML_DEFAULT, (void**)&xml);
if(FAILED(hres))
return display_error_page(This);
V_VT(&var) = VT_UNKNOWN;
V_UNKNOWN(&var) = (IUnknown*)This->stream;
hres = IXMLDOMDocument3_load(xml, var, &succ);
if(FAILED(hres) || !succ) {
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
V_VT(&var) = VT_EMPTY;
bstr = SysAllocString(selectW);
hres = IXMLDOMDocument3_selectSingleNode(xml, bstr, &stylesheet);
SysFreeString(bstr);
if(hres != S_OK) {
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
hres = IXMLDOMNode_get_nodeValue(stylesheet, &var);
IXMLDOMNode_Release(stylesheet);
if(SUCCEEDED(hres) && V_VT(&var)!=VT_BSTR) {
FIXME("Variant type %d not supported\n", V_VT(&var));
VariantClear(&var);
hres = E_FAIL;
}
if(FAILED(hres)) {
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
/* TODO: fix parsing processing instruction value */
if((p = strstrW(V_BSTR(&var), hrefW))) {
p += ARRAY_SIZE(hrefW) - 1;
if(*p!='\'' && *p!='\"') p = NULL;
else {
href = p+1;
p = strchrW(href, *p);
}
}
if(p) {
*p = 0;
} else {
VariantClear(&var);
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
hres = CreateURLMonikerEx(This->mon, href, &mon, 0);
VariantClear(&var);
if(FAILED(hres)) {
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
hres = CreateBindCtx(0, &pbc);
if(SUCCEEDED(hres)) {
hres = IMoniker_GetDisplayName(mon, pbc, NULL, &xsl_url);
IMoniker_Release(mon);
IBindCtx_Release(pbc);
}
if(FAILED(hres)) {
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = SysAllocString(xsl_url);
CoTaskMemFree(xsl_url);
if(!V_BSTR(&var)) {
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
hres = DOMDocument_create(MSXML_DEFAULT, (void**)&xsl);
if(FAILED(hres)) {
VariantClear(&var);
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
/* TODO: do the binding asynchronously */
hres = IXMLDOMDocument3_load(xsl, var, &succ);
VariantClear(&var);
if(FAILED(hres) || !succ) {
IXMLDOMDocument3_Release(xsl);
IXMLDOMDocument3_Release(xml);
return display_error_page(This);
}
hres = IXMLDOMDocument3_transformNode(xml, (IXMLDOMNode*)xsl, &bstr);
IXMLDOMDocument3_Release(xsl);
IXMLDOMDocument3_Release(xml);
if(FAILED(hres))
return display_error_page(This);
hres = IStream_Seek(This->stream, off, STREAM_SEEK_SET, NULL);
if(FAILED(hres)) {
SysFreeString(bstr);
return display_error_page(This);
}
hres = IStream_Write(This->stream, (BYTE*)bstr,
SysStringLen(bstr)*sizeof(WCHAR), NULL);
SysFreeString(bstr);
if(FAILED(hres))
return display_error_page(This);
return report_data(This);
}
void
TclObject::toVariant (VARIANT *pDest,
const Type &type,
Tcl_Interp *interp,
bool addRef)
{
VariantClear(pDest);
VARTYPE vt = type.vartype();
Reference *pReference = Extension::referenceHandles.find(interp, m_pObj);
if (pReference != 0) {
// Convert interface pointer handle to interface pointer.
if (addRef) {
// Must increment reference count of interface pointers returned
// from methods.
pReference->unknown()->AddRef();
}
IDispatch *pDispatch = pReference->dispatch();
if (pDispatch != 0) {
V_VT(pDest) = VT_DISPATCH;
V_DISPATCH(pDest) = pDispatch;
} else {
V_VT(pDest) = VT_UNKNOWN;
V_UNKNOWN(pDest) = pReference->unknown();
}
} else if (m_pObj->typePtr == &Extension::unknownPointerType) {
// Convert to interface pointer.
IUnknown *pUnknown = static_cast<IUnknown *>(
m_pObj->internalRep.otherValuePtr);
if (addRef && pUnknown != 0) {
// Must increment reference count of interface pointers returned
// from methods.
pUnknown->AddRef();
}
V_VT(pDest) = VT_UNKNOWN;
V_UNKNOWN(pDest) = pUnknown;
} else if (vt == VT_SAFEARRAY) {
const Type &elementType = type.elementType();
V_VT(pDest) = VT_ARRAY | elementType.vartype();
V_ARRAY(pDest) = getSafeArray(elementType, interp);
} else if (m_pObj->typePtr == TclTypes::listType()) {
// Convert Tcl list to array of VARIANT.
int numElements;
Tcl_Obj **pElements;
if (Tcl_ListObjGetElements(interp, m_pObj, &numElements, &pElements)
!= TCL_OK) {
_com_issue_error(E_INVALIDARG);
}
SAFEARRAYBOUND bounds[2];
bounds[0].cElements = numElements;
bounds[0].lLbound = 0;
unsigned numDimensions;
// Check if the first element of the list is a list.
if (numElements > 0 && pElements[0]->typePtr == TclTypes::listType()) {
int colSize;
Tcl_Obj **pCol;
if (Tcl_ListObjGetElements(interp, pElements[0], &colSize, &pCol)
!= TCL_OK) {
_com_issue_error(E_INVALIDARG);
}
bounds[1].cElements = colSize;
bounds[1].lLbound = 0;
numDimensions = 2;
} else {
numDimensions = 1;
}
SAFEARRAY *psa = SafeArrayCreate(VT_VARIANT, numDimensions, bounds);
std::vector<long> indices(numDimensions);
fillSafeArray(m_pObj, psa, 1, &indices[0], interp, addRef);
V_VT(pDest) = VT_ARRAY | VT_VARIANT;
V_ARRAY(pDest) = psa;
#if TCL_MINOR_VERSION >= 1
} else if (m_pObj->typePtr == TclTypes::byteArrayType()) {
// Convert Tcl byte array to SAFEARRAY of bytes.
V_VT(pDest) = VT_ARRAY | VT_UI1;
V_ARRAY(pDest) = newSafeArray(m_pObj, VT_UI1);
#endif
} else if (m_pObj->typePtr == &Extension::naType) {
// This variant indicates a missing optional argument.
VariantCopy(pDest, &vtMissing);
} else if (m_pObj->typePtr == &Extension::nullType) {
V_VT(pDest) = VT_NULL;
} else if (m_pObj->typePtr == &Extension::variantType) {
VariantCopy(
pDest,
static_cast<_variant_t *>(m_pObj->internalRep.otherValuePtr));
} else if (m_pObj->typePtr == TclTypes::intType()) {
long value;
if (Tcl_GetLongFromObj(interp, m_pObj, &value) != TCL_OK) {
value = 0;
}
V_VT(pDest) = VT_I4;
V_I4(pDest) = value;
if (vt != VT_VARIANT && vt != VT_USERDEFINED) {
VariantChangeType(pDest, pDest, 0, vt);
}
} else if (m_pObj->typePtr == TclTypes::doubleType()) {
double value;
if (Tcl_GetDoubleFromObj(interp, m_pObj, &value) != TCL_OK) {
value = 0.0;
}
V_VT(pDest) = VT_R8;
V_R8(pDest) = value;
if (vt != VT_VARIANT && vt != VT_USERDEFINED) {
VariantChangeType(pDest, pDest, 0, vt);
}
} else if (m_pObj->typePtr == TclTypes::booleanType()) {
int value;
if (Tcl_GetBooleanFromObj(interp, m_pObj, &value) != TCL_OK) {
value = 0;
}
V_VT(pDest) = VT_BOOL;
V_BOOL(pDest) = (value != 0) ? VARIANT_TRUE : VARIANT_FALSE;
if (vt != VT_VARIANT && vt != VT_USERDEFINED) {
VariantChangeType(pDest, pDest, 0, vt);
}
} else if (vt == VT_BOOL) {
V_VT(pDest) = VT_BOOL;
V_BOOL(pDest) = getBool() ? VARIANT_TRUE : VARIANT_FALSE;
} else {
V_VT(pDest) = VT_BSTR;
V_BSTR(pDest) = getBSTR();
// If trying to convert from a string to a date,
// we need to convert to a double (VT_R8) first.
if (vt == VT_DATE) {
VariantChangeType(pDest, pDest, 0, VT_R8);
}
// Try to convert from a string representation.
if (vt != VT_VARIANT && vt != VT_USERDEFINED && vt != VT_LPWSTR) {
VariantChangeType(pDest, pDest, 0, vt);
}
}
}
HRESULT CContextPlugin::WriteContextInformation( HANDLE hFile, IWMSContext *pContext )
{
HRESULT hr = S_OK;
ContextNameHint *pContextHintValues = NULL;
DWORD nValue = 0;
WMS_CONTEXT_TYPE wmsContextType = WMS_UNKNOWN_CONTEXT_TYPE;
WCHAR wstrBuffer[MAX_PATH];
DWORD cbWritten = 0;
DWORD dwRet = 0;
if( NULL == pContext )
{
// There is no Context, nothing to write
return( hr );
}
hr = pContext->GetContextType( &wmsContextType );
if( FAILED( hr ) )
{
return( hr );
}
ZeroMemory( wstrBuffer, MAX_PATH * sizeof( WCHAR ) );
switch( wmsContextType )
{
case WMS_USER_CONTEXT_TYPE:
// Create a header for this context type
wcsncpy_s( wstrBuffer,MAX_PATH, CONTEXT_SAMPLE_USER_CONTEXT_HEADER, MAX_PATH );
pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_UserContextHintValues);
break;
case WMS_PRESENTATION_CONTEXT_TYPE:
// Create a header for this context type
wcsncpy_s( wstrBuffer, MAX_PATH,CONTEXT_SAMPLE_PRESENTATION_CONTEXT_HEADER, MAX_PATH );
pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_PresentationContextHintValues);
break;
case WMS_COMMAND_REQUEST_CONTEXT_TYPE:
// Create a header for this context type
wcsncpy_s( wstrBuffer,MAX_PATH, CONTEXT_SAMPLE_COMMAND_REQUEST_CONTEXT_HEADER, MAX_PATH );
pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_CommandContextHintValues);
break;
case WMS_COMMAND_RESPONSE_CONTEXT_TYPE:
// Create a header for this context type
wcsncpy_s( wstrBuffer,MAX_PATH, CONTEXT_SAMPLE_COMMAND_RESPONSE_CONTEXT_HEADER, MAX_PATH );
pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_CommandContextHintValues);
break;
}
if( !::WriteFile( hFile, (LPVOID) wstrBuffer, DWORD(wcslen( wstrBuffer ) * sizeof( WCHAR )), &cbWritten, NULL ) )
{
dwRet = GetLastError();
hr = HRESULT_FROM_WIN32( dwRet );
// Failed to write the header should we still continue
// No!
return( hr );
}
if( NULL == pContextHintValues )
{
return( E_UNEXPECTED );
}
// Now we loop until -1 and Write the data
while( ( NULL != pContextHintValues[nValue].wstrContextName ) && ( -1 != pContextHintValues[nValue].lContextHint ) )
{
VARIANT varValue;
VariantInit( &varValue );
ZeroMemory( wstrBuffer, MAX_PATH * sizeof( WCHAR ) );
hr = pContext->GetValue( pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, &varValue, 0 );
if( SUCCEEDED( hr ) )
{
// Write string with data information
switch( V_VT( &varValue ) )
{
case VT_BSTR:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_BSTR_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_BSTR( &varValue ) );
break;
case VT_I4:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_I4_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_I4( &varValue ), V_I4( &varValue ) );
break;
case VT_UI8:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_UI8_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_UI8( &varValue ) );
break;
case VT_CY:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_CY_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_CY( &varValue ) );
break;
case VT_DATE:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_DATE_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_DATE( &varValue ) );
break;
case VT_DECIMAL:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_DECIMAL_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_DECIMAL( &varValue ) );
break;
case VT_UNKNOWN:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_UNKNOWN_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_UNKNOWN( &varValue ) );
break;
case VT_DISPATCH:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_DISPATCH_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_DISPATCH( &varValue ) );
break;
default:
_snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_ARRAY_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_ARRAY( &varValue ) );
break;
}
if( !::WriteFile( hFile, (LPVOID) wstrBuffer, DWORD(wcslen( wstrBuffer ) * sizeof( WCHAR )), &cbWritten, NULL ) )
{
dwRet = GetLastError();
hr = HRESULT_FROM_WIN32( dwRet );
}
}
else
{
// Value probably didn't exist for this event, don't worry about it
// good place to put breakpoint
hr = S_OK;
}
// It doesn't hurt to do a VariantClear on an Empty Variant, this way we won't leak anything.
VariantClear( &varValue );
nValue ++;
}
return( hr );
}
HRESULT DoTheWork (INetSharingManager * pNSM)
{ // add a port mapping to every firewalled or shared connection
INetSharingEveryConnectionCollection * pNSECC = NULL;
HRESULT hr = pNSM->get_EnumEveryConnection (&pNSECC);
int LastErrorCode = 0;
if (!pNSECC)
return ICS_Error_FailGetEvery;
else {
// enumerate connections
IEnumVARIANT * pEV = NULL;
IUnknown * pUnk = NULL;
hr = pNSECC->get__NewEnum (&pUnk);
if (pUnk) {
hr = pUnk->QueryInterface (__uuidof(IEnumVARIANT),
(void**)&pEV);
pUnk->Release();
}else{
return ICS_Error_FailGetNewEnum;
}
if (pEV) {
VARIANT v;
VariantInit (&v);
while (S_OK == pEV->Next (1, &v, NULL)) {
if (V_VT (&v) == VT_UNKNOWN) {
INetConnection * pNC = NULL;
V_UNKNOWN (&v)->QueryInterface
(__uuidof(INetConnection),
(void**)&pNC);
if (pNC) {
INetConnectionProps * pNCP = NULL;
pNSM->get_NetConnectionProps (pNC, &pNCP);
if (!pNCP)
wprintf (L"failed to get NetConnectionProps!\r\n");
else {
// check properties for firewalled or shared connection
NETCON_MEDIATYPE MediaType;
pNCP->get_MediaType(&MediaType);
NETCON_STATUS Status;
pNCP->get_Status(&Status);
BSTR DevName;
pNCP->get_DeviceName(&DevName);
if (MediaType & (NCM_LAN | NCM_SHAREDACCESSHOST_LAN | NCM_PHONE)
&& Status == NCS_CONNECTED
&& QString(_com_util::ConvertBSTRToString(DevName)).indexOf("hosted network", 0, Qt::CaseInsensitive)==-1
&& QString(_com_util::ConvertBSTRToString(DevName)).indexOf("virtual", 0, Qt::CaseInsensitive)==-1
&& QString(_com_util::ConvertBSTRToString(DevName)).indexOf("teamviewer", 0, Qt::CaseInsensitive)==-1) {
// got a shared/firewalled connection
INetSharingConfiguration * pNSC = NULL;
hr = pNSM->get_INetSharingConfigurationForINetConnection (pNC, &pNSC);
if (!pNSC)
wprintf (L"can't make INetSharingConfiguration object!\r\n");
else {
hr = pNSC->EnableSharing(ICSSHARINGTYPE_PRIVATE);
if(hr!=S_OK){
LastErrorCode = ICS_Error_EnableSharing;
}else{
BSTR Name;
pNCP->get_Name(&Name);
QMessageBox msg;
msg.setText(QString("Network: %1 %2 %3").arg(_com_util::ConvertBSTRToString(Name)).arg(_com_util::ConvertBSTRToString(DevName)).arg(Status));
msg.exec();
return 0;
}
pNSC->Release();
}
}
pNCP->Release();
}
pNC->Release();
}
}
VariantClear (&v);
}
pEV->Release();
}else{
return ICS_Error_FailGetEnumVariant;
}
pNSECC->Release();
}
if(LastErrorCode!=0) return LastErrorCode;
return hr;
}
TclObject::TclObject (VARIANT *pSrc, const Type &type, Tcl_Interp *interp, int bytes)
{
if (V_ISARRAY(pSrc)) {
SAFEARRAY *psa = V_ISBYREF(pSrc) ? *V_ARRAYREF(pSrc) : V_ARRAY(pSrc);
VARTYPE elementType = V_VT(pSrc) & VT_TYPEMASK;
unsigned numDimensions = SafeArrayGetDim(psa);
std::vector<long> indices(numDimensions);
m_pObj = convertFromSafeArray( psa, elementType, 1, &indices[0], type, interp, bytes);
} else if (vtMissing == pSrc) {
m_pObj = Extension::newNaObj();
} else {
switch (V_VT(pSrc)) {
case VT_BOOL:
m_pObj = Tcl_NewBooleanObj(V_BOOL(pSrc));
break;
case VT_ERROR:
m_pObj = Tcl_NewLongObj(V_ERROR(pSrc));
break;
case VT_I1:
case VT_UI1:
m_pObj = Tcl_NewLongObj(V_I1(pSrc));
break;
case VT_I2:
case VT_UI2:
m_pObj = Tcl_NewLongObj(V_I2(pSrc));
break;
case VT_I4:
case VT_UI4:
case VT_INT:
case VT_UINT:
m_pObj = Tcl_NewLongObj(V_I4(pSrc));
break;
#ifdef V_I8
case VT_I8:
case VT_UI8:
m_pObj = Tcl_NewWideIntObj(V_I8(pSrc));
break;
#endif
case VT_R4:
m_pObj = Tcl_NewDoubleObj(V_R4(pSrc));
break;
case VT_DATE:
case VT_R8:
m_pObj = Tcl_NewDoubleObj(V_R8(pSrc));
break;
case VT_DISPATCH:
m_pObj = convertFromUnknown(V_DISPATCH(pSrc), type.iid(), interp);
break;
case VT_DISPATCH | VT_BYREF:
m_pObj = convertFromUnknown(
(V_DISPATCHREF(pSrc) != 0) ? *V_DISPATCHREF(pSrc) : 0,
type.iid(),
interp);
break;
case VT_UNKNOWN:
m_pObj = convertFromUnknown(V_UNKNOWN(pSrc), type.iid(), interp);
break;
case VT_UNKNOWN | VT_BYREF:
m_pObj = convertFromUnknown(
(V_UNKNOWNREF(pSrc) != 0) ? *V_UNKNOWNREF(pSrc) : 0,
type.iid(),
interp);
break;
case VT_NULL:
m_pObj = Extension::newNullObj();
break;
case VT_LPSTR:
m_pObj = Tcl_NewStringObj(V_I1REF(pSrc), -1);
break;
case VT_LPWSTR:
{
#if TCL_MINOR_VERSION >= 2
// Uses Unicode function introduced in Tcl 8.2.
m_pObj = newUnicodeObj(V_UI2REF(pSrc), -1);
#else
const wchar_t *pWide = V_UI2REF(pSrc);
_bstr_t str(pWide);
m_pObj = Tcl_NewStringObj(str, -1);
#endif
}
break;
default:
if (V_VT(pSrc) == VT_USERDEFINED && type.name() == "GUID") {
Uuid uuid(*static_cast<UUID *>(V_BYREF(pSrc)));
m_pObj = Tcl_NewStringObj(
const_cast<char *>(uuid.toString().c_str()), -1);
} else {
if (V_VT(pSrc) == (VT_VARIANT | VT_BYREF)) {
pSrc = V_VARIANTREF(pSrc);
}
_bstr_t str(pSrc);
#if TCL_MINOR_VERSION >= 2
// Uses Unicode function introduced in Tcl 8.2.
wchar_t *pWide = str;
m_pObj = newUnicodeObj(
reinterpret_cast<Tcl_UniChar *>(pWide), str.length());
#else
m_pObj = Tcl_NewStringObj(str, -1);
#endif
}
}
}
Tcl_IncrRefCount(m_pObj);
}
PHP_COM_DOTNET_API int php_com_copy_variant(VARIANT *dstvar, VARIANT *srcvar)
{
int ret = SUCCESS;
switch (V_VT(dstvar) & ~VT_BYREF) {
case VT_EMPTY:
case VT_NULL:
case VT_VOID:
/* should not be possible */
break;
case VT_UI1:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI1REF(dstvar) = V_UI1(srcvar);
} else {
V_UI1(dstvar) = V_UI1(srcvar);
}
break;
case VT_I1:
if (V_VT(dstvar) & VT_BYREF) {
*V_I1REF(dstvar) = V_I1(srcvar);
} else {
V_I1(dstvar) = V_I1(srcvar);
}
break;
case VT_UI2:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI2REF(dstvar) = V_UI2(srcvar);
} else {
V_UI2(dstvar) = V_UI2(srcvar);
}
break;
case VT_I2:
if (V_VT(dstvar) & VT_BYREF) {
*V_I2REF(dstvar) = V_I2(srcvar);
} else {
V_I2(dstvar) = V_I2(srcvar);
}
break;
case VT_UI4:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI4REF(dstvar) = V_UI4(srcvar);
} else {
V_UI4(dstvar) = V_UI4(srcvar);
}
break;
case VT_I4:
if (V_VT(dstvar) & VT_BYREF) {
*V_I4REF(dstvar) = V_I4(srcvar);
} else {
V_I4(dstvar) = V_I4(srcvar);
}
break;
#if SIZEOF_ZEND_LONG == 8
case VT_UI8:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI8REF(dstvar) = V_UI8(srcvar);
} else {
V_UI8(dstvar) = V_UI8(srcvar);
}
break;
case VT_I8:
if (V_VT(dstvar) & VT_BYREF) {
*V_I8REF(dstvar) = V_I8(srcvar);
} else {
V_I8(dstvar) = V_I8(srcvar);
}
break;
#endif
case VT_INT:
if (V_VT(dstvar) & VT_BYREF) {
*V_INTREF(dstvar) = V_INT(srcvar);
} else {
V_INT(dstvar) = V_INT(srcvar);
}
break;
case VT_UINT:
if (V_VT(dstvar) & VT_BYREF) {
*V_UINTREF(dstvar) = V_UINT(srcvar);
} else {
V_UINT(dstvar) = V_UINT(srcvar);
}
break;
case VT_R4:
if (V_VT(dstvar) & VT_BYREF) {
*V_R4REF(dstvar) = V_R4(srcvar);
} else {
V_R4(dstvar) = V_R4(srcvar);
}
break;
case VT_R8:
if (V_VT(dstvar) & VT_BYREF) {
*V_R8REF(dstvar) = V_R8(srcvar);
} else {
V_R8(dstvar) = V_R8(srcvar);
}
break;
case VT_BOOL:
if (V_VT(dstvar) & VT_BYREF) {
*V_BOOLREF(dstvar) = V_BOOL(srcvar);
} else {
V_BOOL(dstvar) = V_BOOL(srcvar);
}
break;
case VT_BSTR:
if (V_VT(dstvar) & VT_BYREF) {
*V_BSTRREF(dstvar) = V_BSTR(srcvar);
} else {
V_BSTR(dstvar) = V_BSTR(srcvar);
}
break;
case VT_UNKNOWN:
if (V_VT(dstvar) & VT_BYREF) {
*V_UNKNOWNREF(dstvar) = V_UNKNOWN(srcvar);
} else {
V_UNKNOWN(dstvar) = V_UNKNOWN(srcvar);
}
break;
case VT_DISPATCH:
if (V_VT(dstvar) & VT_BYREF) {
*V_DISPATCHREF(dstvar) = V_DISPATCH(srcvar);
} else {
V_DISPATCH(dstvar) = V_DISPATCH(srcvar);
}
break;
case VT_VARIANT:
return php_com_copy_variant(V_VARIANTREF(dstvar), srcvar);
default:
php_error_docref(NULL, E_WARNING, "variant->variant: failed to copy from 0x%x to 0x%x", V_VT(dstvar), V_VT(srcvar));
ret = FAILURE;
}
return ret;
}
PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepage)
{
OLECHAR *olestring = NULL;
int ret = SUCCESS;
switch (V_VT(v)) {
case VT_EMPTY:
case VT_NULL:
case VT_VOID:
ZVAL_NULL(z);
break;
case VT_UI1:
ZVAL_LONG(z, (zend_long)V_UI1(v));
break;
case VT_I1:
ZVAL_LONG(z, (zend_long)V_I1(v));
break;
case VT_UI2:
ZVAL_LONG(z, (zend_long)V_UI2(v));
break;
case VT_I2:
ZVAL_LONG(z, (zend_long)V_I2(v));
break;
case VT_UI4: /* TODO: promote to double if large? */
ZVAL_LONG(z, (long)V_UI4(v));
break;
case VT_I4:
ZVAL_LONG(z, (long)V_I4(v));
break;
#if SIZEOF_ZEND_LONG == 8
case VT_UI8:
ZVAL_LONG(z, (zend_long)V_UI8(v));
break;
case VT_I8:
ZVAL_LONG(z, (zend_long)V_I8(v));
break;
#endif
case VT_INT:
ZVAL_LONG(z, V_INT(v));
break;
case VT_UINT: /* TODO: promote to double if large? */
ZVAL_LONG(z, (zend_long)V_UINT(v));
break;
case VT_R4:
ZVAL_DOUBLE(z, (double)V_R4(v));
break;
case VT_R8:
ZVAL_DOUBLE(z, V_R8(v));
break;
case VT_BOOL:
ZVAL_BOOL(z, V_BOOL(v) ? 1 : 0);
break;
case VT_BSTR:
olestring = V_BSTR(v);
if (olestring) {
size_t len;
char *str = php_com_olestring_to_string(olestring,
&len, codepage);
ZVAL_STRINGL(z, str, len);
// TODO: avoid reallocation???
efree(str);
olestring = NULL;
}
break;
case VT_UNKNOWN:
if (V_UNKNOWN(v) != NULL) {
IDispatch *disp;
if (SUCCEEDED(IUnknown_QueryInterface(V_UNKNOWN(v), &IID_IDispatch, &disp))) {
php_com_wrap_dispatch(z, disp, codepage);
IDispatch_Release(disp);
} else {
ret = FAILURE;
}
}
break;
case VT_DISPATCH:
if (V_DISPATCH(v) != NULL) {
php_com_wrap_dispatch(z, V_DISPATCH(v), codepage);
}
break;
case VT_VARIANT:
/* points to another variant */
return php_com_zval_from_variant(z, V_VARIANTREF(v), codepage);
default:
php_com_wrap_variant(z, v, codepage);
}
if (olestring) {
efree(olestring);
}
if (ret == FAILURE) {
php_error_docref(NULL, E_WARNING, "variant->zval: conversion from 0x%x ret=%d", V_VT(v), ret);
}
return ret;
}
int
Extension::foreachCmd (
ClientData,
Tcl_Interp *interp,
int objc,
Tcl_Obj *const objv[])
{
if (objc != 4) {
Tcl_WrongNumArgs(
interp, 1, objv, "varList collectionHandle script");
return TCL_ERROR;
}
Tcl_Obj *pVarList = objv[1];
Tcl_Obj *pBody = objv[3];
Reference *pCollection = referenceHandles.find(interp, objv[2]);
if (pCollection == 0) {
const char *arg = Tcl_GetStringFromObj(objv[2], 0);
Tcl_AppendResult(
interp, "invalid interface pointer handle ", arg, 0);
return TCL_ERROR;
}
// Collections should implement a _NewEnum method which returns an object
// that enumerates the elements.
HRESULT hr;
PositionalArguments arguments;
_variant_t varResult;
hr = pCollection->invoke(
DISPID_NEWENUM,
DISPATCH_METHOD | DISPATCH_PROPERTYGET,
arguments,
&varResult);
if (FAILED(hr) || V_VT(&varResult) != VT_UNKNOWN) {
Tcl_AppendResult(interp, "object is not a collection", NULL);
return TCL_ERROR;
}
IUnknownPtr pUnk(V_UNKNOWN(&varResult));
// Get a specific kind of enumeration.
IEnumVARIANTPtr pEnumVARIANT;
IEnumUnknownPtr pEnumUnknown;
enum EnumKind { ENUM_VARIANT, ENUM_UNKNOWN };
EnumKind enumKind;
hr = pUnk->QueryInterface(
IID_IEnumVARIANT, reinterpret_cast<void **>(&pEnumVARIANT));
if (SUCCEEDED(hr)) {
enumKind = ENUM_VARIANT;
} else {
hr = pUnk->QueryInterface(
IID_IEnumUnknown, reinterpret_cast<void **>(&pEnumUnknown));
if (SUCCEEDED(hr)) {
enumKind = ENUM_UNKNOWN;
}
}
if (FAILED(hr)) {
Tcl_AppendResult(interp,
"Unknown enumerator type: not IEnumVARIANT or IEnumUnknown", NULL);
return TCL_ERROR;
}
int completionCode;
int varc; // number of loop variables
completionCode = Tcl_ListObjLength(interp, pVarList, &varc);
if (completionCode != TCL_OK) {
return TCL_ERROR;
}
if (varc < 1) {
Tcl_AppendResult(interp, "foreach varlist is empty", NULL);
return TCL_ERROR;
}
while (true) {
// If the variable list has been converted to another kind of Tcl
// object, convert it back to a list and refetch the pointer to its
// element array.
Tcl_Obj **varv;
completionCode =
Tcl_ListObjGetElements(interp, pVarList, &varc, &varv);
if (completionCode != TCL_OK) {
return TCL_ERROR;
}
// Assign values to all loop variables.
int v = 0;
for (; v < varc; ++v) {
TclObject value;
ULONG count;
switch (enumKind) {
case ENUM_VARIANT:
{
_variant_t elementVar;
hr = pEnumVARIANT->Next(1, &elementVar, &count);
if (hr == S_OK && count > 0) {
value = TclObject(&elementVar, Type::variant(), interp, 0);
}
}
break;
case ENUM_UNKNOWN:
{
IUnknown *pElement;
hr = pEnumUnknown->Next(1, &pElement, &count);
if (hr == S_OK && count > 0) {
value = referenceHandles.newObj(
interp, Reference::newReference(pElement));
}
}
break;
}
if (FAILED(hr)) {
_com_issue_error(hr);
}
if (hr != S_OK || count == 0) {
break;
}
Tcl_Obj *varValuePtr = Tcl_ObjSetVar2(
interp, varv[v], NULL, value, TCL_LEAVE_ERR_MSG);
if (varValuePtr == NULL) {
return TCL_ERROR;
}
}
if (v == 0) {
completionCode = TCL_OK;
break;
}
if (v < varc) {
TclObject empty;
for (; v < varc; ++v) {
Tcl_Obj *varValuePtr = Tcl_ObjSetVar2(
interp, varv[v], NULL, empty, TCL_LEAVE_ERR_MSG);
if (varValuePtr == NULL) {
return TCL_ERROR;
}
}
}
// Execute the script body.
completionCode =
#if TCL_MINOR_VERSION >= 1
Tcl_EvalObjEx(interp, pBody, 0);
#else
Tcl_EvalObj(interp, pBody);
#endif
if (completionCode == TCL_CONTINUE) {
// do nothing
} else if (completionCode == TCL_BREAK) {
completionCode = TCL_OK;
break;
} else if (completionCode == TCL_ERROR) {
std::ostringstream oss;
oss << "\n (\"foreach\" body line %d)" << interp->errorLine;
Tcl_AddObjErrorInfo(
interp, const_cast<char *>(oss.str().c_str()), -1);
break;
} else if (completionCode != TCL_OK) {
break;
}
}
if (completionCode == TCL_OK) {
Tcl_ResetResult(interp);
}
return completionCode;
}
STDMETHODIMP CESceneDocument::ShowViews(IEFrame* pFrame)
{
#if 0
CComPtr<ILXFrameworkFrame> frame;
static_cast<CLXMLEditorApp*>(m_app.p)->m_spAddinSite->GetFrame(&frame);
CComPtr<ILXFrameworkApp> app;
frame->GetApp(&app);
CComPtr<ILXUIMDIFrameElement> frameelement;
frame->get_Element(&frameelement);
CComPtr<ILXUIDocument> appdocument;
app->get_Document(&appdocument);
// CComPtr<ILXUIElement> mdiclient;
// frameelement->getMDIClientElement(&mdiclient);
#if 0
CComPtr<ILDOMElement> mdiclient = GetElementByTagNameNS(frameelement, L"http://www.lerstad.com/2004/lxui", L"mdiclient", FALSE);
if (mdiclient)
{
CComPtr<ILXUIElement> mdichild;
appdocument->createElementNS(L"http://www.lerstad.com/2004/lxui", L"mdichild", (ILDOMElement**)&mdichild);
mdiclient->appendChild(mdichild, NULL);
}
#endif
CDocumentWorkspace* pWorkspace = &static_cast<CLXMLEditorApp*>(m_app.p)->m_sceneDocumentWorkspace;
CComQIPtr<ILXAddin> addin = m_app;
CComPtr<ILXAddinSite> addinSite;
addin->GetSite(&addinSite);
CComPtr<IUIManager> uiManager;
addinSite->GetUIManager((IUnknown**)&uiManager);
CComQIPtr<IUIMDIFrame> mdiframe = pFrame;
/*
CComObject<CEXMLViewGroup>* viewGroup;
CComObject<CEXMLViewGroup>::CreateInstance(&viewGroup);
if (viewGroup)
{
viewGroup->AddRef();
viewGroup->SetDocument(this);
*/
// Create all views
// 3DView(s)
{
CComPtr<ILDOMElement> e;
appdocument->createElementNS(NULL, L"content", &e);
CComPtr<IUnknown> old;
e->setUserData(L"n", /*viewGroup->*/GetUnknown(), NULL, &old);
VARIANT vFactory;
V_VT(&vFactory) = VT_UNKNOWN;
V_UNKNOWN(&vFactory) = static_cast<CLXMLEditorApp*>(m_app.p)->m_pElementBehaviorFactory;
V_UNKNOWN(&vFactory)->AddRef();
long cookie;
e->addBehavior(L"#factory#scene_3dview", &vFactory, &cookie);
m_views.Add(e.Detach());
}
// SceneGraphDlg
{
CComPtr<ILDOMElement> e;
appdocument->createElementNS(NULL, L"content", &e);
CComPtr<IUnknown> old;
e->setUserData(L"n", /*viewGroup->*/GetUnknown(), NULL, &old);
VARIANT vFactory;
V_VT(&vFactory) = VT_UNKNOWN;
V_UNKNOWN(&vFactory) = static_cast<CLXMLEditorApp*>(m_app.p)->m_pElementBehaviorFactory;
V_UNKNOWN(&vFactory)->AddRef();
long cookie;
e->addBehavior(L"#factory#scene_graph", &vFactory, &cookie);
m_views.Add(e.Detach());
}
pWorkspace->Create(pFrame, static_cast<CLXMLEditorApp*>(m_app.p), this/*viewGroup*/);
//}
// UpdateTitles();
#endif
return S_OK;
}
static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
{
HTMLDocument *This = OLEOBJ_THIS(iface);
IDocHostUIHandler *pDocHostUIHandler = NULL;
IOleCommandTarget *cmdtrg = NULL;
BOOL hostui_setup;
VARIANT silent;
HRESULT hres;
TRACE("(%p)->(%p)\n", This, pClientSite);
if(pClientSite == This->doc_obj->client)
return S_OK;
if(This->doc_obj->client) {
IOleClientSite_Release(This->doc_obj->client);
This->doc_obj->client = NULL;
This->doc_obj->usermode = UNKNOWN_USERMODE;
}
if(This->doc_obj->hostui) {
IDocHostUIHandler_Release(This->doc_obj->hostui);
This->doc_obj->hostui = NULL;
}
memset(&This->doc_obj->hostinfo, 0, sizeof(DOCHOSTUIINFO));
if(!pClientSite)
return S_OK;
hostui_setup = This->doc_obj->hostui_setup;
hres = IOleObject_QueryInterface(pClientSite, &IID_IDocHostUIHandler, (void**)&pDocHostUIHandler);
if(SUCCEEDED(hres)) {
DOCHOSTUIINFO hostinfo;
LPOLESTR key_path = NULL, override_key_path = NULL;
IDocHostUIHandler2 *pDocHostUIHandler2;
memset(&hostinfo, 0, sizeof(DOCHOSTUIINFO));
hostinfo.cbSize = sizeof(DOCHOSTUIINFO);
hres = IDocHostUIHandler_GetHostInfo(pDocHostUIHandler, &hostinfo);
if(SUCCEEDED(hres)) {
TRACE("hostinfo = {%u %08x %08x %s %s}\n",
hostinfo.cbSize, hostinfo.dwFlags, hostinfo.dwDoubleClick,
debugstr_w(hostinfo.pchHostCss), debugstr_w(hostinfo.pchHostNS));
update_hostinfo(This->doc_obj, &hostinfo);
This->doc_obj->hostinfo = hostinfo;
}
if(!hostui_setup) {
hres = IDocHostUIHandler_GetOptionKeyPath(pDocHostUIHandler, &key_path, 0);
if(hres == S_OK && key_path) {
if(key_path[0]) {
/* FIXME: use key_path */
TRACE("key_path = %s\n", debugstr_w(key_path));
}
CoTaskMemFree(key_path);
}
hres = IDocHostUIHandler_QueryInterface(pDocHostUIHandler, &IID_IDocHostUIHandler2,
(void**)&pDocHostUIHandler2);
if(SUCCEEDED(hres)) {
hres = IDocHostUIHandler2_GetOverrideKeyPath(pDocHostUIHandler2, &override_key_path, 0);
if(hres == S_OK && override_key_path && override_key_path[0]) {
if(override_key_path[0]) {
/*FIXME: use override_key_path */
TRACE("override_key_path = %s\n", debugstr_w(override_key_path));
}
CoTaskMemFree(override_key_path);
}
IDocHostUIHandler2_Release(pDocHostUIHandler2);
}
This->doc_obj->hostui_setup = TRUE;
}
}
/* Native calls here GetWindow. What is it for?
* We don't have anything to do with it here (yet). */
if(pClientSite) {
IOleWindow *pOleWindow = NULL;
HWND hwnd;
hres = IOleClientSite_QueryInterface(pClientSite, &IID_IOleWindow, (void**)&pOleWindow);
if(SUCCEEDED(hres)) {
IOleWindow_GetWindow(pOleWindow, &hwnd);
IOleWindow_Release(pOleWindow);
}
}
hres = IOleClientSite_QueryInterface(pClientSite, &IID_IOleCommandTarget, (void**)&cmdtrg);
if(SUCCEEDED(hres)) {
VARIANT var;
OLECMD cmd = {OLECMDID_SETPROGRESSTEXT, 0};
if(!hostui_setup) {
V_VT(&var) = VT_UNKNOWN;
V_UNKNOWN(&var) = (IUnknown*)HTMLWINDOW2(This->window);
IOleCommandTarget_Exec(cmdtrg, &CGID_DocHostCmdPriv, DOCHOST_DOCCANNAVIGATE, 0, &var, NULL);
}
IOleCommandTarget_QueryStatus(cmdtrg, NULL, 1, &cmd, NULL);
V_VT(&var) = VT_I4;
V_I4(&var) = 0;
IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_SETPROGRESSMAX,
OLECMDEXECOPT_DONTPROMPTUSER, &var, NULL);
IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_SETPROGRESSPOS,
OLECMDEXECOPT_DONTPROMPTUSER, &var, NULL);
IOleCommandTarget_Release(cmdtrg);
}
IOleClientSite_AddRef(pClientSite);
This->doc_obj->client = pClientSite;
This->doc_obj->hostui = pDocHostUIHandler;
if(This->doc_obj->usermode == UNKNOWN_USERMODE)
IOleControl_OnAmbientPropertyChange(CONTROL(This), DISPID_AMBIENT_USERMODE);
IOleControl_OnAmbientPropertyChange(CONTROL(This), DISPID_AMBIENT_OFFLINEIFNOTCONNECTED);
hres = get_client_disp_property(This->doc_obj->client, DISPID_AMBIENT_SILENT, &silent);
if(SUCCEEDED(hres)) {
if(V_VT(&silent) != VT_BOOL)
WARN("V_VT(silent) = %d\n", V_VT(&silent));
else if(V_BOOL(&silent))
FIXME("silent == true\n");
}
IOleControl_OnAmbientPropertyChange(CONTROL(This), DISPID_AMBIENT_USERAGENT);
IOleControl_OnAmbientPropertyChange(CONTROL(This), DISPID_AMBIENT_PALETTE);
return S_OK;
}
void ProcessLatestUpdate()
{
WORD majorVersion = 0;
WORD minorVersion = 0;
WORD buildNumber = 0;
WORD revisionNumber = 0;
wchar_t szTempFileName[MAX_PATH] { 0 };
wchar_t lpTempPathBuffer[MAX_PATH] = { 0 };
wstring thisFileName = g_moduleFilePath;
wstring currentVersion;
currentVersion = GetAppVersion(thisFileName.c_str(), &majorVersion, &minorVersion, &buildNumber, &revisionNumber);
IWinHttpRequest * pIWinHttpRequest = NULL;
BSTR bstrResponse = NULL;
HRESULT hr = CoInitialize(NULL);
do
{
VARIANT varFalse;
VARIANT varEmpty;
CLSID clsid;
VariantInit(&varFalse);
V_VT(&varFalse) = VT_BOOL;
V_BOOL(&varFalse) = VARIANT_FALSE;
VariantInit(&varEmpty);
V_VT(&varEmpty) = VT_ERROR;
hr = CLSIDFromProgID(L"WinHttp.WinHttpRequest.5.1", &clsid);
if (SUCCEEDED(hr) == FALSE)
{
break;
}
hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
IID_IWinHttpRequest, (void **)&pIWinHttpRequest);
if (SUCCEEDED(hr) == FALSE)
{
break;
}
BSTR bstrMethod = SysAllocString(L"GET");
BSTR bstrUrl = SysAllocString(UPDATE_CHECK_URL);
hr = pIWinHttpRequest->Open(bstrMethod, bstrUrl, varFalse);
SysFreeString(bstrMethod);
SysFreeString(bstrUrl);
if (SUCCEEDED(hr) == FALSE)
{
break;
}
hr = pIWinHttpRequest->Send(varEmpty);
if (SUCCEEDED(hr) == FALSE)
{
break;
}
hr = pIWinHttpRequest->get_ResponseText(&bstrResponse);
wstring txt = bstrResponse;
wstring newUpdateVersion = GetNewVersion(txt);
if (newUpdateVersion.length() == 0)
{
break;
}
if (newUpdateVersion == currentVersion)
{
if (g_isConsoleApp == TRUE)
{
OutputConsole(L"This is the latest version (%s)\n", currentVersion.c_str());
}
break;
}
if (IsNewVersion(majorVersion, minorVersion, buildNumber, revisionNumber, newUpdateVersion) == FALSE)
{
if (g_isConsoleApp == TRUE)
{
OutputConsole(L"This is the latest version (%s)\n", L"1.0.0.4"); // currentVersion.c_str());
}
break;
}
// if new, update latest version.
// if old, roll-back last stable version.
bool is32bit = sizeof(char *) == 4;
wstring location = GetUpdateLocation(txt, is32bit);
VariantInit(&varEmpty);
V_VT(&varEmpty) = VT_ERROR;
bstrMethod = SysAllocString(L"GET");
bstrUrl = SysAllocString(location.c_str());
pIWinHttpRequest->Open(bstrMethod, bstrUrl, varFalse);
SysFreeString(bstrMethod);
SysFreeString(bstrUrl);
if (SUCCEEDED(hr) == FALSE)
{
break;
}
hr = pIWinHttpRequest->Send(varEmpty);
if (SUCCEEDED(hr) == FALSE)
{
break;
}
VARIANT varResponse;
VariantInit(&varResponse);
hr = pIWinHttpRequest->get_ResponseStream(&varResponse);
if (SUCCEEDED(hr) == FALSE)
{
break;
}
txt = pIWinHttpRequest->GetResponseHeader(L"Content-Type").operator const wchar_t *();
if (txt.find(L"text/html") != -1)
{
OutputError(L"file not found: %s", location.c_str());
break;
}
IStream* pStream = NULL;
BYTE bBuffer[8192];
DWORD cb, cbRead, cbWritten;
if (VT_UNKNOWN == V_VT(&varResponse) || VT_STREAM == V_VT(&varResponse))
{
hr = V_UNKNOWN(&varResponse)->QueryInterface(IID_IStream,
reinterpret_cast<void**>(&pStream));
}
else
{
break;
}
if (SUCCEEDED(hr) == FALSE)
{
break;
}
DWORD dwRetVal = GetTempPath(MAX_PATH, // length of the buffer
lpTempPathBuffer); // buffer for path
if (dwRetVal > MAX_PATH || (dwRetVal == 0))
{
OutputError(L"GetTempPath failed (%d)", GetLastError());
break;
}
dwRetVal = GetTempFileName(lpTempPathBuffer, // directory for tmp files
L"straw", // temp file name prefix
0, // create unique name
szTempFileName); // buffer for name
if (dwRetVal == 0)
{
OutputError(L"GetTempFileName failed (%d)", GetLastError());
break;
}
bool succeed = true;
HANDLE hFile = CreateFile(szTempFileName,
GENERIC_WRITE, // Open for writing.
0, // Do not share.
NULL, // No security.
CREATE_ALWAYS, // Overwrite existing.
FILE_ATTRIBUTE_NORMAL, // Normal file.
NULL); // No attribute template.
if (hFile == INVALID_HANDLE_VALUE)
{
OutputError(L"Can't open a file: %s", szTempFileName);
break;
}
else
{
cb = sizeof(bBuffer);
hr = pStream->Read(bBuffer, cb, &cbRead);
while (SUCCEEDED(hr) && 0 != cbRead)
{
if (!WriteFile(hFile, bBuffer,
cbRead, &cbWritten, NULL))
{
OutputError(L"WriteFile fails with 0x%08lx\n", HRESULT_FROM_WIN32(GetLastError()));
succeed = false;
break;
}
hr = pStream->Read(bBuffer, cb, &cbRead);
}
}
CloseHandle(hFile);
pStream->Release();
VariantClear(&varResponse);
if (succeed == true)
{
wstring oldFileName = thisFileName;
oldFileName += currentVersion + L".bak";
::DeleteFile(oldFileName.c_str());
if (MoveFile(thisFileName.c_str(), oldFileName.c_str()) == FALSE)
{
OutputError(L"Backup fails (%d)", GetLastError());
break;
}
if (MoveFile(szTempFileName, thisFileName.c_str()) == FALSE)
{
OutputError(L"Update fails (%d)", GetLastError());
break;
}
FireRestartCommand();
}
} while (false);
if (::PathFileExists(szTempFileName) == TRUE)
{
::DeleteFile(szTempFileName);
}
if (pIWinHttpRequest)
{
pIWinHttpRequest->Release();
}
if (bstrResponse)
{
SysFreeString(bstrResponse);
}
CoUninitialize();
}
static void test_XMLHTTP(void)
{
static const char bodyA[] = "mode=Test";
static const char urlA[] = "http://test.winehq.org/tests/post.php";
static const char xmltestA[] = "http://test.winehq.org/tests/xmltest.xml";
static const char referertesturl[] = "http://test.winehq.org/tests/referer.php";
static const WCHAR wszExpectedResponse[] = {'F','A','I','L','E','D',0};
static const CHAR xmltestbodyA[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<a>TEST</a>\n";
static const WCHAR norefererW[] = {'n','o',' ','r','e','f','e','r','e','r',' ','s','e','t',0};
IXMLHttpRequest *xhr;
IObjectWithSite *obj_site, *obj_site2;
BSTR bstrResponse, str, str1;
VARIANT varbody, varbody_ref;
VARIANT dummy;
LONG state, status, bound;
IDispatch *event;
void *ptr;
HRESULT hr;
HGLOBAL g;
xhr = create_xhr();
VariantInit(&dummy);
V_VT(&dummy) = VT_ERROR;
V_ERROR(&dummy) = DISP_E_MEMBERNOTFOUND;
hr = IXMLHttpRequest_put_onreadystatechange(xhr, NULL);
EXPECT_HR(hr, S_OK);
hr = IXMLHttpRequest_abort(xhr);
EXPECT_HR(hr, S_OK);
V_VT(&varbody) = VT_I2;
V_I2(&varbody) = 1;
hr = IXMLHttpRequest_get_responseBody(xhr, &varbody);
EXPECT_HR(hr, E_PENDING);
ok(V_VT(&varbody) == VT_EMPTY, "got type %d\n", V_VT(&varbody));
V_VT(&varbody) = VT_I2;
V_I2(&varbody) = 1;
hr = IXMLHttpRequest_get_responseStream(xhr, &varbody);
EXPECT_HR(hr, E_PENDING);
ok(V_VT(&varbody) == VT_EMPTY, "got type %d\n", V_VT(&varbody));
/* send before open */
hr = IXMLHttpRequest_send(xhr, dummy);
ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
/* initial status code */
hr = IXMLHttpRequest_get_status(xhr, NULL);
ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr);
status = 0xdeadbeef;
hr = IXMLHttpRequest_get_status(xhr, &status);
ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
ok(status == READYSTATE_UNINITIALIZED || broken(status == 0xdeadbeef) /* <win8 */, "got %d\n", status);
hr = IXMLHttpRequest_get_statusText(xhr, &str);
ok(hr == E_FAIL, "got 0x%08x\n", hr);
/* invalid parameters */
test_open(xhr, NULL, NULL, E_INVALIDARG);
test_open(xhr, "POST", NULL, E_INVALIDARG);
test_open(xhr, NULL, urlA, E_INVALIDARG);
hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, NULL);
EXPECT_HR(hr, E_INVALIDARG);
hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), NULL);
ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, _bstr_("value1"));
EXPECT_HR(hr, E_INVALIDARG);
hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), _bstr_("value1"));
ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_get_readyState(xhr, NULL);
ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr);
state = -1;
hr = IXMLHttpRequest_get_readyState(xhr, &state);
EXPECT_HR(hr, S_OK);
ok(state == READYSTATE_UNINITIALIZED, "got %d, expected READYSTATE_UNINITIALIZED\n", state);
httpreq = xhr;
event = create_dispevent();
EXPECT_REF(event, 1);
hr = IXMLHttpRequest_put_onreadystatechange(xhr, event);
EXPECT_HR(hr, S_OK);
EXPECT_REF(event, 2);
g_unexpectedcall = g_expectedcall = 0;
test_open(xhr, "POST", urlA, S_OK);
ok(g_unexpectedcall == 0, "unexpected disp event call\n");
ok(g_expectedcall == 1 || broken(g_expectedcall == 0) /* win2k */, "no expected disp event call\n");
/* status code after ::open() */
status = 0xdeadbeef;
hr = IXMLHttpRequest_get_status(xhr, &status);
ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
ok(status == READYSTATE_UNINITIALIZED || broken(status == 0xdeadbeef) /* <win8 */, "got %d\n", status);
state = -1;
hr = IXMLHttpRequest_get_readyState(xhr, &state);
EXPECT_HR(hr, S_OK);
ok(state == READYSTATE_LOADING, "got %d, expected READYSTATE_LOADING\n", state);
hr = IXMLHttpRequest_abort(xhr);
EXPECT_HR(hr, S_OK);
state = -1;
hr = IXMLHttpRequest_get_readyState(xhr, &state);
EXPECT_HR(hr, S_OK);
ok(state == READYSTATE_UNINITIALIZED || broken(state == READYSTATE_LOADING) /* win2k */,
"got %d, expected READYSTATE_UNINITIALIZED\n", state);
test_open(xhr, "POST", urlA, S_OK);
hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), _bstr_("value1"));
EXPECT_HR(hr, S_OK);
hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, _bstr_("value1"));
EXPECT_HR(hr, E_INVALIDARG);
hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_(""), _bstr_("value1"));
EXPECT_HR(hr, E_INVALIDARG);
V_VT(&varbody) = VT_BSTR;
V_BSTR(&varbody) = _bstr_(bodyA);
hr = IXMLHttpRequest_send(xhr, varbody);
if (hr == INET_E_RESOURCE_NOT_FOUND)
{
skip("No connection could be made with test.winehq.org\n");
IXMLHttpRequest_Release(xhr);
return;
}
EXPECT_HR(hr, S_OK);
/* response headers */
hr = IXMLHttpRequest_getAllResponseHeaders(xhr, NULL);
ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_getAllResponseHeaders(xhr, &str);
EXPECT_HR(hr, S_OK);
/* status line is stripped already */
ok(memcmp(str, _bstr_("HTTP"), 4*sizeof(WCHAR)), "got response headers %s\n", wine_dbgstr_w(str));
ok(*str, "got empty headers\n");
hr = IXMLHttpRequest_getAllResponseHeaders(xhr, &str1);
EXPECT_HR(hr, S_OK);
ok(str1 != str, "got %p\n", str1);
SysFreeString(str1);
SysFreeString(str);
hr = IXMLHttpRequest_getResponseHeader(xhr, NULL, NULL);
EXPECT_HR(hr, E_INVALIDARG);
hr = IXMLHttpRequest_getResponseHeader(xhr, _bstr_("Date"), NULL);
ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_getResponseHeader(xhr, _bstr_("Date"), &str);
EXPECT_HR(hr, S_OK);
ok(*str != ' ', "got leading space in header %s\n", wine_dbgstr_w(str));
SysFreeString(str);
/* status code after ::send() */
status = 0xdeadbeef;
hr = IXMLHttpRequest_get_status(xhr, &status);
EXPECT_HR(hr, S_OK);
ok(status == 200, "got %d\n", status);
hr = IXMLHttpRequest_get_statusText(xhr, NULL);
ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_get_statusText(xhr, &str);
EXPECT_HR(hr, S_OK);
ok(!lstrcmpW(str, _bstr_("OK")), "got status %s\n", wine_dbgstr_w(str));
SysFreeString(str);
/* another ::send() after completed request */
V_VT(&varbody) = VT_BSTR;
V_BSTR(&varbody) = _bstr_(bodyA);
hr = IXMLHttpRequest_send(xhr, varbody);
ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_get_responseText(xhr, &bstrResponse);
EXPECT_HR(hr, S_OK);
/* the server currently returns "FAILED" because the Content-Type header is
* not what the server expects */
if(hr == S_OK)
{
ok(!memcmp(bstrResponse, wszExpectedResponse, sizeof(wszExpectedResponse)),
"expected %s, got %s\n", wine_dbgstr_w(wszExpectedResponse), wine_dbgstr_w(bstrResponse));
SysFreeString(bstrResponse);
}
/* POST: VT_VARIANT|VT_BYREF body */
test_open(xhr, "POST", urlA, S_OK);
V_VT(&varbody_ref) = VT_VARIANT|VT_BYREF;
V_VARIANTREF(&varbody_ref) = &varbody;
hr = IXMLHttpRequest_send(xhr, varbody_ref);
EXPECT_HR(hr, S_OK);
/* GET request */
test_open(xhr, "GET", xmltestA, S_OK);
V_VT(&varbody) = VT_EMPTY;
hr = IXMLHttpRequest_send(xhr, varbody);
if (hr == INET_E_RESOURCE_NOT_FOUND)
{
skip("No connection could be made with test.winehq.org\n");
IXMLHttpRequest_Release(xhr);
return;
}
EXPECT_HR(hr, S_OK);
hr = IXMLHttpRequest_get_responseText(xhr, NULL);
ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_get_responseText(xhr, &bstrResponse);
EXPECT_HR(hr, S_OK);
ok(!memcmp(bstrResponse, _bstr_(xmltestbodyA), sizeof(xmltestbodyA)*sizeof(WCHAR)),
"expected %s, got %s\n", xmltestbodyA, wine_dbgstr_w(bstrResponse));
SysFreeString(bstrResponse);
hr = IXMLHttpRequest_get_responseBody(xhr, NULL);
EXPECT_HR(hr, E_INVALIDARG);
V_VT(&varbody) = VT_EMPTY;
hr = IXMLHttpRequest_get_responseBody(xhr, &varbody);
EXPECT_HR(hr, S_OK);
ok(V_VT(&varbody) == (VT_ARRAY|VT_UI1), "got type %d, expected %d\n", V_VT(&varbody), VT_ARRAY|VT_UI1);
ok(SafeArrayGetDim(V_ARRAY(&varbody)) == 1, "got %d, expected one dimension\n", SafeArrayGetDim(V_ARRAY(&varbody)));
bound = -1;
hr = SafeArrayGetLBound(V_ARRAY(&varbody), 1, &bound);
EXPECT_HR(hr, S_OK);
ok(bound == 0, "got %d, expected zero bound\n", bound);
hr = SafeArrayAccessData(V_ARRAY(&varbody), &ptr);
EXPECT_HR(hr, S_OK);
ok(memcmp(ptr, xmltestbodyA, sizeof(xmltestbodyA)-1) == 0, "got wrong body data\n");
SafeArrayUnaccessData(V_ARRAY(&varbody));
VariantClear(&varbody);
/* get_responseStream */
hr = IXMLHttpRequest_get_responseStream(xhr, NULL);
EXPECT_HR(hr, E_INVALIDARG);
V_VT(&varbody) = VT_EMPTY;
hr = IXMLHttpRequest_get_responseStream(xhr, &varbody);
ok(V_VT(&varbody) == VT_UNKNOWN, "got type %d\n", V_VT(&varbody));
EXPECT_HR(hr, S_OK);
EXPECT_REF(V_UNKNOWN(&varbody), 1);
g = NULL;
hr = GetHGlobalFromStream((IStream*)V_UNKNOWN(&varbody), &g);
EXPECT_HR(hr, S_OK);
ok(g != NULL, "got %p\n", g);
VariantClear(&varbody);
IDispatch_Release(event);
/* test if referrer header is sent */
test_open(xhr, "GET", referertesturl, S_OK);
V_VT(&varbody) = VT_EMPTY;
hr = IXMLHttpRequest_send(xhr, varbody);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_get_responseText(xhr, &str);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(!lstrcmpW(str, norefererW), "got response text %s\n", wine_dbgstr_w(str));
SysFreeString(str);
/* interaction with object site */
hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectWithSite, (void**)&obj_site);
EXPECT_HR(hr, S_OK);
hr = IObjectWithSite_SetSite(obj_site, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectWithSite, (void**)&obj_site2);
EXPECT_HR(hr, S_OK);
ok(obj_site == obj_site2 || broken(obj_site != obj_site2), "got new instance\n");
IObjectWithSite_Release(obj_site2);
set_xhr_site(xhr);
test_open(xhr, "GET", "tests/referer.php", S_OK);
str1 = a2bstr("http://test.winehq.org/");
V_VT(&varbody) = VT_EMPTY;
hr = IXMLHttpRequest_send(xhr, varbody);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_get_responseText(xhr, &str);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(!lstrcmpW(str, str1), "got response text %s, expected %s\n", wine_dbgstr_w(str), wine_dbgstr_w(str1));
SysFreeString(str);
SysFreeString(str1);
/* try to set site another time */
hr = IObjectWithSite_SetSite(obj_site, &testsite);
EXPECT_HR(hr, S_OK);
IObjectWithSite_Release(obj_site);
IXMLHttpRequest_Release(xhr);
free_bstrs();
}
/////////////////////////////////////////////////////////////////////////////
//
// [OnGetContentInformation]
//
// IWMSCacheProxyServerCallback
//
/////////////////////////////////////////////////////////////////////////////
HRESULT STDMETHODCALLTYPE
CProxyPlugin::OnGetContentInformation(
long lHr,
IWMSContext *pContentInfo,
VARIANT varContext
)
{
HRESULT returnHr = (HRESULT) lHr;
HRESULT hr = S_OK;
COpState *pOpState = NULL;
WMS_CACHE_QUERY_MISS_RESPONSE CacheMissPolicy = WMS_CACHE_QUERY_MISS_SKIP;
IWMSDataContainerVersion *pContentVersion = NULL;
CComBSTR bstrUrl;
BOOL fDownload = FALSE;
long lContentType = 0;
DWORD dwCacheFlags;
WCHAR szPort[ 20 ];
if( ( VT_UNKNOWN != V_VT( &varContext ) ) ||
( NULL == V_UNKNOWN( &varContext ) ) )
{
return( E_INVALIDARG );
}
pOpState = ( COpState *) V_UNKNOWN( &varContext );
if( FAILED( returnHr ) )
{
if( NS_E_CONNECTION_FAILURE == returnHr )
{
// Do protocol rollover
pOpState->m_dwProtocolIndex++;
if( NULL == g_ProxyProtocols[ pOpState->m_dwProtocolIndex ] )
{
// we have tried all the protocols and failed
hr = E_NOINTERFACE;
goto abort;
}
bstrUrl = g_ProxyProtocols[ pOpState->m_dwProtocolIndex ];
bstrUrl.Append( L"://" );
bstrUrl.Append( pOpState->m_bstrHost );
// if we we are using the same protocol requested by the client, then we should
// also use the port specified by the client (if one was specified)
if( ( 0 != pOpState->m_wPort ) &&
( 0 == _wcsicmp( g_ProxyProtocols[ pOpState->m_dwProtocolIndex ], pOpState->m_bstrProtocol ) ) )
{
bstrUrl.Append( L":" );
_itow_s( pOpState->m_wPort, szPort,sizeof(szPort)/sizeof(WCHAR), 10 );
bstrUrl.Append( szPort );
}
bstrUrl.Append( L"/" );
bstrUrl.Append( pOpState->m_bstrPath );
hr = m_pICacheProxyServer->GetContentInformation(
bstrUrl,
pOpState->m_pPresentationContext,
this,
NULL,
(IWMSCacheProxyServerCallback *) this,
varContext
);
if( FAILED( hr ) )
{
goto abort;
}
return( S_OK );
}
else if( E_ACCESSDENIED == returnHr )
{
// the origin server requires authentication to provide information about this content.
// since we don't have the credentials, we can either proxy this stream on-demand (in
// which case the player will be prompted for the credentials) or simply fail this request.
// let's opt for proxying the stream.
CacheMissPolicy = WMS_CACHE_QUERY_MISS_PLAY_ON_DEMAND;
}
else
{
hr = returnHr;
goto abort;
}
}
else
{
hr = pContentInfo->GetLongValue( WMS_CACHE_CONTENT_INFORMATION_CONTENT_TYPE,
WMS_CACHE_CONTENT_INFORMATION_CONTENT_TYPE_ID,
(long *) &lContentType,
0 );
if( FAILED( hr ) )
{
goto abort;
}
if( WMS_CACHE_CONTENT_TYPE_BROADCAST & lContentType )
{
hr = pContentInfo->GetAndQueryIUnknownValue( WMS_CACHE_CONTENT_INFORMATION_DATA_CONTAINER_VERSION,
WMS_CACHE_CONTENT_INFORMATION_DATA_CONTAINER_VERSION_ID,
IID_IWMSDataContainerVersion,
(IUnknown **) &pContentVersion,
0 );
if( ( FAILED( hr ) ) || ( NULL == pContentVersion ) )
{
hr = FAILED( hr ) ? hr : E_UNEXPECTED;
goto abort;
}
hr = pContentVersion->GetCacheFlags( (long *) &dwCacheFlags );
if( FAILED( hr ) )
{
goto abort;
}
if( dwCacheFlags & WMS_DATA_CONTAINER_VERSION_ALLOW_STREAM_SPLITTING )
{
CacheMissPolicy = WMS_CACHE_QUERY_MISS_PLAY_BROADCAST;
}
else
{
CacheMissPolicy = WMS_CACHE_QUERY_MISS_PLAY_ON_DEMAND;
}
}
else // It is an on-demand publishing point
{
CacheMissPolicy = WMS_CACHE_QUERY_MISS_PLAY_ON_DEMAND;
}
}
hr = S_OK;
bstrUrl = g_ProxyProtocols[ pOpState->m_dwProtocolIndex ];
bstrUrl.Append( L"://" );
bstrUrl.Append( pOpState->m_bstrHost );
// if we we are using the same protocol requested by the client, then we should
// also use the port specified by the client (if one was specified)
if( ( 0 != pOpState->m_wPort ) &&
( 0 == _wcsicmp( g_ProxyProtocols[ pOpState->m_dwProtocolIndex ], pOpState->m_bstrProtocol ) ) )
{
bstrUrl.Append( L":" );
_itow_s( pOpState->m_wPort, szPort,sizeof(szPort)/sizeof(WCHAR), 10 );
bstrUrl.Append( szPort );
}
bstrUrl.Append( L"/" );
bstrUrl.Append( pOpState->m_bstrPath );
abort:
hr = pOpState->m_pCacheProxyCallback->OnQueryCacheMissPolicy( hr,
CacheMissPolicy,
bstrUrl,
NULL,
pContentInfo,
pOpState->m_varContext );
if( FAILED( hr ) )
{
hr = S_OK;
}
if( NULL != pOpState )
{
pOpState->Release();
}
if( NULL != pContentVersion )
{
pContentVersion->Release();
}
return( S_OK );
}
HRESULT node_insert_before(xmlnode *This, IXMLDOMNode *new_child, const VARIANT *ref_child,
IXMLDOMNode **ret)
{
IXMLDOMNode *before = NULL;
xmlnode *node_obj;
int refcount = 0;
xmlDocPtr doc;
HRESULT hr;
if(!new_child)
return E_INVALIDARG;
node_obj = get_node_obj(new_child);
if(!node_obj) return E_FAIL;
switch(V_VT(ref_child))
{
case VT_EMPTY:
case VT_NULL:
break;
case VT_UNKNOWN:
case VT_DISPATCH:
if (V_UNKNOWN(ref_child))
{
hr = IUnknown_QueryInterface(V_UNKNOWN(ref_child), &IID_IXMLDOMNode, (void**)&before);
if(FAILED(hr)) return hr;
}
break;
default:
FIXME("refChild var type %x\n", V_VT(ref_child));
return E_FAIL;
}
TRACE("new child %p, This->node %p\n", node_obj->node, This->node);
if(!node_obj->node->parent)
if(xmldoc_remove_orphan(node_obj->node->doc, node_obj->node) != S_OK)
WARN("%p is not an orphan of %p\n", node_obj->node, node_obj->node->doc);
refcount = xmlnode_get_inst_cnt(node_obj);
if(before)
{
xmlnode *before_node_obj = get_node_obj(before);
IXMLDOMNode_Release(before);
if(!before_node_obj) return E_FAIL;
/* unlink from current parent first */
if(node_obj->parent)
{
hr = IXMLDOMNode_removeChild(node_obj->parent, node_obj->iface, NULL);
if (hr == S_OK) xmldoc_remove_orphan(node_obj->node->doc, node_obj->node);
}
doc = node_obj->node->doc;
/* refs count including subtree */
if (doc != before_node_obj->node->doc)
refcount = xmlnode_get_inst_cnt(node_obj);
if (refcount) xmldoc_add_refs(before_node_obj->node->doc, refcount);
xmlAddPrevSibling(before_node_obj->node, node_obj->node);
if (refcount) xmldoc_release_refs(doc, refcount);
node_obj->parent = This->parent;
}
else
{
/* unlink from current parent first */
if(node_obj->parent)
{
hr = IXMLDOMNode_removeChild(node_obj->parent, node_obj->iface, NULL);
if (hr == S_OK) xmldoc_remove_orphan(node_obj->node->doc, node_obj->node);
}
doc = node_obj->node->doc;
if (doc != This->node->doc)
refcount = xmlnode_get_inst_cnt(node_obj);
if (refcount) xmldoc_add_refs(This->node->doc, refcount);
/* xmlAddChild doesn't unlink node from previous parent */
xmlUnlinkNode(node_obj->node);
xmlAddChild(This->node, node_obj->node);
if (refcount) xmldoc_release_refs(doc, refcount);
node_obj->parent = This->iface;
}
if(ret)
{
IXMLDOMNode_AddRef(new_child);
*ret = new_child;
}
TRACE("ret S_OK\n");
return S_OK;
}
//+---------------------------------------------------------------------------
//
// Function: VARIANTARGToCVar
//
// Synopsis: Converts a VARIANT to a C-language variable.
//
// Arguments: [pvarg] -- Variant to convert.
// [pfAlloc] -- BSTR allocated during conversion caller is
// now owner of this BSTR or IUnknown or IDispatch
// object allocated needs to be released.
// [vt] -- Type to convert to.
// [pv] -- Location to place C-language variable.
//
// Modifies: [pv].
//
// Returns: HRESULT.
//
// History: 2-23-94 adams Created
//
// Notes: Supports all variant pointer types, VT_I2, VT_I4, VT_R4,
// VT_R8, VT_ERROR.
//----------------------------------------------------------------------------
HRESULT VARIANTARGToCVar(VARIANT* pvarg, BOOL* pfAlloc, VARTYPE vt, void* pv, IServiceProvider* pSrvProvider, WORD wMaxstrlen)
{
HRESULT hr = S_OK;
VARIANTARG* pVArgCopy = pvarg;
VARIANTARG vargNew; // variant of new type
BOOL fAlloc;
Assert(pvarg);
Assert(pv);
if(!pfAlloc)
{
pfAlloc = &fAlloc;
}
Assert((vt&~VT_TYPEMASK) == 0 || (vt&~VT_TYPEMASK)==VT_BYREF);
// Assume no allocations yet.
*pfAlloc = FALSE;
if(vt & VT_BYREF)
{
// If the parameter is a variant pointer then everything is acceptable.
if((vt&VT_TYPEMASK) == VT_VARIANT)
{
switch(V_VT(pvarg))
{
case VT_VARIANT|VT_BYREF:
hr = ClipVarString(pvarg->pvarVal, *(VARIANT**)pv, pfAlloc, wMaxstrlen);
break;
default:
hr = ClipVarString(pvarg, *(VARIANT**)pv, pfAlloc, wMaxstrlen);
break;
}
if(hr == S_FALSE)
{
hr = S_OK;
*(PVOID*)pv = (PVOID)pvarg;
}
goto Cleanup;
}
if((V_VT(pvarg)&VT_TYPEMASK) != (vt&VT_TYPEMASK))
{
hr = DISP_E_TYPEMISMATCH;
goto Cleanup;
}
// Type of both original and destination or same type (however, original
// may not be a byref only the original.
if(V_ISBYREF(pvarg))
{
// Destination and original are byref and same type just copy pointer.
*(PVOID*)pv = V_BYREF(pvarg);
}
else
{
// Convert original to byref.
switch(vt & VT_TYPEMASK)
{
case VT_BOOL:
*(PVOID*)pv = (PVOID)&V_BOOL(pvarg);
break;
case VT_I2:
*(PVOID*)pv = (PVOID)&V_I2(pvarg);
break;
case VT_ERROR:
case VT_I4:
*(PVOID*)pv = (PVOID)&V_I4(pvarg);
break;
case VT_R4:
*(PVOID*)pv = (PVOID)&V_R4(pvarg);
break;
case VT_R8:
*(PVOID*)pv = (PVOID)&V_R8(pvarg);
break;
case VT_CY:
*(PVOID*)pv = (PVOID)&V_CY(pvarg);
break;
// All pointer types.
case VT_PTR:
case VT_BSTR:
case VT_LPSTR:
case VT_LPWSTR:
case VT_DISPATCH:
case VT_UNKNOWN:
*(PVOID*)pv = (PVOID)&V_UNKNOWN(pvarg);
break;
case VT_VARIANT:
Assert("Dead code: shudn't have gotten here!");
*(PVOID*)pv = (PVOID)pvarg;
break;
default:
Assert(!"Unknown type in BYREF VARIANTARGToCVar().\n");
hr = DISP_E_TYPEMISMATCH;
goto Cleanup;
}
}
goto Cleanup;
}
// If the c style parameter is the same type as the VARIANT then we'll just
// move the data. Also if the c style type is a VARIANT then there's
// nothing to convert just copy the variant to the C parameter.
else if((V_VT(pvarg)&(VT_TYPEMASK|VT_BYREF))!=vt && (vt!=VT_VARIANT))
{
// If the request type isn't the same as the variant passed in then we
// need to convert.
VariantInit(&vargNew);
pVArgCopy = &vargNew;
hr = VariantChangeTypeSpecial(pVArgCopy, pvarg, vt,pSrvProvider);
if(hr)
{
goto Cleanup;
}
*pfAlloc = (vt==VT_BSTR) || (vt==VT_UNKNOWN) || (vt==VT_DISPATCH);
}
// Move the variant data to C style data.
switch(vt)
{
case VT_BOOL:
// convert VT_TRUE and any other non-zero values to TRUE
*(VARIANT_BOOL*)pv = V_BOOL(pVArgCopy);
break;
case VT_I2:
*(short*)pv = V_I2(pVArgCopy);
break;
case VT_ERROR:
case VT_I4:
*(long*)pv = V_I4(pVArgCopy);
break;
case VT_R4:
*(float*)pv = V_R4(pVArgCopy);
break;
case VT_R8:
*(double*)pv = V_R8(pVArgCopy);
break;
case VT_CY:
*(CY*)pv = V_CY(pVArgCopy);
break;
// All Pointer types.
case VT_BSTR:
if(wMaxstrlen && FormsStringLen(V_BSTR(pVArgCopy))>wMaxstrlen)
{
hr = FormsAllocStringLen(V_BSTR(pVArgCopy), wMaxstrlen, (BSTR*)pv);
if(hr)
{
goto Cleanup;
}
if(*pfAlloc)
{
VariantClear(&vargNew);
}
else
{
*pfAlloc = TRUE;
}
goto Cleanup;
}
case VT_PTR:
case VT_LPSTR:
case VT_LPWSTR:
case VT_DISPATCH:
case VT_UNKNOWN:
*(void**)pv = V_BYREF(pVArgCopy);
break;
case VT_VARIANT:
hr = ClipVarString(pVArgCopy, (VARIANT*)pv, pfAlloc, wMaxstrlen);
if(hr == S_FALSE)
{
hr = S_OK;
// Copy entire variant to output parameter.
*(VARIANT*)pv = *pVArgCopy;
}
break;
default:
Assert(FALSE && "Unknown type in VARIANTARGToCVar().\n");
hr = DISP_E_TYPEMISMATCH;
break;
}
Cleanup:
RRETURN(hr);
}
PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepage TSRMLS_DC)
{
OLECHAR *olestring = NULL;
int ret = SUCCESS;
switch (V_VT(v)) {
case VT_EMPTY:
case VT_NULL:
case VT_VOID:
ZVAL_NULL(z);
break;
case VT_UI1:
ZVAL_LONG(z, (long)V_UI1(v));
break;
case VT_I1:
ZVAL_LONG(z, (long)V_I1(v));
break;
case VT_UI2:
ZVAL_LONG(z, (long)V_UI2(v));
break;
case VT_I2:
ZVAL_LONG(z, (long)V_I2(v));
break;
case VT_UI4: /* TODO: promote to double if large? */
ZVAL_LONG(z, (long)V_UI4(v));
break;
case VT_I4:
ZVAL_LONG(z, (long)V_I4(v));
break;
case VT_INT:
ZVAL_LONG(z, V_INT(v));
break;
case VT_UINT: /* TODO: promote to double if large? */
ZVAL_LONG(z, (long)V_UINT(v));
break;
case VT_R4:
ZVAL_DOUBLE(z, (double)V_R4(v));
break;
case VT_R8:
ZVAL_DOUBLE(z, V_R8(v));
break;
case VT_BOOL:
ZVAL_BOOL(z, V_BOOL(v) ? 1 : 0);
break;
case VT_BSTR:
olestring = V_BSTR(v);
if (olestring) {
Z_TYPE_P(z) = IS_STRING;
Z_STRVAL_P(z) = php_com_olestring_to_string(olestring,
&Z_STRLEN_P(z), codepage TSRMLS_CC);
olestring = NULL;
}
break;
case VT_UNKNOWN:
if (V_UNKNOWN(v) != NULL) {
IDispatch *disp;
if (SUCCEEDED(IUnknown_QueryInterface(V_UNKNOWN(v), &IID_IDispatch, &disp))) {
php_com_wrap_dispatch(z, disp, codepage TSRMLS_CC);
IDispatch_Release(disp);
} else {
ret = FAILURE;
}
}
break;
case VT_DISPATCH:
if (V_DISPATCH(v) != NULL) {
php_com_wrap_dispatch(z, V_DISPATCH(v), codepage TSRMLS_CC);
}
break;
case VT_VARIANT:
/* points to another variant */
return php_com_zval_from_variant(z, V_VARIANTREF(v), codepage TSRMLS_CC);
default:
php_com_wrap_variant(z, v, codepage TSRMLS_CC);
}
if (olestring) {
efree(olestring);
}
if (ret == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "variant->zval: conversion from 0x%x ret=%d", V_VT(v), ret);
}
return ret;
}
HRESULT
IStreamToDOMDocument(
__inout IStream *pStream,
__deref_out IXMLDOMDocument2 **ppXmlDocument
)
{
HRESULT hr = S_OK;
if (NULL == ppXmlDocument ||
NULL == pStream)
{
hr = E_INVALIDARG;
}
if (ppXmlDocument)
{
*ppXmlDocument = NULL;
}
if ( SUCCEEDED(hr) )
{
hr = CoCreateInstance(CLSID_DOMDocument60,NULL,CLSCTX_INPROC_SERVER,IID_IXMLDOMDocument2,(LPVOID *)ppXmlDocument);
}
if( SUCCEEDED(hr) )
{
LARGE_INTEGER pos = {0, 0};
hr = pStream->Seek( pos, STREAM_SEEK_SET, NULL );
}
//
// Load the XML synchronously
//
if (SUCCEEDED(hr))
{
VARIANT_BOOL loadResult = 0; // Inidicates the result of loading the XML
VARIANT streamVar; // Variant wrapper for the IStream to pass to load.
VariantInit(&streamVar);
V_VT(&streamVar) = VT_UNKNOWN;
V_UNKNOWN(&streamVar) = pStream;
pStream->AddRef();
hr = (*ppXmlDocument)->load( streamVar, &loadResult );
//
// Check immediately to see if there was a parse error, since this
// comes back as S_FALSE instead of E_...
//
if (hr == S_FALSE)
{
// We could Figure out why it failed, but for now, lets just
// signal failure.
hr = E_FAIL;
}
VariantClear(&streamVar);
}
return hr;
}
static HRESULT create_enumerator(script_ctx_t *ctx, jsval_t *argv, jsdisp_t **ret)
{
EnumeratorInstance *enumerator;
HRESULT hres;
IDispatch *obj;
DISPPARAMS dispparams = {NULL, NULL, 0, 0};
IEnumVARIANT *enumvar = NULL;
if (argv)
{
VARIANT varresult;
if (!is_object_instance(*argv))
{
FIXME("I don't know how to handle this type!\n");
return E_NOTIMPL;
}
obj = get_object(*argv);
/* Try to get a IEnumVARIANT by _NewEnum */
VariantInit(&varresult);
hres = IDispatch_Invoke(obj, DISPID_NEWENUM, &IID_NULL, LOCALE_NEUTRAL,
DISPATCH_METHOD, &dispparams, &varresult, NULL, NULL);
if (FAILED(hres))
{
WARN("Enumerator: no DISPID_NEWENUM.\n");
return E_INVALIDARG;
}
if ((V_VT(&varresult) == VT_DISPATCH) || (V_VT(&varresult) == VT_UNKNOWN))
{
hres = IUnknown_QueryInterface(V_UNKNOWN(&varresult),
&IID_IEnumVARIANT, (void**)&enumvar);
}
else
{
FIXME("Enumerator: NewEnum unexpected type of varresult (%d).\n", V_VT(&varresult));
hres = E_INVALIDARG;
}
VariantClear(&varresult);
if (FAILED(hres))
return hres;
}
hres = alloc_enumerator(ctx, NULL, &enumerator);
if (FAILED(hres))
{
if (enumvar)
IEnumVARIANT_Release(enumvar);
return hres;
}
enumerator->enumvar = enumvar;
enumerator->atend = !enumvar;
hres = enumvar_get_next_item(enumerator);
if (FAILED(hres))
{
jsdisp_release(&enumerator->dispex);
return hres;
}
*ret = &enumerator->dispex;
return S_OK;
}
HRESULT dhGetValueV(LPCWSTR szIdentifier, void * pResult, IDispatch * pDisp, LPCOLESTR szMember, va_list * marker)
{
VARIANT vtResult;
VARTYPE returnType;
HRESULT hr;
DH_ENTER(L"GetValueV");
if (!pResult || !szIdentifier) return DH_EXIT(E_INVALIDARG, szMember);
if (*szIdentifier == L'%') szIdentifier++;
switch(*szIdentifier)
{
case L'd': returnType = VT_I4; break;
case L'u': returnType = VT_UI4; break;
case L'e': returnType = VT_R8; break;
case L'b': returnType = VT_BOOL; break;
case L'v': returnType = VT_EMPTY; break;
case L'B': returnType = VT_BSTR; break;
case L'S': returnType = VT_BSTR; break;
case L's': returnType = VT_BSTR; break;
case L'T': returnType = VT_BSTR; break;
case L'o': returnType = VT_DISPATCH; break;
case L'O': returnType = VT_UNKNOWN; break;
case L't': returnType = VT_DATE; break;
case L'W': returnType = VT_DATE; break;
case L'f': returnType = VT_DATE; break;
case L'D': returnType = VT_DATE; break;
#ifndef _WIN64
case L'p': returnType = VT_I4; break;
#else
case L'p': returnType = VT_I8; break;
#endif
default:
DEBUG_NOTIFY_INVALID_IDENTIFIER(*szIdentifier);
return DH_EXIT(E_INVALIDARG, szMember);
}
hr = dhInvokeV(DISPATCH_PROPERTYGET|DISPATCH_METHOD, returnType, &vtResult, pDisp, szMember, marker);
if (FAILED(hr)) return DH_EXIT(hr, szMember);
switch(*szIdentifier)
{
case L'd':
*((LONG *) pResult) = V_I4(&vtResult);
break;
case L'u':
*((ULONG *) pResult) = V_UI4(&vtResult);
break;
case L'e':
*((DOUBLE *) pResult) = V_R8(&vtResult);
break;
case L'b':
*((BOOL *) pResult) = V_BOOL(&vtResult);
break;
case L'v':
*((VARIANT *) pResult) = vtResult;
break;
case L'B':
*((BSTR *) pResult) = V_BSTR(&vtResult);
break;
case L'S':
*((LPWSTR *) pResult) = V_BSTR(&vtResult);
break;
case L's':
hr = ConvertBStrToAnsiStr(V_BSTR(&vtResult), (LPSTR *) pResult);
SysFreeString(V_BSTR(&vtResult));
break;
case L'T':
if (dh_g_bIsUnicodeMode)
{
*((LPWSTR *) pResult) = V_BSTR(&vtResult);
}
else
{
hr = ConvertBStrToAnsiStr(V_BSTR(&vtResult), (LPSTR *) pResult);
SysFreeString(V_BSTR(&vtResult));
}
break;
case L'o':
*((IDispatch **) pResult) = V_DISPATCH(&vtResult);
if (V_DISPATCH(&vtResult) == NULL) hr = E_NOINTERFACE;
break;
case L'O':
*((IUnknown **) pResult) = V_UNKNOWN(&vtResult);
if (V_UNKNOWN(&vtResult) == NULL) hr = E_NOINTERFACE;
break;
case L't':
hr = ConvertVariantTimeToTimeT(V_DATE(&vtResult), (time_t *) pResult);
break;
case L'W':
hr = ConvertVariantTimeToSystemTime(V_DATE(&vtResult), (SYSTEMTIME *) pResult);
break;
case L'f':
hr = ConvertVariantTimeToFileTime(V_DATE(&vtResult), (FILETIME *) pResult);
break;
case L'D':
*((DATE *) pResult) = V_DATE(&vtResult);
break;
case L'p':
#ifndef _WIN64
*((LPVOID *) pResult) = (LPVOID) V_I4(&vtResult);
#else
*((LPVOID *) pResult) = (LPVOID) V_I8(&vtResult);
#endif
break;
}
return DH_EXIT(hr, szMember);
}
zend_object_iterator *php_com_iter_get(zend_class_entry *ce, zval *object, int by_ref)
{
php_com_dotnet_object *obj;
struct php_com_iterator *I;
IEnumVARIANT *iev = NULL;
DISPPARAMS dp;
VARIANT v;
unsigned long n_fetched;
zval ptr;
if (by_ref) {
zend_throw_error(NULL, "An iterator cannot be used with foreach by reference");
return NULL;
}
obj = CDNO_FETCH(object);
if (V_VT(&obj->v) != VT_DISPATCH && !V_ISARRAY(&obj->v)) {
php_error_docref(NULL, E_WARNING, "variant is not an object or array VT=%d", V_VT(&obj->v));
return NULL;
}
memset(&dp, 0, sizeof(dp));
VariantInit(&v);
I = (struct php_com_iterator*)ecalloc(1, sizeof(*I));
zend_iterator_init(&I->iter);
I->iter.funcs = &com_iter_funcs;
Z_PTR(I->iter.data) = I;
I->code_page = obj->code_page;
ZVAL_UNDEF(&I->zdata);
VariantInit(&I->safe_array);
VariantInit(&I->v);
if (V_ISARRAY(&obj->v)) {
LONG bound;
UINT dims;
dims = SafeArrayGetDim(V_ARRAY(&obj->v));
if (dims != 1) {
php_error_docref(NULL, E_WARNING,
"Can only handle single dimension variant arrays (this array has %d)", dims);
goto fail;
}
/* same semantics as foreach on a PHP array;
* make a copy and enumerate that copy */
VariantCopy(&I->safe_array, &obj->v);
/* determine the key value for the array */
SafeArrayGetLBound(V_ARRAY(&I->safe_array), 1, &bound);
SafeArrayGetUBound(V_ARRAY(&I->safe_array), 1, &I->sa_max);
/* pre-fetch the element */
if (php_com_safearray_get_elem(&I->safe_array, &I->v, bound)) {
I->key = bound;
ZVAL_NULL(&ptr);
php_com_zval_from_variant(&ptr, &I->v, I->code_page);
ZVAL_COPY_VALUE(&I->zdata, &ptr);
} else {
I->key = (zend_ulong)-1;
}
} else {
/* can we enumerate it? */
if (FAILED(IDispatch_Invoke(V_DISPATCH(&obj->v), DISPID_NEWENUM,
&IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
&dp, &v, NULL, NULL))) {
goto fail;
}
/* get something useful out of it */
if (V_VT(&v) == VT_UNKNOWN) {
IUnknown_QueryInterface(V_UNKNOWN(&v), &IID_IEnumVARIANT, (void**)&iev);
} else if (V_VT(&v) == VT_DISPATCH) {
IDispatch_QueryInterface(V_DISPATCH(&v), &IID_IEnumVARIANT, (void**)&iev);
}
VariantClear(&v);
if (iev == NULL) {
goto fail;
}
I->ev = iev;
/* Get the first element now */
if (SUCCEEDED(IEnumVARIANT_Next(I->ev, 1, &I->v, &n_fetched)) && n_fetched > 0) {
/* indicate that we have element 0 */
I->key = 0;
ZVAL_NULL(&ptr);
php_com_zval_from_variant(&ptr, &I->v, I->code_page);
ZVAL_COPY_VALUE(&I->zdata, &ptr);
} else {
/* indicate that there are no more items */
I->key = (zend_ulong)-1;
}
}
return &I->iter;
fail:
if (I) {
VariantClear(&I->safe_array);
VariantClear(&I->v);
efree(I);
}
return NULL;
}
static void test_saxreader(void)
{
HRESULT hr;
ISAXXMLReader *reader = NULL;
VARIANT var;
ISAXContentHandler *lpContentHandler;
ISAXErrorHandler *lpErrorHandler;
SAFEARRAY *pSA;
SAFEARRAYBOUND SADim[1];
char *pSAData = NULL;
IStream *iStream;
ULARGE_INTEGER liSize;
LARGE_INTEGER liPos;
ULONG bytesWritten;
HANDLE file;
static const CHAR testXmlA[] = "test.xml";
static const WCHAR testXmlW[] = {'t','e','s','t','.','x','m','l',0};
IXMLDOMDocument *domDocument;
BSTR bstrData;
VARIANT_BOOL vBool;
hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER,
&IID_ISAXXMLReader, (LPVOID*)&reader);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = ISAXXMLReader_getContentHandler(reader, NULL);
ok(hr == E_POINTER, "Expected E_POINTER, got %08x\n", hr);
hr = ISAXXMLReader_getErrorHandler(reader, NULL);
ok(hr == E_POINTER, "Expected E_POINTER, got %08x\n", hr);
hr = ISAXXMLReader_getContentHandler(reader, &lpContentHandler);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(lpContentHandler == NULL, "Expected %p, got %p\n", NULL, lpContentHandler);
hr = ISAXXMLReader_getErrorHandler(reader, &lpErrorHandler);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(lpErrorHandler == NULL, "Expected %p, got %p\n", NULL, lpErrorHandler);
hr = ISAXXMLReader_putContentHandler(reader, NULL);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = ISAXXMLReader_putContentHandler(reader, &contentHandler);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = ISAXXMLReader_putErrorHandler(reader, &errorHandler);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
hr = ISAXXMLReader_getContentHandler(reader, &lpContentHandler);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
ok(lpContentHandler == &contentHandler, "Expected %p, got %p\n", &contentHandler, lpContentHandler);
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = SysAllocString(szSimpleXML);
expectCall = contentHandlerTest1;
hr = ISAXXMLReader_parse(reader, var);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
test_expect_call(CH_ENDTEST);
VariantClear(&var);
SADim[0].lLbound= 0;
SADim[0].cElements= sizeof(szTestXML)-1;
pSA = SafeArrayCreate(VT_UI1, 1, SADim);
SafeArrayAccessData(pSA, (void**)&pSAData);
memcpy(pSAData, szTestXML, sizeof(szTestXML)-1);
SafeArrayUnaccessData(pSA);
V_VT(&var) = VT_ARRAY|VT_UI1;
V_ARRAY(&var) = pSA;
expectCall = contentHandlerTest1;
hr = ISAXXMLReader_parse(reader, var);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
test_expect_call(CH_ENDTEST);
SafeArrayDestroy(pSA);
CreateStreamOnHGlobal(NULL, TRUE, &iStream);
liSize.QuadPart = strlen(szTestXML);
IStream_SetSize(iStream, liSize);
IStream_Write(iStream, szTestXML, strlen(szTestXML), &bytesWritten);
liPos.QuadPart = 0;
IStream_Seek(iStream, liPos, STREAM_SEEK_SET, NULL);
V_VT(&var) = VT_UNKNOWN|VT_DISPATCH;
V_UNKNOWN(&var) = (IUnknown*)iStream;
expectCall = contentHandlerTest1;
hr = ISAXXMLReader_parse(reader, var);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
test_expect_call(CH_ENDTEST);
IStream_Release(iStream);
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = SysAllocString(szCarriageRetTest);
expectCall = contentHandlerTest2;
hr = ISAXXMLReader_parse(reader, var);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
test_expect_call(CH_ENDTEST);
VariantClear(&var);
file = CreateFileA(testXmlA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
WriteFile(file, szTestXML, sizeof(szTestXML)-1, &bytesWritten, NULL);
CloseHandle(file);
expectCall = contentHandlerTest1;
hr = ISAXXMLReader_parseURL(reader, testXmlW);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
test_expect_call(CH_ENDTEST);
DeleteFileA(testXmlA);
hr = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER,
&IID_IXMLDOMDocument, (LPVOID*)&domDocument);
if(FAILED(hr))
{
skip("Failed to create DOMDocument instance\n");
return;
}
bstrData = SysAllocString(szSimpleXML);
hr = IXMLDOMDocument_loadXML(domDocument, bstrData, &vBool);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
V_VT(&var) = VT_UNKNOWN;
V_UNKNOWN(&var) = (IUnknown*)domDocument;
expectCall = contentHandlerTest2;
hr = ISAXXMLReader_parse(reader, var);
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
test_expect_call(CH_ENDTEST);
IXMLDOMDocument_Release(domDocument);
ISAXXMLReader_Release(reader);
SysFreeString(bstrData);
}
HRESULT share_work(INetSharingManager * pNSM, WCHAR* virtual_adapter)
{
INetSharingEveryConnectionCollection * pNSECC = NULL;
HRESULT hr = pNSM->lpVtbl->get_EnumEveryConnection(pNSM, &pNSECC);
int LastErrorCode = 0;
if (!pNSECC)
return ICS_Error_FailGetEvery;
else {
// enumerate connections
IEnumVARIANT * pEV = NULL;
IUnknown * pUnk = NULL;
hr = pNSECC->lpVtbl->get__NewEnum(pNSECC, &pUnk);
if (pUnk) {
hr = pUnk->lpVtbl->QueryInterface(pUnk, &(IID_IEnumVARIANT),
(void**)&pEV);
pUnk->lpVtbl->Release(pUnk);
}
else {
return ICS_Error_FailGetNewEnum;
}
if (pEV) {
VARIANT v;
VariantInit(&v);
while (S_OK == pEV->lpVtbl->Next(pEV, 1, &v, NULL)) {
if (V_VT(&v) == VT_UNKNOWN) {
INetConnection * pNC = NULL;
V_UNKNOWN(&v)->lpVtbl->QueryInterface
(V_UNKNOWN(&v), &(IID_INetConnection),
(void**)&pNC);
if (pNC) {
INetConnectionProps * pNCP = NULL;
pNSM->lpVtbl->get_NetConnectionProps(pNSM, pNC, &pNCP);
if (pNCP) {
// check properties for firewalled or shared connection
NETCON_MEDIATYPE MediaType;
pNCP->lpVtbl->get_MediaType(pNCP, &MediaType);
NETCON_STATUS Status;
pNCP->lpVtbl->get_Status(pNCP, &Status);
BSTR DevName;
pNCP->lpVtbl->get_DeviceName(pNCP, &DevName);
BSTR devGuid;
pNCP->lpVtbl->get_Guid(pNCP, &devGuid);
if (MediaType & (NCM_LAN | NCM_SHAREDACCESSHOST_LAN | NCM_PHONE)) {
/*wcscmp(devGuid, L"{882F0857-8811-4664-88D9-1C1AA08F69AE}") == 0 && */
if (Status == NCS_CONNECTED && wcscmp(devGuid, virtual_adapter) != 0
&& wcsstr(DevName, L"Virtual") == 0
) {
INetSharingConfiguration * pNSC = NULL;
hr = pNSM->lpVtbl->get_INetSharingConfigurationForINetConnection(pNSM, pNC, &pNSC);
if (pNSC) {
hr = pNSC->lpVtbl->EnableSharing(pNSC, ICSSHARINGTYPE_PUBLIC);
if (hr != S_OK)
LastErrorCode = ICS_Error_EnableSharing;
}
pNSC->lpVtbl->Release(pNSC);
pNSC = NULL;
}
if (wcscmp(devGuid, /*L"{2682DD96-0DB3-4F6D-9230-F36BC70697E5}"*/ virtual_adapter) == 0) {
INetSharingConfiguration * pVWifiNSC = NULL;
hr = pNSM->lpVtbl->get_INetSharingConfigurationForINetConnection(pNSM, pNC, &pVWifiNSC);
if (pVWifiNSC) {
hr = pVWifiNSC->lpVtbl->EnableSharing(pVWifiNSC, ICSSHARINGTYPE_PRIVATE);
if (hr != S_OK) {
LastErrorCode = ICS_Error_EnableSharing;
}
}
pVWifiNSC->lpVtbl->Release(pVWifiNSC);
pVWifiNSC = NULL;
}
}
pNCP->lpVtbl->Release(pNCP);
}
pNC->lpVtbl->Release(pNC);
} // pnc
}
VariantClear(&v);
}
pEV->lpVtbl->Release(pEV);
}
else {
return ICS_Error_FailGetEnumVariant;
}
pNSECC->lpVtbl->Release(pNSECC);
}
if (LastErrorCode != 0) return LastErrorCode;
return hr;
}
static HRESULT WINAPI OleObject_SetClientSite(IOleObject *iface, IOleClientSite *pClientSite)
{
HTMLDocument *This = impl_from_IOleObject(iface);
IOleCommandTarget *cmdtrg = NULL;
IOleWindow *ole_window;
BOOL hostui_setup;
VARIANT silent;
HWND hwnd;
HRESULT hres;
TRACE("(%p)->(%p)\n", This, pClientSite);
if(pClientSite == This->doc_obj->client)
return S_OK;
if(This->doc_obj->client) {
IOleClientSite_Release(This->doc_obj->client);
This->doc_obj->client = NULL;
This->doc_obj->usermode = UNKNOWN_USERMODE;
}
if(This->doc_obj->hostui && !This->doc_obj->custom_hostui) {
IDocHostUIHandler_Release(This->doc_obj->hostui);
This->doc_obj->hostui = NULL;
}
if(This->doc_obj->doc_object_service) {
IDocObjectService_Release(This->doc_obj->doc_object_service);
This->doc_obj->doc_object_service = NULL;
}
memset(&This->doc_obj->hostinfo, 0, sizeof(DOCHOSTUIINFO));
This->doc_obj->is_webbrowser = FALSE;
if(!pClientSite)
return S_OK;
IOleClientSite_AddRef(pClientSite);
This->doc_obj->client = pClientSite;
hostui_setup = This->doc_obj->hostui_setup;
if(!This->doc_obj->hostui) {
IDocHostUIHandler *uihandler;
This->doc_obj->custom_hostui = FALSE;
hres = IOleObject_QueryInterface(pClientSite, &IID_IDocHostUIHandler, (void**)&uihandler);
if(SUCCEEDED(hres))
This->doc_obj->hostui = uihandler;
}
if(This->doc_obj->hostui) {
DOCHOSTUIINFO hostinfo;
LPOLESTR key_path = NULL, override_key_path = NULL;
IDocHostUIHandler2 *uihandler2;
memset(&hostinfo, 0, sizeof(DOCHOSTUIINFO));
hostinfo.cbSize = sizeof(DOCHOSTUIINFO);
hres = IDocHostUIHandler_GetHostInfo(This->doc_obj->hostui, &hostinfo);
if(SUCCEEDED(hres)) {
TRACE("hostinfo = {%u %08x %08x %s %s}\n",
hostinfo.cbSize, hostinfo.dwFlags, hostinfo.dwDoubleClick,
debugstr_w(hostinfo.pchHostCss), debugstr_w(hostinfo.pchHostNS));
update_hostinfo(This->doc_obj, &hostinfo);
This->doc_obj->hostinfo = hostinfo;
}
if(!hostui_setup) {
hres = IDocHostUIHandler_GetOptionKeyPath(This->doc_obj->hostui, &key_path, 0);
if(hres == S_OK && key_path) {
if(key_path[0]) {
/* FIXME: use key_path */
TRACE("key_path = %s\n", debugstr_w(key_path));
}
CoTaskMemFree(key_path);
}
hres = IDocHostUIHandler_QueryInterface(This->doc_obj->hostui, &IID_IDocHostUIHandler2,
(void**)&uihandler2);
if(SUCCEEDED(hres)) {
hres = IDocHostUIHandler2_GetOverrideKeyPath(uihandler2, &override_key_path, 0);
if(hres == S_OK && override_key_path && override_key_path[0]) {
if(override_key_path[0]) {
/*FIXME: use override_key_path */
TRACE("override_key_path = %s\n", debugstr_w(override_key_path));
}
CoTaskMemFree(override_key_path);
}
IDocHostUIHandler2_Release(uihandler2);
}
This->doc_obj->hostui_setup = TRUE;
}
}
/* Native calls here GetWindow. What is it for?
* We don't have anything to do with it here (yet). */
hres = IOleClientSite_QueryInterface(pClientSite, &IID_IOleWindow, (void**)&ole_window);
if(SUCCEEDED(hres)) {
IOleWindow_GetWindow(ole_window, &hwnd);
IOleWindow_Release(ole_window);
}
hres = IOleClientSite_QueryInterface(pClientSite, &IID_IOleCommandTarget, (void**)&cmdtrg);
if(SUCCEEDED(hres)) {
VARIANT var;
OLECMD cmd = {OLECMDID_SETPROGRESSTEXT, 0};
if(!hostui_setup) {
IDocObjectService *doc_object_service;
IBrowserService *browser_service;
IWebBrowser2 *wb;
V_VT(&var) = VT_UNKNOWN;
V_UNKNOWN(&var) = (IUnknown*)&This->window->IHTMLWindow2_iface;
IOleCommandTarget_Exec(cmdtrg, &CGID_DocHostCmdPriv, DOCHOST_DOCCANNAVIGATE, 0, &var, NULL);
hres = do_query_service((IUnknown*)pClientSite, &IID_IShellBrowser,
&IID_IBrowserService, (void**)&browser_service);
if(SUCCEEDED(hres)) {
hres = IBrowserService_QueryInterface(browser_service,
&IID_IDocObjectService, (void**)&doc_object_service);
if(SUCCEEDED(hres)) {
This->doc_obj->doc_object_service = doc_object_service;
/*
* Some embedding routines, esp. in regards to use of IDocObjectService, differ if
* embedder supports IWebBrowserApp.
*/
hres = do_query_service((IUnknown*)pClientSite, &IID_IWebBrowserApp, &IID_IWebBrowser2, (void**)&wb);
if(SUCCEEDED(hres)) {
This->doc_obj->is_webbrowser = TRUE;
IWebBrowser2_Release(wb);
}
IBrowserService_Release(browser_service);
}
}
}
IOleCommandTarget_QueryStatus(cmdtrg, NULL, 1, &cmd, NULL);
V_VT(&var) = VT_I4;
V_I4(&var) = 0;
IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_SETPROGRESSMAX,
OLECMDEXECOPT_DONTPROMPTUSER, &var, NULL);
IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_SETPROGRESSPOS,
OLECMDEXECOPT_DONTPROMPTUSER, &var, NULL);
IOleCommandTarget_Release(cmdtrg);
}
if(This->doc_obj->usermode == UNKNOWN_USERMODE)
IOleControl_OnAmbientPropertyChange(&This->IOleControl_iface, DISPID_AMBIENT_USERMODE);
IOleControl_OnAmbientPropertyChange(&This->IOleControl_iface,
DISPID_AMBIENT_OFFLINEIFNOTCONNECTED);
hres = get_client_disp_property(This->doc_obj->client, DISPID_AMBIENT_SILENT, &silent);
if(SUCCEEDED(hres)) {
if(V_VT(&silent) != VT_BOOL)
WARN("V_VT(silent) = %d\n", V_VT(&silent));
else if(V_BOOL(&silent))
FIXME("silent == true\n");
}
IOleControl_OnAmbientPropertyChange(&This->IOleControl_iface, DISPID_AMBIENT_USERAGENT);
IOleControl_OnAmbientPropertyChange(&This->IOleControl_iface, DISPID_AMBIENT_PALETTE);
return S_OK;
}
HRESULT CTCPropBagOnRegKey::_WriteVariant(CRegKey& key,
const _bstr_t& strValueName, VARIANT* pVar)
{
// Check for an array
if (V_ISARRAY(pVar))
return WriteSafeArray(key, strValueName, pVar);
// Write the value to the registry based on the VARIANT type
switch (V_VT(pVar))
{
// Empty variant is written as nothing
case VT_EMPTY:
key.DeleteValue(strValueName);
key.RecurseDeleteKey(strValueName);
break;
// Integer types are written as a REG_DWORD value
case VT_I1:
case VT_I2:
case VT_I4:
case VT_UI1:
case VT_UI2:
case VT_ERROR:
{
// Coerce the value to a VT_UI4
VariantChangeTypeEx(pVar, pVar, GetThreadLocale(), m_wChangeTypeFlags,
VT_UI4);
// Fall thru to next case
}
case VT_UI4:
{
// Write the REG_DWORD value to the registry
key.RecurseDeleteKey(strValueName);
key.WriteDWord(strValueName, V_UI4(pVar));
break;
}
// BOOL's, float types and strings are written as a REG_SZ value
case VT_R4:
case VT_R8:
case VT_CY:
case VT_DATE:
case VT_DECIMAL:
case VT_BOOL:
{
// Coerce the value to a VT_BSTR
VariantChangeTypeEx(pVar, pVar, GetThreadLocale(), m_wChangeTypeFlags,
VT_BSTR);
// Fall thru to next case
}
case VT_BSTR:
{
// Write the REG_SZ value to the registry
key.RecurseDeleteKey(strValueName);
key.WriteString(strValueName, V_BSTR(pVar));
break;
}
// Objects written as REG_BINARY, if they don't support IPersistPropertyBag
case VT_UNKNOWN:
case VT_DISPATCH:
{
// Attempt first to save the object property using IPersistPropertyBag
key.DeleteValue(strValueName);
key.RecurseDeleteKey(strValueName);
CComObjectStack<CTCPropBagOnRegKey> bag;
bag.Init(key, _bstr_t(), this);
HRESULT hr = bag.SaveObject(strValueName, V_UNKNOWN(pVar), FALSE, TRUE);
if (FAILED(hr))
{
TRACE1("CTCPropBagOnRegKey::_WriteVariant: Saving object property \"%s\" as a binary value\n",
strValueName);
// Create a CArchive on a CMemFile
CMemFile file;
CArchive ar(&file, CArchive::store, 0);
// Archive the variant to the CArchive and close it
CComVariant v(pVar);
ar << v;
ar.Close();
// Write the REG_BINARY value to the registry
int cbData = file.GetLength();
BYTE* pData = file.Detach();
key.RecurseDeleteKey(strValueName);
key.WriteBinary(strValueName, pData, cbData);
file.Attach(pData, cbData);
}
break;
}
default:
TRACE1("CTCPropBagOnRegKey::_WriteVariant(\"%ls\"): ", strValueName);
TRACE2("Unsupported variant type 0x%02X (%d)\n", UINT(V_VT(pVar)),
UINT(V_VT(pVar)));
return E_FAIL;
}
// Indicate success
return S_OK;
}
