MCL/sf/mw/remoteconn: comparison connectivitymodules/SeCon/servers/pcconn/src/sconpcconnserver.cpp

equal deleted inserted replaced

-:dbd1c5e08735
+:453dfc402455
 /*
-* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 */
 #include <s32mem.h> // For RMemReadStream
 #include <utf.h>
+#include <Etel3rdParty.h>
+#include <f32file.h>
 #include "sconpcconnclientserver.h"
 #include "sconpcconnserver.h"
 #include "sconpcd.h"
 #include "sconcsc.h"
 #include "sconconmlhandler.h"
+#include "sconimsireader.h"
+#include "sconoviaccounthandler.h"
+#include "sconfolderlister.h"
+#include "sconbtengine.h"
 #include "debug.h"
 #ifdef DEBUG_XML
 #include <s32file.h>
 _LIT8( KTimeFormat, "%02d:%02d:%02d.%03d" );
 _LIT8( KXmlBegin, "\nXML:\n" );
 #endif
 _LIT( KSCONGetMetadataRequest, "METADATA:" );
+_LIT8( KSCONSyncRequest, "SYNC:" );
+_LIT( KSCONReadImsi, "READIMSI");
+_LIT( KSCONReadNetworkInfo, "READNETWORKINFO");
+_LIT( KSCONReadOviAccount, "READOVIACCOUNT");
+_LIT( KSCONListPath, "LISTP:");
+_LIT( KSCONReadBtInfo, "READBTINFO" );
+_LIT( KSCONSetBtPower, "SETBTPOWER:" );
+_LIT( KSCONSetBtName, "SETBTNAME:" );
+_LIT( KSCONSetBtAuthorized, "SETBTAUTHORIZED:" );
 //------------------------------------------------------------
 // Global functions
 //------------------------------------------------------------
 TSecureId clientId = client.SecureId();
 if ( clientId != KSConPCConnClientSecureId )
 {
 LOGGER_WRITE( "CSConPCConnServer::NewSessionL() : Secure ID does not match" );
+#ifndef __WINS__
+LOGGER_WRITE( "Leave KErrAccessDenied");
 User::Leave( KErrAccessDenied );
+#else
+// does not leave on WINS environment. Easier to run module tests.
+LOGGER_WRITE( "Not leaving on WINS environment" );
+#endif
 }
 TRACE_FUNC_EXIT;
 return CSConPCConnSession::NewL( *CONST_CAST( CSConPCConnServer*, this));
 }
 delete iBuffer;
 iBuffer = NULL;
 }
 iChunk.Close();
+delete iFolderLister;
+iFs.Close();
+delete iBtEngine;
 TRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CSConPCConnSession::NewL()
 {
 TRACE_FUNC_ENTRY;
 TInt ret ( KErrNone );
 iResult = KErrNone;
+User::LeaveIfError( iFs.Connect() );
 #ifdef DEBUG_XML
 // create log file
-RFs fs;
-User::LeaveIfError( fs.Connect () );
-CleanupClosePushL( fs );
 RFile file;
-TInt err = file.Create ( fs, KSConConMLDebugFile, EFileWrite );
+TInt err = file.Create ( iFs, KSConConMLDebugFile, EFileWrite );
 if( err == KErrNone )
 {
 // file created, close it
 file.Close();
 }
-CleanupStack::PopAndDestroy( &fs );
 #endif
 // initialize buffer
 iBuffer = CBufFlat::NewL ( KSConPCConnBufferMaxSize );
 {
 LOGGER_WRITE_1( "CSConPCConnSession::ConstructL() : Parser dll load failed with error code %d", ret );
 User::Leave ( ret );
 }
 }
+iFolderLister = CSconFolderLister::NewL( iFs );
 TRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CSConPCConnSession::ServiceL()
 iBuffer->Reset();
 length = buf.ReadInt32L();
