isl_util.c

来自「Next BIOS Source code : Extensible Firmw」· C语言 代码 · 共 595 行 · 第 1/2 页

		for (i = 0, digest = AlgInfoPtr; digest; i++, digest = digest->Next) 
		{
			if (CSSM_OK != CSSM_DigestData(DigestHandlesPtr[i], 
										   (CSSM_DATA_PTR)&block, 
										   1, 
										   (CSSM_DATA_PTR)(DigestValues + i)))
			{
				continue;
			}
		}
	}
	error = GetDataMethods->Recycle(GetDataContext);
	if (error != ISL_NO_ERROR) 
	{
		goto FAIL;
	}

	for (i = 0, digest = AlgInfoPtr; digest; i++, digest = digest->Next) 
	{
		if (CSSM_OK != CSSM_DeleteContext(DigestHandlesPtr[i]))
		{
			continue;
		}

    }
	status = ISL_FAIL;
	for (i = 0, digest = AlgInfoPtr; digest; i++, digest = digest->Next) 
    {
		if (digest->Methods != NULL)
		{
			status = ISL_FAIL;
			for (hash = digest->Hash; hash; hash = hash->Next) 
			{
				if (IS_EQUAL(hash->Value, DigestValues[i]))
				{
					status = ISL_OK;
					break;
				}
			}

			if (status != ISL_OK) goto FAIL;
		}
	}

	if (status == ISL_OK) retval = ISL_OK;
FAIL:
    {
	    if (DigestValues != NULL)
	    {
		    for(i = 0; i < NumberOfDigests; i++)
		    {
			    isl_FreeMemory(MemoryPtr, DigestValues[i].Data);
		    }
	    }
	    isl_FreeMemory(MemoryPtr, GetDataContext);
	    isl_FreeMemory(MemoryPtr, DigestValues);
	    isl_FreeMemory(MemoryPtr, DigestHandlesPtr);
	    return retval;
    }
}

/*-----------------------------------------------------------------------------
 * Name:  isl_CountItemsInList
 *
 * Description: Counts the number of items in a List. 
 *
 * Parameters: 
 * ListNodePtr(input) - head a list of nodes
 *
 * Return value:
 * the number items in the list
 * 
 * Error Codes:
 * None
 *---------------------------------------------------------------------------*/
uint32
isl_CountItemsInList(ISL_LIST_PTR ListNodePtr)
{
    uint32 count = 0;
    while (ListNodePtr)
    {
        count++;
        ListNodePtr = ListNodePtr->Next;
    }
    return count;
}

/*-----------------------------------------------------------------------------
 * Name:  isl_FindAttributeInHeader
 *
 * Description: Searches for an attribute name/value pair based on an 
 * attribute name and returns the value
 *
 * Parameters: 
 * HeaderSectionPtr (input) - header to search
 * Name (input) - key for searching for attribute name/value pair
 * ValuePtr (output) - value of name/value pair if found
 *
 * Return value:
 * ISL_OK if attribute name/value pair found
 * ISL_FAIL, otherwise
 * 
 * Error Codes:
 * None
 *
 * Notes:
 * No memory allocate when returning the value
 *---------------------------------------------------------------------------*/
ISL_STATUS
isl_FindAttributeInHeader(
    ISL_HEADER_SECTION_PTR HeaderSectionPtr,
    ISL_CONST_DATA Name,
    ISL_CONST_DATA_PTR ValuePtr)
{
    ISL_LIST_PTR ListNodePtr;

    if (HeaderSectionPtr == NULL ||
        ValuePtr == NULL)
    {
        return ISL_FAIL;
    }

    for(ListNodePtr = HeaderSectionPtr->Attribute;
        ListNodePtr != NULL;
        ListNodePtr = ListNodePtr->Next)
    {
        ISL_NAME_VALUE_PTR NameValuePtr = ListNodePtr->Node;
        if (NameValuePtr &&
            IS_EQUAL(NameValuePtr->Name, Name))
        {
            *ValuePtr = NameValuePtr->Value;
            return ISL_OK;
        }
    }
    return ISL_FAIL;
}

/*-----------------------------------------------------------------------------
 * Name:  isl_FindAttributeInHeader
 *
 * Description: Searches for an attribute name/value pair based on an 
 * attribute name and returns the value
 *
 * Parameters: 
 * HeaderSectionPtr (input) - header to search
 * Name (input) - key for searching for attribute name/value pair
 * ValuePtr (output) - value of name/value pair if found
 *
 * Return value:
 * ISL_OK if attribute name/value pair found
 * ISL_FAIL, otherwise
 * 
 * Error Codes:
 * None
 *
 * Notes:
 * No memory allocate when returning the value
 *---------------------------------------------------------------------------*/
