1 /*

     2 * Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  PC Connectivity server

    15 *

    16 */

    17 

    18 

    19 #include <s32mem.h> // For RMemReadStream

    20 #include <utf.h>

    21 #include <Etel3rdParty.h>

    22 #include <f32file.h>

    23 

    24 #include "sconpcconnclientserver.h"

    25 #include "sconpcconnserver.h"

    26 #include "sconpcd.h"

    27 #include "sconcsc.h"

    28 #include "sconconmlhandler.h"

    29 #include "sconimsireader.h"

    30 #include "sconoviaccounthandler.h"

    31 #include "sconfolderlister.h"

    32 #include "sconbtengine.h"

    33 #include "debug.h"

    34 

    35 #ifdef DEBUG_XML

    36 #include <s32file.h>

    37 _LIT8( KTimeFormat, "%02d:%02d:%02d.%03d" );

    38 _LIT8( KXmlBegin, "\nXML:\n" );

    39 #endif

    40 

    41 _LIT( KSCONGetMetadataRequest, "METADATA:" );

    42 _LIT8( KSCONSyncRequest, "SYNC:" );

    43 _LIT( KSCONReadImsi, "READIMSI");

    44 _LIT( KSCONReadNetworkInfo, "READNETWORKINFO");

    45 _LIT( KSCONReadOviAccount, "READOVIACCOUNT");

    46 _LIT( KSCONListPath, "LISTP:");

    47 _LIT( KSCONReadBtInfo, "READBTINFO" );

    48 _LIT( KSCONSetBtPower, "SETBTPOWER:" );

    49 _LIT( KSCONSetBtName, "SETBTNAME:" );

    50 _LIT( KSCONSetBtAuthorized, "SETBTAUTHORIZED:" );

    51 

    52 //------------------------------------------------------------

    53 // Global functions 

    54 //------------------------------------------------------------

    55 

    56 // -----------------------------------------------------------------------------

    57 // E32Main()

    58 // Entry point 

    59 // -----------------------------------------------------------------------------

    60 //

    61 TInt E32Main()

    62     {

    63     TRACE_FUNC_ENTRY;

    64     __UHEAP_MARK;

    65     TInt error( KErrNone );

    66     error = CSConPCConnServer::RunServer();

    67     __UHEAP_MARKEND;

    68     TRACE_FUNC_EXIT;

    69     return error;

    70     }

    71 

    72 // -----------------------------------------------------------------------------

    73 // PanicServer()

    74 // Panics the server with panic reason aPanic 

    75 // -----------------------------------------------------------------------------

    76 //

    77 GLDEF_C void PanicServer(TPCConnServPanic aPanic)

    78     {

    79     LOGGER_WRITE_1( "CSConPCConnSession::PanicServer() : Panic code  %d", aPanic );  

    80     _LIT(KTxtServerPanic,"PCConn server panic");

    81     User::Panic(KTxtServerPanic,aPanic);

    82     }

    83 

    84 // -----------------------------------------------------------------------------

    85 // CSConPCConnServer::CSConPCConnServer ()

    86 // Default constructor - can not leave

    87 // -----------------------------------------------------------------------------

    88 //

    89 CSConPCConnServer::CSConPCConnServer () : CServer2( EPriorityStandard)

    90     {

    91     LOGGER_WRITE( "* * * *  CSConPCConnServer  * * * *" );

    92     }

    93 

    94 // -----------------------------------------------------------------------------

    95 // CSConPCConnServer::~CSConPCConnServer()

    96 // Default destructor

    97 // -----------------------------------------------------------------------------

    98 //

    99 EXPORT_C CSConPCConnServer::~CSConPCConnServer()

   100     {

   101     TRACE_FUNC;

   102     }

   103 

   104 // -----------------------------------------------------------------------------

   105 // CSConPCConnServer::NewLC()

   106 // Creates a new instance of CSConPCConnServer

   107 // -----------------------------------------------------------------------------

   108 //

   109 EXPORT_C CSConPCConnServer*  CSConPCConnServer::NewLC()

   110     {

   111     TRACE_FUNC_ENTRY;

   112     CSConPCConnServer* self  = new (ELeave) CSConPCConnServer();

   113     CleanupStack::PushL( self );

   114     self->StartL( KSConPCConnServerName );

   115     TRACE_FUNC_EXIT;

   116     return self;

   117     }

   118 

   119 // -----------------------------------------------------------------------------

   120 // CSConPCConnServer::NewSessionL()

   121 // Creates a new session to the client

   122 // -----------------------------------------------------------------------------

   123 //

   124 CSession2* CSConPCConnServer::NewSessionL( 

   125     const TVersion &aVersion, const RMessage2& /*aMessage*/ ) const

   126     {

   127     TRACE_FUNC_ENTRY;

   128     

   129     // check version

   130     TVersion version( KSConPCConnServerVersionMajor, 

   131                                   KSConPCConnServerVersionMinor, 

   132                                   KSConPCConnServerVersionBuild);

   133     

   134     if (!User::QueryVersionSupported(version, aVersion))

   135         {

   136         User::Leave(KErrNotSupported);

   137         }

   138     

   139     // check client identity

   140     RThread client;

   141     Message().Client( client );

   142     TSecureId clientId = client.SecureId();

   143     

   144     if ( clientId != KSConPCConnClientSecureId )

   145         {

   146         LOGGER_WRITE( "CSConPCConnServer::NewSessionL() : Secure ID does not match" );

   147         User::Leave( KErrAccessDenied );

   148         }

   149     

   150     TRACE_FUNC_EXIT;

   151     return CSConPCConnSession::NewL( *CONST_CAST( CSConPCConnServer*, this));

   152     }

   153 

   154 // -----------------------------------------------------------------------------

   155 // CSConPCConnServer::RunServer()

   156 // Starts the server

   157 // -----------------------------------------------------------------------------

   158 //

   159 TInt CSConPCConnServer::RunServer()

   160     {

   161     TRACE_FUNC_ENTRY;

   162     

   163     CTrapCleanup* cleanup = CTrapCleanup::New();

   164     TInt ret = KErrNoMemory;

   165     if( cleanup )

   166         {

   167         TRAP( ret, CSConPCConnServer::RunServerL(  ) );

   168         delete cleanup;

   169         }

   170     if( ret != KErrNone )

   171         {

   172         // Signal the client that server creation failed

   173         RProcess::Rendezvous( ret );

   174         }

   175     TRACE_FUNC_EXIT;

   176     return ret;

   177     }

   178 

   179 // -----------------------------------------------------------------------------

   180 // CSConPCConnServer::RunServerL()

   181 // Starts the server

   182 // -----------------------------------------------------------------------------

   183 //

   184 void CSConPCConnServer::RunServerL()

   185     {

   186     // Create and install the active scheduler we need

   187     TRACE_FUNC_ENTRY;

   188     CActiveScheduler *as=new (ELeave)CActiveScheduler;

   189     CleanupStack::PushL( as );

   190     CActiveScheduler::Install( as );

   191 

   192     // Create server

   193     CSConPCConnServer* server = CSConPCConnServer::NewLC();

   194 

   195     // Initialisation complete, now signal the client

   196     User::LeaveIfError( RThread().RenameMe( KSConPCConnServerName ) );

   197     RProcess::Rendezvous( KErrNone );

   198 

   199     // Ready to run

   200     CActiveScheduler::Start();

   201     

   202     // Cleanup the scheduler

   203     CleanupStack::PopAndDestroy( 2, as );

   204     TRACE_FUNC_EXIT;

   205     }

   206     

   207 // -----------------------------------------------------------------------------

   208 // CSConPCConnServer::IncSessionCount()

   209 // Increments session count

   210 // -----------------------------------------------------------------------------

   211 //

   212 void CSConPCConnServer::IncSessionCount()

   213     {

   214     TRACE_FUNC_ENTRY;

   215     iSessionCount++;

   216     LOGGER_WRITE_1( "There are now %d sessions", iSessionCount );

   217     TRACE_FUNC_EXIT;

   218     }    

   219     

   220 // -----------------------------------------------------------------------------

   221 // CSConPCConnServer::DecSessionCount()

   222 // Decrements session count

   223 // -----------------------------------------------------------------------------

   224 //

   225 void CSConPCConnServer::DecSessionCount()

   226     {

   227     TRACE_FUNC_ENTRY;

   228     iSessionCount--;

   229     LOGGER_WRITE_1( "There are still %d sessions", iSessionCount );

   230     if ( iSessionCount < 1 )

   231         {

   232         Cancel();

   233         CActiveScheduler::Stop();   

   234         }

   235     TRACE_FUNC_EXIT;

   236     } 

   237 

   238 // -----------------------------------------------------------------------------

   239 // CSConPCConnSession::CSConPCConnSession()

   240 // Default constructor 

   241 // -----------------------------------------------------------------------------

   242 //

   243 CSConPCConnSession::CSConPCConnSession (

   244      CSConPCConnServer& aServer ) : iServer (aServer)

   245     {

   246     TRACE_FUNC_ENTRY;

   247     iServer.IncSessionCount();

   248     TRACE_FUNC_EXIT;

   249     }

   250 

   251 // -----------------------------------------------------------------------------

   252 // CSConPCConnSession::CSConPCConnSession()

   253 // Default destructor - frees resources

   254 // -----------------------------------------------------------------------------

   255 //

   256 CSConPCConnSession::~CSConPCConnSession()

   257     {

   258     TRACE_FUNC_ENTRY;

   259     

   260     iServer.DecSessionCount();

   261 

   262     if ( iConMLHandler )

   263         {

   264         delete iConMLHandler;

   265         iConMLHandler = NULL;

   266         iConMLHandlerLib.Close();

   267         }

   268 

   269     if ( iPCDHandler )

   270         {

   271         delete iPCDHandler;

   272         iPCDHandler = NULL;

   273         iPCDlib.Close();

   274         }

   275 

   276     if ( iCSCHandler )

   277         {

   278         delete iCSCHandler;

   279         iCSCHandler = NULL;

   280         iCSClib.Close();

   281         }

   282     

   283     if ( iBuffer )

   284         {

   285         delete iBuffer;

   286         iBuffer = NULL;

   287         }

   288         

   289     iChunk.Close();

   290     delete iFolderLister;

   291     

   292     iFs.Close();

   293     

   294     delete iBtEngine;

   295      

   296     TRACE_FUNC_EXIT;

   297     }

   298 

   299 // -----------------------------------------------------------------------------

   300 // CSConPCConnSession::NewL()

   301 // Creates a new instance of CSConPCConnSession

   302 // -----------------------------------------------------------------------------

   303 //

   304 EXPORT_C CSConPCConnSession *CSConPCConnSession::NewL(

   305     CSConPCConnServer& aServer)

   306     {

   307     TRACE_FUNC_ENTRY;

   308     CSConPCConnSession* self = new ( ELeave ) CSConPCConnSession(aServer);

   309     CleanupStack::PushL( self );

   310     self->ConstructL();

   311     CleanupStack::Pop( self );

   312     TRACE_FUNC_EXIT;

   313     return self;

   314     }

   315 

   316 // -----------------------------------------------------------------------------

   317 // CSConPCConnSession::ConstructL()

   318 // 2nd phase constructor

   319 // -----------------------------------------------------------------------------

   320 //

   321 void CSConPCConnSession::ConstructL()

   322     {

   323     TRACE_FUNC_ENTRY;

   324     TInt ret ( KErrNone );

   325     iResult = KErrNone;

   326     

   327     User::LeaveIfError( iFs.Connect() );

   328     

   329 #ifdef DEBUG_XML

   330     // create log file 

   331     

   332     RFile file;

   333     TInt err = file.Create ( iFs, KSConConMLDebugFile, EFileWrite );

   334     if( err == KErrNone )

   335         {

   336         // file created, close it

   337         file.Close();

   338         }              

   339 #endif

   340     

   341     // initialize buffer

   342     iBuffer = CBufFlat::NewL ( KSConPCConnBufferMaxSize );

   343     

   344     // load handlers

   345     if ( !iPCDHandler )

   346         {

   347         TRAP( ret, LoadPCDDllL() );

   348         if ( ret != KErrNone) 

   349             {

   350             LOGGER_WRITE_1( "CSConPCConnSession::ConstructL() : PCD load failed with error code %d", ret );

   351             User::Leave( ret );

   352             }

   353         }   

   354     

   355     if ( !iCSCHandler )

   356         {

   357         TRAP( ret, LoadCSCDllL() );

   358         if ( ret != KErrNone) 

   359             {

   360             LOGGER_WRITE_1( "CSConPCConnSession::ConstructL() : CSC dll load failed with error code %d", ret ); 

   361             User::Leave ( ret );

   362             }

   363         }

   364 

   365     // Load parser

   366     if ( !iConMLHandler )

   367         {

   368         TRAPD( ret, LoadConMLHandlerDllL() );

   369         if ( ret != KErrNone)

   370             {

   371             LOGGER_WRITE_1( "CSConPCConnSession::ConstructL() : Parser dll load failed with error code %d", ret );

   372             User::Leave ( ret );

   373             }

   374         }

   375     

   376     iFolderLister = CSconFolderLister::NewL( iFs );

   377     

   378     TRACE_FUNC_EXIT;

   379     }

   380 

   381 // -----------------------------------------------------------------------------

   382 // CSConPCConnSession::ServiceL()

   383 // Gets the client's request

   384 // -----------------------------------------------------------------------------

   385 //

   386 void CSConPCConnSession::ServiceL( const RMessage2 &aMessage)

   387     {

   388     TRACE_FUNC_ENTRY;

   389     TRAPD(err,DispatchRequestL(aMessage) );

   390     if ( err != KErrNone )

   391         {

   392         LOGGER_WRITE_1( "CSConPCConnSession::ServiceL() : leave code %d", err );

   393         PanicServer( E_DispatchRequest );

   394         }

   395     TRACE_FUNC_EXIT;

   396     }

   397 

   398 // -----------------------------------------------------------------------------

   399 // CSConPCConnSession::DispatchRequestL()

   400 // Identifies an IPC command from the client 

   401 // -----------------------------------------------------------------------------

   402 //

   403 void CSConPCConnSession::DispatchRequestL(const RMessage2 &aMessage)

   404     {

   405     TRACE_FUNC_ENTRY;

   406     

   407     TInt ret (KErrNone);

   408         

   409     switch (aMessage.Function())

   410         {

   411         case EPutMessage:

   412             LOGGER_WRITE( "CSConPCConnSession::DispatchRequestL() : EPutMessage" );

   413             ret = HandlePutMessageL();

   414             break;

   415         

   416         case EGetMessage:

   417             LOGGER_WRITE( "CSConPCConnSession::DispatchRequestL() : EGetMessage" );

   418             ret = HandleGetMessageL();

   419             break;

   420         

   421         case EResetMessage:

   422             LOGGER_WRITE( "CSConPCConnSession::DispatchRequestL() : EResetMessage" );

   423             ret = HandleResetMessage();

   424             break;

   425             

   426         case EChunkMessage:

   427             LOGGER_WRITE( "CSConPCConnSession::DispatchRequestL() : EChunkMessage" );

   428             ret = HandleChunkMessage( aMessage );

   429             break;

   430                         

   431         default:

   432             PanicServer (E_BadRequest);

   433             break;

   434         }

   435 

   436     aMessage.Complete( ret );

   437     TRACE_FUNC_EXIT;

   438     }

   439 

   440 // -----------------------------------------------------------------------------

   441 // CSConPCConnSession::HandlePutMessageL()

   442 // Handles a PUT -type message from the client

   443 // -----------------------------------------------------------------------------

   444 //

   445 TInt CSConPCConnSession::HandlePutMessageL()

   446     {

   447     TRACE_FUNC_ENTRY;

   448     LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL() : begin : Heap count : %d", User::Heap().Count() );

   449     TInt ret ( KErrNone );

   450         

   451     if ( !iPCDHandler )

   452         {

   453         TRAP( ret, LoadPCDDllL() );

   454         if ( ret != KErrNone) 

   455             {

   456             LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL (): PCD dll load failed with error code %d", ret );    

   457             return ( ret );

   458             }

   459         }   

   460         

   461     if ( ! iConMLHandler )

   462         {

   463         TRAP ( ret, LoadConMLHandlerDllL() );

   464         if ( ret != KErrNone )

   465             {

   466             LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL (): ConML Handler dll load failed with error code %d", ret );  

   467             return ( ret );

   468             }

   469         }

   470         

   471     TInt length ( 0 );

   472     

   473     RMemReadStream buf( iChunk.Base(), iChunk.Size() );

   474 

   475 

   476     iBuffer->Reset();

   477 

   478     length = buf.ReadInt32L();

   479     HBufC8* name8 = HBufC8::NewLC( length );

   480     TPtr8 namePtr8 = name8->Des();

   481     buf.ReadL( namePtr8, length);

   482     

   483     const TUint8* ptr8 = namePtr8.Ptr();

   484     const TUint16* ptr16 = reinterpret_cast<const TUint16*>( ptr8 );

   485     TPtrC namePtr;

   486     namePtr.Set( ptr16, length/2 );

   487         

   488     length = buf.ReadInt32L();

   489     HBufC8* type = HBufC8::NewLC( length );

   490     TPtr8 typePtr = type->Des();

   491     buf.ReadL( typePtr, length);

   492    

   493     // WBXML Document

   494     length = buf.ReadInt32L();

   495     HBufC8* data = HBufC8::NewLC( length );

   496     TPtr8 dataPtr = data->Des();

   497     

   498     buf.ReadL( dataPtr, length );

   499     iBuffer->ResizeL( length );

   500     iBuffer->Write( 0, dataPtr );

   501             

   502     buf.Close();

   503     

   504 #ifdef DEBUG_XML

   505 

   506     RFile file;

   507     if ( file.Open( iFs, KSConConMLDebugFile, EFileWrite ) == KErrNone )

   508         {

   509         RFileWriteStream fws;

   510         TInt fileSize;

   511         file.Size( fileSize );

   512         

   513         TTime now;

   514         now.HomeTime();

   515         TDateTime time = now.DateTime();

   516         TBuf8<16> timeLine;

   517         timeLine.Format (KTimeFormat, time.Hour(), time.Minute(), 

   518                                     time.Second(), time.MicroSecond() );

   519         

   520         fws.Attach( file, fileSize );

   521         fws.PushL();

   522         fws.WriteL( timeLine );

   523         _LIT8( KPutMessage, "__________PUT-MESSAGE \nWBXML:\n" );

   524         fws.WriteL( KPutMessage );

   525         fws.WriteL( iBuffer->Ptr(0), iBuffer->Size() );

   526         TRAP_IGNORE( fws.CommitL() );

   527         fws.Close();

   528  

   529         CleanupStack::PopAndDestroy( &fws );

   530         }

   531     file.Close();

   532 #endif

   533     if ( ( ( typePtr.CompareC( KSConPCDWBXMLObjectType)== KErrNone ) || 

   534                  ( typePtr.CompareC( KSConPCDWBXMLObjectType2 )== KErrNone ) )

   535                  && namePtr8.Find(KSCONSyncRequest) == 0 )

   536         {

   537         LOGGER_WRITE_1("Sync request: %S", &namePtr);

   538         RBufReadStream stream( *iBuffer );

   539         

   540         CleanupClosePushL( stream );

   541         TRAP( ret, iPCDHandler->HandlePutSyncRequestL( namePtr8, stream ));

   542         if ( ret )

   543             {

   544             LOGGER_WRITE_1("HandlePutSyncRequestL() Leaved with %d", ret);

   545             }

   546         

   547         CleanupStack::PopAndDestroy( &stream );

   548         }

   549     else if ( ( typePtr.Compare( KSConPCDWBXMLObjectType ) == KErrNone) || 

   550          ( typePtr.Compare( KSConPCDWBXMLObjectType2 )== KErrNone) )

   551         {

   552         LOGGER_WRITE( "CSConPCConnSession::HandlePutMessageL() : Object type PCD " );

   553         TRAPD( err, ret = iConMLHandler->ParseDocumentL( *iBuffer, this ) );    

   554         if ( err != KErrNone )

   555             {

   556             ret = err;

   557             }

   558         if ( ret == KErrNone )

   559             {

   560             // Possible error code returned from PCCS 

   561             ret = iResult;

   562             }

   563         }

   564     else 

   565         {

   566         LOGGER_WRITE( "Object type not regognized " );

   567         ret = KErrNotSupported;

   568         }

   569     CleanupStack::PopAndDestroy( data );

   570     CleanupStack::PopAndDestroy( type );

   571     CleanupStack::PopAndDestroy( name8 );

   572     LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL() end : Heap count : %d", User::Heap().Count() );

   573     LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL() : returned %d", ret );    

   574     return ret;

   575     }

   576 

   577 // -----------------------------------------------------------------------------

   578 // CSConPCConnSession::HandleGetMessageL()

   579 // Handles a GET -type message from the client

   580 // -----------------------------------------------------------------------------

   581 //

   582 TInt CSConPCConnSession::HandleGetMessageL()

   583     {

   584     TRACE_FUNC_ENTRY;

   585     TInt ret ( KErrNone );

   586     

   587     if ( !iCSCHandler )

   588         {

   589         TRAP( ret, LoadCSCDllL() );

   590         if ( ret != KErrNone) 

   591             {

   592             LOGGER_WRITE_1( "CSConPCConnSession::HandleGetMessageL() : CSC dll load failed with error code %d", ret ); 

   593             return ret;

   594             }

   595         }

   596 

   597     TInt32 length ( 0 );

   598     RMemReadStream readBuf( iChunk.Base(), iChunk.Size() );

   599     iBuffer->Reset();

   600     

   601     length = readBuf.ReadInt32L();

   602     HBufC8* name = HBufC8::NewLC( length );

   603     TPtr8 namePtr8 = name->Des();

   604     readBuf.ReadL( namePtr8, length);

   605     namePtr8.SetLength( length );

   606     LOGGER_WRITE8_1("namePtr: %S", &namePtr8);

   607     

   608     const TUint8* ptr8 = namePtr8.Ptr();

   609     const TUint16* ptr16 = reinterpret_cast<const TUint16*>( ptr8 );

   610     TPtrC namePtr;

   611     namePtr.Set( ptr16, length/2 );

   612     

   613     length = readBuf.ReadInt32L();

   614     HBufC8* type = HBufC8::NewLC( length );

   615     TPtr8 typePtr = type->Des();

   616     readBuf.ReadL( typePtr, length);

   617     

   618     readBuf.Close();

   619         

   620     if ( typePtr.Compare( KSConCapabilityObjectType ) == KErrNone )

   621         {

   622         ret = iCSCHandler->CapabilityObject( *iBuffer );

   623         

   624 #ifdef DEBUG_XML

   625         

   626         RFile file;

   627         if ( file.Open(iFs, KSConConMLDebugFile, EFileWrite ) == KErrNone )

   628             {

   629             RFileWriteStream fws;

   630             TInt fileSize;

   631             file.Size ( fileSize );

   632             TTime now;

   633             now.HomeTime();

   634             TDateTime time = now.DateTime();

   635             TBuf8<16> timeLine;

   636             timeLine.Format( KTimeFormat, time.Hour(), time.Minute(), 

   637                                         time.Second(), time.MicroSecond() );

   638 

   639             fws.Attach ( file, fileSize);

   640             fws.PushL();

   641             fws.WriteL( timeLine );

   642             _LIT8( KGetMessage, "__________GET -MESSAGE - Capability Object \n " );

   643             fws.WriteL( KGetMessage );

   644             fws.WriteL( iBuffer->Ptr(0), iBuffer->Size() );

   645             TRAP_IGNORE( fws.CommitL() );

   646             fws.Close();

   647 

   648             CleanupStack::PopAndDestroy( &fws );

   649             }

   650         file.Close();

   651 #endif

   652 

   653         }

   654     else if (  typePtr.CompareC( KSConPCDWBXMLObjectType) == KErrNone )

   655         {

   656         if ( namePtr8.Find(KSCONSyncRequest) == 0 ) // 8-bit search

   657             {

   658             LOGGER_WRITE("Sync request");

   659             

   660             RBufWriteStream stream( *iBuffer );

   661                 

   662             CleanupClosePushL( stream );

   663             

   664             TRAP( ret, iPCDHandler->HandleGetSyncRequestL( namePtr8, stream, iChunk.MaxSize() - sizeof(TInt32) ));

   665             if ( ret )

   666                 {

   667                 LOGGER_WRITE_1("HandleGetSyncRequestL() Leaved with %d", ret);

   668                 }

   669             stream.CommitL();

   670             CleanupStack::PopAndDestroy( &stream );

   671             

   672             LOGGER_WRITE_1("iBuffer size: %d", iBuffer->Size());

   673             

   674             }

   675         else if ( namePtr.Find(KSCONReadImsi) == 0 ) // 16-bit search

   676             {

   677             LOGGER_WRITE("Read IMSI");

   678             TBuf<CTelephony::KIMSISize> imsi;

   679             ret = CSconImsiReader::GetImsiL( imsi );

   680             

   681             if ( ret == KErrNone )

   682                 {

   683                 TBuf8<CTelephony::KIMSISize> imsi8;

   684                 User::LeaveIfError( CnvUtfConverter::ConvertFromUnicodeToUtf8(imsi8,imsi) );

   685                 

   686                 iBuffer->ResizeL( imsi8.Length() );

   687                 iBuffer->Write( 0, imsi8 );

   688                 }

   689             else

   690                 {

   691                 // Change error code more generic

   692                 ret = KErrNotFound;

   693                 }

   694             }

   695         else if ( namePtr.Find(KSCONReadNetworkInfo) == 0 ) // 16-bit search

   696             {

   697             LOGGER_WRITE("Read NetworkInfo");

   698             CTelephony::TRegistrationStatus regStatus;

   699             ret = CSconImsiReader::GetNetworkStatusL( regStatus );

   700             

   701             if ( ret == KErrNone )

   702                 {

   703                 RBufWriteStream stream( *iBuffer );

   704                 CleanupClosePushL( stream );

   705                 stream.WriteInt8L( regStatus );

   706                 stream.CommitL();

   707                 CleanupStack::PopAndDestroy( &stream );

   708                 }

   709             else

   710                 {

   711                 // Change error code more generic

   712                 ret = KErrNotFound;

   713                 }

   714             }

   715         else if ( namePtr.Find(KSCONReadOviAccount) == 0 )

   716             {

   717             LOGGER_WRITE("Read Ovi account");

   718             RBufWriteStream stream( *iBuffer );

   719             CleanupClosePushL( stream );

   720             

   721             ret = ReadOviAccountInfoL( stream );

   722             stream.CommitL();

   723             CleanupStack::PopAndDestroy( &stream );

   724             

   725             }

   726         else if ( namePtr.Find(KSCONListPath) == 0 )

   727             {

   728             LOGGER_WRITE("List path");

   729             // LISTP:0:pathname

   730             if ( namePtr.Length() > KSCONListPath().Length()+2)

   731                 {

   732                 TPtrC pathname = namePtr.Mid( KSCONListPath().Length()+2 );

   733             

   734                 const TUint16 levelsChar = namePtr[ KSCONListPath().Length() ];

   735                 TInt level(KErrNotFound);

   736                 if ( levelsChar >= TChar('0') )

   737                     {

   738                     level = levelsChar - TChar('0');

   739                     }

   740                 

   741                 RBufWriteStream stream( *iBuffer );

   742                 CleanupClosePushL( stream );

   743                 TRAP( ret, iFolderLister->GenerateFolderListL( stream, pathname, level ));

   744                 LOGGER_WRITE_1("GenerateFolderListL leaved with err: %d", ret);

   745                 stream.CommitL();

   746                 CleanupStack::PopAndDestroy( &stream );

   747                 }

   748             else

   749                 {

   750                 ret = KErrArgument;

   751                 }

   752             

   753             }

   754         else if ( namePtr.Find(KSCONReadBtInfo) == 0 )

   755             {

   756             LOGGER_WRITE( "Read BT info");

   757             if ( !iBtEngine )

   758                 {

   759                 iBtEngine = CSconBtEngine::NewL();

   760                 }

   761             RBufWriteStream stream( *iBuffer );

   762             CleanupClosePushL( stream );

   763             TRAP( ret, iBtEngine->ReadBTInfoL( stream ) );

   764             LOGGER_WRITE_1("ReadBTInfoL leaved with err: %d", ret);

   765             stream.CommitL();

   766             CleanupStack::PopAndDestroy( &stream );

   767             }

   768         else if ( namePtr.Find(KSCONSetBtPower) == 0 )

   769             {

   770             LOGGER_WRITE( "Change BT Power state");

   771             if ( namePtr.Length() == KSCONSetBtPower().Length()+1 )

   772                 {

   773                 const TUint16 lastChar = namePtr[ KSCONSetBtPower().Length() ];

   774                 TBool changeBtOn;

   775                 if ( lastChar == TChar('0') )

   776                     {

   777                     changeBtOn = EFalse;

   778                     }

   779                 else if ( lastChar == TChar('1') )

   780                     {

   781                     changeBtOn = ETrue;

   782                     }

   783                 else

   784                     {

   785                     ret = KErrArgument;

   786                     }

   787                 

   788                 if ( !ret )

   789                     {

   790                     if ( !iBtEngine )

   791                        {

   792                        iBtEngine = CSconBtEngine::NewL();

   793                        }

   794                     TInt err = iBtEngine->SetBtPowerState( changeBtOn );

   795                     

   796                     RBufWriteStream stream( *iBuffer );

   797                     CleanupClosePushL( stream );

   798                     stream.WriteInt32L( err );

   799                     stream.CommitL();

   800                     CleanupStack::PopAndDestroy( &stream );

   801                     }

   802                 }

   803             else

   804                 {

   805                 ret = KErrArgument;

   806                 }

   807             }

   808         else if ( namePtr.Find(KSCONSetBtName) == 0 )

   809             {

   810             LOGGER_WRITE( "Set BT Name");

   811             TPtrC btName = namePtr.Mid( KSCONSetBtName().Length() );

   812             TInt err = iBtEngine->SetBtName( btName  );

   813             

   814             RBufWriteStream stream( *iBuffer );

   815             CleanupClosePushL( stream );

   816             stream.WriteInt32L( err );

   817             stream.CommitL();

   818             CleanupStack::PopAndDestroy( &stream );

   819             }

   820         else if ( namePtr.Find(KSCONSetBtAuthorized) == 0 )

   821             {

   822             LOGGER_WRITE( "Set BT Authorized");

   823             ret = KErrArgument;

   824             // SETBTAUTHORIZED:0:00245f8d6a26

   825             // 1. param = auth. state ("0"=off, "1"=true)

   826             // 2. param = bt address (hex string)

   827             

   828             if ( namePtr.Length() > KSCONSetBtAuthorized().Length()+2)

   829                 {

   830                 TPtrC btAddr = namePtr.Mid( KSCONSetBtAuthorized().Length()+2 );

   831                 

   832                 const TUint16 authStateChar = namePtr[ KSCONSetBtAuthorized().Length() ];

   833                 TBool authorize(EFalse);

   834                 if ( authStateChar == TChar('0') )

   835                     {

   836                     authorize = EFalse;

   837                     ret = KErrNone;

   838                     }

   839                 else if ( authStateChar == TChar('1') )

   840                     {

   841                     authorize = ETrue;

   842                     ret = KErrNone;

   843                     }

   844                 

   845                 if ( !iBtEngine )

   846                    {

   847                    iBtEngine = CSconBtEngine::NewL();

   848                    }

   849                 TRAPD(err, iBtEngine->SetBtAuthorizedL( btAddr, authorize ) );

   850                 

   851                 RBufWriteStream stream( *iBuffer );

   852                 CleanupClosePushL( stream );

   853                 stream.WriteInt32L( err );

   854                 stream.CommitL();

   855                 CleanupStack::PopAndDestroy( &stream );

   856                 }

   857             

   858             }

   859         else 

   860             {

   861             ret = HandleWBXMLGetRequestL( namePtr );

   862             }

   863         }

   864     else

   865         {

   866         LOGGER_WRITE( "CSConPCConnSession::HandleGetMessageL() : Header type not regognized " );

   867         ret = KErrNotSupported;

   868         }

   869     

   870     CleanupStack::PopAndDestroy( 2 ); // name, type

   871     

   872     if ( ret != KErrNone )

   873         {

   874         return ret;

   875         }

   876     

   877     length = iBuffer->Size();

   878     

   879     if ( sizeof(TInt32) + length > iChunk.Size() )

   880         {

   881         // need to resize chunk

   882         TInt err = iChunk.Adjust( sizeof(TInt32) + length );

   883         LOGGER_WRITE_2("iChunk.Adjust( %d ) err: %d", sizeof(TInt32) + length, err);

   884         if ( err )

   885             {

   886             iBuffer->Reset();

   887             LOGGER_WRITE_1( "CSConPCConnSession::HandleGetMessageL() : returned %d", ret );

   888             return err;

   889             }

   890         }

   891     

   892     // copy data to chunk

   893     RMemWriteStream writeBuf ( iChunk.Base(), iChunk.Size() );

   894     

   895     if ( length > 0 )

   896         {

   897         writeBuf.WriteInt32L( length );

   898         writeBuf.WriteL( iBuffer->Ptr(0), length );

   899         writeBuf.CommitL();

   900         }

   901     else 

   902         {

   903         writeBuf.WriteInt32L( 0 );

   904         }

   905     writeBuf.CommitL();

   906     writeBuf.Close();

   907     iBuffer->Reset();

   908     LOGGER_WRITE_1( "CSConPCConnSession::HandleGetMessageL() : returned %d", ret );

   909     return ( ret );

   910     }

   911 

   912 // -----------------------------------------------------------------------------

   913 // CSConPCConnSession::HandleWBXMLGetRequestL()

   914 // Handles a ConML(wbxml) Get request from the client

   915 // -----------------------------------------------------------------------------

   916 //

   917 TInt CSConPCConnSession::HandleWBXMLGetRequestL( const TDesC& aFileName )

   918     {

   919     TRACE_FUNC_ENTRY;

   920     TInt ret(KErrNone);

   921     if ( aFileName.Find(KSCONGetMetadataRequest) == 0 )

   922         {

   923         // ConML get metadata request --> Create metadata task

   924         LOGGER_WRITE( "ConML GetMetadataRequest" );

   925         TPtrC filename = aFileName.Mid( KSCONGetMetadataRequest().Length() );

   926         

   927         TSConMethodName method ( EGetMetadata );

   928         CSConTask* task = CSConTask::NewLC( method );

   929         

   930         if ( filename.Length() > task->iGetMetadataParams->iFilename.MaxLength() )

   931             {

   932             User::Leave( KErrTooBig );

   933             }

   934         task->iGetMetadataParams->iFilename = filename;

   935         

   936         ret = iPCDHandler->PutTaskL( task );

   937         CleanupStack::Pop( task );

   938         LOGGER_WRITE_1("iPCDHandler->PutTaskL ret: %d", ret);

   939         }

   940     else if ( aFileName.Length() > 0 )

   941         {

   942         LOGGER_WRITE("Error: aFilename does not match to any definitions");

   943         TRACE_FUNC_RET( KErrArgument );

   944         return KErrArgument;

   945         }

   946     

   947 	// Get reply

   948     LOGGER_WRITE( "CSConPCConnSession::HandleGetMessageL() before ConML GetReplyL" );

   949     CSConStatusReply* reply = iPCDHandler->GetReply();

   950     CleanupStack::PushL( reply );

   951     

   952     ConML_ConMLPtr_t content = new ( ELeave ) ConML_ConML_t();

   953     CleanupStack::PushL( content );

   954     

   955     AppendStatusL( content, reply );

   956     ret = iConMLHandler->GenerateDocument( content );

   957     

   958     CleanupStack::PopAndDestroy( content );

   959     CleanupStack::PopAndDestroy( reply );

   960      

   961     TPtrC8 ptr( iConMLHandler->WBXMLDocument() );

   962     LOGGER_WRITE_1("ptr.Size(): %d", ptr.Size());

   963     iBuffer->ResizeL( ptr.Size() );

   964     iBuffer->Write( 0, ptr );

   965 

   966 #ifdef DEBUG_XML

   967     RFile file;

   968     if ( file.Open( iFs, KSConConMLDebugFile, EFileWrite) == KErrNone )

   969         {

   970         RFileWriteStream fws;   

   971         TInt fileSize;

   972         file.Size ( fileSize );

   973         fws.Attach ( file, fileSize);

   974         fws.PushL();

   975         TTime now;

   976         now.HomeTime();

   977         TDateTime time = now.DateTime();

   978         TBuf8<16> timeLine;

   979         timeLine.Format( KTimeFormat, time.Hour(), time.Minute(), 

   980                          time.Second(), time.MicroSecond() );

   981 

   982         fws.WriteL( timeLine );

   983         _LIT8( KGetMessage, "__________GET -MESSAGE" );

   984         fws.WriteL( KGetMessage );

   985         fws.WriteL(KXmlBegin);

   986         fws.WriteL(iConMLHandler->XMLDocument().Ptr(), 

   987                           iConMLHandler->XMLDocument().Length());

   988         fws.WriteL(_L("\n\n"));

   989         TRAP_IGNORE( fws.CommitL() );

   990         fws.Close();

   991         CleanupStack::PopAndDestroy( &fws );

   992         }

   993         

   994     file.Close();

   995 #endif

   996     TRACE_FUNC_RET(ret);

   997     return ret;

   998     }

   999 

  1000 

  1001 // -----------------------------------------------------------------------------

  1002 // CSConPCConnSession::ReadOviAccountInfoL()

  1003 // Reads ovi account information to stream

  1004 // -----------------------------------------------------------------------------

  1005 //

  1006 TInt CSConPCConnSession::ReadOviAccountInfoL( RWriteStream& aAccountInfoStream )

  1007     {

  1008 	TRACE_FUNC_ENTRY;

  1009     RLibrary oviaccounthandlerLib;

  1010     CleanupClosePushL( oviaccounthandlerLib );

  1011     // Dynamically load DLL

  1012     TInt err = oviaccounthandlerLib.Load( KSconOviAccountHandlerDllName );

  1013     if ( err )

  1014         {

  1015         LOGGER_WRITE_1("oviaccounthandlerLib.Load err: %d", err);

  1016         err = KErrNotSupported;

  1017         }

  1018     else if( oviaccounthandlerLib.Type()[1] != KSconOviAccountHandlerDllUid )

  1019         {

  1020         LOGGER_WRITE_1( "KSconOviAccountHandlerDllUid incorrect... (0x%08X)",oviaccounthandlerLib.Type()[1].iUid  );

  1021         err = KErrNotSupported;

  1022         }

  1023     

  1024     if ( err == KErrNone )

  1025         {

  1026         TSConCreateCSconOviAccountHandlerFunc CreateCSconOviAccountHandlerL =

  1027         (TSConCreateCSconOviAccountHandlerFunc)oviaccounthandlerLib.Lookup(1);

  1028         

  1029         CSconOviAccountHandler* oviAccountHandler = (CSconOviAccountHandler*)CreateCSconOviAccountHandlerL();

  1030         

  1031         TRAP(err, oviAccountHandler->GetOviAccountDetailsL( aAccountInfoStream ) );

  1032         LOGGER_WRITE_1("GetOviAccountDetailsL err: %d", err);

  1033         

  1034         delete oviAccountHandler;

  1035         oviAccountHandler = NULL;

  1036         

  1037         if ( err )

  1038             {

  1039             // change error code

  1040             err = KErrNotFound;

  1041             }

  1042         }

  1043     else

  1044         {

  1045         err = KErrNotSupported;

  1046         }

  1047 	

  1048     CleanupStack::PopAndDestroy( &oviaccounthandlerLib );

  1049 	TRACE_FUNC_EXIT;

  1050     return err;

  1051     }

  1052 

  1053 // -----------------------------------------------------------------------------

  1054 // CSConPCConnSession::HandleResetMessage()

  1055 // Resets the PCCS service

  1056 // -----------------------------------------------------------------------------

  1057 //

  1058 TInt CSConPCConnSession::HandleResetMessage()   

  1059     {

  1060     TRACE_FUNC_ENTRY;

  1061     TInt ret ( KErrNone );

  1062     

  1063     // reset PCD

  1064     if ( iPCDHandler )

  1065         {

  1066         iPCDHandler->ResetPCD();

  1067         }

  1068         

  1069     LOGGER_WRITE_1( "CSConPCConnSession::HandleResetMessage() : ret %d", ret );

  1070     return ret;

  1071     }

  1072     

  1073 // -----------------------------------------------------------------------------

  1074 // CSConPCConnSession::HandleChunkMessage( const RMessage2& aMessage )

  1075 // Receives the chunk handle from the client

  1076 // -----------------------------------------------------------------------------

  1077 //

  1078 TInt CSConPCConnSession::HandleChunkMessage( const RMessage2& aMessage )    

  1079     {

  1080     TRACE_FUNC_ENTRY;

  1081     TInt ret ( KErrNone );

  1082     

  1083     ret = iChunk.Open( aMessage, 0, EFalse );

  1084         

  1085     LOGGER_WRITE_1( "CSConPCConnSession::HandleChunkMessageL() : ret %d", ret );

  1086     return ret;

  1087     }

  1088 

  1089 // -----------------------------------------------------------------------------

  1090 // CSConPCConnSession::LoadPCDDllL()

  1091 // Loads the PCCS service

  1092 // -----------------------------------------------------------------------------

  1093 //

  1094 void CSConPCConnSession::LoadPCDDllL()

  1095     {

  1096     TRACE_FUNC_ENTRY;

  1097     

  1098     // Dynamically load DLL

  1099     User::LeaveIfError( iPCDlib.Load( KSConPCDLibName ) );

  1100     if( iPCDlib.Type()[1] != KSConPCDUid )

  1101         {

  1102         LOGGER_WRITE( "CSConPCConnSession::LoadPCDDllL() : KSConPCDUidValue incorrect..." );

  1103         iPCDlib.Close();

  1104         User::Leave( KErrNotFound );

  1105         }   

  1106     TSConCreateCSConPCDFunc CreateCSConPCDL =

  1107     (TSConCreateCSConPCDFunc)iPCDlib.Lookup(1);

  1108     

  1109     iPCDHandler = (CSConPCD*)CreateCSConPCDL();

  1110     TRACE_FUNC_EXIT;

  1111     }

  1112 

  1113 // -----------------------------------------------------------------------------

  1114 // CSConPCConnSession::LoadCSCDllL()

  1115 // Loads the CSC service

  1116 // -----------------------------------------------------------------------------

  1117 //

  1118 void CSConPCConnSession::LoadCSCDllL()

  1119     {

  1120     TRACE_FUNC_ENTRY;

  1121     // Dynamically load DLL

  1122     User::LeaveIfError( iCSClib.Load( KSConCSCLibName ) );

  1123     if( iCSClib.Type()[1] != KSConCSCUid )

  1124         {

  1125         LOGGER_WRITE( "CSConPCConnSession::LoadCSCDllL() : KSConCSCUidValue incorrect" );

  1126         iCSClib.Close();

  1127         User::Leave( KErrNotFound );

  1128         }   

  1129     TSConCreateCSConCSCFunc CreateCSConCSCL = 

  1130     (TSConCreateCSConCSCFunc)iCSClib.Lookup(1);

  1131     

  1132     iCSCHandler = (CSConCSC*)CreateCSConCSCL();

  1133     TRACE_FUNC_EXIT;

  1134     }