-HBufC8* name = HBufC8::NewLC( length );
+HBufC8* name8 = HBufC8::NewLC( length );
-TPtr8 namePtr = name->Des();
+TPtr8 namePtr8 = name8->Des();
-buf.ReadL( namePtr, length);
+buf.ReadL( namePtr8, length);
+const TUint8* ptr8 = namePtr8.Ptr();
+const TUint16* ptr16 = reinterpret_cast<const TUint16*>( ptr8 );
+TPtrC namePtr;
+namePtr.Set( ptr16, length/2 );
 length = buf.ReadInt32L();
 HBufC8* type = HBufC8::NewLC( length );
 TPtr8 typePtr = type->Des();
 buf.ReadL( typePtr, length);
 iBuffer->Write( 0, dataPtr );
 buf.Close();
 #ifdef DEBUG_XML
-RFs fs;
-User::LeaveIfError( fs.Connect() );
-CleanupClosePushL( fs );
 RFile file;
-if ( file.Open( fs, KSConConMLDebugFile, EFileWrite ) == KErrNone )
+if ( file.Open( iFs, KSConConMLDebugFile, EFileWrite ) == KErrNone )
 {
 RFileWriteStream fws;
 TInt fileSize;
 file.Size( fileSize );
 TRAP_IGNORE( fws.CommitL() );
 fws.Close();
 CleanupStack::PopAndDestroy( &fws );
 }
 file.Close();
-CleanupStack::PopAndDestroy( &fs );
 #endif
