diff -r 000000000000 -r 62f9d29f7211 webservices/wsmanager/src/rsenservicemanager.cpp
--- /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
+
+
+