return ret;
}
-/* Decodes an array of like types into a struct GenericArray.
- * The layout and decoding of the array are described by a struct
+/* Decodes an array of like types into a structure described by a struct
* AsnArrayDescriptor. Doesn't allocate memory for the decoded items,
* leaves that up to the caller.
*/
static BOOL CRYPT_AsnDecodeArrayNoAlloc(const struct AsnArrayDescriptor *arrayDesc,
- const BYTE *pbEncoded, DWORD cbEncoded, DWORD *pcItems, void *rgItems,
- DWORD *pcbItems, DWORD *pcbDecoded)
+ const BYTE *pbEncoded, DWORD cbEncoded, void *pvStructInfo, DWORD *pcbItems,
+ DWORD *pcbDecoded)
{
BOOL ret = TRUE;
- TRACE("%p, %p, %d, %p, %p, %d\n", arrayDesc, pbEncoded,
- cbEncoded, pcItems, rgItems, pcItems ? *pcbItems : 0);
+ TRACE("%p, %p, %d, %p, %d\n", arrayDesc, pbEncoded,
+ cbEncoded, pvStructInfo, pvStructInfo ? *pcbItems : 0);
if (!cbEncoded)
{
{
if (pcbDecoded)
*pcbDecoded = decoded;
- if (!pcItems)
+ if (!pvStructInfo)
*pcbItems = bytesNeeded;
- else if ((ret = CRYPT_DecodeEnsureSpace(0, NULL, rgItems,
+ else if ((ret = CRYPT_DecodeEnsureSpace(0, NULL, pvStructInfo,
pcbItems, bytesNeeded)))
{
- DWORD i;
+ DWORD i, *pcItems;
BYTE *nextData;
const BYTE *ptr;
+ void *rgItems;
+ pcItems = pvStructInfo;
*pcItems = cItems;
+ rgItems = *(void **)((BYTE *)pcItems -
+ arrayDesc->countOffset + arrayDesc->arrayOffset);
nextData = (BYTE *)rgItems + cItems * arrayDesc->itemSize;
for (i = 0, ptr = pbEncoded + 1 + lenBytes; ret &&
i < cItems && ptr - pbEncoded - 1 - lenBytes <
pvStructInfo, *pcbStructInfo, pcbDecoded);
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &itemSize, pcbDecoded);
+ NULL, &itemSize, pcbDecoded);
if (ret)
{
DWORD bytesNeeded;
info = (CERT_INFO *)((BYTE *)pvStructInfo -
offsetof(CERT_INFO, cExtension));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded,
- cbEncoded, &info->cExtension, info->rgExtension, &itemSize,
- pcbDecoded);
+ cbEncoded, &info->cExtension, &itemSize, pcbDecoded);
}
}
return ret;
pvStructInfo, *pcbStructInfo, pcbDecoded);
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &itemSize, pcbDecoded);
+ NULL, &itemSize, pcbDecoded);
if (ret)
{
DWORD bytesNeeded;
entry = (CRL_ENTRY *)((BYTE *)pvStructInfo -
offsetof(CRL_ENTRY, cExtension));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded,
- cbEncoded, &entry->cExtension, entry->rgExtension, &itemSize,
- pcbDecoded);
+ cbEncoded, &entry->cExtension, &itemSize, pcbDecoded);
}
}
return ret;
pvStructInfo, *pcbStructInfo, pcbDecoded);
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &itemSize, pcbDecoded);
+ NULL, &itemSize, pcbDecoded);
if (ret)
{
DWORD bytesNeeded;
info = (CRL_INFO *)((BYTE *)pvStructInfo -
offsetof(CRL_INFO, cCRLEntry));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded,
- cbEncoded, &info->cCRLEntry, info->rgCRLEntry, &itemSize,
- pcbDecoded);
+ cbEncoded, &info->cCRLEntry, &itemSize, pcbDecoded);
}
}
TRACE("Returning %d (%08x)\n", ret, GetLastError());
pvStructInfo, *pcbStructInfo, pcbDecoded);
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &itemSize, pcbDecoded);
+ NULL, &itemSize, pcbDecoded);
if (ret)
{
DWORD bytesNeeded;
info = (CRL_INFO *)((BYTE *)pvStructInfo -
offsetof(CRL_INFO, cExtension));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded,
- cbEncoded, &info->cExtension, info->rgExtension, &itemSize,
- pcbDecoded);
+ cbEncoded, &info->cExtension, &itemSize, pcbDecoded);
}
}
return ret;
DWORD itemSize;
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &itemSize, NULL);
+ NULL, &itemSize, NULL);
if (ret)
{
DWORD bytesNeeded;
exts->rgExtension = (CERT_EXTENSION *)((BYTE *)exts +
sizeof(CERT_EXTENSIONS));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded,
- cbEncoded, &exts->cExtension, exts->rgExtension, &itemSize,
- NULL);
+ cbEncoded, &exts->cExtension, &itemSize, NULL);
}
}
}
BOOL ret;
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &bytesNeeded, pcbDecoded);
+ NULL, &bytesNeeded, pcbDecoded);
if (ret)
{
bytesNeeded += FINALMEMBERSIZE(CTL_ENTRY, cAttribute);
entry = (CTL_ENTRY *)((BYTE *)pvStructInfo -
offsetof(CTL_ENTRY, cAttribute));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded,
- cbEncoded, &entry->cAttribute, entry->rgAttribute, &bytesNeeded,
- pcbDecoded);
+ cbEncoded, &entry->cAttribute, &bytesNeeded, pcbDecoded);
}
}
return ret;
pvStructInfo, *pcbStructInfo, pcbDecoded);
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &bytesNeeded, pcbDecoded);
+ NULL, &bytesNeeded, pcbDecoded);
if (ret)
{
/* The size expected by the caller includes the combination of
info = (CTL_INFO *)((BYTE *)pvStructInfo -
offsetof(CTL_INFO, cCTLEntry));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded,
- cbEncoded, &info->cCTLEntry, info->rgCTLEntry, &bytesNeeded,
- pcbDecoded);
+ cbEncoded, &info->cCTLEntry, &bytesNeeded, pcbDecoded);
}
}
return ret;
pvStructInfo, *pcbStructInfo, pcbDecoded);
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &itemSize, pcbDecoded);
+ NULL, &itemSize, pcbDecoded);
if (ret)
{
DWORD bytesNeeded;
info = (CTL_INFO *)((BYTE *)pvStructInfo -
offsetof(CTL_INFO, cExtension));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded,
- cbEncoded, &info->cExtension, info->rgExtension, &itemSize,
- pcbDecoded);
+ cbEncoded, &info->cExtension, &itemSize, pcbDecoded);
}
}
return ret;
offsetof(CRYPT_SMIME_CAPABILITY, pszObjId) };
if ((ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &bytesNeeded, NULL)))
+ NULL, &bytesNeeded, NULL)))
{
bytesNeeded += sizeof(CRYPT_SMIME_CAPABILITIES);
if (!pvStructInfo)
sizeof(CRYPT_SMIME_CAPABILITIES));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc,
pbEncoded, cbEncoded, &capabilities->cCapability,
- capabilities->rgCapability, pcbStructInfo, NULL);
+ pcbStructInfo, NULL);
}
}
}
pvStructInfo, pvStructInfo ? *pcbDecoded : 0);
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &bytesNeeded, pcbDecoded);
+ NULL, &bytesNeeded, pcbDecoded);
if (ret)
{
/* The size expected by the caller includes the combination of
((BYTE *)pvStructInfo -
offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE, cNoticeNumbers));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded,
- cbEncoded, &ref->cNoticeNumbers, ref->rgNoticeNumbers,
- &bytesNeeded, pcbDecoded);
+ cbEncoded, &ref->cNoticeNumbers, &bytesNeeded, pcbDecoded);
}
}
TRACE("returning %d\n", ret);
pvStructInfo, pvStructInfo ? *pcbStructInfo : 0, pcbDecoded);
if ((ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &bytesNeeded, pcbDecoded)))
+ NULL, &bytesNeeded, pcbDecoded)))
{
bytesNeeded += FINALMEMBERSIZE(CRYPT_ATTRIBUTE, cValue);
if (!pvStructInfo)
offsetof(CRYPT_ATTRIBUTE, cValue));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- &attr->cValue, attr->rgValue, pcbStructInfo, pcbDecoded);
+ &attr->cValue, pcbStructInfo, pcbDecoded);
}
}
return ret;
DWORD bytesNeeded;
if ((ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded,
- cbEncoded, NULL, NULL, &bytesNeeded, NULL)))
+ cbEncoded, NULL, &bytesNeeded, NULL)))
{
bytesNeeded += sizeof(CRYPT_ATTRIBUTES);
if (!pvStructInfo)
attrs->rgAttr = (PCRYPT_ATTRIBUTE)((BYTE *)pvStructInfo +
sizeof(CRYPT_ATTRIBUTES));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded,
- cbEncoded, &attrs->cAttr, attrs->rgAttr, &bytesNeeded, NULL);
+ cbEncoded, &attrs->cAttr, &bytesNeeded, NULL);
}
}
}
pvStructInfo, *pcbStructInfo, pcbDecoded);
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &bytesNeeded, pcbDecoded);
+ NULL, &bytesNeeded, pcbDecoded);
if (ret)
{
/* The size expected by the caller includes the combination of
((BYTE *)pvStructInfo -
offsetof(CERT_BASIC_CONSTRAINTS_INFO, cSubtreesConstraint));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded,
- cbEncoded, &constraint->cSubtreesConstraint,
- constraint->rgSubtreesConstraint, &bytesNeeded, pcbDecoded);
+ cbEncoded, &constraint->cSubtreesConstraint, &bytesNeeded,
+ pcbDecoded);
}
}
TRACE("Returning %d (%08x)\n", ret, GetLastError());
pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &bytesNeeded, pcbDecoded);
+ NULL, &bytesNeeded, pcbDecoded);
if (ret)
{
/* The size expected by the caller includes the combination of
info = (CERT_POLICY_INFO *)((BYTE *)pvStructInfo -
offsetof(CERT_POLICY_INFO, cPolicyQualifier));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- &info->cPolicyQualifier, info->rgPolicyQualifier, &bytesNeeded,
- pcbDecoded);
+ &info->cPolicyQualifier, &bytesNeeded, pcbDecoded);
}
}
TRACE("Returning %d (%08x)\n", ret, GetLastError());
{
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc,
pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes,
- NULL, NULL, &nameLen, NULL);
+ NULL, &nameLen, NULL);
bytesNeeded = sizeof(CRL_DIST_POINT_NAME) + nameLen;
}
else
name->dwDistPointNameChoice = CRL_DIST_POINT_FULL_NAME;
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc,
pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes,
- &name->u.FullName.cAltEntry, name->u.FullName.rgAltEntry,
- &nameLen, NULL);
+ &name->u.FullName.cAltEntry, &nameLen, NULL);
}
else
name->dwDistPointNameChoice = CRL_DIST_POINT_NO_NAME;
pvStructInfo, *pcbStructInfo, pcbDecoded);
if ((ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &bytesNeeded, pcbDecoded)))
+ NULL, &bytesNeeded, pcbDecoded)))
{
bytesNeeded += MEMBERSIZE(CERT_NAME_CONSTRAINTS_INFO,
cPermittedSubtree, cExcludedSubtree);
offsetof(CERT_NAME_CONSTRAINTS_INFO, cPermittedSubtree));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- &info->cPermittedSubtree, info->rgPermittedSubtree, &bytesNeeded,
- pcbDecoded);
+ &info->cPermittedSubtree, &bytesNeeded, pcbDecoded);
}
}
return ret;
pvStructInfo, *pcbStructInfo, pcbDecoded);
if ((ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &bytesNeeded, pcbDecoded)))
+ NULL, &bytesNeeded, pcbDecoded)))
{
bytesNeeded += FINALMEMBERSIZE(CERT_NAME_CONSTRAINTS_INFO,
cExcludedSubtree);
offsetof(CERT_NAME_CONSTRAINTS_INFO, cExcludedSubtree));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- &info->cExcludedSubtree, info->rgExcludedSubtree, &bytesNeeded,
- pcbDecoded);
+ &info->cExcludedSubtree, &bytesNeeded, pcbDecoded);
}
}
return ret;
pvStructInfo, pvStructInfo ? *pcbStructInfo : 0, pcbDecoded);
if ((ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &bytesNeeded, pcbDecoded)))
+ NULL, &bytesNeeded, pcbDecoded)))
{
bytesNeeded += MEMBERSIZE(CRYPT_SIGNED_INFO, cCertEncoded, cCrlEncoded);
if (!pvStructInfo)
((BYTE *)pvStructInfo - offsetof(CRYPT_SIGNED_INFO, cCertEncoded));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- &info->cCertEncoded, info->rgCertEncoded, &bytesNeeded,
- pcbDecoded);
+ &info->cCertEncoded, &bytesNeeded, pcbDecoded);
}
}
return ret;
pvStructInfo, pvStructInfo ? *pcbStructInfo : 0, pcbDecoded);
if ((ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &bytesNeeded, pcbDecoded)))
+ NULL, &bytesNeeded, pcbDecoded)))
{
bytesNeeded += MEMBERSIZE(CRYPT_SIGNED_INFO, cCrlEncoded, content);
if (!pvStructInfo)
((BYTE *)pvStructInfo - offsetof(CRYPT_SIGNED_INFO, cCrlEncoded));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- &info->cCrlEncoded, info->rgCrlEncoded, &bytesNeeded,
- pcbDecoded);
+ &info->cCrlEncoded, &bytesNeeded, pcbDecoded);
}
}
return ret;
pvStructInfo, *pcbStructInfo, pcbDecoded);
if ((ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- NULL, NULL, &bytesNeeded, pcbDecoded)))
+ NULL, &bytesNeeded, pcbDecoded)))
{
bytesNeeded += FINALMEMBERSIZE(CRYPT_SIGNED_INFO, cSignerInfo);
if (!pvStructInfo)
((BYTE *)pvStructInfo - offsetof(CRYPT_SIGNED_INFO, cSignerInfo));
ret = CRYPT_AsnDecodeArrayNoAlloc(&arrayDesc, pbEncoded, cbEncoded,
- &info->cSignerInfo, info->rgSignerInfo, &bytesNeeded,
- pcbDecoded);
+ &info->cSignerInfo, &bytesNeeded, pcbDecoded);
}
}
return ret;