1 /*

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

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 #include <e32math.h>

    26 #include <f32file.h>

    27 

    28 #include "sendebug.h"                 // internal Utils\inc - logging MACROs

    29 #include "senlogger.h"

    30 #include "senservicemanagerdefines.h" // internal Core\inc  - IPC enumerations

    31 

    32 #include "rsenserviceconnection.h"

    33 

    34 #include <SenSoapMessage.h>

    35 

    36 #if defined (__WINS__) && !defined(EKA2)

    37 static const TUint KServerMinHeapSize =    0x1000;     //  4K

    38 static const TUint KServerMaxHeapSize =    0x100000;   // 1000K

    39 #endif

    40 

    41 static TInt StartServerL();

    42 static TInt CreateServerProcessL();

    43 

    44 CSenProgressResourceHandler::CSenProgressResourceHandler(TInt aTxnId,

    45         TBool aIncoming, TBool aIsSoap, TInt aProgress,

    46         RSenServiceConnection* aOwner): CActive(EPriorityStandard),

    47         iOwner(aOwner)

    48     {

    49     TTransferProgress& data = iProgressData();

    50     data.iTxnId = aTxnId;

    51     data.iIncoming = aIncoming;

    52     data.iSoap = aIsSoap;

    53     data.iProgress = aProgress;

    54     }

    55 

    56 CSenProgressResourceHandler::~CSenProgressResourceHandler()

    57     {

    58     delete iSoapOrCid;

    59     }

    60 

    61 void CSenProgressResourceHandler::DoCancel()

    62     {

    63     

    64     }

    65 

    66 void CSenProgressResourceHandler::RunL()

    67     {

    68     iOwner->Remove(this);

    69     delete this;

    70     }

    71 

    72 TInt CSenProgressResourceHandler::SetBuffer(const TDesC8& aSoapOrCid)

    73     {

    74     iSoapOrCid = aSoapOrCid.Alloc();

    75     if (iSoapOrCid)

    76         {

    77         return KErrNone;

    78         }

    79     return KErrNoMemory;

    80     }

    81 

    82 CSenConnAgentSync::CSenConnAgentSync(): CActive(EPriorityStandard)

    83 	{

    84 	CActiveScheduler::Add(this);

    85 	iStatus = KRequestPending;

    86 	}

    87 

    88 CSenConnAgentSync::~CSenConnAgentSync()

    89 	{

    90 	if(IsActive())

    91 		{

    92 		Cancel();

    93 		}

    94 	}

    95 

    96 void CSenConnAgentSync::DoCancel()

    97 	{	

    98 	}

    99 

   100 void CSenConnAgentSync::RunL()

   101 	{

   102 	}

   103 

   104 void CSenConnAgentSync::Start()

   105 	{

   106 	SetActive();

   107 	}

   108 

   109 RSenServiceConnection::RSenServiceConnection(RFileLogger* aLog)

   110     : RSessionBase(),

   111       iMessageContextId(0),

   112       iLog(aLog)

   113     {

   114     // No implementation required

   115     }

   116 

   117 void RSenServiceConnection::SetLog(RFileLogger* aLog)

   118     {

   119     iLog = aLog;

   120     }

   121 void RSenServiceConnection::SetChannel(TInt aChannel)

   122 {

   123      iTLSLogChannel=aChannel;

   124 }

   125 

   126 TInt RSenServiceConnection::Connect()

   127     {

   128     TInt error(KErrNone);

   129     TRAPD( leave, error = ::StartServerL(); )

   130     

   131     if( leave != KErrNone )

   132         {

   133         error = leave;

   134         }

   135         

   136     if( error == KErrNone )

   137         {

   138         error = CreateSession( KSenServiceManager, Version(), KDefaultMessageSlots );

   139         /// By defining TRequestStatus (last arg) to NULL, one could force 

   140         /// error = CreateSession( KSenServiceManager, Version(), KDefaultMessageSlots, NULL, NULL ); 

   141 #ifdef _SENDEBUG

   142         if(error != KErrNone)

   143             {

   144             TLSLOG_FORMAT((KSenServiceConnectionLogChannel, KMinLogLevel , _L8("RSenServiceConnection::Connect - CreateSession returned error: (%d)"), error));

   145             }

   146         else

   147             {

   148             TLSLOG_L(KSenServiceConnectionLogChannel, KMinLogLevel,"RSenServiceConnection::Connect - CreateSession returned KErrNone");

   149             }

   150 #endif // _SENDEBUG

   151         }

   152 #ifdef _SENDEBUG

   153     else

   154         {

   155         TLSLOG_FORMAT((KSenServiceConnectionLogChannel, KMinLogLevel , _L8("RSenServiceConnection::Connect - StartServerL failed, error: (%d)"), error));

   156         }

   157 #endif // _SENDEBUG

   158     return error;

   159     }

   160 

   161 TVersion RSenServiceConnection::Version() const

   162     {

   163     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::Version");

   164     return(TVersion( KWsfServMajorVersionNumber, KWsfServMinorVersionNumber, KWsfServBuildVersionNumber) );

   165     }

   166 

   167 void RSenServiceConnection::Initialize( TRequestStatus& aStatus,

   168                                         TDes8& aErrPtr,

   169                                         TDes& aSessionID,

   170                                         CSenChunk& aSenChunk,

   171                                         TInt aSdLength,

   172                                         TInt /* aCpLength */,

   173                                         TBool aHasAuthenticationCallback)

   174     {

   175     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::Initialize");

   176     TIpcArgs args;

   177     args.Set(0, &aErrPtr);

   178     args.Set(1, &aSessionID);

   179     // Note: chunk will carry XML SD - and possibly consumer policy -

   180     // over the process boundary.

   181     aSenChunk.ChunkToArgs(args, 2);

   182     

   183     iFourInts().iInt1 = aSdLength;

   184     iFourInts().iInt2 = aHasAuthenticationCallback;

   185     args.Set(3,&iFourInts);

   186     

   187     SendReceive(ESenServInitialize, args, aStatus);

   188     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::Initialize Completed");

   189     }

   190 

   191 

   192 TInt RSenServiceConnection::IsReady(TBool& aReady)

   193     {

   194     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::IsReady");

   195     TPtr8 descriptor(reinterpret_cast<TUint8*>(&aReady), sizeof(aReady), sizeof(aReady));

   196     TIpcArgs args;

   197     args.Set(0, &descriptor);

   198     return SendReceive(ESenServIsReady, args);

   199     }

   200 

   201 TInt RSenServiceConnection::HasFacet(TDesC8& aUri, TBool& aHasFacet)

   202     {

   203     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::HasFacet");

   204     TLSLOG_ALL(iTLSLogChannel, KMaxLogLevel,(aUri));

   205     TPtr8 descriptor(reinterpret_cast<TUint8*>(&aHasFacet), sizeof(aHasFacet), sizeof(aHasFacet));

   206     TInt length = aUri.Length();

   207     TIpcArgs args;

   208     args.Set(0, &aUri);

   209     args.Set(1, &descriptor);

   210     args.Set(2, length);

   211     return SendReceive(ESenServHasFacet, args);

   212     }

   213 

   214 TInt RSenServiceConnection::CompleteServerMessagesOnOff(TBool& aOnOff)

   215     {

   216     TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceConnection::CompleteServerMessagesOnOff")));

   217 

   218     // Note : Using TPtr8 since this is binary information

   219     TPtr8 descriptor(reinterpret_cast<TUint8*>(&aOnOff),sizeof(aOnOff),

   220         sizeof(aOnOff));

   221 

   222     TIpcArgs args;

   223     args.Set(0, &descriptor);

   224 

   225     return SendReceive(ESenServServerMessagesOnOff, args);

   226     }

   227 

   228 void RSenServiceConnection::Transaction( TRequestStatus& aStatus,

   229                                          TDes8& aErrPtr,

   230                                          TDes8& aTxnPtr,

   231                                          CSenChunk& aClientOp )

   232     {

   233     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::Transaction");

   234 

   235     // Set the message context ID in here: it is only locally unique, inside each service connection - "in client scope"

   236     // Context IDs use negative range, to avoid collisions with txnIDs (which are always positive integers)

   237     aClientOp.ChunkHeader().SetContextId( --iMessageContextId );

   238     TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Transaction - SetContextId: %d"), iMessageContextId));

   239     

   240     TIpcArgs args;

   241     args.Set(0, &aErrPtr);

   242     args.Set(1, &aTxnPtr);

   243     // This RChunk will pass message to server and include response when this

   244     // txn is complete

   245     aClientOp.ChunkToArgs(args,2);

   246     SendReceive(ESenServTransaction, args, aStatus);

   247     }

   248 

   249 TInt RSenServiceConnection::SendMsgAndReceiveTxnId(CSenChunk& aClientOp)

   250     {

   251     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::SendMsgAndReceiveTxnId");

   252     TInt retVal(KErrNone);

   253 

   254     TIpcArgs args;

   255     aClientOp.ChunkToArgs(args,0);

   256     args.Set(1,aClientOp.ChunkHeader().ContextId());

   257     retVal = SendReceive(ESenServSendMsgAndGetTxnId, args);

   258 

   259     return retVal;

   260     }

   261 TInt RSenServiceConnection::MoveFile(CSenChunk& aClientOp,

   262                                      const TDesC8& aCid,

   263                                      RFile& aFile)

   264     {

   265     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::SendFile");

   266     

   267     TInt retVal = aClientOp.DescToChunk(aCid,2);

   268     

   269     TIpcArgs args;

   270 

   271     if ( retVal == KErrNone)

   272         {

   273         aClientOp.ChunkToArgs(args,0);

   274         aFile.TransferToServer(args, 1, 2);

   275         

   276         retVal = SendReceive(ESenServMoveFile, args);

   277         }

   278 

   279     return retVal;

   280     }

   281     

   282 TInt RSenServiceConnection::SendFileHandle(CSenChunk& aSenChunk, 

   283                       						RFile& aFile)

   284 	{

   285   	 TInt retVal(KErrNone);

   286      TIpcArgs args;

   287 

   288      if ( retVal == KErrNone)

   289         {

   290          aSenChunk.ChunkToArgs(args,0);

   291          aFile.TransferToServer(args, 1, 2);       

   292          retVal = SendReceive(ESenServSendFileHandle, args);

   293         }

   294 

   295      return retVal;

   296 	}

   297 

   298 TInt RSenServiceConnection::MoveChunk(CSenChunk& aClientOp,

   299                                       const TDesC8& aCid,

   300                                       RChunk& aChunk,

   301                                       TInt aDataOffset,

   302                                       TInt aDataSize)

   303     {

   304     TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceConnection::SendChunk")));

   305     

   306     TInt retVal = aClientOp.DescToChunk(aCid,2);

   307     

   308     TIpcArgs args;

   309     

   310     if ( retVal == KErrNone )

   311         {

   312         TIpcArgs args;

   313         aClientOp.ChunkToArgs(args,0);

   314         args.Set(1, aChunk);

   315         args.Set(2, aDataOffset);

   316         args.Set(3, aDataSize);

   317         retVal = SendReceive(ESenServMoveChunk, args);

   318         }

   319 

   320     return retVal;

   321     }

   322 

   323 TInt RSenServiceConnection::RequestServiceDescription(TDes8& aSdLength)

   324     {

   325     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::RequestServiceDescription");

   326     TIpcArgs args;

   327     args.Set(0, &aSdLength);

   328     return SendReceive(ESenServRequestServiceDescription, args);

   329     }

   330 

   331 

   332 TInt RSenServiceConnection::ReceiveServiceDescription(TDes8& aServiceDescription)

   333     {

   334     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::ReceiveServiceDescription");

   335     TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Waiting for SD: maxlength(%d):"),

   336                                 aServiceDescription.MaxLength()));

   337     TIpcArgs args;

   338     args.Set(0, &aServiceDescription);

   339     return SendReceive(ESenServReceiveServiceDescription, args);

   340     }

   341 

   342 TInt RSenServiceConnection::StartTransaction()

   343     {

   344     TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceConnection::StartTransaction")));

   345     return SendReceive(ESenServStartTransaction);

   346     }

   347 

   348 TInt RSenServiceConnection::TransactionCompleted()

   349     {

   350     TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceConnection::TransactionCompleted")));

   351     return SendReceive(ESenServTransactionCompleted);

   352     }

   353 

   354 TInt RSenServiceConnection::SetTransportPropertiesL(CSenChunk& aSenChunk)

   355     {

   356     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::SetTransportPropertiesL");

   357 

   358     TIpcArgs args;

   359     aSenChunk.ChunkToArgs(args, 0);

   360 

   361     TInt retVal = SendReceive(ESenServSetTransportProperties, args);

   362     

   363     return retVal;

   364     }

   365 

   366 TInt RSenServiceConnection::TransportPropertiesL(CSenChunk& aSenChunk)

   367     {

   368     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::TransportPropertiesL");

   369 

   370     TIpcArgs args;

   371     aSenChunk.ChunkToArgs(args, 0);

   372 

   373     TInt retVal = SendReceive(ESenServTransportProperties, args);

   374     

   375     return retVal;

   376     }

   377 

   378 void  RSenServiceConnection::CancelSession(TRequestStatus& aStatus)

   379     {

   380     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::CancelSession(sync)");

   381     SendReceive(ESenServCancelSession, aStatus);

   382     }

   383 

   384 // ASYNC VERSION

   385 void RSenServiceConnection::CancelRequests(TRequestStatus& aStatus)

   386     {

   387     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::CancelSession(async)");

   388     TIpcArgs args; // empty

   389     SendReceive(ESenServCancelSession, args, aStatus);

   390     }

   391 

   392 void RSenServiceConnection::CancelRequest(TInt aTransactionID)

   393     {

   394     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::CancelRequest");

   395     TIpcArgs args;

   396     args.Set(0, aTransactionID);

   397     SendReceive(ESenServCancelRequest, args);

   398     }

   399 

   400 void RSenServiceConnection::DataTrafficDetails(TSenDataTrafficDetails& aDetails,

   401 											   TSenDataTrafficOperations& aOperations) 

   402 	{

   403 	TLSLOG_L(iTLSLogChannel, KSenServiceConnectionLogLevel,"RSenServiceConnection::DataTrafficDetails");

   404     TPtr8 trafficDetailsDesc(reinterpret_cast<TUint8*>(&aDetails),sizeof(aDetails),

   405         					sizeof(aDetails));

   406     TIpcArgs args;

   407     args.Set(0,&trafficDetailsDesc);

   408     args.Set(1,&aOperations.iReset);

   409     SendReceive(ESenTrafficDetails, args);

   410     }

   411 

   412 TInt RSenServiceConnection::ConnectionID()

   413     {

   414     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::ConnectionID");

   415     TInt connectionID = SendReceive( ESenServConnectionID );

   416     //LOG_WRITEFORMAT((_L("- Connection ID: (%d)"), connectionID));

   417     return connectionID;

   418     }

   419 

   420 TInt RSenServiceConnection::IdentityProviderL(CSenChunk& aSenChunk)

   421     {

   422     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::IdentityProviderL");

   423 

   424     TIpcArgs args;

   425     aSenChunk.ChunkToArgs(args, 0);

   426 

   427     TInt retVal = SendReceive(ESenServConnectionIdentityProvider, args);

   428     

   429     return retVal;

   430     }

   431     

   432 TInt RSenServiceConnection::RegisterIdentityProvider(TDesC8& aMessage)

   433     {

   434 #ifdef _SENDEBUG

   435     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::RegisterIdentityProvider");

   436 

   437     TPtrC8 outBufferLeft = aMessage.Left(30);

   438     TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"), &outBufferLeft,

   439         aMessage.Length()));

   440 #endif // _SENDEBUG

   441 

   442     TInt length = aMessage.Length();

   443 

   444     TIpcArgs args;

   445     args.Set(0, &aMessage);

   446     args.Set(1, length);

   447 

   448     return SendReceive(ESenServRegisterIdentityProvider, args);

   449     }

   450 	

   451 TInt RSenServiceConnection::RegisterTransferObserver(

   452         const TDesC* aServerName, TAny* aConnection)

   453     {

   454     TInt retVal(KErrNone);

   455     CActiveSchedulerWait asWait;

   456     TIpcArgs args(aServerName, aConnection, &asWait);

   457     CSenConnAgentSync* caSync = new CSenConnAgentSync();

   458     if(caSync)

   459     	{

   460 	    SendReceive(ESenObserveTransfer, args, caSync->iStatus);

   461 	    caSync->Start();

   462 	    Mem::FillZ(&asWait, sizeof(asWait));

   463 	    asWait.Start();

   464 	    retVal = caSync->iStatus.Int();

   465 	    delete caSync;

   466     	}

   467     else

   468     	{

   469     	retVal = KErrNoMemory;

   470     	}

   471     return retVal;

   472     }

   473 

   474 TInt RSenServiceConnection::SendFileProgress( TInt aTxnId, 

   475                                               TBool aIncoming,

   476                                               TBool aIsSoap, 

   477                                               const TDesC8& aSoapOrCid, 

   478                                               TInt aProgress)

   479     {

   480     CSenProgressResourceHandler* resHandler = new CSenProgressResourceHandler(

   481             aTxnId, aIncoming, aIsSoap, aProgress, this);

   482     if (!resHandler)

   483         {

   484         return KErrNoMemory; // new (ELeave) was not used!

   485         }

   486     TInt retVal = resHandler->SetBuffer(aSoapOrCid);

   487     if ( retVal != KErrNone)

   488         {

   489         delete resHandler;

   490         }

   491     else

   492         {

   493         if (iFirst)

   494             {

   495             iFirst->iPrevious = resHandler;

   496             }

   497         resHandler->iNext = iFirst;

   498         iFirst = resHandler;

   499 

   500         CActiveScheduler::Add(resHandler);

   501         resHandler->SetActive();

   502         resHandler->iStatus = KRequestPending;

   503 

   504         TIpcArgs args(&resHandler->iProgressData, resHandler->iSoapOrCid);

   505         SendReceive(ESenTransferProgress, args, resHandler->iStatus);

   506         }

   507     return retVal;

   508     }

   509 

   510 void RSenServiceConnection::Remove(

   511         CSenProgressResourceHandler* aResourceHandler)

   512     {

   513     if (aResourceHandler == iFirst)

   514         {

   515         iFirst = aResourceHandler->iNext;

   516         if (iFirst)

   517             {

   518             iFirst->iPrevious = NULL;

   519             }

   520         }

   521     else

   522         {

   523         aResourceHandler->iPrevious->iNext = aResourceHandler->iNext;

   524         }

   525     }

   526 

   527 

   528 void RSenServiceConnection::Close()

   529     {

   530     CSenProgressResourceHandler* resHandler = iFirst;

   531     while (resHandler)

   532         {

   533         resHandler->Cancel();

   534         CSenProgressResourceHandler* tmp = resHandler;

   535         resHandler = resHandler->iNext;

   536         delete tmp;

   537         }

   538     RSessionBase::Close();

   539     }

   540 

   541 TInt RSenServiceConnection::SearchIdentityProviderL(CSenChunk& aSenChunk, const TDesC8& aProviderId)

   542 	{

   543 	TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::SearchIdentityProviderL");

   544 	

   545 	TInt length = aProviderId.Length();

   546 	

   547 	TIpcArgs args;

   548     aSenChunk.ChunkToArgs(args, 0);

   549     args.Set(1, &aProviderId);

   550     args.Set(2, length);

   551   

   552     TInt retVal = SendReceive(ESenServSearchIdentityProvider, args);

   553     return retVal;

   554 	}

   555 

   556 TInt RSenServiceConnection::RegisterAuthenticationObserver(const TDesC* aServerName, TAny* aConnection)

   557 	{

   558 	TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::RegisterAuthenticationObserver");

   559 	CActiveSchedulerWait asWait;

   560     TIpcArgs args(aServerName, aConnection, &asWait);

   561     TRequestStatus rs = KRequestPending;

   562     SendReceive(ESenObserveAuthCallback, args, rs);

   563     Mem::FillZ(&asWait, sizeof(asWait));

   564     asWait.Start();

   565     User::WaitForRequest(rs);

   566     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::RegisterAuthenticationObserver Completed");

   567     return rs.Int();

   568 	}

   569 

   570 TInt RSenServiceConnection::RegisterCoBrandingObserver(

   571         const TDesC* aServerName, TAny* aConnection)

   572     {

   573     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::RegisterCoBrandingObserver");

   574 	CActiveSchedulerWait asWait;

   575     TIpcArgs args(aServerName, aConnection, &asWait);

   576     TRequestStatus rs = KRequestPending;

   577     SendReceive(ESenObserveCoBranding, args, rs);

   578     Mem::FillZ(&asWait, sizeof(asWait));

   579     asWait.Start();

   580     User::WaitForRequest(rs);

   581     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::RegisterCoBrandingObserver Completed");

   582     return rs.Int();

   583     }

   584 #ifdef __ENABLE_ALR__

   585 TInt RSenServiceConnection::RegisterMobilityObserverL(

   586         const TDesC* aServerName, TAny* aConnection)

   587     {

   588     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::RegisterMobilityObserverL");

   589     TInt retVal(KErrNone);

   590     CActiveSchedulerWait asWait;

   591     TIpcArgs args(aServerName, aConnection, &asWait);

   592     CSenConnAgentSync* caSync = new CSenConnAgentSync();

   593     if(caSync)

   594     	{

   595 	    SendReceive(ESenServRegisterMobiltyObserver, args, caSync->iStatus);

   596 	    caSync->Start();

   597 	    Mem::FillZ(&asWait, sizeof(asWait));

   598 	    asWait.Start();

   599 	    retVal = caSync->iStatus.Int();

   600 	    delete caSync;

   601     	}

   602     else

   603     	{

   604     	retVal = KErrNoMemory;

   605     	}

   606     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::RegisterMobilityObserverL Completed");

   607     return retVal;

   608     }

   609 

   610 

   611 TInt RSenServiceConnection::MigrateToPrefferedCarrierL(TBool &aUserChoice)

   612 	{

   613 	TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::MigrateToPrefferedCarrierL");

   614 	

   615 	 // Note : Using TPtr8 since this is binary information

   616 	TPtr8 descriptor(reinterpret_cast<TUint8*>(&aUserChoice),sizeof(aUserChoice),

   617         sizeof(aUserChoice));

   618 

   619     TInt retVal(KErrNone);

   620     TIpcArgs args(&descriptor) ; 

   621     

   622     CSenConnAgentSync* caSync = new CSenConnAgentSync();

   623     if(caSync)

   624     	{

   625         caSync->Start();    	

   626 	    SendReceive(ESenServMigrateToPreffredCarrier, args, caSync->iStatus);

   627 	    retVal = caSync->iStatus.Int();

   628 	    delete caSync;

   629     	}

   630     else

   631     	{

   632     	retVal = KErrNoMemory;

   633     	}

   634     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::MigrateToPrefferedCarrierL Completed");

   635     return retVal;

   636 	    

   637 	}	

   638 

   639 TInt RSenServiceConnection::NewCarrierAcceptedL(TBool &aUserChoice)

   640 	{

   641 	TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::MigrateToPrefferedCarrierL");

   642 	

   643 	 // Note : Using TPtr8 since this is binary information

   644 	 TPtr8 descriptor(reinterpret_cast<TUint8*>(&aUserChoice),sizeof(aUserChoice),

   645         sizeof(aUserChoice));

   646 

   647     TInt retVal(KErrNone);

   648     TIpcArgs args(&descriptor) ;

   649     CSenConnAgentSync* caSync = new CSenConnAgentSync();

   650     if(caSync)

   651     	{

   652         caSync->Start();    	

   653 	    SendReceive(ESenServNewCarrierAccepted, args, caSync->iStatus);

   654 	    retVal = caSync->iStatus.Int();

   655 	    delete caSync;

   656     	}

   657     else

   658     	{

   659     	retVal = KErrNoMemory;

   660     	}

   661     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::MigrateToPrefferedCarrierL Completed");

   662     return retVal;	    

   663 	}	

   664 #endif

   665 

   666 RFileLogger* RSenServiceConnection::Log() const

   667     {

   668     return iLog;

   669     }

   670 

   671 static TInt StartServerL()

   672     {

   673     TInt result(KErrNotFound);

   674 

   675 #ifdef _SENDEBUG   

   676     RFileLogger log;

   677     CleanupClosePushL(log);

   678     User::LeaveIfError( log.Connect() );

   679     log.CreateLog( KSenServiceConnectionLogDir, _L("SenStartServer.log"), EFileLoggingModeAppend );

   680     log.Write(_L("- StartServerL() - invoked by SC."));

   681 #endif // _SENDEBUG

   682 

   683     TFindServer findSenServiceManager(KSenServiceManager);

   684     TFullName name;

   685 

   686     result = findSenServiceManager.Next(name);

   687     if (result == KErrNone)

   688         {

   689         // Server already running

   690 #ifdef _SENDEBUG        

   691         log.Write(_L8("- Server already running, KErrNone"));

   692         log.CloseLog();

   693         CleanupStack::PopAndDestroy(); // log.Close()

   694 #endif // _SENDEBUG        

   695         return KErrNone;

   696         }

   697 

   698     RSemaphore semaphore;

   699     CleanupClosePushL(semaphore);

   700 

   701     // First, try to open the semaphore (if someone else created it already):

   702     result = semaphore.OpenGlobal( KSenServiceManagerSemaphoreName );

   703     if( result == KErrNone )

   704         {

   705         // If another client is starting up SEN.EXE, this client should return

   706         // to re-connect loop (wait one sec, max 5 times)

   707 #ifdef _SENDEBUG        

   708         log.Write(_L8("- OpenGlobal OK => Another client already starting up SEN.EXE. About to WAIT and RE-CONNECT."));

   709 #endif        

   710         result = KErrServerBusy;

   711         }

   712     else // could not find any already opened global semaphore ==> it is safe to create new one

   713         {   

   714         // Semaphore has not yet been created, so instantiate it now(!)

   715         result = semaphore.CreateGlobal( KSenServiceManagerSemaphoreName, 0 );

   716 #ifdef _SENDEBUG        

   717         if( result != KErrNone )

   718             {

   719             log.Write(_L8("CreateGlobal failed"));

   720             log.WriteFormat(_L8("- error: %d"), result);

   721             }

   722 #endif        

   723         }

   724         

   725     if (result != KErrNone)

   726         {

   727         CleanupStack::PopAndDestroy(); // semaphore.Close()

   728 #ifdef _SENDEBUG        

   729         log.CloseLog();

   730 #endif // _SENDEBUG        

   731         if( result != KErrServerBusy )

   732             {

   733 #ifdef _SENDEBUG        

   734             log.Write(_L8("- CreateGlobal failed => Another client already starting up SEN.EXE. About to WAIT and RE-CONNECT."));

   735             CleanupStack::PopAndDestroy(); // log.Close()

   736 #endif // _SENDEBUG        

   737             result = KErrServerBusy; // again, this error will activate re-connect loop (max 5 times)

   738             }

   739         return result;

   740         }

   741 

   742     result = CreateServerProcessL();

   743     if (result != KErrNone)

   744         {

   745         CleanupStack::PopAndDestroy(); // semaphore.Close()

   746 #ifdef _SENDEBUG        

   747         log.Write(_L8("CreateServerProcessL failed"));

   748         log.CloseLog();

   749         CleanupStack::PopAndDestroy(); // log.Close()

   750 #endif // _SENDEBUG         

   751         return result;

   752         }

   753 

   754     // Now start waiting for signal from server: it will release this semaphore from wait:

   755     semaphore.Wait();  

   756     CleanupStack::PopAndDestroy(); // semaphore.Close()

   757     

   758 #ifdef _SENDEBUG        

   759     log.Write(_L("Log file closed."));

   760     log.CloseLog();

   761     CleanupStack::PopAndDestroy(); // log.Close()    

   762 #endif // _SENDEBUG

   763     return  KErrNone;

   764     }

   765 

   766 static TInt CreateServerProcessL()

   767     {

   768     TInt result(KErrNone);

   769 

   770 #ifdef _SENDEBUG

   771     RFileLogger log;

   772     CleanupClosePushL(log);

   773     User::LeaveIfError( log.Connect() );

   774     // Note: appends to the log created in StartServer(), as it already exists

   775     log.CreateLog( KSenServiceConnectionLogDir, _L("SenStartServer.log"), EFileLoggingModeAppend );

   776     log.Write(_L("- CreateServerProcessL() - invoked by SC."));

   777 #endif //_SENDEBUG

   778 

   779     const TUidType serverUid(KNullUid, KNullUid, KServerUid3);

   780 

   781 #if defined( __WINS__ ) && !defined(EKA2)

   782     // WINDOWS emulator version

   783     RLibrary lib;

   784     CleanupClosePushL(lib);

   785 

   786     RThread server;

   787     CleanupClosePushL(server);

   788 

   789     result = lib.Load( KSenServiceManagerFileName, serverUid );

   790 

   791     if(result==KErrNone)

   792         {

   793 #ifdef _SENDEBUG

   794         log.Write(_L8("Library successfully loaded, KErrNone"));

   795 #endif // _SENDEBUG

   796         

   797         //  Get the WinsMain function

   798         TLibraryFunction functionWinsMain = lib.Lookup(1);

   799 

   800         //  Call it and cast the result to a thread function

   801         TThreadFunction serverThreadFunction =

   802             reinterpret_cast<TThreadFunction>(functionWinsMain());

   803 

   804         TName threadName(KSenServiceManagerFileName);

   805 

   806         // Append a random number to make it unique

   807         threadName.AppendNum(Math::Random(), EHex);

   808 

   809         result = server.Create(threadName,   // create new server thread

   810                                serverThreadFunction, // thread's main function

   811                                KDefaultStackSize,

   812                                NULL,

   813                                &lib,

   814                                NULL,

   815                                KServerMinHeapSize,

   816                                KServerMaxHeapSize,

   817                                EOwnerProcess);

   818 

   819         // if successful, server thread now has the handle to library:

   820 

   821         if(result== KErrNone)

   822             {

   823             server.SetPriority(EPriorityMore);

   824             }

   825         }

   826 #ifdef _SENDEBUG

   827     else

   828         {

   829         log.Write(_L8("- Could not load library"));

   830         }

   831 #endif // _SENDEBUG

   832 

   833     CleanupStack::Pop(); // server (thread)

   834     CleanupStack::PopAndDestroy(); // lib

   835     CleanupClosePushL(server);

   836 

   837 #else // _WINS_ not defined (EKA2, for example)

   838     RProcess server;

   839     CleanupClosePushL(server);

   840     result = server.Create( KSenServiceManagerFileName, _L(""), serverUid );

   841 #endif // _WINS_

   842 

   843     if( result == KErrNone )

   844         {

   845 #ifdef _SENDEBUG

   846         log.Write( _L8("- Server successfully created (KErrNone)") );

   847 #endif // _SENDEBUG

   848         server.Resume();

   849         }

   850 #ifdef _SENDEBUG

   851     else

   852         {

   853         log.Write( _L8("- Could not create server") );

   854         }

   855 #endif // _SENDEBUG

   856 

   857     CleanupStack::PopAndDestroy(); // server.Close();

   858 

   859 #ifdef _SENDEBUG

   860     CleanupStack::PopAndDestroy(); // log.Close();

   861 #endif // _SENDEBUG

   862 

   863     return result;

   864     }

   865     

   866 

   867 // End of file

   868 

   869 

   870