BioAPI_RETURN BioAPI BioSPI_FreeBIRHandle(
BioAPI_HANDLE ModuleHandle,
BioAPI_BIR_HANDLE BIRHandle )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_ATTACH_DATA *pAttachData = NULL;
/*-------------------------*
* Initialize MAF Contexts *
*-------------------------*/
/* Note to keep in mind from here on: after MAF has been initialized
* the function must release the context with ADDIN_SPIEnd(...). The
* return macro for doing this is SPI_RETURN(<errorcode>). This will
* be used to return in each function in each case after MAF is in use. */
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (BioAPI_OK != ret) return ret;
if (NULL == (pAttachData = Addin_GetAttachData()))
SPI_RETURN(BioAPI_ERRCODE_INTERNAL_ERROR);
/*----------------------------------------------------------------*
* Call to the internal routine where the real functionality lies *
*----------------------------------------------------------------*/
ret = _biospi_FreeBIRHandle(pAttachData, BIRHandle);
if (BioAPI_OK != ret) SPI_RETURN(ret);
SPI_RETURN(BioAPI_OK);
}
BioAPI_RETURN BioAPI BSP_DbFreeCursor(
BioAPI_HANDLE ModuleHandle,
BioAPI_DB_CURSOR_PTR Cursor )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_DB_FREE_CURSOR;
}
BioAPI_RETURN BioAPI BSP_DbClose(
BioAPI_HANDLE ModuleHandle,
BioAPI_DB_HANDLE DbHandle )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_DB_CLOSE;
}
BioAPI_RETURN BioAPI BSP_DbDelete(
BioAPI_HANDLE ModuleHandle,
const uint8 *DbName )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_DB_DELETE;
}
/* Define each SPI function.
*/
BioAPI_RETURN BioAPI BSP_FreeBIRHandle(
BioAPI_HANDLE ModuleHandle,
BioAPI_BIR_HANDLE BIRHandle )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_FREE_BIRHANDLE;
}
BioAPI_RETURN BioAPI BSP_EnableEvents(
BioAPI_HANDLE ModuleHandle,
BioAPI_MODULE_EVENT_MASK *Events )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_ENABLE_EVENTS;
}
BioAPI_RETURN BioAPI BSP_SetPowerMode(
BioAPI_HANDLE ModuleHandle,
BioAPI_POWER_MODE PowerMode )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_SET_POWER_MODE;
}
BioAPI_RETURN BioAPI BSP_GetHeaderFromHandle(
BioAPI_HANDLE ModuleHandle,
BioAPI_BIR_HANDLE BIRHandle,
BioAPI_BIR_HEADER_PTR Header )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_GET_HEADER_FROM_HANDLE;
}
BioAPI_RETURN BioAPI BSP_Process(
BioAPI_HANDLE ModuleHandle,
const BioAPI_INPUT_BIR *CapturedBIR,
BioAPI_BIR_HANDLE_PTR ProcessedBIR )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_PROCESS;
}
BioAPI_RETURN BioAPI BSP_DbDeleteBIR(
BioAPI_HANDLE ModuleHandle,
BioAPI_DB_HANDLE DbHandle,
const BioAPI_UUID *KeyValue )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_DB_DELETE_BIR;
}
BioAPI_RETURN BioAPI BioSPI_Capture(
BioAPI_HANDLE ModuleHandle,
BioAPI_BIR_PURPOSE Purpose,
BioAPI_BIR_HANDLE_PTR CapturedBIR,
sint32 Timeout,
BioAPI_BIR_HANDLE_PTR AuditData )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_ATTACH_DATA *pAttachData = NULL;
/*------------------------------------------------------------------*
* Check for bad paramters and initialize output for the error case *
*------------------------------------------------------------------*/
if (NULL == CapturedBIR)
return BioAPI_ERRCODE_INVALID_OUTPUT_POINTER;
else
*CapturedBIR = BioAPI_INVALID_BIR_HANDLE;
if (NULL != AuditData)
/* AuditData not supported */
*AuditData = BioAPI_UNSUPPORTED_BIR_HANDLE;
if (Purpose != BioAPI_PURPOSE_VERIFY &&
Purpose != BioAPI_PURPOSE_ENROLL_FOR_VERIFICATION_ONLY)
return BioAPIERR_BSP_PURPOSE_NOT_SUPPORTED;
/*-------------------------*
* Initialize MAF Contexts *
*-------------------------*/
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
if ((pAttachData = Addin_GetAttachData()) == NULL)
SPI_RETURN(BioAPI_ERRCODE_INTERNAL_ERROR);
/*-----------------------------------------------------------------*
* Check to ensure there are still handles available for more BIRs *
*-----------------------------------------------------------------*/
if (pAttachData->HandleIndex < 0)
/* Overflow, we've run out of handles */
SPI_RETURN(BioAPIERR_BSP_TOO_MANY_HANDLES);
/*----------------------------------------------------------------*
* Call to the internal routine where the real functionality lies *
*----------------------------------------------------------------*/
ret = _biospi_Capture(pAttachData, Purpose, CapturedBIR);
if (BioAPI_OK != ret) SPI_RETURN(ret);
SPI_RETURN(BioAPI_OK);
}
BioAPI_RETURN BioAPI BSP_SetStreamCallback(
BioAPI_HANDLE ModuleHandle,
BioAPI_STREAM_CALLBACK StreamCallback,
void *StreamCallbackCtx )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_SET_STREAM_CALLBACK;
}
BioAPI_RETURN BioAPI BSP_StreamInputOutput(
BioAPI_HANDLE ModuleHandle,
BioAPI_DATA_PTR InMessage,
BioAPI_DATA_PTR OutMessage )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_STREAM_INPUT_OUTPUT;
}
BioAPI_RETURN BioAPI BSP_DbSetCursor(
BioAPI_HANDLE ModuleHandle,
BioAPI_DB_HANDLE DbHandle,
const BioAPI_UUID *KeyValue,
BioAPI_DB_CURSOR_PTR Cursor )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_DB_SET_CURSOR;
}
BioAPI_RETURN BioAPI BSP_DbGetNextBIR(
BioAPI_HANDLE ModuleHandle,
BioAPI_DB_CURSOR_PTR Cursor,
BioAPI_BIR_HANDLE_PTR RetievedBIR,
BioAPI_UUID_PTR Uuid )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_DB_GET_NEXT_BIR;
}
BioAPI_RETURN BioAPI BSP_DbQueryBIR(
BioAPI_HANDLE ModuleHandle,
BioAPI_DB_HANDLE DbHandle,
const BioAPI_INPUT_BIR *BIRToQuery,
BioAPI_UUID_PTR Uuid )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_DB_QUERY_BIR;
}
BioAPI_RETURN BioAPI BSP_DbCreate(
BioAPI_HANDLE ModuleHandle,
const uint8 *DbName,
BioAPI_DB_ACCESS_TYPE AccessRequest,
BioAPI_DB_HANDLE_PTR DbHandle )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_DB_CREATE;
}
BioAPI_RETURN BioAPI BSP_Capture(
BioAPI_HANDLE ModuleHandle,
BioAPI_BIR_PURPOSE Purpose,
BioAPI_BIR_HANDLE_PTR CapturedBIR,
sint32 Timeout,
BioAPI_BIR_HANDLE_PTR AuditData )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_CAPTURE;
}
BioAPI_RETURN BioAPI BSP_CreateTemplate(
BioAPI_HANDLE ModuleHandle,
const BioAPI_INPUT_BIR *CapturedBIR,
const BioAPI_INPUT_BIR *StoredTemplate,
BioAPI_BIR_HANDLE_PTR NewTemplate,
const BioAPI_DATA *Payload )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_CREATE_TEMPLATE;
}
BioAPI_RETURN BioAPI BSP_Import(
BioAPI_HANDLE ModuleHandle,
const BioAPI_DATA *InputData,
BioAPI_BIR_BIOMETRIC_DATA_FORMAT InputFormat,
BioAPI_BIR_PURPOSE Purpose,
BioAPI_BIR_HANDLE_PTR ConstructedBIR )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_IMPORT;
}
BioAPI_RETURN BioAPI BSP_SetGUICallbacks(
BioAPI_HANDLE ModuleHandle,
BioAPI_GUI_STREAMING_CALLBACK GuiStreamingCallback,
void *GuiStreamingCallbackCtx,
BioAPI_GUI_STATE_CALLBACK GuiStateCallback,
void *GuiStateCallbackCtx )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_SET_GUICALLBACKS;
}
BioAPI_RETURN BioAPI BSP_Enroll(
BioAPI_HANDLE ModuleHandle,
BioAPI_BIR_PURPOSE Purpose,
const BioAPI_INPUT_BIR *StoredTemplate,
BioAPI_BIR_HANDLE_PTR NewTemplate,
const BioAPI_DATA *Payload,
sint32 Timeout,
BioAPI_BIR_HANDLE_PTR AuditData )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_ENROLL;
}
BioAPI_RETURN BioAPI BSP_VerifyMatch(
BioAPI_HANDLE ModuleHandle,
const BioAPI_FAR *MaxFARRequested,
const BioAPI_FRR *MaxFRRRequested,
const BioAPI_BOOL *FARPrecedence,
const BioAPI_INPUT_BIR *ProcessedBIR,
const BioAPI_INPUT_BIR *StoredTemplate,
BioAPI_BIR_HANDLE *AdaptedBIR,
BioAPI_BOOL *Result,
BioAPI_FAR_PTR FARAchieved,
BioAPI_FRR_PTR FRRAchieved,
BioAPI_DATA_PTR *Payload )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_VERIFY_MATCH;
}
BioAPI_RETURN BioAPI BSP_Identify(
BioAPI_HANDLE ModuleHandle,
const BioAPI_FAR *MaxFARRequested,
const BioAPI_FRR *MaxFRRRequested,
const BioAPI_BOOL *FARPrecedence,
const BioAPI_IDENTIFY_POPULATION *Population,
BioAPI_BOOL Binning,
uint32 MaxNumberOfResults,
uint32 *NumberOfResults,
BioAPI_CANDIDATE_ARRAY_PTR *Candidates,
sint32 Timeout,
BioAPI_BIR_HANDLE_PTR AuditData )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
Addin_SPIEnd(pAddinContext);
return BioAPIERR_BSP_IDENTIFY;
}
BioAPI_RETURN BioAPI BioSPI_GetHeaderFromHandle(
BioAPI_HANDLE ModuleHandle,
BioAPI_BIR_HANDLE BIRHandle,
BioAPI_BIR_HEADER_PTR Header )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
BioAPI_BIR *pFoundBIR = NULL;
ADDIN_ATTACH_DATA *pAttachData = NULL;
/*--------------------------*
* Check for bad parameters *
*--------------------------*/
if (NULL == Header)
return BioAPI_ERRCODE_INVALID_OUTPUT_POINTER;
/*-------------------------*
* Initialize MAF Contexts *
*-------------------------*/
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (ret != BioAPI_OK) return ret;
if ((pAttachData = Addin_GetAttachData()) == NULL)
SPI_RETURN(BioAPI_ERRCODE_INTERNAL_ERROR);
/*-------------------------------------------------*
* Get the BIR from which the header will be taken *
*-------------------------------------------------*/
ret = _biospi_GetBIRFromHandle(pAttachData, BIRHandle, &pFoundBIR);
if (BioAPI_OK != ret) SPI_RETURN(ret);
/* Copy the header into the application's memory space */
port_memcpy((void*)Header, (void*)&(pFoundBIR->Header),
sizeof(BioAPI_BIR_HEADER));
SPI_RETURN(BioAPI_OK);
}
BioAPI_RETURN BioAPI BioSPI_Enroll(
BioAPI_HANDLE ModuleHandle,
BioAPI_BIR_PURPOSE Purpose,
const BioAPI_INPUT_BIR *StoredTemplate,
BioAPI_BIR_HANDLE_PTR NewTemplate,
const BioAPI_DATA *Payload,
sint32 Timeout,
BioAPI_BIR_HANDLE_PTR AuditData )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
BioAPI_BIR_HANDLE CapturedBIR;
BioAPI_BIR *pInputCapturedBIR;
ADDIN_ATTACH_DATA *pAttachData = NULL;
const void *pLoadData = NULL;
/*-----------------------------------------------------------------------*
* Check for bad parameters and initialize output for the case of errors *
*-----------------------------------------------------------------------*/
if (NULL != StoredTemplate)
return BioAPI_UNSUPPORTED_BIR_HANDLE;
if (NULL == NewTemplate)
return BioAPI_ERRCODE_INVALID_OUTPUT_POINTER;
else
*NewTemplate = BioAPI_INVALID_HANDLE;
if (NULL != AuditData)
*AuditData = BioAPI_UNSUPPORTED_BIR_HANDLE;
/*-------------------------*
* Initialize MAF Contexts *
*-------------------------*/
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (BioAPI_OK != ret) return ret;
if ((NULL == (pAttachData = Addin_GetAttachData())) )
SPI_RETURN(BioAPI_ERRCODE_INTERNAL_ERROR);
/*---------------------------------------------*
* Capture the BIR that will be used to create *
* the new enrollment template *
*---------------------------------------------*/
ret = _biospi_Capture(pAttachData, Purpose, &CapturedBIR);
if (BioAPI_OK != ret) SPI_RETURN(ret);
/*---------------------------------------------*
* Create the new enrollment template and *
* associate payload with the captured BIR *
*---------------------------------------------*/
ret = _biospi_GetBIRFromHandle(pAttachData, CapturedBIR,
&pInputCapturedBIR);
if (BioAPI_OK != ret) SPI_RETURN(ret);
ret = _biospi_CreateTemplate( pAttachData, pLoadData,
pInputCapturedBIR, NewTemplate,
Payload);
if (BioAPI_OK != ret) SPI_RETURN(ret);
/*---------------------------------------------------------*
* Release the BIR which was captured to perform the *
* enrollment *
*---------------------------------------------------------*/
ret = _biospi_FreeBIRHandle(pAttachData, CapturedBIR);
if (BioAPI_OK != ret) SPI_RETURN(ret);
SPI_RETURN(BioAPI_OK);
}
BioAPI_RETURN BioAPI BioSPI_GetBIRFromHandle(
BioAPI_HANDLE ModuleHandle,
BioAPI_BIR_HANDLE BIRHandle,
BioAPI_BIR_PTR *BIR )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
BioAPI_BIR *pFoundBIR = NULL;
ADDIN_ATTACH_DATA *pAttachData = NULL;
/*--------------------------*
* Check for bad parameters *
*--------------------------*/
if (NULL == BIR)
return BioAPI_ERRCODE_INVALID_OUTPUT_POINTER;
/*-------------------------*
* Initialize MAF Contexts *
*-------------------------*/
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (BioAPI_OK != ret) return ret;
if (NULL == (pAttachData = Addin_GetAttachData()))
SPI_RETURN(BioAPI_ERRCODE_INTERNAL_ERROR);
/*----------------------------------------------------------------*
* Call to the internal routine where the real functionality lies *
*----------------------------------------------------------------*/
ret = _biospi_GetBIRFromHandle(pAttachData, BIRHandle, &pFoundBIR);
if (BioAPI_OK != ret) SPI_RETURN(ret);
/* allocate memory in the Application's memory space
* for the BIR to be stored */
*BIR = App_Malloc(ModuleHandle, sizeof(BioAPI_BIR));
if (NULL == *BIR)
return (BioAPIERR_BSP_MEMORY_ERROR);
/* move BIR header to Application's memory space */
port_memcpy((void*)&(*BIR)->Header, (void*)&(pFoundBIR->Header),
sizeof(BioAPI_BIR_HEADER));
/* allocate memory in the Application's memory space
* for the biometric data to be stored */
(*BIR)->BiometricData = (BioAPI_BIR_BIOMETRIC_DATA*)
App_Malloc(ModuleHandle, LocalEndian4 ((*BIR)->Header.Length) - sizeof(BioAPI_BIR_HEADER));
if (NULL == (*BIR)->BiometricData)
return (BioAPIERR_BSP_MEMORY_ERROR);
/* move the BIR biometric data to the Application's memory space */
port_memcpy((void*)(*BIR)->BiometricData,
(void*)pFoundBIR->BiometricData,
LocalEndian4 ((*BIR)->Header.Length) - sizeof(BioAPI_BIR_HEADER));
/* This BSP cannot support signatures */
(*BIR)->Signature = NULL;
/*------------------------------------------------------------*
* Free the BIR now that it's been yielded to the application *
*------------------------------------------------------------*/
ret = _biospi_FreeBIRHandle(pAttachData, BIRHandle);
if (BioAPI_OK != ret) SPI_RETURN(ret);
SPI_RETURN(BioAPI_OK);
}
BioAPI_RETURN BioAPI BioSPI_Process(
BioAPI_HANDLE ModuleHandle,
const BioAPI_INPUT_BIR *CapturedBIR,
BioAPI_BIR_HANDLE_PTR ProcessedBIR )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
BioAPI_BIR *pBIRtoProcess = NULL;
ADDIN_ATTACH_DATA *pAttachData = NULL;
const void *pLoadData = NULL;
/*-----------------------------------------------------------------------*
* Check for bad parameters and initialize output for the case of errors *
*-----------------------------------------------------------------------*/
if (NULL == CapturedBIR)
return BioAPI_ERRCODE_INVALID_INPUT_POINTER;
if (NULL == ProcessedBIR)
return BioAPI_ERRCODE_INVALID_OUTPUT_POINTER;
else
*ProcessedBIR = BioAPI_INVALID_HANDLE;
/*-------------------------*
* Initialize MAF Contexts *
*-------------------------*/
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (BioAPI_OK != ret) return ret;
if ((NULL == (pAttachData = Addin_GetAttachData())) )
SPI_RETURN(BioAPI_ERRCODE_INTERNAL_ERROR);
/*-----------------------------------------------------------------*
* Check to ensure there are still handles available for more BIRs *
*-----------------------------------------------------------------*/
if (pAttachData->HandleIndex < 0)
/* Overflow, we've run out of handles */
SPI_RETURN(BioAPIERR_BSP_TOO_MANY_HANDLES);
/*-------------------------*
* Find the BIR to process *
*-------------------------*/
if (BioAPI_FULLBIR_INPUT == CapturedBIR->Form)
pBIRtoProcess = CapturedBIR->InputBIR.BIR;
else if (BioAPI_BIR_HANDLE_INPUT == CapturedBIR->Form)
{
ret = _biospi_GetBIRFromHandle(
pAttachData, *(CapturedBIR->InputBIR.BIRinBSP), &pBIRtoProcess);
if (BioAPI_OK != ret) SPI_RETURN(ret);
}
else
/* something went wrong - these are the only two
* forms supported by this BSP */
SPI_RETURN(BioAPIERR_BSP_INVALID_BIR);
/*----------------------------------------------------------------*
* Call to the internal routine where the real functionality lies *
*----------------------------------------------------------------*/
ret = _biospi_Process(pAttachData, pLoadData, pBIRtoProcess, ProcessedBIR);
if (BioAPI_OK != ret) SPI_RETURN(ret);
SPI_RETURN(BioAPI_OK);
}
BioAPI_RETURN BioAPI BioSPI_VerifyMatch(
BioAPI_HANDLE ModuleHandle,
const BioAPI_FAR *MaxFARRequested,
const BioAPI_FRR *MaxFRRRequested,
const BioAPI_BOOL *FARPrecedence,
const BioAPI_INPUT_BIR *ProcessedBIR,
const BioAPI_INPUT_BIR *StoredTemplate,
BioAPI_BIR_HANDLE *AdaptedBIR,
BioAPI_BOOL *Result,
BioAPI_FAR_PTR FARAchieved,
BioAPI_FRR_PTR FRRAchieved,
BioAPI_DATA_PTR *Payload )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
BioAPI_BIR *pCapturedBIR = NULL;
BioAPI_BIR *pTemplateBIR = NULL;
const ADDIN_ATTACH_DATA *pAttachData = NULL;
const void *pLoadData = NULL;
/*-----------------------------------------------------------------------*
* Check for bad parameters and initialize output for the case of errors *
*-----------------------------------------------------------------------*/
/* MaxFARRequested, MaxFRRRequested, and FARPrecedence are ignored
* anyway, so we won't quibble over those. See note below! */
if (NULL == ProcessedBIR || NULL == StoredTemplate)
return BioAPI_ERRCODE_INVALID_INPUT_POINTER;
if (NULL != AdaptedBIR)
*AdaptedBIR = BioAPI_UNSUPPORTED_BIR_HANDLE;
if (NULL == FARAchieved || NULL == Result)
return BioAPI_ERRCODE_INVALID_OUTPUT_POINTER;
*Result = BioAPI_FALSE;
if (Payload)
*Payload = NULL;
/*--------------------------------------------------------------------------*
* A note to begin this function, the false accept rate (FAR) for this BSP *
* is by nature next to nothing. The chances of someone being validated *
* by entering an incorrect password whose hash collides with the correct *
* one seems to me to have about the same odds as a person getting hit by *
* lightning 3 times in each of 3 states where he's won the lotto. We'll *
* just consider this to be zero, and ignore the parameter. The false *
* reject rate (FRR) is most certainly zero - if someone enters the correct *
* pasword, they WILL get access. No question there, so this parameter can *
* also be ignored. Similarly, the returned FAR and FRR achieved will *
* always be 0 and 0. *
*--------------------------------------------------------------------------*/
*FARAchieved = 0;
if (FRRAchieved)
*FRRAchieved = 0;
/*-------------------------*
* Initialize MAF Contexts *
*-------------------------*/
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (BioAPI_OK != ret) return ret;
if ((NULL == (pAttachData = Addin_GetAttachData())) )
SPI_RETURN(BioAPI_ERRCODE_INTERNAL_ERROR);
/*------------------------*
* Find the BIR to verify *
*------------------------*/
if (BioAPI_FULLBIR_INPUT == ProcessedBIR->Form)
pCapturedBIR = ProcessedBIR->InputBIR.BIR;
else if (BioAPI_BIR_HANDLE_INPUT == ProcessedBIR->Form)
{
ret = _biospi_GetBIRFromHandle(
pAttachData, *(ProcessedBIR->InputBIR.BIRinBSP), &pCapturedBIR);
if (BioAPI_OK != ret) SPI_RETURN(ret);
}
else
/* something went wrong - these are the only two
* forms supported by this BSP */
SPI_RETURN(BioAPIERR_BSP_INVALID_BIR);
/*-----------------------------------------*
* Find the template BIR to verify against *
*-----------------------------------------*/
if (BioAPI_FULLBIR_INPUT == StoredTemplate->Form)
pTemplateBIR = StoredTemplate->InputBIR.BIR;
else if (BioAPI_BIR_HANDLE_INPUT == StoredTemplate->Form)
{
ret = _biospi_GetBIRFromHandle(
pAttachData, *(StoredTemplate->InputBIR.BIRinBSP), &pTemplateBIR);
if (BioAPI_OK != ret) SPI_RETURN(ret);
}
else
/* something went wrong - these are the only two
* forms supported by this BSP */
SPI_RETURN(BioAPIERR_BSP_INVALID_BIR);
/*----------------------------------------------------------------*
* Call to the internal routine where the real functionality lies *
*----------------------------------------------------------------*/
ret = _biospi_VerifyMatch( pAttachData, pLoadData, ModuleHandle, pCapturedBIR,
pTemplateBIR, Result, Payload);
if (BioAPI_OK != ret) SPI_RETURN(ret);
SPI_RETURN(BioAPI_OK);
}
BioAPI_RETURN BioAPI BioSPI_Verify(
BioAPI_HANDLE ModuleHandle,
const BioAPI_FAR *MaxFARRequested,
const BioAPI_FRR *MaxFRRRequested,
const BioAPI_BOOL *FARPrecedence,
const BioAPI_INPUT_BIR *StoredTemplate,
BioAPI_BIR_HANDLE_PTR AdaptedBIR,
BioAPI_BOOL *Result,
BioAPI_FAR_PTR FARAchieved,
BioAPI_FRR_PTR FRRAchieved,
BioAPI_DATA_PTR *Payload,
sint32 Timeout,
BioAPI_BIR_HANDLE_PTR AuditData )
{
BioAPI_RETURN ret = BioAPI_OK;
void *pAddinContext = NULL;
BioAPI_BIR_HANDLE CapturedBIR;
BioAPI_BIR *pInputCapturedBIR;
BioAPI_BIR *pInputTemplateBIR;
ADDIN_ATTACH_DATA *pAttachData = NULL;
const void *pLoadData = NULL;
/*-----------------------------------------------------------------------*
* Check for bad parameters and initialize output for the case of errors *
*-----------------------------------------------------------------------*/
/* MaxFARRequested, MaxFRRRequested, and FARPrecedence are ignored
* anyway, so we won't quibble over those. See note below! */
if (NULL == StoredTemplate)
return BioAPI_ERRCODE_INVALID_INPUT_POINTER;
if (NULL != AdaptedBIR)
*AdaptedBIR = BioAPI_UNSUPPORTED_BIR_HANDLE;
if (NULL == FARAchieved || NULL == Result)
return BioAPI_ERRCODE_INVALID_OUTPUT_POINTER;
if (NULL != AuditData)
*AuditData = BioAPI_UNSUPPORTED_BIR_HANDLE;
*Result = BioAPI_FALSE;
if (Payload)
*Payload = NULL;
*FARAchieved = 0;
if (FRRAchieved)
*FRRAchieved = 0;
/*-------------------------*
* Initialize MAF Contexts *
*-------------------------*/
ADDIN_SPI_BEGIN(ret, ModuleHandle, pAddinContext);
if (BioAPI_OK != ret) return ret;
if (((ADDIN_ATTACH_DATA *)NULL == (pAttachData = Addin_GetAttachData())) )
SPI_RETURN(BioAPI_ERRCODE_INTERNAL_ERROR);
/*---------------------------------------------------------*
* Capture the BIR that will be used as verification *
* against the input template BIR *
*---------------------------------------------------------*/
ret = _biospi_Capture( pAttachData, BioAPI_PURPOSE_VERIFY, &CapturedBIR);
if (BioAPI_OK != ret) SPI_RETURN(ret);
/*---------------------------------------------------------*
* Verify that the two BIRs had the same plaintext *
* password, and if so, grab the payload from the template *
*---------------------------------------------------------*/
ret = _biospi_GetBIRFromHandle(pAttachData, CapturedBIR, &pInputCapturedBIR);
if (BioAPI_OK != ret) SPI_RETURN(ret);
/*-----------------------------------------*
* Find the template BIR to verify against *
*-----------------------------------------*/
if (BioAPI_FULLBIR_INPUT == StoredTemplate->Form)
pInputTemplateBIR = StoredTemplate->InputBIR.BIR;
else if (BioAPI_BIR_HANDLE_INPUT == StoredTemplate->Form)
{
ret = _biospi_GetBIRFromHandle(
pAttachData, *(StoredTemplate->InputBIR.BIRinBSP), &pInputTemplateBIR);
if (BioAPI_OK != ret) SPI_RETURN(ret);
}
else
/* something went wrong - these are the only two
* forms supported by this BSP */
SPI_RETURN(BioAPIERR_BSP_INVALID_BIR);
ret = _biospi_VerifyMatch(pAttachData, pLoadData, ModuleHandle,
pInputCapturedBIR,
pInputTemplateBIR,
Result,
Payload);
if (BioAPI_OK != ret) SPI_RETURN(ret);
/*---------------------------------------------------------*
* Release the BIR which was captured to perform the *
* verification *
*---------------------------------------------------------*/
ret = _biospi_FreeBIRHandle(pAttachData, CapturedBIR);
if (BioAPI_OK != ret) SPI_RETURN(ret);
SPI_RETURN(BioAPI_OK);
}