+if ( ( ( typePtr.CompareC( KSConPCDWBXMLObjectType)== KErrNone ) ||
-if ( ( typePtr.Compare( KSConPCDWBXMLObjectType ) == KErrNone) ||
+( typePtr.CompareC( KSConPCDWBXMLObjectType2 )== KErrNone ) )
+&& namePtr8.Find(KSCONSyncRequest) == 0 )
+{
+LOGGER_WRITE_1("Sync request: %S", &namePtr);
+RBufReadStream stream( *iBuffer );
+CleanupClosePushL( stream );
+TRAP( ret, iPCDHandler->HandlePutSyncRequestL( namePtr8, stream ));
+if ( ret )
+{
+LOGGER_WRITE_1("HandlePutSyncRequestL() Leaved with %d", ret);
+}
+CleanupStack::PopAndDestroy( &stream );
+}
+else if ( ( typePtr.Compare( KSConPCDWBXMLObjectType ) == KErrNone) ||
 ( typePtr.Compare( KSConPCDWBXMLObjectType2 )== KErrNone) )
 {
 LOGGER_WRITE( "CSConPCConnSession::HandlePutMessageL() : Object type PCD " );
 TRAPD( err, ret = iConMLHandler->ParseDocumentL( *iBuffer, this ) );
 if ( err != KErrNone )
 LOGGER_WRITE( "Object type not regognized " );
 ret = KErrNotSupported;
 }
 CleanupStack::PopAndDestroy( data );
 CleanupStack::PopAndDestroy( type );
-CleanupStack::PopAndDestroy( name );
+CleanupStack::PopAndDestroy( name8 );
 LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL() end : Heap count : %d", User::Heap().Count() );
 LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL() : returned %d", ret );
 return ret;
 }
 if ( typePtr.Compare( KSConCapabilityObjectType ) == KErrNone )
 {
 ret = iCSCHandler->CapabilityObject( *iBuffer );
 #ifdef DEBUG_XML
-RFs fs;
-User::LeaveIfError(fs.Connect());
-CleanupClosePushL(fs);
 RFile file;
-if ( file.Open(fs, KSConConMLDebugFile, EFileWrite ) == KErrNone )
+if ( file.Open(iFs, KSConConMLDebugFile, EFileWrite ) == KErrNone )
 {
 RFileWriteStream fws;
 TInt fileSize;
 file.Size ( fileSize );
 TTime now;
 fws.Close();
 CleanupStack::PopAndDestroy( &fws );
 }
 file.Close();
-CleanupStack::PopAndDestroy( &fs );
 #endif
 }
 else if (  typePtr.CompareC( KSConPCDWBXMLObjectType) == KErrNone )
 {
-ret = HandleWBXMLGetRequestL( namePtr );
+if ( namePtr8.Find(KSCONSyncRequest) == 0 ) // 8-bit search
+{
+LOGGER_WRITE("Sync request");
+RBufWriteStream stream( *iBuffer );
+CleanupClosePushL( stream );
+TRAP( ret, iPCDHandler->HandleGetSyncRequestL( namePtr8, stream, iChunk.MaxSize() - sizeof(TInt32) ));
+if ( ret )
+{
+LOGGER_WRITE_1("HandleGetSyncRequestL() Leaved with %d", ret);
+}
+stream.CommitL();
+CleanupStack::PopAndDestroy( &stream );
+LOGGER_WRITE_1("iBuffer size: %d", iBuffer->Size());
+}
+else if ( namePtr.Find(KSCONReadImsi) == 0 ) // 16-bit search
+{
+LOGGER_WRITE("Read IMSI");
+TBuf<CTelephony::KIMSISize> imsi;
+ret = CSconImsiReader::GetImsiL( imsi );
+if ( ret == KErrNone )
+{
+TBuf8<CTelephony::KIMSISize> imsi8;
+User::LeaveIfError( CnvUtfConverter::ConvertFromUnicodeToUtf8(imsi8,imsi) );
+iBuffer->ResizeL( imsi8.Length() );
+iBuffer->Write( 0, imsi8 );
+}
+else
+{
+// Change error code more generic
+ret = KErrNotFound;
+}
+}
+else if ( namePtr.Find(KSCONReadNetworkInfo) == 0 ) // 16-bit search
+{
+LOGGER_WRITE("Read NetworkInfo");
+CTelephony::TRegistrationStatus regStatus;
+ret = CSconImsiReader::GetNetworkStatusL( regStatus );
+if ( ret == KErrNone )
+{
+RBufWriteStream stream( *iBuffer );
+CleanupClosePushL( stream );
+stream.WriteInt8L( regStatus );
+stream.CommitL();
+CleanupStack::PopAndDestroy( &stream );
+}
+else
+{
+// Change error code more generic
+ret = KErrNotFound;
+}
+}
+else if ( namePtr.Find(KSCONReadOviAccount) == 0 )
+{
+LOGGER_WRITE("Read Ovi account");
+RBufWriteStream stream( *iBuffer );
+CleanupClosePushL( stream );
+ret = ReadOviAccountInfoL( stream );
+stream.CommitL();
+CleanupStack::PopAndDestroy( &stream );
+}
+else if ( namePtr.Find(KSCONListPath) == 0 )
+{
+LOGGER_WRITE("List path");
+// LISTP:0:pathname
+if ( namePtr.Length() > KSCONListPath().Length()+2)
+{
+TPtrC pathname = namePtr.Mid( KSCONListPath().Length()+2 );
+const TUint16 levelsChar = namePtr[ KSCONListPath().Length() ];
+TInt level(KErrNotFound);
+if ( levelsChar >= TChar('0') )
+{
+level = levelsChar - TChar('0');
+}
+RBufWriteStream stream( *iBuffer );
+CleanupClosePushL( stream );
+TRAP( ret, iFolderLister->GenerateFolderListL( stream, pathname, level ));
+LOGGER_WRITE_1("GenerateFolderListL leaved with err: %d", ret);
+stream.CommitL();
+CleanupStack::PopAndDestroy( &stream );
+}
+else
+{
+ret = KErrArgument;
+}
+}
+else if ( namePtr.Find(KSCONReadBtInfo) == 0 )
+{
+LOGGER_WRITE( "Read BT info");
+if ( !iBtEngine )
+{
+iBtEngine = CSconBtEngine::NewL();
+}
+RBufWriteStream stream( *iBuffer );
+CleanupClosePushL( stream );
+TRAP( ret, iBtEngine->ReadBTInfoL( stream ) );
+LOGGER_WRITE_1("ReadBTInfoL leaved with err: %d", ret);
+stream.CommitL();
+CleanupStack::PopAndDestroy( &stream );
+}
+else if ( namePtr.Find(KSCONSetBtPower) == 0 )
+{
+LOGGER_WRITE( "Change BT Power state");
+if ( namePtr.Length() == KSCONSetBtPower().Length()+1 )
+{
+const TUint16 lastChar = namePtr[ KSCONSetBtPower().Length() ];
+TBool changeBtOn;
+if ( lastChar == TChar('0') )
+{
+changeBtOn = EFalse;
+}
+else if ( lastChar == TChar('1') )
+{
+changeBtOn = ETrue;
+}
+else
+{
+ret = KErrArgument;
+}
+if ( !ret )
+{
+if ( !iBtEngine )
+{
+iBtEngine = CSconBtEngine::NewL();
+}
+TInt err = iBtEngine->SetBtPowerState( changeBtOn );
+RBufWriteStream stream( *iBuffer );
+CleanupClosePushL( stream );
+stream.WriteInt32L( err );
+stream.CommitL();
+CleanupStack::PopAndDestroy( &stream );
+}
+}
+else
+{
+ret = KErrArgument;
+}
+}
+else if ( namePtr.Find(KSCONSetBtName) == 0 )
+{
+LOGGER_WRITE( "Set BT Name");
+TPtrC btName = namePtr.Mid( KSCONSetBtName().Length() );
+TInt err = iBtEngine->SetBtName( btName  );
+RBufWriteStream stream( *iBuffer );
+CleanupClosePushL( stream );
+stream.WriteInt32L( err );
+stream.CommitL();
+CleanupStack::PopAndDestroy( &stream );
+}
+else if ( namePtr.Find(KSCONSetBtAuthorized) == 0 )
+{
+LOGGER_WRITE( "Set BT Authorized");
+ret = KErrArgument;
+// SETBTAUTHORIZED:0:00245f8d6a26
+// 1. param = auth. state ("0"=off, "1"=true)
+// 2. param = bt address (hex string)
+if ( namePtr.Length() > KSCONSetBtAuthorized().Length()+2)
+{
+TPtrC btAddr = namePtr.Mid( KSCONSetBtAuthorized().Length()+2 );
+const TUint16 authStateChar = namePtr[ KSCONSetBtAuthorized().Length() ];
+TBool authorize(EFalse);
+if ( authStateChar == TChar('0') )
+{
+authorize = EFalse;
+ret = KErrNone;
+}
+else if ( authStateChar == TChar('1') )
+{
+authorize = ETrue;
+ret = KErrNone;
+}
+if ( !iBtEngine )
+{
+iBtEngine = CSconBtEngine::NewL();
+}
+TRAPD(err, iBtEngine->SetBtAuthorizedL( btAddr, authorize ) );
+RBufWriteStream stream( *iBuffer );
+CleanupClosePushL( stream );
+stream.WriteInt32L( err );
+stream.CommitL();
+CleanupStack::PopAndDestroy( &stream );
+}
+}
+else
+{
+ret = HandleWBXMLGetRequestL( namePtr );
+}
 }
 else
 {
 LOGGER_WRITE( "CSConPCConnSession::HandleGetMessageL() : Header type not regognized " );
 ret = KErrNotSupported;
 #endif
 TRACE_FUNC_RET(ret);
 return ret;
 }
