windows-server-2003/inetcore/wininet/inetui/ierrui.cxx

/*++

Copyright (c) 1995  Microsoft Corporation

Module Name:

    ierrui.cxx

Abstract:

    Contains immplimentation of generic Error UI API.

    Contents:
        InternetErrorDlg
        InternetConfirmZoneCrossing
        (wErrorUIInvalidPassword)

Author:

    Arthur L Bierer (arthurbi) 04-Apr-1996

Revision History:

    04-Apr-1996 arthurbi
        Created

--*/

#include <wininetp.h>
#include <persist.h>
#include "ierrui.hxx"


//
// private prototypes
//



PRIVATE
DWORD
wErrorUIInvalidPassword(
    IN HWND hWnd,
    IN OUT HINTERNET hRequest,
    IN DWORD dwError,
    IN DWORD dwFlags,
    IN OUT LPVOID *lppvData
    );


//
// public functions
//

INTERNETAPI_(DWORD) InternetErrorDlg(IN HWND hWnd,
                 IN OUT HINTERNET hRequest,
                 IN DWORD dwError,
                 IN DWORD dwFlags,
                 IN OUT LPVOID *lppvData
                 )
/*++

Routine Description:

    Creates an Error Dialog informing the User of a problem with a WinINet HttpSendRequest.
    Can optionally store the results of dialog in the HTTP handle.
    Data may be specified in the lppvData pointer, or optionally InternetErrorDlg
    will gather the information from the HTTP handle

Arguments:

    hWnd -        Window handle to be used as the parent window of a Error Dialog.

    hRequest -    An open HTTP request handle
                  where headers will be added if needed.

    dwError -     The Error code to which the appropriate UI will be shown for.

    dwFlags -     Can be any of all of the following Flags:

                    FLAGS_ERROR_UI_FLAGS_GENERATE_DATA - generates lppvData, and queries
                    internet handle for information.

                    FLAGS_ERROR_UI_FILTER_FOR_ERRORS - scans the returned headers,
                    and determines if there is a "hidden" error, such as an authentication
                    failure.

                    FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS - On successful return of the dialog,
                    this flag will causes the results to be stored in the handle.

                    FLAGS_ERROR_UI_SERIALIZE_DIALOGS - display only one auth dlg and
                    notify subsequent threads when the dialog has been dismissed.

    lppvData -    Contains a Pointer to a Pointer where a stucture is stored containing
                  error specific data, and Dialog results.


Return Value:

    DWORD
    Success - ERROR_SUCCESS

    Failure - One of Serveral Error codes defined in winerror.h or wininet.w

Comments:

    BUGBUG - need to look into multiple authentication scheme handling, and
    how it relates to the UI

--*/

