hackedteam/core-symbian

#include "SharedQueue.h"
#include "SharedQueueSrv.h"
#include "SharedQueueCliSrv.h"
#include "SharedQueueErr.h"
#include <S32MEM.H>
#include <HT\logging.h>

const TInt KServerDefaultMessageSlots = 1; //Number of message slots available per session.

LOCAL_C TInt CreateServerProcess(RSemaphore& sem)
    {
    const TUidType serverUid(KNullUid, KNullUid, KSharedQueueSrvUid3);

    RProcess server;
    TInt err = server.Create(KSharedQueueSrvImg, KNullDesC, serverUid);
    if (err != KErrNone)
        {
        return err;
        }

    server.Resume();
    err = sem.Wait(5000000);
    TInt r = (server.ExitType() == EExitPanic) ? KErrGeneral : err;
    server.Close();
    return r;
    }

LOCAL_C TInt StartServer()
    {
    // Il FindServer non e' suffic. perche' il nome del server sara' assegnato diverso tempo dopo la creazione del processo... 
    TFindServer find(KSharedQueueSrvName);
    TFullName name;
    TInt err = find.Next(name); // KErrNone if a matching server is found, KErrNotFound otherwise. 
    if (err != KErrNone)
        {
        // Probably the Server is not Running
        RSemaphore sem;
        err = sem.CreateGlobal(KSharedQueueSrvImg, 0);
        if (err != KErrNone)
            {
            // Server is already Running...
            return KErrNone;
            }
        // Server not Running        
        err = CreateServerProcess(sem);
        sem.Close();
        }
    return err;
    }

EXPORT_C TInt RSharedQueue::Connect()
    {
    TInt i = 0;
    TInt errno;
    do
        {
        errno = StartServer();
        i++;
        }
    while (errno != KErrNone && i < 5);
    if (errno == KErrNone)
        {
        errno = CreateSession(KSharedQueueSrvName, TVersion(KServMajorVersionNumber, KServMinorVersionNumber,
                KServBuildVersionNumber), KServerDefaultMessageSlots);
        }
    return errno;
    }

EXPORT_C void RSharedQueue::Enqueue(TCmdType aType, TInt aSrc, TInt aDest, const TDesC8& params)
    {
    TCmdStruct cmd(aType, aSrc, aDest);
    Enqueue(cmd, params);
    }

EXPORT_C void RSharedQueue::Enqueue(TCmdStruct aCmd, const TDesC8& params)
    {
    TPckgBuf<TCmdStruct> pckg(aCmd);
    TIpcArgs args(&pckg, &params);
    SendReceive(EEnqueue, args);
    }

EXPORT_C TCmdStruct RSharedQueue::Dequeue()
    {
    TPckgBuf<TCmdStruct> pckg;
    TIpcArgs args(&pckg);
    SendReceive(EDequeue, args);
    TCmdStruct cmd = pckg();
    return cmd;
    }

EXPORT_C TCmdStruct RSharedQueue::Top()
    {
    TPckgBuf<TCmdStruct> pckg;
    TIpcArgs args(&pckg);
    SendReceive(ETop, args);
    TCmdStruct cmd = pckg();
    return cmd;
    }

EXPORT_C HBufC8* RSharedQueue::TopParamL()
    {
    HBufC8* buffer = HBufC8::NewLC(500);
    buffer->Des().Zero();

    TInt err = KErrNone;
    do
        {
        TIpcArgs args(&buffer->Des());
        err = SendReceive(ETopParam, args);
        if (err == KErrUnderflow)
            {
            // Increase the buffer size to receive the parameters from server...
            TInt maxLen = buffer->Des().MaxLength();
            CleanupStack::PopAndDestroy(buffer);
            buffer = HBufC8::NewLC(maxLen * 2);
            }
        }
    while (err == KErrUnderflow);

    CleanupStack::Pop(buffer);
    return buffer;
    }

EXPORT_C TBool RSharedQueue::IsEmpty()
    {
    TPckgBuf<TBool> pckg;
    TIpcArgs args(&pckg);
    SendReceive(EIsEmpty, args);
    TBool res = pckg();
    return res;
    }



EXPORT_C TBool RSharedQueue::LockTop()
    {
    TPckgBuf<TBool> pckg;
    TIpcArgs args(&pckg);
    SendReceive(ELockTop, args);
    TBool res = pckg();
    return res;
    }

EXPORT_C void RSharedQueue::DoEmpty()   // added j
    {
      
        SendReceive(EDoEmpty);
    }