1 /*

     2 * Copyright (c) 2005-2009 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 

    22 #include "sconpcconnclientserver.h"

    23 #include "sconpcconnserver.h"

    24 #include "sconpcd.h"

    25 #include "sconcsc.h"

    26 #include "sconconmlhandler.h"

    27 #include "debug.h"

    28 

    29 #ifdef DEBUG_XML

    30 #include <s32file.h>

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

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

    33 #endif

    34 

    35 _LIT( KSCONGetMetadataRequest, "METADATA:" );

    36 

    37 //------------------------------------------------------------

    38 // Global functions 

    39 //------------------------------------------------------------

    40 

    41 // -----------------------------------------------------------------------------

    42 // E32Main()

    43 // Entry point 

    44 // -----------------------------------------------------------------------------

    45 //

    46 TInt E32Main()

    47     {

    48     TRACE_FUNC_ENTRY;

    49     __UHEAP_MARK;

    50     TInt error( KErrNone );

    51     error = CSConPCConnServer::RunServer();

    52     __UHEAP_MARKEND;

    53     TRACE_FUNC_EXIT;

    54     return error;

    55     }

    56 

    57 // -----------------------------------------------------------------------------

    58 // PanicServer()

    59 // Panics the server with panic reason aPanic 

    60 // -----------------------------------------------------------------------------

    61 //

    62 GLDEF_C void PanicServer(TPCConnServPanic aPanic)

    63     {

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

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

    66     User::Panic(KTxtServerPanic,aPanic);

    67     }

    68 

    69 // -----------------------------------------------------------------------------

    70 // CSConPCConnServer::CSConPCConnServer ()

    71 // Default constructor - can not leave

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

    73 //

    74 CSConPCConnServer::CSConPCConnServer () : CServer2( EPriorityStandard)

    75     {

    76     LOGGER_WRITE( "* * * *  CSConPCConnServer  * * * *" );

    77     }

    78 

    79 // -----------------------------------------------------------------------------

    80 // CSConPCConnServer::~CSConPCConnServer()

    81 // Default destructor

    82 // -----------------------------------------------------------------------------

    83 //

    84 EXPORT_C CSConPCConnServer::~CSConPCConnServer()

    85     {

    86     TRACE_FUNC;

    87     }

    88 

    89 // -----------------------------------------------------------------------------

    90 // CSConPCConnServer::NewLC()

    91 // Creates a new instance of CSConPCConnServer

    92 // -----------------------------------------------------------------------------

    93 //

    94 EXPORT_C CSConPCConnServer*  CSConPCConnServer::NewLC()

    95     {

    96     TRACE_FUNC_ENTRY;

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

    98     CleanupStack::PushL( self );

    99     self->StartL( KSConPCConnServerName );

   100     TRACE_FUNC_EXIT;

   101     return self;

   102     }

   103 

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

   105 // CSConPCConnServer::NewSessionL()

   106 // Creates a new session to the client

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

   108 //

   109 CSession2* CSConPCConnServer::NewSessionL( 

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

   111     {

   112     TRACE_FUNC_ENTRY;

   113     

   114     // check version

   115     TVersion version( KSConPCConnServerVersionMajor, 

   116                                   KSConPCConnServerVersionMinor, 

   117                                   KSConPCConnServerVersionBuild);

   118     

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

   120         {

   121         User::Leave(KErrNotSupported);

   122         }

   123     

   124     // check client identity

   125     RThread client;

   126     Message().Client( client );

   127     TSecureId clientId = client.SecureId();

   128     

   129     if ( clientId != KSConPCConnClientSecureId )

   130         {

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

   132         User::Leave( KErrAccessDenied );

   133         }

   134     

   135     TRACE_FUNC_EXIT;

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

   137     }

   138 

   139 // -----------------------------------------------------------------------------

   140 // CSConPCConnServer::RunServer()

   141 // Starts the server

   142 // -----------------------------------------------------------------------------

   143 //

   144 TInt CSConPCConnServer::RunServer()

   145     {

   146     TRACE_FUNC_ENTRY;

   147     

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

   149     TInt ret = KErrNoMemory;

   150     if( cleanup )

   151         {

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

   153         delete cleanup;

   154         }

   155     if( ret != KErrNone )

   156         {

   157         // Signal the client that server creation failed

   158         RProcess::Rendezvous( ret );

   159         }

   160     TRACE_FUNC_EXIT;

   161     return ret;

   162     }

   163 

   164 // -----------------------------------------------------------------------------

   165 // CSConPCConnServer::RunServerL()

   166 // Starts the server

   167 // -----------------------------------------------------------------------------

   168 //

   169 void CSConPCConnServer::RunServerL()

   170     {

   171     // Create and install the active scheduler we need

   172     TRACE_FUNC_ENTRY;

   173     CActiveScheduler *as=new (ELeave)CActiveScheduler;

   174     CleanupStack::PushL( as );

   175     CActiveScheduler::Install( as );

   176 

   177     // Create server

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

   179 

   180     // Initialisation complete, now signal the client

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

   182     RProcess::Rendezvous( KErrNone );

   183 

   184     // Ready to run

   185     CActiveScheduler::Start();

   186     

   187     // Cleanup the scheduler

   188     CleanupStack::PopAndDestroy( 2, as );

   189     TRACE_FUNC_EXIT;

   190     }

   191     

   192 // -----------------------------------------------------------------------------

   193 // CSConPCConnServer::IncSessionCount()

   194 // Increments session count

   195 // -----------------------------------------------------------------------------

   196 //

   197 void CSConPCConnServer::IncSessionCount()

   198     {

   199     TRACE_FUNC_ENTRY;

   200     iSessionCount++;

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

   202     TRACE_FUNC_EXIT;

   203     }    

   204     

   205 // -----------------------------------------------------------------------------

   206 // CSConPCConnServer::DecSessionCount()

   207 // Decrements session count

   208 // -----------------------------------------------------------------------------

   209 //

   210 void CSConPCConnServer::DecSessionCount()

   211     {

   212     TRACE_FUNC_ENTRY;

   213     iSessionCount--;

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

   215     if ( iSessionCount < 1 )

   216         {

   217         Cancel();

   218         CActiveScheduler::Stop();   

   219         }

   220     TRACE_FUNC_EXIT;

   221     } 

   222 

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

   224 // CSConPCConnSession::CSConPCConnSession()

   225 // Default constructor 

   226 // -----------------------------------------------------------------------------

   227 //

   228 CSConPCConnSession::CSConPCConnSession (

   229      CSConPCConnServer& aServer ) : iServer (aServer)

   230     {

   231     TRACE_FUNC_ENTRY;

   232     iServer.IncSessionCount();

   233     TRACE_FUNC_EXIT;

   234     }

   235 

   236 // -----------------------------------------------------------------------------

   237 // CSConPCConnSession::CSConPCConnSession()

   238 // Default destructor - frees resources

   239 // -----------------------------------------------------------------------------

   240 //

   241 CSConPCConnSession::~CSConPCConnSession()

   242     {

   243     TRACE_FUNC_ENTRY;

   244     

   245     iServer.DecSessionCount();

   246 

   247     if ( iConMLHandler )

   248         {

   249         delete iConMLHandler;

   250         iConMLHandler = NULL;

   251         iConMLHandlerLib.Close();

   252         }

   253 

   254     if ( iPCDHandler )

   255         {

   256         delete iPCDHandler;

   257         iPCDHandler = NULL;

   258         iPCDlib.Close();

   259         }

   260 

   261     if ( iCSCHandler )

   262         {

   263         delete iCSCHandler;

   264         iCSCHandler = NULL;

   265         iCSClib.Close();

   266         }

   267     

   268     if ( iBuffer )

   269         {

   270         delete iBuffer;

   271         iBuffer = NULL;

   272         }

   273         

   274     iChunk.Close();

   275         

   276     TRACE_FUNC_EXIT;

   277     }

   278 

   279 // -----------------------------------------------------------------------------

   280 // CSConPCConnSession::NewL()

   281 // Creates a new instance of CSConPCConnSession

   282 // -----------------------------------------------------------------------------

   283 //

   284 EXPORT_C CSConPCConnSession *CSConPCConnSession::NewL(

   285     CSConPCConnServer& aServer)

   286     {

   287     TRACE_FUNC_ENTRY;

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

   289     CleanupStack::PushL( self );

   290     self->ConstructL();

   291     CleanupStack::Pop( self );

   292     TRACE_FUNC_EXIT;

   293     return self;

   294     }

   295 

   296 // -----------------------------------------------------------------------------

   297 // CSConPCConnSession::ConstructL()

   298 // 2nd phase constructor

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

   300 //

   301 void CSConPCConnSession::ConstructL()

   302     {

   303     TRACE_FUNC_ENTRY;

   304     TInt ret ( KErrNone );

   305     iResult = KErrNone;

   306     

   307 #ifdef DEBUG_XML

   308     // create log file 

   309     RFs fs;

   310     User::LeaveIfError( fs.Connect () );

   311     CleanupClosePushL( fs );

   312     

   313     RFile file;

   314     TInt err = file.Create ( fs, KSConConMLDebugFile, EFileWrite );

   315     if( err == KErrNone )

   316         {

   317         // file created, close it

   318         file.Close();

   319         }       

   320     

   321     CleanupStack::PopAndDestroy( &fs );               

   322 #endif

   323     

   324     // initialize buffer

   325     iBuffer = CBufFlat::NewL ( KSConPCConnBufferMaxSize );

   326     

   327     // load handlers

   328     if ( !iPCDHandler )

   329         {

   330         TRAP( ret, LoadPCDDllL() );

   331         if ( ret != KErrNone) 

   332             {

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

   334             User::Leave( ret );

   335             }

   336         }   

   337     

   338     if ( !iCSCHandler )

   339         {

   340         TRAP( ret, LoadCSCDllL() );

   341         if ( ret != KErrNone) 

   342             {

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

   344             User::Leave ( ret );

   345             }

   346         }

   347 

   348     // Load parser

   349     if ( !iConMLHandler )

   350         {

   351         TRAPD( ret, LoadConMLHandlerDllL() );

   352         if ( ret != KErrNone)

   353             {

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

   355             User::Leave ( ret );

   356             }

   357         }

   358 

   359     TRACE_FUNC_EXIT;

   360     }

   361 

   362 // -----------------------------------------------------------------------------

   363 // CSConPCConnSession::ServiceL()

   364 // Gets the client's request

   365 // -----------------------------------------------------------------------------

   366 //

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

   368     {

   369     TRACE_FUNC_ENTRY;

   370     TRAPD(err,DispatchRequestL(aMessage) );

   371     if ( err != KErrNone )

   372         {

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

   374         PanicServer( E_DispatchRequest );

   375         }

   376     TRACE_FUNC_EXIT;

   377     }

   378 

   379 // -----------------------------------------------------------------------------

   380 // CSConPCConnSession::DispatchRequestL()

   381 // Identifies an IPC command from the client 

   382 // -----------------------------------------------------------------------------

   383 //

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

   385     {

   386     TRACE_FUNC_ENTRY;

   387     

   388     TInt ret (KErrNone);

   389         

   390     switch (aMessage.Function())

   391         {

   392         case EPutMessage:

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

   394             ret = HandlePutMessageL();

   395             break;

   396         

   397         case EGetMessage:

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

   399             ret = HandleGetMessageL();

   400             break;

   401         

   402         case EResetMessage:

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

   404             ret = HandleResetMessage();

   405             break;

   406             

   407         case EChunkMessage:

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

   409             ret = HandleChunkMessage( aMessage );

   410             break;

   411                         

   412         default:

   413             PanicServer (E_BadRequest);

   414             break;

   415         }

   416 

   417     aMessage.Complete( ret );

   418     TRACE_FUNC_EXIT;

   419     }

   420 

   421 // -----------------------------------------------------------------------------

   422 // CSConPCConnSession::HandlePutMessageL()

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

   424 // -----------------------------------------------------------------------------

   425 //

   426 TInt CSConPCConnSession::HandlePutMessageL()

   427     {

   428     TRACE_FUNC_ENTRY;

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

   430     TInt ret ( KErrNone );

   431         

   432     if ( !iPCDHandler )

   433         {

   434         TRAP( ret, LoadPCDDllL() );

   435         if ( ret != KErrNone) 

   436             {

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

   438             return ( ret );

   439             }

   440         }   

   441         

   442     if ( ! iConMLHandler )

   443         {

   444         TRAP ( ret, LoadConMLHandlerDllL() );

   445         if ( ret != KErrNone )

   446             {

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

   448             return ( ret );

   449             }

   450         }

   451         

   452     TInt length ( 0 );

   453     

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

   455 

   456 

   457     iBuffer->Reset();

   458 

   459     length = buf.ReadInt32L();

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

   461     TPtr8 namePtr = name->Des();

   462     buf.ReadL( namePtr, length);

   463         

   464     length = buf.ReadInt32L();

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

   466     TPtr8 typePtr = type->Des();

   467     buf.ReadL( typePtr, length);

   468    

   469     // WBXML Document

   470     length = buf.ReadInt32L();

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

   472     TPtr8 dataPtr = data->Des();

   473     

   474     buf.ReadL( dataPtr, length );

   475     iBuffer->ResizeL( length );

   476     iBuffer->Write( 0, dataPtr );

   477             

   478     buf.Close();

   479     

   480 #ifdef DEBUG_XML

   481     RFs fs;

   482     User::LeaveIfError( fs.Connect() );

   483     CleanupClosePushL( fs );

   484 

   485     RFile file;

   486     if ( file.Open( fs, KSConConMLDebugFile, EFileWrite ) == KErrNone )

   487         {

   488         RFileWriteStream fws;

   489         TInt fileSize;

   490         file.Size( fileSize );

   491         

   492         TTime now;

   493         now.HomeTime();

   494         TDateTime time = now.DateTime();

   495         TBuf8<16> timeLine;

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

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

   498         

   499         fws.Attach( file, fileSize );

   500         fws.PushL();

   501         fws.WriteL( timeLine );

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

   503         fws.WriteL( KPutMessage );

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

   505         TRAP_IGNORE( fws.CommitL() );

   506         fws.Close();

   507  

   508         CleanupStack::PopAndDestroy( &fws );

   509         }

   510     file.Close();   

   511     CleanupStack::PopAndDestroy( &fs );

   512 #endif

   513     

   514     if ( ( typePtr.Compare( KSConPCDWBXMLObjectType ) == KErrNone) || 

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

   516         {

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

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

   519         if ( err != KErrNone )

   520             {

   521             ret = err;

   522             }

   523         if ( ret == KErrNone )

   524             {

   525             // Possible error code returned from PCCS 

   526             ret = iResult;

   527             }

   528         }

   529     else 

   530         {

   531         LOGGER_WRITE( "Object type not regognized " );

   532         ret = KErrNotSupported;

   533         }

   534     CleanupStack::PopAndDestroy( data );

   535     CleanupStack::PopAndDestroy( type );

   536     CleanupStack::PopAndDestroy( name );

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

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

   539     return ret;

   540     }

   541 

   542 // -----------------------------------------------------------------------------

   543 // CSConPCConnSession::HandleGetMessageL()

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

   545 // -----------------------------------------------------------------------------

   546 //

   547 TInt CSConPCConnSession::HandleGetMessageL()

   548     {

   549     TRACE_FUNC_ENTRY;

   550     TInt ret ( KErrNone );

   551     

   552     if ( !iCSCHandler )

   553         {

   554         TRAP( ret, LoadCSCDllL() );

   555         if ( ret != KErrNone) 

   556             {

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

   558             return ret;

   559             }

   560         }

   561 

   562     TInt32 length ( 0 );

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

   564     iBuffer->Reset();

   565     

   566     length = readBuf.ReadInt32L();

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

   568     TPtr8 namePtr8 = name->Des();

   569     readBuf.ReadL( namePtr8, length);

   570     namePtr8.SetLength( length );

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

   572     

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

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

   575     TPtrC namePtr;

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

   577     

   578     length = readBuf.ReadInt32L();

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

   580     TPtr8 typePtr = type->Des();

   581     readBuf.ReadL( typePtr, length);

   582     

   583     readBuf.Close();

   584         

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

   586         {

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

   588         

   589 #ifdef DEBUG_XML

   590         RFs fs;

   591         User::LeaveIfError(fs.Connect());

   592         CleanupClosePushL(fs);

   593 

   594         RFile file;

   595         if ( file.Open(fs, KSConConMLDebugFile, EFileWrite ) == KErrNone )

   596             {

   597             RFileWriteStream fws;

   598             TInt fileSize;

   599             file.Size ( fileSize );

   600             TTime now;

   601             now.HomeTime();

   602             TDateTime time = now.DateTime();

   603             TBuf8<16> timeLine;

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

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

   606 

   607             fws.Attach ( file, fileSize);

   608             fws.PushL();

   609             fws.WriteL( timeLine );

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

   611             fws.WriteL( KGetMessage );

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

   613             TRAP_IGNORE( fws.CommitL() );

   614             fws.Close();

   615 

   616             CleanupStack::PopAndDestroy( &fws );

   617             }

   618         file.Close();

   619         CleanupStack::PopAndDestroy( &fs );

   620 #endif

   621 

   622         }

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

   624         {

   625         ret = HandleWBXMLGetRequestL( namePtr );

   626         }

   627     else

   628         {

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

   630         ret = KErrNotSupported;

   631         }

   632     

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

   634     

   635     if ( ret != KErrNone )

   636         {

   637         return ret;

   638         }

   639     

   640     length = iBuffer->Size();

   641     

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

   643         {

   644         // need to resize chunk

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

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

   647         if ( err )

   648             {

   649             iBuffer->Reset();

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

   651             return err;

   652             }

   653         }

   654     

   655     // copy data to chunk

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

   657     

   658     if ( length > 0 )

   659         {

   660         writeBuf.WriteInt32L( length );

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

   662         writeBuf.CommitL();

   663         }

   664     else 

   665         {

   666         writeBuf.WriteInt32L( 0 );

   667         }

   668     writeBuf.CommitL();

   669     writeBuf.Close();

   670     iBuffer->Reset();

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

   672     return ( ret );

   673     }

   674 

   675 // -----------------------------------------------------------------------------

   676 // CSConPCConnSession::HandleWBXMLGetRequestL()

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

   678 // -----------------------------------------------------------------------------

   679 //

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

   681     {

   682     TRACE_FUNC_ENTRY;

   683     TInt ret(KErrNone);

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

   685         {

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

   687         LOGGER_WRITE( "ConML GetMetadataRequest" );

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

   689         

   690         TSConMethodName method ( EGetMetadata );

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

   692         

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

   694             {

   695             User::Leave( KErrTooBig );

   696             }

   697         task->iGetMetadataParams->iFilename = filename;

   698         

   699         ret = iPCDHandler->PutTaskL( task );

   700         CleanupStack::Pop( task );

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

   702         }

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

   704         {

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

   706         TRACE_FUNC_RET( KErrArgument );

   707         return KErrArgument;

   708         }

   709     

   710 	// Get reply

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

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

   713     CleanupStack::PushL( reply );

   714     

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

   716     CleanupStack::PushL( content );

   717     

   718     AppendStatusL( content, reply );

   719     ret = iConMLHandler->GenerateDocument( content );

   720     

   721     CleanupStack::PopAndDestroy( content );

   722     CleanupStack::PopAndDestroy( reply );

   723      

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

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

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

   727     iBuffer->Write( 0, ptr );

   728 

   729 #ifdef DEBUG_XML

   730     RFile file;

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

   732         {

   733         RFileWriteStream fws;   

   734         TInt fileSize;

   735         file.Size ( fileSize );

   736         fws.Attach ( file, fileSize);

   737         fws.PushL();

   738         TTime now;

   739         now.HomeTime();

   740         TDateTime time = now.DateTime();

   741         TBuf8<16> timeLine;

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

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

   744 

   745         fws.WriteL( timeLine );

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

   747         fws.WriteL( KGetMessage );

   748         fws.WriteL(KXmlBegin);

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

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

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

   752         TRAP_IGNORE( fws.CommitL() );

   753         fws.Close();

   754         CleanupStack::PopAndDestroy( &fws );

   755         }

   756         

   757     file.Close();

   758 #endif

   759     TRACE_FUNC_RET(ret);

   760     return ret;

   761     }

   762 

   763 // -----------------------------------------------------------------------------

   764 // CSConPCConnSession::HandleResetMessage()

   765 // Resets the PCCS service

   766 // -----------------------------------------------------------------------------

   767 //

   768 TInt CSConPCConnSession::HandleResetMessage()   

   769     {

   770     TRACE_FUNC_ENTRY;

   771     TInt ret ( KErrNone );

   772     

   773     // reset PCD

   774     if ( iPCDHandler )

   775         {

   776         iPCDHandler->ResetPCD();

   777         }

   778         

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

   780     return ret;

   781     }

   782     

   783 // -----------------------------------------------------------------------------

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

   785 // Receives the chunk handle from the client

   786 // -----------------------------------------------------------------------------

   787 //

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

   789     {

   790     TRACE_FUNC_ENTRY;

   791     TInt ret ( KErrNone );

   792     

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

   794         

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

   796     return ret;

   797     }

   798 

   799 // -----------------------------------------------------------------------------

   800 // CSConPCConnSession::LoadPCDDllL()

   801 // Loads the PCCS service

   802 // -----------------------------------------------------------------------------

   803 //

   804 void CSConPCConnSession::LoadPCDDllL()

   805     {

   806     TRACE_FUNC_ENTRY;

   807     

   808     // Dynamically load DLL

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

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

   811         {

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

   813         iPCDlib.Close();

   814         User::Leave( KErrNotFound );

   815         }   

   816     TSConCreateCSConPCDFunc CreateCSConPCDL =

   817     (TSConCreateCSConPCDFunc)iPCDlib.Lookup(1);

   818     

   819     iPCDHandler = (CSConPCD*)CreateCSConPCDL();

   820     TRACE_FUNC_EXIT;

   821     }

   822 

   823 // -----------------------------------------------------------------------------

   824 // CSConPCConnSession::LoadCSCDllL()

   825 // Loads the CSC service

   826 // -----------------------------------------------------------------------------

   827 //

   828 void CSConPCConnSession::LoadCSCDllL()

   829     {

   830     TRACE_FUNC_ENTRY;

   831     // Dynamically load DLL

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

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

   834         {

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

   836         iCSClib.Close();

   837         User::Leave( KErrNotFound );

   838         }   

   839     TSConCreateCSConCSCFunc CreateCSConCSCL = 

   840     (TSConCreateCSConCSCFunc)iCSClib.Lookup(1);

   841     

   842     iCSCHandler = (CSConCSC*)CreateCSConCSCL();

   843     TRACE_FUNC_EXIT;

   844     }

   845 

   846 // -----------------------------------------------------------------------------

   847 // CSConPCConnSession::LoadConMLHandlerDllL()

   848 // Loads the ConML handler

   849 // -----------------------------------------------------------------------------

   850 //

   851 void CSConPCConnSession::LoadConMLHandlerDllL()

   852     {

   853     TRACE_FUNC_ENTRY;

   854     // Dynamically load DLL

   855     User::LeaveIfError( iConMLHandlerLib.Load( KSConConMLHandlerLibName ) );

   856     if ( iConMLHandlerLib.Type()[1] != KSConConMLHandlerUid )

   857         {

   858         LOGGER_WRITE( "CSConPCConnSession::LoadConMLHandlerDllL() : KSConConMLHandlerUidValue incorrect" );

   859         iConMLHandlerLib.Close();

   860         User::Leave( KErrNotFound );

   861         }

   862     TSConCreateCSConConMLHandlerFunc CreateCSConConMLHandlerL = 

   863     (TSConCreateCSConConMLHandlerFunc)iConMLHandlerLib.Lookup(1);

   864     

   865     iConMLHandler = (CSConConMLHandler*)CreateCSConConMLHandlerL();

   866     TRACE_FUNC_EXIT;

   867     }

   868 

   869 // -----------------------------------------------------------------------------

   870 // CSConPCConnSession::ConMLL()

   871 // Callback function for ConML handler - parsed data processing starts

   872 // -----------------------------------------------------------------------------

   873 //

   874 void CSConPCConnSession::ConMLL( ConML_ConMLPtr_t aContent )

   875     {

   876     TRACE_FUNC_ENTRY;

   877     TInt ret ( KErrNone );

   878     

   879 #ifdef DEBUG_XML

   880     iConMLHandler->GenerateDocument( aContent );

   881     RFs fs;

   882     User::LeaveIfError(fs.Connect());

   883     CleanupClosePushL(fs);

   884     RFile file;

   885     

   886     if ( file.Open(fs, KSConConMLDebugFile, EFileWrite) == KErrNone )

   887         {

   888         RFileWriteStream fws;

   889         TInt fileSize;

   890         file.Size( fileSize );

   891         fws.Attach ( file, fileSize );

   892         fws.PushL();

   893         

   894         TTime now;

   895         now.HomeTime();

   896         TDateTime time = now.DateTime();

   897         TBuf8<16> timeLine;

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

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

   900         

   901         fws.WriteL( timeLine );

   902         _LIT8( KPutMessage, "__________PUT-MESSAGE" );

   903         fws.WriteL( KPutMessage );

   904         fws.WriteL( KXmlBegin );

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

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

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

   908         TRAP_IGNORE( fws.CommitL() );

   909         fws.Close();

   910         CleanupStack::PopAndDestroy( &fws );

   911         }

   912     file.Close();

   913     CleanupStack::PopAndDestroy( &fs );

   914     

   915 #endif

   916 

   917 

   918     if ( aContent )

   919         {

   920         if ( aContent->execute )

   921             {

   922             ret = OptionsFromExecuteL( aContent->execute );

   923             }

   924         else if ( aContent->cancel )

   925             {

   926             ret = TaskCancelL( aContent->cancel );

   927             }

   928         else if ( aContent->getStatus )

   929             {

   930             ret = TaskGetStatusL ( aContent->getStatus );

   931             }

   932         else 

   933             {

   934             LOGGER_WRITE( "CSConPCConnSession::ConML() : No appropriate content in ConML -element " );

   935             ret = KErrArgument;

   936             }

   937         }

   938     else 

   939         {

   940         ret  = KErrArgument;

   941         }

   942     

   943     // store result for later use

   944     iResult = ret;

   945     TRACE_FUNC_EXIT;

   946     }

   947 

   948 // -----------------------------------------------------------------------------

   949 // CSConPCConnSession::OptionsFromExecuteL()

   950 // Handles data of an execute -element

   951 // -----------------------------------------------------------------------------

   952 //

   953 TInt CSConPCConnSession::OptionsFromExecuteL(ConML_ExecutePtr_t aContent )

   954     {

   955     TRACE_FUNC_ENTRY;

   956     

   957     TInt ret ( KErrNone );

   958     if ( aContent->updateDeviceInfo )

   959         {

   960         ret = TaskUpdateDeviceInfoL( aContent->updateDeviceInfo);

   961         }

   962     else if ( aContent->listInstalledApps )

   963         {

   964         ret = TaskListInstalledAppsL( aContent->listInstalledApps);

   965         }

   966     else if ( aContent->install )

   967         {

   968         ret = TaskInstallL( aContent->install );

   969         }       

   970     else if ( aContent->unInstall )

   971         {

   972         ret = TaskUnInstallL( aContent->unInstall );

   973         }

   974     else if ( aContent->listDataOwners )

   975         {

   976         ret = TaskListDataOwnersL();

   977         }

   978     else if ( aContent->setBurMode )    

   979         {

   980         ret = TaskSetBURModeL( aContent->setBurMode );

   981         }

   982     else if ( aContent->getDataSize )

   983         {

   984         ret = TaskGetDataSizeL( aContent->getDataSize );

   985         }

   986     else if ( aContent->requestData )

   987         {

   988         ret = TaskRequestDataL( aContent->requestData );

   989         }

   990     else if ( aContent->listPublicFiles )

   991         {

   992         ret = TaskListPublicFilesL( aContent->listPublicFiles );

   993         }

   994     else if ( aContent->reboot )

   995         {

   996         ret = TaskRebootL();

   997         }

   998     else if ( aContent->getDataOwnerStatus )

   999         {

  1000         ret = TaskGetDataOwnerStatusL( aContent->getDataOwnerStatus );      

  1001         }

  1002     else if ( aContent->supplyData )

  1003         {

  1004         ret = TaskSupplyDataL( aContent->supplyData );

  1005         }

  1006     else if ( aContent->getMetadata )

  1007         {

  1008         ret = TaskGetMetadataL( aContent->getMetadata );

  1009         }

  1010     else 

  1011         {

  1012         LOGGER_WRITE( "CSConPCConnSession::OptionsFromExecute() : No content " );

  1013         ret = KErrNotSupported;

  1014         }

  1015     LOGGER_WRITE_1( "CSConPCConnSession::OptionsFromExecute() : returned %d", ret );    

  1016     return ret;

  1017     }

  1018 

  1019 // -----------------------------------------------------------------------------

  1020 // CSConPCConnSession::TaskCancelL(ConML_CancelPtr_t aContent)

  1021 // Sends a Cancel -task to PCCS service

  1022 // -----------------------------------------------------------------------------

  1023 //

  1024 TInt CSConPCConnSession::TaskCancelL( ConML_CancelPtr_t aContent )

  1025     {

  1026     TRACE_FUNC_ENTRY;

  1027     TInt ret ( KErrNone );

  1028     TSConMethodName method ( ECancel );

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

  1030     if ( aContent->all )

  1031         {

  1032         task->iCancelTaskAll = ETrue;

  1033         }

  1034     if ( aContent->id )

  1035         {

  1036         task->iCancelTaskId = ( DesToInt( aContent->id->Data() ));

  1037         }

  1038     ret = iPCDHandler->PutTaskL( task );

  1039     CleanupStack::Pop( task );

  1040     LOGGER_WRITE_1( "CSConPCConnSession::TaskCancelL() : returned %d", ret );    

  1041     return ret;

  1042     }

  1043 

  1044 

  1045 // -----------------------------------------------------------------------------

  1046 // CSConPCConnSession::TaskGetStatusL()

  1047 // Sends a Get Status -task to PCCS service

  1048 // -----------------------------------------------------------------------------

  1049 //

  1050 TInt CSConPCConnSession::TaskGetStatusL( ConML_GetStatusPtr_t aContent )

  1051     {

  1052     TRACE_FUNC_ENTRY;

  1053     TInt ret ( KErrNone );

  1054     TSConMethodName method ( EGetStatus );

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

  1056     if ( aContent->all )

  1057         {

  1058         task->iGetStatusParams->iAll = ETrue;

  1059         }

  1060     if ( aContent->id)

  1061         {

  1062         task->iGetStatusParams->iTaskId = ( DesToInt( aContent->id->Data() ));

  1063         }

  1064     ret = iPCDHandler->PutTaskL( task );

  1065     CleanupStack::Pop( task );

  1066     LOGGER_WRITE_1( "CSConPCConnSession::TaskGetStatusL() : returned %d", ret );    

  1067     return ret;

  1068     }

  1069     

  1070 // -----------------------------------------------------------------------------

  1071 // CSConPCConnSession::TaskInstallL()

  1072 // Sends an Install -task to PCCS service

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

  1074 //

  1075 TInt CSConPCConnSession::TaskInstallL( ConML_InstallPtr_t aContent )

  1076     {

  1077     TRACE_FUNC_ENTRY;

  1078     TInt ret ( KErrNone );

  1079     TSConMethodName method ( EInstall );

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

  1081     task->iInstallParams->iMode = EUnknown;

  1082     if ( aContent->name )

  1083         {

  1084         // Unicode conversion from 8-bit to 16-bit

  1085         CnvUtfConverter::ConvertToUnicodeFromUtf8(task->iInstallParams->iPath, 

  1086                                                     aContent->name->Data());    

  1087         }

  1088     if ( aContent->instParams )

  1089         {

  1090         if ( aContent->instParams->param )

  1091             {

  1092             for ( ConML_ParamListPtr_t p = aContent->instParams->param; 

  1093                   p && p->data; p = p->next)

  1094                 {

  1095                 LOGGER_WRITE( "CSConPCConnSession::TaskInstallL() : Parameters found " );

  1096                 if ( p->data->name )

  1097                     {

  1098                     LOGGER_WRITE( "CSConPCConnSession::TaskInstallL() : name param found " );

  1099                     TPtrC8 silent(KParamNameSilent);

  1100                     

  1101                     TInt comp = Mem::Compare((TUint8*)p->data->name->content, (TInt)p->data->name->length, silent.Ptr(), silent.Length());

  1102                     if( comp == 0)

  1103                         {

  1104                         // "Silent"-param found

  1105                         LOGGER_WRITE( "CSConPCConnSession::TaskInstallL() : Silent-param found " );

  1106                         if ( p->data->value )

  1107                             {

  1108                             TPtrC8 dataValue((TUint8*)p->data->value->content, (TInt)p->data->value->length);

  1109                             TInt value = DesToInt( dataValue );

  1110                             if (value == 1)

  1111                                 {

  1112                                 LOGGER_WRITE( "CSConPCConnSession::TaskInstallL() : ESilentInstall " );

  1113                                 task->iInstallParams->iMode = ESilentInstall;

  1114                                 }

  1115                             else if( value == 0 )

  1116                                 {

  1117                                 LOGGER_WRITE( "CSConPCConnSession::TaskInstallL() : EUnsilentInstall " );

  1118                                 task->iInstallParams->iMode = EUnsilentInstall;

  1119                                 }

  1120                             }

  1121                         }

  1122                     }

  1123                 }

  1124             }

  1125         }

  1126     ret = iPCDHandler->PutTaskL( task );

  1127     CleanupStack::Pop( task );

  1128     LOGGER_WRITE_1( "CSConPCConnSession::TaskInstallL() : returned %d", ret );    

  1129     return ret;

  1130     }

  1131     

  1132 // -----------------------------------------------------------------------------

  1133 // CSConPCConnSession::TaskUnInstallL()

  1134 // Sends an Uninstall -task to PCCS service