diff -r 000000000000 -r e4d67989cc36 genericopenlibs/openenvcore/libc/test/testmsgqueue/src/tmsgqueueblocks.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/genericopenlibs/openenvcore/libc/test/testmsgqueue/src/tmsgqueueblocks.cpp Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,2674 @@ +/* +* 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 +#include +#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) + { + User::After(100000); + }*/ + if (err == KErrNone) + { + err = (iErrno == EIDRM) ?KErrNone : KErrGeneral; + } + break; + default: + err = KErrNone; + break; + } + if ( err ) + { + ERR_PRINTF2 ( _L("pthread_create error:%d"), err); + } + return err; + } + +// ----------------------------------------------------------------------------- +// CTestMsgqueue::SendMessage +// ----------------------------------------------------------------------------- +// +TInt CTestMsgqueue::SendMessage() + { + _LIT(KFunc, "SendMessage"); + INFO_PRINTF1( KFunc); + + TInt msqId; + TInt msgType; + TInt msqFlag; + TInt terror; + TInt err; + message_buf buf = {0}; + TInt msgLen; + TInt retVal = KErrGeneral; + + // retrieve passed parameters + err = MsgId( msqId); + RETURN_ON_ERROR(err); + + err = MsgLen( msgLen); + RETURN_ON_ERROR(err); + + err = MsgType( msgType); + RETURN_ON_ERROR(err); + + err = MsgFlag( msqFlag); + RETURN_ON_ERROR(err); + + err = ErrCode( terror); + RETURN_ON_ERROR(err); + + MessageCreate(msgLen, msgType, &buf); + + while (iBlocked == 0) + { + User::After(100000); + } + err = msgsnd(msqId, &buf, msgLen, msqFlag); + + 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 ( terror != WITH_ERROR) + { + TInt tmout = 0; + while (iBlocked && (tmout < 5)) + { + User::After(10000); + tmout++; + } + retVal = (iBlocked == 0) ?KErrNone: KErrGeneral; + } + } + + return retVal; + } +// ----------------------------------------------------------------------------- +// CTestMsgqueue::RecvMessage +// ----------------------------------------------------------------------------- +// +TInt CTestMsgqueue::RecvMessage() + { + _LIT(KFunc, "RecvMessage"); + INFO_PRINTF1( KFunc); + + TInt msgType; + TInt msqFlag = 0; + TInt err; + TInt terror; + message_buf buf = {0}; + TInt msgLen = 128; + TInt retVal = KErrGeneral; + + err = ErrCode( terror); + RETURN_ON_ERROR(err); + + msgType = 0; //any message + msqFlag = ~IPC_NOWAIT; //Blocking + + iBlocked = 1; + + + char array[128+1]; + for(int idx=0; idx<128; idx++) + { + array[idx]='a'; + } + array[128]='\0'; + + + err = msgrcv(iNoOfMsqIds[0], &buf, msgLen, msgType, msqFlag); + while (!iBlocked) + { + User::After(10000); + } + + 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 ( terror != WITH_ERROR && (msgLen>0 && msgLen<256) && !(strncmp(&buf.mtext[0], &array[0], msgLen))) + { + retVal = KErrNone; + } + } + + return retVal; + } +//----------------------------------------------------------------------------- +//CTestMsgqueue::ThreadEntryFunctionRead +//----------------------------------------------------------------------------- + +void* CTestMsgqueue::ThreadEntryFunctionRead(void* arg) + { + TInt msgType; + TInt msqFlag = 0; + TInt err; + message_buf buf = {0}; + TInt msgLen = 128; + CTestMsgqueue *self = static_cast (arg); + + TInt msqId = msgget(IPC_KEY, 0); + if ( msqId < 0) + { + return NULL; + } + msgType = 0; //any message + msqFlag = ~IPC_NOWAIT; //Blocking + + self->iBlocked = 1; + + err = msgrcv(msqId, &buf, msgLen, msgType, msqFlag); + + if ((err > 0) && (self->iBlocked)) + { + self->iBlocked = 0; + } + return NULL; + } +//----------------------------------------------------------------------------- +//CTestMsgqueue::ThreadEntryFunctionWrite +//----------------------------------------------------------------------------- + +void* CTestMsgqueue::ThreadEntryFunctionDestroyQ(void* arg) + { + message_buf buf = {0}; + CTestMsgqueue *self = static_cast (arg); + + while (!self->iBlocked) + { + User::After(10000); + } + self->iBlocked = 0; + TInt msqId = msgget(IPC_KEY, 0); + if ( msqId < 0) + { + return NULL; + } + + msgctl(msqId, IPC_STAT, (struct msqid_ds *)&buf); + msgctl(msqId, IPC_RMID, 0); + self->iBlocked = 1; + + return NULL; + } +//----------------------------------------------------------------------------- +//CTestMsgqueue::ThreadEntryFunctionWrite +//----------------------------------------------------------------------------- + +void* CTestMsgqueue::ThreadEntryFunctionWrite(void* arg) + { + TInt msgType; + TInt msqFlag = 0; + HBufC8* messPtr = HBufC8::NewLC(65295); + char *bufPtr = (char*)messPtr->Des().PtrZ(); + + struct msg_buf{ + long mtype; + char mtext[1]; + }; + struct msg_buf *pMess = (struct msg_buf *)bufPtr; + TInt msgLen = 4090; + CTestMsgqueue *self = static_cast (arg); + + TInt msqId = msgget(IPC_KEY, 0); + if ( msqId < 0) + { + return NULL; + } + msgType = 1; //any message + msqFlag = ~IPC_NOWAIT; //Blocking + + memset(pMess, 0, 65295); + pMess->mtype = msgType; + pMess->mtext[msgLen + 4] = '\0'; + self->iBlocked = 1; + msgsnd(msqId, pMess, msgLen, msqFlag); + self->iBlocked = 1; + self->iErrno = errno; + CleanupStack::PopAndDestroy(); + return NULL; + } +// ----------------------------------------------------------------------------- +// CTestMsgqueue::MessageQueueSend +// ----------------------------------------------------------------------------- +// +TInt CTestMsgqueue::MessageQueueSend( ) + { + _LIT(KFunc, "MessageQueueSend"); + INFO_PRINTF1( KFunc); + + TInt msqId = -1; + TInt msgType; + TInt msqFlag; + TInt terror; + TInt err; + message_buf buf = {0}; + TInt msgLen; + TInt retVal = KErrGeneral; + + // retrieve passed parameters + err = MsgId( msqId); + RETURN_ON_ERROR(err); + + err = MsgLen( msgLen); + RETURN_ON_ERROR(err); + + err = MsgType( msgType); + RETURN_ON_ERROR(err); + + err = MsgFlag( msqFlag); + RETURN_ON_ERROR(err); + + err = ErrCode( terror); + RETURN_ON_ERROR(err); + + MessageCreate(msgLen, msgType, &buf); + + err = msgsnd(msqId, &buf, msgLen, msqFlag); + + 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 ( terror != WITH_ERROR ) + { + retVal = KErrNone; + } + } + + return retVal; + } + +// ----------------------------------------------------------------------------- +// CTestMsgqueue::MessageQueueRecv +// ----------------------------------------------------------------------------- +// +TInt CTestMsgqueue::MessageQueueRecv( ) + { + _LIT(KFunc, "MessageQueueRecv"); + INFO_PRINTF1( KFunc); + + TInt msqId; + TInt msgType; + TInt msqFlag; + TInt terror; + TInt err; + message_buf buf = {0}; + TInt msgLen; + TInt retVal = KErrGeneral; + + // retrieve passed parameters + err = MsgId( msqId); + RETURN_ON_ERROR(err); + + err = MsgLen( msgLen); + RETURN_ON_ERROR(err); + + err = MsgType( msgType); + RETURN_ON_ERROR(err); + + err = MsgFlag( msqFlag); + RETURN_ON_ERROR(err); + + err = ErrCode( terror); + RETURN_ON_ERROR(err); + + char array[256]; + for(int idx=0; idx<255; idx++) + { + array[idx]='a'; + } + array[255]='\0'; + + err = msgrcv(msqId, &buf, msgLen, msgType, msqFlag); + + 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 ( terror != WITH_ERROR && ( msgType <= 0 || buf.mtype == msgType)) + { + if((msgLen>0 && msgLen<256) && !(strncmp(&buf.mtext[0], &array[0], msgLen))) + retVal = KErrNone; + } + } + + return retVal; + } + + +TInt CTestMsgqueue::IntgTest1() + { + + TInt err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueClose(); + } + return err; + } + +TInt CTestMsgqueue::IntgTest2() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueClose(); + } + } + return err; + } + + +TInt CTestMsgqueue::IntgTest3() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueControl(); + if(!err) + { + err = MessageQueueClose(); + } + } + return err; + } + +TInt CTestMsgqueue::IntgTest4() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueSend(); + if(!err) + { + err = MessageQueueRecv(); + if(!err) + { + err = MessageQueueClose(); + } + } + } + return err; + } + +TInt CTestMsgqueue::IntgTest5() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueSend(); + if(!err) + { + err = MessageQueueClose(); + } + } + return err; + } + +TInt CTestMsgqueue::IntgTest6() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueSend(); + if(!err) + { + err = MessageQueueSend(); + if(!err) + { + err = MessageQueueClose(); + } + } + } + return err; + } + +TInt CTestMsgqueue::IntgTest7() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueRecv(); + if(!err) + { + err = MessageQueueClose(); + } + } + return err; + } + +TInt CTestMsgqueue::IntgTest8() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueSend(); + if(!err) + { + err = MessageQueueRecv(); + if(!err) + { + err = MessageQueueRecv(); + if(!err) + { + err = MessageQueueClose(); + } + } + } + } + return err; + } + +TInt CTestMsgqueue::IntgTest9() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueSend(); + if(!err) + { + err = MessageQueueRecv(); + if(!err) + { + err = MessageQueueControl(); + if(!err) + { + err = MessageQueueClose(); + } + } + } + } + return err; + } + + +TInt CTestMsgqueue::IntgTest10() + { + TInt err = MessageQueueCreate(); + if(err) + { + return err; + } + err = MessageQueueSend(); + if(err) + { + return err; + } + err = MessageQueueSend(); + if(err) + { + return err; + } + err = MessageQueueSend(); + if(err) + { + return err; + } + err = MessageQueueRecv(); + if(err) return err; + if(err) + { + return err; + } + if(err) return err; + if(err) + { + return err; + } + if(err) return err; + if(err) + { + return err; + } + MessageQueueClose(); + return err; + } + +TInt CTestMsgqueue::IntgTest11() + { + TInt err = MessageQueueCreate(); + if(err) + { + return err; + } + err = MessageQueueSend(); + if(err) + { + return err; + } + err = MessageQueueSend(); + if(err) + { + return err; + } + err = MessageQueueSend(); + if(err) + { + return err; + } + err = MessageQueueRecv(); + if(err) + { + return err; + } + err = MessageQueueRecv(); + if(err) + { + return err; + } + err = MessageQueueRecv(); + if(err) + { + return err; + } + err = MessageQueueRecv(); + if(err) + { + return err; + } + err = MessageQueueControl(); + if(err) + { + return err; + } + err = MessageQueueClose(); + return err; + } + +TInt CTestMsgqueue::IntgTest12() + { + TInt err = MessageQueueCreate(); + if(err) + { + return err; + } + err = MessageQueueSend(); + if(err) + { + return err; + } + err = MessageQueueSend(); + if(err) + { + return err; + } + err = MessageQueueRecv(); + if(err) + { + return err; + } + err = MessageQueueRecv(); + if(err) + { + return err; + } + err = MessageQueueControl(); + if(err) + { + return err; + } + err = MessageQueueClose(); + return err; + } + +TInt CTestMsgqueue::IntgTest13() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = CreateThread(); + if(!err) + { + err = MessageQueueClose(); + } + } + return err; + } + +TInt CTestMsgqueue::IntgTest14() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = CreateThread(); + } + return err; + } + +TInt CTestMsgqueue::IntgTest15() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueSend(); + if(!err) + { + err = CreateThread(); + if(!err) + { + err = MessageQueueClose(); + } + } + } + return err; + } + +TInt CTestMsgqueue::IntgTest16() + { + TInt err = MessageQueueCreate(); + if(!err) + { + for(int i=0;i<512;i++) + { + INFO_PRINTF2(_L("i is %d\n"),i); + err = MessageQueueSend(); + if(err!=0) + { + break; + } + } + if(!err) + { + err = CreateThread(); + } + } + return err; + } + +TInt CTestMsgqueue::IntgTest17() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueSend(); + if(!err) + { + err = MessageQueueRecv(); + if(!err) + { + err = MessageQueueSend(); + if(!err) + { + err = MessageQueueClose(); + } + } + } + } + return err; + } + +TInt CTestMsgqueue::IntgTest6_1() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueSend(); + if(!err) + { + for(int i=0;i<16;i++) + { + err = MessageQueueSend(); + if(err!=0) + { + break; + } + } + if(!err) + { + err = MessageQueueClose(); + } + } + } + return err; + } + + +/* +TInt CTestMsgqueue::IntgTest16() + { + int msq_id; + if ((msq_id = msgget(MESSAGE_Q_KEY, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + int err; + message_buf buf = {0}; + MessageCreate(4096, 1, &buf); + for(int i=0;i<16;i++) + { + err = msgsnd(msq_id, &buf, 4096, 2048); + } + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + } + +nt CTestMsgqueue::IntgTest6_1() + { + TInt err = MessageQueueCreate(); + if(!err) + { + err = MessageQueueSend(); + if(!err) + { + err = MessageQueueSend(); + err = MessageQueueSend(); + err = MessageQueueSend(); + err = MessageQueueSend(); + if(!err) + { + err = MessageQueueClose(); + } + } + } + return err; + } +*/ +////////////////////////////////////////////////////////////////////////// + + // MSGGET + +// with the specified key + +TInt CTestMsgqueue::msggettest1() + { + int msq_id; + + if ((msq_id = msgget(MESSAGE_Q_KEY, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + + return KErrNone; + } + +// with the IPC_PRIVATE flag + +TInt CTestMsgqueue::msggettest2() + { + int msq_id; + + if ((msq_id = msgget(IPC_PRIVATE , IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + return KErrNone; + } + +// Max no.of msg ids per process +// Check for the errno ENOSPC + +TInt CTestMsgqueue::msggettest3() + { + int msq_id[1512]; + + int i=0,j=0; + int ret = KErrNone; + for(i=0;;i++) + { + if ((msq_id[i] = msgget(IPC_PRIVATE , IPC_CREAT | 0666)) == -1) + { + if(errno == ENOSPC) + { + _LIT(KFunc, "Message Q create set the proper errno %d\n"); + INFO_PRINTF2(KFunc,i); + break; + } + else + { + _LIT(KFunc, "Message Q create didnt set the proper errno \n"); + INFO_PRINTF1(KFunc); + ret=KErrGeneral; + break; + } + } + } + + for(j=0;j pNameBuf; + + iParamCnt = 0; + _LIT( KaMsgNum, "Param%d" ); + + pNameBuf.Format(KaMsgNum,++iParamCnt); + TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, key); + if(!res) + { + _LIT(Kerr , "Unable to retrieve msg key") ; + INFO_PRINTF1(Kerr) ; + return KErrGeneral ; + } + + msgid = msgget(key, IPC_CREAT); + if( msgid < 0 ) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + + if (msgctl(msgid, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + + return KErrNone; + } + + // MSGCTL + +// check for the errno EINVAL with invalid + +TInt CTestMsgqueue::msgctltest1() + { + + if ((msgctl(-1, IPC_RMID, NULL) == -1) && errno == EINVAL ) + { + _LIT(KFunc, "msgctl set the proper errno\n"); + INFO_PRINTF1(KFunc); + return KErrNone; + } + + return KErrGeneral; + } + +// check for the errno EINVAL with invalid + +TInt CTestMsgqueue::msgctltest2() + { + int msq_id; + + if ((msq_id = msgget(IPC_PRIVATE, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + if ((msgctl(msq_id, -5, NULL) == -1) && errno == EINVAL) + { + _LIT(KFunc, "msgctl set the proper errno\n"); + INFO_PRINTF1(KFunc); + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + return KErrNone; + } + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + + return KErrGeneral; + } + +// get the details of the message queue with flag IPC_STAT + +TInt CTestMsgqueue::msgctltest3() + { + int msq_id,ret=KErrNone; + struct msqid_ds buf; + int msgflg = IPC_R|IPC_CREAT | IPC_EXCL | 0666; + if ((msq_id = msgget(MESSAGE_Q_KEY, msgflg)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + if (msgctl(msq_id, IPC_STAT, &buf) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + + if ( buf.msg_cbytes != 0 ) + { + ret= KErrGeneral; + } + if ( buf.msg_qnum != 0 ) + { + ret= KErrGeneral; + } + if ( buf.msg_perm.key != MESSAGE_Q_KEY ) + { + ret= KErrGeneral; + } + if ( buf.msg_qbytes != 2097152 ) + { + ret= KErrGeneral; + } + if( buf.msg_lspid != 0 ) + { + ret= KErrGeneral; + } + if( buf.msg_lrpid != 0 ) + { + ret= KErrGeneral; + } + if( buf.msg_stime != 0 ) + { + ret= KErrGeneral; + } + if( buf.msg_rtime != 0 ) + { + ret= KErrGeneral; + } + + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + return ret; + } + +// set the max # of bytes on the queue with IPC_SET flag + +TInt CTestMsgqueue::msgctltest4() + { + int msq_id; + struct msqid_ds buf; + struct msqid_ds buf1; + if ((msq_id = msgget(MESSAGE_Q_KEY, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + if (msgctl(msq_id, IPC_STAT, &buf) == -1) + { + _LIT(KFunc, "Message Q set failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + buf1=buf; + buf1.msg_qbytes = 65546; + if (msgctl(msq_id, IPC_SET, &buf1) == -1) + { + _LIT(KFunc, "Message Q set failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + + if (msgctl(msq_id, IPC_STAT, &buf) == -1) + { + _LIT(KFunc, "Message Q get failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + + if ( buf.msg_cbytes != 0 ) + { + return KErrGeneral; + } + if ( buf.msg_qnum != 0 ) + { + return KErrGeneral; + } + if ( buf.msg_perm.key != MESSAGE_Q_KEY ) + { + return KErrGeneral; + } + if ( buf.msg_qbytes != 65546 ) + { + return KErrGeneral; + } + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + return KErrNone; + } + +// check for the errno EACCESS without read permissions over IPC_STAT + +TInt CTestMsgqueue::msgctltest5() + { + int msq_id,ret=KErrNone,x; + struct msqid_ds buf; + if ((msq_id = msgget(IPC_PRIVATE, 0 )) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + x=msgctl(msq_id, IPC_STAT, &buf); + if ((x != -1) && errno != EACCES) + { + _LIT(KFunc, "Message Q didnt set the proper errno\n"); + INFO_PRINTF1(KFunc); + ret= KErrGeneral; + } + + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + return ret; + } + + + // MSGSND + +// check for the errno EIDRM + +TInt CTestMsgqueue::msgsndtest1() + { + int msq_id,len; + struct { + long mtype; + char mtext[128]; + } msg_buf; + + msg_buf.mtype = 1; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send"); /* data */ + len = strlen(msg_buf.mtext)+1; + + if ((msq_id = msgget(IPC_PRIVATE, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + + if ((msgsnd(msq_id, (struct msgbuf *)&msg_buf, len, IPC_NOWAIT) != -1) && errno != EIDRM) + { + _LIT(KFunc, "msgsnd failed in setting errno\n"); + INFO_PRINTF1(KFunc); + return KErrGeneral; + } + return KErrNone; + } + +// check for the errno EINVAL with invalid + +TInt CTestMsgqueue::msgsndtest2() + { + int msq_id=-1,len,ret=KErrGeneral; + struct { + long mtype; + char mtext[128]; + } msg_buf; + + msg_buf.mtype = 1; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send"); /* data */ + len = strlen(msg_buf.mtext)+1; + + if ((msgsnd(msq_id, (struct msgbuf *)&msg_buf, len, IPC_NOWAIT) == -1) && errno == EINVAL ) + { + _LIT(KFunc, "msgsnd set the proper errno\n"); + INFO_PRINTF1(KFunc); + ret=KErrNone; + } + + return ret; + } + +// check for the errno EINVAL with mtype<1 + +TInt CTestMsgqueue::msgsndtest3() + { + int msq_id=0,len,ret=KErrNone; + struct { + long mtype; + char mtext[128]; + } msg_buf; + + msg_buf.mtype = 0; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send"); /* data */ + len = strlen(msg_buf.mtext)+1; + + if ((msq_id = msgget(IPC_PRIVATE, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + + if ((msgsnd(msq_id, (struct msgbuf *)&msg_buf, len, IPC_NOWAIT) == -1) && errno == EINVAL ) + { + _LIT(KFunc, "msgsnd set the proper errno\n"); + INFO_PRINTF1(KFunc); + } + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + return ret; + } + +// check for the errno EINVAL with msgsz<0 +TInt CTestMsgqueue::msgsndtest4() + { + int msq_id=0,ret=KErrNone; + struct { + long mtype; + char mtext[128]; + } msg_buf; + + msg_buf.mtype = 1; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send"); /* data */ + int len = strlen(msg_buf.mtext)+1; + + if ((msq_id = msgget(IPC_PRIVATE, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + + if ((msgsnd(msq_id, (struct msgbuf *)&msg_buf, (size_t)-1, IPC_NOWAIT) == -1) && errno == EINVAL ) + { + _LIT(KFunc, "msgsnd set the proper errno\n"); + INFO_PRINTF1(KFunc); + } + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + return ret; + } + +// successful msgsnd + +TInt CTestMsgqueue::msgsndtest5() + { + int msq_id=0,len,ret=KErrNone; + struct msqid_ds buf; + struct { + long mtype; + char mtext[128]; + } msg_buf; + + msg_buf.mtype = 1; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send"); /* data */ + len = strlen(msg_buf.mtext)+1; + + if ((msq_id = msgget(IPC_PRIVATE, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf, len, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if (msgctl(msq_id, IPC_STAT, &buf) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + /* + if ( buf.msg_cbytes != len ) + { + ret= KErrGeneral; + }*/ + if ( buf.msg_qnum != 1 ) + { + ret= KErrGeneral; + } + if ( buf.msg_perm.key != IPC_PRIVATE ) + { + ret= KErrGeneral; + } + if ( buf.msg_qbytes != 2097152 ) + { + ret= KErrGeneral; + } + + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + return ret; + } + +// successful 2 msgsnd + +TInt CTestMsgqueue::msgsndtest6() + { + int msq_id=0,len,ret=KErrNone; + struct msqid_ds buf; + struct { + long mtype; + char mtext[128]; + } msg_buf; + + msg_buf.mtype = 1; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send"); /* data */ + len = strlen(msg_buf.mtext)+1; + + if ((msq_id = msgget(IPC_PRIVATE, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf, len, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf, len, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if (msgctl(msq_id, IPC_STAT, &buf) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + /* + if ( buf.msg_cbytes != (2*len) ) + { + ret= KErrGeneral; + } + */ + if ( buf.msg_qnum != 2 ) + { + ret= KErrGeneral; + } + if ( buf.msg_perm.key != IPC_PRIVATE ) + { + ret= KErrGeneral; + } + if ( buf.msg_qbytes != 2097152 ) + { + ret= KErrGeneral; + } + + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + return ret; + } + + // MSGRCV + + +// check for the errno EIDRM + +TInt CTestMsgqueue::msgrcvtest1() + { + int msq_id,len; + struct { + long mtype; + char mtext[128]; + } msg_buf; + + msg_buf.mtype = 1; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send"); /* data */ + len = strlen(msg_buf.mtext)+1; + + if ((msq_id = msgget(MESSAGE_Q_KEY, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + + if ((msgrcv(msq_id, (struct msgbuf *)&msg_buf, len,1, 0) != -1) && errno != EIDRM) + { + _LIT(KFunc, "msgsnd failed in setting errno\n"); + INFO_PRINTF1(KFunc); + return KErrGeneral; + } + return KErrNone; + } + +// check for the errno E2BIG + +TInt CTestMsgqueue::msgrcvtest2() + { + int msq_id=0,len,ret=KErrNone; + struct { + long mtype; + char mtext[128]; + } msg_buf; + + msg_buf.mtype = 1; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send"); /* data */ + len = strlen(msg_buf.mtext)+1; + + if ((msq_id = msgget(IPC_PRIVATE, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf, len, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if ((msgrcv(msq_id, (struct msgbuf *)&msg_buf, 15,1, 0) != -1) || errno != E2BIG) + { + _LIT(KFunc, "msgrcv failed in setting errno %d\n"); + INFO_PRINTF2(KFunc,errno); + return KErrGeneral; + } + + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + return ret; + } + +// check for the errno EINVAL + +TInt CTestMsgqueue::msgrcvtest3() + { + int msq_id=-1,len,ret=KErrNone; + struct { + long mtype; + char mtext[128]; + } msg_buf; + + msg_buf.mtype = 1; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send"); /* data */ + len = strlen(msg_buf.mtext)+1; + + if ((msgrcv(msq_id, (struct msgbuf *)&msg_buf, len,1, 0) != -1) && errno != EINVAL) + { + _LIT(KFunc, "msgsnd failed in setting errno\n"); + INFO_PRINTF1(KFunc); + return KErrGeneral; + } + + return ret; + } + + +// check for the errno ENOMSG + +TInt CTestMsgqueue::msgrcvtest4() + { + int msq_id,len; + struct { + long mtype; + char mtext[128]; + } msg_buf,msg_buf1; + + msg_buf.mtype = 1; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send"); /* data */ + len = strlen(msg_buf.mtext)+1; + + if ((msq_id = msgget(IPC_PRIVATE, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf, len, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + return KErrGeneral; + } + + if ((msgrcv(msq_id, (struct msgbuf *)&msg_buf1, len,3, IPC_NOWAIT) != -1) && errno != ENOMSG) + { + _LIT(KFunc, "msgsnd failed in setting errno\n"); + INFO_PRINTF1(KFunc); + return KErrGeneral; + } + + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + + return KErrNone; + } + + // MSGSND & MSGRCV + +TInt CTestMsgqueue::sndrcvtest1() + { + int msq_id=0,len,ret=KErrNone; + struct msqid_ds buf= {0}; + struct { + long mtype; + char mtext[128]; + } msg_buf,msg_buf1; + + msg_buf.mtype = 1; // message identifier + strcpy(msg_buf.mtext, "some_data_to_send"); // data + len = strlen(msg_buf.mtext)+1; + + if ((msq_id = msgget(MESSAGE_Q_KEY1, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf, len, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if ((msgrcv(msq_id, (struct msgbuf *)&msg_buf1, len,1, 0) == -1)) + { + _LIT(KFunc, "msgsnd failed in setting errno %d\n"); + INFO_PRINTF2(KFunc,errno); + return KErrGeneral; + } + + if(msg_buf1.mtype != 1) + { + return KErrGeneral; + } + if( (strcmp(msg_buf1.mtext,msg_buf.mtext)) ) + { + return KErrGeneral; + } + if ( buf.msg_qnum != 0 ) + { + ret= KErrGeneral; + } + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + return ret; + } +/* + +TInt CTestMsgqueue::sndrcvtest1() + { + int msq_id=0,len,ret=KErrNone; + struct msqid_ds buf= {0}; + struct { + long mtype; + char mtext[128]; + } msg_buf,msg_buf1; + + msg_buf.mtype = 1; // message identifier + strcpy(msg_buf.mtext, "some_data_to_send"); // data + len = strlen(msg_buf.mtext)+1; + + if ((msq_id = msgget(MESSAGE_Q_KEY1, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf, len, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if ((msgrcv(msq_id, (struct msgbuf *)&msg_buf1, len-1,1, MSG_NOERROR) == -1)) + { + _LIT(KFunc, "msgsnd failed in setting errno %d\n"); + INFO_PRINTF2(KFunc,errno); + return KErrGeneral; + } + + if(msg_buf1.mtype != 1) + { + return KErrGeneral; + } + if( (strcmp(msg_buf1.mtext,msg_buf.mtext)) ) + { + return KErrGeneral; + } + if ( buf.msg_qnum != 0 ) + { + ret= KErrGeneral; + } + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + return ret; + }*/ + +// If msgtyp is 0, the first message on the queue shall be received. +TInt CTestMsgqueue::sndrcvtest2() + { + int msq_id=0,len1,len2,ret=KErrNone; + struct msqid_ds buf= {0}; + struct { + long mtype; + char mtext[128]; + } msg_buf,msg_buf1,msg_buf2; + + msg_buf.mtype = 1; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send1"); /* data */ + len1 = strlen(msg_buf.mtext)+1; + + msg_buf1.mtype = 2; /* message identifier */ + strcpy(msg_buf1.mtext, "some_data_to_send2"); /* data */ + len2 = strlen(msg_buf1.mtext)+1; + + if ((msq_id = msgget(MESSAGE_Q_KEY1, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf, len1, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd1 failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf1, len2, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd2 failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if ((msgrcv(msq_id, (struct msgbuf *)&msg_buf2, 100,0, 0) == -1)) + { + _LIT(KFunc, "msgsnd failed in setting errno %d\n"); + INFO_PRINTF2(KFunc,errno); + return KErrGeneral; + } + + if (msgctl(msq_id, IPC_STAT, &buf) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + return KErrGeneral; + } + + if(msg_buf2.mtype != 1) + { + return KErrGeneral; + } + if( (strcmp(msg_buf2.mtext,msg_buf.mtext)) ) + { + return KErrGeneral; + } + if ( buf.msg_qnum != 1 ) + { + ret= KErrGeneral; + } + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + return ret; + } + +// If msgtyp is greater than 0, the first message of type msgtyp shall be received. + +TInt CTestMsgqueue::sndrcvtest3() + { + int msq_id=0,len1,len2,len3,ret=KErrNone; + + struct { + long mtype; + char mtext[128]; + } msg_buf,msg_buf1,msg_buf2,msg_buf3; + + msg_buf.mtype = 1; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send1"); /* data */ + len1 = strlen(msg_buf.mtext)+1; + + msg_buf1.mtype = 2; /* message identifier */ + strcpy(msg_buf1.mtext, "some_data_to_send2"); /* data */ + len2 = strlen(msg_buf1.mtext)+1; + + msg_buf3.mtype = 2; /* message identifier */ + strcpy(msg_buf3.mtext, "some_data_to_send3"); /* data */ + len3 = strlen(msg_buf3.mtext)+1; + + if ((msq_id = msgget(MESSAGE_Q_KEY1, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf, len1, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd1 failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf1, len2, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd2 failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf3, len3, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd3 failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if ((msgrcv(msq_id, (struct msgbuf *)&msg_buf2, 100,2, 0) == -1)) + { + _LIT(KFunc, "msgsnd failed in setting errno %d\n"); + INFO_PRINTF2(KFunc,errno); + return KErrGeneral; + } + + if(msg_buf2.mtype != 2) + { + return KErrGeneral; + } + if( (strcmp(msg_buf2.mtext,msg_buf1.mtext)) ) + { + return KErrGeneral; + } + + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + return ret; + } + +// If msgtyp is less than 0, the first message of the lowest type that is +// less than or equal to the absolute value of msgtyp shall be received. + +TInt CTestMsgqueue::sndrcvtest4() + { + int msq_id=0,len1,len2,len3,ret=KErrNone; + + struct { + long mtype; + char mtext[128]; + } msg_buf,msg_buf1,msg_buf2,msg_buf3; + + msg_buf.mtype = 3; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send1"); /* data */ + len1 = strlen(msg_buf.mtext)+1; + + msg_buf1.mtype = 2; /* message identifier */ + strcpy(msg_buf1.mtext, "some_data_to_send2"); /* data */ + len2 = strlen(msg_buf1.mtext)+1; + + msg_buf3.mtype = 1; /* message identifier */ + strcpy(msg_buf3.mtext, "some_data_to_send3"); /* data */ + len3 = strlen(msg_buf3.mtext)+1; + + if ((msq_id = msgget(MESSAGE_Q_KEY1, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + _LIT(KFunc, "Message Q create failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf, len1, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd1 failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf1, len2, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd2 failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if (msgsnd(msq_id, (struct msgbuf *)&msg_buf3, len3, IPC_NOWAIT) != 0) + { + _LIT(KFunc, "msgsnd3 failed with errno %d\n"); + INFO_PRINTF2(KFunc,errno); + ret = KErrGeneral; + } + + if ((msgrcv(msq_id, (struct msgbuf *)&msg_buf2, 100,-2, 0) == -1)) + { + _LIT(KFunc, "msgsnd failed in setting errno %d\n"); + INFO_PRINTF2(KFunc,errno); + return KErrGeneral; + } + + if(msg_buf2.mtype != 1) + { + return KErrGeneral; + } + if( (strcmp(msg_buf2.mtext,msg_buf3.mtext)) ) + { + return KErrGeneral; + }/* + if ( buf.msg_qnum != 2 ) + { + ret= KErrGeneral; + }*/ + if (msgctl(msq_id, IPC_RMID, NULL) == -1) + { + _LIT(KFunc, "Message Q delete failed with errno %d\n"); + INFO_PRINTF2(KFunc, errno); + ret= KErrGeneral; + } + return ret; + } + + // THREADS + +TInt MsgQueueGet() + { + int msgq_id; + if ((msgq_id = msgget(MESSAGE_Q_KEY_TH, IPC_CREAT | IPC_EXCL | 0666)) == -1) + { + return 0; + } + return msgq_id; + } + +void* ThreadEntryRead(void* arg) + { + TInt msgType; + TInt msqFlag = 0; + message_buf buf = {0}; + TInt msgLen = 128; + + msgType = 0; //any message + msqFlag = ~IPC_NOWAIT; //Blocking + int msgq_id = (int)arg; + int err = msgrcv(msgq_id, &buf, msgLen, msgType, msqFlag); + + if(buf.mtype != 1) + { + exit(1); + } + if( (strcmp(buf.mtext,"some_data_to_send")) ) + { + exit(1); + } + return NULL; + } + +TInt MsgQueueThread( int id ) + { + + TInt err = KErrNone; + int threadRetVal = 0; + void *threadRetValPtr = (void*)&threadRetVal; + pthread_t testThread; + err = pthread_create(&testThread,(pthread_attr_t *)NULL,ThreadEntryRead,(TAny*)id); + if (!err) + { + sleep(5); + err = MsgQueueSend(id); + } + pthread_join(testThread, &threadRetValPtr); + return err; + } + +TInt MsgQueueSend(int msgq_id) + { + + TInt len; + + struct { + long mtype; + char mtext[128]; + } msg_buf; + + msg_buf.mtype = 1; /* message identifier */ + strcpy(msg_buf.mtext, "some_data_to_send"); /* data */ + len = strlen(msg_buf.mtext)+1; + + if (msgsnd(msgq_id, (struct msgbuf *)&msg_buf, len, 0) != 0) + { + return -1; + } + + return 0; + } + +TInt MsgQueueDelete(int msgq_id) + { + User::After(100000); + if (msgctl(msgq_id, IPC_RMID, NULL) == -1) + { + return -1; + } + return 0; + + } + +TInt CTestMsgqueue::thsndrcvtest1() + { + + int err=0,id; + + id = MsgQueueGet(); + + if(id) + { + + err = MsgQueueThread(id); + if(!err) + { + err = MsgQueueDelete(id); + if(!err) + { + return KErrNone; + } + } + } + + return KErrGeneral; + }