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

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

Permission denied

Aber leider steht nicht wo...

MFG

MFG

Connection refused

Was mach ich falsch???

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

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;	
	}
}

BR

LG

Ich habe beim Verbinden keinen Port angegeben.

LG