[gelöst] "Speicherzugriffsfehler" beim Schreiben in eine Datei

[D3lta]

Hallo,
Ich versuche derzeit eine Server-Client-Anwendung zu schreiben, dennoch zeigt der Server immer "Speicherfehler" an und beendet sich, ohne etwas auszugeben, während der Client sich ordnungsgemäß beendet.
Die Auswertung der Log-Datei und das Einfügen einiger Debug-Meldungen hat ergeben, dass der Fehler in dem überladenem >>-Operators liegt, aber ich kann keinen Fehler finden.

main.cpp

//Test-main
#include <iostream>
#include <string>
#include "socket.h"
#include "logger.h"
#include "socket_server.h"
//using namespace std;

int main(int argc, char* argv[])
{
	try
	{
		string s;
		if(argc < 2)
		{//Server
			Logger log("Server.log");
			Socket_Server ser(15000, log);
			Socket_Server cli;
			ser.accept(cli);

				//Wenn ein befehl des Objekts "cli" ausgeführt
                                // wird, kommt der Fehler, er kommt, wenn ich 
                                // "cli.recv" auskommentiere, bei dem 
                                // "cli.close". Daher vermute ich, dass der 
                                // Fehler in der Funktion 
                                // Socket_Server::accept() liegt.

			cli.recv(s);
			cout << "Nachricht erhalten: " << s << endl;
			cli.close();
		}
		else
		{//Client
			Socket so;
			so.create_TCP();
			Logger log("Client.log");
			log.write("Server Adresse:");
			s = argv[1];
			log.write(s);
			so.connect(argv[1], 15000);
			log.write("Mit Server auf Port 15000 verbunden");
			getline(cin, s, '\n');
			so.send(s.c_str(), s.size());
			log.write("An Server gesendet:");
			log.write(s);
			so.close();
		}
	}
	catch(Exception e)
	{
		cerr << "EXCEPTION: " << e.get_error() << endl;
		Logger log("Exception.log");
		log.write(e.get_error());
	}
	catch(...)
	{
		cout << "Unbekannte Exception";
	}
	return 0;
}

socket.h

/*****************
***** Socket *****
******************

Socket-Basis

*****************/

#ifndef SOCKET_H
#define SOCKET_H
#ifdef __WIN32__
//...
#endif
#ifdef __linux__
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <unistd.h>
#endif
#include <cstdlib>
#include <cstring>
#include "logger.h"
#include "exception.h"

// Limits
#ifndef NO_MAX
const int MAX_CONNECTIONS=16;
const int MAX_DATASIZE=1024;
#endif

class Socket
{
private:
	//Socket-Deskriptor
	int sock;
	//Adressstrukur
	struct sockaddr_in addr;

public:
	Socket() :sock(0) {}
	virtual ~Socket() {::close(sock);}

	int get_sock() const {return sock;}
	void set_sock(int socket) {sock=socket;}
	struct sockaddr_in get_addr() {return addr;}

	//Socket erstellen
	void create_TCP();
	void create_UDP();

	//Socket schließen
	void close() const;

	//TCP-Server
	void bind(const int port);
	void listen() const;
	void accept(Socket&) const;

	//TCP-Client
	int connect(const string host, const int port);

	//TCP-Datentransfer
	int send(const void* data, int size) const;
	int recv(void* data, int size) const;

	//UDP-Datentransfer
	int send_UDP(const void* data, int size, 
		const string host, const int port); //const;
	int recv_UDP(void* data, int size) const;
};

#endif

socket.cpp

//Socket.cpp
#include "socket.h"

void Socket::create_TCP()
{
	sock=::socket(AF_INET, SOCK_STREAM, 0);
	if(sock < 0)
		throw Exception("Anlegen eines Sockets gescheitert");
	int y=1;
	//Zulassen, dass sich mehrere Clients den Port teilen
	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &y, sizeof(int));
}

void Socket::create_UDP()
{
	sock=::socket(AF_INET, SOCK_DGRAM, 0);
	if(sock < 0)
		throw Exception("Anlegen eines Sockets gescheitert");
}

void Socket::close() const
{
	::close(sock);
}

