examples/Base/IPC/ClientServer/Gettingstarted/transient/src/server.cpp

// Copyright (c) 2000-2009 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:
// Transient server example - server implementation
//

#include "server.h"

inline CShutdown::CShutdown()
        :CTimer(-1)
        {CActiveScheduler::Add(this);}
inline void CShutdown::ConstructL()
        {CTimer::ConstructL();}
inline void CShutdown::Start()
        {After(KMyShutdownDelay);}

inline CMyServer::CMyServer()
        :CServer2(0,ESharableSessions)
        {}

inline CMySession::CMySession()
        {}
inline CMyServer& CMySession::Server()
        {return *static_cast<CMyServer*>(const_cast<CServer2*>(CSession2::Server()));}
inline TBool CMySession::ReceivePending() const
        {return !iReceiveMsg.IsNull();}



void CMySession::CreateL()
//
// 2nd phase construct for sessions - called by the CServer framework
//
        {
        Server().AddSession();
        }

CMySession::~CMySession()
        {
        Server().DropSession();
        }

void CMySession::Send(const TDesC& aMessage)
//
// Deliver the message to the client, truncating if required
// If the write fails, panic the client, not the sender
//
        {
        if (ReceivePending())
                {
                TPtrC m(aMessage);
                if (iReceiveLen<aMessage.Length())
                        m.Set(m.Left(iReceiveLen));
                TInt r=iReceiveMsg.Write(0,m);
                if (r==KErrNone)
                        iReceiveMsg.Complete(KErrNone);
                else
                        PanicClient(iReceiveMsg,EPanicBadDescriptor);
                }
        }

void CMySession::ServiceL(const RMessage2& aMessage)
//
// Handle a client request.
// Leaving is handled by CMyServer::ServiceError() which reports
// the error code to the client
//
        {
        switch (aMessage.Function())
                {
        case ESend:
                {
                TBuf<KMaxMyMessage> message;
                aMessage.ReadL(0,message);
                Server().Send(message);
                aMessage.Complete(KErrNone);
                break;
                }
        case EReceive:
                if (ReceivePending())
                        PanicClient(aMessage,EPanicAlreadyReceiving);
                else
                        {
                        iReceiveMsg=aMessage;
                        iReceiveLen=aMessage.Int1();
                        }
                break;
        case ECancelReceive:
                if (ReceivePending())
                        iReceiveMsg.Complete(KErrCancel);
                aMessage.Complete(KErrNone);
                break;
        default:
                PanicClient(aMessage,EPanicIllegalFunction);
                break;
                }
        }

void CMySession::ServiceError(const RMessage2& aMessage,TInt aError)
//
// Handle an error from CMySession::ServiceL()
// A bad descriptor error implies a badly programmed client, so panic it;
// otherwise use the default handling (report the error to the client)
//
        {
        if (aError==KErrBadDescriptor)
                PanicClient(aMessage,EPanicBadDescriptor);
        CSession2::ServiceError(aMessage,aError);
        }

void CShutdown::RunL()
//
// Initiate server exit when the timer expires
//
        {
        CActiveScheduler::Stop();
        }

CServer2* CMyServer::NewLC()
        {
        CMyServer* self=new(ELeave) CMyServer;
        CleanupStack::PushL(self);
        self->ConstructL();
        return self;
        }

void CMyServer::ConstructL()
//
// 2nd phase construction - ensure the timer and server objects are running
//
        {
        StartL(KMyServerName);
        iShutdown.ConstructL();
        // ensure that the server still exits even if the 1st client fails to connect
        iShutdown.Start();
        }


CSession2* CMyServer::NewSessionL(const TVersion&,const RMessage2&) const
//
// Cretae a new client session. This should really check the version number.
//
        {
        return new(ELeave) CMySession();
        }

void CMyServer::AddSession()
//
// A new session is being created
// Cancel the shutdown timer if it was running
//
        {
        ++iSessionCount;
        iShutdown.Cancel();
        }

void CMyServer::DropSession()
//
// A session is being destroyed
// Start the shutdown timer if it is the last session.
//
        {
        if (--iSessionCount==0)
                iShutdown.Start();
        }

void CMyServer::Send(const TDesC& aMessage)
//
// Pass on the signal to all clients
//
        {
        iSessionIter.SetToFirst();
        CSession2* s;
        while ((s=iSessionIter++)!=0)
                static_cast<CMySession*>(s)->Send(aMessage);
        }

void PanicClient(const RMessagePtr2& aMessage,TMyPanic aPanic)
//
// RMessage::Panic() also completes the message. This is:
// (a) important for efficient cleanup within the kernel
// (b) a problem if the message is completed a second time
//
        {
        _LIT(KPanic,"MyServer");
        aMessage.Panic(KPanic,aPanic);
        }

static void RunServerL()
//
// Perform all server initialisation, in particular creation of the
// scheduler and server and then run the scheduler
//
        {
        // naming the server thread after the server helps to debug panics
        User::LeaveIfError(RThread::RenameMe(KMyServerName));
        //
        // create and install the active scheduler we need
        CActiveScheduler* s=new(ELeave) CActiveScheduler;
        CleanupStack::PushL(s);
        CActiveScheduler::Install(s);
        //
        // create the server (leave it on the cleanup stack)
        CMyServer::NewLC();
        //
        // Initialisation complete, now signal the client
        RProcess::Rendezvous(KErrNone);
        //
        // Ready to run
        CActiveScheduler::Start();
        //
        // Cleanup the server and scheduler
        CleanupStack::PopAndDestroy(2);
        }

TInt E32Main()
//
// Server process entry-point
//
        {
        __UHEAP_MARK;
        //
        CTrapCleanup* cleanup=CTrapCleanup::New();
        TInt r=KErrNoMemory;
        if (cleanup)
                {
                TRAP(r,RunServerL());
                delete cleanup;
                }
        //
        __UHEAP_MARKEND;
        return r;
        }

---