/*

* Copyright (c) 2002-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:

*

*/

// INCLUDE FILES

#include "tmsgqueue.h"

#include <string.h>

#include <unistd.h>

#define MESSAGE_Q_KEY 1000

#define MESSAGE_Q_KEY1 1001

#define MESSAGE_Q_KEY_TH 1002

#define WITH_ERROR 1

#define WITHOUT_ERROR 0

#define MSGSZ 128

#define IPC_KEY 1000

#define IPC_CREAT_EXCL 3000

#define IPC_NO_CREAT_EXCL 2000

#define USE_DEFAULT_ID 1

static void* ThreadEntryRead(TAny* arg);

TInt MsgQueueGet();

TInt MsgQueueThread(int a);

TInt MsgQueueSend(int a);

TInt MsgQueueRecieve();

TInt MsgQueueDelete();

#define RETURN_ON_ERROR(err) if ( err ) \

            { \

            ERR_PRINTF2 ( KFunc, err); \

            return err; \

            }

typedef struct 

		{

        long    mtype;

        char    mtext[4097];

        } message_buf;

TInt CTestMsgqueue::MsgKey(  TInt& aKey )

    {

    _LIT(KFunc, "MsgKey");

    INFO_PRINTF1 ( KFunc);

    _LIT( KaKey, "Param%d" );

    TBuf<8> pNameBuf;

    pNameBuf.Format(KaKey,++iParamCnt);

	TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, aKey);

	if(!res)

		{

	 	_LIT(Kerr , "Unable to retrieve aKey") ;

	 	INFO_PRINTF1(Kerr) ;

	 	return KErrGeneral;

		}

    return KErrNone;

    }

TInt CTestMsgqueue::MsgFlag(  TInt& aFlag )

    {

    _LIT(KFunc, "MsgFlag");

    INFO_PRINTF1 ( KFunc);

    _LIT( KaFlag, "Param%d" );

	TBuf<16> pNameBuf;

    pNameBuf.Format(KaFlag,++iParamCnt);

	TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, aFlag);

	if(!res)

		{

	 	_LIT(Kerr , "Unable to retrieve message flag") ;

	 	INFO_PRINTF1(Kerr) ;

	 	return KErrGeneral;

		}

    return KErrNone;

    }

TInt CTestMsgqueue::MsgId(  TInt& aId )

    {

    _LIT(KFunc, "MsgId");

    INFO_PRINTF1 ( KFunc);

    _LIT( KaId, "Param%d" );

	TBuf<16> pNameBuf;

    pNameBuf.Format(KaId,++iParamCnt);

	TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, aId);

	if(!res)

		{

	 	_LIT(Kerr , "Unable to retrieve message Id") ;

	 	INFO_PRINTF1(Kerr) ;

		}

    if ( aId == USE_DEFAULT_ID )

        {

        aId = iNoOfMsqIds[0];

        }    

    return KErrNone;

    }

TInt CTestMsgqueue::MsgCmd(  TInt& aCmd )

    {

    _LIT(KFunc, "MsgCmd");

    INFO_PRINTF1( KFunc);

    _LIT( KaCmd, "Param%d" );

	TBuf<16> pNameBuf;

	pNameBuf.Format(KaCmd,++iParamCnt);

	TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, aCmd);

	if(!res)

		{

	 	_LIT(Kerr , "Unable to retrieve command") ;

	 	INFO_PRINTF1(Kerr) ;

		}

    return KErrNone;

    } 

TInt CTestMsgqueue::MsgType(  TInt& aType )

    {

    _LIT(KFunc, "MsgType");

    INFO_PRINTF1( KFunc);

    _LIT( KaType, "Param%d" );

	TBuf<16> pNameBuf;

    pNameBuf.Format(KaType,++iParamCnt);

	TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, aType);

	if(!res)

		{

	 	_LIT(Kerr , "Unable to retrieve message type") ;

	 	INFO_PRINTF1(Kerr) ;

		return KErrGeneral;

		}

    return KErrNone;

    }    

TInt CTestMsgqueue::MsgLen(  TInt& aLen )

    {

    _LIT(KFunc, "MsgLen");

    INFO_PRINTF1( KFunc);

    _LIT( KaLen, "Param%d" );

	TBuf<16> pNameBuf;

    pNameBuf.Format(KaLen,++iParamCnt);

	TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, aLen);

	if(!res)

		{

	 	_LIT(Kerr , "Unable to retrieve message length") ;

	 	INFO_PRINTF1(Kerr) ;

		return KErrGeneral;

		}

    return KErrNone;

    }

TInt CTestMsgqueue::MsgSegs(  TInt& aSegs )

    {

    _LIT(KFunc, "MsgSegs");

    INFO_PRINTF1( KFunc);

    _LIT( KaSegs, "Param%d" );

	TBuf<16> pNameBuf;

    pNameBuf.Format(KaSegs,++iParamCnt);

	TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, aSegs);

	if(!res)

		{

	 	_LIT(Kerr , "Unable to retrieve message flag") ;

	 	INFO_PRINTF1(Kerr) ;

	 	return KErrGeneral;

		}

    return KErrNone;

    }       