{
    DEBUG_ENTER_API((DBG_HTTP,
                     Dword,
                     "InternetErrorDlg",
                     "%#x, %#x, %s (%d), %#x, %#x",
                     hWnd,
                     hRequest,
                     InternetMapError(dwError),
                     dwError,
                     dwFlags,
                     lppvData
                     ));

    DWORD dwStatusCode = HTTP_STATUS_OK;
    DWORD error = ERROR_SUCCESS;
    HINTERNET hMappedRequestHandle = NULL;
    HINTERNET_HANDLE_TYPE handleType;
    HTTP_REQUEST_HANDLE_OBJECT *lpRequest;

    LPVOID lpVoidData;

    //
    // Check Parameters
    //

    if ( !(dwFlags & FLAGS_ERROR_UI_FLAGS_NO_UI) &&
         !IsWindow(hWnd) )
    {
        error = ERROR_INVALID_HANDLE;
        goto quit;
    }

    if (!GlobalDataInitialized) {
        error = GlobalDataInitialize();
        if (error != ERROR_SUCCESS) {
            goto quit;
        }
    }

    if ( hRequest )
    {
        error = MapHandleToAddress(hRequest, (LPVOID *)&hMappedRequestHandle, FALSE);

        if ( error != ERROR_SUCCESS )
            goto quit;

        //
        //  We only support HttpRequestHandles for this form of UI.
        //


        error = RGetHandleType(hMappedRequestHandle, &handleType);

        if ( error != ERROR_SUCCESS || handleType != TypeHttpRequestHandle )
            goto quit;

        lpRequest = (HTTP_REQUEST_HANDLE_OBJECT *) hMappedRequestHandle;

        //
        // See if we can detect an error if needed
        //

        if ( dwFlags & FLAGS_ERROR_UI_FILTER_FOR_ERRORS )
        {
            dwStatusCode = lpRequest->GetStatusCode();

            if ( dwStatusCode == HTTP_STATUS_DENIED || dwStatusCode == HTTP_STATUS_PROXY_AUTH_REQ )
                dwError = ERROR_INTERNET_INCORRECT_PASSWORD;

            if ( lpRequest->GetBlockingFilter())
                dwError = ERROR_INTERNET_NEED_UI;
        }
    }
    else
    {
        if( ERROR_INTERNET_NEED_UI                  == dwError ||
            ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED  == dwError ||
            ERROR_INTERNET_INSERT_CDROM             == dwError ||
            ERROR_INTERNET_INCORRECT_PASSWORD       == dwError )
        {

            error = ERROR_INVALID_PARAMETER;
            goto quit;
        }
    }

    //
    // If the Caller didn't pass us anything, then we create our own
    // structure. Lets NULL it, and then allocate it later
    //
    //

    if ( !lppvData )
    {
        lppvData = &lpVoidData;
        *lppvData = NULL;
    }

    if  (   dwFlags & FLAGS_ERROR_UI_FLAGS_GENERATE_DATA
       && !(dwFlags & FLAGS_ERROR_UI_SERIALIZE_DIALOGS))
    {
        *lppvData = NULL;
    }

    //
    // Determine what Function to handle this based on what error where given
    //

    BOOL fRet;

    switch ( dwError )
    {
        case ERROR_INTERNET_NEED_UI:
            fRet = HttpFiltOnBlockingOps
                (lpRequest, hRequest, hWnd);
            error = fRet? ERROR_SUCCESS : GetLastError();
            break;

        case ERROR_INTERNET_INCORRECT_PASSWORD:
            error = wErrorUIInvalidPassword(hWnd,
                                    hMappedRequestHandle,
                                    dwError,
                                    dwFlags,
                                    lppvData);

            break;

        case ERROR_HTTP_COOKIE_NEEDS_CONFIRMATION:
            // If we are in silent mode, we will have to
            // decline the cookie without throwing up a
            // dialog
            if((dwFlags & FLAGS_ERROR_UI_FLAGS_NO_UI))
            {
                error = ERROR_HTTP_COOKIE_DECLINED;
            }
            else
            {
                COOKIE_DLG_INFO info;

                memset(&info, 0, sizeof(info));
                info.dwOperation = COOKIE_OP_SET;
                info.pic = (INTERNET_COOKIE*)(*lppvData);

                if(info.pic->dwFlags & INTERNET_COOKIE_IS_SESSION)
                {
                    info.dwOperation |= COOKIE_OP_SESSION;
                }

                error = ConfirmCookie(hWnd,
                                      lpRequest,
                                      &info);

            }
            break;

        case ERROR_HTTP_COOKIE_NEEDS_CONFIRMATION_EX:
            // If we are in silent mode, we will have to
            // decline the cookie without throwing up a
            // dialog
            if((dwFlags & FLAGS_ERROR_UI_FLAGS_NO_UI))
            {
                error = ERROR_HTTP_COOKIE_DECLINED;
            }
            else
            {
                error = ConfirmCookie(hWnd,
                                      lpRequest,
                                      (COOKIE_DLG_INFO *)(*lppvData));
            }
            break;

        case ERROR_INTERNET_FORTEZZA_LOGIN_NEEDED:
            //
            // Call the function which gets the cert context from the
            // Fortezza CSP.

            error = FortezzaLogOn(hWnd);
            break;

        case ERROR_INTERNET_SEC_CERT_REVOKED:
            {
                static WCHAR szMsgBoxText[128]  = L"\0";
                static WCHAR szCaption[64]      = L"\0";
                if (!szCaption[0])
                {
                    LoadStringWrapW(GlobalDllHandle, IDS_CERT_REVOKED, szMsgBoxText, sizeof(szMsgBoxText));
                    LoadStringWrapW(GlobalDllHandle, IDS_SECURITY_CAPTION, szCaption, sizeof(szCaption));
                }
                MessageBoxWrapW(hWnd, szMsgBoxText, szCaption, MB_OK | MB_ICONWARNING);
                error = ERROR_CANCELLED;
            }
            break;

        case ERROR_INTERNET_HTTP_TO_HTTPS_ON_REDIR:
        case ERROR_INTERNET_HTTPS_TO_HTTP_ON_REDIR:

            //
            // Read the registry, and check to make sure
            //  the user hasn't overriden this.
            //

            GlobalDataReadWarningUIFlags();

            if ( ! GlobalWarnOnZoneCrossing )
                break;


            //
            // fall through to launch dlg code.
            //

            goto l_launchdlg;

        case ERROR_HTTP_REDIRECT_NEEDS_CONFIRMATION:
            //
            // Read the registry, and check to make sure
            //  the user hasn't overriden this.
            //

            GlobalDataReadWarningUIFlags();

            if ( ! GlobalWarnOnPostRedirect )
                break;


            //
            // fall through to launch dlg code.
            //

            goto l_launchdlg;

        case ERROR_INTERNET_POST_IS_NON_SECURE:
        case ERROR_INTERNET_CHG_POST_IS_NON_SECURE:

            //
            // Read the registry, and check to make sure
            //  the user hasn't overriden this.
            //

            GlobalDataReadWarningUIFlags();

            if ( ! GlobalWarnOnPost )
                break;

            //
            // If we're not warning always, ie only warning
            //  if the user actually changed some fields, then
            //  bail out, and don't warn.
            //

            if ( ! GlobalWarnAlways &&
                   dwError == ERROR_INTERNET_POST_IS_NON_SECURE )
                break;

            //
            // fall through to launch dlg code.
            //

            goto l_launchdlg;

        case ERROR_INTERNET_SEC_CERT_DATE_INVALID:
        case ERROR_INTERNET_SEC_CERT_CN_INVALID:
        case ERROR_INTERNET_MIXED_SECURITY:
        case ERROR_INTERNET_INVALID_CA:
        case ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED:
        case ERROR_INTERNET_BAD_AUTO_PROXY_SCRIPT:
        case ERROR_INTERNET_UNABLE_TO_DOWNLOAD_SCRIPT:
        case ERROR_INTERNET_HTTPS_HTTP_SUBMIT_REDIR:
        case ERROR_INTERNET_INSERT_CDROM:
        case ERROR_INTERNET_SEC_CERT_ERRORS:
        case ERROR_INTERNET_SEC_CERT_REV_FAILED:

l_launchdlg:
            // if silent flag is set, we can just pass
            // ERROR_CANCELLED back without throwing up
            // a dialog
            if ((dwFlags & FLAGS_ERROR_UI_FLAGS_NO_UI))
            {
                error = ERROR_CANCELLED;
            }
            else
            {
                ERRORINFODLGTYPE ErrorInfoDlgInfo;
                DLGPROC          pDlgProc;


                MapWininetErrorToDlgId(
                                       dwError,
                                       &ErrorInfoDlgInfo.dwDlgId,
                                       &ErrorInfoDlgInfo.dwDlgFlags,
                                       &pDlgProc
                                       );


                INET_ASSERT(pDlgProc);

                ErrorInfoDlgInfo.hInternetMapped =
                    hMappedRequestHandle;
                if (ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED == dwError)
                {
                    CERT_CONTEXT_ARRAY* pCertContextArray = 
                        ((HTTP_REQUEST_HANDLE_OBJECT *)hMappedRequestHandle)->GetCertContextArray();

                    if (pCertContextArray)
                    {
                        const DWORD c_dwArraySize = pCertContextArray->GetArraySize();

                        if (1 == c_dwArraySize || 0 == c_dwArraySize)
                        {
                            const BOOL fRestricted =
                                lpRequest->GetOpenFlags() & INTERNET_FLAG_RESTRICTED_ZONE;
                            const DWORD dwClientCertPromptPolicy =
                                ::GetClientCertPromptPolicy(lpRequest->GetURL(), fRestricted);
                            if (dwClientCertPromptPolicy == URLPOLICY_ALLOW)
                            {
                                // If 1, select index 0, otherwise -1 if none
                                pCertContextArray->SelectCertContext(c_dwArraySize ? 0 : -1);
                                error = ERROR_SUCCESS;
                                break;
                            }
                        }
                    }
                }
                error = LaunchDlg(
                          hWnd,
                          (LPVOID) &ErrorInfoDlgInfo,
                          ErrorInfoDlgInfo.dwDlgId,
                          pDlgProc
                          );


            }

            break;
        default:
            //
            // if we're filtering for errors, then its not an error
            // since we're intented to process all errors
            //

            if ( ! (dwFlags & FLAGS_ERROR_UI_FILTER_FOR_ERRORS) )
                error = ERROR_NOT_SUPPORTED;
            break;
    }

quit:

    if ( hMappedRequestHandle != NULL )
        DereferenceObject((LPVOID)hMappedRequestHandle);

    DEBUG_LEAVE_API(error);

    return error;
}


