1 /*

     2 * Copyright (c) 2002-2006 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: Classes for IM server and Conn.

    15 *

    16 *

    17 */

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include    <e32math.h>

    23 #include    <ecom/ecom.h>

    24 #include    "impsserver.h"

    25 #include    "impssession.h"

    26 #include    "impssubsession.h"

    27 #include    "impsfields.h"

    28 #include    "impsutils.h"

    29 #include    "impserrors.h"

    30 #include    "impstimer.h"

    31 #include    "impsservices.h"

    32 #include    "impscommonenums.h"

    33 #include    "impssdatautils.h"

    34 #include    "impsmessageinterpreterapi.h"

    35 #include    "ImpsVariantAPI.h"

    36 #include    "impscspsession.h"

    37 #include    "impsorphans.h"

    38 #include    "impstoffobserver.h"

    39 #include    "WVEngineInternalCRKeys.h"

    40 

    41 

    42 #include    "impsserversecuritypolicy.h"

    43 

    44 

    45 // MACROS

    46 #ifndef _DEBUG

    47 #define _NO_IMPS_LOGGING_

    48 #endif

    49 

    50 // CONSTANTS

    51 // Shutdown idle wait time in seconds

    52 const TInt KImpsShutdownTime = 0;

    53 // Overhead estimate for XML message : total - transaction content

    54 const TInt KImpsBufOverhead = 100;

    55 

    56 // ================= MEMBER FUNCTIONS =======================

    57 

    58 void CImpsScheduler::Error( TInt anError ) const

    59     {

    60     // This is just for compiler to avoid warning

    61     TInt err = anError;

    62 #ifndef _NO_IMPS_LOGGING_

    63     CImpsClientLogger::Log( _L( "Scheduler: error=%d" ), anError );

    64 #endif

    65     // This is just for another compiler to avoid warning

    66     anError = err;

    67     }

    68 

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

    70 // CLASS CImpsConn

    71 // -----------------------------------------------------------------------------

    72 CImpsConn::CImpsConn( MImpsCSPSession* aSess ) :

    73         iSess( aSess ), iRemover( NULL )

    74     {}

    75 

    76 CImpsConn::~CImpsConn()

    77     {

    78 

    79     }   //lint !e1540 iSess freed in Destroy

    80 

    81 // Two-phased constructor.

    82 CImpsConn* CImpsConn::NewL( MImpsCSPSession* aSess, CImpsServer& aServer )

    83     {

    84     CImpsConn* self = new ( ELeave ) CImpsConn( aSess );

    85     CleanupStack::PushL( self );

    86     self->ConstructL( aServer );

    87     CleanupStack::Pop();

    88     return self;

    89     }

    90 

    91 // Two-phased constructor.

    92 // It creates an active object to destroy CSP session asynchronously later.

    93 // It's better to create it now to avoid OOM errors in CSP closing.

    94 void CImpsConn::ConstructL( CImpsServer& aServer )

    95     {

    96     iRemover = new ( ELeave ) CImpsCSPDestroyer(

    97         aServer, *iSess, CActive::EPriorityUserInput + 1 );

    98     }

    99 

   100 // -----------------------------------------------------------------------------

   101 // CImpsConn::Destroy

   102 // -----------------------------------------------------------------------------

   103 void CImpsConn::Destroy()

   104     {

   105     iRemover->Cancel();

   106     delete iRemover;

   107     iSess->Destroy();

   108     delete ( CImpsCSPSession* )iSess;

   109     iSess = NULL;

   110     iLink.Deque();

   111     delete this;

   112     }

   113 

   114 // -----------------------------------------------------------------------------

   115 // CImpsConn::Sess

   116 // -----------------------------------------------------------------------------

   117 MImpsCSPSession* CImpsConn::Sess()

   118     {

   119     return iSess;

   120     }

   121 

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

   123 // CImpsConn::DeleteCSPAsynch

   124 // -----------------------------------------------------------------------------

   125 void CImpsConn::DeleteCSPAsynch()

   126     {

   127     // iRemover cannot be NULL since it's created in contructor

   128     if ( iRemover->IsActive() )

   129         {

   130         // asynchronous request already runnig, nothing to do

   131         return;

   132         }

   133     iRemover->DeleteCSPAsynch( );

   134     }

   135 

   136 // -----------------------------------------------------------------------------

   137 // CImpsConn::MatchCSP

   138 // -----------------------------------------------------------------------------

   139 TBool CImpsConn::MatchCSP( TImpsSessIdent aCSP )

   140     {

   141     if ( ( aCSP.UserId().Compare( iSess->UserId() ) ) ||

   142          ( aCSP.SAP().Compare( iSess->SAP() ) ) )

   143         // Notice: no need for this

   144         // ( aCSP.SID().Length() && aCSP.SID().Compare( iSess->SID() )))

   145         {

   146         return EFalse;

   147         }

   148     return ETrue;

   149     }

   150 

   151 

   152 // -----------------------------------------------------------------------------

   153 // CLASS CImpsCSPDestroyer

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

   155 CImpsCSPDestroyer::CImpsCSPDestroyer(

   156     CImpsServer& aServer, MImpsCSPSession& aSess, TInt aPriority )

   157         : CActive( aPriority ),

   158         iServer( aServer ),

   159         iSess( aSess ),

   160         iCanceled ( EFalse )

   161     {

   162     // Add this to the scheduler

   163     CActiveScheduler::Add( this );

   164     }

   165 

   166 CImpsCSPDestroyer::~CImpsCSPDestroyer()

   167     {

   168     Cancel();

   169     }

   170 

   171 // -----------------------------------------------------------------------------

   172 // CImpsCSPDestroyer::DeleteCSPAsynch

   173 // -----------------------------------------------------------------------------

   174 void CImpsCSPDestroyer::DeleteCSPAsynch(  )

   175     {

   176 #ifndef _NO_IMPS_LOGGING_

   177     CImpsClientLogger::Log( _L( "CImpsCSPDestroyer: DeleteCSPAsynch" ) );

   178 #endif

   179     // This yields the control to the server thread active scheduler

   180     if ( !IsActive() )

   181         {

   182         iStatus = KRequestPending;

   183         SetActive();

   184         iCanceled = EFalse;

   185         TRequestStatus* s = &iStatus;

   186         User::RequestComplete( s, KErrNone );

   187         }

   188     }

   189 

   190 // -----------------------------------------------------------------------------

   191 // CImpsCSPDestroyer::DoCancel

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

   193 void CImpsCSPDestroyer::DoCancel()

   194     {

   195     iCanceled = ETrue;

   196     }

   197 

   198 // -----------------------------------------------------------------------------

   199 // CImpsCSPDestroyer::RunL

   200 // -----------------------------------------------------------------------------

   201 void CImpsCSPDestroyer::RunL()

   202     {

   203 #ifndef _NO_IMPS_LOGGING_

   204     CImpsClientLogger::Log( _L( "CImpsCSPDestroyer: RunL" ) );

   205 #endif

   206     if ( iCanceled || iStatus.Int() != KErrNone )

   207         {

   208         return;

   209         }

   210     // Trigger a server thread to send a queued message

   211     iServer.DeleteCSP( &iSess );

   212     // It is extremely important that after the previous call this

   213     // method does nothing since DeleteCSP actully deletes the

   214     // current entity if this class!

   215 #ifndef _NO_IMPS_LOGGING_

   216     CImpsClientLogger::Log( _L( "CImpsCSPDestroyer: RunL ends" ) );

   217 #endif

   218     }

   219 

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

   221 // CLASS CImpsServer

   222 // -----------------------------------------------------------------------------

   223 CImpsServer::CImpsServer()

   224         : CPolicyServer( EPriorityUserInput /*EPriorityHigh*/, KImpsServerPolicy ),

   225         iFs(),

   226         iSettings( ),

   227         iConAllowed( ETrue ),

   228         iCSPVersion( EImpsCspVersion11 ),

   229         iOperation( EImpsSrvNone ),

   230         iOrphans( NULL ),

   231         iCSPList( _FOFF( CImpsConn, iLink ) ), //lint !e413,

   232         iObserver( NULL ),

   233         iExpiryInterval( 0 )

   234     {

   235     }

   236 

   237 // Create and start a new server.

   238 

   239 CImpsServer* CImpsServer::New()

   240     {

   241 #ifndef _NO_IMPS_LOGGING_

   242     CImpsClientLogger::Log( _L( "Server: rel200614.4+" ) );

   243 #endif

   244 

   245     CImpsServer* server = new CImpsServer();

   246     if ( server )

   247         {

   248         if ( server->Start( KImpsServerName ) != KErrNone )

   249             {

   250             delete server;

   251             server = NULL;

   252             }

   253         }

   254 

   255 #ifdef _DEBUG

   256     if ( server && server->iFs.Connect() )

   257         {

   258         delete server;

   259         server = NULL;

   260         }

   261 #endif // _DEBUG               

   262 

   263     return server;

   264     }

   265 

   266 CImpsServer::~CImpsServer()

   267     {

   268     // deallocate all memory

   269 

   270     delete iSnd;

   271     delete iShutTimer;

   272     delete iExpiryTimer;

   273 

   274     delete iContainerIndex;

   275     delete iVariant;

   276     delete iOrphans;

   277     delete iObserver;

   278 

   279 #ifdef _DEBUG

   280     // close file session

   281     iFs.Close();

   282 #endif // _DEBUG      

   283     }

   284 

   285 // -----------------------------------------------------------------------------

   286 // CImpsServer::ConstructL()

   287 // -----------------------------------------------------------------------------

   288 void CImpsServer::ConstructL()

   289     {

   290 #ifndef _NO_IMPS_LOGGING_

   291     CImpsClientLogger::Log( _L( "Server:ConstructL begins" ) );

   292 #endif

   293 

   294     iContainerIndex = CObjectConIx::NewL();

   295 

   296     // Read static settings, use defaults if ini file not exist

   297     iSettings.ReadStaticSettings();

   298 #ifdef _DEBUG

   299     TInt errx = KErrNone;

   300     TRAP( errx, iSettings.ReadIniFileL( iFs ) );

   301 #endif

   302 

   303     iVariant = CImpsVariant::NewLC( );

   304     CleanupStack::Pop( ); // >> iVariant

   305 

   306     iSnd = CImpsFields::NewL();

   307     iShutTimer = new ( ELeave ) CImpsShutdownTimer( *this,

   308                                                     CActive::EPriorityUserInput + 1 );

   309     iExpiryTimer = new ( ELeave ) CImpsExpiryTimer( *this,

   310                                                     EImpsEventAll, CActive::EPriorityStandard );

   311 

   312     // Get the supported WV CSP version for all sessions

   313     GetCSPVersion();

   314 

   315     // local variation

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

   317     if ( iVariant->IsFeatureSupportedL( EImLauncher ) )

   318         {

   319         iOrphans = CImpsOrphans::NewL();

   320         }

   321     //----------------------------

   322 

   323     // Check terminal off line state

   324     iObserver = CImpsTOffObserver::NewL( *this );

   325     if ( !iObserver->CheckConnAllowed() )

   326         {

   327         SetConnAllowed( EFalse );

   328         }

   329 

   330 #ifndef _NO_IMPS_LOGGING_

   331     CImpsClientLogger::Log( _L( "Server:ConstructL ends" ) );

   332 #endif

   333 

   334     }

   335 

   336 // -----------------------------------------------------------------------------

   337 // CImpsServer::NewSessionL()

   338 // -----------------------------------------------------------------------------

   339 CSession2* CImpsServer::NewSessionL(

   340     const TVersion &aVersion, const RMessage2& aMessage ) const

   341     {

   342     // check that we're the right version

   343     TVersion v( KImpsServMajorVersionNumber,

   344                 KImpsServMinorVersionNumber,

   345                 KImpsServBuildVersionNumber );

   346     if ( !User::QueryVersionSupported( v, aVersion ) )

   347         {

   348         User::Leave( KErrNotSupported );

   349         }

   350 

   351     if ( iOperation == EImpsSrvShuttingDown )

   352         {

   353 #ifndef _NO_IMPS_LOGGING_

   354         CImpsClientLogger::Log( _L( "Server: NewSessionL in shut down ***" ) );

   355 #endif

   356         User::Leave( KImpsErrorShuttingDown );

   357         }

   358 

   359     StopTimer();

   360 

   361 #ifndef _NO_IMPS_LOGGING_

   362     CImpsClientLogger::Log( _L( "Server: NewSessionL ends" ) );

   363 #endif

   364 

   365     // make a new session

   366     RMessage2 msg = aMessage;

   367     return new( ELeave ) CImpsSession( msg );

   368     }

   369 

   370 // -----------------------------------------------------------------------------

   371 // CImpsServer::CloseSession()

   372 // -----------------------------------------------------------------------------

   373 void CImpsServer::CloseSession( TImpsSessIdent aCSP, TBool aComplete )

   374     {

   375 

   376 #ifndef _NO_IMPS_LOGGING_

   377     TInt temp1 = NbrSessions( ETrue );

   378     TInt temp2 = NbrSessions( EFalse );

   379     CImpsClientLogger::Log( _L( "Server: CloseSession nbrses=%d-%d aComplete=%d" ), temp1, temp2, aComplete );

   380 #endif

   381 

   382     // CServer2 calls CImpsSession's desctrutor if its consctrutor fails

   383     // but in that case NbrSessions() method does not see the failed entity.

   384     // Thus in case of failed session creation the limit is 0, otherwise 1,

   385     // i.e. the last client session to be closed starts the shut down timer.

   386     TInt limit = aComplete ? 1 : 0;

   387     MImpsCSPSession* ses = GetCSP( aCSP, ETrue );

   388     if ( !ses )

   389         {

   390         // If the last client session and no CSP sessions

   391         // then start final count down

   392         if ( NbrSessions( EFalse ) <= limit )

   393             {

   394             // There is nobody listening to expiry events

   395             iExpiryTimer->Stop( );

   396             if ( !NbrCSPs() )

   397                 {

   398                 // start the final count down

   399                 iOperation = EImpsSrvFinish;

   400                 iShutTimer->Start( KImpsShutdownTime );

   401                 }

   402             }

   403         return;

   404         }

   405 

   406     // This is very last client session for the CSP connection.

   407     // Disconnect CSP session on behalf of applications in this case.

   408     TInt myCount = NbrSessions( EFalse, aCSP );

   409     if ( myCount == 1 )

   410         {

   411         TRAPD( errx, ( void )ses->LogoutL( EFalse ) );

   412         if ( !errx )

   413             {

   414             return;

   415             }

   416         }

   417 

   418     }

   419 

   420 // -----------------------------------------------------------------------------

   421 // CImpsServer::ThreadStart()

   422 // -----------------------------------------------------------------------------

   423 EXPORT_C TInt CImpsServer::ThreadStart( TImpsSignal& aSignal )

   424     {

   425     // naming the server thread after the server helps to debug panics

   426     RThread().RenameMe( KImpsServerExe );

   427 

   428     TInt err = KErrNone;

   429 #ifndef _NO_IMPS_LOGGING_

   430     CImpsClientLogger::Log( _L( "Server: ThreadStart begins" ) );

   431     CImpsClientLogger::Log( _L( "Server: aSignal.iRate = %x" ), aSignal.iRate );

   432 #endif

   433     __UHEAP_MARK;

   434 

   435     CTrapCleanup* cleanup = NULL;

   436     CImpsScheduler* scheduler = NULL;

   437     CImpsServer* server = NULL;

   438     cleanup = CTrapCleanup::New();

   439 

   440 #ifdef _DEBUG

   441     TInt rate = aSignal.iRate;

   442     if ( rate > 0 )

   443         {

   444         TRAP( err, __UHEAP_SETFAIL( RHeap::EFailNext, rate ) );

   445         }

   446 #endif

   447 

   448     scheduler = new CImpsScheduler;

   449 

   450     if ( cleanup && scheduler )

   451         {

   452         CImpsScheduler::Install( scheduler );

   453         server = CImpsServer::New();      // adds server in scheduler

   454         }

   455 

   456     if ( !cleanup || !scheduler || !server )

   457         {

   458         err = KErrNoMemory;

   459         }

   460     else

   461         {

   462         TRAP( err, server->ConstructL() );

   463         }

   464 

   465     if ( err )

   466         {

   467 #ifndef _NO_IMPS_LOGGING_

   468         CImpsClientLogger::Log( _L( "Server:ConstructL failed = %d" ), err );

   469 #endif

   470         delete server;      //lint !e644 initialization ok

   471         delete cleanup;     //lint !e644 initialization ok

   472         delete scheduler;   //lint !e644 initialization ok

   473         }

   474 

   475     // signal that we've started

   476     RProcess::Rendezvous( err );

   477 

   478     // start fielding requests from clients

   479     if ( err == KErrNone )

   480         {

   481         CImpsScheduler::Start();

   482 

   483         // comes here when server shuts down

   484 

   485 #ifndef _NO_IMPS_LOGGING_

   486         CImpsClientLogger::Log( _L( "Server: Scheduler is STOPPED" ) );

   487 #endif

   488         delete server;      //lint !e644 initialization ok

   489         delete scheduler;   //lint !e644 initialization ok

   490         delete cleanup;     //lint !e644 initialization ok

   491         }

   492 

   493 #ifdef _DEBUG

   494     if ( rate > 0 )

   495         {

   496         TInt err2 = KErrNone;

   497         TRAP( err2, __UHEAP_SETFAIL( RHeap::ENone, 0 ) );

   498         }

   499 #ifndef _NO_IMPS_LOGGING_

   500     CImpsClientLogger::Log( _L( "Server: MEM TEST begins" ) );

   501 #endif

   502     __UHEAP_MARKEND;

   503 #ifndef _NO_IMPS_LOGGING_

   504     CImpsClientLogger::Log( _L( "Server: MEM TEST OK" ) );

   505 #endif

   506 #endif

   507 

   508     return( err );

   509     }

   510 

   511 // -----------------------------------------------------------------------------

   512 // CImpsServer::LoginL

   513 // -----------------------------------------------------------------------------

   514 TPtrC CImpsServer::LoginL(

   515     const TDesC& aUser,

   516     const TDesC& aPassword,

   517     const TDesC& aClientId,

   518     const TDesC& aSAP,

   519     TUint32 aAP,

   520     const TDesC& aKey1,

   521     const TDesC& aKey2,

   522     CImpsSubSession* /*aSub*/,

   523     const TTime aLoginExpiry,

   524     TBool aReactive )

   525     {

   526 #ifndef _NO_IMPS_LOGGING_

   527     CImpsClientLogger::Log( _L( "Server: LoginL" ) );

   528 #endif

   529 

   530     if ( iOperation == EImpsSrvShuttingDown )

   531         {

   532         User::Leave( KImpsErrorShuttingDown );

   533         }

   534 

   535     // multi: check if CSP already exists, otherwise create a new CSP session

   536     TImpsSessIdent csp( KNullDesC, aSAP, aUser );

   537     MImpsCSPSession* ses = GetCSP( csp, EFalse );

   538     // multi: Check if another client is logging with this CSP session

   539     if ( ses && ses->IsLogging() )

   540         {

   541 #ifndef _NO_IMPS_LOGGING_

   542         CImpsClientLogger::Log( _L( "Server: CSP is logging ****" ) );

   543 #endif

   544         }

   545     else if ( !ses  )

   546         {

   547         ses = NewCSPL( csp, iCSPVersion );

   548         }

   549 

   550     // Before starting actual transport data transfer we start expiry timer

   551     SetExpiryTimer( 0, ETrue );

   552 

   553     // This leaves if already logged or if performing logging currently

   554     // Certain error types means that CSP sessions is already doing something,

   555     // rest of the error codes means that initialization has been failed and

   556     // thus the entity has to deleted

   557     TPtrC p( KNullDesC );

   558     TRAPD( errx, p.Set( ses->LoginL( aUser, aPassword, aClientId, aSAP, aAP,

   559                                      aKey1, aKey2, aLoginExpiry, aReactive ) ) );

   560     if ( errx )

   561         {

   562         // These are means that CSP entity is running and in use, don't delete it yet.

   563         if ( errx != KErrNotReady && errx != KImpsErrorAlreadyLogged )

   564             {

   565             DeleteCSPAsynch( ses );

   566             }

   567         User::Leave( errx );

   568         }

   569     return p;

   570     }

   571 

   572 // -----------------------------------------------------------------------------

   573 // CImpsServer::LogoutL

   574 // -----------------------------------------------------------------------------

   575 TPtrC CImpsServer::LogoutL(

   576     TBool aCancel,

   577     TImpsSessIdent aCSP )

   578     {

   579 #ifndef _NO_IMPS_LOGGING_

   580     CImpsClientLogger::Log( _L( "Server: LogoutL" ) );

   581 #endif

   582 

   583     // Just leave if other client sessions use still this CSP session

   584     // or if server is shutting down.

   585     // KImpsErrorTerminalOffLine is handled in a special way in a client session class.

   586     // That's because of Logout should not fail if sessions existed.

   587     //

   588     if ( NbrSessions( ETrue, aCSP ) > 1 ||

   589          iOperation == EImpsSrvShuttingDown )

   590         {

   591 #ifndef _NO_IMPS_LOGGING_

   592         CImpsClientLogger::Log( _L( "Server: LogoutL LEAVES 1 KImpsErrorTerminalOffLine  ***" ) );

   593 #endif

   594         User::Leave( KImpsErrorTerminalOffLine );

   595         }

   596 

   597     // Leave also if there is no CSP session or CSP session state is improper

   598     MImpsCSPSession* ses = GetCSP( aCSP, EFalse );

   599     if ( !ses || ( !IsLogged( aCSP, NULL ) && !IsPendingLogin( aCSP ) ) )

   600         {

   601         // The following is not needed:

   602         //   Send error messages for existing requests

   603         //   DiscardRequests( EImpsEventAll, KImpsErrorNotLogged, aCSP );

   604         // This error code is handled in a special way in a sub-session.

   605 #ifndef _NO_IMPS_LOGGING_

   606         CImpsClientLogger::Log( _L( "Server: LogoutL LEAVES 2 KImpsErrorTerminalOffLine  ***" ) );

   607 #endif

   608         User::Leave( KImpsErrorTerminalOffLine );

   609         }

   610 

   611     // Be 100% sure that expiry timer is running

   612     if ( !iExpiryTimer->IsActive() )

   613         {

   614         TInt expiryInterval = iSettings.iAccessExp;

   615         iExpiryTimer->Start( expiryInterval / 2 );

   616         }

   617 

   618     return ses->LogoutL( aCancel );

   619     }

   620 

   621 // -----------------------------------------------------------------------------

   622 // CImpsServer::CirMessageL

   623 // -----------------------------------------------------------------------------

   624 void CImpsServer::CirMessageL(

   625     const TDesC8& aCookie )

   626     {

   627 #ifndef _NO_IMPS_LOGGING_

   628     CImpsClientLogger::Log( _L( "Server: CirMessageL" ) );

   629 #endif

   630 

   631     // Call Session

   632 

   633     // multi: scan all sessions until session cookie matches

   634     TDblQueIter<CImpsConn> rIter( iCSPList );

   635     rIter.SetToFirst();

   636     while ( rIter )

   637         {

   638         CImpsConn* conn = rIter;

   639         rIter++;

   640         TRAPD( errx, conn->Sess()->CirMessageL( aCookie ) );

   641         if ( !errx )

   642             {

   643             // If no error then the CSP session was a right one

   644             break;

   645             }

   646         }

   647     }

   648 

   649 // -----------------------------------------------------------------------------

   650 // CImpsServer::SendDataL

   651 // aSession MUST NOT be NULL

   652 // -----------------------------------------------------------------------------

   653 TPtrC CImpsServer::SendDataL(

   654     CImpsSubSession* aSession, TImpsSessIdent aCSP )

   655     {

   656 

   657 #ifndef _NO_IMPS_LOGGING_

   658     CImpsClientLogger::Log( _L( "Server: SendDataL begins" ) );

   659 #endif

   660 

   661     // multi:

   662     MImpsCSPSession* ses = GetCSP( aCSP, EFalse );

   663     if ( !ses )

   664         {

   665         User::Leave( KImpsErrorNotLogged );

   666         }

   667 

   668     TInt expiryTime = aSession->ExpiryTime();

   669 

   670     // iSnd is for own creations, but this is created in a session

   671     CImpsFields* fields = NULL;

   672     fields = aSession->ImpsFields();

   673 

   674     __ASSERT_DEBUG( fields, User::Panic( KImpsPanicCategory, EImpsCorrupted ) );

   675 

   676     TBool ownerCh( EFalse );

   677     TPtrC ptr = ses->SendDataL( fields, expiryTime, ownerCh );

   678     if ( ownerCh )

   679         {

   680         // Transport adapter is busy so the request is queued and

   681         // data owner is changed

   682         aSession->NewFieldsL();

   683         }

   684     return ptr;

   685     }

   686 

   687 // -----------------------------------------------------------------------------

   688 // CImpsServer::StopTimer

   689 // -----------------------------------------------------------------------------

   690 void CImpsServer::StopTimer() const

   691     {

   692     iShutTimer->Stop();

   693     }

   694 

   695 // -----------------------------------------------------------------------------

   696 // CImpsServer::CheckRequestsL

   697 // -----------------------------------------------------------------------------

   698 void CImpsServer::CheckRequestsL(

   699     CImpsFields* aFields,

   700     TBool& aFound,

   701     TImpsSessIdent aCSP )

   702     {

   703 

   704 #ifndef _NO_IMPS_LOGGING_

   705     CImpsClientLogger::Log( _L( "Server: CheckRequests begins " ) );

   706 #endif

   707 

   708     aFound = EFalse;

   709 

   710     // Block some message types for push message, not MO CSP transactions,

   711     // to speed up performance

   712     // Notice: update list as needed

   713     TInt messageType = aFields->MessageType();

   714     if ( messageType == EImpsNewMessage ||

   715          messageType == EImpsDeliveryReportReq ||

   716          // This may be requested or SAP initiated

   717          // so, don't do that :messageType == EImpsLeaveGroupRes ||

   718          messageType == EImpsInviteUserReq ||

   719          messageType == EImpsInviteRes ||

   720          messageType == EImpsCancelInviteUserReq ||

   721          messageType == EImpsPresenceNotification ||

   722          messageType == EImpsGroupChangeNotice )

   723         {

   724 #ifndef _NO_IMPS_LOGGING_

   725         CImpsClientLogger::Log( _L( "Server: CheckRequests cancelled" ) );

   726 #endif

   727         return;

   728         }

   729 

   730     // Go through all sessions (each having an own request list)

   731 

   732     iSessionIter.SetToFirst();

   733     TInt myOpId = 0;

   734     TImpsServRequest reqType = EImpsServNone;

   735     TImpsMessageType msgType = EImpsMessageNone;

   736 

   737     TUint subHandle = 0;

   738 

   739     // Check TID match

   740     while ( iSessionIter )

   741         {

   742         CSession2* session = iSessionIter;

   743         iSessionIter++;

   744         // return handle of matching subsession and give it as parameter

   745         subHandle = ( ( CImpsSession* )session )->CheckRequests( aFields->TidL(),

   746                                                                  myOpId, reqType, msgType, aCSP );

   747         if ( subHandle )

   748             {

   749             // Do not delete request until corresponding event is sent.

   750             // If event sending fails then expiration will take place later.

   751             ( ( CImpsSession* )session )->SendEvent(

   752                 aFields, myOpId, reqType, msgType, subHandle );

   753 

   754             ( ( CImpsSession* )session )->DeleteRequest( myOpId, subHandle );

   755             aFound = ETrue;

   756             // multi: do not stop searching because of there may be

   757             // multiple login requests with the same TID.

   758             // break;

   759             }

   760         }

   761     }

   762 

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

   764 // CImpsServer::CheckNotifications

   765 // -----------------------------------------------------------------------------

   766 TBool CImpsServer::CheckNotifications(

   767     CImpsFields* aFields,

   768     TImpsSessIdent aCSP )

   769     {

   770 

   771 #ifndef _NO_IMPS_LOGGING_

   772     CImpsClientLogger::Log( _L( "Server: CheckNotifications begins" ) );

   773 #endif

   774 

   775     // Check if IM message max size is exceeded

   776     if ( aFields->MessageType() == EImpsNewMessage &&

   777          aFields->Size() > iSettings.MaximumMessageSize() )

   778         {

   779 #ifndef _NO_IMPS_LOGGING_

   780         CImpsClientLogger::Log( _L( "Server: error: IM Message max size exceeded ***" ) );

   781 #endif

   782         // This is not saved in an orphan queue either

   783         return ETrue;

   784         }

   785 

   786     TBool retVal( EFalse );

   787     // Go through all sessions

   788     iSessionIter.SetToFirst();

   789     // Check notification events

   790     while ( iSessionIter )

   791         {

   792         CSession2* session = iSessionIter;

   793         iSessionIter++;

   794         if ( ( ( CImpsSession* )session )->CheckNotifications( aFields, aCSP ) )

   795             {

   796             retVal = ETrue;

   797             }

   798         }

   799     return retVal;

   800     }

   801 

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

   803 // CImpsServer::CheckExpiryL

   804 // -----------------------------------------------------------------------------

   805 void CImpsServer::CheckExpiryL(

   806     TImpsEventType aType, TTime aExpiry  )

   807     {

   808     if ( iOrphans )

   809         {

   810         TInt errx = KErrNone;

   811         TRAP( errx, iOrphans->CheckExpiryL() );

   812         }

   813     // multi: check all csp sessions

   814     TDblQueIter<CImpsConn> rIter( iCSPList );

   815     rIter.SetToFirst();

   816     while ( rIter )

   817         {

   818         CImpsConn* conn = rIter;

   819         rIter++;

   820         conn->Sess()->CheckExpiry(  aType, aExpiry );

   821         }

   822     }

   823 

   824 // -----------------------------------------------------------------------------

   825 // CImpsServer::CheckExpiryL

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

   827 void CImpsServer::CheckExpiryL(

   828     TImpsEventType aType  )

   829     {

   830 #ifndef _NO_IMPS_LOGGING_

   831     CImpsClientLogger::Log( _L( "Server: CheckExpiryL begins" ) );

   832 #endif

   833     TTime myExpiry;

   834     myExpiry.HomeTime();

   835     CheckExpiryL( aType, myExpiry );

   836     }

   837 

   838 // -----------------------------------------------------------------------------

   839 // CImpsServer::DiscardRequests

   840 // -----------------------------------------------------------------------------

   841 void CImpsServer::DiscardRequests( TImpsEventType aType, TTime aExpiry,

   842                                    TImpsSessIdent aCSP, MImpsCSPSession* aSess )

   843     {

   844     iSessionIter.SetToFirst();

   845     while ( iSessionIter )

   846         {

   847         CSession2* session = iSessionIter;

   848         iSessionIter++;

   849         ( ( CImpsSession* )session )->DiscardRequests(

   850             aExpiry,

   851             aType,

   852             aCSP, aSess );

   853         }

   854     }

   855 

   856 // -----------------------------------------------------------------------------

   857 // CImpsServer::DiscardRequests

   858 // -----------------------------------------------------------------------------

   859 void CImpsServer::DiscardRequests( TImpsEventType aType, TInt aError,

   860                                    TImpsSessIdent aCSP, MImpsCSPSession* aSess )

   861     {

   862     iSessionIter.SetToFirst();

   863     while ( iSessionIter )

   864         {

   865         CSession2* session = iSessionIter;

   866         iSessionIter++;

   867         ( ( CImpsSession* )session )->DiscardRequests(

   868             aError,

   869             aType,

   870             aCSP,

   871             aSess );

   872         }

   873     }

   874 

   875 // -----------------------------------------------------------------------------

   876 // CImpsServer::DiscardLogout

   877 // -----------------------------------------------------------------------------

   878 void CImpsServer::DiscardLogout(

   879     const TDesC& aTID,

   880     TImpsSessIdent aCSP )

   881     {

   882 #ifndef _NO_IMPS_LOGGING_

   883     CImpsClientLogger::Log( _L( "Server: DiscardLogoutL begins" ) );

   884 #endif

   885     TUint subHandle = 0;

   886     // This is a special case to handle logout error

   887     // Check TID match

   888     iSessionIter.SetToFirst();

   889     while ( iSessionIter )

   890         {

   891         CSession2* session = iSessionIter;

   892         iSessionIter++;

   893         TInt myHit = 0;     // opId

   894         // output params

   895         TImpsServRequest reqType = EImpsServNone;

   896         TImpsMessageType msgType = EImpsMessageNone;

   897 

   898         // return handle of matching subsession and give it as parameter

   899         subHandle = ( ( CImpsSession* )session )->CheckRequests( aTID,

   900                                                                  myHit, reqType, msgType, aCSP );

   901         // call SendLogoutevent

   902         if ( subHandle )

   903             {

   904             // Send event to client

   905             ( ( CImpsSession* )session )->SendLogoutEvent(

   906                 KErrNone, myHit, NULL, subHandle );

   907 

   908             // Delete client request after successful event sending

   909             ( ( CImpsSession* )session )->DeleteRequest( myHit, subHandle );

   910             break;

   911             }

   912         }

   913     }

   914 

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

   916 // CImpsServer::HandleOrphanL

   917 // -----------------------------------------------------------------------------

   918 void CImpsServer::HandleOrphanL( CImpsFields* aFields, TImpsSessIdent aCSP )

   919     {

   920 #ifndef _NO_IMPS_LOGGING_

   921     CImpsClientLogger::Log( _L( "Server: HandleOrphanL" ) );

   922 #endif

   923     if ( iOrphans )

   924         {

   925         // CSP identification

   926         iOrphans->NewOrphanL( aFields, aCSP );

   927         }

   928     else

   929         {

   930         User::Leave( KErrNotSupported );

   931         }

   932     }

   933 

   934 // -----------------------------------------------------------------------------

   935 // CImpsServer::NextOrphanLC

   936 // -----------------------------------------------------------------------------

   937 CImpsFields* CImpsServer::NextOrphanLC( const TDesC& aCID,

   938                                         TImpsEventType aServiceType,

   939                                         TImpsSessIdent aCSP )

   940     {

   941 #ifndef _NO_IMPS_LOGGING_

   942     CImpsClientLogger::Log( _L( "Server: NextOrphanL" ) );

   943 #endif

   944     if ( !iOrphans )

   945         {

   946         return NULL;

   947         }

   948     // CSP session and application id identification

   949     return iOrphans->NextOrphanLC( aCID, aServiceType, aCSP );

   950     }

   951 

   952 // -----------------------------------------------------------------------------

   953 // CImpsServer::HandleAllOrphans

   954 // -----------------------------------------------------------------------------

   955 void CImpsServer::HandleAllOrphans( )

   956     {

   957 #ifndef _NO_IMPS_LOGGING_

   958     CImpsClientLogger::Log( _L( "Server: HandleAllOrphans" ) );

   959 #endif

   960     if ( !iOrphans )

   961         {

   962         return;

   963         }

   964     // loop each session

   965     iSessionIter.SetToFirst();

   966     while ( iSessionIter )

   967         {

   968         CSession2* session = iSessionIter;

   969         iSessionIter++;

   970         ( ( CImpsSession* )session )->HandleAllOrphans();

   971         }

   972     }

   973 

   974 // -----------------------------------------------------------------------------

   975 // CImpsServer::IsLogged

   976 // -----------------------------------------------------------------------------

   977 TBool CImpsServer::IsLogged( TImpsSessIdent aCSP, TPtrC* aPsw )

   978     {

   979     MImpsCSPSession* csp = GetCSP( aCSP, EFalse );

   980     TBool ret =  ( csp ? csp->IsLogged() : EFalse );

   981     if ( ret && aPsw )

   982         {

   983         aPsw->Set( csp->Password() );

   984         }

   985     return ret;

   986     }

   987 

   988 // -----------------------------------------------------------------------------

   989 // CImpsServer::SID()

   990 // -----------------------------------------------------------------------------

   991 TPtrC CImpsServer::SID( TImpsSessIdent aCSP )

   992     {

   993     if ( aCSP.IsZero() )

   994         {

   995         return TPtrC();

   996         }

   997     else

   998         {

   999         MImpsCSPSession* csp = GetCSP( aCSP, EFalse );

  1000         return ( csp ? csp->SID() : TPtrC() );

  1001         }

  1002     }

  1003 

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

  1005 // CImpsServer::GetCSP

  1006 // -----------------------------------------------------------------------------

  1007 MImpsCSPSession* CImpsServer::GetCSP( TImpsSessIdent aCSP, TBool aAll )

  1008     {

  1009     TDblQueIter<CImpsConn> rIter( iCSPList );

  1010     rIter.SetToFirst();

  1011     while ( rIter )

  1012         {

  1013         CImpsConn* conn = rIter;

  1014         rIter++;

  1015         if ( conn->MatchCSP( aCSP ) )

  1016             {

  1017             if ( ( !aAll && !conn->Sess()->IsShuttingDown() ) ||

  1018                  ( aAll ) )

  1019                 {

  1020                 return conn->Sess();

  1021                 }

  1022             }

  1023         }

  1024     return NULL;

  1025     }

  1026 

  1027 // -----------------------------------------------------------------------------

  1028 // CImpsServer::NewCSPL

  1029 // -----------------------------------------------------------------------------

  1030 MImpsCSPSession* CImpsServer::NewCSPL( TImpsSessIdent /*aCSP*/, TImpsCspVersion aVer )

  1031     {

  1032 #ifndef _NO_IMPS_LOGGING_

  1033     CImpsClientLogger::Log( _L( "Server: NewCSPL" ) );

  1034 #endif

  1035     CImpsCSPSession* ses = CImpsCSPSession::NewL( *this,

  1036                                                   iSettings, iFs, *iVariant, aVer );

  1037     CleanupStack::PushL( ses );

  1038     CImpsConn* conn = CImpsConn::NewL( ses, *this );

  1039     iCSPList.AddLast( *conn );

  1040     CleanupStack::Pop( 1 );

  1041     return ses;

  1042     }

  1043 

  1044 // -----------------------------------------------------------------------------

  1045 // CImpsServer::DeleteCSP

  1046 // -----------------------------------------------------------------------------

  1047 void CImpsServer::DeleteCSP( MImpsCSPSession* aSess )

  1048     {

  1049 #ifndef _NO_IMPS_LOGGING_

  1050     CImpsClientLogger::Log( _L( "Server: DeleteCSP" ) );

  1051 #endif

  1052     TDblQueIter<CImpsConn> rIter( iCSPList );

  1053     rIter.SetToFirst();

  1054     while ( rIter )

  1055         {

  1056         CImpsConn* conn = rIter;

  1057         rIter++;

  1058         if ( conn->Sess() == aSess )

  1059             {

  1060             conn->Destroy();

  1061             break;

  1062             }

  1063         }

  1064     // Check also if all the client sessions are closed and if this is the

  1065     // last CSP session. Then start final count down.

  1066     if ( !NbrSessions( EFalse ) && !NbrCSPs() )

  1067         {

  1068         iOperation = EImpsSrvFinish;

  1069         iShutTimer->Start( KImpsShutdownTime );

  1070         }

  1071     }

  1072 

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

  1074 // CImpsServer::DeleteCSPAsynch

  1075 // -----------------------------------------------------------------------------

  1076 void CImpsServer::DeleteCSPAsynch( MImpsCSPSession* aSess )

  1077     {

  1078 #ifndef _NO_IMPS_LOGGING_

  1079     CImpsClientLogger::Log( _L( "Server: DeleteCSPAsynch" ) );

  1080 #endif

  1081     TDblQueIter<CImpsConn> rIter( iCSPList );

  1082     rIter.SetToFirst();

  1083     while ( rIter )

  1084         {

  1085         CImpsConn* conn = rIter;

  1086         rIter++;

  1087         if ( conn->Sess() == aSess )

  1088             {

  1089             conn->DeleteCSPAsynch();

  1090             return;

  1091             }

  1092         }

  1093     }

  1094 

  1095 // -----------------------------------------------------------------------------

  1096 // CImpsServer::CloseAllCSPs

  1097 // -----------------------------------------------------------------------------

  1098 void CImpsServer::CloseAllCSPs()

  1099     {

  1100 #ifndef _NO_IMPS_LOGGING_

  1101     CImpsClientLogger::Log( _L( "Server: CloseAllCSPs" ) );

  1102 #endif

  1103     TDblQueIter<CImpsConn> rIter( iCSPList );

  1104     rIter.SetToFirst();

  1105     while ( rIter )

  1106         {

  1107         CImpsConn* conn = rIter;

  1108         rIter++;

  1109         conn->Sess()->DoLogout();

  1110         }

  1111     }

  1112 

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

  1114 // CImpsServer::NbrCSPs

  1115 // -----------------------------------------------------------------------------

  1116 TInt CImpsServer::NbrCSPs( )

  1117     {

  1118     TDblQueIter<CImpsConn> rIter( iCSPList );

  1119     rIter.SetToFirst();

  1120     TInt count = 0;

  1121     while ( rIter )

  1122         {

  1123         rIter++;

  1124         count++;

  1125         }

  1126     return count;

  1127     }

  1128 

  1129 // -----------------------------------------------------------------------------

  1130 // CImpsServer::NbrSessions

  1131 // -----------------------------------------------------------------------------

  1132 TInt CImpsServer::NbrSessions( TBool aIgnoreCIR )

  1133     {

  1134     iSessionIter.SetToFirst();

  1135     TInt myRet = 0;