void Socket::bind(const int port)
{
	//Ausfüllen von der Adressstruktur
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = INADDR_ANY;
	addr.sin_port = htons(port);

	//bind()
	if((::bind(sock, (struct sockaddr*) &addr, sizeof(addr))) == -1)
		throw Exception("Binden eines Sockets gescheitert");
}

void Socket::listen() const
{
	if((::listen(sock, MAX_CONNECTIONS)) == -1)
		throw Exception("Einrichten der Warteschlange eine Sockets gescheitert");
}

void Socket::accept(Socket& new_sock) const
{
	int addrlen = sizeof(addr);
	new_sock.sock = ::accept(sock, 
		(struct sockaddr*) &addr, (socklen_t*) &addrlen);
	if(new_sock.sock <= 0)
		throw Exception("Verbindungs aufbau zum Client gescheitert");
}

int Socket::connect(const string host, const int port)
{
	struct hostent* host_info;
	unsigned long host_addr;
	memset(&addr, 0, sizeof(addr));
	if((host_addr = inet_addr(host.c_str())) != INADDR_NONE)
	{//host ist eine numerische IP
		memcpy((char*)&addr.sin_addr, &host_addr, sizeof(host_addr));
	}
	else
	{//eventuell ist host ein hostname
		host_info = gethostbyname(host.c_str());
		if(host_info == NULL)
			throw Exception(
				"Host-Adresse konnte nicht aufgelöst werden");
		memcpy((char*)&addr.sin_addr, 
			host_info->h_addr, host_info->h_length);
	}
	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);

	int status = ::connect(sock, (sockaddr*) &addr, sizeof(addr));

	if(status == -1)
		throw Exception("Fehler beim verbinden mit dem Server");
	return status;
}

//Daten senden via TCP
int Socket::send(const void* data, int size) const
{
	int status = ::send(sock, data, size, 0);
	if(status == -1)
		throw Exception("Fehler beim Empfangen von Daten");
	return status;
}

//Daten empfangen via TCP
int Socket::recv(void* data, int size) const
{
	int status = ::recv(sock, data, size, 0);
	if(status == -1)
		throw Exception("Fehler beim Empfangen von Daten");
	return status;
}

//Daten senden via UDP
int Socket::send_UDP(const void* data, int size,
	const string host, const int port) //const
{
	struct hostent* host_info;
        unsigned long host_addr;
	int status;
        memset((void*)&addr, 0, sizeof(addr));
        if((host_addr = inet_addr(host.c_str())) != INADDR_NONE)
        {//host ist eine numerische IP
                memcpy((char*)&addr.sin_addr, &host_addr, sizeof(host_addr));
        }
        else
        {//eventuell ist host ein hostname
                host_info = gethostbyname(host.c_str());
                if(host_info == NULL)
                        throw Exception(
                                "Host-Adresse konnte nicht aufgelöst werden");
                memcpy((char*)&addr.sin_addr,
                        host_info->h_addr, host_info->h_length);
        }
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);

	if((status = sendto(sock, data, size, 0, (struct sockaddr*) &addr, sizeof(addr))) == -1)
		throw Exception("Daten konnten nicht gesendet werden");
	return status;
}

//Datein empfangen via UDP
int Socket::recv_UDP(void* data, int size) const
{
	int len = sizeof(addr);
	int retval = recvfrom(sock, data, size, 0,
		(struct sockaddr*) &addr, 
		(socklen_t*) &len);
	if(retval == -1)
		throw Exception("Daten konnten nicht empfangen werden");
	return retval;
}

socket_server.h

/************************
***** socket_server *****
*************************

Eine serverorientierte Socket-Klasse
auf der Basis von der Klasse Socket

************************/

#include <cstring>
#include "exception.h"
#include "logger.h"
#include "socket.h"

//Konstanten
const int CONNECTION_END = 0;

using namespace std;

class Socket_Server :private Socket
{
private:
	Logger* log;

public:
	Socket_Server(int port, Logger&);
	Socket_Server() {}
	virtual ~Socket_Server() {}

	//Daten senden und empfangen
	const Socket_Server& operator<< (const string&) const;
	const Socket_Server& operator>> (string&) const;
	const Socket_Server& operator<< (const int&) const;
	const Socket_Server& operator>> (int&) const;

	void recv (string&) const;

	void close();

