--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsmanager/src/rsenservicemanager.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,542 @@
+/*
+* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+
+
+
+
+
+
+
+
+
+
+#include <e32math.h>
+
+#include "rsenservicemanager.h"
+
+#include "senservicemanagerdefines.h" // IPC enumerations
+#include "sendebug.h" // internal Utils\inc - filelogging MACROs
+#include "senlogger.h"
+#include "senchunk.h"
+
+#if defined(__WINS__) && !defined(EKA2)
+ static const TUint KServerMinHeapSize = 0x1000; // 4K
+ static const TUint KServerMaxHeapSize = 0x100000; // 1000K
+#endif
+
+static TInt StartServerL();
+static TInt CreateServerProcessL();
+
+RSenServiceManager::RSenServiceManager()//(RFileLogger* aLog)
+ : RSessionBase()//,
+ //iLog(aLog)
+ {
+ // No implementation required
+ }
+
+/*
+void RSenServiceManager::SetLog(RFileLogger* aLog)
+ {
+ iLog = aLog;
+ }
+*/
+void RSenServiceManager::SetChannel(TInt aChannel)
+{
+ iTLSLogChannel = aChannel;
+}
+TInt RSenServiceManager::Connect()
+ {
+ TLSLOG(KSenServiceManagerLogChannel, KMinLogLevel,(_L("RSenServiceManager::Connect")));
+ TInt error(KErrNone);
+ TRAPD (err, error = ::StartServerL();)
+
+ if (err != KErrNone)
+ {
+ error = err;
+ }
+
+ if (KErrNone == error)
+ {
+ error = CreateSession(KSenServiceManager,
+ Version(),
+ KDefaultMessageSlots);
+
+#ifdef _SENDEBUG
+ if(error != KErrNone)
+ {
+ TLSLOG_L(KSenServiceManagerLogChannel, KMinLogLevel,"CSenServiceManagerImpl::DoCancel");
+ TLSLOG_FORMAT((KSenServiceManagerLogChannel, KMinLogLevel , _L8("- CreateSession returned error: (%d)"), error));
+ }
+ else
+ {
+ TLSLOG_L(KSenServiceManagerLogChannel, KMinLogLevel,"RSenServiceManager::Connect");
+ TLSLOG_L(KSenServiceManagerLogChannel, KMinLogLevel,"- CreateSession returned KErrNone");
+ }
+#endif // _SENDEBUG
+ }
+#ifdef _SENDEBUG
+ else
+ {
+ TLSLOG_FORMAT((KSenServiceManagerLogChannel, KMinLogLevel , _L8("RSenServiceManager::Connect - StartServer failed, error: (%d)"),
+ error));
+ }
+#endif // _SENDEBUG
+
+ return error;
+ }
+
+TVersion RSenServiceManager::Version() const
+ {
+ TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceManager::Version")));
+ return(TVersion(KWsfServMajorVersionNumber,
+ KWsfServMinorVersionNumber,
+ KWsfServBuildVersionNumber));
+ }
+
+TInt RSenServiceManager::InstallFramework(TDesC8& aMessage)
+ {
+#ifdef _SENDEBUG
+ TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceManager::InstallFramework")));
+
+ TPtrC8 outBufferLeft = aMessage.Left(30);
+ TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),
+ &outBufferLeft, aMessage.Length()));
+#endif // _SENDEBUG
+ TInt length = aMessage.Length();
+
+ TIpcArgs args;
+ args.Set(0,&aMessage);
+ args.Set(1, length);
+
+ return SendReceive(ESenServInstallFramework, args);
+ }
+
+// Note: cannot log here (without TLS), since flogger server session has not yet been opened(!)
+TInt RSenServiceManager::ConnectionID()
+ {
+ TInt connectionID = SendReceive( ESenServConnectionID );
+
+// iTlsLogChannel = KSenHostletConnectionLogChannelBase + connectionID;
+// TLSLOG_FORMAT((iTlsLogChannel, KSenServiceManagerLogLevel,
+// _L("- Connection ID: (%d)"), connectionID));
+ return connectionID;
+ }
+
+
+
+TInt RSenServiceManager::AssociateService( TDesC8& aServiceID, TDesC8& aProviderID )
+ {
+#ifdef _SENDEBUG
+ TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::AssociateService");
+
+ TPtrC8 outBufferLeft = aServiceID.Left(30);
+ TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),
+ &outBufferLeft, aServiceID.Length()));
+#endif // _SENDEBUG
+
+ TInt servIdLength = aServiceID.Length();
+ TInt provIdLength = aProviderID.Length();
+
+ TIpcArgs args;
+ args.Set(0, &aServiceID);
+ args.Set(1, servIdLength);
+ args.Set(2, &aProviderID);
+ args.Set(3, provIdLength);
+
+ return SendReceive(ESenServAssociateService, args);
+ }
+
+TInt RSenServiceManager::DissociateService(TDesC8& aServiceID,
+ TDesC8& aProviderID)
+ {
+#ifdef _SENDEBUG
+ TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::DissociateService");
+
+ TPtrC8 outBufferLeft = aServiceID.Left(30);
+ TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),
+ &outBufferLeft, aServiceID.Length()));
+#endif // _SENDEBUG
+
+ TInt servIdLength = aServiceID.Length();
+ TInt provIdLength = aProviderID.Length();
+
+ TIpcArgs args;
+ args.Set(0, &aServiceID);
+ args.Set(1, servIdLength);
+ args.Set(2, &aProviderID);
+ args.Set(3, provIdLength);
+
+ return SendReceive(ESenServDissociateService, args);
+ }
+
+TInt RSenServiceManager::RegisterIdentityProvider(TDesC8& aMessage)
+ {
+#ifdef _SENDEBUG
+ TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::RegisterIdentityProvider");
+
+ TPtrC8 outBufferLeft = aMessage.Left(30);
+ TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),
+ &outBufferLeft, aMessage.Length()));
+#endif // _SENDEBUG
+
+ TInt length = aMessage.Length();
+
+ TIpcArgs args;
+ args.Set(0, &aMessage);
+ args.Set(1, length);
+
+ return SendReceive(ESenServRegisterIdentityProvider, args);
+ }
+
+TInt RSenServiceManager::UnregisterIdentityProvider(TDesC8& aMessage)
+ {
+#ifdef _SENDEBUG
+ TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::UnregisterIdentityProvider");
+
+ TPtrC8 outBufferLeft = aMessage.Left(30);
+ TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),
+ &outBufferLeft, aMessage.Length()));
+#endif // _SENDEBUG
+
+ TInt length = aMessage.Length();
+ TIpcArgs args;
+ args.Set(0, &aMessage);
+ args.Set(1, length);
+
+ return SendReceive(ESenServUnregisterIdentityProvider, args);
+ }
+
+
+TInt RSenServiceManager::UnregisterServiceDescription(TDesC8& aMessage)
+ {
+#ifdef _SENDEBUG
+ TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceManager::UnregisterServiceDescription")));
+
+ TPtrC8 outBufferLeft = aMessage.Left(30);
+ TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),
+ &outBufferLeft, aMessage.Length()));
+#endif // _SENDEBUG
+
+ TInt length = aMessage.Length();
+ TIpcArgs args;
+ args.Set(0, &aMessage);
+ args.Set(1, length);
+
+ return SendReceive(ESenServUnregisterServiceDescription, args);
+ }
+
+TInt RSenServiceManager::RegisterServiceDescription(TDesC8& aMessage)
+ {
+#ifdef _SENDEBUG
+ TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceManager::RegisterServiceDescription")));
+
+ TPtrC8 outBufferLeft = aMessage.Left(30);
+ TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"),
+ &outBufferLeft, aMessage.Length()));
+#endif // _SENDEBUG
+
+ TInt length = aMessage.Length();
+ TIpcArgs args;
+ args.Set(0, &aMessage);
+ args.Set(1, length);
+
+ return SendReceive(ESenServRegisterServiceDescription, args);
+ }
+
+TInt RSenServiceManager::ServiceDescriptionsByUriL(CSenChunk& aSenChunk)
+ {
+ TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::GetServiceDescriptionsByUri");
+
+ TIpcArgs args;
+ aSenChunk.ChunkToArgs(args, 0);
+
+ TInt retVal = SendReceive(ESenServGetLengthOfServiceDescriptionByUri, args);
+
+ return retVal;
+ }
+
+TInt RSenServiceManager::IdentityProvidersL(CSenChunk& aSenChunk)
+ {
+ TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::IdentityProvidersL");
+
+ TIpcArgs args;
+ aSenChunk.ChunkToArgs(args, 0);
+
+ TInt retVal = SendReceive(ESenServGetIdentityProviders, args);
+
+ return retVal;
+ }
+
+TInt RSenServiceManager::ServiceDescriptionsByPatternL(CSenChunk& aSenChunk)
+ {
+ TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::GetServiceDescriptionsByPattern");
+
+ TIpcArgs args;
+ aSenChunk.ChunkToArgs(args, 0);
+
+ TInt retVal = SendReceive(ESenServGetLengthOfServiceDescriptionByPattern, args);
+
+ return retVal;
+ }
+
+TInt RSenServiceManager::CredentialsL(CSenChunk& aSenChunk)
+ {
+ TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::GetServiceDescriptionsByPattern");
+
+ TIpcArgs args;
+ aSenChunk.ChunkToArgs(args, 0);
+
+ TInt retVal = SendReceive(ESenServGetGredentials, args);
+
+ return retVal;
+ }
+
+TInt RSenServiceManager::AddCredentialL(CSenChunk& aSenChunk)
+ {
+ TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::GetServiceDescriptionsByPattern");
+
+ TIpcArgs args;
+ aSenChunk.ChunkToArgs(args, 0);
+
+ TInt retVal = SendReceive(ESenServAddCredential, args);
+
+ return retVal;
+ }
+
+TInt RSenServiceManager::RemoveCredentialsL(CSenChunk& aSenChunk)
+ {
+ TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceManager::GetServiceDescriptionsByPattern");
+
+ TIpcArgs args;
+ aSenChunk.ChunkToArgs(args, 0);
+
+ TInt retVal = SendReceive(ESenServRemoveCredential, args);
+
+ return retVal;
+ }
+/*
+RFileLogger* RSenServiceManager::Log() const
+ {
+ return iLog;
+ }
+*/
+static TInt StartServerL()
+ {
+ TInt result(KErrNotFound);
+
+#ifdef _SENDEBUG
+ RFileLogger log;
+ CleanupClosePushL(log);
+ User::LeaveIfError( log.Connect() );
+ log.CreateLog( KSenServiceManagerLogDir, _L("SenStartServer.log"), EFileLoggingModeOverwrite );
+ log.Write(_L("- StartServerL() - Log file opened."));
+#endif // _SENDEBUG
+
+ TFindServer findSenServiceManager(KSenServiceManager);
+ TFullName name;
+
+ result = findSenServiceManager.Next(name);
+ if (result == KErrNone)
+ {
+ // Server already running
+#ifdef _SENDEBUG
+ log.Write(_L8("- Server already running, KErrNone"));
+ log.CloseLog();
+ CleanupStack::PopAndDestroy(); // log.Close()
+#endif // _SENDEBUG
+ return KErrNone;
+ }
+
+ RSemaphore semaphore;
+ CleanupClosePushL(semaphore);
+
+ // First, try to open the semaphore (if someone else created it already):
+ result = semaphore.OpenGlobal( KSenServiceManagerSemaphoreName );
+ if( result == KErrNone )
+ {
+ // If another client is starting up SEN.EXE, this client should return
+ // to re-connect loop (wait one sec, max 5 times)
+#ifdef _SENDEBUG
+ log.Write(_L8("- OpenGlobal OK => Another client already starting up SEN.EXE. About to WAIT and RE-CONNECT."));
+#endif
+ result = KErrServerBusy;
+ }
+ else // could not find any already opened global semaphore ==> it is safe to create new one
+ {
+ // Semaphore has not yet been created, so instantiate it now(!)
+ result = semaphore.CreateGlobal( KSenServiceManagerSemaphoreName, 0 );
+#ifdef _SENDEBUG
+ if( result != KErrNone )
+ {
+ log.Write(_L8("CreateGlobal failed"));
+ log.WriteFormat(_L8("- error: %d"), result);
+ }
+#endif
+ }
+
+ if (result != KErrNone)
+ {
+ CleanupStack::PopAndDestroy(); // semaphore.Close()
+#ifdef _SENDEBUG
+ log.CloseLog();
+#endif // _SENDEBUG
+ if( result != KErrServerBusy )
+ {
+#ifdef _SENDEBUG
+ log.Write(_L8("- CreateGlobal failed => Another client already starting up SEN.EXE. About to WAIT and RE-CONNECT."));
+ CleanupStack::PopAndDestroy(); // log.Close()
+#endif // _SENDEBUG
+ result = KErrServerBusy; // again, this error will activate re-connect loop (max 5 times)
+ }
+ return result;
+ }
+
+ result = CreateServerProcessL();
+ if (result != KErrNone)
+ {
+ CleanupStack::PopAndDestroy(); // semaphore.Close()
+#ifdef _SENDEBUG
+ log.Write(_L8("CreateServerProcessL failed"));
+ log.CloseLog();
+ CleanupStack::PopAndDestroy(); // log.Close()
+#endif // _SENDEBUG
+ return result;
+ }
+
+ // Now start waiting for signal from server: it will release this semaphore from wait:
+ semaphore.Wait();
+ CleanupStack::PopAndDestroy(); // semaphore.Close()
+
+#ifdef _SENDEBUG
+ log.Write(_L("Log file closed."));
+ log.CloseLog();
+ CleanupStack::PopAndDestroy(); // log.Close()
+#endif // _SENDEBUG
+ return KErrNone;
+ }
+
+static TInt CreateServerProcessL()
+ {
+ TInt result(KErrNotFound);
+
+#ifdef _SENDEBUG
+ RFileLogger log;
+ CleanupClosePushL(log);
+ User::LeaveIfError( log.Connect() );
+ // Note: this appends to the log created in StartServer()
+ log.CreateLog(KSenServiceManagerLogDir, _L("SenStartServer.log"), EFileLoggingModeAppend);
+ log.Write(_L("- CreateServerProcessL() - invoked by SM."));
+#endif // _SENDEBUG
+
+ const TUidType serverUid(KNullUid, KNullUid, KServerUid3);
+
+#if defined(__WINS__) && !defined(EKA2)
+
+ RLibrary lib;
+ CleanupClosePushL(lib);
+
+ RThread server;
+ CleanupClosePushL(server);
+
+ result = lib.Load(KSenServiceManagerFileName, serverUid);
+
+ if ( result == KErrNone )
+ {
+#ifdef _SENDEB
+ log.Write(_L8("Library successfully loaded, KErrNone"));
+#endif // _SENDEBUG
+
+ // Get the WinsMain function
+ TLibraryFunction functionWinsMain = lib.Lookup(1);
+
+ // Call it and cast the result to a thread function
+ TThreadFunction serverThreadFunction = reinterpret_cast<TThreadFunction>(functionWinsMain());
+
+ TName threadName(KSenServiceManagerFileName);
+
+ // Append a random number to make it unique
+ threadName.AppendNum(Math::Random(), EHex);
+
+ result = server.Create( threadName, // create new server thread
+ serverThreadFunction, // thread's main function
+ KDefaultStackSize,
+ NULL,
+ &lib,
+ NULL,
+ KServerMinHeapSize,
+ KServerMaxHeapSize,
+ EOwnerProcess );
+
+ if ( result == KErrNone )
+ {
+ server.SetPriority( EPriorityMore );
+ }
+#ifdef _SENDEBUG
+ else
+ {
+ log.Write(_L8("Failed to create server thread."));
+ }
+#endif // _SENDEBUG
+ }
+#ifdef _SENDEBUG
+ else
+ {
+ log.Write(_L8("Could not load library"));
+ }
+#endif // _SENDEBUG
+
+
+ CleanupStack::Pop(); // server (thread)
+ CleanupStack::PopAndDestroy(); // lib
+ CleanupClosePushL(server);
+
+
+#else // NON WINS TARGET(S):
+ RProcess server;
+ CleanupClosePushL(server);
+
+ result = server.Create(KSenServiceManagerFileName, KNullDesC, serverUid); //CodeScannerWarnings
+#endif
+
+ if( result == KErrNone )
+ {
+#ifdef _SENDEBUG
+ log.Write(_L8("Server successfully created, KErrNone"));
+#endif // _SENDEBUG
+ server.Resume();
+ }
+#ifdef _SENDEBUG
+ else
+ {
+ log.Write(_L8("Could not create server"));
+ }
+#endif // _SENDEBUG
+
+ CleanupStack::PopAndDestroy(); // server.Close();
+
+#ifdef _SENDEBUG
+ CleanupStack::PopAndDestroy(); // log.Close();
+#endif
+
+ return result;
+ }
+
+// END OF FILE
+
+
+