INTERNETAPI_(DWORD) InternetConfirmZoneCrossingA(
    IN HWND hWnd,
    IN LPSTR szUrlPrev,
    IN LPSTR szUrlNew,
    BOOL bPost
    )
/*++

Routine Description:

    Creates an Error Dialog informing the User of a zone crossing ( going
    between HTTPS to HTTP or HTTPS to HTTP ) when one is detected.

Arguments:

    hWnd -        Window handle to be used as the parent window of a Error Dialog.

    szUrlPrev -   Previous URL string.

    szUrlNew  -   New URL string that the User is about to go to.

    bPost     -   TRUE if a POST is being done, FALSE otherwise.

Return Value:

    DWORD
    Success - ERROR_SUCCESS
               ( user either confirmed OK to continue, or there was no
                 UI needed )

    Failure - ERROR_CANCELLED ( user canceled, we want to stop )
              ERROR_NOT_ENOUGH_MEMORY

Comments:

    none.

--*/

{
    DEBUG_ENTER_API((DBG_API,
                     Dword,
                     "InternetConfirmZoneCrossingA",
                     "%#x, %q, %q, %d",
                     hWnd,
                     szUrlPrev,
                     szUrlNew,
                     bPost));

    DWORD error = ERROR_SUCCESS;
    INTERNET_SCHEME ustPrevScheme;
    INTERNET_SCHEME ustNewScheme;

    INET_ASSERT(szUrlNew);


    //
    // If the Previous one is NULL, then we could be starting out
    //  for the first time
    //

    if ( szUrlPrev == NULL )
        goto quit;


    error = CrackUrl(szUrlPrev,
             lstrlen(szUrlPrev),
             FALSE,
             &ustPrevScheme,
             NULL,          //  Scheme Name
             NULL,          //  Scheme Length
             NULL,          //  Host Name
             NULL,          //  Host Length
             NULL,          //  Internet Port
             NULL,          //  UserName
             NULL,          //  UserName Length
             NULL,          //  Password
             NULL,          //  Password Length
             NULL,          //  Path
             NULL,          //  Path Length
             NULL,          //  Extra
             NULL,          //  Extra Length
             NULL
             );

    if ( error != ERROR_SUCCESS )
    {
        error = ERROR_SUCCESS;
        ustPrevScheme = INTERNET_SCHEME_UNKNOWN;
    }


    error = CrackUrl(szUrlNew,
             lstrlen(szUrlNew),
             FALSE,
             &ustNewScheme,
             NULL,          //  Scheme Name
             NULL,          //  Scheme Length
             NULL,          //  Host Name
             NULL,          //  Host Length
             NULL,          //  Internet Port
             NULL,          //  UserName
             NULL,          //  UserName Length
             NULL,          //  Password
             NULL,          //  Password Length
             NULL,          //  Path
             NULL,          //  Path Length
             NULL,          //  Extra
             NULL,          //  Extra Length
             NULL
             );

    if ( error != ERROR_SUCCESS )
    {
        error = ERROR_SUCCESS;
        ustNewScheme = INTERNET_SCHEME_UNKNOWN;
    }

    //
    // First Eliminate the obvious.
    //

    if ( ustPrevScheme == ustNewScheme )
        goto quit;


    //
    // Next, if it wasn't HTTPS, and it is now
    //  we've caught one zone cross.
    //

    if ( ustPrevScheme != INTERNET_SCHEME_HTTPS &&
         ustNewScheme  == INTERNET_SCHEME_HTTPS   )
    {
        error = ERROR_INTERNET_HTTP_TO_HTTPS_ON_REDIR;
    }


    //
    // Otherwise, if it was HTTPS, and it is now
    //  no longer HTTPS, we also flag it.
    //

    else if ((ustPrevScheme == INTERNET_SCHEME_HTTPS)
             && ((ustNewScheme != INTERNET_SCHEME_HTTPS)
                 && (ustNewScheme != INTERNET_SCHEME_JAVASCRIPT)
                 && (ustNewScheme != INTERNET_SCHEME_VBSCRIPT))) {
        error = ERROR_INTERNET_HTTPS_TO_HTTP_ON_REDIR;
    }


    if ( error != ERROR_SUCCESS &&
         hWnd )
    {
        error = InternetErrorDlg(
                 hWnd,
                 NULL,  // hRequest
                 error,
                 0,
                 NULL   // non Data structure to pass.
                 );
    }

quit:
    DEBUG_LEAVE_API(error);
    return error;
}