ISL_CERTIFICATE_GROUP_PTR
isl_BuildCertificateGroup(
    ISL_LIST_PTR CertificateListPtr,
    ISL_MEMORY_CONTEXT_PTR MemoryPtr)
{
    ISL_CERTIFICATE_GROUP_PTR CertGrpPtr;
    ISL_CERTIFICATE_PTR *CertObjPtr;
    ISL_CERTIFICATE_PTR CurrCertObjPtr;
    ISL_LIST_PTR CurrNodePtr;

    uint32 NumberOfCertificates;

    CertGrpPtr = isl_AllocateMemory(
        MemoryPtr,
        sizeof(ISL_CERTIFICATE_GROUP));
    if (CertGrpPtr == NULL) return NULL;

    NumberOfCertificates = isl_CountItemsInList(CertificateListPtr);
    if (NumberOfCertificates == 0)
    {
        CertGrpPtr->NumberOfCertificates = 0;
        CertGrpPtr->Certificates = NULL;
        return CertGrpPtr;
    }

    CertGrpPtr->NumberOfCertificates = NumberOfCertificates;
    CertObjPtr = isl_AllocateMemory(
        MemoryPtr,
        sizeof(ISL_CERTIFICATE_PTR) * NumberOfCertificates);
    if (CertObjPtr == NULL)
    {
        goto FAIL;
    }

    CertGrpPtr->Certificates = CertObjPtr;    
    for(CurrNodePtr = CertificateListPtr, CurrCertObjPtr = *CertObjPtr;
        CurrNodePtr != NULL;
        CurrNodePtr = CurrNodePtr->Next, CurrCertObjPtr++)
    {
        CurrCertObjPtr = CurrNodePtr->Node;
    }
    return CertGrpPtr;

FAIL:
    {
        if (CertGrpPtr)
        {
            isl_FreeMemory(MemoryPtr, CertGrpPtr->Certificates);
        }
        isl_FreeMemory(MemoryPtr, CertGrpPtr);
        return NULL;
    }
}

ISL_STATUS
isl_FreeCertificateGroup(
    ISL_CERTIFICATE_GROUP_PTR CertGrpPtr,
    ISL_MEMORY_CONTEXT_PTR MemoryPtr)
{
    if (CertGrpPtr == NULL) return ISL_OK;

    if (MemoryPtr == NULL) return ISL_FAIL;
    isl_FreeMemory(MemoryPtr, CertGrpPtr->Certificates);
    isl_FreeMemory(MemoryPtr, CertGrpPtr);
    return ISL_OK;
}

ISL_ATTRIBUTE_GROUP_PTR
isl_BuildAttributeGrp(
    ISL_LIST_PTR AttributeListPtr,
    ISL_MEMORY_CONTEXT_PTR MemoryPtr)
{
    ISL_ATTRIBUTE_GROUP_PTR AttributeGrpPtr = NULL;

    if (MemoryPtr == NULL) return NULL;

    {
        ISL_NAME_VALUE_PTR AttributesPtr;
        ISL_LIST_PTR ListNodePtr;
        uint32 AttributeCount;

        AttributeGrpPtr = isl_AllocateMemory(
            MemoryPtr,
            sizeof(ISL_ATTRIBUTE_GROUP));
        if (AttributeGrpPtr == NULL) goto FAIL;

        AttributeCount = isl_CountItemsInList(AttributeListPtr);
        if (AttributeCount == 0) return AttributeGrpPtr;
        AttributeGrpPtr->NumberOfAttributes = AttributeCount;

        AttributesPtr = isl_AllocateMemory(
            MemoryPtr,
            AttributeCount * sizeof(ISL_NAME_VALUE));
        if (AttributesPtr == NULL) goto FAIL;
        AttributeGrpPtr->AttributesPtr = AttributesPtr;

        for(ListNodePtr = AttributeListPtr;
            ListNodePtr != NULL;
            ListNodePtr = ListNodePtr->Next)
        {
            ISL_NAME_VALUE_PTR ListAttributePtr;

            ListAttributePtr = ListNodePtr->Node;
            if (ListAttributePtr == NULL) goto FAIL;
            *AttributesPtr = *ListAttributePtr;
            AttributesPtr++;
        }
        return AttributeGrpPtr;
    }

FAIL:
    {
        if (AttributeGrpPtr)
        {
            isl_FreeMemory(MemoryPtr, AttributeGrpPtr->AttributesPtr);
        }
        isl_FreeMemory(MemoryPtr, AttributeGrpPtr);
        return NULL;
    }
}


ISL_STATUS
isl_FreeAttributeGrp(
    ISL_ATTRIBUTE_GROUP_PTR AttributeGrpPtr,
    ISL_MEMORY_CONTEXT_PTR MemoryPtr)
{
    if (MemoryPtr == NULL) return ISL_FAIL;

    if (AttributeGrpPtr)
    {
        isl_FreeMemory(MemoryPtr, AttributeGrpPtr->AttributesPtr);
    }
    isl_FreeMemory(MemoryPtr, AttributeGrpPtr);
    return ISL_OK;

}