Implementera IMFNetCredentialManager
Gör följande i metoden IMFNetCredentialManager::BeginGetCredentials.
- Om du inte redan har en IMFNetCredentialCache-pekare anropar du MFCreateCredentialCache för att skapa cacheobjektet för autentiseringsuppgifter. Lagra den här pekaren.
- Anropa IMFNetCredentialCache::GetCredential. Ange flaggorna i parametern dwAuthenticationFlags enligt följande:
- Om hrOp medlem av MFNetCredentialManagerGetParam strukturen är lika med NS_E_PROXY_ACCESSDENIED, anger du flaggan MFNET_AUTHENTICATION_PROXY.
- Om fClearTextPackage är TRUEanger du flaggan MFNET_AUTHENTICATION_CLEAR_TEXT.
- Om fAllowLoggedOnUser är TRUE, ställ in flaggan MFNET_AUTHENTICATION_LOGGED_ON_USER.
- Metoden GetCredential returnerar en IMFNetCredential- pekare och eventuellt flaggan REQUIRE_PROMPT. Lagra pekaren IMFNetCredential.
- Om GetCredential inte returnerar -flaggan REQUIRE_PROMPT är du färdig. Gå vidare till steg 9.
- Om GetCredential- returnerar flaggan REQUIRE_PROMPT måste du annars fråga användaren om hans eller hennes användarnamn och lösenord.
- Om fClearTextPackage är FALSEkrypterar du autentiseringsuppgifterna.
- Anropa IMFNetCredential::SetUser och IMFNetCredential::SetPassword för att ange användarens namn och lösenord för objektet för autentiseringsuppgifter.
- Du kan också anropa IMFNetCredentialCache::SetUserOptions för att uppdatera cacheobjektet för autentiseringsuppgifter med användarens inställningar för att lagra och skicka autentiseringsuppgifter.
- Anropa återkallningsfunktionen IMFAsyncCallback genom att anropa MFInvokeCallback.
I metoden IMFNetCredentialManager::EndGetCredentials returnerar du IMFNetCredential pekare som hämtats i metoden BeginGetCredentials.
I metoden IMFNetCredentialManager::SetGood skickar du indataparametrarna direkt till metoden IMFNetCredentialCache::SetGood. Detta meddelar cacheminnet för autentiseringsuppgifter om autentiseringsuppgifterna har godkänts av servern.
Om du behöver fråga användaren (steg 5) eller kryptera autentiseringsuppgifterna (steg 6) bör du göra det i en arbetskötråd så att du inte blockerar Microsoft Media Foundation-pipelinen. Anropa MFPutWorkItem och utför sedan de återstående stegen i återanropet till arbetskön.
Anteckning
Tänk på att BeginGetCredentials kan anropas medan nätverkskällan skapas. Om du skapar nätverkskällan genom att anropa den synkrona IMFSourceResolver::CreateObjectFromURL-metoden kan anropstråden blockeras när autentiseringsuppgifterna hämtas. Därför rekommenderar vi att du använder den asynkrona IMFSourceResolver::BeginCreateObjectFromURL-metoden i stället.
Exempel
Det här exemplet visar en typ av beteende som en autentiseringsansvarig kan tillhandahålla.
Här är en förklaring av klassen som implementerar 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);
};
För att spåra tillståndet för åtgärden BeginGetCredentials använder klassen följande hjälpobjekt:
// 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;
}
};
Metoden BeginGetCredentials skapar cachen för autentiseringsuppgifter och hämtar en IMFNetCredential- pekare. Om användaren måste uppmanas (anges av flaggan REQUIRE_PROMPT) anropar metoden MFPutWorkItem för att köa ett nytt arbetsobjekt:
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;
}
Arbetstråden anropar Invoke, som först uppmanar användaren och sedan anropar MFInvokeCallback- för att anropa återkallningspekaren som angavs i 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;
}
Metoden EndGetCredentials slutför åtgärden genom att returnera pekaren IMFNetCredential till anroparen.
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;
}
Relaterade ämnen