//
// private functions
//


PRIVATE
DWORD
wErrorUIInvalidPassword(IN HWND hWnd,
                        IN HINTERNET hRequest,
                        IN DWORD dwError,
                        IN DWORD dwFlags,
                        IN OUT LPVOID *lppvData
                        )
/*++

Routine Description:

    Creates an Error Dialog asking the User for his Username and Password.

Arguments:

    hWnd -        Window handle to be used as the parent window of a Error Dialog.

    hRequest -    An open HTTP request handle, that is MAPPED,
                  where headers will be added if needed.

    dwError -     The Error code to which the appropriate UI will be shown for.

    dwFlags -     Can be any of all of the following Flags:

                    FLAGS_ERROR_UI_FLAGS_GENERATE_DATA - generates lppvData, and queries
                    internet handle for information.

                    FLAGS_ERROR_UI_FILTER_FOR_ERRORS - scans the returned headers,
                    and determines if there is a "hidden" error, such as an authentication
                    failure.

                    FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS - On successful return of the dialog,
                    this flag will causes the results to be stored in the handle.

                    FLAGS_ERROR_UI_FLAGS_NO_UI - Don't show any User interface. Silently,
                    accepts the Username, and Password that is passed in.

    lppvData -    Contains a Pointer to a Pointer where a stucture is stored containing
                  error specific data, and Dialog results.


Return Value:

    DWORD
    Success - ERROR_SUCCESS

    Failure - One of Serveral Error codes defined in winerror.h or wininet.w

Comments:

    BUGBUG - need to look into multiple authentication scheme handling, and
    how it relates to the UI
    BUGBUG - need to handle case where one thread calls into this function,
    and a second threads also calls in to put up UI on the same User-Pass Info
    as the first.

--*/