TInt CTestMsgqueue::ErrCode(  TInt& aErrCode )

    {

    _LIT(KFunc, "ErrCode");

    INFO_PRINTF1( KFunc);

    _LIT( KaErrCode, "Param%d" );

	TBuf<16> pNameBuf;

    pNameBuf.Format(KaErrCode,++iParamCnt);

	TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, aErrCode);

	if(!res)

		{

	 	_LIT(Kerr , "Unable to retrieve error code") ;

	 	INFO_PRINTF1(Kerr) ;

		return KErrGeneral;

		}

    return KErrNone;

    }

TInt CTestMsgqueue::CheckMessageQueueStats(struct msqid_ds& buf)

	{

    _LIT(KFunc, "CheckMessageQueueStats");

    INFO_PRINTF1( KFunc);

    if ( buf.msg_cbytes != 0 )

        {

        return KErrGeneral;

        }

    if ( buf.msg_qnum != 0 )

        {

        return KErrGeneral;

        }

    if ( buf.msg_perm.key != IPC_KEY )

        {

        return KErrGeneral;

        }

    if ( buf.msg_qbytes != 2097152 )

        {

        return KErrGeneral;

        }   

    return KErrNone;

}

void CTestMsgqueue::SetMessageQueueParms(struct msqid_ds* /*buf*/)

	{

	}    

// -----------------------------------------------------------------------------

// CTestMsgqueue::MessageQueueCreate

// -----------------------------------------------------------------------------

//

TInt CTestMsgqueue::MessageQueueCreate(  )

    {

    _LIT(KFunc, "MessageQueueCreate");

    INFO_PRINTF1( KFunc);

    TInt key;

    TInt msgFlag;

    TInt msgSegs;

    TInt terror;

    TInt err;

    TInt i = 0;

    TInt msgid = -1;

    TInt retVal = KErrGeneral;

    // retrieve passed parameters

    err = MsgKey( key);

    RETURN_ON_ERROR(err);

    err = MsgFlag( msgFlag);

    RETURN_ON_ERROR(err);

    err = MsgSegs( msgSegs);

    RETURN_ON_ERROR(err);

    err = ErrCode( terror);

    RETURN_ON_ERROR(err);

    int startIndex = 0;

    TInt index = 0;

    for(index = 0; index < MAX_IPC_OBJ; index++)

        {

        if(iNoOfMsqIds[i] == -1)

            {

            startIndex = index;

            break;

            }

        }

    errno=0;

    for (i=0; i < msgSegs; i++)

        {

        msgid = msgget(key, msgFlag);

        if (msgid == -1)

			{

            break;        

			}

        iNoOfMsqIds[startIndex + i] = msgid;

        }    

    if (msgid == -1)

        {

        if(terror == WITHOUT_ERROR)

            {

            retVal = errno;

            }

        else

            {

            TInt errCode = 0;

            _LIT( KerrCode, "Param%d" );

			TBuf<8> pNameBuf;

		    pNameBuf.Format(KerrCode,++iParamCnt);

			TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, errCode);

			if(!res)

				{

			 	_LIT(Kerr , "Unable to retrieve error code") ;

			 	INFO_PRINTF1(Kerr) ;

			 	return KErrGeneral ;

				}

            if ( errCode == errno)

                {

                retVal = KErrNone;

                }

			}

        }

    else

        {

        if(terror != WITH_ERROR)

            {

            retVal = errno;

            }

        }

    	errno=0;    

    if(retVal != KErrNone && i < msgSegs && msgSegs > 1)

        {

        // do the cleanup

        for(index = startIndex; index < MAX_IPC_OBJ; index++)

            {

            if(iNoOfMsqIds[index] > 0)

				{

                msgctl(iNoOfMsqIds[index], IPC_RMID, 0);

				}

            }

        }        

	return retVal;

    }

// -----------------------------------------------------------------------------

// CTestMsgqueue::MessageQueueClose

// -----------------------------------------------------------------------------

//

TInt CTestMsgqueue::MessageQueueClose(  )

    {

    _LIT(KFunc, "MessageQueueClose");

    INFO_PRINTF1( KFunc);

    TInt retVal = KErrGeneral;

    TInt terror;

    TInt err;

    err = ErrCode( terror);

    RETURN_ON_ERROR(err);

    errno=0;

    for(TInt index = 0; index < MAX_IPC_OBJ; index++)

        {

        if(iNoOfMsqIds[index] >= 0)

			{

            err = msgctl(iNoOfMsqIds[index], IPC_RMID, 0);

			}

        }

    if (err == -1)

        {

        if(terror == WITHOUT_ERROR)

            {

            retVal = errno;

            }

        }

    else

        {

        errno = 0;

        if(terror != WITH_ERROR)

            {

            retVal = errno;

            }

        }

	return retVal;

    }