	//blockierendes akzeptieren eines clients
	void accept(Socket_Server&);
};

socket_server.cpp

//socket_server.cpp
#include "socket_server.h"

using namespace std;

Socket_Server::Socket_Server(int port, Logger& logger)
{
	try
	{
		log = &logger;
		Socket::create_TCP();
		log->write("Server-Socket erstellt");
		Socket::bind(port);
		log->write("Server an Port gebunden");
		Socket::listen();
		log->write("Warteschlange eingerichtet");
	}
	catch(Exception e)
	{
		throw Exception(e.get_error(), log);
	}
}

const Socket_Server& Socket_Server::operator<< (const string& s) const
{
	try
	{
		Socket::send((void*)s.c_str(), s.size());
		log->write("An Client gesendet:");
		log->write(s);
	}
	catch(Exception e)
	{
		throw Exception(e.get_error(), log);
	}
	return *this;
}

const Socket_Server& Socket_Server::operator>> (string& s) const
{
	try
	{
		char buffer[MAX_DATASIZE+1];
		memset(buffer, 0, MAX_DATASIZE+1);
		int count;
		if((count = Socket::recv(buffer, MAX_DATASIZE)) == 0)
			throw CONNECTION_END;
		log->write("Daten erhalten");
		buffer[count] = '\0';
		s = buffer;
		log->write("Vom Client empfangen:");
		log->write(s);
	}
	catch(Exception e)
	{
		throw Exception(e.get_error(), log);
	}
	//catch(CONNECTION_END) {throw;}
	return *this;
}

void Socket_Server::recv (string& s) const
{
	try
	{
		char buffer[MAX_DATASIZE+1];
		memset(buffer, 0, MAX_DATASIZE+1);
		int count;
		if((count = Socket::recv(buffer, MAX_DATASIZE)) == 0)
			throw CONNECTION_END;
		log->write("Daten erhalten");
		buffer[count] = '\0';
		s = buffer;
		log->write("Vom Client empfangen:");
		log->write(s);
	}
	catch(Exception e)
	{
		throw Exception(e.get_error(), log);
	}
	//catch(CONNECTION_END) {throw;}
}

const Socket_Server& Socket_Server::operator<< (const int& i) const
{
	try
	{
		Socket::send((void*)&i, sizeof(int));
		log->write("An Client gesendet: int");
	}
	catch(Exception e)
	{
		throw Exception(e.get_error(), log);
	}
	return *this;
}

const Socket_Server& Socket_Server::operator>> (int& i) const
{
	try
	{
		if(Socket::recv((void*)&i, sizeof(int)) == 0)
			throw CONNECTION_END;
		log->write("Vom Client empfangen: int");
	}
	catch(Exception e)
	{
		throw Exception(e.get_error(), log);
	}
	//catch(CONNECTION_END) {throw;}
	return *this;
}

void Socket_Server::accept(Socket_Server& sock)
{
	try
	{
		Socket::accept(sock);
		log->write("Clientverbindung aufgebaut");
	}
	catch(Exception e)
	{
		throw Exception(e.get_error(), log);
	}
}

void Socket_Server::close() 
{
	try
	{
		Socket::close();
		log->write("Socket geschlossen");
	}
	catch(Exception e)
	{
		throw Exception(e.get_error(), log);
	}
}

mfg D3lta

EDIT: Ich habe den Quellcode aktualisiert und socket.h && socket.cpp hinzugefügt. Der Fehler ist in der main.cpp beschrieben.

mfg D3lta

[CStoll]

Das einzige Problem, was mir auf Anhieb ins Auge springt: Du stellst nicht sicher, daß der Buffer nullterminiert ist, den du in den zurückgegebenen String schreiben willst.

[D3lta]

Der String wird so gesendet:

string s="test"
send(s.c_str(), s.size());

Also sollte er Nullterminiert sein...

mfg D3lta

P.S.: Wie würdest du das denn überprüfen?

[TyRoXx]

D3lta schrieb:

Der String wird so gesendet:

string s="test"
send(s.c_str(), s.size());

Also sollte er Nullterminiert sein...

mfg D3lta

P.S.: Wie würdest du das denn überprüfen?

Nö. size() ist hier 4, weil es die 0 nicht mitzählt.