{
    DEBUG_ENTER((DBG_INET,
                Dword,
                "wErrorUIInvalidPassword",
                "%#x, %#x, %d (%s), %#x, %#x",
                hWnd,
                hRequest,
                dwError,
                InternetMapError(dwError),
                dwFlags,
                lppvData
                ));

    DWORD error = ERROR_SUCCESS;
    BOOL fMustLock = FALSE;
    InvalidPassType ipt;
    ipt.lpszPassword = NULL;
    
    // Get the request handle and connect handle.
    HTTP_REQUEST_HANDLE_OBJECT *pRequest =
        (HTTP_REQUEST_HANDLE_OBJECT *) hRequest;
    INTERNET_CONNECT_HANDLE_OBJECT *pConnect =
        (INTERNET_CONNECT_HANDLE_OBJECT *) pRequest->GetParent();

    // Validate parameters.
    if (!pConnect || (!(dwFlags & FLAGS_ERROR_UI_FLAGS_NO_UI) && !IsWindow(hWnd)))
    {
        error = ERROR_INVALID_PARAMETER;
        goto quit;
    }

    // Get the authentication context.
    AUTHCTX *pAuthCtx;
    pAuthCtx = pRequest->GetAuthCtx();
    if (!pAuthCtx)
    {
        pAuthCtx = pRequest->GetTunnelAuthCtx();
        if (!pAuthCtx)
        {
            error = ERROR_SUCCESS;
            goto quit;
        }
    }

    PWC *pwc;
    pwc = pAuthCtx->_pPWC;
    // INET_ASSERT (pwc && pwc->nLockCount); w/ Passport, this is no longer true

    //
    //  Initialize InvalidPassType struct
    //

    if (pAuthCtx->GetSchemeType() != AUTHCTX::SCHEME_PASSPORT)
    {
        char szUserBuf[MAX_FIELD_LENGTH], szPassBuf[MAX_FIELD_LENGTH];
        ipt.ulMaxField = MAX_FIELD_LENGTH - 1;
        ipt.lpszPassword = szUserBuf;
        ipt.lpszUsername = szPassBuf;
        
        if (pAuthCtx->_pszFQDN)
        {
            ipt.lpszHost = (LPSTR)pAuthCtx->_pszFQDN;
        }
        else
        {
            ipt.lpszHost = pAuthCtx->_pPWC->lpszHost;
        }
        
        ipt.fIsProxy = pAuthCtx->_fIsProxy;
    
    
        //
        // Transfer password cache entry fields to UI structure.
        //
        AuthLock();
        LPSTR lpszPass = pwc->GetPass();

        if (pwc->lpszUser)
            lstrcpyn (ipt.lpszUsername, pwc->lpszUser, MAX_FIELD_LENGTH);
        else
            ipt.lpszUsername[0] = 0;
        if (lpszPass)
            lstrcpyn (ipt.lpszPassword, lpszPass, MAX_FIELD_LENGTH);
        else
            ipt.lpszPassword[0] = 0;
        ipt.lpszRealm = pwc->lpszRealm;

        if (lpszPass)
        {
            SecureZeroMemory(lpszPass, strlen(lpszPass));
            FREE_MEMORY(lpszPass);
        }
        
        AuthUnlock();
    }

    if (dwFlags & FLAGS_ERROR_UI_SERIALIZE_DIALOGS)
    {
        // Queue this thread if we're already in a dialog.
        INET_ASSERT (lppvData);
        INTERNET_AUTH_NOTIFY_DATA *pNotify =
            (INTERNET_AUTH_NOTIFY_DATA *) *lppvData;
        if (IsBadReadPtr (pNotify, sizeof(*pNotify)))
        {
            error = ERROR_INVALID_PARAMETER;
            goto quit;
        }
        if (AuthInDialog (pAuthCtx, pNotify, &fMustLock))
        {
            // The auth context maintains a context handle
            // to correctly process the 'stale' subheader.
            // Setting _nRetries to 0 will cause no context handle to
            // be passed into the package and restart auth for this context
            // from scratch. Therefore, no attempt will be made to parse the
            // stale header which is the correct behavior.
            if (pAuthCtx->GetSchemeType() == AUTHCTX::SCHEME_DIGEST)
            {
                ((DIGEST_CTX*)pAuthCtx)->_nRetries = 0;
            }
            error = ERROR_INTERNET_DIALOG_PENDING;
            goto quit;
        }
    }

    if ((dwFlags & FLAGS_ERROR_UI_FLAGS_NO_UI))
    {
        // No UI - retrieve any persisted credentials.
        error = InetGetCachedCredentials(pwc->lpszHost, pwc->lpszRealm,
            ipt.lpszUsername, ipt.lpszPassword);
    }
    else // Launch the appropriate dialog.
    {
        if ((pAuthCtx->GetFlags() & PLUGIN_AUTH_FLAGS_CAN_HANDLE_UI))
        {
            // If auth package handles its own UI, let it.
            error = LaunchAuthPlugInDlg
                (pRequest, pAuthCtx, hWnd, dwError, dwFlags, &ipt);
        }
        else
        {
            if (pAuthCtx->GetSchemeType() == AUTHCTX::SCHEME_BASIC
                || pAuthCtx->GetSchemeType() == AUTHCTX::SCHEME_DIGEST)
            {
                ipt.eAuthType = REALM_AUTH;
            }
            else if (pAuthCtx->GetSchemeType() == AUTHCTX::SCHEME_PASSPORT)
            {
                ipt.eAuthType = PASSPORT_AUTH;
            }
            else
            {
                INET_ASSERT(pAuthCtx->GetSchemeType() == AUTHCTX::SCHEME_NTLM 
                    || pAuthCtx->GetSchemeType() == AUTHCTX::SCHEME_KERBEROS
                    || pAuthCtx->GetSchemeType() == AUTHCTX::SCHEME_NEGOTIATE);
                ipt.eAuthType = NTLM_AUTH;
            }

            CREDINFODLGTYPE CredInfoDlgInfo;
            CredInfoDlgInfo.pipt = &ipt;
            CredInfoDlgInfo.pRequest = pRequest;
            CredInfoDlgInfo.pAuthCtx = pAuthCtx;

            if (ipt.eAuthType == REALM_AUTH)
                error = LaunchDlg (hWnd,(LPVOID) &CredInfoDlgInfo, IDD_REALM_AUTH, NULL);
            else if (ipt.eAuthType == PASSPORT_AUTH)
                error = LaunchDlg (hWnd,(LPVOID) &CredInfoDlgInfo, 0,              NULL);
            else
                error = LaunchDlg (hWnd,(LPVOID) &CredInfoDlgInfo, IDD_NTLM_AUTH, NULL);
        }
    }
        
    // If dialog was OK, return as follows.
    if (error == ERROR_SUCCESS)
    {
        AuthLock();

        if (ipt.eAuthType == NTLM_AUTH)
        {
            // Update user/pass which would overwrite PWC.
            pRequest->SetUserOrPass (ipt.lpszUsername, IS_USER, pAuthCtx->_fIsProxy);
            pRequest->SetUserOrPass (ipt.lpszPassword, IS_PASS, pAuthCtx->_fIsProxy);

            // Update PWC so related requests will be retried.
            pwc->SetUser (ipt.lpszUsername);
            pwc->SetPass (ipt.lpszPassword);
        }
        else if (pAuthCtx->GetSchemeType() != AUTHCTX::SCHEME_PASSPORT)
        {
            // Update user/pass which would overwrite PWC.
            // Update PWC so related requests will be retried.
            
            //if (ipt.lpszUsername[0])
            {
                pRequest->SetUserOrPass (ipt.lpszUsername, IS_USER, pAuthCtx->_fIsProxy);
                pwc->SetUser (ipt.lpszUsername);
            }
            
            //if (ipt.lpszPassword[0])
            {
                pRequest->SetUserOrPass (ipt.lpszPassword, IS_PASS, pAuthCtx->_fIsProxy);
                pwc->SetPass (ipt.lpszPassword);
            }
    
        }
        AuthUnlock();

        // Retry this request.
        error = ERROR_INTERNET_FORCE_RETRY;
    }

    // Notify any waiting threads.

    if (dwFlags & FLAGS_ERROR_UI_SERIALIZE_DIALOGS)
    {
        if (fMustLock)
        {
            // fMustLock will have been set by AuthInDialog if this is
            // a reentrant call to InternetErrorDlg by AuthNotify. If this
            // is the case, acquire the lock and do not call AuthNotify.
            // so that when control is returned to AuthNotify the lock will
            // already be correctly acquired.
            AuthLock();
        }
        else
        {
            AuthNotify (pwc, error);
        }
    }

quit:

    if (ipt.lpszPassword)
    {
        SecureZeroMemory(ipt.lpszPassword, strlen(ipt.lpszPassword));
    }

    //
    // IE30 compat: must return ERROR_SUCCESS to avoid bogus dialog.
    //
    if ( error == ERROR_CANCELLED )
        error = ERROR_SUCCESS;

    DEBUG_LEAVE(error);
    return error;
}

