Asynchrone Kontexte
Asynchrone SSPI-Sicherheits Kontexte ermöglichen Aufrufern das fortfahren ohne Blockierung und Empfang von Benachrichtigungen, sobald der Aufruf abgeschlossen ist. Asynchrone Kontexte werden derzeit nur für TLS-Clients und-Server im Kernelmodus unterstützt. Die folgenden asynchronen SSPI-Funktionen werden in asynchronen Sicherheits Kontexten ausgeführt:
Asynchrone Kontext Verwaltungs Typen
| Objektname | BESCHREIBUNG |
|---|---|
| Sspiasyncnotifycallback | Rückruf, der zum Benachrichtigen des Abschlusses eines Async-SSPI-Aufrufs verwendet wird. |
Asynchrone Kontext Verwaltungsfunktionen
| API-Name | BESCHREIBUNG |
|---|---|
| Sspikreateasynccontext | Erstellt eine Instanz von sspiasynccontext, die zum Nachverfolgen des asynchronen Aufrufes verwendet wird. |
| Sspireinitasynccontext | Markiert einen Async-Kontext für die Wiederverwendung. |
| Sspisetasyncnotifycallback | Registriert einen Rückruf, der beim Abschluss des asynchronen Aufrufs benachrichtigt wird. |
| Sspiasynccontextrequiresnotify | Bestimmt, ob ein angegebener asynchroner Kontext eine Benachrichtigung über den Abschluss des Aufrufes erfordert. |
| Sspigetasynccallstatus | Ruft den aktuellen Status eines Async-Aufrufes ab, der dem bereitgestellten Kontext zugeordnet ist. |
| Sspifreasynccontext | Gibt einen kontextfrei, der im Aufrufen der sspikreateasynccontext-Funktion erstellt wurde. |
Async-SSPI-Funktionen
Die folgenden Funktionen akzeptieren einen asynchronen Kontext zusätzlich zu denselben Parametern wie Ihre synchrone Entsprechung.
| API-Name | BESCHREIBUNG |
|---|---|
| Sspiacquirecredentialshandleasync | Ruft asynchron ein Handle für bereits vorhandene Anmelde Informationen eines Sicherheits Prinzipals ab. |
| Sspiaccept tsecuritycontextasync | Ermöglicht der Serverkomponente einer Transport Anwendung das asynchrone Einrichten eines Sicherheits Kontexts zwischen dem Server und einem Remote Client. |
| Sspiinitializesecuritycontextasync | Initialisiert einen Async-Sicherheitskontext. |
| Sspidelta etesecuritycontextasync | Löscht die lokalen Datenstrukturen, die dem angegebenen Sicherheitskontext zugeordnet sind, der durch einen vorherigen Aufrufen der sspiinitializesecuritycontextasync-Funktion oder der sspiaccept-securitycontextasync-Funktion initiiert wurde. |
| Sspifreecredentialshandleasync | Gibt ein Anmelde Informationen-Handle frei. |
API-Beispiel
Ein typischer callflow funktioniert wie folgt:
- Sspiasynccontext-Kontext zum Nachverfolgen des Aufrufes mithilfe von sspikreateasynccontext erstellen
- Registrieren eines sspiasyncnotifycallback für den Kontext
- Asynchronen Aufrufen mithilfe von sspiaccept tsecuritycontextasync
- Bei Rückruf das Ergebnis mithilfe von sspigetasynccallstatus abrufen
- Löschen Sie sspiasynccontext mithilfe von sspidelta etesecuritycontextasync. Wenn Sie den Kontext mit sspireinitasynccontextwieder verwenden, gehen Sie zurück zu Schritt 2.
Das folgende Beispiel veranschaulicht den Aufruf von sspiaccept tsecuritycontextasync. Das Beispiel wartet auf den Abschluss des Aufrufes und ruft das Ergebnis ab.
Bei einem vollständigen SSPI-Handshake werden "sspiaccept tsecuritycontextasync" und "sspiinitializesecuritycontextasync" mehrmals aufgerufen, bis SEC_E_OK zurückgegeben wird. Sspireinitasynccontext wurde bereitgestellt, um die Benutzerfreundlichkeit zu vereinfachen und die Leistung in diesem Fall zu vereinfachen.
Assertionen werden verwendet, um hervorzuheben, was wir bei Erfolg erwarten.
#include <sspi.h>
void AsyncCallCompleted(
_In_ SspiAsyncContext* AsyncContext,
_In_opt_ PVOID pCallbackData
)
{
// Get result.
SECURITY_STATUS Status = SspiGetAsyncCallStatus(AsyncContext);
ASSERT(SEC_E_OK == Status);
// *Perform any needed callback actions, use pCallbackData if needed*
// Clean up async context when done.
SspiFreeAsyncContext(AsyncContext);
}
void DoASCCall(
_In_opt_ PCredHandle phCred,
_In_opt_ PCtxtHandle phContext,
_In_opt_ PSecBufferDesc pInput,
_In_opt_ PSecBufferDesc pOutput,
_Out_ unsigned long* pfContextAttr,
_Out_opt_ PTimeStamp ptsExpiry
)
{
// Create context for async call
SspiAsyncContext* AsyncContext = SspiCreateAsyncContext();
// Check for out of memory condition
ASSERT(AsyncContext);
// Register callback that continues execution upon completion.
PVOID pCallbackData = … ; // *Setup any state needed for callback.*
SECURITY_STATUS Status = SspiSetAsyncNotifyCallback(AsyncContext,
AsyncCallCompleted,
pCallbackData);
ASSERT(SEC_E_OK == Status);
// Queue asynchronous call.
Status = SspiAcceptSecurityContextAsync(AsyncContext,
phCred,
phContext,
pInput,
ASC_REQ_CONNECTION,
SECURITY_NATIVE_DREP,
phContext,
pOutput,
pfContextAttr,
ptsExpiry);
// All async functions return the status of queueing the async call,
// not the call’s result.
ASSERT(SEC_E_OK == Status);
// At this point, the call can be pending or complete.
// If complete, the result or error is returned.
// For this example, we assume if it finished, it finished with SEC_E_OK.
Status = SspiGetAsyncCallStatus(AsyncContext);
ASSERT(SEC_I_ASYNC_CALL_PENDING == Status ||
SEC_E_OK == Status);
// Execution will continue in the callback upon completion
}