wiedermal boost:asio...

[Vezweifelter]

Hi Leute,
nachdem ich etwas mit Netzwerkfunktionalität programmieren möchte, dachte ich mir, dass ich mir einfach mal boost::asio ansehe;

gesagt,getan. Allerdings würde ich hier nichts posten wenn alles funktionieren würde -.-

Ich habe eine Klasse TCPServer die den Server darstellt, die aus 2 Haupt-funktionen besteht (TCPsender und TCPreceiver) die später in eigene Threads ausgelagert werden sollen.

TCPconn.cpp

TCPServer::TCPServer(short port):
	socket(io_service),
	acceptor(io_service, tcp::endpoint(tcp::v4(), port))
{

}
TCPServer::~TCPServer()
{

}
void TCPServer::TCPsetRecvBuffer(boost::array<char, 128> *buf, int len, boost::mutex *lock)
{
	p_recvBuf = buf;
	recvBufLen = len;
	p_recvLock = lock;
}

void TCPServer::TCPsetLog(vector<string> *log, boost::mutex *lock)
{
	p_log = log;
	p_logLock = lock;
}

void TCPServer::TCPsetSendBuffer(boost::array<char, 128> *buf, boost::mutex *lock)
{
	p_sendBuf = buf;
	p_sendLock = lock;	
}

void TCPServer::TCPaccept(void)
{
      	acceptor.accept(socket);
}

void TCPServer::TCPsender(void)
{
	bool exit = false;

	while(!exit){
      		boost::mutex::scoped_lock sendlock(*p_sendLock);
      		boost::system::error_code ignored_error;
		boost::asio::write(socket, boost::asio::buffer(*p_sendBuf),
		boost::asio::transfer_all(), ignored_error);

		boost::mutex::scoped_lock stoplock(stopLock);
		exit = shutdown;	
	}
}

void TCPServer::TCPreceiver(void)
{
	bool exit = false;

	while(!exit){

      		boost::mutex::scoped_lock recvlock(*p_recvLock);
      		boost::system::error_code ignored_error;
		socket.read_some(boost::asio::buffer(*p_recvBuf), ignored_error);

		boost::mutex::scoped_lock stoplock(stopLock);
		exit = shutdown;	
	}
}

TCPconn.hpp

using boost::asio::ip::tcp;
using namespace std;
#ifndef TCPSERVER
#define TCPSERVER
class TCPServer
{
	public:
		TCPServer(short port);			
		~TCPServer();
		//void TCPsetPort(short p);
		void TCPsetRecvBuffer(boost::array<char, 128> *buf, int len, boost::mutex *lock);
		void TCPsetSendBuffer(boost::array<char, 128> *buf, boost::mutex *lock);
		void TCPsetLog(vector<string> *log, boost::mutex *lock);
		void TCPaccept(void);
		void TCPreceiver(void);  //1st thread
		void TCPsender(void);    //2nd thread
		void stop(void);

	private:
		/*
		   guarantees clean thread shutdown
		*/
		bool shutdown;
		boost::mutex stopLock;
		/*
		   buffers and locks for received- and to be sent content
		*/
		boost::array<char, 128> *p_recvBuf,*p_sendBuf;
		int recvBufLen;
		boost::mutex *p_recvLock;
		boost::mutex *p_sendLock;
		/*
		   buffer and lock for event-logging
		*/
		vector<string> *p_log;
		boost::mutex *p_logLock;
		/*
		   TCP-socket
		*/
		boost::asio::io_service io_service;
		//short port;

		tcp::acceptor acceptor;
		tcp::socket socket;
};
#endif

und die main.cpp

#include "TCPconn.hpp"

int main(void)
{

	boost::array<char, 128>  sendBuf;
	boost::array<char, 128>  recvBuf;

	boost::mutex sendLock;
	boost::mutex recvLock;

	TCPServer Server((short)13);
	//Server.TCPsetPort(13);
	Server.TCPsetRecvBuffer(&recvBuf,1024,&recvLock);
	Server.TCPsetSendBuffer(&sendBuf,&sendLock);
	Server.TCPaccept();
	while(1){
		asm volatile("");  //nur zum sichergehen das nicht wegoptimiert wird
	};

}

und das wichtigste, die Fehlermeldung:

./main 
terminate called after throwing an instance of 'boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<boost::system::system_error> >'
  what():  Permission denied
Aborted

Ich hoffe es hat jemand Zeit sich das anzusehen und mir zu helfen.

LG

[Kóyaánasqatsi]

Sieht nach einer regulären Exception aus. Fang sie mal mit:

catch(boost::system::system_error &) 
{ 
}

[Verzweifelter]

Die Exception ist:

Permission denied

Aber leider steht nicht wo...

MFG

[Verzweifelter]