+// -----------------------------------------------------------------------------
+// CSConPCConnSession::ReadOviAccountInfoL()
+// Reads ovi account information to stream
+// -----------------------------------------------------------------------------
+//
+TInt CSConPCConnSession::ReadOviAccountInfoL( RWriteStream& aAccountInfoStream )
+{
+	TRACE_FUNC_ENTRY;
+RLibrary oviaccounthandlerLib;
+CleanupClosePushL( oviaccounthandlerLib );
+// Dynamically load DLL
+TInt err = oviaccounthandlerLib.Load( KSconOviAccountHandlerDllName );
+if ( err )
+{
+LOGGER_WRITE_1("oviaccounthandlerLib.Load err: %d", err);
+err = KErrNotSupported;
+}
+else if( oviaccounthandlerLib.Type()[1] != KSconOviAccountHandlerDllUid )
+{
+LOGGER_WRITE_1( "KSconOviAccountHandlerDllUid incorrect... (0x%08X)",oviaccounthandlerLib.Type()[1].iUid  );
+err = KErrNotSupported;
+}
+if ( err == KErrNone )
+{
+TSConCreateCSconOviAccountHandlerFunc CreateCSconOviAccountHandlerL =
+(TSConCreateCSconOviAccountHandlerFunc)oviaccounthandlerLib.Lookup(1);
+CSconOviAccountHandler* oviAccountHandler = (CSconOviAccountHandler*)CreateCSconOviAccountHandlerL();
+TRAP(err, oviAccountHandler->GetOviAccountDetailsL( aAccountInfoStream ) );
+LOGGER_WRITE_1("GetOviAccountDetailsL err: %d", err);
+delete oviAccountHandler;
+oviAccountHandler = NULL;
+if ( err )
+{
+// change error code
+err = KErrNotFound;
+}
+}
+else
+{
+err = KErrNotSupported;
+}
+CleanupStack::PopAndDestroy( &oviaccounthandlerLib );
+	TRACE_FUNC_EXIT;
+return err;
+}
 // -----------------------------------------------------------------------------
 // CSConPCConnSession::HandleResetMessage()
 // Resets the PCCS service
 // -----------------------------------------------------------------------------
 //
 TRACE_FUNC_ENTRY;
 TInt ret ( KErrNone );
 #ifdef DEBUG_XML
 iConMLHandler->GenerateDocument( aContent );
