HRESULT node_get_nodeName(xmlnode *This, BSTR *name)
{
BSTR prefix, base;
HRESULT hr;
if (!name)
return E_INVALIDARG;
hr = node_get_base_name(This, &base);
if (hr != S_OK) return hr;
hr = node_get_prefix(This, &prefix);
if (hr == S_OK)
{
static const WCHAR colW = ':';
WCHAR *ptr;
/* +1 for ':' */
ptr = *name = SysAllocStringLen(NULL, SysStringLen(base) + SysStringLen(prefix) + 1);
memcpy(ptr, prefix, SysStringByteLen(prefix));
ptr += SysStringLen(prefix);
memcpy(ptr++, &colW, sizeof(WCHAR));
memcpy(ptr, base, SysStringByteLen(base));
SysFreeString(base);
SysFreeString(prefix);
}
else
*name = base;
return S_OK;
}
BOOL COleObjectFactory::VerifyLicenseKey(BSTR bstrKey)
{
// May be overridden by subclass
BOOL bLicensed = FALSE;
BSTR bstr = NULL;
if ((bstrKey != NULL) && GetLicenseKey(0, &bstr))
{
ASSERT(bstr != NULL);
// if length and content match, it's good!
UINT cch = SysStringByteLen(bstr);
if ((cch == SysStringByteLen(bstrKey)) &&
(memcmp(bstr, bstrKey, cch) == 0))
{
bLicensed = TRUE;
}
SysFreeString(bstr);
}
return bLicensed;
}
HRESULT
CCertExitSample::_NotifyNewCert(
/* [in] */ LONG Context)
{
HRESULT hr;
VARIANT varCert;
ICertServerExit *pServer = NULL;
VariantInit(&varCert);
// only call write fxns if server policy allows
if (m_dwExitPublishFlags & EXITPUB_FILE)
{
hr = CoCreateInstance(
CLSID_CCertServerExit,
NULL, // pUnkOuter
CLSCTX_INPROC_SERVER,
IID_ICertServerExit,
(VOID **) &pServer);
_JumpIfError(hr, error, "Exit:CoCreateInstance");
hr = pServer->SetContext(Context);
_JumpIfError(hr, error, "Exit:SetContext");
hr = exitGetProperty(
pServer,
FALSE, // fRequest,
wszPROPRAWCERTIFICATE,
PROPTYPE_BINARY,
&varCert);
_JumpIfErrorStr(
hr,
error,
"Exit:exitGetProperty",
wszPROPRAWCERTIFICATE);
if (VT_BSTR != varCert.vt)
{
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
_JumpError(hr, error, "Exit:BAD cert var type");
}
hr = _WriteCertToFile(
pServer,
(BYTE const *) varCert.bstrVal,
SysStringByteLen(varCert.bstrVal));
_JumpIfError(hr, error, "_WriteCertToFile");
}
hr = S_OK;
error:
VariantClear(&varCert);
if (NULL != pServer)
{
pServer->Release();
}
return(hr);
}
bool ConvertToFormatInfo (
CPropVariant &vGUID,
CPropVariant &vUpdate,
CPropVariant &vExtension,
CPropVariant &vSignature,
CPropVariant &vName,
FormatInfoInternal *pInfo
)
{
if ( (vGUID.vt != VT_BSTR) ||
(vUpdate.vt != VT_BOOL) ||
(vName.vt != VT_BSTR) )
return false;
memcpy (&pInfo->uid, vGUID.bstrVal, sizeof (GUID));
pInfo->bUpdate = (vUpdate.boolVal == VARIANT_TRUE);
int nLength;
if ( vExtension.vt == VT_BSTR )
{
nLength = SysStringLen (vExtension.bstrVal);
pInfo->lpDefaultExt = (char*)malloc (nLength+1);
memset (pInfo->lpDefaultExt, 0, nLength+1);
WideCharToMultiByte (CP_OEMCP, 0, vExtension.bstrVal, -1, pInfo->lpDefaultExt, nLength, NULL, NULL);
char *p = strchr(pInfo->lpDefaultExt, ' ');
if ( p )
*p = 0;
}
else
pInfo->lpDefaultExt = NULL;
if ( vSignature.vt == VT_BSTR )
{
nLength = SysStringByteLen(vSignature.bstrVal);
pInfo->lpSignature = (char*)malloc(nLength);
pInfo->nSignatureLength = nLength;
memcpy (pInfo->lpSignature, vSignature.bstrVal, nLength);
}
else
pInfo->lpSignature = NULL;
nLength = SysStringLen (vName.bstrVal);
pInfo->lpName = (char*)malloc (nLength+1+strlen(" archive [7z]"));
memset (pInfo->lpName, 0, nLength+1);
WideCharToMultiByte (CP_OEMCP, 0, vName.bstrVal, -1, pInfo->lpName, nLength, NULL, NULL);
strcat (pInfo->lpName, " archive [7z]");
return true;
}
STDMETHODIMP CDlrComServer::GetByteArray(SAFEARRAY **ppsaRetVal)
{
CComBSTR cbstrTestData(L"GetByteArrayTestData");
CComSafeArray<BYTE> csaData;
void HUGEP *pvData = NULL;
DWORD cbData;
HRESULT hr = S_OK;
// create a stream of bytes encoded as UNICODE text
cbData = SysStringByteLen(cbstrTestData.m_str);
hr = csaData.Create(cbData, 0);
if (FAILED(hr))
goto Error;
hr = SafeArrayAccessData((LPSAFEARRAY)csaData, (void HUGEP **)&pvData);
if (FAILED(hr))
goto Error;
memcpy((void*)pvData, cbstrTestData.m_str, cbData);
hr = SafeArrayUnaccessData((LPSAFEARRAY)csaData);
if (FAILED(hr))
goto Error;
if (FAILED(hr))
goto Error;
*ppsaRetVal = csaData.Detach();
Error:
return hr;
}
HRESULT CAzAppGroup::CopyVersion2Constructs(CAzAppGroup &srcAppGroup) {
static unsigned int rgProperties[]={AZ_PROP_GROUP_BIZRULE,AZ_PROP_GROUP_BIZRULE_LANGUAGE,AZ_PROP_GROUP_BIZRULE_IMPORTED_PATH};
CComVariant cVVar;
HRESULT hr=S_OK;
if (!CAzGlobalOptions::m_bVersionTwo)
goto lDone;
for (long i=0;i<3;i++) {
hr=srcAppGroup.m_native->GetProperty(rgProperties[i],CComVariant(), &cVVar);
CAzLogging::Log(hr,_TEXT("Getting IAzApplicationGroup Property ID:"),COLE2T(srcAppGroup.getName()),rgProperties[i]);
if (SUCCEEDED(hr) && (SysStringByteLen(cVVar.bstrVal))!=0) {
hr=m_native->SetProperty(rgProperties[i],cVVar,CComVariant());
CAzLogging::Log(hr,_TEXT("Setting IAzApplicationGroup Property ID:"),COLE2T(getName()),rgProperties[i]);
cVVar.Clear();
}
}
lDone:
return hr;
}
unsigned long WINAPI BSTR_UserSize(unsigned long *pFlags, unsigned long Start, BSTR *pstr)
{
TRACE("(%lx,%ld,%p) => %p\n", *pFlags, Start, pstr, *pstr);
if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
ALIGN_LENGTH(Start, 3);
Start += sizeof(bstr_wire_t) + ((SysStringByteLen(*pstr) + 1) & ~1);
TRACE("returning %ld\n", Start);
return Start;
}
ErrStringCopy(BSTR bstrSrc, BSTR FAR * pbstrOut)
{
BSTR bstrNew;
if((bstrNew = SysAllocStringByteLen((char FAR *)bstrSrc,
SysStringByteLen(bstrSrc))) == NULL)
return RESULT(E_OUTOFMEMORY);
*pbstrOut = bstrNew;
return NOERROR;
}
CMarkdown::HSTR CMarkdown::_HSTR::Convert(const Converter &converter)
{
HSTR H = this;
size_t s = SysStringByteLen(B);
if (size_t d = converter.Convert(A, s, 0, 0))
{
H = (HSTR)SysAllocStringByteLen(0, d);
converter.Convert(A, s, H->A, d);
SysFreeString(B);
}
return H;
}
HRESULT CBDictionary::putItem(VARIANT* pvarKey, VARIANT* pvar)
{
if(pvarKey->vt == VT_ERROR)return DISP_E_PARAMNOTOPTIONAL;
if(pvarKey->vt & VT_ARRAY)return E_INVALIDARG;
if(pvarKey->vt == VT_BSTR)
{
if(pvarKey->bstrVal == NULL)
return DISP_E_TYPEMISMATCH;
UINT len = SysStringByteLen(pvarKey->bstrVal);
if(len & 1)
return DISP_E_TYPEMISMATCH;
for(UINT i = 0; i < len / 2; i ++)
if(pvarKey->bstrVal[i] == 0)
return DISP_E_TYPEMISMATCH;
}
if(pvar->vt == VT_ERROR)
return DISP_E_PARAMNOTOPTIONAL;
m_cs.Enter();
if(m_bArrayMode && (pvarKey->vt == VT_I4 || pvarKey->vt == VT_I2))
{
long i = varGetNumber(*pvarKey);
if(i >=0 && i < (int)m_posArray.GetCount())
{
VariantCopyInd(&m_posArray[i]->m_value, pvar);
m_cs.Leave();
return S_OK;
}
}
CRBMap<CBVariant, CComVariant>::CPair* pPair = m_mapItems.Lookup(*(CBVariant*)pvarKey);
if(pPair == NULL)
{
static VARIANT varTemp;
pPair = (CRBMap<CBVariant, CComVariant>::CPair*)m_mapItems.SetAt(*(CBVariant*)pvarKey, varTemp);
m_posArray.Add(pPair);
}
VariantCopyInd(&pPair->m_value, pvar);
m_cs.Leave();
return S_OK;
}
CMarkdown::HSTR CMarkdown::_HSTR::Unicode(UINT codepage)
{
HSTR H = this;
if (codepage != 1200) // 1200 means 'no conversion'
{
int a = SysStringByteLen(B);
int w = MultiByteToWideChar(codepage, 0, A, a, 0, 0);
H = (HSTR)SysAllocStringLen(0, w);
MultiByteToWideChar(codepage, 0, A, a, H->W, w);
SysFreeString(B);
}
return H;
}
BOOL WINAPI CRTfunc(LPWSTR *Buf,size_t cnt,BSTR arg1,BSTR arg2,BSTR arg3,BSTR arg4,BSTR arg5)
{
UINT len = SysStringByteLen( arg1 );
memcpy(*Buf, arg1, len);
LPWSTR p = *Buf+ SysStringLen ( arg1 );
len = SysStringByteLen( arg2 );
memcpy(p, arg2, len);
p = p+ SysStringLen ( arg2 );
len = SysStringByteLen( arg3 );
memcpy(p, arg3, len);
p = p+ SysStringLen ( arg3 );
len = SysStringByteLen( arg4 );
memcpy(p, arg4, len);
p = p+ SysStringLen ( arg4 );
len = SysStringByteLen( arg5 );
memcpy(p, arg5, len);
return TRUE;
}
HRESULT ArcLib::get_bytes_prop(UInt32 index, PROPID prop_id, ByteVector& value) const {
PropVariant prop;
HRESULT res = get_prop(index, prop_id, prop.ref());
if (res != S_OK)
return res;
if (prop.vt == VT_BSTR) {
UINT len = SysStringByteLen(prop.bstrVal);
unsigned char* data = reinterpret_cast<unsigned char*>(prop.bstrVal);
value.assign(data, data + len);
}
else
return E_FAIL;
return S_OK;
}
STDMETHODIMP CID3Field::put_Binary(BSTR newVal)
{
// TODO: Add your implementation code here
try
{
size_t Size = SysStringByteLen(newVal);
m_Field->Set((const uchar *)newVal,Size);
}
catch (...)
{
return Error(IDS_UNEXPECTED_ERROR, IID_IID3ComField, E_UNEXPECTED);
}
return S_OK;
}
HRESULT BstrStream::WriteBstr(BSTR bstr)
{
UINT nlen = SysStringByteLen(bstr);
ULONG written = 0, pos = 0, cb = nlen;
HRESULT hr;
LPBYTE pbuf = (LPBYTE)bstr;
for ( ; pos < nlen; cb -= written, pos += written) {
hr = Write(&pbuf[pos], cb, &written);
if (FAILED(hr)) return hr;
}
return S_OK;
}
static char* _StrClone(const BSTR bstr)
{
UINT blen = SysStringLen(bstr);
UINT alen = SysStringByteLen(bstr);
char* astr = new char[alen + 1];
if (!astr)
return 0;
memset(astr, 0, alen + 1);
WideCharToMultiByte(CP_ACP, 0, bstr, blen, astr, alen, NULL, NULL);
return astr;
}
size_t TP_SysStringByteLen(BSTR bstr)
{
#ifdef WINDOWS
return SysStringByteLen(bstr);
#else
if(bstr == NULL)
return 0;
int32_t * p32 = (int32_t *) bstr;
int32_t * p32_1 = p32 -1;
DWORD * d32 = (DWORD *) bstr;
DWORD * d32_1 = d32 - 1;
//std::cout << p32 << p32_1 << endl;
//std::cout << d32 << d32_1 << endl;
return (unsigned int)(((DWORD *)bstr)[-1]);
#endif
}
HRESULT VariantCopy(VARIANTARG *dest, VARIANTARG *src)
{
HRESULT res = ::VariantClear(dest);
if (res != S_OK)
return res;
if (src->vt == VT_BSTR)
{
dest->bstrVal = SysAllocStringByteLen((LPCSTR)src->bstrVal,
SysStringByteLen(src->bstrVal));
if (dest->bstrVal == 0)
return E_OUTOFMEMORY;
dest->vt = VT_BSTR;
}
else
*dest = *src;
return S_OK;
}
HRESULT BstrStream::ReadBstr(BSTR *bstr)
{
*bstr = SysAllocStringByteLen(NULL, avail());
UINT nlen = SysStringByteLen(*bstr);
ULONG read = 0, pos = 0, cb = nlen;
HRESULT hr;
LPBYTE pbuf = (LPBYTE)*bstr;
for ( ; pos < nlen; cb -= read, pos += read) {
hr = Read(&pbuf[pos], cb, &read);
if (FAILED(hr)) {
SysFreeString(*bstr);
return hr;
}
if (read == 0) break;
}
return S_OK;
}
STDMETHODIMP
CCertEncodeAltName::Decode(
/* [in] */ BSTR const strBinary)
{
HRESULT hr = S_OK;
_Cleanup();
if (NULL == strBinary)
{
hr = E_POINTER;
ceERRORPRINTLINE("NULL parm", hr);
goto error;
}
// Decode CERT_ALT_NAME_INFO:
if (!ceDecodeObject(
X509_ASN_ENCODING,
X509_ALTERNATE_NAME,
(BYTE *) strBinary,
SysStringByteLen(strBinary),
FALSE,
(VOID **) &m_DecodeInfo,
&m_DecodeLength))
{
hr = ceHLastError();
ceERRORPRINTLINE("ceDecodeObject", hr);
goto error;
}
m_aValue = m_DecodeInfo->rgAltEntry;
m_cValue = m_DecodeInfo->cAltEntry;
error:
if (S_OK != hr)
{
_Cleanup();
}
return(_SetErrorInfo(hr, L"CCertEncodeAltName::Decode"));
}
/************************************************************************
* VectorFromBstr (OLEAUT32.@)
*
* Create a SafeArray Vector from the bytes of a BSTR.
*
* PARAMS
* bstr [I] String to get bytes from
* ppsa [O] Destination for the array
*
* RETURNS
* Success: S_OK. ppsa contains the strings bytes as a VT_UI1 array.
* Failure: An HRESULT error code indicating the error.
*
* NOTES
* See SafeArray.
*/
HRESULT WINAPI VectorFromBstr(BSTR bstr, SAFEARRAY **ppsa)
{
SAFEARRAYBOUND sab;
TRACE("(%p,%p)\n", bstr, ppsa);
if (!ppsa)
return E_INVALIDARG;
sab.lLbound = 0;
sab.cElements = SysStringByteLen(bstr);
*ppsa = SAFEARRAY_Create(VT_UI1, 1, &sab, 0);
if (*ppsa)
{
memcpy((*ppsa)->pvData, bstr, sab.cElements);
return S_OK;
}
return E_OUTOFMEMORY;
}
unsigned char * WINAPI BSTR_UserMarshal(unsigned long *pFlags, unsigned char *Buffer, BSTR *pstr)
{
bstr_wire_t *header;
DWORD len = SysStringByteLen(*pstr);
TRACE("(%lx,%p,%p) => %p\n", *pFlags, Buffer, pstr, *pstr);
if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
ALIGN_POINTER(Buffer, 3);
header = (bstr_wire_t*)Buffer;
header->len = header->len2 = (len + 1) / 2;
if (*pstr)
{
header->byte_len = len;
memcpy(header + 1, *pstr, header->len * 2);
}
else
header->byte_len = 0xffffffff; /* special case for a null bstr */
return Buffer + sizeof(*header) + sizeof(OLECHAR) * header->len;
}
static void test_TxSetText(void)
{
HRESULT hres;
BSTR rettext;
WCHAR settext[] = {'T','e','s','t',0};
if (!init_texthost())
return;
hres = ITextServices_TxSetText(txtserv, settext);
ok(hres == S_OK, "ITextServices_TxSetText failed (result = %x)\n", hres);
hres = ITextServices_TxGetText(txtserv, &rettext);
ok(hres == S_OK, "ITextServices_TxGetText failed (result = %x)\n", hres);
ok(SysStringLen(rettext) == 4,
"String returned of wrong length (expected 4, got %d)\n", SysStringLen(rettext));
ok(memcmp(rettext,settext,SysStringByteLen(rettext)) == 0,
"String returned differs\n");
SysFreeString(rettext);
free_texthost();
}
static void test_TxSetText(void)
{
ITextServices *txtserv;
ITextHost *host;
HRESULT hres;
BSTR rettext;
WCHAR settext[] = {'T','e','s','t',0};
if (!init_texthost(&txtserv, &host))
return;
hres = ITextServices_TxSetText(txtserv, settext);
ok(hres == S_OK, "ITextServices_TxSetText failed (result = %x)\n", hres);
hres = ITextServices_TxGetText(txtserv, &rettext);
ok(hres == S_OK, "ITextServices_TxGetText failed (result = %x)\n", hres);
ok(SysStringLen(rettext) == 4,
"String returned of wrong length (expected 4, got %d)\n", SysStringLen(rettext));
ok(memcmp(rettext,settext,SysStringByteLen(rettext)) == 0,
"String returned differs\n");
/* Null-pointer should behave the same as empty-string */
hres = ITextServices_TxSetText(txtserv, 0);
ok(hres == S_OK, "ITextServices_TxSetText failed (result = %x)\n", hres);
hres = ITextServices_TxGetText(txtserv, &rettext);
ok(hres == S_OK, "ITextServices_TxGetText failed (result = %x)\n", hres);
ok(SysStringLen(rettext) == 0,
"String returned of wrong length (expected 0, got %d)\n", SysStringLen(rettext));
SysFreeString(rettext);
ITextServices_Release(txtserv);
ITextHost_Release(host);
}
// ----------------------------------------------------------------------------------
// SSOWebAccessible()
// ----------------------------------------------------------------------------------
// SSO commun aux navigateurs implémentant l'interface IAccessible
// Utilise forcément la méthode de configuration simplifiée
// ----------------------------------------------------------------------------------
// [out] 0=OK, -1=pas réussi (champs non trouvés ou autre erreur)
// ----------------------------------------------------------------------------------
int SSOWebAccessible(HWND w,int iAction,int iBrowser)
{
TRACE((TRACE_ENTER,_F_, "w=0x%08lx iAction=%d iBrowser=%d",w,iAction,iBrowser));
int rc=-1;
IAccessible *pAccessible=NULL;
IAccessible *pTopAccessible=NULL;
IDispatch *pIDispatch=NULL;
int i;
T_SUIVI_ACCESSIBLE tSuivi,*ptSuivi;
HRESULT hr;
long lCount;
VARIANT vtChild,vtState;
int iId1Index;
int iId2Index;
int iId3Index;
int iId4Index;
IAccessible *pNiveau0=NULL,*pChildNiveau1=NULL, *pChildNiveau2=NULL;
int iNbTry;
// ISSUE#39 : important, initialisation pour que le pointer iAccessible soit à NULL sinon le release provoque plantage !
ZeroMemory(&tSuivi,sizeof(T_SUIVI_ACCESSIBLE));
// BROWSER_MAXTHON: strcpy_s(tSuivi.szClassName,sizeof(tSuivi.szClassName),"Afx:400000:2008:10011:0:0");
tSuivi.w=NULL;
if (iBrowser==BROWSER_IE)
{
// enum des fils à la recherche de la fenêtre de rendu Web
// ISSUE#70 0.95 essaie aussi avec contenu flash (à faire en 1er)
// pour tester le flash : http://itmj.homelinux.org:9090/workspace/Main.html?ap=1
strcpy_s(tSuivi.szClassName,sizeof(tSuivi.szClassName),"MacromediaFlashPlayerActiveX");
EnumChildWindows(w,WebEnumChildProc,(LPARAM)&tSuivi);
if (tSuivi.w!=NULL) { TRACE((TRACE_INFO,_F_,"MacromediaFlashPlayerActiveX. Visible = %d",IsWindowVisible(tSuivi.w))); }
if (tSuivi.w==NULL || ((tSuivi.w!=NULL) && (!IsWindowVisible(tSuivi.w)))) // pas trouvé de flash ou trouvé flash mais non visible
{
strcpy_s(tSuivi.szClassName,sizeof(tSuivi.szClassName),"Internet Explorer_Server");
EnumChildWindows(w,WebEnumChildProc,(LPARAM)&tSuivi);
if (tSuivi.w!=NULL) { TRACE((TRACE_INFO,_F_,"Internet Explorer_Server = %d",IsWindowVisible(tSuivi.w))); }
}
if (tSuivi.w==NULL) { TRACE((TRACE_ERROR,_F_,"EnumChildWindows() => pas trouve la fenetre de contenu")); goto end; }
// Obtient un IAccessible
hr=AccessibleObjectFromWindow(tSuivi.w,(DWORD)OBJID_CLIENT,IID_IAccessible,(void**)&pAccessible);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"AccessibleObjectFromWindow(IID_IAccessible)=0x%08lx",hr)); goto end; }
}
else if (iBrowser==BROWSER_CHROME)
{
// enum des fils à la recherche de la fenêtre de rendu Web
strcpy_s(tSuivi.szClassName,sizeof(tSuivi.szClassName),"Chrome_RenderWidgetHostHWND");
// ISSUE #98 . 0.99 : pour chrome 33 ou 34+, l'énumération refonctionne (cf ISSUE#95 plus bas) mais la fenêtre
// qu'on récupère ne fonctionne pas. Elle a un vtRole.lVal=0x0000000a au lieu de vtRole.lVal=0x0000000f, et 0 childs !
// La version 34 de Chrome se reconnait grace à la fenêtre de classe static qui est remontée juste avant celle
// qu'on cherche, du coup si je trouve fenêtre static, je rebranche sur la recherche sans énumération
// 11/01-15:53:58:470 DEBUG WebEnumChildProc Fenetre classe=Static w=0x00030618
// 11/01-15:53:58:470 DEBUG WebEnumChildProc Fenetre classe=Chrome_RenderWidgetHostHWND w=0x00080120
strcpy_s(tSuivi.szExclude,sizeof(tSuivi.szExclude),"Static");
EnumChildWindows(w,WebEnumChildProc,(LPARAM)&tSuivi);
if (tSuivi.w==NULL)
{
// ISSUE#95 / 0.98 : pour Chome 31 ou 32+, impossible de rechercher la fenêtre fille, on est obligé de passer par IAccessible :
// La fenêtre principale a 1 child de niveau 1, il faut prendre le 1er.
// Le child de niveau 1 a 2 childs, il faut prendre le 2eme.
// Le child de niveau 2 a 4 childs, il faut prendre le 2eme --> c'est la fenêtre de contenu web !
hr=AccessibleObjectFromWindow(w,(DWORD)OBJID_CLIENT,IID_IAccessible,(void**)&pNiveau0);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"AccessibleObjectFromWindow(IID_IAccessible)=0x%08lx",hr)); goto end; }
// La fenêtre principale a 1 child de niveau 1, il faut prendre le 1er.
vtChild.vt=VT_I4;
vtChild.lVal=1;
hr=pNiveau0->get_accChild(vtChild,&pIDispatch);
TRACE((TRACE_DEBUG,_F_,"pAccessible->get_accChild(%ld)=0x%08lx",vtChild.lVal,hr));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accChild(%ld)=0x%08lx",vtChild.lVal,hr)); goto end; }
hr=pIDispatch->QueryInterface(IID_IAccessible, (void**) &pChildNiveau1);
TRACE((TRACE_DEBUG,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr)); goto end; }
pIDispatch->Release(); pIDispatch=NULL;
// Le child de niveau 1 a 2 childs, il faut prendre le 2eme.
vtChild.vt=VT_I4;
vtChild.lVal=2;
hr=pChildNiveau1->get_accChild(vtChild,&pIDispatch);
TRACE((TRACE_DEBUG,_F_,"pChildNiveau1->get_accChild(%ld)=0x%08lx",vtChild.lVal,hr));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accChild(%ld)=0x%08lx",vtChild.lVal,hr)); goto end; }
hr=pIDispatch->QueryInterface(IID_IAccessible, (void**) &pChildNiveau2);
TRACE((TRACE_DEBUG,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr)); goto end; }
pIDispatch->Release(); pIDispatch=NULL;
// Le child de niveau 2 a 4 childs, il faut prendre le 2eme.
vtChild.vt=VT_I4;
vtChild.lVal=2;
hr=pChildNiveau2->get_accChild(vtChild,&pIDispatch);
TRACE((TRACE_DEBUG,_F_,"pChildNiveau2->get_accChild(%ld)=0x%08lx",vtChild.lVal,hr));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accChild(%ld)=0x%08lx",vtChild.lVal,hr)); goto end; }
hr=pIDispatch->QueryInterface(IID_IAccessible, (void**) &pAccessible);
TRACE((TRACE_DEBUG,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr)); goto end; }
pIDispatch->Release(); pIDispatch=NULL;
}
else
{
// Obtient un IAccessible
hr=AccessibleObjectFromWindow(tSuivi.w,(DWORD)OBJID_CLIENT,IID_IAccessible,(void**)&pAccessible);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"AccessibleObjectFromWindow(IID_IAccessible)=0x%08lx",hr)); goto end; }
}
VARIANT vtMe,vtRole;
vtMe.vt=VT_I4;
vtMe.lVal=CHILDID_SELF;
hr=pAccessible->get_accRole(vtMe,&vtRole);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accRole()=0x%08lx",hr)); goto end; }
TRACE((TRACE_DEBUG,_F_,"get_accRole() vtRole.lVal=0x%08lx",vtRole.lVal));
}
else if (iBrowser==BROWSER_FIREFOX3 || iBrowser==BROWSER_FIREFOX4)
{
// accNavigate permet de trouver la fenêtre de rendu web
hr=AccessibleObjectFromWindow(w,(DWORD)OBJID_CLIENT,IID_IAccessible,(void**)&pTopAccessible);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"AccessibleObjectFromWindow(IID_IAccessible)=0x%08lx",hr)); goto end; }
VARIANT vtStart,vtResult;
vtStart.vt=VT_I4;
vtStart.lVal=CHILDID_SELF;
hr=pTopAccessible->accNavigate(0x1009,vtStart,&vtResult); // NAVRELATION_EMBEDS = 0x1009
pTopAccessible->Release();pTopAccessible=NULL;
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"accNavigate(NAVRELATION_EMBEDS)=0x%08lx",hr)); goto end; }
TRACE((TRACE_DEBUG,_F_,"accNavigate(NAVRELATION_EMBEDS) vtEnd=%ld",vtResult.lVal));
if (vtResult.vt!=VT_DISPATCH) { TRACE((TRACE_ERROR,_F_,"accNavigate(NAVRELATION_EMBEDS) is not VT_DISPATCH")); goto end; }
pIDispatch=(IDispatch*)vtResult.lVal;
if (pIDispatch==NULL) { TRACE((TRACE_ERROR,_F_,"accNavigate(NAVRELATION_EMBEDS) pIDispatch=NULL")); goto end; }
hr=pIDispatch->QueryInterface(IID_IAccessible, (void**)&pAccessible);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"QueryInterface(IID_IAccessible)=0x%08lx",hr)); goto end; }
}
// à ce stade, on a un pAccessible pour travailler, quel que soit le navigateur
vtChild.vt=VT_I4;
vtChild.lVal=CHILDID_SELF;
VariantInit(&vtState);
hr=pAccessible->get_accState(vtChild,&vtState);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accState()=0x%08lx",hr)); goto end; }
TRACE((TRACE_DEBUG,_F_,"get_accState(DOCUMENT PRINCIPAL) vtState.lVal=0x%08lx",vtState.lVal));
// ISSUE#163 : plutôt que d'attendre 1 fois 5 secondes, on attend 5 fois 100ms et ensuite on continue,
// ça ne semble pas être bloquant surtout que Chrome et IE ont l'air de se mettre BUSY dès qu'ils n'ont pas le focus...
iNbTry=1;
while ((vtState.lVal & STATE_SYSTEM_BUSY) && iNbTry < 6)
{
TRACE((TRACE_DEBUG,_F_,"STATE_SYSTEM_BUSY -- wait 100ms before retry #%d (max 5)",iNbTry));
Sleep(100);
VariantInit(&vtState);
hr=pAccessible->get_accState(vtChild,&vtState);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accState()=0x%08lx",hr)); }
TRACE((TRACE_DEBUG,_F_,"get_accState(DOCUMENT PRINCIPAL) vtState.lVal=0x%08lx",vtState.lVal));
iNbTry++;
}
lCount=0;
hr=pAccessible->get_accChildCount(&lCount);
TRACE((TRACE_DEBUG,_F_,"get_accChildCount() hr=0x%08lx lCount=%ld",hr,lCount));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accChildCount() hr=0x%08lx",hr)); goto end; }
if (iBrowser==BROWSER_CHROME) // lCount=0 arrive parfois quelque fois après ouverture d'un nouvel onglet
{
iNbTry=0;
while (lCount==0 && iNbTry<10) // ajouté en 0.93B1 : 10 essais supplémentaires au lieu d'un seul
{
Sleep(150);
pAccessible->Release();
pAccessible=NULL;
// Obtient un IAccessible
hr=AccessibleObjectFromWindow(tSuivi.w,(DWORD)OBJID_CLIENT,IID_IAccessible,(void**)&pAccessible);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"AccessibleObjectFromWindow(IID_IAccessible)=0x%08lx",hr)); goto end; }
hr=pAccessible->get_accChildCount(&lCount);
TRACE((TRACE_DEBUG,_F_,"get_accChildCount() hr=0x%08lx lCount=%ld",hr,lCount));
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accChildCount() hr=0x%08lx",hr)); goto end; }
iNbTry++;
}
if (lCount==0) // ça n'a toujours pas marché, on abandonne...
{
TRACE((TRACE_ERROR,_F_,"get_accChildCount() hr=0x%08lx",hr)); goto end;
}
}
ZeroMemory(&tSuivi,sizeof(T_SUIVI_ACCESSIBLE)); // déplacé plus haut, mais laissé ici aussi dans le doute ça coute pas cher.
tSuivi.w=w;
tSuivi.iAction=iAction;
tSuivi.iErreur=0;
tSuivi.iLevel=0;
tSuivi.iPwdIndex=-1;
tSuivi.iNbPwdFound=0;
tSuivi.iBrowser=iBrowser; // ISSUE#279
#ifdef TRACES_ACTIVEES
DoWebAccessible("",w,pAccessible,&tSuivi);
#else
DoWebAccessible(w,pAccessible,&tSuivi);
#endif
TRACE((TRACE_INFO,_F_,"tSuivi.iErreur=%d",tSuivi.iErreur));
if (tSuivi.iErreur==0)
{
ptSuivi=&tSuivi;
vtChild.vt=VT_I4;
vtChild.lVal=CHILDID_SELF;
// 0.93B1 / ISSUE#40 : avant de démarrer les saisies, il faut vérifier qu'on a trouvé tous les champs attendus
// En effet, comme on ne cherche plus les champs par leurs noms, on peut provoquer des mises au premier plan intempestives
// de la fenêtre du navigateur si le titre et l'URL ne permettent pas de reconnaitre la page de login de manière certaine
TRACE((TRACE_INFO,_F_,"Page analysee, verification (lCount=%d ptSuivi->iTextFieldIndex=%d)",lCount,ptSuivi->iTextFieldIndex));
// 0.99B3 / ISSUE#103 : En mode configration simplifiée, la position du champ identifiant est considérée comme absolue
// si le champ de mot de passe est configuré à 0
// if (*gptActions[ptSuivi->iAction].szPwdName!=0 && ptSuivi->iPwdIndex==-1)
if (*gptActions[ptSuivi->iAction].szPwdName!=0 && atoi(gptActions[ptSuivi->iAction].szPwdName)!=0 && ptSuivi->iPwdIndex==-1)
{
TRACE((TRACE_ERROR,_F_,"Un champ mot de passe etait attendu mais n'a pas ete trouve => le SSO ne sera pas execute"));
goto end;
}
iId1Index=GetAbsolutePos(gptActions[ptSuivi->iAction].szId1Name,gptActions[ptSuivi->iAction].szPwdName,ptSuivi->iPwdIndex,ptSuivi);
iId2Index=GetAbsolutePos(gptActions[ptSuivi->iAction].szId2Name,gptActions[ptSuivi->iAction].szPwdName,ptSuivi->iPwdIndex,ptSuivi);
iId3Index=GetAbsolutePos(gptActions[ptSuivi->iAction].szId3Name,gptActions[ptSuivi->iAction].szPwdName,ptSuivi->iPwdIndex,ptSuivi);
iId4Index=GetAbsolutePos(gptActions[ptSuivi->iAction].szId4Name,gptActions[ptSuivi->iAction].szPwdName,ptSuivi->iPwdIndex,ptSuivi);
if (iId1Index==-1 || iId2Index==-1 || iId3Index==-1 || iId4Index==-1)
{
TRACE((TRACE_ERROR,_F_,"Au moins un des champs n'a pas ete trouve => le SSO ne sera pas execute"));
goto end;
}
// Vérification OK, on peut mettre la fenêtre au premier plan et démarrer les saisies
TRACE((TRACE_INFO,_F_,"Verifications OK, demarrage des saisies (lCount=%d ptSuivi->iTextFieldIndex=%d)",lCount,ptSuivi->iTextFieldIndex));
SetForegroundWindow(ptSuivi->w);
// ISSUE#266 : Bidouille contournement incident ouvert sur chromium : 533830
if (iBrowser==BROWSER_CHROME && gpAccessibleChromeURL!=NULL)
{
VARIANT vtSelf;
VARIANT vtURLBarState;
vtSelf.vt=VT_I4;
vtSelf.lVal=CHILDID_SELF;
hr=gpAccessibleChromeURL->get_accState(vtSelf,&vtURLBarState);
TRACE((TRACE_DEBUG,_F_,"get_accState() vtURLBarState.lVal=0x%08lx",vtURLBarState.lVal));
if (vtURLBarState.lVal & STATE_SYSTEM_FOCUSED)
{
TRACE((TRACE_INFO,_F_,"BIDOUILLE BARRE URL CHROME !")); // on tabule jusqu'à mettre le focus sur champ id1 ou pwd
KBSimEx(w,"[TAB]","","","","","");
int iAntiLoop=0;
VARIANT vtIdOrPwdState;
vtIdOrPwdState.lVal=0;
while ((!(vtIdOrPwdState.lVal & STATE_SYSTEM_FOCUSED)) && iAntiLoop <10)
{
KBSimEx(w,"[TAB]","","","","","");
Sleep(10);
if (iId1Index>=0)
{
hr=ptSuivi->pTextFields[iId1Index]->accSelect(SELFLAG_TAKEFOCUS,vtChild);
TRACE((TRACE_DEBUG,_F_,"accSelect(id1)=0x%08lx",hr));
hr=ptSuivi->pTextFields[iId1Index]->get_accState(vtSelf,&vtIdOrPwdState);
TRACE((TRACE_DEBUG,_F_,"get_accState(id1)=0x%08lx vtId1State.lVal=0x%08lx",hr,vtIdOrPwdState.lVal));
}
else if (ptSuivi->iPwdIndex!=-1)
{
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->accSelect(SELFLAG_TAKEFOCUS,vtChild);
TRACE((TRACE_DEBUG,_F_,"accSelect(pwd)=0x%08lx",hr));
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->get_accState(vtSelf,&vtIdOrPwdState);
TRACE((TRACE_DEBUG,_F_,"get_accState(pwd)=0x%08lx vtId1State.lVal=0x%08lx",hr,vtIdOrPwdState.lVal));
}
else // tant pis, cas à peu près impossible, on sort
{
break;
}
iAntiLoop++;
}
}
}
// fin bidouille chrome
if (iId1Index>=0) PutAccValue(ptSuivi->w,ptSuivi->pTextFields[iId1Index],vtChild,gptActions[ptSuivi->iAction].szId1Value);
if (iId2Index>=0) PutAccValue(ptSuivi->w,ptSuivi->pTextFields[iId2Index],vtChild,gptActions[ptSuivi->iAction].szId2Value);
if (iId3Index>=0) PutAccValue(ptSuivi->w,ptSuivi->pTextFields[iId3Index],vtChild,gptActions[ptSuivi->iAction].szId3Value);
if (iId4Index>=0) PutAccValue(ptSuivi->w,ptSuivi->pTextFields[iId4Index],vtChild,gptActions[ptSuivi->iAction].szId4Value);
// Mdp
if (ptSuivi->iPwdIndex!=-1)
{
// CODE A GARDER POUR BUGS OUVERTS CHEZ CHROME #75908 et #75911
/*
int iAntiLoop=0;
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->accSelect(SELFLAG_TAKEFOCUS,vtChild);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"accSelect(SELFLAG_TAKEFOCUS)=0x%08lx",hr)); }
TRACE((TRACE_DEBUG,_F_,"accSelect(SELFLAG_TAKEFOCUS)=0x%08lx",hr));
VARIANT vtSelf;
VARIANT vtState;
vtSelf.vt=VT_I4;
vtSelf.lVal=CHILDID_SELF;
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->get_accState(vtSelf,&vtState);
TRACE((TRACE_DEBUG,_F_,"get_accState() vtState.lVal=0x%08lx",vtState.lVal));
while (iAntiLoop <50)
//while ((!(vtState.lVal & STATE_SYSTEM_FOCUSED)) && iAntiLoop <10)
{
Sleep(100);
KBSimEx(w,"[TAB]","","","","","");
Sleep(100);
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->get_accState(vtSelf,&vtState);
if (FAILED(hr)) { TRACE((TRACE_ERROR,_F_,"get_accState(CHILDID_SELF)=0x%08lx",hr)); }
TRACE((TRACE_DEBUG,_F_,"get_accState() vtState.lVal=0x%08lx",vtState.lVal));
iAntiLoop++;
}
*/
Sleep(100); // ISSUE#163 (et autres problèmes, notamment identifiant saisi tronqué avec le reste dans le mot de passe)
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->accSelect(SELFLAG_TAKEFOCUS,vtChild);
if (FAILED(hr)) // ISSUE#251 : en cas d'erreur du accSelect (vu UNE fois), on fait TAB à l'aveugle, ça évite de taper le mdp dans le champ id
{
TRACE((TRACE_ERROR,_F_,"accSelect(SELFLAG_TAKEFOCUS)=0x%08lx",hr));
// remarque : nombre de tab à faire = fonction de la position relative du champ id par rapport au champ mdp
Sleep(100);
for (i=0; i<abs(atoi(gptActions[ptSuivi->iAction].szId1Name));i++) { KBSimEx(w,"[TAB]","","","","",""); }
Sleep(100);
}
if ((*gptActions[ptSuivi->iAction].szPwdEncryptedValue!=0))
{
//char *pszPassword=swCryptDecryptString(gptActions[ptSuivi->iAction].szPwdEncryptedValue,ghKey1);
char *pszPassword=GetDecryptedPwd(gptActions[ptSuivi->iAction].szPwdEncryptedValue);
if (pszPassword!=NULL)
{
// 1.09B2 : essaie de faire put_accValue avant de se rabattre sur la simulation de frappe
BSTR bstrValue=GetBSTRFromSZ(pszPassword);
hr=S_OK;
if (bstrValue!=NULL)
{
hr=ptSuivi->pTextFields[ptSuivi->iPwdIndex]->put_accValue(vtChild,bstrValue);
TRACE((TRACE_INFO,_F_,"pAccessible->put_accValue() : hr=0x%08lx",hr));
}
if (bstrValue==NULL || FAILED(hr))
{
KBSim(ptSuivi->w,TRUE,100,pszPassword,TRUE);
}
if (bstrValue!=NULL)
{
SecureZeroMemory(bstrValue,SysStringByteLen(bstrValue));
SysFreeString(bstrValue); bstrValue=NULL;
}
SecureZeroMemory(pszPassword,strlen(pszPassword));
free(pszPassword);
}
}
}
// Validation si demandée
if (*gptActions[ptSuivi->iAction].szValidateName!=0)
{
Sleep(100);
// ISSUE#101
// KBSimEx(NULL,gptActions[ptSuivi->iAction].szValidateName,"","","","","");
// ISSUE#101 suite : on autorise aussi le mot de passe sinon c'est naze...
char szDecryptedPassword[LEN_PWD+1];
// char *pszPassword=swCryptDecryptString(gptActions[ptSuivi->iAction].szPwdEncryptedValue,ghKey1);
char *pszPassword=GetDecryptedPwd(gptActions[ptSuivi->iAction].szPwdEncryptedValue);
if (pszPassword!=NULL)
{
strcpy_s(szDecryptedPassword,sizeof(szDecryptedPassword),pszPassword);
SecureZeroMemory(pszPassword,strlen(pszPassword));
free(pszPassword);
}
else
{
*szDecryptedPassword=0;
}
KBSimEx(NULL,gptActions[ptSuivi->iAction].szValidateName,
gptActions[iAction].szId1Value,
gptActions[iAction].szId2Value,
gptActions[iAction].szId3Value,
gptActions[iAction].szId4Value,szDecryptedPassword);
SecureZeroMemory(szDecryptedPassword,sizeof(szDecryptedPassword));
}
guiNbWEBSSO++;
}
rc=0;
end:
for (i=0;i<MAX_TEXT_FIELDS;i++) if (tSuivi.pTextFields[i]!=NULL) tSuivi.pTextFields[i]->Release();
if (pAccessible!=NULL) pAccessible->Release();
if (pTopAccessible!=NULL) pTopAccessible->Release();
if (pIDispatch!=NULL) pIDispatch->Release();
if (pNiveau0!=NULL) pNiveau0->Release();
if (pChildNiveau1!=NULL) pChildNiveau1->Release();
if (pChildNiveau2!=NULL) pChildNiveau2->Release();
if (gpAccessibleChromeURL!=NULL) { gpAccessibleChromeURL->Release(); gpAccessibleChromeURL=NULL; }
TRACE((TRACE_LEAVE,_F_, "rc=%d",rc));
return rc;
}
UINT SysStringLen(BSTR bstr)
{
return SysStringByteLen(bstr) / sizeof(OLECHAR);
}
// convert a VARIANT to a J array
// returns 0 on error with detail in jerr.
static A v2a(J jt, VARIANT* v, int dobstrs)
{
A a;
SAFEARRAY* psa;
SAFEARRAYBOUND* pb;
I shape[MAXRANK];
I k=1,n,r,i;
I* pintsnk;
#if SY_64
int* pint32src;
#else
long long* pint64src;
#endif
short* pshortsrc;
unsigned short* pboolsrc;
char* pboolsnk;
VARTYPE t;
int byref;
double* pdoublesnk;
float* pfloatsrc;
#define OPTREF(v,field) (byref ? *v->p##field : v->field)
t=v->vt;
byref = t & VT_BYREF;
t = t & ~VT_BYREF;
if(dobstrs && t == VT_BSTR)
{
BSTR bstr; int len;
bstr = OPTREF(v,bstrVal);
if(uniflag)
// len=SysStringLen(bstr);
len=WideCharToMultiByte(CP_UTF8,0,bstr,(int)SysStringLen(bstr),0,0,0,0);
else
len=SysStringByteLen(bstr);
RE(a=ga(LIT, len, 1, 0));
if(uniflag)
toutf8n(bstr, (C*)AV(a), len);
else
memcpy((C*)AV(a), (C*)bstr, len);
R a;
}
if(t & VT_ARRAY)
{
psa = OPTREF(v,parray);
pb = psa->rgsabound;
r=psa->cDims;
ASSERT(r<=MAXRANK,EVRANK);
for(i=0; i<r; ++i)
{
n = pb[i].cElements;
shape[i] = n;
k *= n;
}
}
else
r = 0;
switch(t)
{
case VT_VARIANT | VT_ARRAY:
{
A *boxes;
VARIANT* pv;
// fixup scalar boxes which arrive
// as a 1-elem vector with a lower bound at -1, not 0.
if (pb[0].lLbound == -1)
{
ASSERT(psa->cDims==1 && pb[0].cElements==1, EVDOMAIN);
r = 0;
}
RE(a=ga(BOX, k, r, (I*)&shape));
ASSERT(S_OK==SafeArrayAccessData(psa, &pv),EVFACE);
boxes = AAV(a);
while(k--)
{
A z;
// Don't use a PROLOG/EPILOG during v2a.
// The z's are not getting their reference
// count set until everything is in place
// and the jset() is done in Jset().
z = *boxes++ = v2a(jt, pv++, dobstrs);
if (!z) break;
}
SafeArrayUnaccessData(psa);
if (jt->jerr) return 0;
break;
}
case VT_BOOL | VT_ARRAY:
RE(a=ga(B01, k, r, (I*)&shape));
pboolsrc = (VARIANT_BOOL*)psa->pvData;
pboolsnk = BAV(a);
// J bool returned from VB boolean, a -1 and 0 mess.
// It wouldn't be that bad if the Microsoft folks used their own macros
// and kept an eye an sign extensions. But the way they are
// doing it they are returning at least some TRUEs as value 255
// instead of VARIANT_TRUE. Therefore, we have to compare against
// VARIANT_FALSE which -we hope- is consistently defined (as 0).
while(k--)
*pboolsnk++ = (*pboolsrc++)!=VARIANT_FALSE;
break;
case VT_UI1 | VT_ARRAY:
RE(a=ga(LIT, k, r, (I*)&shape));
memcpy(AV(a), psa->pvData, k * sizeof(char));
break;
case VT_UI2 | VT_ARRAY:
RE(a=ga(C2T, k, r, (I*)&shape));
memcpy(AV(a), psa->pvData, k * sizeof(short));
break;
case VT_UI4 | VT_ARRAY:
RE(a=ga(C4T, k, r, (I*)&shape));
memcpy(AV(a), psa->pvData, k * sizeof(int));
break;
case VT_I2 | VT_ARRAY:
RE(a=ga(INT, k, r, (I*)&shape));
pshortsrc = (short*)psa->pvData;
pintsnk = AV(a);
while(k--)
*pintsnk++ = *pshortsrc++;
break;
case VT_I4 | VT_ARRAY:
RE(a=ga(INT, k, r, (I*)&shape));
#if SY_64
pint32src = (long*)psa->pvData;
pintsnk = AV(a);
while(k--)
*pintsnk++ = *pint32src++;
#else
memcpy(AV(a), psa->pvData, k * sizeof(int));
#endif
break;
case VT_I8 | VT_ARRAY:
RE(a=ga(INT, k, r, (I*)&shape));
#if SY_64
memcpy(AV(a), psa->pvData, k * sizeof(I));
#else
pint64src = (long long*)psa->pvData;
pintsnk = AV(a);
while(k--)
*pintsnk++ = (I)*pint64src++;
#endif
break;
case VT_R4 | VT_ARRAY:
RE(a=ga(FL, k, r, (I*)&shape));
pfloatsrc = (float*)psa->pvData;
pdoublesnk = (double*)AV(a);
while(k--)
*pdoublesnk++ = *pfloatsrc++;
break;
case VT_R8 | VT_ARRAY:
RE(a=ga(FL, k, r, (I*)&shape));
memcpy(AV(a), psa->pvData, k * sizeof(double));
break;
case VT_UI1:
RE(a=ga(LIT, 1, 0, 0));
*CAV(a) = OPTREF(v,bVal);
break;
case VT_UI2:
RE(a=ga(C2T, 1, 0, 0));
*USAV(a) = (US)OPTREF(v,iVal);
break;
case VT_UI4:
RE(a=ga(C4T, 1, 0, 0));
*C4AV(a) = (C4)OPTREF(v,lVal);
break;
case VT_BOOL:
RE(a=ga(B01, 1, 0, 0));
// array case above explains this messy phrase:
*BAV(a) = OPTREF(v,boolVal)!=VARIANT_FALSE;
break;
case VT_I2:
RE(a=ga(INT, 1, 0, 0));
*IAV(a) = OPTREF(v,iVal);
break;
case VT_I4:
RE(a=ga(INT, 1, 0, 0));
*IAV(a) = OPTREF(v,lVal);
break;
case VT_I8:
RE(a=ga(INT, 1, 0, 0));
*IAV(a) = (I)OPTREF(v,llVal);
break;
case VT_R4:
RE(a=ga(FL, 1, 0, 0));
*DAV(a) = OPTREF(v,fltVal);
break;
case VT_R8:
RE(a=ga(FL, 1, 0, 0));
*DAV(a) = OPTREF(v,dblVal);
break;
default:
ASSERT(0,EVDOMAIN);
}
if(1<r && jt->transposeflag)
{
RE(a=cant1(a));
DO(r, AS(a)[i]=shape[r-1-i];);
static void Load(const CSysString &folderPrefix)
{
NFile::NFind::CEnumerator enumerator(folderPrefix + CSysString(TEXT("*")));
NFile::NFind::CFileInfo fileInfo;
while (enumerator.Next(fileInfo))
{
if (fileInfo.IsDirectory())
continue;
CSysString filePath = folderPrefix + fileInfo.Name;
{
NDLL::CLibrary library;
if (!library.LoadEx(filePath, LOAD_LIBRARY_AS_DATAFILE))
continue;
}
NDLL::CLibrary library;
if (!library.Load(filePath))
continue;
GetMethodPropertyFunc getMethodProperty = (GetMethodPropertyFunc)
library.GetProcAddress("GetMethodProperty");
if (getMethodProperty == NULL)
continue;
UInt32 numMethods = 1;
GetNumberOfMethodsFunc getNumberOfMethodsFunc = (GetNumberOfMethodsFunc)
library.GetProcAddress("GetNumberOfMethods");
if (getNumberOfMethodsFunc != NULL)
if (getNumberOfMethodsFunc(&numMethods) != S_OK)
continue;
for(UInt32 i = 0; i < numMethods; i++)
{
CMethodInfo2 info;
info.FilePath = filePath;
NWindows::NCOM::CPropVariant propVariant;
if (getMethodProperty(i, NMethodPropID::kID, &propVariant) != S_OK)
continue;
if (propVariant.vt != VT_BSTR)
continue;
info.MethodID.IDSize = SysStringByteLen(propVariant.bstrVal);
memmove(info.MethodID.ID, propVariant.bstrVal, info.MethodID.IDSize);
propVariant.Clear();
if (getMethodProperty(i, NMethodPropID::kName, &propVariant) != S_OK)
continue;
if (propVariant.vt == VT_EMPTY)
{
}
else if (propVariant.vt == VT_BSTR)
info.Name = propVariant.bstrVal;
else
continue;
propVariant.Clear();
if (getMethodProperty (i, NMethodPropID::kEncoder, &propVariant) != S_OK)
continue;
if (propVariant.vt == VT_EMPTY)
info.EncoderIsAssigned = false;
else if (propVariant.vt == VT_BSTR)
{
info.EncoderIsAssigned = true;
info.Encoder = *(const GUID *)propVariant.bstrVal;
}
else
continue;
propVariant.Clear();
if (getMethodProperty (i, NMethodPropID::kDecoder, &propVariant) != S_OK)
continue;
if (propVariant.vt == VT_EMPTY)
info.DecoderIsAssigned = false;
else if (propVariant.vt == VT_BSTR)
{
info.DecoderIsAssigned = true;
info.Decoder = *(const GUID *)propVariant.bstrVal;
}
else
continue;
propVariant.Clear();
if (getMethodProperty (i, NMethodPropID::kInStreams, &propVariant) != S_OK)
continue;
if (propVariant.vt == VT_EMPTY)
info.NumInStreams = 1;
else if (propVariant.vt == VT_UI4)
info.NumInStreams = propVariant.ulVal;
else
continue;
propVariant.Clear();
if (getMethodProperty (i, NMethodPropID::kOutStreams, &propVariant) != S_OK)
continue;
if (propVariant.vt == VT_EMPTY)
info.NumOutStreams = 1;
else if (propVariant.vt == VT_UI4)
info.NumOutStreams = propVariant.ulVal;
else
continue;
propVariant.Clear();
g_Methods.Add(info);
}
}
}
HRESULT
ceVerifyAltNameString(
IN LONG NameChoice,
IN BSTR strName)
{
HRESULT hr = S_OK;
CERT_ALT_NAME_INFO AltName;
CERT_ALT_NAME_ENTRY Entry;
CERT_OTHER_NAME OtherName;
char *pszObjectId = NULL;
DWORD cbEncoded;
ZeroMemory(&AltName, sizeof(AltName));
AltName.cAltEntry = 1;
AltName.rgAltEntry = &Entry;
ZeroMemory(&Entry, sizeof(Entry));
Entry.dwAltNameChoice = NameChoice;
switch (NameChoice)
{
case CERT_ALT_NAME_RFC822_NAME:
Entry.pwszRfc822Name = strName;
break;
case CERT_ALT_NAME_DNS_NAME:
Entry.pwszDNSName = strName;
break;
case CERT_ALT_NAME_URL:
Entry.pwszURL = strName;
break;
case CERT_ALT_NAME_REGISTERED_ID:
if (!ceConvertWszToSz(&pszObjectId, strName, -1))
{
hr = E_OUTOFMEMORY;
ceERRORPRINTLINE("ceConvertWszToSz", hr);
goto error;
}
Entry.pszRegisteredID = pszObjectId;
break;
case CERT_ALT_NAME_OTHER_NAME:
Entry.pOtherName = &OtherName;
OtherName.pszObjId = szOID_NT_PRINCIPAL_NAME;
OtherName.Value.cbData = SysStringByteLen(strName);
OtherName.Value.pbData = (BYTE *) strName;
break;
case CERT_ALT_NAME_DIRECTORY_NAME:
Entry.DirectoryName.cbData = SysStringByteLen(strName);
Entry.DirectoryName.pbData = (BYTE *) strName;
break;
case CERT_ALT_NAME_IP_ADDRESS:
Entry.IPAddress.cbData = SysStringByteLen(strName);
Entry.IPAddress.pbData = (BYTE *) strName;
break;
//case CERT_ALT_NAME_X400_ADDRESS:
//case CERT_ALT_NAME_EDI_PARTY_NAME:
default:
hr = E_INVALIDARG;
ceERRORPRINTLINE("NameChoice", hr);
goto error;
}
// Encode CERT_ALT_NAME_INFO:
if (!CryptEncodeObject(
X509_ASN_ENCODING,
X509_ALTERNATE_NAME,
&AltName,
NULL,
&cbEncoded))
{
hr = ceHLastError();
ceERRORPRINTLINE("ceEncodeObject", hr);
goto error;
}
error:
if (NULL != pszObjectId)
{
LocalFree(pszObjectId);
}
return(hr);
}
size_t sbstr::ByteLength() const
{
return SysStringByteLen(bstr_);
}
