diff -r 000000000000 -r dd21522fd290 webengine/osswebengine/WebCore/platform/network/symbian/HttpUiCallbacks.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/webengine/osswebengine/WebCore/platform/network/symbian/HttpUiCallbacks.cpp Mon Mar 30 12:54:55 2009 +0300 @@ -0,0 +1,495 @@ +/* +* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#include "HttpUiCallbacks.h" +#include "Page.h" +#include <../bidi.h> +#include +#include +#include +#include +#include "WebFrame.h" +#include "WebFrameView.h" +#include "WebView.h" +#include "BrCtl.h" +#include "SettingsContainer.h" +#include "BrCtlSpecialLoadObserver.h" +#include "StaticObjectsContainer.h" +#include "ResourceLoaderDelegate.h" +#include "HttpDefs.h" +#include "HttpConnection.h" +#include "CDBCols.h" + +using namespace WebCore; + +// CONSTANTS +_LIT (KEmptyTitle, ""); + +static CBrCtl* brctl() +{ + return StaticObjectsContainer::instance()->brctl(); +} + +HttpUiCallbacks::HttpUiCallbacks() +{ + m_error = KErrNone; + m_scheduler = NULL; +} + +HttpUiCallbacks::~HttpUiCallbacks() +{ + if (m_scheduler) { + m_scheduler->Cancel(); + delete m_scheduler; + } +} + +TInt HttpUiCallbacks::handleErrorCb(TAny* aPtr) +{ + HttpUiCallbacks* self = static_cast(aPtr); + self->handleError(); + return KErrNone; +} + +void HttpUiCallbacks::handleError() +{ + m_scheduler->Cancel(); + delete m_scheduler; + m_scheduler = NULL; + StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager()->handleError(m_error); +} + + +TInt HttpUiCallbacks::CreateConnection(TInt* aConnectionPtr, TInt* aSockSvrHandle, + TBool* aNewConn, TApBearerType* aBearerType) +{ + TInt error = KErrNone; + if( aConnectionPtr && aSockSvrHandle && aNewConn ){ + TRAP(error, brctl()->brCtlSpecialLoadObserver()->NetworkConnectionNeededL(aConnectionPtr, aSockSvrHandle, aNewConn, aBearerType)); + if( error == KErrNone && *aConnectionPtr ) { + RConnection* connPtr = REINTERPRET_CAST( RConnection*, *aConnectionPtr ); + TConnectionInfoBuf connInfoBuf; + TUint conns( 0 ); + connPtr->EnumerateConnections( conns ); + if (conns > 0 && connPtr->GetConnectionInfo(1, connInfoBuf) == KErrNone ) + { + TUint32 iapId; + TBuf<20> query; + + //Get the IAP id used by browser from the RConnection object. + query.Format( _L("%s\\%s"), IAP, COMMDB_ID ); + if( connPtr->GetIntSetting( query, iapId ) == KErrNone) + { + // Set the access point Id to BrCrl + brctl()->webView()->setAccessPointId( iapId ); + + } + //If IAP is not avilable from connection Object then use the first connection. + else + { + brctl()->webView()->setAccessPointId( connInfoBuf().iIapId ); + } + } + //pass the connection to download manager + // let the dm know about the connection + HttpDownload* httpDownload = StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager()->httpDownload(); + if(httpDownload) + { + TName name; + connPtr->Name( name ); + httpDownload->connect( name ); + } + } + } + // no connection, cancel transactions asynchronously + if( error != KErrNone ) { + m_error = error; + if (m_scheduler == NULL) { + m_scheduler = CPeriodic::NewL( CActive::EPriorityStandard ); + m_scheduler->Start( 0, 0, TCallBack( &handleErrorCb, this ) ); + } + } + return error; +} + +void HttpUiCallbacks::CoverageEvent( TInt aError ) +{ + TInt error = (aError == EErrNetUnreach) ? KErrNetUnreach : + ((aError == EErrWaitTimeout ) ? KBrowserWaitTimeout : KErrNone); + TRAP_IGNORE(brctl()->brCtlDialogsProvider()->DialogNotifyErrorL(error)); + StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager()->handleError(error); + // the download manager handles coverage event in the Dl Mgr Server (KShutDownTimer = 30 sec). +} + +int HttpUiCallbacks::aboutToLoadPage(CBrCtl* brctl, int stateType) +{ + int ret = KErrNone; + TRAPD(err, ret = aboutToLoadPageL(brctl, stateType)); + return (err == KErrNone) ? ret : err; +} + +int HttpUiCallbacks::aboutToLoadPageL(CBrCtl* brctl, int stateType) +{ + TBool result ( ETrue ); + TEnterStatus enterStatus ( (TEnterStatus)stateType ); + TInt resId ( 0 ); // don't display a dialog, + // event = 0 means, don't send an event. NOTE: TBrCtlDefs::EEventNone = 0 + TBrCtlDefs::TBrCtlLoadEvent event ( TBrCtlDefs::EEventNone ) ; + // Map TEnterStatus to a corresponding dialog string + // resource IDs and browser load event + switch (enterStatus) + { + case EExitingSecurePage: + { + resId = R_HTTPSEC_LEAVE_SECURE_SITE; + event = TBrCtlDefs::EEventExitingSecurePage; + break; + } + case EEnteringSecurePage: + { + resId = R_HTTPSEC_ENTER_SECURE_SITE; + event = TBrCtlDefs::EEventEnteringSecurePage; + break; + } + case ESomeItemsNotSecure: + { + resId = R_HTTPSEC_SOME_ITEMS_NOT_SECURE; + event = TBrCtlDefs::EEventSomeItemsNotSecure; + break; + } + case ESubmittingToNonSecurePage: + { + resId = R_HTTPSEC_SUBMITTING_TO_NON_SECURE_PAGE; + event = TBrCtlDefs::EEventExitingSecurePage; + break; + } + case ERedirectConfirmation: + { + resId = R_HTTP_REDIRECT_POST_CONFIRMATION; + event = TBrCtlDefs::EEventRedirectConfirmation; + break; + } + case ERepostConfirmation: + { + resId = R_HTTP_REPOST_CONFIRMATION; + event = TBrCtlDefs::EEventRepostConfirmation; + break; + } + case ESecureItemInNonSecurePage: + { + resId = 0; + event = TBrCtlDefs::EEventSecureItemInNonSecurePage; + break; + } + + default: + { + resId = 0; + event = TBrCtlDefs::EEventNone; + break; + } + } // end of switch + TUint retVal = brctl->settings()->brctlSetting(TBrCtlDefs::ESettingsSecurityWarnings); + // Show dialogs only if warning dialogs are enabled in the preferences, and + if (retVal && resId) + { + HBufC* message = StringLoader::LoadLC(resId); + HBufC* leftMessage = NULL; + HBufC* rightMessage = NULL; + leftMessage = StringLoader::LoadLC(R_TEXT_SOFTKEY_YES); + rightMessage = StringLoader::LoadLC(R_TEXT_SOFTKEY_NO); + MBrCtlDialogsProvider* dialogsProvider = brctl->brCtlDialogsProvider(); + TRAPD(err, result = dialogsProvider->DialogConfirmL(KEmptyTitle, + *message, + *leftMessage, + *rightMessage)); + // Clean up the memory we allocated, before returning + CleanupStack::PopAndDestroy(3); // message, leftMessage, rightMessage + // Check to see if DialogConfirmL leaves + if (err != KErrNone) + { + return KErrNoMemory; + } + // If the user selected "No" or "Cancel", we are cancelling the load + if ( !result ) + { + return KErrCancel; + } + } // end of if + if(result && event != TBrCtlDefs::EEventNone) + // Send the BrowserLoadEvent to the registered listeners + { + brctl->HandleBrowserLoadEventL(event, 0, 0); + } + + // The user selected "Yes" or "Continue" or we aren't displaying a dialog + return KErrNone; +} + +// ----------------------------------------------------------------------------- +// HttpUiCallbacks::AuthenticationNeeded +// Public Class Method +// UI Call back to inform authentication is required +// ----------------------------------------------------------------------------- +// +void HttpUiCallbacks::AuthenticationRequest( + HttpConnection* aHttpConn, + TPtr& aUri, + TPtr& aUsername, + TPtr& aRealm, + bool aProxy, + bool aDataExists, + TPtr& aPassword, + bool aBasicAuthentication ) + { + TPtr usernamePtr(NULL, 0); + TPtr passwordPtr(NULL, 0); + TUint16* retUsername = NULL; + TUint16* retPassword = NULL; + int status( KErrNone ); + int error( KErrNone ); + // Check if authentication data exists + // If Yes: + if( !aDataExists ) + { + //Get user authentication data + TRAP(status, GetUserAuthenticationDataL(aHttpConn, aUri.Ptr(), + aUsername.Ptr(), aRealm.Ptr(), &retUsername, + &retPassword, aBasicAuthentication)); + switch (status) + { + case KErrNone: + { + if (retUsername ) + { + usernamePtr.Set(retUsername, User::StringLength(retUsername), + User::StringLength(retUsername)); + } + if (retPassword != NULL) + { + passwordPtr.Set(retPassword, User::StringLength(retPassword), + User::StringLength(retPassword)); + } + break; + } + case KErrCancel: + { + error = KErrCancel; + break; + } + case KErrNoMemory: + { + error = KErrNoMemory; + break; + } + default: + { + error = KErrGeneral; + break; + } + } + } + else + // if aDataExists take the existing uname/pwd again, because + // they were ok, but nonce was expired. + // Make a copy of the original uname/pwd. + { + retPassword = new TUint16 [aPassword.Length() + 1]; + if ( retPassword ) + { + passwordPtr.Set(retPassword, aPassword.Length() + 1, aPassword.Length() + 1); + passwordPtr.Copy(aPassword); + passwordPtr.ZeroTerminate(); + retUsername = new TUint16 [aUsername.Length() + 1]; + if ( retUsername ) + { + usernamePtr.Set(retUsername, aUsername.Length() + 1, aUsername.Length() + 1); + usernamePtr.Copy(aUsername); + usernamePtr.ZeroTerminate(); + } + else + { + passwordPtr.Set( NULL, 0, 0 ); + delete [] retPassword; + retPassword = NULL; + error = KErrNoMemory; + } + } + else + { + error = KErrNoMemory; + } + } + // send the credentials + aHttpConn->AuthenticationResponse( usernamePtr, passwordPtr, aProxy, error); + } + +// ----------------------------------------------------------------------------- +// HttpUiCallbacks::NextUriL +// Private Class Method +// ----------------------------------------------------------------------------- +void HttpUiCallbacks::NextUriL(const TDesC8& aUri, CBrCtl* brCtl) +{ + HBufC16* urlDes = HBufC16::NewLC(aUri.Length()); + urlDes->Des().Copy(aUri); + if (brCtl) + brCtl->LoadUrlL (*urlDes, -1, TBrCtlDefs::ECacheModeNormal); + CleanupStack::Pop(urlDes); +} + +// ----------------------------------------------------------------------------- +// HttpUiCallbacks::GetUserAuthenticationDataL +// Private Class Method +// ----------------------------------------------------------------------------- +void HttpUiCallbacks::GetUserAuthenticationDataL( + HttpConnection* aHttpConn, + const TUint16* aUri, + const TUint16* aUsername, + const TUint16* aRealm, + TUint16** aRetUsername, + TUint16** aRetPassword, + bool aBasicAuthentication) + { + TBool bRet( EFalse ); + HBufC* returnedUserName = NULL; + HBufC* returnedPasswd = NULL; + // Initialize our return values + *aRetUsername = NULL; + *aRetPassword = NULL; + TInt needPop ( 0 ); + + CBrCtl* brCtl = control(aHttpConn->frame()); + MBrCtlDialogsProvider* dialogsProvider = brCtl->brCtlDialogsProvider(); + + // Display the User Authentication Dialog + bRet = dialogsProvider->DialogUserAuthenticationLC(TPtrC(aUri), + TPtrC(aRealm), + TPtrC(aUsername), + returnedUserName, + returnedPasswd, + aBasicAuthentication); + + TUint retVal ( 0 ); + TRAP_IGNORE( retVal = brCtl->BrowserSettingL(TBrCtlDefs::ESettingsSecurityWarnings)); + + TUriParser uriParser; + TBool secureScheme(EFalse); + if(uriParser.Parse( TPtrC(aUri) ) == KErrNone) + { + if( uriParser.Extract( EUriScheme ).FindF( _L("https") ) == 0 ) + { + secureScheme = ETrue; + } + } + + // Display the Basic Authentication dialog, if needed. + if (bRet && aBasicAuthentication && retVal && !secureScheme) + { + // Our memory pointers for the basic authentication dialog + HBufC* message = NULL; + HBufC* okMsg = NULL; + HBufC* cancelMsg = NULL; + // Set up the message text + message = StringLoader::LoadLC(R_BROWSER_QUERY_BASIC_AUTHENTICATION); + // Set up the OK button text + okMsg = StringLoader::LoadLC(R_WML_OK_BUTTON); + // Set up the CANCEL button text + cancelMsg = StringLoader::LoadLC(R_WML_CANCEL_BUTTON); + // Display the basic authentication dialog + if (message && okMsg && cancelMsg) + { + bRet = dialogsProvider->DialogConfirmL(KEmptyTitle, *message, *okMsg, *cancelMsg); + } + // Clean up the basic authentication dialog memory + CleanupStack::PopAndDestroy(3); // message, okMsg, cancelMsg + } // end of if (bRet && basic authentication && display security warnings) + // The user selected "yes" or "continue", from the dialog(s). + // Return the username and password. + if (bRet) + { + // Set up the returned user name + if (!returnedUserName) + { + *aRetUsername = NULL; + } + else + { + *aRetUsername = new(ELeave) TUint16[returnedUserName->Length() + 1]; + CleanupStack::PushL(*aRetUsername); + needPop ++; + + TPtr usernamePtr(*aRetUsername, returnedUserName->Length() + 1); + usernamePtr.Copy(*returnedUserName); + usernamePtr.ZeroTerminate(); + } + + // Set up the returned password + if (!returnedPasswd) + { + *aRetPassword = NULL; + } + else + { + *aRetPassword = new(ELeave) TUint16[returnedPasswd->Length() + 1]; + TPtr passwordPtr(*aRetPassword, returnedPasswd->Length() + 1); + passwordPtr.Copy(*returnedPasswd); + passwordPtr.ZeroTerminate(); + } + } + else + { + TRAP_IGNORE(brCtl->HandleBrowserLoadEventL(TBrCtlDefs::EEventAuthenticationFailed, 0, 0)); + } + CleanupStack::Pop(needPop); // *aRetUsername + + // Clean up the memory from User Authentication dialog + if (returnedUserName) + { + CleanupStack::PopAndDestroy(); // returnedUserName + } + if (returnedPasswd) + { + CleanupStack::PopAndDestroy(); // returnedPasswd + } + if (!bRet) + { + User::Leave(KErrCancel); + } + } + +// ----------------------------------------------------------------------------- +// HttpUiCallbacks::reportError +// ----------------------------------------------------------------------------- +void HttpUiCallbacks::reportError(int error) +{ + MBrCtlDialogsProvider* dialogsProvider = brctl()->brCtlDialogsProvider(); + if ( dialogsProvider ) + { + TRAP_IGNORE(dialogsProvider->DialogNotifyErrorL(error)); + } +} + +void HttpUiCallbacks::reportHttpError(int error, const TDesC& aText ) +{ + MBrCtlDialogsProvider* dialogsProvider = brctl()->brCtlDialogsProvider(); + if ( dialogsProvider ) + { + TRAP_IGNORE(dialogsProvider->DialogNotifyHttpErrorL( error, aText ) ); + } +} + +// end of file