-RFs fs;
-User::LeaveIfError(fs.Connect());
-CleanupClosePushL(fs);
 RFile file;
+if ( file.Open(iFs, KSConConMLDebugFile, EFileWrite) == KErrNone )
-if ( file.Open(fs, KSConConMLDebugFile, EFileWrite) == KErrNone )
 {
 RFileWriteStream fws;
 TInt fileSize;
 file.Size( fileSize );
 fws.Attach ( file, fileSize );
 TRAP_IGNORE( fws.CommitL() );
 fws.Close();
 CleanupStack::PopAndDestroy( &fws );
 }
 file.Close();
-CleanupStack::PopAndDestroy( &fs );
 #endif
 if ( aContent )
 {
 for ( ConML_SIDListPtr_t p = aContent->dataOwners->sid;
 p && p->data; p=p->next )
 {
 CSConDataOwner* dataOwner = new (ELeave) CSConDataOwner();
+CleanupStack::PushL( dataOwner );
 if ( p->data->type )
 {
 dataOwner->iType = TSConDOType (DesToInt(
 p->data->type->Data() ));
 }
 if ( p->data->transferDataType )
 {
 TInt intValue = DesToInt( p->data->transferDataType->Data() );
 dataOwner->iTransDataType = static_cast<TSConTransferDataType> (intValue);
 }
-task->iGetDataSizeParams->iDataOwners.Append( dataOwner );
+task->iGetDataSizeParams->iDataOwners.AppendL( dataOwner );
+CleanupStack::Pop( dataOwner );
 }
 }
 ret = iPCDHandler->PutTaskL( task );
 CleanupStack::Pop( task );
 LOGGER_WRITE_1( "CSConPCConnSession::TaskGetDataSizeL() : returned %d", ret );
 if ( aContent->sid )
 {
 for ( ConML_SIDListPtr_t p = aContent->sid; p && p->data; p = p->next )
 {
 CSConDataOwner* dataOwner = new (ELeave) CSConDataOwner();
+CleanupStack::PushL( dataOwner );
 if ( p->data->type )
 {
 dataOwner->iType = TSConDOType ( DesToInt(
 p->data->type->Data() ) );
 }
 // Unicode conversion from 8-bit to 16-bit
 CnvUtfConverter::ConvertToUnicodeFromUtf8(
 dataOwner->iPackageName,
 p->data->packageInfo->name->Data());
 }
-task->iPubFilesParams->iDataOwners.Append( dataOwner );
+task->iPubFilesParams->iDataOwners.AppendL( dataOwner );
+CleanupStack::Pop( dataOwner );
 }
 }
 ret = iPCDHandler->PutTaskL( task );
 CleanupStack::Pop( task );
 LOGGER_WRITE_1( "CSConPCConnSession::TaskListPublicFilesL() : returned %d", ret );
 {
 for ( ConML_SIDListPtr_t p = aContent->dataOwners->sid;
 p && p->data; p=p->next )
 {
 CSConDataOwner* dataOwner = new (ELeave) CSConDataOwner();
+CleanupStack::PushL( dataOwner );
 if ( p->data->type )
 {
 dataOwner->iType = TSConDOType (DesToInt(
 p->data->type->Data() ));
 }
 dataOwner->iJavaHash = HBufC::NewL( hashPtr.Size() );
 dataOwner->iJavaHash->Des().Copy( hashPtr );
 CleanupStack::PopAndDestroy(); //DesToHashLC()
 }
 }