Jetzt hab ich das ganze als root ausgeführ und es kommt schon mal keine Exception mehr.
Doch würde ich gerne wissen warum ich es nur als root und nicht als normaler User ausführen kann. Ich benutze Ubuntu;

MFG

[Vezweifelter]

So, nachdem ich jetzt noch schnell einen Client geschrieben habe, gibt der mir als Antwort:

Connection refused

Was mach ich falsch???

[Kóyaánasqatsi]

Wie, wo, wann, in welchem Client? Mehr Infos bitte

[Vezweifelter]

ok hier kommt der Client:

class TCPClient
{
	public:
		TCPClient(string ip,short port);
		~TCPClient();
		void setRecvBuffer(boost::array<char, 1024> *buf, boost::mutex *lock);
		void setSendBuffer(boost::array<char, 1024> *buf, boost::mutex *lock);
		void setLog(vector<string> *log, boost::mutex *lock);
		bool connect(void);
		void receiver(void);
		void sender(void);
	private:
		/*
		   guarantees clean thread shutdown
		*/
		bool shutdown;
		boost::mutex stopLock;
		/*
		   buffers and locks for received- and to be sent content
		*/
		boost::array<char, 1024> *p_recvBuf;
		boost::array<char, 1024> *p_sendBuf;

		boost::mutex *p_recvLock;
		boost::mutex *p_sendLock;
		/*
		   buffer and lock for event-logging
		*/
		vector<string> *p_log;
		boost::mutex *p_logLock;
		/*
		   TCP-socket
		*/
		short port;
		boost::asio::ip::address ipaddress;

		boost::asio::io_service io_service;

		tcp::socket socket;
};

main:

int main(void)
{
	try
	{
		boost::array<char, 1024>  sendBuf;
		boost::array<char, 1024>  recvBuf;

		boost::mutex sendLock;
		boost::mutex recvLock;

		TCPClient Client("127.0.0.1",13);
		//Server.TCPsetPort(13);
		Client.setRecvBuffer(&recvBuf,&recvLock); // Buffer must be of length 1024
		Client.setSendBuffer(&sendBuf,&sendLock); // Buffer must be of length 1024
		Client.connect();
		while(1){
			asm volatile("");
		};
	}
	catch(boost::system::system_error &e) 
	{ 
		printf("%s\n",e.what());
	}

}

LG

[Verzweifelter]

sry hab die .cpp vergessen

TCPClient::TCPClient(string ip, short p):
	socket(io_service)
{
	ipaddress.from_string(ip.c_str());
	port = p;
}

TCPClient::~TCPClient()
{

}

void TCPClient::setRecvBuffer(boost::array<char, 1024> *buf, boost::mutex *lock)
{
	p_recvBuf = buf;
	p_recvLock = lock;
}

void TCPClient::setSendBuffer(boost::array<char, 1024> *buf, boost::mutex *lock)
{
	p_sendBuf = buf;
	p_sendLock = lock;
}

void TCPClient::setLog(vector<string> *log, boost::mutex *lock)
{
	p_log = log;
	p_logLock = lock;
}

bool TCPClient::connect(void)
{
	boost::system::error_code error;
	boost::asio::ip::tcp::endpoint endpt;
	endpt.address(ipaddress);
	socket.connect(endpt,error);
	if (error)
      		throw boost::system::system_error(error);
}

void TCPClient::receiver(void)
{
	bool exit = false;
	while(!exit)
	{
		boost::mutex::scoped_lock recvlock(*p_recvLock);
      		boost::system::error_code ignored_error;
		socket.read_some(boost::asio::buffer(*p_recvBuf), ignored_error);

		boost::mutex::scoped_lock stoplock(stopLock);
		exit = shutdown;
	}
}

void TCPClient::sender(void)
{
	bool exit = false;

	while(!exit){
      		boost::mutex::scoped_lock sendlock(*p_sendLock);
      		boost::system::error_code ignored_error;
		boost::asio::write(socket, boost::asio::buffer(*p_sendBuf),
		boost::asio::transfer_all(), ignored_error);

		boost::mutex::scoped_lock stoplock(stopLock);
		exit = shutdown;	
	}
}

[evilissimo]

Auf POSIX-Systemen können die ports unter 1024 nur vom "root" benutzt werden um einen Server darauf zum lauschen anzulegen.

BR

[Verzweifelter]

Ich hab es jetzt auf Port 4000 gelegt und kann den Server zwar jetzt ohne root-Rechte ausführen,
allerdings bekomme ich vom Client immer noch ein "Connection refused"

LG

[Th69]

Außerdem ist Port 13 für den DayTime-Dienst reserviert: http://de.wikipedia.org/wiki/Daytime

[Verzweifelter]

So Leute, ich denke ich habe das Problem gefunden:

Ich habe beim Verbinden keinen Port angegeben.

LG