[CStoll]

D3lta schrieb:

Der String wird so gesendet:

string s="test"
send(s.c_str(), s.size());

Also sollte er Nullterminiert sein...

Erstens ist der gesendete String nicht nullterminiert (string::size() liefert die Größe in Nutzzeichen ohne das (im Umgang mit reinen C++ Strings nicht unbedingt erforderliche) \0 am Ende. Und zweitens Ist es viel wichtiger, was recv() am anderen Ende entgegennimmt.

P.S.: Wie würdest du das denn überprüfen?

Ich vermute mal, daß recv() die Anzahl der empfangenen Zeichen zurückliefert. Wenn das so ist, mußt du sie nur merken und das \0 selber dahinterschreiben:

const Socket_Server& Socket_Server::operator>> (string& s) const
{
    try
    {
        char buffer[MAX_DATASIZE+1];
        int recv_count = Socken::recv(bufferm, MA_DATASIZE);
        if(recv_count == 0)
            throw CONNECTION_END;
        buffer[recv_count] = '\0'; // hier wird der Null-Terminator gesetzt
        log->write("Daten erhalten");
        s = buffer;
        log->write("Vom Client empfangen:");
        log->write(s);
    }
    catch(Exception e)
    {
        throw Exception(e.get_error(), log);
    }
    //catch(CONNECTION_END) {throw;}
    return *this;
}

[D3lta]

CStoll schrieb:

D3lta schrieb:

Der String wird so gesendet:

string s="test"
send(s.c_str(), s.size());

Also sollte er Nullterminiert sein...

Erstens ist der gesendete String nicht nullterminiert (string::size() liefert die Größe in Nutzzeichen ohne das (im Umgang mit reinen C++ Strings nicht unbedingt erforderliche) \0 am Ende. Und zweitens Ist es viel wichtiger, was recv() am anderen Ende entgegennimmt.

P.S.: Wie würdest du das denn überprüfen?

Ich vermute mal, daß recv() die Anzahl der empfangenen Zeichen zurückliefert. Wenn das so ist, mußt du sie nur merken und das \0 selber dahinterschreiben:

const Socket_Server& Socket_Server::operator>> (string& s) const
{
    try
    {
        char buffer[MAX_DATASIZE+1];
        int recv_count = Socken::recv(bufferm, MA_DATASIZE);
        if(recv_count == 0)
            throw CONNECTION_END;
        buffer[recv_count] = '\0'; // hier wird der Null-Terminator gesetzt
        log->write("Daten erhalten");
        s = buffer;
        log->write("Vom Client empfangen:");
        log->write(s);
    }
    catch(Exception e)
    {
        throw Exception(e.get_error(), log);
    }
    //catch(CONNECTION_END) {throw;}
    return *this;
}

Danke für die Antwort, aber es hat nicht geholfen...

mfg D3lta

P.S.: Ich habe herausgefunden, dass der Fehler zwischen dem Annehmen des Clients (was erfolgreich zu verlaufen scheint) und dem ersten Befehl in dem überladenem operator>> liegt (also eventuell ein Syntaxfehler beim operator?

[theta]

Du brauchst ein (Framing) Protokoll - d.h. ein Mechnismus um den Anfang und das Ende einer Übermittelten Nachricht (bei dir Strings) festzustellen und entsprechende zu extrahieren.

Eine Möglichkeit ist (wie bereits halbwegs angefangen) die Strings als C-Strings zuu versenden, d.h. inkl. terminierendem 0. Auf der Empfangsseite empfängst Du solange Zeichen bis ein 0 kommt - voila, das ist das Ende des Strings und du hast deine Nachricht Empfangen. Ev. sind im selben recv(..) Aufruf noch mehr Strings vorhanden (hintereinander).

Allgemeine Möglichkeiten fürs Framing:
- Nachrichten (Frames) haben fixe Länge
- Nachrichten haben einen Header mit fixer Länge, in dem Header steht die Länge der Payload
- Markierung durch spezielle Zeichen vom Ende einer Nachricht - alles dazwischen ist Payload (bei Dir ist das 0).

So, nun musst Du noch wissen, dass 1 send(..) Aufruf der 16 Zeichen übermittelt nicht unbedingt in 1 recv(..) Aufruf resultiert - sondern z.B. in zwei, einmal 14 bytes und einmal 2 bytes. Desshalb brauchst Du einen Zwischen Puffer für die Empfangenen Zeichen, welche aber noch keine komplette Nachricht bilden.

Das alles gilt für den Fall, dass deine Wrapper des Sockets einfach send(..) und recv(..) wrappen - d.h. keine weitere Semantik ins Spiel bringen.

Simon

[D3lta]

theta schrieb:

Du brauchst ein (Framing) Protokoll - d.h. ein Mechnismus um den Anfang und das Ende einer Übermittelten Nachricht (bei dir Strings) festzustellen und entsprechende zu extrahieren.

Eine Möglichkeit ist (wie bereits halbwegs angefangen) die Strings als C-Strings zuu versenden, d.h. inkl. terminierendem 0. Auf der Empfangsseite empfängst Du solange Zeichen bis ein 0 kommt - voila, das ist das Ende des Strings und du hast deine Nachricht Empfangen. Ev. sind im selben recv(..) Aufruf noch mehr Strings vorhanden (hintereinander).

Allgemeine Möglichkeiten fürs Framing:
- Nachrichten (Frames) haben fixe Länge
- Nachrichten haben einen Header mit fixer Länge, in dem Header steht die Länge der Payload
- Markierung durch spezielle Zeichen vom Ende einer Nachricht - alles dazwischen ist Payload (bei Dir ist das 0).

So, nun musst Du noch wissen, dass 1 send(..) Aufruf der 16 Zeichen übermittelt nicht unbedingt in einem recv(..) Aufruf resultiert - sondern z.B. in zwei, einmal 14 bytes und einmal 2 bytes. Desshalb brauchst Du einen Zwischen Puffer für die Empfangenen Zeichen, welche aber noch keine komplette Nachricht bilden.

Das alles gilt für den Fall, dass deine Wrapper des Sockets einfach send(..) und recv(..) wrappen - d.h. keine weitere Semantik ins Spiel bringen.

Simon

So etwas hatte ich noch vor in die Serverklasse zu integireren und das Logging ist im Moment noch katastrophal
Aber wie will ich so etwas machen, wenn ich noch nicht einmal 4 Zeichen übermittelt kriege

mfg D3lta

P.S.: Danke für die Inspirationen für das Framing

[theta]

Aber wie will ich so etwas machen, wenn ich noch nicht einmal 4 Zeichen übermittelt kriege

Mach das Framing und es geht - das bedeutet nämlich dass recv(..) sovielmal aufgerufen wird, bis mindestens eine komplette Nachricht empfangen wurde.

recv(..) in einer Schleife aufrufen, bis komplette Nachricht oder sogar mehrere Nachrichten empfangen wurden!

[D3lta]

theta schrieb:

Aber wie will ich so etwas machen, wenn ich noch nicht einmal 4 Zeichen übermittelt kriege

Mach das Framing und es geht - das bedeutet nämlich dass recv(..) sovielmal aufgerufen wird, bis mindestens eine komplette Nachricht empfangen wurde.

recv(..) in einer Schleife aufrufen, bis komplette Nachricht oder sogar mehrere Nachrichten empfangen wurden!

Bei mir ist der Buffer aber 1024 Zeichen groß, da passen die paar Zeichen doch Sicher hinein, oder?

mfg D3lta

P.S.: Außerdem liegt der Fehler noch vor dem Aufruf von recv() !

mfg D3lta

[314159265358979]

Ich vermute mal, dass du in deinen anderen Klassen, wie hier auch, die Return-Codes nicht prüfst. Alle Socket-Funktionen geben -1 zurück, wenn etwas nicht geklappt hat. Ich würde das überprüfen und im Fehlerfall eine Exception mit aussagekräftiger Nachricht werfen - Dann siehst du sofort, wo es kracht.

[theta]

Bei mir ist der Buffer aber 1024 Zeichen groß, da passen die paar Zeichen doch Sicher hinein, oder?

Ja, sie passen potentiell rein. Das heisst noch lange nicht dass der recv(..) Aufruf soviele reinschreibt. Wieviel genau reingeschrieben werden sagt dir der Return Wert von recv(..). Achtung: Auch Fehler oder Connection Ende (wie schon in deinem Code behandelt) wird über den Return Code mitgeteilt.

P.S.: Außerdem liegt der Fehler noch vor dem Aufruf von recv() !

Wo?

[EDIT]
Ausserdem:

Socket::send((void*)s.c_str(), s.size());

Der Cast unnötig, weil die Konvertierung nach void* implizit geht. Gilt auch für andere Stellen.

catch(Exception e)

Exceptions soll man üblicherweise per (const) Referenz fangen.

[D3lta]

theta schrieb:

Bei mir ist der Buffer aber 1024 Zeichen groß, da passen die paar Zeichen doch Sicher hinein, oder?

Ja, sie passen potentiell rein. Das heisst noch lange nicht dass der recv(..) Aufruf soviele reinschreibt. Wieviel genau reingeschrieben werden sagt dir der Return Wert von recv(..). Achtung: Auch Fehler oder Connection Ende (wie schon in deinem Code behandelt) wird über den Return Code mitgeteilt.

P.S.: Außerdem liegt der Fehler noch vor dem Aufruf von recv() !

Wo?

D3lta schrieb:

...

P.S.: Ich habe herausgefunden, dass der Fehler zwischen dem Annehmen des Clients (was erfolgreich zu verlaufen scheint) und dem ersten Befehl in dem überladenem operator>> liegt (also eventuell ein Syntaxfehler beim operator?

314159265358979 schrieb:

Ich vermute mal, dass du in deinen anderen Klassen, wie hier auch, die Return-Codes nicht prüfst. Alle Socket-Funktionen geben -1 zurück, wenn etwas nicht geklappt hat. Ich würde das überprüfen und im Fehlerfall eine Exception mit aussagekräftiger Nachricht werfen - Dann siehst du sofort, wo es kracht.

Doch, ich prüfe bei jedem Aufruf auf den RetVal -1, aber in der class Socket, auf welcher diese hier basiert.

mfg D3lta

[theta]

Und wie kommst Du darauf, dass es vor dem 1. recv(..) ist?
Und wenns so ist, dann debugge doch einfach.

[D3lta]

theta schrieb:

Und wie kommst Du darauf, dass es vor dem 1. recv(..) ist?
Und wenns so ist, dann debugge doch einfach.

Durch Debug-Meldungen

mfg D3lta

[314159265358979]

D3lta schrieb:

Doch, ich prüfe bei jedem Aufruf auf den RetVal -1, aber in der class Socket, auf welcher diese hier basiert.

Und du wirfst schön brav socket_error's?

[D3lta]

314159265358979 schrieb:

D3lta schrieb:

Doch, ich prüfe bei jedem Aufruf auf den RetVal -1, aber in der class Socket, auf welcher diese hier basiert.

Und du wirfst schön brav socket_error's?

Ja, mit meiner Exception-Class
Aber es wird keine geworfen...

mfg D3lta

[theta]

D3lta schrieb:

theta schrieb:

Und wie kommst Du darauf, dass es vor dem 1. recv(..) ist?
Und wenns so ist, dann debugge doch einfach.

Durch Debug-Meldungen

mfg D3lta

Ich würds durchsteppen.

[D3lta]

theta schrieb:

D3lta schrieb:

theta schrieb:

Und wie kommst Du darauf, dass es vor dem 1. recv(..) ist?
Und wenns so ist, dann debugge doch einfach.

Durch Debug-Meldungen

mfg D3lta

Ich würds durchsteppen.

Ich benutze den gcc-Kompiler
Außerdem habe ich mit Debug-Meldungen den Fehler weitesgehend ausgemacht, ich makiere den Fehler gleich im 1. Post.

mfg D3lta

EDIT: makiert

[D3lta]

Ich habe weiter nach dem Fehler gesucht und verdächtige nun Socket_Server::accept(), den Fehler zu verursachen, deswegen habe ich den Startpost mit meinem aktuellen Source versehen und den Fehler in die main.cpp geschrieben.

mfg Δ3lta

P.S.: Gibt es in dem Forum hier so eine Art Spoiler (Womit man Text verstecken kann, aber bei Mausklick sichtbar wird)? Ich habe so etwas bisher noch nicht gefunden...