-task->iGetDataOwnerParams->iDataOwners.Append( dataOwner );
+task->iGetDataOwnerParams->iDataOwners.AppendL( dataOwner );
+CleanupStack::Pop( dataOwner );
 }
 }
 ret = iPCDHandler->PutTaskL( task );
 CleanupStack::Pop( task );
 LOGGER_WRITE_1( "CSConPCConnSession::TaskGetDataOwnerStatusL() : returned %d", ret );
 }
 AppendProgressL ( aContent, aResult->iProgress );
 if ( aResult->iApps.Count() > 0 )
 {
-// 5 * KMaxFileName should be enought
+// 6 * KMaxFileName should be enought
-// ( 4 items of TFileName and uid + type + size + 6* "#" )
+// ( 5 items of TFileName and uid + type + size + 7* "#" )
-HBufC8* buf = HBufC8::NewLC( 5 * KMaxFileName );
+HBufC8* buf = HBufC8::NewLC( 6 * KMaxFileName );
 TPtr8 ptrBuf = buf->Des();
 aContent->applications = new ( ELeave ) ConML_Applications_t();
 for ( TInt i=0; i<aResult->iApps.Count(); i++)
 {
 app->data->name = new ( ELeave ) pcdata_t();
 app->data->name->SetDataL( BufToDesLC(
 aResult->iApps[i]->iName));
 CleanupStack::PopAndDestroy(); // BufToDesLC
-// create uid: UID # Type # Size # Version # Vendor # Parent app. name #
+// create uid: UID # Type # Size # Version # Vendor # Parent app. name # WidgetBundleId #
 LOGGER_WRITE( "CSConPCConnSession::AppendListInstalledAppsResultsL() : Create Uid" );
 ptrBuf.Copy( UidToDesLC( aResult->iApps[i]->iUid ) );
 CleanupStack::PopAndDestroy(); // UidToDesLC
 CleanupStack::PopAndDestroy(); // BufToDesLC
 ptrBuf.Append( KSConAppInfoSeparator );
 ptrBuf.Append( BufToDesLC( aResult->iApps[i]->iParentName ) );
 CleanupStack::PopAndDestroy(); // BufToDesLC
+ptrBuf.Append( KSConAppInfoSeparator );
+if (aResult->iApps[i]->iWidgetBundleId)
+{
+ptrBuf.Append( BufToDesLC( *aResult->iApps[i]->iWidgetBundleId ) );
+CleanupStack::PopAndDestroy(); // BufToDesLC
+}
 ptrBuf.Append( KSConAppInfoSeparator );
 LOGGER_WRITE( "CSConPCConnSession::AppendListInstalledAppsResultsL() : set data" );
 app->data->uid = new ( ELeave ) pcdata_t();

branch	RCL_3
changeset 18	453dfc402455
parent 0	d0791faffa3f