PIBIO_SENSOR_CONTROL_UNIT_PRIVILEGED_FN fonction de rappel (winbio_adapter.h)
Appelé par l’infrastructure biométrique Windows pour effectuer une opération de contrôle définie par le fournisseur qui nécessite des privilèges élevés. Appelez la fonction SensorAdapterControlUnit pour effectuer une opération de contrôle définie par le fournisseur qui ne nécessite pas de privilèges élevés.
Syntaxe
PIBIO_SENSOR_CONTROL_UNIT_PRIVILEGED_FN PibioSensorControlUnitPrivilegedFn;
HRESULT PibioSensorControlUnitPrivilegedFn(
[in, out] PWINBIO_PIPELINE Pipeline,
[in] ULONG ControlCode,
[in] PUCHAR SendBuffer,
[in] SIZE_T SendBufferSize,
[in] PUCHAR ReceiveBuffer,
[in] SIZE_T ReceiveBufferSize,
[out] PSIZE_T ReceiveDataSize,
[out] PULONG OperationStatus
)
{...}
Paramètres
[in, out] Pipeline
Pointeur vers une structure WINBIO_PIPELINE associée à l’unité biométrique effectuant l’opération.
[in] ControlCode
Valeur ULONG qui spécifie l’opération définie par le fournisseur à effectuer.
[in] SendBuffer
Pointeur vers une mémoire tampon qui contient les informations de contrôle envoyées à l’adaptateur de capteur. Le format et le contenu de la mémoire tampon sont définis par le fournisseur.
[in] SendBufferSize
Taille, en octets, de la mémoire tampon spécifiée par le paramètre SendBuffer .
[in] ReceiveBuffer
Pointeur vers une mémoire tampon qui reçoit des informations retournées par l’adaptateur de capteur en réponse à l’opération de contrôle. Le format de la mémoire tampon est défini par le fournisseur.
[in] ReceiveBufferSize
Taille, en octets, de la mémoire tampon spécifiée par le paramètre ReceiveBuffer .
[out] ReceiveDataSize
Pointeur vers une variable qui reçoit la taille, en octets, des données écrites dans la mémoire tampon spécifiée par le paramètre ReceiveBuffer .
[out] OperationStatus
Pointeur vers une variable qui reçoit un code status défini par le fournisseur qui spécifie le résultat de l’opération de contrôle.
Valeur retournée
Si la fonction réussit, elle retourne S_OK. Si la fonction échoue, elle doit retourner l’une des valeurs HRESULT suivantes pour indiquer l’erreur.
| Code de retour | Description |
|---|---|
|
Un argument pointeur obligatoire est NULL. |
|
La taille ou le format de la mémoire tampon spécifiée par le paramètre SendBuffer n’est pas correct, ou la valeur spécifiée dans le paramètre ControlCode n’est pas reconnue par l’adaptateur. |
|
La mémoire tampon spécifiée par le paramètre ReceiveBuffer est trop petite. |
|
L'opération a été annulée. |
|
Il y a eu une défaillance matérielle. |
|
La valeur spécifiée dans le paramètre ControlCode n’est pas reconnue par l’adaptateur.
Note À compter de Windows 8, utilisez uniquement E_INVALIDARG pour signaler cette condition.
|
Remarques
Votre implémentation de cette fonction doit être identique à celle de la fonction SensorAdapterControlUnit , sauf que des privilèges élevés sont requis pour effectuer les opérations spécifiées par le paramètre ControlCode . Vous êtes responsable de la définition des opérations et de la détermination de celles qui nécessiteront des privilèges élevés.
Cette fonction doit case activée la valeur du paramètre ReceiveBufferSize pour être certaine que la mémoire tampon spécifiée par le paramètre ReceiveBuffer est suffisamment grande pour contenir les données retournées.
Exemples
Le pseudo-code suivant montre une implémentation possible de cette fonction. L’exemple ne se compile pas. Vous devez l’adapter à votre objectif.
//////////////////////////////////////////////////////////////////////////////////////////
//
// SensorAdapterControlUnitPrivileged
//
// Purpose:
// Performs a vendor-defined control operation that requires elevated
// privilege.
//
// Parameters:
// Pipeline - Pointer to a WINBIO_PIPELINE structure associated
// with the biometric unit performing the operation
// ControlCode - Specifies the vendor-defined operation to perform
// SendBuffer - Contains the control information sent to the
// sensor adapter
// SendBufferSize - Size, in bytes, of the buffer specified by the
// SendBuffer parameter
// ReceiveBuffer - Receives information returned by the sensor adapter
// in response to the control operation
// ReceiveBufferSize - Size, in bytes, of the buffer specified by the
// ReceiveBuffer parameter.
// ReceiveDataSize - Receives the size, in bytes, of the data written to
// the buffer specified by the ReceiveBuffer parameter
// OperationStatus - Receives a vendor-defined status code that specifies
// the outcome of the control operation.
//
static HRESULT
WINAPI
SensorAdapterControlUnitPrivileged(
__inout PWINBIO_PIPELINE Pipeline,
__in ULONG ControlCode,
__in_bcount(SendBufferSize) PUCHAR SendBuffer,
__in SIZE_T SendBufferSize,
__in_bcount(ReceiveBufferSize) PUCHAR ReceiveBuffer,
__in SIZE_T ReceiveBufferSize,
__out SIZE_T *ReceiveDataSize,
__out ULONG *OperationStatus
)
{
HRESULT hr = S_OK;
BOOL result = TRUE;
// Verify that pointer arguments are not NULL.
if (!ARGUMENT_PRESENT(Pipeline) ||
!ARGUMENT_PRESENT(SendBuffer) ||
!ARGUMENT_PRESENT(ReceiveBuffer) ||
!ARGUMENT_PRESENT(ReceiveDataSize) ||
!ARGUMENT_PRESENT(OperationStatus))
{
hr = E_POINTER;
goto cleanup;
}
// Retrieve the context from the pipeline.
PWINBIO_SENSOR_CONTEXT sensorContext =
(PWINBIO_SENSOR_CONTEXT)Pipeline->SensorContext;
// Verify the state of the pipeline.
if (sensorContext == NULL ||
Pipeline->SensorHandle == INVALID_HANDLE_VALUE)
{
hr = WINBIO_E_INVALID_DEVICE_STATE;
goto cleanup;
}
switch (ControlCode)
{
case MY_PRIVILEGED_CTRL_CODE_P1:
{
CTRL_CODE_P1_SEND_BUFFER *sendBuffer = (CTRL_CODE_P1_SEND_BUFFER*)SendBuffer;
// Verify the size of the send buffer.
if (SendBufferSize < sizeof(CTRL_CODE_P1_SEND_BUFFER))
{
hr = E_INVALIDARG;
break;
}
// Perform any other checks that may be required on the buffer
// contents. Return E_INVALIDARG if any of the checks fail.
if (sendBuffer->SomeField != SomeSpecialValue ||
sendBuffer->SomeOtherField != SomeOtherSpecialValue)
{
hr = E_INVALIDARG;
break;
}
if (ReceiveBufferSize < sizeof(CTRL_CODE_P1_RECEIVE_BUFFER))
{
hr = E_NOT_SUFFICIENT_BUFFER;
break;
}
}
// Fall through and perform the control operation after the switch
// statement. Alternatively, depending on your requirements, you can
// perform the control operation here.
break;
case MY_PRIVILEGED_CTRL_CODE_P2:
// Continue testing for other non-privileged control codes that your
// adapter supports.
{
CTRL_CODE_P2_SEND_BUFFER *sendBuffer = (CTRL_CODE_P2_SEND_BUFFER*)SendBuffer;
// Verify the size of the send buffer.
if (SendBufferSize < sizeof(CTRL_CODE_P2_SEND_BUFFER))
{
hr = E_INVALIDARG;
break;
}
// Perform any other checks that may be required on the buffer
// contents. Return E_INVALIDARG if any of the checks fail.
if (sendBuffer->SomeField != SomeSpecialValue ||
sendBuffer->SomeOtherField != SomeOtherSpecialValue)
{
hr = E_INVALIDARG;
break;
}
if (ReceiveBufferSize < sizeof(CTRL_CODE_P2_RECEIVE_BUFFER))
{
hr = E_NOT_SUFFICIENT_BUFFER;
break;
}
}
break;
default:
// All unrecognized control code values should return an error.
hr = WINBIO_E_INVALID_CONTROL_CODE;
break;
}
if (FAILED(hr))
{
goto cleanup;
}
// If control code validation succeeds, perform the control operation. This
// example assumes that the driver performs overlapped I/O and that a properly
// initialized OVERLAPPED structure is contained in the sensor context.
result = DeviceIoControl(
Pipeline->SensorHandle,
ControlCode,
SendBuffer,
(DWORD)SendBufferSize,
ReceiveBuffer,
(DWORD)ReceiveBufferSize,
(LPDWORD)ReceiveDataSize,
&sensorContext->Overlapped
);
if (result == FALSE && GetLastError() == ERROR_IO_PENDING)
{
SetLastError(ERROR_SUCCESS);
result = GetOverlappedResult(
Pipeline->SensorHandle,
&sensorContext->Overlapped,
(LPDWORD)ReceiveDataSize,
TRUE
);
}
*OperationStatus = GetLastError();
if (!result)
{
hr = _AdapterGetHresultFromWin32(*OperationStatus);
}
cleanup:
return hr;
}
Configuration requise
| Condition requise | Valeur |
|---|---|
| Client minimal pris en charge | Windows 7 [applications de bureau uniquement] |
| Serveur minimal pris en charge | Windows Server 2008 R2 [applications de bureau uniquement] |
| Plateforme cible | Windows |
| En-tête | winbio_adapter.h (include Winbio_adapter.h) |