/*

* 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 "tsemaphore.h"

#include <sys/stat.h> 

#include <sys/wait.h> 

#include <fcntl.h>

#include <stdio.h>

#define MAXVAL 3

#define UNIX_BASE   TTime(MAKE_TINT64(0x00dcddb3,0x0f2f8000))

#define MESSAGE_Q_KEY 1000

#define WITH_ERROR 1

#define WITHOUT_ERROR 0

#define IPC_KEY 1000

#define IPC_CREAT_EXCL 3000

#define IPC_NO_CREAT_EXCL 2000

#define INVALID_SEM_COMMAND 1024

#define TH_CASE_SEMOP_NEGATIVE_VAL 1024

#define TH_CASE_SEMOP_ZERO_VAL 1025

#define MAX_SEM_OPS 3

#define RETURN_ON_ERROR(err) if ( err ) \

            { \

            ERR_PRINTF2(KFunc, err); \

            return err; \

            }

TInt iFlag;  

TInt CTestSemaphore::SemKey(  TInt& aKey )

    {

    _LIT(KFunc, "SemKey");

    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 CTestSemaphore::SemNum(  TInt& aSemNum )

    {

    _LIT(KFunc, "SemNum");

    INFO_PRINTF1 ( KFunc);

    _LIT( KaSemNum, "Param%d" );

	TBuf<8> pNameBuf;

    pNameBuf.Format(KaSemNum,++iParamCnt);

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

	if(!res)

		{

	 	_LIT(Kerr , "Unable to retrieve semaphore number") ;

	 	INFO_PRINTF1(Kerr) ;

	 	return KErrGeneral ;

		}

    return KErrNone;

    }

TInt CTestSemaphore::SemFlag(  TInt& aFlag )

    {

    _LIT(KFunc, "SemFlag");

    INFO_PRINTF1 ( KFunc);

    _LIT( KaFlag, "Param%d" );

	TBuf<8> pNameBuf;

    pNameBuf.Format(KaFlag,++iParamCnt);

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

	if(!res)

		{

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

	 	INFO_PRINTF1(Kerr) ;

	 	return KErrGeneral ;

		}

    return KErrNone;

    }

TInt CTestSemaphore::SemOpVal(  TInt& aSemOp )

    {

    _LIT(KFunc, "SemOpVal");

    INFO_PRINTF1 ( KFunc);

    _LIT( KaSemOp, "Param%d" );

	TBuf<8> pNameBuf;

    pNameBuf.Format(KaSemOp,++iParamCnt);

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

	if(!res)

		{

	 	_LIT(Kerr , "Unable to retrieve semaphore operation value");

	 	ERR_PRINTF1(Kerr);

	 	return KErrGeneral ;

		}

    return KErrNone;

    }

TInt CTestSemaphore::ErrCode(  TInt& aErrCode )

    {

    _LIT(KFunc, "ErrCode");

    INFO_PRINTF1 ( KFunc());

    _LIT( KaErrCode, "Param%d" );

	TBuf<8> 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;

    }

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

// CTestSemaphore::SemNCreate

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

//

TInt CTestSemaphore::SemNCreate(  )

    {

    _LIT(KFunc, "SemCreate");

    INFO_PRINTF1 ( KFunc);

    TInt key;

    TInt semFlag;

    TInt terror;

    TInt retVal = KErrNone;

    TInt numberOfSem = 0;

    // retrieve passed parameters

    retVal = SemKey( key);

    RETURN_ON_ERROR(retVal);

    retVal = SemNum( iSemNum);

    RETURN_ON_ERROR(retVal);

    retVal = SemFlag( semFlag);

    RETURN_ON_ERROR(retVal);

    retVal = ErrCode( terror);

    RETURN_ON_ERROR(retVal);

    retVal = SemNum( numberOfSem);

    RETURN_ON_ERROR(retVal);

    TInt semid = 0;

    int startIndex = 0;

    TInt index = 0;

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

        {

        if(iNumberOfCreateSem[index] == -1)

            {

            startIndex = index;

            break;

            }

        }

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

        {

        semid = semget(key +index, iSemNum, semFlag);

        if(semid == -1) 

            {

            break;

            }

        iNumberOfCreateSem[startIndex + index] = semid;            

        }

    if (semid == -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 eror code") ;

			 	INFO_PRINTF1(Kerr) ;

			 	return KErrGeneral ;

				}

            if ( errCode == errno)

                {

                retVal = KErrNone;

                }

            }

        }

    else

        {

        if(terror == WITH_ERROR)

            {

            retVal = errno;

            }

        }

    if(retVal != KErrNone && index < numberOfSem && numberOfSem > 1)

        {

        // do the cleanup

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

            {

            if(iNumberOfCreateSem[index] > 0)

                semctl(iNumberOfCreateSem[index], iSemNum, IPC_RMID);

            }

        }

    //DebugLogPrintL ( KFunc(), OUT, retVal);

    return retVal;

    }

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

// CTestSemaphore::SemNClose

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

//

TInt CTestSemaphore::SemNClose(  )

    {

    _LIT(KFunc, "SemClose");

    INFO_PRINTF1 ( KFunc);

    TInt retVal = KErrNone;

    TInt terror;

    retVal = ErrCode( terror);

    RETURN_ON_ERROR(retVal);

    TInt err = KErrNone;

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

        {

        if(iNumberOfCreateSem[index] > 0)

            err = semctl(iNumberOfCreateSem[index], iSemNum, IPC_RMID);

        }

    if (err == -1)

        {

        if(terror == WITHOUT_ERROR)

            {

            retVal = errno;

            }

        }

    else

        {

        if(terror == WITH_ERROR)

            {

            retVal = errno;

            }

        }

	return retVal;

    }

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

// CTestSemaphore::SemCreate

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

//

TInt CTestSemaphore::SemCreate(  )

    {

    _LIT(KFunc, "SemCreate");

    INFO_PRINTF1 ( KFunc);

    TInt key;

    TInt semFlag;

    TInt terror;

    TInt retVal = KErrNone;

    // retrieve passed parameters

    retVal = SemKey( key);

    RETURN_ON_ERROR(retVal);

    retVal = SemNum( iSemNum);

    RETURN_ON_ERROR(retVal);

    retVal = SemFlag( semFlag);

    RETURN_ON_ERROR(retVal);

    retVal = ErrCode( terror);

    RETURN_ON_ERROR(retVal);

    TInt semid = semget(key, iSemNum, semFlag);

    if (semid == -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 eror code") ;

			 	INFO_PRINTF1(Kerr) ;

			 	return KErrGeneral ;

				}

            if ( errCode == errno)

                {

                retVal = KErrNone;

                }

            }

        }

    else

        {

        iNumberOfCreateSem[0] = semid;

        iKey = key;

        if(terror == WITH_ERROR)

            {

            retVal = errno;

            }

        }

	return retVal;

    }

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

// CTestSemaphore::SemOp

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

//

TInt CTestSemaphore::SemOp(  )

    {

    _LIT(KFunc, "SemOp");

    INFO_PRINTF1 ( KFunc);

    TInt key = iNumberOfCreateSem[0];

    TInt semnops;

    TInt terror;

    TInt retVal = KErrNone;

    // retrieve passed parameters

    if(iReadSemIdFlag)

        {

        retVal = SemKey( key);

        RETURN_ON_ERROR(retVal);

        }

    // nsops

    _LIT( Ksemnops, "Param%d" );

	TBuf<8> pNameBuf;

	pNameBuf.Format(Ksemnops,++iParamCnt);

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

	 if(!res)

		{

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

	 	ERR_PRINTF1(Kerr) ;

	 	return KErrGeneral ;

		}

    if(semnops > MAX_SEM_OPS)

        {

        return KErrGeneral;

        }

    struct sembuf lSemBuf[MAX_SEM_OPS];

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

        {

        TInt sem_num;

        TInt sem_op;

        TInt sem_flg;

		_LIT( Ksem_num, "Param%d" );

		TBuf<8> pNameBuf;

		pNameBuf.Format(Ksem_num,++iParamCnt);

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

		if(!res)

			{

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

		 	ERR_PRINTF1(Kerr) ;

		 	return KErrGeneral ;

			}

    	_LIT( Ksem_op, "Param%d" );

		pNameBuf.Zero();

		pNameBuf.Format(Ksem_op,++iParamCnt);

		res = GetIntFromConfig(ConfigSection(), pNameBuf, sem_op);

		if(!res)

			{

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

		 	ERR_PRINTF1(Kerr) ;

		 	return KErrGeneral ;

			}

        _LIT( Ksem_flg, "Param%d" );

		pNameBuf.Zero();

		pNameBuf.Format(Ksem_flg,++iParamCnt);

		res = GetIntFromConfig(ConfigSection(), pNameBuf, sem_flg);

		if(!res)

			{

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

		 	ERR_PRINTF1(Kerr) ;

		 	return KErrGeneral ;

			}

        lSemBuf[index].sem_num = sem_num;

        lSemBuf[index].sem_op = sem_op;

        lSemBuf[index].sem_flg = sem_flg;

        }

    retVal = ErrCode( terror);

    RETURN_ON_ERROR(retVal);

    iSemopStartFlag = ETrue;

    TInt err = semop(key, &lSemBuf[0], semnops);

    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 eror code") ;

			 	INFO_PRINTF1(Kerr) ;

			 	return KErrGeneral ;

				}

            if ( errCode == errno)

                {

                retVal = KErrNone;

                }

            }

        }

    else

        {

        if(terror == WITH_ERROR)

            {

            retVal = errno;

            }

        }

    return retVal;

    }

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

// CTestSemaphore::SemCtl

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

//

TInt CTestSemaphore::SemCtl(  )

    {

    _LIT(KFunc, "SemCtl");

    INFO_PRINTF1 ( KFunc);

    TInt key = iNumberOfCreateSem[0];

    TInt semCmd,err1;

    TInt terror;

    TInt retVal = KErrNone;

    TInt semNum;

    // retrieve passed parameters

    if(iReadSemIdFlag)

        {

        retVal = SemKey( key);

        RETURN_ON_ERROR(retVal);

        }

    retVal = SemNum( semNum);

    RETURN_ON_ERROR(retVal);

    // semaphore command

    retVal = SemNum( semCmd);

    RETURN_ON_ERROR(retVal);

    retVal = ErrCode( terror);

    RETURN_ON_ERROR(retVal);

	union semun psemun;

	psemun.array = NULL;

	psemun.buf = NULL;

	TInt expectedReturn = 0;

    TInt semNumbers = 0;

    TInt seq = 0;

    TBool freeReq = EFalse;

    TBuf<8> pNameBuf;

    TBool res ;

    _LIT( KexpectedReturn, "Param%d" );

    switch(semCmd)

        {

        case IPC_RMID:

	  		pNameBuf.Format(KexpectedReturn,++iParamCnt);