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 

    26 

    27 

    28 #include <e32math.h>

    29 

    30 #include "rsenservicemanager.h"

    31 

    32 #include "senservicemanagerdefines.h" // IPC enumerations

    33 #include "sendebug.h" // internal Utils\inc - filelogging MACROs

    34 #include "senlogger.h"

    35 #include "senchunk.h"

    36 

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

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

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

    40 #endif

    41 

    42 static TInt StartServerL();

    43 static TInt CreateServerProcessL();

    44 

    45 RSenServiceManager::RSenServiceManager()//(RFileLogger* aLog)

    46     : RSessionBase()//,

    47       //iLog(aLog)

    48     {

    49     // No implementation required

    50     }

    51 

    52 /*

    53 void RSenServiceManager::SetLog(RFileLogger* aLog)

    54     {

    55     iLog = aLog;

    56     }

    57 */    

    58 void RSenServiceManager::SetChannel(TInt aChannel)

    59 {

    60 	iTLSLogChannel = aChannel;

    61 }

    62 TInt RSenServiceManager::Connect()

    63     {

    64     TLSLOG(KSenServiceManagerLogChannel, KMinLogLevel,(_L("RSenServiceManager::Connect")));

    65     TInt error(KErrNone);

    66     TRAPD (err, error = ::StartServerL();)

    67     

    68     if (err != KErrNone)

    69         {

    70         error = err;

    71         }

    72 

    73     if (KErrNone == error)

    74         {

    75         error = CreateSession(KSenServiceManager,

    76                               Version(),

    77                               KDefaultMessageSlots);

    78 

    79 #ifdef _SENDEBUG

    80         if(error != KErrNone)

    81             {

    82             TLSLOG_L(KSenServiceManagerLogChannel, KMinLogLevel,"CSenServiceManagerImpl::DoCancel");

    83             TLSLOG_FORMAT((KSenServiceManagerLogChannel, KMinLogLevel , _L8("- CreateSession returned error: (%d)"), error));

    84             }

    85         else

    86             {

    87             TLSLOG_L(KSenServiceManagerLogChannel, KMinLogLevel,"RSenServiceManager::Connect");

    88             TLSLOG_L(KSenServiceManagerLogChannel, KMinLogLevel,"- CreateSession returned KErrNone");

    89             }

    90 #endif // _SENDEBUG

    91         }

    92 #ifdef _SENDEBUG

    93     else

    94         {

    95         TLSLOG_FORMAT((KSenServiceManagerLogChannel, KMinLogLevel , _L8("RSenServiceManager::Connect - StartServer failed, error: (%d)"),

    96                     error));

    97         }

    98 #endif // _SENDEBUG

    99 

   100     return error;

   101     }

   102 

   103 TVersion RSenServiceManager::Version() const

   104     {

   105     TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceManager::Version")));

   106     return(TVersion(KWsfServMajorVersionNumber,

   107                     KWsfServMinorVersionNumber,

   108                     KWsfServBuildVersionNumber));

   109     }

   110 

   111 TInt RSenServiceManager::InstallFramework(TDesC8& aMessage)

   112     {

   113 #ifdef _SENDEBUG

   114     TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceManager::InstallFramework")));

   115 

   116     TPtrC8 outBufferLeft = aMessage.Left(30);

   117     TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

   118                         &outBufferLeft, aMessage.Length()));

   119 #endif // _SENDEBUG

   120     TInt length = aMessage.Length();

   121 

   122     TIpcArgs args;

   123     args.Set(0,&aMessage);

   124     args.Set(1, length);

   125 

   126     return SendReceive(ESenServInstallFramework, args);

   127     }

   128 

   129 // Note: cannot log here (without TLS), since flogger server session has not yet been opened(!)

   130 TInt RSenServiceManager::ConnectionID()

   131     {

   132     TInt connectionID = SendReceive( ESenServConnectionID );

   133                    

   134 //    iTlsLogChannel = KSenHostletConnectionLogChannelBase + connectionID;

   135 //    TLSLOG_FORMAT((iTlsLogChannel, KSenServiceManagerLogLevel,

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

   137     return connectionID;

   138     }

   139 

   140 

   141 

   142 TInt RSenServiceManager::AssociateService( TDesC8& aServiceID, TDesC8& aProviderID )

   143     {

   144 #ifdef _SENDEBUG

   145     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::AssociateService");

   146 

   147     TPtrC8 outBufferLeft = aServiceID.Left(30);

   148     TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

   149                     &outBufferLeft, aServiceID.Length()));

   150 #endif // _SENDEBUG

   151 

   152     TInt servIdLength = aServiceID.Length();

   153     TInt provIdLength = aProviderID.Length();

   154 

   155     TIpcArgs args;

   156     args.Set(0, &aServiceID);

   157     args.Set(1, servIdLength);

   158     args.Set(2, &aProviderID);

   159     args.Set(3, provIdLength);

   160 

   161     return SendReceive(ESenServAssociateService, args);

   162     }

   163 

   164 TInt RSenServiceManager::DissociateService(TDesC8& aServiceID,

   165                                            TDesC8& aProviderID)

   166     {

   167 #ifdef _SENDEBUG

   168     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::DissociateService");

   169 

   170     TPtrC8 outBufferLeft = aServiceID.Left(30);

   171     TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

   172                     &outBufferLeft, aServiceID.Length()));

   173 #endif // _SENDEBUG

   174 

   175     TInt servIdLength = aServiceID.Length();

   176     TInt provIdLength = aProviderID.Length();

   177 

   178     TIpcArgs args;

   179     args.Set(0, &aServiceID);

   180     args.Set(1, servIdLength);

   181     args.Set(2, &aProviderID);

   182     args.Set(3, provIdLength);

   183 

   184     return SendReceive(ESenServDissociateService, args);

   185     }

   186 

   187 TInt RSenServiceManager::RegisterIdentityProvider(TDesC8& aMessage)

   188     {

   189 #ifdef _SENDEBUG

   190     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::RegisterIdentityProvider");

   191 

   192     TPtrC8 outBufferLeft = aMessage.Left(30);

   193     TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

   194                         &outBufferLeft, aMessage.Length()));

   195 #endif // _SENDEBUG

   196 

   197     TInt length = aMessage.Length();

   198 

   199     TIpcArgs args;

   200     args.Set(0, &aMessage);

   201     args.Set(1, length);

   202 

   203     return SendReceive(ESenServRegisterIdentityProvider, args);

   204     }

   205 

   206 TInt RSenServiceManager::UnregisterIdentityProvider(TDesC8& aMessage)

   207     {

   208 #ifdef _SENDEBUG

   209     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::UnregisterIdentityProvider");

   210 

   211     TPtrC8 outBufferLeft = aMessage.Left(30);

   212     TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

   213                     &outBufferLeft, aMessage.Length()));

   214 #endif // _SENDEBUG

   215 

   216     TInt length = aMessage.Length();

   217     TIpcArgs args;

   218     args.Set(0, &aMessage);

   219     args.Set(1, length);

   220 

   221     return SendReceive(ESenServUnregisterIdentityProvider, args);

   222     }

   223 

   224 

   225 TInt RSenServiceManager::UnregisterServiceDescription(TDesC8& aMessage)

   226     {

   227 #ifdef _SENDEBUG

   228     TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceManager::UnregisterServiceDescription")));

   229 

   230     TPtrC8 outBufferLeft = aMessage.Left(30);

   231     TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

   232                     &outBufferLeft, aMessage.Length()));

   233 #endif // _SENDEBUG

   234 

   235     TInt length = aMessage.Length();

   236     TIpcArgs args;

   237     args.Set(0, &aMessage);

   238     args.Set(1, length);

   239 

   240     return SendReceive(ESenServUnregisterServiceDescription, args);

   241     }

   242 

   243 TInt RSenServiceManager::RegisterServiceDescription(TDesC8& aMessage)

   244     {

   245 #ifdef _SENDEBUG

   246     TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceManager::RegisterServiceDescription")));

   247 

   248     TPtrC8 outBufferLeft = aMessage.Left(30);

   249     TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),

   250         &outBufferLeft, aMessage.Length()));

   251 #endif // _SENDEBUG

   252 

   253     TInt length = aMessage.Length();

   254     TIpcArgs args;

   255     args.Set(0, &aMessage);

   256     args.Set(1, length);

   257 

   258     return SendReceive(ESenServRegisterServiceDescription, args);

   259     }

   260 

   261 TInt RSenServiceManager::ServiceDescriptionsByUriL(CSenChunk& aSenChunk)

   262     {

   263     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::GetServiceDescriptionsByUri");

   264 

   265     TIpcArgs args;

   266     aSenChunk.ChunkToArgs(args, 0);

   267 

   268     TInt retVal = SendReceive(ESenServGetLengthOfServiceDescriptionByUri, args);

   269     

   270     return retVal;

   271     }

   272 

   273 TInt RSenServiceManager::IdentityProvidersL(CSenChunk& aSenChunk)

   274     {

   275     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::IdentityProvidersL");

   276 

   277     TIpcArgs args;

   278     aSenChunk.ChunkToArgs(args, 0);

   279 

   280     TInt retVal = SendReceive(ESenServGetIdentityProviders, args);

   281     

   282     return retVal;

   283     }

   284 

   285 TInt RSenServiceManager::ServiceDescriptionsByPatternL(CSenChunk& aSenChunk)

   286     {

   287     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::GetServiceDescriptionsByPattern");

   288 

   289     TIpcArgs args;

   290     aSenChunk.ChunkToArgs(args, 0);

   291     

   292     TInt retVal = SendReceive(ESenServGetLengthOfServiceDescriptionByPattern, args);

   293     

   294     return retVal;

   295     }

   296 

   297 TInt RSenServiceManager::CredentialsL(CSenChunk& aSenChunk)

   298     {

   299     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::GetServiceDescriptionsByPattern");

   300 

   301     TIpcArgs args;

   302     aSenChunk.ChunkToArgs(args, 0);

   303     

   304     TInt retVal = SendReceive(ESenServGetGredentials, args);

   305     

   306     return retVal;

   307     }

   308     

   309 TInt RSenServiceManager::AddCredentialL(CSenChunk& aSenChunk)

   310     {

   311     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::GetServiceDescriptionsByPattern");

   312 

   313     TIpcArgs args;

   314     aSenChunk.ChunkToArgs(args, 0);

   315     

   316     TInt retVal = SendReceive(ESenServAddCredential, args);

   317     

   318     return retVal;

   319     }

   320 

   321 TInt RSenServiceManager::RemoveCredentialsL(CSenChunk& aSenChunk)

   322     {

   323     TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::GetServiceDescriptionsByPattern");

   324 

   325     TIpcArgs args;

   326     aSenChunk.ChunkToArgs(args, 0);

   327     

   328     TInt retVal = SendReceive(ESenServRemoveCredential, args);

   329     

   330     return retVal;

   331     }

   332 /*

   333 RFileLogger* RSenServiceManager::Log() const

   334     {

   335     return iLog;

   336     }

   337 */

   338 static TInt StartServerL()

   339     {

   340     TInt result(KErrNotFound);

   341 

   342 #ifdef _SENDEBUG   

   343     RFileLogger log;

   344     CleanupClosePushL(log);

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

   346     log.CreateLog( KSenServiceManagerLogDir, _L("SenStartServer.log"), EFileLoggingModeOverwrite );

   347     log.Write(_L("- StartServerL() - Log file opened."));

   348 #endif // _SENDEBUG

   349 

   350     TFindServer findSenServiceManager(KSenServiceManager);

   351     TFullName name;

   352 

   353     result = findSenServiceManager.Next(name);

   354     if (result == KErrNone)

   355         {

   356         // Server already running

   357 #ifdef _SENDEBUG        

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

   359         log.CloseLog();

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

   361 #endif // _SENDEBUG        

   362         return KErrNone;

   363         }

   364 

   365     RSemaphore semaphore;

   366     CleanupClosePushL(semaphore);

   367 

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

   369     result = semaphore.OpenGlobal( KSenServiceManagerSemaphoreName );

   370     if( result == KErrNone )

   371         {

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

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

   374 #ifdef _SENDEBUG        

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

   376 #endif        

   377         result = KErrServerBusy;

   378         }

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

   380         {   

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

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

   383 #ifdef _SENDEBUG        

   384         if( result != KErrNone )

   385             {

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

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

   388             }

   389 #endif        

   390         }

   391         

   392     if (result != KErrNone)

   393         {

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

   395 #ifdef _SENDEBUG        

   396         log.CloseLog();

   397 #endif // _SENDEBUG        

   398         if( result != KErrServerBusy )

   399             {

   400 #ifdef _SENDEBUG        

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

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

   403 #endif // _SENDEBUG        

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

   405             }

   406         return result;

   407         }

   408 

   409     result = CreateServerProcessL();

   410     if (result != KErrNone)

   411         {

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

   413 #ifdef _SENDEBUG        

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

   415         log.CloseLog();

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

   417 #endif // _SENDEBUG         

   418         return result;

   419         }

   420 

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

   422     semaphore.Wait();  

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

   424 

   425 #ifdef _SENDEBUG        

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

   427     log.CloseLog();

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

   429 #endif // _SENDEBUG

   430     return  KErrNone;

   431     }

   432 

   433 static TInt CreateServerProcessL()

   434     {

   435     TInt result(KErrNotFound);

   436 

   437 #ifdef _SENDEBUG

   438     RFileLogger log;

   439     CleanupClosePushL(log);

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

   441     // Note: this appends to the log created in StartServer()

   442     log.CreateLog(KSenServiceManagerLogDir, _L("SenStartServer.log"), EFileLoggingModeAppend);

   443     log.Write(_L("- CreateServerProcessL() - invoked by SM."));

   444 #endif // _SENDEBUG

   445 

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

   447 

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

   449 

   450     RLibrary lib;

   451     CleanupClosePushL(lib);

   452 

   453     RThread server;

   454     CleanupClosePushL(server);

   455 

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

   457 

   458     if ( result == KErrNone )

   459         {

   460 #ifdef _SENDEB

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

   462 #endif // _SENDEBUG

   463 

   464         //  Get the WinsMain function

   465         TLibraryFunction functionWinsMain = lib.Lookup(1);

   466 

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

   468         TThreadFunction serverThreadFunction = reinterpret_cast<TThreadFunction>(functionWinsMain());

   469 

   470         TName threadName(KSenServiceManagerFileName);

   471 

   472         // Append a random number to make it unique

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

   474 

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

   476                                 serverThreadFunction, // thread's main function

   477                                 KDefaultStackSize,

   478                                 NULL,

   479                                 &lib,

   480                                 NULL,

   481                                 KServerMinHeapSize,

   482                                 KServerMaxHeapSize,

   483                                 EOwnerProcess );

   484 

   485         if ( result == KErrNone )

   486             {

   487             server.SetPriority( EPriorityMore );

   488             }

   489 #ifdef _SENDEBUG

   490         else

   491             {

   492             log.Write(_L8("Failed to create server thread."));

   493             }

   494 #endif // _SENDEBUG

   495         }

   496 #ifdef _SENDEBUG

   497     else

   498         {

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

   500         }

   501 #endif // _SENDEBUG

   502 

   503 

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

   505     CleanupStack::PopAndDestroy(); // lib

   506     CleanupClosePushL(server);

   507 

   508         

   509 #else // NON WINS TARGET(S):

   510     RProcess server;

   511     CleanupClosePushL(server);

   512 

   513     result = server.Create(KSenServiceManagerFileName, KNullDesC, serverUid);	//CodeScannerWarnings

   514 #endif

   515 

   516     if( result == KErrNone )

   517         {

   518 #ifdef _SENDEBUG

   519         log.Write(_L8("Server successfully created, KErrNone"));

   520 #endif // _SENDEBUG

   521         server.Resume();

   522         }

   523 #ifdef _SENDEBUG

   524     else

   525         {

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

   527         }

   528 #endif // _SENDEBUG

   529 

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

   531 

   532 #ifdef _SENDEBUG

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

   534 #endif

   535 

   536     return result;

   537     }

   538 

   539 // END OF FILE

   540 

   541 

   542