Reformat source

CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.0)
+project(serialmultiplexer)
+
+set(SRC_FILES   main.cpp serial_io.cpp Socket.cpp )
+set(LIBS -pthread )
+
+add_executable(${PROJECT_NAME} ${SRC_FILES})
+
+target_link_libraries( ${PROJECT_NAME} ${LIBS})
+add_definitions(" -std=c++11 -Wall -O2 -g")
+
+install(TARGETS serialmultiplexer RUNTIME DESTINATION bin)

Socket.cpp

@@ -19,28 +19,34 @@ using namespace std;
 // SocketException Code
 
 SocketException::SocketException(const string &message, bool inclSysMsg)
-   : userMessage(message) {
-  if (inclSysMsg) {
+	: userMessage(message)
+{
+	if (inclSysMsg)
+	{
 		userMessage.append(": ");
 		userMessage.append(strerror(errno));
 	}
 }
 
-SocketException::~SocketException() noexcept (true) {
+SocketException::~SocketException() noexcept (true)
+{
 }
 
-const char *SocketException::what(){
+const char *SocketException::what()
+{
 	return userMessage.c_str();
 }
 
 // Function to fill in address structure given an address and port
 static void fillAddr(const string &address, unsigned short port,
-                     sockaddr_in &addr) {
+                     sockaddr_in &addr)
+{
 	memset(&addr, 0, sizeof(addr));  // Zero out address structure
 	addr.sin_family = AF_INET;       // Internet address
 
 	hostent *host;  // Resolve name
-  if ((host = gethostbyname(address.c_str())) == NULL) {
+	if ((host = gethostbyname(address.c_str())) == NULL)
+	{
 		// strerror() will not work for gethostbyname() and hstrerror()
 		// is supposedly obsolete
 		throw SocketException("Failed to resolve name (gethostbyname())");
@@ -52,15 +58,18 @@ static void fillAddr(const string &address, unsigned short port,
 
 // Socket Code
 
-Socket::Socket(int type, int protocol)  {
+Socket::Socket(int type, int protocol)
+{
 
 	// Make a new socket
-  if ((sockDesc = socket(PF_INET, type, protocol)) < 0) {
+	if ((sockDesc = socket(PF_INET, type, protocol)) < 0)
+	{
 		throw SocketException("Socket creation failed (socket())", true);
 	}
 }
 
-Socket::Socket(int sockDesc) {
+Socket::Socket(int sockDesc)
+{
 	this->sockDesc = sockDesc;
 }
 
@@ -70,27 +79,32 @@ Socket::~Socket()
 	sockDesc = -1;
 }
 
-string Socket::getLocalAddress()  {
+string Socket::getLocalAddress()
+{
 	sockaddr_in addr;
 	unsigned int addr_len = sizeof(addr);
 
-  if (getsockname(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0) {
+	if (getsockname(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0)
+	{
 		throw SocketException("Fetch of local address failed (getsockname())", true);
 	}
 	return inet_ntoa(addr.sin_addr);
 }
 
-unsigned short Socket::getLocalPort()  {
+unsigned short Socket::getLocalPort()
+{
 	sockaddr_in addr;
 	unsigned int addr_len = sizeof(addr);
 
-  if (getsockname(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0) {
+	if (getsockname(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0)
+	{
 		throw SocketException("Fetch of local port failed (getsockname())", true);
 	}
 	return ntohs(addr.sin_port);
 }
 
-void Socket::setLocalPort(unsigned short localPort)  {
+void Socket::setLocalPort(unsigned short localPort)
+{
 	// Bind the socket to its port
 	sockaddr_in localAddr;
 	memset(&localAddr, 0, sizeof(localAddr));
@@ -98,18 +112,21 @@ void Socket::setLocalPort(unsigned short localPort)  {
 	localAddr.sin_addr.s_addr = htonl(INADDR_ANY);
 	localAddr.sin_port = htons(localPort);
 
-  if (bind(sockDesc, (sockaddr *) &localAddr, sizeof(sockaddr_in)) < 0) {
+	if (bind(sockDesc, (sockaddr *) &localAddr, sizeof(sockaddr_in)) < 0)
+	{
 		throw SocketException("Set of local port failed (bind())", true);
 	}
 }
 
 void Socket::setLocalAddressAndPort(const string &localAddress,
-    unsigned short localPort)  {
+                                    unsigned short localPort)
+{
 	// Get the address of the requested host
 	sockaddr_in localAddr;
 	fillAddr(localAddress, localPort, localAddr);
 
-  if (bind(sockDesc, (sockaddr *) &localAddr, sizeof(sockaddr_in)) < 0) {
+	if (bind(sockDesc, (sockaddr *) &localAddr, sizeof(sockaddr_in)) < 0)
+	{
 		throw SocketException("Set of local address and port failed (bind())", true);
 	}
 }
@@ -132,12 +149,15 @@ void Socket::setKeepalive()
 void Socket::setBlocking(bool flag)
 {
 	int flags = fcntl(sockDesc, F_GETFL, 0);
-    if( !flag ) flags = flags | O_NONBLOCK;
-    else flags = flags & ~O_NONBLOCK;
+	if( !flag )
+		flags = flags | O_NONBLOCK;
+	else
+		flags = flags & ~O_NONBLOCK;
 	fcntl(sockDesc, F_SETFL, flags);
 }
 
-void Socket::cleanUp()  {
+void Socket::cleanUp()
+{
 
 }
 
@@ -147,7 +167,8 @@ int Socket::getFD()
 }
 
 unsigned short Socket::resolveService(const string &service,
-                                      const string &protocol) {
+                                      const string &protocol)
+{
 	struct servent *serv;        /* Structure containing service information */
 
 	if ((serv = getservbyname(service.c_str(), protocol.c_str())) == NULL)
@@ -159,27 +180,32 @@ unsigned short Socket::resolveService(const string &service,
 // CommunicatingSocket Code
 
 CommunicatingSocket::CommunicatingSocket(int type, int protocol)
-     : Socket(type, protocol) {
+	: Socket(type, protocol)
+{
 }
 
-CommunicatingSocket::CommunicatingSocket(int newConnSD) : Socket(newConnSD) {
+CommunicatingSocket::CommunicatingSocket(int newConnSD) : Socket(newConnSD)
+{
 }
 
 void CommunicatingSocket::connect(const string &foreignAddress,
-    unsigned short foreignPort)  {
+                                  unsigned short foreignPort)
+{
 	// Get the address of the requested host
 	sockaddr_in destAddr;
 	fillAddr(foreignAddress, foreignPort, destAddr);
 
 	// Try to connect to the given port
-  if (::connect(sockDesc, (sockaddr *) &destAddr, sizeof(destAddr)) < 0) {
+	if (::connect(sockDesc, (sockaddr *) &destAddr, sizeof(destAddr)) < 0)
+	{
 		throw SocketException("Connect failed (connect())", true);
 	}
 }
 
 void CommunicatingSocket::send(const void *buffer, int bufferLen)
 {
-  if (::send(sockDesc, (raw_type *) buffer, bufferLen, 0) < 0) {
+	if (::send(sockDesc, (raw_type *) buffer, bufferLen, 0) < 0)
+	{
 		throw SocketException("Send failed (send())", true);
 	}
 }
@@ -189,8 +215,10 @@ int CommunicatingSocket::recv(void *buffer, int bufferLen)
 	int rtn;
 	if ((rtn = ::recv(sockDesc, (raw_type *) buffer, bufferLen, MSG_DONTWAIT)) < 0 )
 	{
-    if(errno == EWOULDBLOCK || errno == EAGAIN) return -1;
-    else throw SocketException("Received failed (recv())", true);
+		if(errno == EWOULDBLOCK || errno == EAGAIN)
+			return -1;
+		else
+			throw SocketException("Received failed (recv())", true);
 	}
 
 	return rtn;
@@ -201,17 +229,20 @@ string CommunicatingSocket::getForeignAddress()
 	sockaddr_in addr;
 	unsigned int addr_len = sizeof(addr);
 
-  if (getpeername(sockDesc, (sockaddr *) &addr,(socklen_t *) &addr_len) < 0) {
+	if (getpeername(sockDesc, (sockaddr *) &addr,(socklen_t *) &addr_len) < 0)
+	{
 		throw SocketException("Fetch of foreign address failed (getpeername())", true);
 	}
 	return inet_ntoa(addr.sin_addr);
 }
 
-unsigned short CommunicatingSocket::getForeignPort()  {
+unsigned short CommunicatingSocket::getForeignPort()
+{
 	sockaddr_in addr;
 	unsigned int addr_len = sizeof(addr);
 
-  if (getpeername(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0) {
+	if (getpeername(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0)
+	{
 		throw SocketException("Fetch of foreign port failed (getpeername())", true);
 	}
 	return ntohs(addr.sin_port);
@@ -221,16 +252,20 @@ unsigned short CommunicatingSocket::getForeignPort()  {
 
 TCPSocket::TCPSocket()
 	: CommunicatingSocket(SOCK_STREAM,
-    IPPROTO_TCP) {
+	                      IPPROTO_TCP)
+{
 }
 
 TCPSocket::TCPSocket(const string &foreignAddress, unsigned short foreignPort, bool keepalive)
-     : CommunicatingSocket(SOCK_STREAM, IPPROTO_TCP) {
+	: CommunicatingSocket(SOCK_STREAM, IPPROTO_TCP)
+{
 	connect(foreignAddress, foreignPort);
-  if(keepalive) setKeepalive();
+	if(keepalive)
+		setKeepalive();
 }
 
-TCPSocket::TCPSocket(int newConnSD) : CommunicatingSocket(newConnSD) {
+TCPSocket::TCPSocket(int newConnSD) : CommunicatingSocket(newConnSD)
+{
 }
 
 // TCPServerSocket Code
@@ -262,15 +297,18 @@ TCPSocket* TCPServerSocket::accept()
 	if(newConnSD > 0)
 	{
 		newSocket = new TCPSocket(newConnSD);
-    if(keepalive) newSocket->setKeepalive();
+		if(keepalive)
+			newSocket->setKeepalive();
 	}
 	return newSocket;
 }
 
 
 
-void TCPServerSocket::setListen(int queueLen)  {
-  if (listen(sockDesc, queueLen) < 0) {
+void TCPServerSocket::setListen(int queueLen)
+{
+	if (listen(sockDesc, queueLen) < 0)
+	{
 		throw SocketException("Set listening socket failed (listen())", true);
 	}
 }
@@ -278,23 +316,27 @@ void TCPServerSocket::setListen(int queueLen)  {
 // UDPSocket Code
 
 UDPSocket::UDPSocket()  : CommunicatingSocket(SOCK_DGRAM,
-    IPPROTO_UDP) {
+	        IPPROTO_UDP)
+{
 	setBroadcast();
 }
 
 UDPSocket::UDPSocket(unsigned short localPort)   :
-    CommunicatingSocket(SOCK_DGRAM, IPPROTO_UDP) {
+	CommunicatingSocket(SOCK_DGRAM, IPPROTO_UDP)
+{
 	setLocalPort(localPort);
 	setBroadcast();
 }
 
 UDPSocket::UDPSocket(const string &localAddress, unsigned short localPort)
-      : CommunicatingSocket(SOCK_DGRAM, IPPROTO_UDP) {
+	: CommunicatingSocket(SOCK_DGRAM, IPPROTO_UDP)
+{
 	setLocalAddressAndPort(localAddress, localPort);
 	setBroadcast();
 }
 
-void UDPSocket::setBroadcast() {
+void UDPSocket::setBroadcast()
+{
 	// If this fails, we'll hear about it when we try to send.  This will allow
 	// system that cannot broadcast to continue if they don't plan to broadcast
 	int broadcastPermission = 1;
@@ -302,14 +344,17 @@ void UDPSocket::setBroadcast() {
 	           (raw_type *) &broadcastPermission, sizeof(broadcastPermission));
 }
 
-void UDPSocket::disconnect()  {
+void UDPSocket::disconnect()
+{
 	sockaddr_in nullAddr;
 	memset(&nullAddr, 0, sizeof(nullAddr));
 	nullAddr.sin_family = AF_UNSPEC;
 
 	// Try to disconnect
-  if (::connect(sockDesc, (sockaddr *) &nullAddr, sizeof(nullAddr)) < 0) {
-    if (errno != EAFNOSUPPORT) {
+	if (::connect(sockDesc, (sockaddr *) &nullAddr, sizeof(nullAddr)) < 0)
+	{
+		if (errno != EAFNOSUPPORT)
+		{
 			throw SocketException("Disconnect failed (connect())", true);
 		}
 	}
@@ -323,17 +368,20 @@ void UDPSocket::sendTo(const void *buffer, int bufferLen,
 
 	// Write out the whole buffer as a single message.
 	if (sendto(sockDesc, (raw_type *) buffer, bufferLen, 0,
-             (sockaddr *) &destAddr, sizeof(destAddr)) != bufferLen) {
+	           (sockaddr *) &destAddr, sizeof(destAddr)) != bufferLen)
+	{
 		throw SocketException("Send failed (sendto())", true);
 	}
 }
 
 int UDPSocket::recvFrom(void *buffer, int bufferLen, string &sourceAddress,
-    unsigned short &sourcePort)  {
+                        unsigned short &sourcePort)
+{
 	sockaddr_in clntAddr;
 	socklen_t addrLen = sizeof(clntAddr);
 	int rtn;
-  if ((rtn = recvfrom(sockDesc, (raw_type *) buffer, bufferLen, MSG_DONTWAIT, (sockaddr *) &clntAddr, (socklen_t *) &addrLen)) < 0) 
+	if ((rtn = recvfrom(sockDesc, (raw_type *) buffer, bufferLen, MSG_DONTWAIT, (sockaddr *) &clntAddr,
+	                    (socklen_t *) &addrLen)) < 0)
 	{
 		throw SocketException("Receive failed (recvfrom())", true);
 	}
@@ -343,33 +391,39 @@ int UDPSocket::recvFrom(void *buffer, int bufferLen, string &sourceAddress,
 	return rtn;
 }
 
-void UDPSocket::setMulticastTTL(unsigned char multicastTTL)  {
+void UDPSocket::setMulticastTTL(unsigned char multicastTTL)
+{
 	if (setsockopt(sockDesc, IPPROTO_IP, IP_MULTICAST_TTL,
-                 (raw_type *) &multicastTTL, sizeof(multicastTTL)) < 0) {
+	               (raw_type *) &multicastTTL, sizeof(multicastTTL)) < 0)
+	{
 		throw SocketException("Multicast TTL set failed (setsockopt())", true);
 	}
 }
 
-void UDPSocket::joinGroup(const string &multicastGroup)  {
+void UDPSocket::joinGroup(const string &multicastGroup)
+{
 	struct ip_mreq multicastRequest;
 
 	multicastRequest.imr_multiaddr.s_addr = inet_addr(multicastGroup.c_str());
 	multicastRequest.imr_interface.s_addr = htonl(INADDR_ANY);
 	if (setsockopt(sockDesc, IPPROTO_IP, IP_ADD_MEMBERSHIP,
 	               (raw_type *) &multicastRequest,
-                 sizeof(multicastRequest)) < 0) {
+	               sizeof(multicastRequest)) < 0)
+	{
 		throw SocketException("Multicast group join failed (setsockopt())", true);
 	}
 }
 
-void UDPSocket::leaveGroup(const string &multicastGroup)  {
+void UDPSocket::leaveGroup(const string &multicastGroup)
+{
 	struct ip_mreq multicastRequest;
 
 	multicastRequest.imr_multiaddr.s_addr = inet_addr(multicastGroup.c_str());
 	multicastRequest.imr_interface.s_addr = htonl(INADDR_ANY);
 	if (setsockopt(sockDesc, IPPROTO_IP, IP_DROP_MEMBERSHIP,
 	               (raw_type *) &multicastRequest,
-                 sizeof(multicastRequest)) < 0) {
+	               sizeof(multicastRequest)) < 0)
+	{
 		throw SocketException("Multicast group leave failed (setsockopt())", true);
 	}
 }

Socket.h

@@ -9,7 +9,8 @@
 /**
  *   Signals a problem with the execution of a socket call.
  */
-class SocketException : public std::exception {
+class SocketException : public std::exception
+{
 public:
 	/**
 	 *   Construct a SocketException with a explanatory message.
@@ -37,7 +38,8 @@ private:
 /**
  *   Base class representing basic communication endpoint
  */
-class Socket {
+class Socket
+{
 public:
 	/**
 	 *   Close and deallocate this socket
@@ -120,7 +122,8 @@ protected:
 /**
  *   Socket which is able to connect, send, and receive
  */
-class CommunicatingSocket : public Socket {
+class CommunicatingSocket : public Socket
+{
 public:
 	/**
 	 *   Establish a socket connection with the given foreign
@@ -173,7 +176,8 @@ protected:
 /**
  *   TCP socket for communication with other TCP sockets
  */
-class TCPSocket : public CommunicatingSocket {
+class TCPSocket : public CommunicatingSocket
+{
 public:
 	/**
 	 *   Construct a TCP socket with no connection
@@ -202,7 +206,8 @@ private:
 /**
  *   TCP socket class for servers
  */
-class TCPServerSocket : public Socket {
+class TCPServerSocket : public Socket
+{
 public:
 	/**
 	 *   Construct a TCP socket for use with a server, accepting connections
@@ -243,7 +248,8 @@ private:
 /**
   *   UDP socket class
   */
-class UDPSocket : public CommunicatingSocket {
+class UDPSocket : public CommunicatingSocket
+{
 public:
 	/**
 	 *   Construct a UDP socket

clienthandler.h

@@ -0,0 +1,135 @@
+#pragma once
+
+#include <vector>
+#include <array>
+#include <algorithm>
+#include <iostream>
+#include "Socket.h"
+#include "serial_io.h"
+
+class ClientHandler
+{
+private:
+	bool _isBroadcasting = false;
+	CommunicatingSocket *_socket;
+	bool _disconnected = false;
+
+public:
+
+	void cleanUp();
+	ClientHandler(CommunicatingSocket * const socket);
+	~ClientHandler();
+	bool operator==(int fd);
+	bool operator!=(int fd);
+	bool operator==(ClientHandler& other);
+	bool operator!=(ClientHandler& other);
+	bool isDisconnected();
+	bool run(std::vector<ClientHandler>* clients, int serial, bool verbose = false);
+	void write(const char* buffer, const size_t len);
+	void dropData();
+};
+
+ClientHandler::ClientHandler(CommunicatingSocket * const socket): _socket(socket)
+{}
+
+ClientHandler::~ClientHandler()
+{
+}
+
+void ClientHandler::cleanUp()
+{
+	_socket->cleanUp();
+	delete  _socket;
+}
+
+void ClientHandler::dropData()
+{
+	std::array<char, 4096> buffer;
+	while(_socket->recv(buffer.data(), 4096) > 0);
+}
+
+bool ClientHandler::run(std::vector<ClientHandler>* clients, int serial, bool verbose)
+{
+	std::array<char, 4096> buffer;
+	int reclen = 0;
+	try
+	{
+		reclen = _socket->recv(buffer.data(), 4096);
+		if(verbose)
+			std::cout<<"Recived "<<reclen<<" bytes\n";
+	}
+	catch (SocketException &e)
+	{
+		std::cout<<e.what()<<std::endl;
+		_disconnected = true;
+	}
+	if(reclen > 0)
+	{
+		if(!_isBroadcasting && reclen >= 5 && strncmp( buffer.data(), "bcst:", 5) == 0)
+			_isBroadcasting = true;
+
+		if(_isBroadcasting)
+		{
+			if(verbose)
+				std::cout<<"Boradcasting "<<reclen<<" bytes\n";
+			for(ClientHandler& item : *clients)
+				if(operator!=(item))
+					item.write(buffer.data(), reclen);
+			char* newline = std::find(buffer.begin(), buffer.end(), '\n');
+			if(newline != std::end(buffer))
+				_isBroadcasting = false;
+		}
+		else
+		{
+			if(verbose)
+				std::cout<<"wrote "<<reclen<<" bytes to serial\n";
+			if(sWrite(serial, buffer.data(), reclen) < 0 && (errno != EAGAIN || errno != EWOULDBLOCK))
+			{
+				throw serialIoException(serial, errno);
+			}
+		}
+	}
+	else if(reclen == 0)
+		_disconnected = true;
+	return !_disconnected;
+}
+
+bool ClientHandler::isDisconnected()
+{
+	return _disconnected;
+}
+
+void ClientHandler::write(const char* buffer, const size_t len)
+{
+	try
+	{
+		_socket->send(buffer, len);
+	}
+	catch (SocketException &e)
+	{
+		std::cout<<e.what()<<std::endl;
+		_disconnected = true;
+	}
+}
+
+bool ClientHandler::operator==(int fd)
+{
+	return fd == _socket->getFD();
+}
+
+
+bool ClientHandler::operator!=(int fd)
+{
+	return fd != _socket->getFD();
+}
+
+bool ClientHandler::operator==(ClientHandler& other)
+{
+	return _socket->getFD() == other._socket->getFD();
+}
+
+
+bool ClientHandler::operator!=(ClientHandler& other)
+{
+	return !(operator==(other));
+}

main.cpp

@@ -14,25 +14,17 @@
 
 #include "serial_io.h"
 #include "Socket.h"
+#include "clienthandler.h"
 
-#define VERSION "v0.5"
+#define VERSION "v0.7"
 
-volatile bool stop = false;
-volatile bool resettSerialPort = false;
-struct epoll_event ev;
+sig_atomic_t stop = false;
 
 void intHandler(int sig)
 {
 	stop = true;
 }
 
-void alarmHandler(int sig)
-{
-	resettSerialPort = true;
-	signal(sig, alarmHandler);
-	alarm(600);
-}
-
 static void printUsage()
 {
 	std::cout<<"usage mulitplexer [option]\n\
@@ -68,24 +60,29 @@ static int parseCmdArgs(int argc, char** argv, Config *config)
 		}
 		else if (std::string(argv[i]) == "--serialport" || std::string(argv[i]) == "-p")
 		{
-			if(argc > i) config->portFileName = argv[i+1];
-			else return -1;
+			if(argc > i)
+				config->portFileName = argv[i+1];
+			else
+				return -1;
 		}
 		else if (std::string(argv[i]) == "--port" || std::string(argv[i]) == "-P")
 		{
-			if(argc > i) config->port = atoi(argv[i+1]);
-			else return -1;
+			if(argc > i)
+				config->port = atoi(argv[i+1]);
+			else
+				return -1;
 		}
 		else if (std::string(argv[i]) == "--baud" || std::string(argv[i]) == "-b")
 		{
-			if(argc > i) config->baud = atoi(argv[i+1]);
-			else return -1;
+			if(argc > i)
+				config->baud = atoi(argv[i+1]);
+			else
+				return -1;
 		}
 		else if (std::string(argv[i]) == "--sinkless" || std::string(argv[i]) == "-s" )
 		{
 			config->noSerial=true;
 		}
-		
 		else if (std::string(argv[i]) == "-r" || std::string(argv[i]) == "--rates")
 		{
 			printRates();
@@ -103,18 +100,23 @@ static int parseCmdArgs(int argc, char** argv, Config *config)
 	return 0;
 }
 
-void acceptThreadFunction( TCPServerSocket* servSock,  std::vector<TCPSocket*>* clientSockets, std::mutex* clientSocketsMutex, int pollQue )
+void acceptThreadFunction( TCPServerSocket* servSock,  std::vector<ClientHandler>* clients, std::mutex* clientsMutex,
+                           int pollQue )
 {
 	while(!stop)
 	{
 		TCPSocket* newSock = servSock->accept();
 		if(newSock != nullptr)
 		{
-			clientSocketsMutex->lock();
-			clientSockets->push_back(newSock);       // Wait for a client to connect
-			clientSocketsMutex->unlock();
+			clientsMutex->lock();
+			clients->push_back(ClientHandler(newSock));       // Wait for a client to connect
+			struct epoll_event ev;
+			ev.events = EPOLLIN;
+			ev.data.fd = newSock->getFD();
+			clientsMutex->unlock();
 			epoll_ctl(pollQue, EPOLL_CTL_ADD, newSock->getFD(), &ev);
-			clientSockets->back()->send("UVOS serial multiplexer " VERSION "\n", sizeof("UVOS serial multiplexer " VERSION "\n")-1);
+			char welcomeMesg[] =  "UVOS serial multiplexer " VERSION "\n";
+			clients->back().write(welcomeMesg, sizeof(welcomeMesg)-1);
 			std::cout<<"got client\n";
 		}
 		std::this_thread::sleep_for(std::chrono::seconds(1));
@@ -129,13 +131,39 @@ int openSerialPort(const Config& config)
 		std::cout<<"Opeing serial port: "<<config.portFileName<<" at "<<config.baud<<" baud\n";
 		serial = serialport_init(config.portFileName.c_str(), config.baud);
 		if(serial == -1)
-		{
 			std::cout<<"Opeing serial port failed\n";
-			stop = true;
-		}
 		tcflush(serial, TCIOFLUSH);
 	}
-	else std::cout<<"Sinkless mode\n";
+	else
+		std::cout<<"Sinkless mode\n";
+	return serial;
+}
+
+int serialPortReconnect(Config& config, std::string err)
+{
+	std::cout<<"serial port execption "<<err<<"\ntrying to reopen\n";
+
+	sleep(10);
+	int serial = openSerialPort(config);
+	if(serial == -1)
+	{
+
+		if(config.portFileName == "/dev/ttyUSB0")
+		{
+			std::cout<<"Could not reopen "<<config.portFileName<<" trying /dev/ttyUSB1\n";
+			config.portFileName = "/dev/ttyUSB1";
+			serial = openSerialPort(config);
+		}
+		else if(config.portFileName == "/dev/ttyUSB1")
+		{
+			std::cout<<"Could not reopen "<<config.portFileName<<" trying /dev/ttyUSB0\n";
+			config.portFileName = "/dev/ttyUSB0";
+			serial = openSerialPort(config);
+		}
+
+		if(serial == -1)
+			std::cout<<"Could not reopen "<<config.portFileName<<'\n';
+	}
 	return serial;
 }
 
@@ -143,30 +171,36 @@ int main(int argc, char* argv[])
 {
 	Config config;
 
-	if(parseCmdArgs(argc, argv, &config) != 0) return -1;
+	if(parseCmdArgs(argc, argv, &config) != 0)
+		return -1;
 
 	std::cout<<"UVOS serial mulitplexer "<<VERSION<<'\n';
 
 	int pollQue = epoll_create1(0);
-	ev.events = EPOLLIN; 
+
+	std::mutex clientsMutex;
+	std::vector<ClientHandler> clients;
 
 	int serial = openSerialPort(config);
 	if(!config.noSerial)
 	{
-		std::cout<<"Using serial port: "<<config.portFileName<<" at "<<config.baud<<" baud\n";
-		serial = serialport_init(config.portFileName.c_str(), config.baud);
-		if(serial == -1) return 1;
+		if(serial == -1)
+		{
+			return 1;
+		}
 		else
 		{
-			struct epoll_event ev;
+			struct epoll_event ev = {};
+			ev.events = EPOLLIN;
+			ev.data.fd = -1;
 			epoll_ctl(pollQue, EPOLL_CTL_ADD, serial, &ev);
 		}
 		tcflush(serial, TCIOFLUSH);
 	}
-	else std::cout<<"Sinkless mode\n";
-	
-	std::mutex clientSocketsMutex;
-	std::vector<TCPSocket*> clientSockets;
+	else
+	{
+		std::cout<<"Sinkless mode\n";
+	}
 
 	std::thread* acceptThread;
 	TCPServerSocket* servSock;
@@ -174,9 +208,9 @@ int main(int argc, char* argv[])
 	std::cout<<"opening TCP socket on port "<<config.port<<'\n';
 	try
 	{
-		servSock = new TCPServerSocket(config.port, 5, true);     // Server Socket object
+		servSock = new TCPServerSocket(config.port, 5, true);
 		servSock->setBlocking(false);
-		acceptThread = new std::thread(acceptThreadFunction, servSock, &clientSockets, &clientSocketsMutex, pollQue);
+		acceptThread = new std::thread(acceptThreadFunction, servSock, &clients, &clientsMutex, pollQue);
 	}
 	catch(SocketException &e)
 	{
@@ -184,114 +218,100 @@ int main(int argc, char* argv[])
 		return 1;
 	}
 
-	char buffer[4096];
-	
 	signal(SIGINT, intHandler);
 	signal(SIGTERM, intHandler);
-	signal(SIGALRM, alarmHandler);
-	
-	if(config.reinit) alarm(600);
-	
+	signal(SIGPIPE, SIG_IGN);
 
 	std::cout<<"starting loop\n";
 
 	while(!stop)
 	{
-		epoll_wait(pollQue, &ev, 1, 2000);
-		int readlen = sRead(serial, buffer, 4096);
-		for(unsigned int i = 0; i < clientSockets.size(); i++)
+		struct epoll_event ev;
+		if(epoll_wait(pollQue, &ev, 1, 2000) == 1)
+		{
+			if(ev.data.fd != -1)
+			{
+				std::vector<ClientHandler>::iterator client =
+				    std::find(clients.begin(), clients.end(), ev.data.fd);
+				if(client == clients.end())
+					continue;
+				clientsMutex.lock();
+				std::cout<<"client poll\n";
+				if(ev.events & EPOLLIN)
 				{
-			clientSocketsMutex.lock();
 					try
 					{
-				if(readlen > 0) 
-				{
-					if(config.verbose) 
-					{
-						std::cout<<"bcst: ";
-						for( int j = 0; j < readlen; j++  )std::cout<<buffer[j];
-						std::cout<<std::endl;
+						client->run(&clients, serial, config.verbose);
 					}
-					clientSockets[i]->send(buffer, readlen);
-				}
-				
-				char inBuffer[4096];
-				int reclen = clientSockets[i]->recv(inBuffer, 4096);
-				if( reclen > 0 ) 
-				{
-					if(config.verbose)
-					{
-						std::cout<<"rec: ";
-						for( int j = 0; j < reclen; j++  )std::cout<<inBuffer[j];
-					}
-					if(strncmp( inBuffer, "bcst:", 5) == 0)
-					{
-						if(config.verbose) 
-						{
-							std::cout<<"bcst: ";
-							for( int j = 6; j < reclen; j++  )std::cout<<inBuffer[j];
-							std::cout<<std::endl;
-						}
-						for(unsigned int j = 0; j < clientSockets.size(); j++) if(i != j) clientSockets[j]->send(inBuffer+6, reclen-6);
-						
-					}
-					else if(strncmp( inBuffer, "reinitsp", 8) == 0 && serial != -1)
-					{
-						if(serialport_set_config(serial, config.baud) == 0)
-						{
-							char response[] = "reinit serial port succsesfull\n";
-							std::cerr<<response;
-							clientSockets[i]->send(response, sizeof(response));
-						}
-						else
-						{
-							char response[] = "reinit serial port failed!\n";
-							std::cerr<<response;
-							clientSockets[i]->send(response, sizeof(response));
-						}
-					}
-					else
-					{
-						if(config.verbose) 
-						{
-							std::cout<<"wrote \"";
-							for( int j = 0; j < reclen; j++  )std::cout<<inBuffer[j];
-							std::cout<<"\" to serial \n";
-						}
-						sWrite(serial, inBuffer, reclen);
-					}
-					if(config.verbose) std::cout<<std::endl;
-				}
-				else if(reclen == 0)
-				{
-					std::cout<<"client "<<i<<" disconnected"<<'\n';
-					clientSockets[i]->cleanUp();
-					clientSockets.erase(clientSockets.begin()+i);
-					i--;
-					if(i < 0) i=0;
-				}
-			}
-			catch(SocketException &e)
-			{
-				std::cout<<e.what()<<std::endl;
-				clientSockets[i]->cleanUp();
-				clientSockets.erase(clientSockets.begin()+i);
-				i--;
-				if(i < 0) i=0;
-			}
-			clientSocketsMutex.unlock();
-		}
-		if(resettSerialPort)
+					catch(serialIoException& ex)
 					{
 						close(serial);
-			serial = openSerialPort(config);
-			resettSerialPort = false;
+						serial = serialPortReconnect(config, ex.what());
+						if(serial < 0)
+						{
+							std::cerr<<"Serial port connection has failed with: "<<strerror(errno)<<'\n';
+							return 2;
+						}
+
+						struct epoll_event ev = {};
+						ev.events = EPOLLIN;
+						ev.data.fd = -1;
+						epoll_ctl(pollQue, EPOLL_CTL_ADD, serial, &ev);
+					}
+				}
+				if((ev.events & (EPOLLHUP | EPOLLERR)) || client->isDisconnected())
+				{
+					client->cleanUp();
+					clients.erase(client);
+					std::cout<<"client disconnected\n";
+				}
+				clientsMutex.unlock();
+			}
+			else
+			{
+				char buffer[4096];
+				ssize_t readlen = sRead(serial, buffer, 4096);
+				if(readlen < 0 && (errno != EAGAIN || errno != EWOULDBLOCK))
+				{
+					close(serial);
+					serial = serialPortReconnect(config, strerror(errno));
+					if(serial < 0)
+					{
+						std::cerr<<"Serial port connection has failed with: "<<strerror(errno)<<'\n';
+						return 2;
+					}
+
+					struct epoll_event ev = {};
+					ev.events = EPOLLIN;
+					ev.data.fd = -1;
+					epoll_ctl(pollQue, EPOLL_CTL_ADD, serial, &ev);
+				}
+				if(config.verbose)
+				{
+					std::cout<<"Sending \"";
+					for(ssize_t i = 0; i < readlen; ++i)
+					{
+						if(buffer[i] == '\n')
+							std::cout<<"\\n";
+						else
+							std::cout<<buffer[i];
+					}
+					std::cout<<"\" to clients from serial\n";
+				}
+				clientsMutex.lock();
+				for(ClientHandler& client : clients)
+				{
+					client.write(buffer, readlen);
+				}
+				clientsMutex.unlock();
+			}
 		}
 	}
 
 	acceptThread->join();
 	delete acceptThread;
-	for(unsigned int i = 0; i < clientSockets.size(); i++) clientSockets[i]->cleanUp();
+	for(ClientHandler& client : clients)
+		client.cleanUp();
 	servSock->cleanUp();
 	delete servSock;
 	return 0;

serial_io.cpp

@@ -1,13 +1,19 @@
 #include "serial_io.h"
 
-void sWrite(int port, char string[], size_t length)
+ssize_t sWrite(int port, char string[], size_t length)
 {
-    if(port != -1) write(port, string, length);
+	if(port != -1)
+		return write(port, string, length);
+	else
+		return 0;
 }
 
-void sWrite(int port, const char string[], size_t length)
+ssize_t sWrite(int port, const char string[], size_t length)
 {
-    if(port != -1) write(port, string, length);
+	if(port != -1)
+		return write(port, string, length);
+	else
+		return 0;
 }
 
 ssize_t sRead(int port, void *buf, size_t count)

serial_io.h

@@ -6,13 +6,15 @@
 
 #ifdef __cplusplus
 #include <iostream>
+#include <stdexcept>
+#include <string.h>
 #endif
 
 #define BAUDRATE B38400
 
-void sWrite(int port, char string[], size_t length);
+ssize_t sWrite(int port, char string[], size_t length);
 
-void sWrite(int port, const char string[], size_t length);
+ssize_t sWrite(int port, const char string[], size_t length);
 
 ssize_t sRead(int port, void *buf, size_t count);
 
@@ -24,5 +26,18 @@ int serialport_set_config(int fd, int baud);
 
 int serialport_init(const char* device, int baud = BAUDRATE, bool block = false);
 
+#ifdef __cplusplus
+class serialIoException: public std::runtime_error
+{
+public:
+	int fd;
+	int errorNumber;
+	serialIoException(int fd_, int errorNumber_):
+		std::runtime_error("file descriptor error, fd: " + std::to_string(fd_) + " error: " + strerror(errorNumber_) + "\n"),
+		fd(fd_), errorNumber(errorNumber_)
+	{}
+};
+#endif
+
 
 #endif // SERIAL_H