#define ARRAYSIZE(a) (sizeof(a)/sizeof(a[0]))

DWORD
ConfirmCookie(
            HWND hwnd,
            HTTP_REQUEST_HANDLE_OBJECT *lpRequest,
            COOKIE_DLG_INFO *pcdi
            )
{
    DWORD dw;
    BYTE *buf = NULL;

    //
    //  Get the server name
    //
    WCHAR wszServer[INTERNET_MAX_HOST_NAME_LENGTH + 1];
    if (lpRequest)
    {
        DEBUG_ONLY(lpRequest->GetHostName(&dw));
        INET_ASSERT(dw <= ARRAYSIZE(wszServer));
        CHAR szServerTmp[INTERNET_MAX_HOST_NAME_LENGTH + 1];
        lpRequest->CopyHostName(szServerTmp);
        if(SHAnsiToUnicode(szServerTmp, wszServer, ARRAYSIZE(wszServer))) 
            pcdi->pszServer = wszServer;
    }
    else if(pcdi->pic)
    {
        if(SHAnsiToUnicode(pcdi->pic->pszDomain, wszServer, ARRAYSIZE(wszServer))) 
            pcdi->pszServer = wszServer;
    }

    /* Consult per-site decisions one more time.
       By the time the prompt is being displayed, another instance
       of the cookie-prompt MAY have already written a decision. */ 
    unsigned long dwPerSiteDecision = COOKIE_STATE_UNKNOWN;

    if (InternetGetPerSiteCookieDecisionW(pcdi->pszServer, &dwPerSiteDecision) &&
        dwPerSiteDecision!=COOKIE_STATE_UNKNOWN)
    {
        if (dwPerSiteDecision==COOKIE_STATE_ACCEPT) 
            return ERROR_SUCCESS;
        else
            return ERROR_HTTP_COOKIE_DECLINED;
    }

    ULONG_PTR uCookie = 0;
    SHActivateContext(&uCookie);

    // Can typecast as long as "CookieDialogProc" only returns true or false
    dw = (BOOL ) DialogBoxParamWrapW(GetModuleHandle("WININET.DLL"),
                                    MAKEINTRESOURCEW(IDD_CONFIRM_COOKIE),
                                    hwnd,
                                    CookieDialogProc,
                                    (LPARAM) pcdi);

    if (uCookie)
    {
        SHDeactivateContext(uCookie);
    }

    return dw;
}


