Implementación de IMFNetCredentialManager

Artículo
06/13/2023

En el método IMFNetCredentialManager::BeginGetCredentials , haga lo siguiente.

Si aún no tiene un puntero IMFNetCredentialCache , llame a MFCreateCredentialCache para crear el objeto de caché de credenciales. Almacene este puntero.
Llame a IMFNetCredentialCache::GetCredential. Establezca las marcas en el parámetro dwAuthenticationFlags de la siguiente manera:
- Si el miembro hrOp de la estructura MFNetCredentialManagerGetParam es igual a NS_E_PROXY_ACCESSDENIED, establezca la marca MFNET_AUTHENTICATION_PROXY .
- Si fClearTextPackage es TRUE, establezca la marca MFNET_AUTHENTICATION_CLEAR_TEXT .
- Si fAllowLoggedOnUser es TRUE, establezca la marca MFNET_AUTHENTICATION_LOGGED_ON_USER .
El método GetCredential devuelve un puntero IMFNetCredential y, posiblemente, la marca REQUIRE_PROMPT. Almacene el puntero IMFNetCredential .
Si GetCredential no devuelve la marca REQUIRE_PROMPT , ya ha terminado. Vaya al paso 9.
De lo contrario, si GetCredential devuelve la marca REQUIRE_PROMPT , debe solicitar al usuario su nombre de usuario y contraseña.
Si fClearTextPackage es FALSE, cifre las credenciales.
Llame a IMFNetCredential::SetUser y IMFNetCredential::SetPassword para establecer el nombre y la contraseña del usuario en el objeto de credenciales.
Opcionalmente, llame a IMFNetCredentialCache::SetUserOptions para actualizar el objeto de caché de credenciales con las preferencias del usuario para almacenar y enviar credenciales.
Invoque la devolución de llamada IMFAsyncCallback llamando a MFInvokeCallback.

En el método IMFNetCredentialManager::EndGetCredentials , devuelve el puntero IMFNetCredential obtenido en el método BeginGetCredentials .

En el método IMFNetCredentialManager::SetGood , pase los parámetros de entrada directamente al método IMFNetCredentialCache::SetGood . Esto notifica a la memoria caché de credenciales si el servidor aceptó las credenciales.

Si necesita solicitar al usuario (paso 5) o cifrar las credenciales (paso 6), debe hacerlo en un subproceso de cola de trabajo, de modo que no bloquee la canalización de Microsoft Media Foundation. Llame a MFPutWorkItem y realice los pasos restantes dentro de la devolución de llamada de la cola de trabajo.

Nota:

Tenga en cuenta que BeginGetCredentials se puede invocar mientras se crea el origen de red. Por lo tanto, si crea el origen de red llamando al método IMFSourceResolver::CreateObjectFromURL sincrónico, el subproceso que realiza la llamada podría bloquearse mientras se adquieren las credenciales. Por lo tanto, se recomienda usar el método asincrónico IMFSourceResolver::BeginCreateObjectFromURL en su lugar.

Ejemplo

En este ejemplo se muestra un tipo de comportamiento que podría proporcionar un administrador de credenciales.

Esta es una declaración de la clase que implementa IMFNetCredentialManager.

class CCredentialManager : public IMFNetCredentialManager, IMFAsyncCallback 
{
    long                    m_cRef;
    IMFNetCredentialCache   *m_pCredentialCache;

public:
    CCredentialManager () : m_cRef(1), m_pCredentialCache(NULL)
    { 
    }
    ~CCredentialManager()
    {
        SafeRelease(&m_pCredentialCache);
    }

    STDMETHODIMP QueryInterface(REFIID riid, void** ppv)
    {
        static const QITAB qit[] = 
        {
            QITABENT(CCredentialManager, IMFNetCredentialManager),
            QITABENT(CCredentialManager, IMFAsyncCallback),
            { 0 }
        };
        return QISearch(this, qit, riid, ppv);
    }      

    STDMETHODIMP_(ULONG) AddRef()
    {
        return InterlockedIncrement(&m_cRef);
    }

    STDMETHODIMP_(ULONG) Release()
    {
        LONG cRef = InterlockedDecrement(&m_cRef);
        if (cRef == 0)
        {
            delete this;
        }
        return cRef;
    }

