hackedteam/core-symbian

#include <e32base.h>
#include <e32def.h>
#include <e32des8.h>

#include <f32file.h>
#include <S32MEM.H>
#include "SharedQueue.pan"
#include "SharedQueueErr.h"
#include "SharedQueueSession.h"
#include "SharedQueueCliSrv.h"

// Forward Declaration
void PanicClient(const RMessagePtr2& aMessage, TSharedQueuePanic aPanic);

// Gets a reference to the Server
inline CSharedQueueSrv& CSharedQueueSession::Server()
    {
    return *static_cast<CSharedQueueSrv*> (const_cast<CServer2*> (CSession2::Server()));
    }

CSharedQueueSession::CSharedQueueSession()
    {
    }

///////////////////////

void CSharedQueueSession::CreateL()
//
// 2nd phase construct for sessions - called by the CServer framework
//
    {
    Server().AddSession();
    __FLOG_OPEN_ID("HT", "Session.txt");
    __FLOG(_L("-------------"));
    }

CSharedQueueSession::~CSharedQueueSession()
    {
    __FLOG(_L("Destructor"));
    Server().DropSession();
    __FLOG(_L("End Destructor"));
    __FLOG_CLOSE;
    }

void CSharedQueueSession::IsEmptyL(const RMessage2& aMessage)
    {
    TBool empty = Server().IsEmpty();
    TPckgBuf<TBool> pckg(empty);
    aMessage.WriteL(0, pckg);
    aMessage.Complete(KErrNone);
    }

void CSharedQueueSession::LockTop(const RMessage2& aMessage)
    {
    TBool res = Server().LockTop();
    TPckgBuf<TBool> pckg(res);
    aMessage.WriteL(0, pckg);
    aMessage.Complete(KErrNone);
    }

void CSharedQueueSession::TopL(const RMessage2& aMessage)
    {
    TCmdStruct cmd = Server().TopL();
    TPckgBuf<TCmdStruct> pckg(cmd);
    aMessage.WriteL(0, pckg);
    aMessage.Complete(KErrNone);
    }

void CSharedQueueSession::TopParamL(const RMessage2& aMessage)
    {
    TInt cliBufferLen = aMessage.GetDesMaxLength(0);
    HBufC8* paramToSend = Server().TopParamL();
    if (cliBufferLen < paramToSend->Length())
        {
        aMessage.Complete(KErrUnderflow);
        return;
        }
    aMessage.WriteL(0, paramToSend->Des());
    aMessage.Complete(KErrNone);
    }

void CSharedQueueSession::DequeueL(const RMessage2& aMessage)
    {
    TCmdStruct cmd = Server().DequeueL();
    TPckgBuf<TCmdStruct> pckg(cmd);
    aMessage.WriteL(0, pckg);
    aMessage.Complete(KErrNone);
    }

void CSharedQueueSession::EnqueueL(const RMessage2& aMessage)
    {
    TPckgBuf<TCmdStruct> pckg;
    aMessage.ReadL(0, pckg);
    TCmdStruct cmd = pckg();

    // Read the params buffer
    TInt params_len = aMessage.GetDesLength(1);
    HBufC8* buff = HBufC8::NewLC(params_len);
    TPtr8 ptrBuf = buff->Des();
    aMessage.ReadL(1, ptrBuf);

    Server().EnqueueL(cmd, buff->Des());

    CleanupStack::PopAndDestroy(buff);
    aMessage.Complete(KErrNone);
    }

void CSharedQueueSession::DoEmptyL(const RMessage2& aMessage)     // added jo
    {
    Server().DoEmptyL();
    
    aMessage.Complete(KErrNone);
    }

void CSharedQueueSession::ServiceL(const RMessage2& aMessage)
//
// Handle a client request.
// Leaving is handled by ::ServiceError() which reports
// the error code to the client
//
    {
    __FLOG_1(_L("ServiceL:%d"), aMessage.Function());
    switch (aMessage.Function())
        {
        case ELockTop:
            LockTop(aMessage);
            break;
        case EIsEmpty:
            IsEmptyL(aMessage);
            break;
        case EEnqueue:
            EnqueueL(aMessage);
            break;
        case EDequeue:
            DequeueL(aMessage);
            break;
        case ETop:
            TopL(aMessage);
            break;
        case ETopParam:
            TopParamL(aMessage);
            break;
        case EDoEmpty:       // added jo  
            DoEmptyL(aMessage);
            break;
        default:
            __FLOG(_L("!!!PanicClient!!!"));
            PanicClient(aMessage, EPanicIllegalFunction);
            break;
        }
    }

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

void PanicClient(const RMessagePtr2& aMessage, TSharedQueuePanic 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, "SharedQueueSession");
    aMessage.Panic(KPanic, aPanic);
    }