INTERNETAPI_(DWORD) InternetConfirmZoneCrossingW(
    IN HWND hWnd,
    IN LPWSTR szUrlPrev,
    IN LPWSTR szUrlNew,
    BOOL bPost
    )
/*++

Routine Description:

    Creates an Error Dialog informing the User of a zone crossing ( going
    between HTTPS to HTTP or HTTPS to HTTP ) when one is detected.

Arguments:

    hWnd -        Window handle to be used as the parent window of a Error Dialog.

    szUrlPrev -   Previous URL string.

    szUrlNew  -   New URL string that the User is about to go to.

    bPost     -   TRUE if a POST is being done, FALSE otherwise.

Return Value:

    DWORD
    Success - ERROR_SUCCESS
               ( user either confirmed OK to continue, or there was no
                 UI needed )

    Failure - ERROR_CANCELLED ( user canceled, we want to stop )
              ERROR_NOT_ENOUGH_MEMORY

Comments:

    none.

--*/

{
    DEBUG_ENTER_API((DBG_API,
                     Dword,
                     "InternetConfirmZoneCrossingW",
                     "%wq, %wq, %d",
                     szUrlPrev,
                     szUrlNew,
                     bPost));

    DWORD dwErr = ERROR_SUCCESS;
    MEMORYPACKET mpNew, mpPrev;

    if (!(szUrlPrev && szUrlNew))
    {
        dwErr = ERROR_INVALID_PARAMETER;
        goto cleanup;
    }
    ALLOC_MB(szUrlPrev,0,mpPrev);
    ALLOC_MB(szUrlNew,0,mpNew);
    if (!(mpPrev.psStr && mpNew.psStr))
    {
        dwErr = ERROR_NOT_ENOUGH_MEMORY;
        goto cleanup;
    }
    UNICODE_TO_ANSI(szUrlPrev,mpPrev);
    UNICODE_TO_ANSI(szUrlNew,mpNew);
    dwErr = InternetConfirmZoneCrossingA(hWnd, mpPrev.psStr, mpNew.psStr, bPost);

cleanup:
    if (dwErr!=ERROR_SUCCESS) 
    { 
        SetLastError(dwErr); 
        DEBUG_ERROR(INET, dwErr);
    }
    DEBUG_LEAVE_API(dwErr);
    return dwErr;
}