    STDMETHODIMP BeginGetCredentials(
        MFNetCredentialManagerGetParam* pParam,
        IMFAsyncCallback* pCallback,
        IUnknown* pState
        );

    STDMETHODIMP EndGetCredentials(
        IMFAsyncResult* pResult, 
        IMFNetCredential** ppCred);

    STDMETHODIMP SetGood(IMFNetCredential* pCred, BOOL fGood)
    {
        if (!pCred)
        {
            return E_POINTER;
        }

        return m_pCredentialCache->SetGood(pCred, fGood);
    }


    STDMETHODIMP GetParameters(DWORD* pdwFlags, DWORD* pdwQueue)
    {
        return E_NOTIMPL;
    }

    STDMETHODIMP Invoke(IMFAsyncResult* pResult);
};

Para realizar un seguimiento del estado de la operación BeginGetCredentials , la clase usa el siguiente objeto auxiliar:

// Holds state information for the GetCredentials operation, so that work can 
// be moved to a work-queue thread.

struct CredentialOp : public IUnknown
{
    long                m_cRef;
    IMFNetCredential    *m_pCredential;
    DWORD               m_dwFlags;

    CredentialOp(IMFNetCredential *pCredential) 
        : m_cRef(1), m_dwFlags(0), m_pCredential(pCredential)
    {
        m_pCredential->AddRef();
    }

    ~CredentialOp()
    {
        SafeRelease(&m_pCredential);
    }

    STDMETHODIMP QueryInterface(REFIID riid, void** ppv)
    {
        static const QITAB qit[] = 
        {
            QITABENT(CredentialOp, IUnknown),
            { 0 }
        };
        return QISearch(this, qit, riid, ppv);
    }      

    STDMETHODIMP_(ULONG) AddRef()
    {
        return InterlockedIncrement(&m_cRef);
    }

    STDMETHODIMP_(ULONG) Release()
    {
        LONG cRef = InterlockedDecrement(&m_cRef);
        if (cRef == 0)
        {
            delete this;
        }
        return cRef;
    }
};

El método BeginGetCredentials crea la memoria caché de credenciales y obtiene un puntero IMFNetCredential . Si se debe solicitar al usuario (indicado por la marca REQUIRE_PROMPT ), el método llama a MFPutWorkItem para poner en cola un nuevo elemento de trabajo:

STDMETHODIMP CCredentialManager::BeginGetCredentials(
    MFNetCredentialManagerGetParam* pParam,
    IMFAsyncCallback* pCallback,
    IUnknown* pState
    )
{
    if (!pParam || !pCallback)
    {
        return E_POINTER;
    }

    DWORD dwAuthenticationFlags = 0;
    DWORD dwRequirementFlags = 0;

    if (pParam->hrOp == NS_E_PROXY_ACCESSDENIED)
    {
        dwAuthenticationFlags |= MFNET_AUTHENTICATION_PROXY;
    }

    if (pParam->fAllowLoggedOnUser)
    {
        dwAuthenticationFlags |= MFNET_AUTHENTICATION_LOGGED_ON_USER;
    }

    if (pParam->fClearTextPackage)
    {
        dwAuthenticationFlags |= MFNET_AUTHENTICATION_CLEAR_TEXT;
    }

    IMFNetCredential *pCredential =  NULL;
    IMFAsyncResult* pResult = NULL;

    HRESULT hr = S_OK;

    if (m_pCredentialCache == NULL)
    {
        hr = MFCreateCredentialCache(&m_pCredentialCache);
        if (FAILED(hr))
        {
            goto done;
        }
    }

    hr = m_pCredentialCache->GetCredential(
        pParam->pszUrl, 
        pParam->pszRealm, 
        dwAuthenticationFlags, 
        &pCredential, 
        &dwRequirementFlags
        );

    if (FAILED(hr))
    {
        goto done;
    }

    if( ( dwRequirementFlags & REQUIRE_PROMPT ) == 0 )
    {
        // The credential is good to use. Prompting the user is not required.
        hr = S_OK;
        goto done;
    }

    // The credential requires prompting the user. 
    CredentialOp *pOp = new (std::nothrow) CredentialOp(pCredential);

    if (pOp == NULL)
    {
        hr = E_OUTOFMEMORY;
        goto done;
    }

    // Set flags. Use these to inform the user if the credentials will
    // be sent in plaintext or saved in the credential cache.

    if (pParam->fClearTextPackage)
    {
        // Notify the user that credentials will be sent in plaintext.
        pOp->m_dwFlags |= MFNET_CREDENTIAL_ALLOW_CLEAR_TEXT;
    }

    if(dwRequirementFlags & REQUIRE_SAVE_SELECTED )
    {
        // Credentials will be saved in the cache by default.
        pOp->m_dwFlags |= MFNET_CREDENTIAL_SAVE;
    }

    // NOTE: The application should enable to user to deselect these two flags;
    // for example, through check boxes in the prompt dialog.


    // Now queue the work item.

    hr = MFCreateAsyncResult(pOp, pCallback, pState, &pResult);
    if (FAILED(hr))
    {
        goto done;
    }

    hr = MFPutWorkItem(MFASYNC_CALLBACK_QUEUE_LONG_FUNCTION, this, pResult);

done:
    SafeRelease(&pResult);
    SafeRelease(&pCredential);
    SafeRelease(&pOp);
    return hr;
}

