/* Create an array */
static SAFEARRAY* SAFEARRAY_Create(VARTYPE vt, UINT cDims, const SAFEARRAYBOUND *rgsabound, ULONG ulSize)
{
SAFEARRAY *psa = NULL;
unsigned int i;
if (!rgsabound)
return NULL;
if (SUCCEEDED(SafeArrayAllocDescriptorEx(vt, cDims, &psa)))
{
switch (vt)
{
case VT_BSTR: psa->fFeatures |= FADF_BSTR; break;
case VT_UNKNOWN: psa->fFeatures |= FADF_UNKNOWN; break;
case VT_DISPATCH: psa->fFeatures |= FADF_DISPATCH; break;
case VT_VARIANT: psa->fFeatures |= FADF_VARIANT; break;
}
for (i = 0; i < cDims; i++)
memcpy(psa->rgsabound + i, rgsabound + cDims - 1 - i, sizeof(SAFEARRAYBOUND));
if (ulSize)
psa->cbElements = ulSize;
if (!psa->cbElements || FAILED(SafeArrayAllocData(psa)))
{
SafeArrayDestroyDescriptor(psa);
psa = NULL;
}
}
return psa;
}
unsigned char * WINAPI LPSAFEARRAY_UserUnmarshal(unsigned long *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
{
ULONG_PTR ptr;
wireSAFEARRAY wiresa;
ULONG cDims;
HRESULT hr;
SF_TYPE sftype;
ULONG cell_count;
GUID guid;
VARTYPE vt;
SAFEARRAYBOUND *wiresab;
TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", Buffer, ppsa);
ALIGN_POINTER(Buffer, 3);
ptr = *(ULONG_PTR *)Buffer;
Buffer += sizeof(ULONG_PTR);
if (!ptr)
{
*ppsa = NULL;
TRACE("NULL safe array unmarshaled\n");
return Buffer;
}
cDims = *(ULONG *)Buffer;
Buffer += sizeof(ULONG);
wiresa = (wireSAFEARRAY)Buffer;
Buffer += FIELD_OFFSET(struct _wireSAFEARRAY, uArrayStructs);
if (cDims != wiresa->cDims)
RpcRaiseException(RPC_S_INVALID_BOUND);
/* FIXME: there should be a limit on how large cDims can be */
vt = HIWORD(wiresa->cLocks);
sftype = *(ULONG *)Buffer;
Buffer += sizeof(ULONG);
cell_count = *(ULONG *)Buffer;
Buffer += sizeof(ULONG);
ptr = *(ULONG_PTR *)Buffer;
Buffer += sizeof(ULONG_PTR);
if (sftype == SF_HAVEIID)
{
memcpy(&guid, Buffer, sizeof(guid));
Buffer += sizeof(guid);
}
wiresab = (SAFEARRAYBOUND *)Buffer;
Buffer += sizeof(wiresab[0]) * wiresa->cDims;
*ppsa = SafeArrayCreateEx(vt, wiresa->cDims, wiresab, NULL);
if (!*ppsa)
RpcRaiseException(E_OUTOFMEMORY);
/* be careful about which flags we set since they could be a security
* risk */
(*ppsa)->fFeatures &= FADF_AUTOSETFLAGS;
(*ppsa)->fFeatures |= (wiresa->fFeatures & ~(FADF_AUTOSETFLAGS));
/* FIXME: there should be a limit on how large wiresa->cbElements can be */
(*ppsa)->cbElements = wiresa->cbElements;
(*ppsa)->cLocks = LOWORD(wiresa->cLocks);
hr = SafeArrayAllocData(*ppsa);
if (FAILED(hr))
RpcRaiseException(hr);
if ((*(ULONG *)Buffer != cell_count) || (SAFEARRAY_GetCellCount(*ppsa) != cell_count))
RpcRaiseException(RPC_S_INVALID_BOUND);
Buffer += sizeof(ULONG);
if (ptr)
{
switch (sftype)
{
case SF_BSTR:
{
BSTR* lpBstr;
for (lpBstr = (BSTR*)(*ppsa)->pvData; cell_count; cell_count--, lpBstr++)
Buffer = BSTR_UserUnmarshal(pFlags, Buffer, lpBstr);
break;
}
case SF_DISPATCH:
case SF_UNKNOWN:
case SF_HAVEIID:
FIXME("marshal interfaces\n");
break;
case SF_VARIANT:
{
VARIANT* lpVariant;
for (lpVariant = (VARIANT*)(*ppsa)->pvData; cell_count; cell_count--, lpVariant++)
Buffer = VARIANT_UserUnmarshal(pFlags, Buffer, lpVariant);
break;
}
case SF_RECORD:
{
FIXME("set record info\n");
break;
}
case SF_I8:
ALIGN_POINTER(Buffer, 7);
/* fallthrough */
case SF_I1:
case SF_I2:
case SF_I4:
/* Just copy the data over */
memcpy((*ppsa)->pvData, Buffer, cell_count * (*ppsa)->cbElements);
Buffer += cell_count * (*ppsa)->cbElements;
break;
default:
break;
}
}
TRACE("safe array unmarshaled: %p\n", *ppsa);
return Buffer;
}
