C / C++ / MFC

<br />
//-----------------------------------------------------------------------<br />
// Implementierung der Methode OnCommunication() in der Klasse CKupDlg<br />
//-----------------------------------------------------------------------<br />
//<br />
LONG CKupDlg::OnCommunication(WPARAM ch, LPARAM port) {	// gfa<br />
static unsigned char *pKupParam = (unsigned char *) &gKupParam; <br />
   *pKupParam++ = ch;<br />
   return 0;<br />
}<br />
<br />

OVERLAPPED osReader = {0};
osReader.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

int UModulSerial::ReceiveVoid(LPVOID Buffer, int &NumberOfBytesToRead)
{

	//overlapped read, it's possible, that we have to wait with waitforsingle object till the read operation finishes
	if (m_bOverlapped)
	{
		CMutex mutRead;
		CSingleLock lock(&mutRead,TRUE);		//this will block other processes to read from the com port till our operation finishes
		m_sError = "";
		m_iErrNumber = 0;
		DWORD NumberOfBytesReceived=0;

		OVERLAPPED osReader = {0};
		osReader.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
		if (osReader.hEvent == NULL)
		{
			SetErrorMessage(ERROR_CREATING_EVENT);				
			return -1;
		}


		int Read_Error = ReadFile
		(
			m_hSerPort,					// handle of file to read
			Buffer,						// pointer to buffer that receives data
			NumberOfBytesToRead,		// number of bytes to read
			&NumberOfBytesReceived,	// pointer to number of bytes read
			&osReader					// pointer to OVERLAPPED structure for data
		);

		if (!Read_Error)
		{
			DWORD LastErrorCode = GetLastError();						
			if (LastErrorCode == ERROR_IO_PENDING)     //if the read is not yet finished, wait till it finishes, or timeouts
			{							
				DWORD dwRes = WaitForSingleObject(osReader.hEvent, m_Comtimeout.ReadTotalTimeoutConstant);
				switch(dwRes)
				{					
					case WAIT_OBJECT_0:	// Read completed, transfer the overlapped result to our buffer.						
						if (!GetOverlappedResult(m_hSerPort, &osReader, &NumberOfBytesReceived, FALSE))
						{
							//if there was an error during transfering the overlapped structure to our buffer							
							SetErrorMessage(GetLastError());				
							CloseHandle(osReader.hEvent);
							return -1;
						}
						else
						{	
							//when the transfer was succesful, but the number of read bytes are not equal to requested than error
							if(NumberOfBytesToRead != NumberOfBytesReceived)
							{
								NumberOfBytesToRead = NumberOfBytesReceived;
								SetErrorMessage(ERROR_TIMEOUT);								
								CloseHandle(osReader.hEvent);
								return -1;
							}								
						}												
						break;
					case WAIT_TIMEOUT:
						//if there was a timeout during the read operation, than cancel the reading and return with error
						SetErrorMessage(ERROR_TIMEOUT);
						CancelIo(m_hSerPort);
						//we call this to get how many bytes were read till the timeout
						GetOverlappedResult(m_hSerPort, &osReader, &NumberOfBytesReceived, FALSE);						
						//maybe it was timeout but we received all the bytes we requested, in such case everything is ok
						if (NumberOfBytesToRead != NumberOfBytesReceived)
						{
							CloseHandle(osReader.hEvent);
							NumberOfBytesToRead = NumberOfBytesReceived;
							return -1;
						}
						else
							break;
						break;                       
					default:
						//this indicates, that there is a problem with the overlapped eventhandler
						SetErrorMessage(-1);
						CloseHandle(osReader.hEvent);
						return -1;
						break;
					}
				}
				else
				{
					// Error in communications; report it.
					SetErrorMessage(GetLastError());
					CloseHandle(osReader.hEvent);
					return -1;
				}		

			}
			
		CloseHandle(osReader.hEvent);
		if(NumberOfBytesToRead != NumberOfBytesReceived)
		{
			NumberOfBytesToRead = NumberOfBytesReceived;
			SetErrorMessage(ERROR_TIMEOUT);				
			return -1;
		}
		
		return 0;		//we return here, so the lock object will be destroyed in correct moment, when lock destroyed, it calls unlock
	}