DWORD WINAPI BrokerThreadBusEmulation(LPVOID pVoid)
{
CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid;
// Validate certain required pointers
//VALIDATE_POINTER_RETURN_VALUE_LOG(pThreadParam, -1);
//VALIDATE_POINTER_RETURN_VALUE_LOG(pThreadParam->m_hActionEvent, -1);
// Get hold of the bus simulation and error logger interfaces
HRESULT hResult = CoInitialize(NULL);
ISimENG* pISimENG = NULL;
hResult = CoCreateInstance(CLSID_SimENG, NULL, CLSCTX_LOCAL_SERVER,
IID_ISimENG, (LPVOID*) &pISimENG);
if ((S_OK != hResult) || (NULL == pISimENG))
{
return 0L;
}
bool bLoopON = true;
while (bLoopON)
{
WaitForSingleObject(pThreadParam->m_hActionEvent, INFINITE);
switch (pThreadParam->m_unActionCode)
{
case CONNECT:
{
sg_hResult = Worker_Connect(pISimENG, sg_pIlog);
SetEvent(sg_hNotifyFinish);
}
break;
case DISCONNECT:
{
sg_hResult = Worker_Disconnect(pISimENG, sg_pIlog);
SetEvent(sg_hNotifyFinish);
}
break;
case STOP_HARDWARE:
{
sg_hResult = Worker_StopHardware(pISimENG, sg_pIlog);
SetEvent(sg_hNotifyFinish);
}
break;
case START_HARDWARE:
{
sg_hResult = Worker_StartHardware(pISimENG, sg_pIlog);
SetEvent(sg_hNotifyFinish);
}
break;
case SEND_MESSAGE:
{
sg_hResult = Worker_SendCanMsg(pISimENG, sg_pIlog, sg_pouCanTxMsg);
SetEvent(sg_hNotifyFinish);
}
break;
case GET_TIME_MAP:
{
sg_hResult = Worker_GetTimeModeMapping(pISimENG, sg_pIlog);
SetEvent(sg_hNotifyFinish);
}
break;
case REGISTER:
{
sg_hResult = Worker_RegisterClient(pISimENG, sg_pIlog);
SetEvent(sg_hNotifyFinish);
}
break;
case UNREGISTER:
{
sg_hResult = Worker_UnregisterClient(pISimENG, sg_pIlog);
SetEvent(sg_hNotifyFinish);
}
break;
case EXIT_THREAD:
{
bLoopON = false;
}
break;
default:
case INACTION:
{
// nothing right at this moment
}
break;
}
}
// Release the bus simulation & error logger out-of-proc server components
//pISimENG->Release();
// Reset the interface pointers
pISimENG = NULL;
SetEvent(pThreadParam->hGetExitNotifyEvent());
return 0;
}
/**
* \brief Read thread procedure
* \param[in] pVoid contains the CPARAM_THREADPROC class object
* \return void
* \authors Prince Varghese
* \date 09.04.2013 Created
*/
DWORD WINAPI CanMsgReadThreadProc_CAN_ISolar_Eve(LPVOID pVoid)
{
USES_CONVERSION;
CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid;
/* Assign thread action to CREATE_TIME_MAP */
pThreadParam->m_unActionCode = CREATE_TIME_MAP;
bool bLoopON = true;
while (bLoopON)
{
Sleep (10); // To avoid continuous loop as there is no event mechanism
switch (pThreadParam->m_unActionCode)
{
case INVOKE_FUNCTION:
{
int functionType = 0;
unsigned int dataSize = 0;
if (ReceiveCommandFromClient(&functionType, &dataSize) >= 0)
{
switch (functionType)
{
case SEND_MESSAGE:
{
STCAN_MSG RxMsg;
int receiveResult = ReceiveCANMessageFromClient(&RxMsg);
if (receiveResult > 0)
{
sg_EVE_CANMsg.m_uDataInfo.m_sCANMsg.m_bCANFD = false;
sg_EVE_CANMsg.m_ucDataType = receiveResult;
sg_EVE_CANMsg.m_uDataInfo.m_sCANMsg = RxMsg;
RxMsg.m_ucChannel = 1;
vWriteIntoClientsBuffer(sg_EVE_CANMsg);
}
}
break;
default:
break;
}
}
}
break;
case EXIT_THREAD:
{
bLoopON = false;
}
break;
case CREATE_TIME_MAP:
{
SetEvent(pThreadParam->m_hActionEvent);
pThreadParam->m_unActionCode = INVOKE_FUNCTION;
}
break;
default:
case INACTION:
{
// nothing right at this moment
}
break;
}
}
SetEvent(pThreadParam->hGetExitNotifyEvent());
pThreadParam->m_hActionEvent = NULL;
return 0;
}
DWORD WINAPI DataCopyThreadProc(LPVOID pVoid)
{
CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid;
if (pThreadParam == NULL)
{
// TBD
}
CFrameProcessor_Common* pCurrObj = NULL;
if(pThreadParam != NULL)
{
pCurrObj = (CFrameProcessor_Common*) pThreadParam->m_pBuffer;
}
if (pCurrObj == NULL)
{
// TBD
}
//pThreadParam->m_unActionCode = INACTION;
bool bLoopON = true;
while (bLoopON)
{
// PTV CPP
if(pCurrObj != NULL)
{
pCurrObj->m_bIsThreadBlocked = TRUE;
}
WaitForSingleObject(pThreadParam->m_hActionEvent, INFINITE);
switch (pThreadParam->m_unActionCode)
{
case INVOKE_FUNCTION:
{
// Retrieve message from the driver
pCurrObj->vRetrieveDataFromBuffer();
ResetEvent(pThreadParam->m_hActionEvent);
}
break;
case EXIT_THREAD:
{
bLoopON = false;
}
break;
case CREATE_TIME_MAP:
{
pCurrObj->m_bIsThreadBlocked = FALSE;
pCurrObj->InitTimeParams();
pThreadParam->m_unActionCode = INVOKE_FUNCTION;
SetEvent(pThreadParam->m_hActionEvent);
}
break;
default:
case INACTION:
{
// nothing right at this moment
}
break;
}
}
SetEvent(pThreadParam->hGetExitNotifyEvent());
return 0;
}
/**
* Read thread procedure
*/
DWORD WINAPI EthernetMsgReadThreadProc(LPVOID pVoid)
{
USES_CONVERSION;
CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid;
// Validate certain required pointers
VALIDATE_POINTER_RETURN_VALUE_LOG(pThreadParam, (DWORD)-1);
// Assign thread action to CREATE_TIME_MAP
pThreadParam->m_unActionCode = INVOKE_FUNCTION;
//Set event object for reading from the socket
//SOCKET ClientSocket = sg_Connector.GetClientSocket();
//int rc = WSAEventSelect(ClientSocket, g_hReadEventObject, FD_READ);
int rc = 0;
if(rc == SOCKET_ERROR)
{
//unable to add event for reading
return 1;
}
HANDLE hDataEvent = sg_Connector.GetEvent();
HANDLE hEvents[] = {sg_hDataReceivedEvent, g_hInformStopTx};
bool bLoopON = true;
sg_Connector.SetReceiveCallBackFn();
PPKTHDR *pHeader = new PPKTHDR;
u_char *pkt_data = new u_char[1540];
while (bLoopON)
{
//g_hReadEventObject is the event triggered on reception of the Data in ethernet port
//Event should listen to the client socket in CConnector class
WaitForMultipleObjects(2, hEvents, FALSE, INFINITE);
//WaitForSingleObject(sg_hDataReceivedEvent, INFINITE);
if(sg_bIsConnected == false)
{
pThreadParam->m_unActionCode = EXIT_THREAD;
break;
}
switch (pThreadParam->m_unActionCode)
{
case INVOKE_FUNCTION:
{
int nResult = 0;
do {
string strError;
nResult = sg_Connector.ReceivePackets(&pHeader,&pkt_data);
if(nResult == S_FALSE)
{
sg_pIlog->vLogAMessage(A2T(__FILE__), __LINE__, strError);
break;
}
ProcessMsg(pHeader,pkt_data );
ResetEvent(sg_hDataReceivedEvent);
//delete(pHeader);
//delete(pkt_data);
} while (nResult > 0);
}
break;
case EXIT_THREAD:
{
bLoopON = false;
}
break;
case CREATE_TIME_MAP:
{
SetEvent(pThreadParam->m_hActionEvent);
pThreadParam->m_unActionCode = INVOKE_FUNCTION;
}
break;
default:
case INACTION:
{
// nothing right at this moment
}
break;
}
}
/*delete(pHeader);
delete(pkt_data);*/
SetEvent(pThreadParam->hGetExitNotifyEvent());
ResetEvent(sg_hDataReceivedEvent);
//g_hReadEventObject = NULL;
/* for (UINT i = 0; i < sg_unClientCnt; i++)
{
ResetEvent(hReadEventObject);
g_hDataEvent[i] = NULL;
}*/
pThreadParam->m_hActionEvent = NULL;
return 0;
}
DWORD WINAPI ReadDILCANMsg(LPVOID pVoid)
{
CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid;
if (pThreadParam != NULL)
{
CReadCanMsg* pCurrObj = (CReadCanMsg*) pThreadParam->m_pBuffer;
if (pCurrObj != NULL)
{
pThreadParam->m_unActionCode = INVOKE_FUNCTION; // Set default action
// Create the action event. In this case this will be used solely for
// thread exit procedure. The first entry will be used.
pThreadParam->m_hActionEvent = pCurrObj->m_ahActionEvent[0];
DWORD dwWaitRet;
BYTE byHIndex;
bool bLoopON = true;
while (bLoopON)
{
dwWaitRet = WaitForMultipleObjects(pCurrObj->m_nEvents,
pCurrObj->m_ahActionEvent, FALSE, INFINITE);
///// TEMP : BEGIN
DWORD dwLLimit = WAIT_OBJECT_0;
DWORD dwULimit = WAIT_OBJECT_0 + pCurrObj->m_nEvents - 1;
DWORD dwLLError = WAIT_ABANDONED_0;
DWORD dwULError = WAIT_ABANDONED_0 + pCurrObj->m_nEvents - 1;
if ((dwWaitRet >= dwLLimit) && (dwWaitRet <= dwULimit))
{
switch (pThreadParam->m_unActionCode)
{
case INVOKE_FUNCTION:
{
//Get the handle's index and pass it
byHIndex = (BYTE)(dwWaitRet - WAIT_OBJECT_0);
HANDLE hHandleSet = pCurrObj->m_ahActionEvent[byHIndex];
BYTE byNodeIndex;
if( pCurrObj->m_omHandleToNodeMgrMap.Lookup(hHandleSet, byNodeIndex))
{
//vRetrieveDataFromBuffer to read from that buffer
pCurrObj->vRetrieveDataFromBuffer(byNodeIndex);
}
//BOOL Result = ResetEvent(hHandleSet);
ResetEvent(hHandleSet);
}
break;
case EXIT_THREAD:
{
bLoopON = false;
}
break;
case INACTION:
{
// Signal the owner
SetEvent(pThreadParam->m_hThread2Owner);
Sleep(0);
// Wait until owner signals back.
WaitForSingleObject(pThreadParam->m_hOwner2Thread, INFINITE);
// Signal the owner
SetEvent(pThreadParam->m_hThread2Owner);
Sleep(0);
}
break;
case CREATE_TIME_MAP:
default:
break;
}
}
else if ((dwWaitRet >= dwLLError) && (dwWaitRet <= dwULError))
{
TRACE(_T(_("Abandoned... %X %d\n")), dwWaitRet, g_unCount++);
}
else if ( dwWaitRet == WAIT_TIMEOUT)
{
TRACE(_T("ReadDILCANMsg->WAIT_TIMEOUT %d\n"), g_unCount++);
}
else if (dwWaitRet == WAIT_FAILED)
{
TRACE(_T("WAIT_FAILED... %X %d\n"), GetLastError(), g_unCount++);
}
///// TEMP : END
}
SetEvent(pThreadParam->hGetExitNotifyEvent());
}
}
return 0;
}
/* Thread function used for sending messages cyclically */
DWORD WINAPI Cyclic_Transmission_Thread(LPVOID pVoid)
{
CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid;
if (pThreadParam == NULL)
{
return (DWORD)-1;
}
CTxMsgWndJ1939* pTxMsgWndJ1939 = static_cast<CTxMsgWndJ1939*> (pThreadParam->m_pBuffer);
if (pTxMsgWndJ1939 == NULL)
{
return (DWORD)-1;
}
bool bLoopON = true;
DWORD dwMiliSecs = INFINITE;
while (bLoopON) // Continue so long as the loop is ON.
{
WaitForSingleObject(pThreadParam->m_hActionEvent,
dwMiliSecs);
dwMiliSecs = pTxMsgWndJ1939->unGetTimerVal();
ESTATE_TRANS eTransState = pTxMsgWndJ1939->eGetTransState();
if ((eTransState == TRANS_TO_BE_STOPPED)
|| (eTransState == TRANS_STOPPED))
{
if (NULL != pTxMsgWndJ1939 && IsWindow(pTxMsgWndJ1939->m_hWnd))
{
pTxMsgWndJ1939->vProcessTransmission(FALSE);
dwMiliSecs = INFINITE;
ResetEvent(pThreadParam->m_hActionEvent);
}
}
else if (eTransState == TRANS_STARTED)
{
switch (pThreadParam->m_unActionCode)
{
case INVOKE_FUNCTION:
{
if (pTxMsgWndJ1939->SendSavedMessage() == S_OK)
{
if (pTxMsgWndJ1939->m_sMsgToBeSent.m_unDLC > 8)
{
WaitForSingleObject(sg_hMsgSent, INFINITE);
}
}
}
break;
case EXIT_THREAD:
{
bLoopON = false;
}
break;
case IDLE:
break;
default:
break;
}
}
}
SetEvent(pThreadParam->hGetExitNotifyEvent()); // Signal the owner that the thread
Sleep(0); // is going to terminate the infinite loop.
return 0;
}
DWORD WINAPI FlexMsgReadThreadProc_Stub(LPVOID pVoid)
{
VALIDATE_POINTER_RETURN_VAL(sg_pIlog, (DWORD)-1);
CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid;
pThreadParam->m_unActionCode = CREATE_TIME_MAP;
// Validate certain required pointers
//Set the action event
if ( sg_unClientCnt > 0 )
{
pThreadParam->m_hActionEvent = sg_asClientToBufMap[0].hClientHandle;
}
bool bLoopON = true;
while (bLoopON)
{
static HANDLE ahClientReadHandle[MAX_CLIENT_ALLOWED] = {0};
for (UINT i = 0; i < sg_unClientCnt; i++)
{
ahClientReadHandle[i] = sg_asClientToBufMap[i].hClientHandle;
}
DWORD dwIndex = WaitForMultipleObjects(sg_unClientCnt, ahClientReadHandle, FALSE, INFINITE);
if (dwIndex == WAIT_FAILED)
{
GetSystemErrorString();
}
else
{
UINT Index = dwIndex - WAIT_OBJECT_0;
switch (pThreadParam->m_unActionCode)
{
case INVOKE_FUNCTION:
{
// Retrieve message from the pipe
ProcessCanMsg(sg_asClientToBufMap[Index].hPipeFileHandle, Index);
}
break;
case CREATE_TIME_MAP:
{
PerformAnOperation(GET_TIME_MAP);
ProcessCanMsg(sg_asClientToBufMap[Index].hPipeFileHandle, Index);
pThreadParam->m_unActionCode = INVOKE_FUNCTION;
}
break;
case EXIT_THREAD:
{
bLoopON = false;
}
break;
default:
case INACTION:
{
// nothing right at this moment
}
break;
}
}
}
SetEvent(pThreadParam->hGetExitNotifyEvent());
return 0;
}
/**
* \brief Read thread procedure
* \param[in] pVoid contains the CPARAM_THREADPROC class object
* \return void
* \authors Arunkumar Karri
* \date 07.19.2013 Created
*/
DWORD WINAPI CDIL_LIN_VectorXL::LINMsgReadThreadProc_LIN_Vector_XL(LPVOID pVoid)
{
USES_CONVERSION;
CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid;
XLstatus xlStatus = XL_SUCCESS;
/* Assign thread action to CREATE_TIME_MAP */
pThreadParam->m_unActionCode = CREATE_TIME_MAP;
/* Set the event to LIN_Vector_XL driver for wakeup and frame arrival notification */
//for (UINT i = 0; i < sg_unClientCnt; i++)
{
xlStatus = xlSetNotification (g_xlPortHandle[0], &g_hDataEvent[0], 1);
}
/* Set the thread action event to first notification event handle */
if (g_hDataEvent[0] != nullptr)
{
pThreadParam->m_hActionEvent = g_hDataEvent[0];
}
/* Get the handle to the controller and validate it */
VALIDATE_POINTER_RETURN_VALUE_LOG(pThreadParam->m_hActionEvent, (DWORD)-1);
DWORD dwResult = 0;
unsigned int msgsrx;
XLevent xlEvent;
bool bLoopON = true;
while (bLoopON)
{
WaitForSingleObject(g_hDataEvent[0], INFINITE);
switch (pThreadParam->m_unActionCode)
{
case INVOKE_FUNCTION:
{
bool bMoreDataExist;
msgsrx = RECEIVE_EVENT_SIZE;
xlStatus = xlReceive(g_xlPortHandle[0], &msgsrx, &xlEvent);
while (xlStatus == XL_SUCCESS )
{
switch (xlStatus)
{
case XL_SUCCESS:
{
if ( g_pouDIL_LIN_Vector_XL != nullptr )
{
g_pouDIL_LIN_Vector_XL->ProcessLINMsg(xlEvent);
bMoreDataExist = true;
}
}
break;
default:
break;
}
xlStatus = xlReceive(g_xlPortHandle[0], &msgsrx, &xlEvent);;
}
}
break;
case EXIT_THREAD:
{
bLoopON = false;
}
break;
case CREATE_TIME_MAP:
{
//vCreateTimeModeMapping(pThreadParam->m_hActionEvent);
SetEvent(pThreadParam->m_hActionEvent);
pThreadParam->m_unActionCode = INVOKE_FUNCTION;
}
break;
default:
case INACTION:
{
// nothing right at this moment
}
break;
}
}
SetEvent(pThreadParam->hGetExitNotifyEvent());
{
ResetEvent(g_hDataEvent[0]);
g_hDataEvent[0] = nullptr;
}
pThreadParam->m_hActionEvent = nullptr;
return 0;
}
/**
* \brief Read thread procedure
* \param[in] pVoid contains the CPARAM_THREADPROC class object
* \return void
* \authors Prince Varghese
* \date 09.04.2013 Created
*/
DWORD WINAPI LinMsgReadThreadProc_LIN_ISolar_Eve(LPVOID pVoid)
{
USES_CONVERSION;
CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pVoid;
/* Assign thread action to CREATE_TIME_MAP */
pThreadParam->m_unActionCode = CREATE_TIME_MAP;
/* Dummy action event */
pThreadParam->m_hActionEvent = CreateEvent(nullptr, false, false, nullptr);
bool bLoopON = true;
while (bLoopON)
{
Sleep (10);
switch (pThreadParam->m_unActionCode)
{
case INVOKE_FUNCTION:
{
static STLIN_FRAME RxFrame;
static STLIN_MSG RxMsg;
static int iRxLength;
int iChecksum = 0;
RxMsg.m_ucDataLen = 0;
unsigned int uiDataType = ReceiveLINMessageFromClient(&RxFrame, &iRxLength);
if (iRxLength == LIN_PID_LENGTH)
{
RxMsg.m_ucMsgID = RxFrame.m_ucMsgID;
RxMsg.m_ucChksum = 0;
vValidateReceivedLinPID(RxMsg);
/*sg_EVE_LINMsg.m_ucDataType = TX_FLAG;*/
sg_EVE_LINMsg.m_uDataInfo.m_sLINMsg = RxMsg;
RxMsg.m_ucChannel = LIN_CHANNEL_1;
//vWriteIntoClientsBuffer(sg_EVE_LINMsg);
}
else if (iRxLength > LIN_PID_LENGTH)
{
RxMsg.m_ucMsgID = RxFrame.m_ucMsgID;
RxMsg.m_ucChksum = RxFrame.m_ucChksum;
RxMsg.m_ucDataLen = iRxLength - (LIN_PID_LENGTH + LIN_CHECKSUM_LENGTH); // 2 (1 byte checksum and 1byte pid)
for(int i=0; i<8; i++)
{
RxMsg.m_ucData[i] = RxFrame.m_ucData[i];
iChecksum = iChecksum + RxFrame.m_ucData[i];
if (iChecksum > 255)
{
iChecksum = iChecksum - 255;
}
}
RxMsg.m_ucChksum = 255 - iChecksum;
if((RxMsg.m_ucChksum != RxFrame.m_ucChksum))
{
RxMsg.m_ucMsgTyp = LIN_CHECKSUM_ERROR;
RxMsg.m_ucChksum = RxFrame.m_ucChksum;
}
else
{
vValidateReceivedLinMsg(RxMsg);
}
if(uiDataType == TX_LOOPBACK_UDP_DATA)
{
sg_EVE_LINMsg.m_ucDataType = TX_FLAG;
}
else if((uiDataType == RX_UDP_PID)||(uiDataType == RX_UDP_DATA))
{
sg_EVE_LINMsg.m_ucDataType = RX_FLAG;
}
RxMsg.m_ucChannel = LIN_CHANNEL_1;
sg_EVE_LINMsg.m_uDataInfo.m_sLINMsg = RxMsg;
RxMsg.m_ucChannel = 1;
vWriteIntoClientsBuffer(sg_EVE_LINMsg);
}
}
break;
case EXIT_THREAD:
{
bLoopON = false;
}
break;
case CREATE_TIME_MAP:
{
SetEvent(pThreadParam->m_hActionEvent);
pThreadParam->m_unActionCode = INVOKE_FUNCTION;
}
break;
default:
case INACTION:
{
// nothing right at this moment
}
break;
}
}
SetEvent(pThreadParam->hGetExitNotifyEvent());
pThreadParam->m_hActionEvent = nullptr;
return 0;
}
DWORD WINAPI MsgDelegatingThread(LPVOID pParam)
{
CPARAM_THREADPROC* pThreadParam = (CPARAM_THREADPROC*) pParam;
WORD wSenderID = 0;
INT Type = -1;
UINT64 TimeStamp = 0x0;
bool bLoopON = true;
while (bLoopON)
{
WaitForSingleObject(pThreadParam->m_hActionEvent, INFINITE);
switch (pThreadParam->m_unActionCode)
{
case INVOKE_FUNCTION:
{
// Retrieve message from the circular buffer
while (sg_MessageBuf.GetMsgCount() > 0)
{
EnterCriticalSection(&sg_CriticalSection);
BYTE* pbCurrEntry = sg_pbEntry2;
INT CurrLength = sg_nEntryLen2;
sg_MessageBuf.ReadFromBuffer(Type, pbCurrEntry, CurrLength);
// Save the sender id for reference
memcpy(&TimeStamp, pbCurrEntry + 1, SIZE_TIMESTAMP);
wSenderID = (WORD) TimeStamp;
// Calculate the current time stamp assigning the same to
// the message
LARGE_INTEGER CurrCounter;
QueryPerformanceCounter(&CurrCounter);
// Convert it to time stamp with the granularity of hundreds of us
if (CurrCounter.QuadPart * 10000 > CurrCounter.QuadPart)
{
TimeStamp =
(CurrCounter.QuadPart * 10000) / sg_lnFrequency.QuadPart;
}
else
{
TimeStamp =
(CurrCounter.QuadPart / sg_lnFrequency.QuadPart) * 10000;
}
// Now save the time stamp calculated
memcpy(pbCurrEntry + 1, &TimeStamp, SIZE_TIMESTAMP);
CLIENT_MAP::iterator itr = sg_ClientMap.begin();
while (itr != sg_ClientMap.end())
{
BOOL Result = TRUE;
// If the current client is meant for the same bus,
// then continue with the same.
if (itr->second.m_nBus == Type)
{
Result = itr->second.m_bActive;
}
if (Result)
{
if (itr->first == wSenderID)
{
// Make the self reception bit up
//CurrMsgDat.stcDataMsg.dwHeaderInfoFlags |= 0x800;
*pbCurrEntry = 0x1;
}
DWORD Count = 0;
Result = WriteFile(itr->second.m_hWrite, pbCurrEntry,
itr->second.m_dwDataSize, &Count, NULL);
//&CurrMsgDat, SIZE_ENTRY, &Count, NULL);
SetEvent(itr->second.m_hEvent);
FlushFileBuffers(itr->second.m_hWrite);
if (itr->first == wSenderID)
{
// Make the self reception bit down
//CurrMsgDat.stcDataMsg.dwHeaderInfoFlags &= ~0x800;
*pbCurrEntry = 0x0;
}
}
itr++;
}
LeaveCriticalSection(&sg_CriticalSection);
}
ResetEvent(pThreadParam->m_hActionEvent);
}
break;
case EXIT_THREAD:
{
bLoopON = false;
}
break;
default:
case INACTION:
{
// nothing right at this moment
}
break;
}
}
SetEvent(pThreadParam->hGetExitNotifyEvent());
return 0;
}