Serielle Schnittstelle Empfangsbuffer

[Peter(TOO)]

Hallo Florian,

/*------------Printing the RXed String to Console----------------------*/

			printf("\n\n    ");
			int j = 0;
			for (j = 0; j < i - 1; j++)		// j < i-1 to remove the dupliated last character
				printf("%c", SerialBuffer[j]);

Hier fehlt

i = 0;

Nach der Ausgabe der Daten.

Grundsätzlich: Wieso gibt man die ganzen Variablen-Deklarationen nicht auch an?
Da können schon viele Fehler entstehen, z.B. durch signed/unsigned.

Dein Code ist aber eher etwas kriminell!

SerialBuffer[i] = TempChar;
i++;

Hier überprüfst du nicht ob i grösser als der Buffer ist!
Kann gut gehen, aber wenn da mal eine Störung bei der Übertragung ist überschreibst du alles was hinter SerialBuffer im Speicher liegt...

Übrigens war genau dieser Fehler bei MS schuld daran, dass SASSER sich verbreiten konnte.
Hinter deren Buffer lag irgendwo Code und das Protokoll war festgelegt auf maximal 4kB pro Paket. Der Hacker hat dann einfach ein zu grosses Datenpaket verschickt, welches dann hinten seinen Code enthalten hat. Somit wurde dann das normale Programm überschrieben und bei einem Aufruf der normalen Funktionen wurde der Code des Hackers ausgeführt! Braucht nur etwas Analyse, damit die Einsprungspunkte der Hackerroutinen an die Stellen der originalen Einsprungspunkte zu liegen kommen.

MfG Peter(TOO)

[FlorianKr]

Hallo,

vielen Dank für die Hinweise und Erklärungen.

Ich habe jetzt versucht den Code etwas aufzuräumen:

//CommSeriell.cpp

#include "stdafx.h"
#include "CommSeriell.h"


CommSeriell::CommSeriell(int a)
{
	m_run.store(true);
	m_thread = std::thread(std::bind(&CommSeriell::theThread, this));
}


CommSeriell::~CommSeriell()
{
	m_run.store(false);
	if (m_thread.joinable())
	{
		m_thread.join();
	}
}

BOOL CommSeriell::initComPort()
{
	std::cout <<std::endl<<"Serial Port  Reception (Win32 API)"<< std::endl;

	/*---------------------------------- Opening the Serial Port -------------------------------------------*/
	
	ComPortName = TEXT("COM2");
	hComm = CreateFile(ComPortName,                  // Name of the Port to be Opened
		GENERIC_READ | GENERIC_WRITE, // Read/Write Access
		0,                            // No Sharing, ports cant be shared
		NULL,                         // No Security
		OPEN_EXISTING,                // Open existing port only
		0,                            // Non Overlapped I/O
		NULL);                        // Null for Comm Devices

	if (hComm == INVALID_HANDLE_VALUE)
		std::wcout <<"\n    Error! - Port "<<ComPortName<<" can't be opened\n";
	else
		std::wcout <<"\n    Port "<<ComPortName<<" Opened\n ";

	/*------------------------------- Setting the Parameters for the SerialPort ------------------------------*/

	DCB dcbSerialParams = { 0 };                         // Initializing DCB structure
	dcbSerialParams.DCBlength = sizeof(dcbSerialParams);

	Status = GetCommState(hComm, &dcbSerialParams);      //retreives  the current settings

	if (Status == FALSE){
		std::cout <<"\n    Error! in GetCommState()";
		error = 10;
	}
	dcbSerialParams.BaudRate = CBR_19200;		// Setting BaudRate = 9600
	dcbSerialParams.ByteSize = 8;				// Setting ByteSize = 8
	dcbSerialParams.StopBits = ONESTOPBIT;		// Setting StopBits = 1
	dcbSerialParams.Parity = NOPARITY;			// Setting Parity = None 

	Status = SetCommState(hComm, &dcbSerialParams);	//Configuring the port according to settings in DCB 

	if (Status == FALSE)
	{
		std::cout <<std::endl<<"\n    Error! in Setting DCB Structure"<<std::endl;
		error = 1;
	}
	else //If Successfull display the contents of the DCB Structure
	{
		std::cout << "\n\n    Setting DCB Structure Successfull" << std::endl
			<<"\n       Baudrate = " << dcbSerialParams.BaudRate
			<<"\n       ByteSize = %d" << dcbSerialParams.ByteSize
			<<"\n       StopBits = %d" << dcbSerialParams.StopBits
			<<"\n       Parity   = %d" << dcbSerialParams.Parity;
	}
	return Status;
}

BOOL CommSeriell::setRecieveMask() {
	/*------------------------------------ Setting Receive Mask ----------------------------------------------*/

	Status = SetCommMask(hComm, EV_RXCHAR); //Configure Windows to Monitor the serial device for Character Reception

	if (Status == FALSE)
		std::cout << "\n\n    Error! in Setting CommMask";
	else
		std::cout << "\n\n    Setting CommMask successfull";
	return Status;
}

BOOL CommSeriell::recieveComPort(){
	/*------------------------------------ Setting WaitComm() Event   ----------------------------------------*/

	std::cout <<"\n\n    Waiting for Data Reception";

	do {

		Status = WaitCommEvent(hComm, &dwEventMask, NULL); //Wait for the character to be received

		/*-------------------------- Program will Wait here till a Character is received ------------------------*/

		if (Status == FALSE)
		{
			std::cout <<"\n    Error! in Setting WaitCommEvent()";
			error = 10;
		}
		else //If  WaitCommEvent()==True Read the RXed data using ReadFile();
		{
			readbuf = ReceiveData();
			std::cout <<"\n Print input\n";
			std::cout << readbuf << std::endl;
		}
		error++; //nur 10 mal ausführen
	} while (error <10);
	return Status;
}

std::string CommSeriell::ReceiveData()
{
	const int nReadSize = 256;
	std::vector<char> Buffer(nReadSize);
	unsigned long nDataRead;

	if (!ReadFile(hComm, &Buffer[0], nReadSize, &nDataRead, NULL))
	{
		std::cout<<"General Read Error";
	}

	return std::string(Buffer.begin(), Buffer.begin() + nDataRead);
}

void CommSeriell::theThread()
{
	initComPort();
	setRecieveMask();
	recieveComPort();

	CloseHandle(hComm);//Closing the Serial Port
	printf("\n +==========================================+\n");
}

// CommSeriell.h

#pragma once
class CommSeriell
{
public:
	CommSeriell(int a);
	~CommSeriell();

private:
	std::atomic<bool> m_run;
	std::thread m_thread;

	//Variablendeklarationen
	HANDLE hComm;				// Handle to the Serial port
	TCHAR  *ComPortName;		// Name of the Serial port(May Change) to be opened,
	BOOL  Status;				// Status of the various operations 
	DWORD dwEventMask;			// Event mask to trigger
	int error = 0;				// 
	std::string readbuf;		//

	//Funktiosdeklarationen
	void theThread();

	BOOL initComPort();
	BOOL setRecieveMask();
	BOOL recieveComPort();
	std::string ReceiveData();
};

Anbei auch die Variablen-Deklarationen.

Die von dir einen Thread vorher genannten Punkte habe ich hoffentlich soweit alle herausgenommen.

Anbei noch ein Bild wie die Daten jetzt ausgegeben werden.

MfG Florian