// -----------------------------------------------------------------------------

// CTestMsgqueue::MessageQueueControl

// -----------------------------------------------------------------------------

//

TInt CTestMsgqueue::MessageQueueControl(  )

    {

    _LIT(KFunc, "MessageQueueControl");

    INFO_PRINTF1( KFunc);

    TInt msqId;

    TInt msqCmd;

    TInt terror;

    TInt err;

    struct msqid_ds buf = {0};

    TInt retVal = KErrGeneral;

    // retrieve passed parameters

    err = MsgId( msqId);

    RETURN_ON_ERROR(err);

    err = MsgCmd( msqCmd);

    RETURN_ON_ERROR(err);

    if ( msqCmd == IPC_SET )

        {

        SetMessageQueueParms(&buf);

        }

    err = ErrCode( terror);

    RETURN_ON_ERROR(err);

    err = msgctl(msqId, msqCmd, &buf);

    if ( err == -1 )

        {

        if(terror == WITHOUT_ERROR)

            {

            retVal = errno;

            }

        else

            {

            TInt errCode = 0;

            _LIT( KerrCode, "Param%d" );

			 TBuf<8> pNameBuf;

		     pNameBuf.Format(KerrCode,++iParamCnt);

			 TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, errCode);

			 if(!res)

				{

			 	_LIT(Kerr , "Unable to retrieve error code") ;

			 	INFO_PRINTF1(Kerr) ;

			 	return KErrGeneral ;

				}

            if ( errCode == errno)

                {

                retVal = KErrNone;

                }

            }    

        }

    else

        {

        if ( msqCmd == IPC_STAT )

            {

            retVal = CheckMessageQueueStats(buf);

            }

        else if ( terror != WITH_ERROR )

            {

            retVal = KErrNone;

            }    

        }

    return retVal;

    }

void MessageCreate(TInt msgLen, TInt msgType, message_buf* buf  )

	{

    TInt i;

    buf->mtype = msgType;

    if (msgLen > 0 && msgLen <= 4096)

        {

        for (i=0; i< msgLen; i++)

            {

            buf->mtext[i] = 'a';

            }

        buf->mtext[i] = '\0';    

        }

    else 

        {

         buf->mtext[0] = '\0';

        }

	}

// -----------------------------------------------------------------------------

// CTestMsgqueue::CreateThread

// -----------------------------------------------------------------------------

//

TInt CTestMsgqueue::CreateThread(  )

	{

    _LIT(KFunc, "CreateThread");

    INFO_PRINTF1( KFunc);

    TInt threadType = -1;

    message_buf buf = {0};

    _LIT( KthreadType, "Param%d" );

	TBuf<16> pNameBuf;

	TInt err = KErrNone;

	pNameBuf.Format(KthreadType,++iParamCnt);

	TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, threadType);

	if(!res)

		{

	 	_LIT(Kerr , "Unable to retrieve eror code") ;

	 	INFO_PRINTF1(Kerr) ;

	 	return KErrGeneral ;

		}

    switch(threadType)

        {

        case 1: 

            iBlocked = 0;

            err = pthread_create((unsigned int *)&iThreadId,(pthread_attr_t *)NULL,ThreadEntryFunctionRead,(void*)this);

            if (!err)

                {

                err = SendMessage();

                }

            break;

        case 2:

            err = pthread_create((unsigned int *)&iThreadId,(pthread_attr_t *)NULL,ThreadEntryFunctionDestroyQ,(void*)this);

            if (!err)

                {

                err = RecvMessage();

                }

            break;

        case 3:

            iBlocked = 0;

            err = pthread_create((unsigned int *)&iThreadId,(pthread_attr_t *)NULL,ThreadEntryFunctionWrite,(void*)this);

            while(!iBlocked)

                {

                User::After(100000);

                }

            // fake msgctl...

            iBlocked = 0;

            msgctl(iNoOfMsqIds[0], IPC_STAT, (struct msqid_ds *)&buf);

            err = MessageQueueRecv();

            /*while(!iBlocked)

                {

                User::After(100000);

                }*/

            err = (iErrno) ?KErrGeneral : KErrNone;

            break;

        case 4:

            iBlocked = 0;

            err = pthread_create((unsigned int *)&iThreadId,(pthread_attr_t *)NULL,ThreadEntryFunctionWrite,(void*)this);

            while(!iBlocked)

                {

                User::After(100000);

                }

            // fake msgctl...

            iBlocked = 0; // again we want to block

            msgctl(iNoOfMsqIds[0], IPC_STAT, (struct msqid_ds *)&buf);

            err = msgctl(iNoOfMsqIds[0], IPC_RMID, 0);/*

            while(!iBlocked)