El subproceso de cola de trabajo llama a Invoke, que solicita al usuario y, a continuación, llama a MFInvokeCallback para invocar el puntero de devolución de llamada que se proporcionó en BeginGetCredentials.

STDMETHODIMP CCredentialManager::Invoke(IMFAsyncResult* pResult)
{
    IUnknown *pState = NULL;
    IMFAsyncResult *pGetCredentialsResult = NULL;
    IUnknown *pOpState = NULL;

    CredentialOp *pOp = NULL;   // not AddRef'd

    HRESULT hr = pResult->GetState(&pState);

    if (SUCCEEDED(hr))
    {
        hr = pState->QueryInterface(IID_PPV_ARGS(&pGetCredentialsResult));
    }

    if (SUCCEEDED(hr))
    {
        hr = pGetCredentialsResult->GetObject(&pOpState);
    }

    if (SUCCEEDED(hr))
    {
        pOp = static_cast<CredentialOp*>(pOpState);

        // Display a dialog for the user to enter user name and password.
        hr = PromptUserCredentials(pOp);
    }

    if (SUCCEEDED(hr) && m_pCredentialCache)
    {
        // Update with options set by the user.
        hr = m_pCredentialCache->SetUserOptions(
            pOp->m_pCredential, 
            pOp->m_dwFlags
            );
    }

    if (pGetCredentialsResult)
    {
        pGetCredentialsResult->SetStatus(hr);
        MFInvokeCallback(pGetCredentialsResult);
    }

    SafeRelease(&pState);
    SafeRelease(&pGetCredentialsResult);
    SafeRelease(&pOpState);
    return S_OK;
}

El método EndGetCredentials completa la operación devolviendo el puntero IMFNetCredential al autor de la llamada.

STDMETHODIMP CCredentialManager::EndGetCredentials(
    IMFAsyncResult* pResult, 
    IMFNetCredential** ppCred
    )
{
    if (!pResult || !ppCred)
    {
        return E_POINTER;
    }

    *ppCred = NULL;

    IUnknown *pUnk = NULL;

    // Check the result of the asynchronous operation.
    HRESULT hr = pResult->GetStatus();

    if (FAILED(hr))
    {
        // The operation failed.
        goto done;
    }

    hr = pResult->GetObject(&pUnk);
    if (FAILED(hr))
    {
        goto done;
    }

    CredentialOp *pOp = static_cast<CredentialOp*>(pUnk);

    *ppCred = pOp->m_pCredential;
    pOp->m_pCredential = NULL;

done:
    SafeRelease(&pUnk);
    return hr;
}

Autenticación de origen de red

Compartir a través de

Implementación de IMFNetCredentialManager

Ejemplo

Comentarios

Recursos adicionales

Compartir a través de

Implementación de IMFNetCredentialManager

Ejemplo

Temas relacionados

Comentarios

Recursos adicionales