uvos/SerialPortMultiplexer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reformat source

Browse Source
This commit is contained in:
uvos 2024-08-08 21:10:29 +02:00
parent 15fe1a928a
commit 5df7c881b9
6 changed files with 733 additions and 649 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

552
Socket.cpp
View File

@ -2,15 +2,15 @@
#include "Socket.h" #include "Socket.h"
#include <sys/types.h> // For data types #include <sys/types.h> // For data types
#include <sys/socket.h> // For socket(), connect(), send(), and recv() #include <sys/socket.h> // For socket(), connect(), send(), and recv()
#include <netdb.h> // For gethostbyname() #include <netdb.h> // For gethostbyname()
#include <arpa/inet.h> // For inet_addr() #include <arpa/inet.h> // For inet_addr()
#include <unistd.h> // For close() #include <unistd.h> // For close()
#include <netinet/in.h> // For sockaddr_in #include <netinet/in.h> // For sockaddr_in
#include <netinet/tcp.h> // TCP_KEEPCNT #include <netinet/tcp.h> // TCP_KEEPCNT
#include <fcntl.h> #include <fcntl.h>
typedef void raw_type; // Type used for raw data on this platform typedef void raw_type; // Type used for raw data on this platform
#include <errno.h> // For errno #include <errno.h> // For errno
@ -19,126 +19,146 @@ using namespace std;
// SocketException Code // SocketException Code
SocketException::SocketException(const string &message, bool inclSysMsg) SocketException::SocketException(const string &message, bool inclSysMsg)
: userMessage(message) { : userMessage(message)
if (inclSysMsg) { {
userMessage.append(": "); if (inclSysMsg)
userMessage.append(strerror(errno)); {
} 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(); {
return userMessage.c_str();
} }
// Function to fill in address structure given an address and port // Function to fill in address structure given an address and port
static void fillAddr(const string &address, unsigned short 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 memset(&addr, 0, sizeof(addr)); // Zero out address structure
addr.sin_family = AF_INET; // Internet address
hostent *host; // Resolve name 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 // strerror() will not work for gethostbyname() and hstrerror()
throw SocketException("Failed to resolve name (gethostbyname())"); // is supposedly obsolete
} throw SocketException("Failed to resolve name (gethostbyname())");
addr.sin_addr.s_addr = *((unsigned long *) host->h_addr_list[0]); }
addr.sin_addr.s_addr = *((unsigned long *) host->h_addr_list[0]);
addr.sin_port = htons(port); // Assign port in network byte order addr.sin_port = htons(port); // Assign port in network byte order
} }
// Socket Code // 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) {
throw SocketException("Socket creation failed (socket())", true);
}
}
Socket::Socket(int sockDesc) {
this->sockDesc = sockDesc;
}
Socket::~Socket()
{ {
close(sockDesc);
sockDesc = -1; // Make a new socket
if ((sockDesc = socket(PF_INET, type, protocol)) < 0)
{
throw SocketException("Socket creation failed (socket())", true);
}
} }
string Socket::getLocalAddress() { Socket::Socket(int sockDesc)
sockaddr_in addr; {
unsigned int addr_len = sizeof(addr); this->sockDesc = sockDesc;
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() { Socket::~Socket()
sockaddr_in addr; {
unsigned int addr_len = sizeof(addr); close(sockDesc);
sockDesc = -1;
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) { string Socket::getLocalAddress()
// Bind the socket to its port {
sockaddr_in localAddr; sockaddr_in addr;
memset(&localAddr, 0, sizeof(localAddr)); unsigned int addr_len = sizeof(addr);
localAddr.sin_family = AF_INET;
localAddr.sin_addr.s_addr = htonl(INADDR_ANY);
localAddr.sin_port = htons(localPort);
if (bind(sockDesc, (sockaddr *) &localAddr, sizeof(sockaddr_in)) < 0) { if (getsockname(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0)
throw SocketException("Set of local port failed (bind())", true); {
} throw SocketException("Fetch of local address failed (getsockname())", true);
}
return inet_ntoa(addr.sin_addr);
}
unsigned short Socket::getLocalPort()
{
sockaddr_in addr;
unsigned int addr_len = sizeof(addr);
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)
{
// Bind the socket to its port
sockaddr_in localAddr;
memset(&localAddr, 0, sizeof(localAddr));
localAddr.sin_family = AF_INET;
localAddr.sin_addr.s_addr = htonl(INADDR_ANY);
localAddr.sin_port = htons(localPort);
if (bind(sockDesc, (sockaddr *) &localAddr, sizeof(sockaddr_in)) < 0)
{
throw SocketException("Set of local port failed (bind())", true);
}
} }
void Socket::setLocalAddressAndPort(const string &localAddress, void Socket::setLocalAddressAndPort(const string &localAddress,
unsigned short localPort) { unsigned short localPort)
// Get the address of the requested host {
sockaddr_in localAddr; // Get the address of the requested host
fillAddr(localAddress, localPort, localAddr); 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); {
} throw SocketException("Set of local address and port failed (bind())", true);
}
} }
void Socket::setKeepalive() void Socket::setKeepalive()
{ {
int optval = 1; int optval = 1;
setsockopt(sockDesc, SOL_SOCKET, SO_KEEPALIVE,&optval, sizeof(optval)); setsockopt(sockDesc, SOL_SOCKET, SO_KEEPALIVE,&optval, sizeof(optval));
optval = 2; optval = 2;
setsockopt(sockDesc, SOL_SOCKET, TCP_KEEPCNT, &optval, sizeof(optval)); setsockopt(sockDesc, SOL_SOCKET, TCP_KEEPCNT, &optval, sizeof(optval));
optval = 10; optval = 10;
setsockopt(sockDesc, SOL_SOCKET, TCP_KEEPIDLE, &optval, sizeof(optval)); setsockopt(sockDesc, SOL_SOCKET, TCP_KEEPIDLE, &optval, sizeof(optval));
optval = 5; optval = 5;
setsockopt(sockDesc, SOL_SOCKET, TCP_KEEPINTVL, &optval, sizeof(optval)); setsockopt(sockDesc, SOL_SOCKET, TCP_KEEPINTVL, &optval, sizeof(optval));
} }
void Socket::setBlocking(bool flag) void Socket::setBlocking(bool flag)
{ {
int flags = fcntl(sockDesc, F_GETFL, 0); int flags = fcntl(sockDesc, F_GETFL, 0);
if( !flag ) flags = flags | O_NONBLOCK; if( !flag )
else flags = flags & ~O_NONBLOCK; flags = flags | O_NONBLOCK;
fcntl(sockDesc, F_SETFL, flags); else
flags = flags & ~O_NONBLOCK;
fcntl(sockDesc, F_SETFL, flags);
} }
void Socket::cleanUp() { void Socket::cleanUp()
{
} }
int Socket::getFD() int Socket::getFD()
@ -147,229 +167,263 @@ int Socket::getFD()
} }
unsigned short Socket::resolveService(const string &service, unsigned short Socket::resolveService(const string &service,
const string &protocol) { const string &protocol)
struct servent *serv; /* Structure containing service information */ {
struct servent *serv; /* Structure containing service information */
if ((serv = getservbyname(service.c_str(), protocol.c_str())) == NULL) if ((serv = getservbyname(service.c_str(), protocol.c_str())) == NULL)
return atoi(service.c_str()); /* Service is port number */ return atoi(service.c_str()); /* Service is port number */
else else
return ntohs(serv->s_port); /* Found port (network byte order) by name */ return ntohs(serv->s_port); /* Found port (network byte order) by name */
} }
// CommunicatingSocket Code // CommunicatingSocket Code
CommunicatingSocket::CommunicatingSocket(int type, int protocol) 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, 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) {
throw SocketException("Connect failed (connect())", true);
}
}
void CommunicatingSocket::send(const void *buffer, int bufferLen)
{
if (::send(sockDesc, (raw_type *) buffer, bufferLen, 0) < 0) {
throw SocketException("Send failed (send())", true);
}
}
int CommunicatingSocket::recv(void *buffer, int bufferLen)
{ {
int rtn; // Get the address of the requested host
if ((rtn = ::recv(sockDesc, (raw_type *) buffer, bufferLen, MSG_DONTWAIT)) < 0 ) sockaddr_in destAddr;
{ fillAddr(foreignAddress, foreignPort, destAddr);
if(errno == EWOULDBLOCK || errno == EAGAIN) return -1;
else throw SocketException("Received failed (recv())", true);
}
return rtn; // Try to connect to the given port
if (::connect(sockDesc, (sockaddr *) &destAddr, sizeof(destAddr)) < 0)
{
throw SocketException("Connect failed (connect())", true);
}
} }
string CommunicatingSocket::getForeignAddress() void CommunicatingSocket::send(const void *buffer, int bufferLen)
{ {
sockaddr_in addr; if (::send(sockDesc, (raw_type *) buffer, bufferLen, 0) < 0)
unsigned int addr_len = sizeof(addr); {
throw SocketException("Send failed (send())", true);
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() { int CommunicatingSocket::recv(void *buffer, int bufferLen)
sockaddr_in addr; {
unsigned int addr_len = sizeof(addr); 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 (getpeername(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0) { return rtn;
throw SocketException("Fetch of foreign port failed (getpeername())", true); }
}
return ntohs(addr.sin_port); string CommunicatingSocket::getForeignAddress()
{
sockaddr_in addr;
unsigned int addr_len = sizeof(addr);
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()
{
sockaddr_in addr;
unsigned int addr_len = sizeof(addr);
if (getpeername(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0)
{
throw SocketException("Fetch of foreign port failed (getpeername())", true);
}
return ntohs(addr.sin_port);
} }
// TCPSocket Code // TCPSocket Code
TCPSocket::TCPSocket() TCPSocket::TCPSocket()
: CommunicatingSocket(SOCK_STREAM, : CommunicatingSocket(SOCK_STREAM,
IPPROTO_TCP) { IPPROTO_TCP)
{
} }
TCPSocket::TCPSocket(const string &foreignAddress, unsigned short foreignPort, bool keepalive) 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(); connect(foreignAddress, foreignPort);
if(keepalive)
setKeepalive();
} }
TCPSocket::TCPSocket(int newConnSD) : CommunicatingSocket(newConnSD) { TCPSocket::TCPSocket(int newConnSD) : CommunicatingSocket(newConnSD)
{
} }
// TCPServerSocket Code // TCPServerSocket Code
TCPServerSocket::TCPServerSocket(unsigned short localPort, int queueLen, bool keepaliveIN) TCPServerSocket::TCPServerSocket(unsigned short localPort, int queueLen, bool keepaliveIN)
: Socket(SOCK_STREAM, IPPROTO_TCP) : Socket(SOCK_STREAM, IPPROTO_TCP)
{ {
keepalive = keepaliveIN; keepalive = keepaliveIN;
setLocalPort(localPort); setLocalPort(localPort);
setListen(queueLen); setListen(queueLen);
} }
TCPServerSocket::TCPServerSocket(const string &localAddress, unsigned short localPort, int queueLen, bool keepaliveIN) TCPServerSocket::TCPServerSocket(const string &localAddress, unsigned short localPort, int queueLen, bool keepaliveIN)
: Socket(SOCK_STREAM, IPPROTO_TCP) : Socket(SOCK_STREAM, IPPROTO_TCP)
{ {
keepalive = keepaliveIN; keepalive = keepaliveIN;
setLocalAddressAndPort(localAddress, localPort); setLocalAddressAndPort(localAddress, localPort);
setListen(queueLen); setListen(queueLen);
} }
TCPSocket* TCPServerSocket::accept() TCPSocket* TCPServerSocket::accept()
{ {
int newConnSD = -1; int newConnSD = -1;
if ((newConnSD = ::accept(sockDesc, NULL, 0)) < 0 && errno != EAGAIN && errno != EWOULDBLOCK ) if ((newConnSD = ::accept(sockDesc, NULL, 0)) < 0 && errno != EAGAIN && errno != EWOULDBLOCK )
{ {
throw SocketException("Accept failed (accept())", true); throw SocketException("Accept failed (accept())", true);
} }
TCPSocket* newSocket = nullptr; TCPSocket* newSocket = nullptr;
if(newConnSD > 0) if(newConnSD > 0)
{ {
newSocket = new TCPSocket(newConnSD); newSocket = new TCPSocket(newConnSD);
if(keepalive) newSocket->setKeepalive(); if(keepalive)
} newSocket->setKeepalive();
return newSocket; }
return newSocket;
} }
void TCPServerSocket::setListen(int queueLen) { void TCPServerSocket::setListen(int queueLen)
if (listen(sockDesc, queueLen) < 0) { {
throw SocketException("Set listening socket failed (listen())", true); if (listen(sockDesc, queueLen) < 0)
} {
throw SocketException("Set listening socket failed (listen())", true);
}
} }
// UDPSocket Code // UDPSocket Code
UDPSocket::UDPSocket() : CommunicatingSocket(SOCK_DGRAM, UDPSocket::UDPSocket() : CommunicatingSocket(SOCK_DGRAM,
IPPROTO_UDP) { IPPROTO_UDP)
setBroadcast(); {
setBroadcast();
} }
UDPSocket::UDPSocket(unsigned short localPort) : UDPSocket::UDPSocket(unsigned short localPort) :
CommunicatingSocket(SOCK_DGRAM, IPPROTO_UDP) { CommunicatingSocket(SOCK_DGRAM, IPPROTO_UDP)
setLocalPort(localPort); {
setBroadcast(); setLocalPort(localPort);
setBroadcast();
} }
UDPSocket::UDPSocket(const string &localAddress, unsigned short localPort) UDPSocket::UDPSocket(const string &localAddress, unsigned short localPort)
: CommunicatingSocket(SOCK_DGRAM, IPPROTO_UDP) { : CommunicatingSocket(SOCK_DGRAM, IPPROTO_UDP)
setLocalAddressAndPort(localAddress, localPort); {
setBroadcast(); 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 // If this fails, we'll hear about it when we try to send. This will allow
int broadcastPermission = 1; // system that cannot broadcast to continue if they don't plan to broadcast
setsockopt(sockDesc, SOL_SOCKET, SO_BROADCAST, int broadcastPermission = 1;
(raw_type *) &broadcastPermission, sizeof(broadcastPermission)); setsockopt(sockDesc, SOL_SOCKET, SO_BROADCAST,
(raw_type *) &broadcastPermission, sizeof(broadcastPermission));
} }
void UDPSocket::disconnect() { void UDPSocket::disconnect()
sockaddr_in nullAddr; {
memset(&nullAddr, 0, sizeof(nullAddr)); sockaddr_in nullAddr;
nullAddr.sin_family = AF_UNSPEC; memset(&nullAddr, 0, sizeof(nullAddr));
nullAddr.sin_family = AF_UNSPEC;
// Try to disconnect // Try to disconnect
if (::connect(sockDesc, (sockaddr *) &nullAddr, sizeof(nullAddr)) < 0) { if (::connect(sockDesc, (sockaddr *) &nullAddr, sizeof(nullAddr)) < 0)
if (errno != EAFNOSUPPORT) { {
throw SocketException("Disconnect failed (connect())", true); if (errno != EAFNOSUPPORT)
} {
} throw SocketException("Disconnect failed (connect())", true);
}
}
} }
void UDPSocket::sendTo(const void *buffer, int bufferLen, void UDPSocket::sendTo(const void *buffer, int bufferLen,
const string &foreignAddress, unsigned short foreignPort) const string &foreignAddress, unsigned short foreignPort)
{ {
sockaddr_in destAddr; sockaddr_in destAddr;
fillAddr(foreignAddress, foreignPort, destAddr); fillAddr(foreignAddress, foreignPort, destAddr);
// Write out the whole buffer as a single message. // Write out the whole buffer as a single message.
if (sendto(sockDesc, (raw_type *) buffer, bufferLen, 0, if (sendto(sockDesc, (raw_type *) buffer, bufferLen, 0,
(sockaddr *) &destAddr, sizeof(destAddr)) != bufferLen) { (sockaddr *) &destAddr, sizeof(destAddr)) != bufferLen)
throw SocketException("Send failed (sendto())", true); {
} throw SocketException("Send failed (sendto())", true);
}
} }
int UDPSocket::recvFrom(void *buffer, int bufferLen, string &sourceAddress, int UDPSocket::recvFrom(void *buffer, int bufferLen, string &sourceAddress,
unsigned short &sourcePort) { unsigned short &sourcePort)
sockaddr_in clntAddr; {
socklen_t addrLen = sizeof(clntAddr); sockaddr_in clntAddr;
int rtn; socklen_t addrLen = sizeof(clntAddr);
if ((rtn = recvfrom(sockDesc, (raw_type *) buffer, bufferLen, MSG_DONTWAIT, (sockaddr *) &clntAddr, (socklen_t *) &addrLen)) < 0) int rtn;
{ if ((rtn = recvfrom(sockDesc, (raw_type *) buffer, bufferLen, MSG_DONTWAIT, (sockaddr *) &clntAddr,
throw SocketException("Receive failed (recvfrom())", true); (socklen_t *) &addrLen)) < 0)
} {
sourceAddress = inet_ntoa(clntAddr.sin_addr); throw SocketException("Receive failed (recvfrom())", true);
sourcePort = ntohs(clntAddr.sin_port); }
sourceAddress = inet_ntoa(clntAddr.sin_addr);
sourcePort = ntohs(clntAddr.sin_port);
return rtn; 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) { if (setsockopt(sockDesc, IPPROTO_IP, IP_MULTICAST_TTL,
throw SocketException("Multicast TTL set failed (setsockopt())", true); (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; {
struct ip_mreq multicastRequest;
multicastRequest.imr_multiaddr.s_addr = inet_addr(multicastGroup.c_str()); multicastRequest.imr_multiaddr.s_addr = inet_addr(multicastGroup.c_str());
multicastRequest.imr_interface.s_addr = htonl(INADDR_ANY); multicastRequest.imr_interface.s_addr = htonl(INADDR_ANY);
if (setsockopt(sockDesc, IPPROTO_IP, IP_ADD_MEMBERSHIP, if (setsockopt(sockDesc, IPPROTO_IP, IP_ADD_MEMBERSHIP,
(raw_type *) &multicastRequest, (raw_type *) &multicastRequest,
sizeof(multicastRequest)) < 0) { sizeof(multicastRequest)) < 0)
throw SocketException("Multicast group join failed (setsockopt())", true); {
} throw SocketException("Multicast group join failed (setsockopt())", true);
}
} }
void UDPSocket::leaveGroup(const string &multicastGroup) { void UDPSocket::leaveGroup(const string &multicastGroup)
struct ip_mreq multicastRequest; {
struct ip_mreq multicastRequest;
multicastRequest.imr_multiaddr.s_addr = inet_addr(multicastGroup.c_str()); multicastRequest.imr_multiaddr.s_addr = inet_addr(multicastGroup.c_str());
multicastRequest.imr_interface.s_addr = htonl(INADDR_ANY); multicastRequest.imr_interface.s_addr = htonl(INADDR_ANY);
if (setsockopt(sockDesc, IPPROTO_IP, IP_DROP_MEMBERSHIP, if (setsockopt(sockDesc, IPPROTO_IP, IP_DROP_MEMBERSHIP,
(raw_type *) &multicastRequest, (raw_type *) &multicastRequest,
sizeof(multicastRequest)) < 0) { sizeof(multicastRequest)) < 0)
throw SocketException("Multicast group leave failed (setsockopt())", true); {
} throw SocketException("Multicast group leave failed (setsockopt())", true);
}
} }

496
Socket.h
View File

@ -9,320 +9,326 @@
/** /**
* Signals a problem with the execution of a socket call. * Signals a problem with the execution of a socket call.
*/ */
class SocketException : public std::exception { class SocketException : public std::exception
{
public: public:
/** /**
* Construct a SocketException with a explanatory message. * Construct a SocketException with a explanatory message.
* @param message explanatory message * @param message explanatory message
* @param incSysMsg true if system message (from strerror(errno)) * @param incSysMsg true if system message (from strerror(errno))
* should be postfixed to the user provided message * should be postfixed to the user provided message
*/ */
SocketException(const std::string &message, bool inclSysMsg = false) ; SocketException(const std::string &message, bool inclSysMsg = false) ;
/** /**
* Provided just to guarantee that no exceptions are thrown. * Provided just to guarantee that no exceptions are thrown.
*/ */
~SocketException() noexcept (true); ~SocketException() noexcept (true);
/** /**
* Get the exception message * Get the exception message
* @return exception message * @return exception message
*/ */
const char *what(); const char *what();
private: private:
std::string userMessage; // Exception message std::string userMessage; // Exception message
}; };
/** /**
* Base class representing basic communication endpoint * Base class representing basic communication endpoint
*/ */
class Socket { class Socket
{
public: public:
/** /**
* Close and deallocate this socket * Close and deallocate this socket
*/ */
~Socket(); ~Socket();
/** /**
* Get the local address * Get the local address
* @return local address of socket * @return local address of socket
* @exception SocketException thrown if fetch fails * @exception SocketException thrown if fetch fails
*/ */
std::string getLocalAddress(); std::string getLocalAddress();
/** /**
* Get the local port * Get the local port
* @return local port of socket * @return local port of socket
* @exception SocketException thrown if fetch fails * @exception SocketException thrown if fetch fails
*/ */
unsigned short getLocalPort() ; unsigned short getLocalPort() ;
/** /**
* Set the local port to the specified port and the local address * Set the local port to the specified port and the local address
* to any interface * to any interface
* @param localPort local port * @param localPort local port
* @exception SocketException thrown if setting local port fails * @exception SocketException thrown if setting local port fails
*/ */
void setLocalPort(unsigned short localPort) ; void setLocalPort(unsigned short localPort) ;
/** /**
* Set the local port to the specified port and the local address * Set the local port to the specified port and the local address
* to the specified address. If you omit the port, a random port * to the specified address. If you omit the port, a random port
* will be selected. * will be selected.
* @param localAddress local address * @param localAddress local address
* @param localPort local port * @param localPort local port
* @exception SocketException thrown if setting local port or address fails * @exception SocketException thrown if setting local port or address fails
*/ */
void setLocalAddressAndPort(const std::string &localAddress, void setLocalAddressAndPort(const std::string &localAddress,
unsigned short localPort = 0) ; unsigned short localPort = 0) ;
/** /**
* If WinSock, unload the WinSock DLLs; otherwise do nothing. We ignore * If WinSock, unload the WinSock DLLs; otherwise do nothing. We ignore
* this in our sample client code but include it in the library for * this in our sample client code but include it in the library for
* completeness. If you are running on Windows and you are concerned * completeness. If you are running on Windows and you are concerned
* about DLL resource consumption, call this after you are done with all * about DLL resource consumption, call this after you are done with all
* Socket instances. If you execute this on Windows while some instance of * Socket instances. If you execute this on Windows while some instance of
* Socket exists, you are toast. For portability of client code, this is * Socket exists, you are toast. For portability of client code, this is
* an empty function on non-Windows platforms so you can always include it. * an empty function on non-Windows platforms so you can always include it.
* @param buffer buffer to receive the data * @param buffer buffer to receive the data
* @param bufferLen maximum number of bytes to read into buffer * @param bufferLen maximum number of bytes to read into buffer
* @return number of bytes read, 0 for EOF, and -1 for error * @return number of bytes read, 0 for EOF, and -1 for error
* @exception SocketException thrown WinSock clean up fails * @exception SocketException thrown WinSock clean up fails
*/ */
static void cleanUp() ; static void cleanUp() ;
/** /**
* Resolve the specified service for the specified protocol to the * Resolve the specified service for the specified protocol to the
* corresponding port number in host byte order * corresponding port number in host byte order
* @param service service to resolve (e.g., "http") * @param service service to resolve (e.g., "http")
* @param protocol protocol of service to resolve. Default is "tcp". * @param protocol protocol of service to resolve. Default is "tcp".
*/ */
static unsigned short resolveService(const std::string &service, static unsigned short resolveService(const std::string &service,
const std::string &protocol = "tcp"); const std::string &protocol = "tcp");
void setKeepalive(); void setKeepalive();
void setBlocking(bool flag); void setBlocking(bool flag);
int getFD(); int getFD();
private: private:
// Prevent the user from trying to use value semantics on this object // Prevent the user from trying to use value semantics on this object
Socket(const Socket &sock); Socket(const Socket &sock);
void operator=(const Socket &sock); void operator=(const Socket &sock);
protected: protected:
int sockDesc; // Socket descriptor int sockDesc; // Socket descriptor
Socket(int type, int protocol) ; Socket(int type, int protocol) ;
Socket(int sockDesc); Socket(int sockDesc);
}; };
/** /**
* Socket which is able to connect, send, and receive * Socket which is able to connect, send, and receive
*/ */
class CommunicatingSocket : public Socket { class CommunicatingSocket : public Socket
{
public: public:
/** /**
* Establish a socket connection with the given foreign * Establish a socket connection with the given foreign
* address and port * address and port
* @param foreignAddress foreign address (IP address or name) * @param foreignAddress foreign address (IP address or name)
* @param foreignPort foreign port * @param foreignPort foreign port
* @exception SocketException thrown if unable to establish connection * @exception SocketException thrown if unable to establish connection
*/ */
void connect(const std::string &foreignAddress, unsigned short foreignPort) void connect(const std::string &foreignAddress, unsigned short foreignPort)
; ;
/** /**
* Write the given buffer to this socket. Call connect() before * Write the given buffer to this socket. Call connect() before
* calling send() * calling send()
* @param buffer buffer to be written * @param buffer buffer to be written
* @param bufferLen number of bytes from buffer to be written * @param bufferLen number of bytes from buffer to be written
* @exception SocketException thrown if unable to send data * @exception SocketException thrown if unable to send data
*/ */
void send(const void *buffer, int bufferLen) ; void send(const void *buffer, int bufferLen) ;
/** /**
* Read into the given buffer up to bufferLen bytes data from this * Read into the given buffer up to bufferLen bytes data from this
* socket. Call connect() before calling recv() * socket. Call connect() before calling recv()
* @param buffer buffer to receive the data * @param buffer buffer to receive the data
* @param bufferLen maximum number of bytes to read into buffer * @param bufferLen maximum number of bytes to read into buffer
* @return number of bytes read, 0 for EOF, and -1 for error * @return number of bytes read, 0 for EOF, and -1 for error
* @exception SocketException thrown if unable to receive data * @exception SocketException thrown if unable to receive data
*/ */
int recv(void *buffer, int bufferLen) ; int recv(void *buffer, int bufferLen) ;
/** /**
* Get the foreign address. Call connect() before calling recv() * Get the foreign address. Call connect() before calling recv()
* @return foreign address * @return foreign address
* @exception SocketException thrown if unable to fetch foreign address * @exception SocketException thrown if unable to fetch foreign address
*/ */
std::string getForeignAddress() ; std::string getForeignAddress() ;
/** /**
* Get the foreign port. Call connect() before calling recv() * Get the foreign port. Call connect() before calling recv()
* @return foreign port * @return foreign port
* @exception SocketException thrown if unable to fetch foreign port * @exception SocketException thrown if unable to fetch foreign port
*/ */
unsigned short getForeignPort() ; unsigned short getForeignPort() ;
protected: protected:
CommunicatingSocket(int type, int protocol) ; CommunicatingSocket(int type, int protocol) ;
CommunicatingSocket(int newConnSD); CommunicatingSocket(int newConnSD);
}; };
/** /**
* TCP socket for communication with other TCP sockets * TCP socket for communication with other TCP sockets
*/ */
class TCPSocket : public CommunicatingSocket { class TCPSocket : public CommunicatingSocket
{
public: public:
/** /**
* Construct a TCP socket with no connection * Construct a TCP socket with no connection
* @exception SocketException thrown if unable to create TCP socket * @exception SocketException thrown if unable to create TCP socket
*/ */
TCPSocket() ; TCPSocket() ;
/** /**
* Construct a TCP socket with a connection to the given foreign address * Construct a TCP socket with a connection to the given foreign address
* and port * and port
* @param foreignAddress foreign address (IP address or name) * @param foreignAddress foreign address (IP address or name)
* @param foreignPort foreign port * @param foreignPort foreign port
* @exception SocketException thrown if unable to create TCP socket * @exception SocketException thrown if unable to create TCP socket
*/ */
TCPSocket(const std::string &foreignAddress, unsigned short foreignPort, bool keepalive = false) TCPSocket(const std::string &foreignAddress, unsigned short foreignPort, bool keepalive = false)
; ;
bool isOpen();
bool isOpen();
private: private:
// Access for TCPServerSocket::accept() connection creation // Access for TCPServerSocket::accept() connection creation
friend class TCPServerSocket; friend class TCPServerSocket;
TCPSocket(int newConnSD); TCPSocket(int newConnSD);
}; };
/** /**
* TCP socket class for servers * TCP socket class for servers
*/ */
class TCPServerSocket : public Socket { class TCPServerSocket : public Socket
{
public: public:
/** /**
* Construct a TCP socket for use with a server, accepting connections * Construct a TCP socket for use with a server, accepting connections
* on the specified port on any interface * on the specified port on any interface
* @param localPort local port of server socket, a value of zero will * @param localPort local port of server socket, a value of zero will
* give a system-assigned unused port * give a system-assigned unused port
* @param queueLen maximum queue length for outstanding * @param queueLen maximum queue length for outstanding
* connection requests (default 5) * connection requests (default 5)
* @exception SocketException thrown if unable to create TCP server socket * @exception SocketException thrown if unable to create TCP server socket
*/ */
TCPServerSocket(unsigned short localPort, int queueLen = 5, bool keepaliveIN = false); TCPServerSocket(unsigned short localPort, int queueLen = 5, bool keepaliveIN = false);
/** /**
* Construct a TCP socket for use with a server, accepting connections * Construct a TCP socket for use with a server, accepting connections
* on the specified port on the interface specified by the given address * on the specified port on the interface specified by the given address
* @param localAddress local interface (address) of server socket * @param localAddress local interface (address) of server socket
* @param localPort local port of server socket * @param localPort local port of server socket
* @param queueLen maximum queue length for outstanding * @param queueLen maximum queue length for outstanding
* connection requests (default 5) * connection requests (default 5)
* @exception SocketException thrown if unable to create TCP server socket * @exception SocketException thrown if unable to create TCP server socket
*/ */
TCPServerSocket(const std::string &localAddress, unsigned short localPort, TCPServerSocket(const std::string &localAddress, unsigned short localPort,
int queueLen = 5, bool keepaliveIN = false); int queueLen = 5, bool keepaliveIN = false);
/** /**
* Blocks until a new connection is established on this socket or error * Blocks until a new connection is established on this socket or error
* @return new connection socket * @return new connection socket
* @exception SocketException thrown if attempt to accept a new connection fails * @exception SocketException thrown if attempt to accept a new connection fails
*/ */
TCPSocket *accept() ; TCPSocket *accept() ;
private: private:
void setListen(int queueLen) ; void setListen(int queueLen) ;
bool keepalive; bool keepalive;
}; };
/** /**
* UDP socket class * UDP socket class
*/ */
class UDPSocket : public CommunicatingSocket { class UDPSocket : public CommunicatingSocket
{
public: public:
/** /**
* Construct a UDP socket * Construct a UDP socket
* @exception SocketException thrown if unable to create UDP socket * @exception SocketException thrown if unable to create UDP socket
*/ */
UDPSocket() ; UDPSocket() ;
/** /**
* Construct a UDP socket with the given local port * Construct a UDP socket with the given local port
* @param localPort local port * @param localPort local port
* @exception SocketException thrown if unable to create UDP socket * @exception SocketException thrown if unable to create UDP socket
*/ */
UDPSocket(unsigned short localPort) ; UDPSocket(unsigned short localPort) ;
/** /**
* Construct a UDP socket with the given local port and address * Construct a UDP socket with the given local port and address
* @param localAddress local address * @param localAddress local address
* @param localPort local port * @param localPort local port
* @exception SocketException thrown if unable to create UDP socket * @exception SocketException thrown if unable to create UDP socket
*/ */
UDPSocket(const std::string &localAddress, unsigned short localPort) UDPSocket(const std::string &localAddress, unsigned short localPort)
; ;
/** /**
* Unset foreign address and port * Unset foreign address and port
* @return true if disassociation is successful * @return true if disassociation is successful
* @exception SocketException thrown if unable to disconnect UDP socket * @exception SocketException thrown if unable to disconnect UDP socket
*/ */
void disconnect() ; void disconnect() ;
/** /**
* Send the given buffer as a UDP datagram to the * Send the given buffer as a UDP datagram to the
* specified address/port * specified address/port
* @param buffer buffer to be written * @param buffer buffer to be written
* @param bufferLen number of bytes to write * @param bufferLen number of bytes to write
* @param foreignAddress address (IP address or name) to send to * @param foreignAddress address (IP address or name) to send to
* @param foreignPort port number to send to * @param foreignPort port number to send to
* @return true if send is successful * @return true if send is successful
* @exception SocketException thrown if unable to send datagram * @exception SocketException thrown if unable to send datagram
*/ */
void sendTo(const void *buffer, int bufferLen, const std::string &foreignAddress, void sendTo(const void *buffer, int bufferLen, const std::string &foreignAddress,
unsigned short foreignPort) ; unsigned short foreignPort) ;
/** /**
* Read read up to bufferLen bytes data from this socket. The given buffer * Read read up to bufferLen bytes data from this socket. The given buffer
* is where the data will be placed * is where the data will be placed
* @param buffer buffer to receive data * @param buffer buffer to receive data
* @param bufferLen maximum number of bytes to receive * @param bufferLen maximum number of bytes to receive
* @param sourceAddress address of datagram source * @param sourceAddress address of datagram source
* @param sourcePort port of data source * @param sourcePort port of data source
* @return number of bytes received and -1 for error * @return number of bytes received and -1 for error
* @exception SocketException thrown if unable to receive datagram * @exception SocketException thrown if unable to receive datagram
*/ */
int recvFrom(void *buffer, int bufferLen, std::string &sourceAddress, int recvFrom(void *buffer, int bufferLen, std::string &sourceAddress,
unsigned short &sourcePort) ; unsigned short &sourcePort) ;
/** /**
* Set the multicast TTL * Set the multicast TTL
* @param multicastTTL multicast TTL * @param multicastTTL multicast TTL
* @exception SocketException thrown if unable to set TTL * @exception SocketException thrown if unable to set TTL
*/ */
void setMulticastTTL(unsigned char multicastTTL) ; void setMulticastTTL(unsigned char multicastTTL) ;
/** /**
* Join the specified multicast group * Join the specified multicast group
* @param multicastGroup multicast group address to join * @param multicastGroup multicast group address to join
* @exception SocketException thrown if unable to join group * @exception SocketException thrown if unable to join group
*/ */
void joinGroup(const std::string &multicastGroup) ; void joinGroup(const std::string &multicastGroup) ;
/** /**
* Leave the specified multicast group * Leave the specified multicast group
* @param multicastGroup multicast group address to leave * @param multicastGroup multicast group address to leave
* @exception SocketException thrown if unable to leave group * @exception SocketException thrown if unable to leave group
*/ */
void leaveGroup(const std::string &multicastGroup) ; void leaveGroup(const std::string &multicastGroup) ;
private: private:
void setBroadcast(); void setBroadcast();
}; };
#endif #endif

125
clienthandler.h
View File

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

68
main.cpp
View File

@ -20,7 +20,7 @@
sig_atomic_t stop = false; sig_atomic_t stop = false;
void intHandler(int sig) void intHandler(int sig)
{ {
stop = true; stop = true;
} }
@ -60,18 +60,24 @@ static int parseCmdArgs(int argc, char** argv, Config *config)
} }
else if (std::string(argv[i]) == "--serialport" || std::string(argv[i]) == "-p") else if (std::string(argv[i]) == "--serialport" || std::string(argv[i]) == "-p")
{ {
if(argc > i) config->portFileName = argv[i+1]; if(argc > i)
else return -1; config->portFileName = argv[i+1];
else
return -1;
} }
else if (std::string(argv[i]) == "--port" || std::string(argv[i]) == "-P") else if (std::string(argv[i]) == "--port" || std::string(argv[i]) == "-P")
{ {
if(argc > i) config->port = atoi(argv[i+1]); if(argc > i)
else return -1; config->port = atoi(argv[i+1]);
else
return -1;
} }
else if (std::string(argv[i]) == "--baud" || std::string(argv[i]) == "-b") else if (std::string(argv[i]) == "--baud" || std::string(argv[i]) == "-b")
{ {
if(argc > i) config->baud = atoi(argv[i+1]); if(argc > i)
else return -1; config->baud = atoi(argv[i+1]);
else
return -1;
} }
else if (std::string(argv[i]) == "--sinkless" || std::string(argv[i]) == "-s" ) else if (std::string(argv[i]) == "--sinkless" || std::string(argv[i]) == "-s" )
{ {
@ -94,17 +100,18 @@ static int parseCmdArgs(int argc, char** argv, Config *config)
return 0; return 0;
} }
void acceptThreadFunction( TCPServerSocket* servSock, std::vector<ClientHandler>* clients, std::mutex* clientsMutex, int pollQue ) void acceptThreadFunction( TCPServerSocket* servSock, std::vector<ClientHandler>* clients, std::mutex* clientsMutex,
int pollQue )
{ {
while(!stop) while(!stop)
{ {
TCPSocket* newSock = servSock->accept(); TCPSocket* newSock = servSock->accept();
if(newSock != nullptr) if(newSock != nullptr)
{ {
clientsMutex->lock(); clientsMutex->lock();
clients->push_back(ClientHandler(newSock)); // Wait for a client to connect clients->push_back(ClientHandler(newSock)); // Wait for a client to connect
struct epoll_event ev; struct epoll_event ev;
ev.events = EPOLLIN; ev.events = EPOLLIN;
ev.data.fd = newSock->getFD(); ev.data.fd = newSock->getFD();
clientsMutex->unlock(); clientsMutex->unlock();
epoll_ctl(pollQue, EPOLL_CTL_ADD, newSock->getFD(), &ev); epoll_ctl(pollQue, EPOLL_CTL_ADD, newSock->getFD(), &ev);
@ -123,11 +130,12 @@ int openSerialPort(const Config& config)
{ {
std::cout<<"Opeing serial port: "<<config.portFileName<<" at "<<config.baud<<" baud\n"; std::cout<<"Opeing serial port: "<<config.portFileName<<" at "<<config.baud<<" baud\n";
serial = serialport_init(config.portFileName.c_str(), config.baud); serial = serialport_init(config.portFileName.c_str(), config.baud);
if(serial == -1) if(serial == -1)
std::cout<<"Opeing serial port failed\n"; std::cout<<"Opeing serial port failed\n";
tcflush(serial, TCIOFLUSH); tcflush(serial, TCIOFLUSH);
} }
else std::cout<<"Sinkless mode\n"; else
std::cout<<"Sinkless mode\n";
return serial; return serial;
} }
@ -162,12 +170,12 @@ int serialPortReconnect(Config& config, std::string err)
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
Config config; Config config;
if(parseCmdArgs(argc, argv, &config) != 0) if(parseCmdArgs(argc, argv, &config) != 0)
return -1; return -1;
std::cout<<"UVOS serial mulitplexer "<<VERSION<<'\n'; std::cout<<"UVOS serial mulitplexer "<<VERSION<<'\n';
int pollQue = epoll_create1(0); int pollQue = epoll_create1(0);
std::mutex clientsMutex; std::mutex clientsMutex;
@ -180,23 +188,23 @@ int main(int argc, char* argv[])
{ {
return 1; return 1;
} }
else else
{ {
struct epoll_event ev = {}; struct epoll_event ev = {};
ev.events = EPOLLIN; ev.events = EPOLLIN;
ev.data.fd = -1; ev.data.fd = -1;
epoll_ctl(pollQue, EPOLL_CTL_ADD, serial, &ev); epoll_ctl(pollQue, EPOLL_CTL_ADD, serial, &ev);
} }
tcflush(serial, TCIOFLUSH); tcflush(serial, TCIOFLUSH);
} }
else else
{ {
std::cout<<"Sinkless mode\n"; std::cout<<"Sinkless mode\n";
} }
std::thread* acceptThread; std::thread* acceptThread;
TCPServerSocket* servSock; TCPServerSocket* servSock;
std::cout<<"opening TCP socket on port "<<config.port<<'\n'; std::cout<<"opening TCP socket on port "<<config.port<<'\n';
try try
{ {
@ -209,13 +217,13 @@ int main(int argc, char* argv[])
std::cerr<<"Could not open port"<<std::endl; std::cerr<<"Could not open port"<<std::endl;
return 1; return 1;
} }
signal(SIGINT, intHandler); signal(SIGINT, intHandler);
signal(SIGTERM, intHandler); signal(SIGTERM, intHandler);
signal(SIGPIPE, SIG_IGN); signal(SIGPIPE, SIG_IGN);
std::cout<<"starting loop\n"; std::cout<<"starting loop\n";
while(!stop) while(!stop)
{ {
struct epoll_event ev; struct epoll_event ev;
@ -224,7 +232,7 @@ int main(int argc, char* argv[])
if(ev.data.fd != -1) if(ev.data.fd != -1)
{ {
std::vector<ClientHandler>::iterator client = std::vector<ClientHandler>::iterator client =
std::find(clients.begin(), clients.end(), ev.data.fd); std::find(clients.begin(), clients.end(), ev.data.fd);
if(client == clients.end()) if(client == clients.end())
continue; continue;
clientsMutex.lock(); clientsMutex.lock();
@ -251,7 +259,7 @@ int main(int argc, char* argv[])
epoll_ctl(pollQue, EPOLL_CTL_ADD, serial, &ev); epoll_ctl(pollQue, EPOLL_CTL_ADD, serial, &ev);
} }
} }
if((ev.events & (EPOLLHUP | EPOLLERR)) || client->isDisconnected()) if((ev.events & (EPOLLHUP | EPOLLERR)) || client->isDisconnected())
{ {
client->cleanUp(); client->cleanUp();
clients.erase(client); clients.erase(client);
@ -263,7 +271,7 @@ int main(int argc, char* argv[])
{ {
char buffer[4096]; char buffer[4096];
ssize_t readlen = sRead(serial, buffer, 4096); ssize_t readlen = sRead(serial, buffer, 4096);
if(readlen < 0 && (errno != EAGAIN || errno != EWOULDBLOCK)) if(readlen < 0 && (errno != EAGAIN || errno != EWOULDBLOCK))
{ {
close(serial); close(serial);
serial = serialPortReconnect(config, strerror(errno)); serial = serialPortReconnect(config, strerror(errno));
@ -291,7 +299,7 @@ int main(int argc, char* argv[])
std::cout<<"\" to clients from serial\n"; std::cout<<"\" to clients from serial\n";
} }
clientsMutex.lock(); clientsMutex.lock();
for(ClientHandler& client : clients) for(ClientHandler& client : clients)
{ {
client.write(buffer, readlen); client.write(buffer, readlen);
} }
@ -299,7 +307,7 @@ int main(int argc, char* argv[])
} }
} }
} }
acceptThread->join(); acceptThread->join();
delete acceptThread; delete acceptThread;
for(ClientHandler& client : clients) for(ClientHandler& client : clients)

128
serial_io.cpp
View File

@ -2,44 +2,48 @@
ssize_t sWrite(int port, char string[], size_t length) ssize_t sWrite(int port, char string[], size_t length)
{ {
if(port != -1) return write(port, string, length); if(port != -1)
else return 0; return write(port, string, length);
else
return 0;
} }
ssize_t sWrite(int port, const char string[], size_t length) ssize_t sWrite(int port, const char string[], size_t length)
{ {
if(port != -1) return write(port, string, length); if(port != -1)
else return 0; return write(port, string, length);
else
return 0;
} }
ssize_t sRead(int port, void *buf, size_t count) ssize_t sRead(int port, void *buf, size_t count)
{ {
return (port != -1) ? read(port, buf, count) : 0; return (port != -1) ? read(port, buf, count) : 0;
} }
#ifdef __cplusplus #ifdef __cplusplus
void printRates() void printRates()
{ {
std::cout<<"Rates:\n"\ std::cout<<"Rates:\n"\
<<"Unchanged 0\n" \ <<"Unchanged 0\n" \
<<"B50 "<<B50<<'\n'\ <<"B50 "<<B50<<'\n'\
<<"B75 "<<B75<<'\n'\ <<"B75 "<<B75<<'\n'\
<<"B110 "<<B110<<'\n'\ <<"B110 "<<B110<<'\n'\
<<"B134 "<<B134<<'\n'\ <<"B134 "<<B134<<'\n'\
<<"B150 "<<B150<<'\n'\ <<"B150 "<<B150<<'\n'\
<<"B200 "<<B200<<'\n'\ <<"B200 "<<B200<<'\n'\
<<"B300 "<<B300<<'\n'\ <<"B300 "<<B300<<'\n'\
<<"B600 "<<B600<<'\n'\ <<"B600 "<<B600<<'\n'\
<<"B1200 "<<B1200<<'\n'\ <<"B1200 "<<B1200<<'\n'\
<<"B1800 "<<B1800<<'\n'\ <<"B1800 "<<B1800<<'\n'\
<<"B2400 "<<B2400<<'\n'\ <<"B2400 "<<B2400<<'\n'\
<<"B4800 "<<B4800<<'\n'\ <<"B4800 "<<B4800<<'\n'\
<<"B9600 "<<B9600<<'\n'\ <<"B9600 "<<B9600<<'\n'\
<<"B19200 "<<B19200<<'\n'\ <<"B19200 "<<B19200<<'\n'\
<<"B38400 "<<B38400<<'\n'\ <<"B38400 "<<B38400<<'\n'\
<<"B57600 "<<B57600<<'\n'\ <<"B57600 "<<B57600<<'\n'\
<<"B115200 "<<B115200<<'\n'\ <<"B115200 "<<B115200<<'\n'\
<<"B230400 "<<B230400<<'\n'; <<"B230400 "<<B230400<<'\n';
} }
#endif #endif
@ -47,26 +51,26 @@ int serialport_set_config(int fd, int baud)
{ {
struct termios toptions; struct termios toptions;
if (tcgetattr(fd, &toptions) < 0) if (tcgetattr(fd, &toptions) < 0)
{ {
perror("init_serialport: Couldn't get term attributes"); perror("init_serialport: Couldn't get term attributes");
return -1; return -1;
} }
// 8N1 // 8N1
toptions.c_cflag &= ~PARENB; toptions.c_cflag &= ~PARENB;
toptions.c_cflag &= ~CSTOPB; toptions.c_cflag &= ~CSTOPB;
toptions.c_cflag &= ~CSIZE; toptions.c_cflag &= ~CSIZE;
toptions.c_cflag |= CS8; toptions.c_cflag |= CS8;
// no flow control // no flow control
toptions.c_cflag &= ~(CRTSCTS | CLOCAL); toptions.c_cflag &= ~(CRTSCTS | CLOCAL);
//Make Raw
toptions.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
toptions.c_oflag &= ~OPOST; //hmm examine
toptions.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
toptions.c_cflag &= ~(CSIZE | PARENB);
toptions.c_cflag |= CS8;
//Make Raw
toptions.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
toptions.c_oflag &= ~OPOST; //hmm examine
toptions.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
toptions.c_cflag &= ~(CSIZE | PARENB);
toptions.c_cflag |= CS8;
if(baud != 0) if(baud != 0)
{ {
int error = cfsetispeed(&toptions, baud) | cfsetospeed(&toptions, baud); int error = cfsetispeed(&toptions, baud) | cfsetospeed(&toptions, baud);
@ -77,33 +81,33 @@ int serialport_set_config(int fd, int baud)
return -1; return -1;
} }
} }
// see: http://unixwiz.net/techtips/termios-vmin-vtime.html // see: http://unixwiz.net/techtips/termios-vmin-vtime.html
toptions.c_cc[VMIN] = 0; toptions.c_cc[VMIN] = 0;
toptions.c_cc[VTIME] = 40; toptions.c_cc[VTIME] = 40;
fcntl(fd, F_SETFL, FNDELAY); fcntl(fd, F_SETFL, FNDELAY);
if( tcsetattr(fd, TCSANOW, &toptions) < 0) if( tcsetattr(fd, TCSANOW, &toptions) < 0)
{ {
perror("init_serialport: Couldn't set term attributes"); perror("init_serialport: Couldn't set term attributes");
return -1; return -1;
} }
return 0; return 0;
} }
int serialport_init(const char* device, int baud, bool block) int serialport_init(const char* device, int baud, bool block)
{ {
int fd; int fd;
fd = open(device, O_RDWR | O_NOCTTY | (block ? 0 : O_NONBLOCK)); fd = open(device, O_RDWR | O_NOCTTY | (block ? 0 : O_NONBLOCK));
if (fd == -1) if (fd == -1)
{ {
perror("init_serialport: Unable to open port "); perror("init_serialport: Unable to open port ");
return -1; return -1;
} }
if(serialport_set_config(fd, baud) != 0) if(serialport_set_config(fd, baud) != 0)
{ {
close(fd); close(fd);
fd = -1; fd = -1;
} }
return fd; return fd;
} }

13
serial_io.h
View File

@ -29,12 +29,13 @@ int serialport_init(const char* device, int baud = BAUDRATE, bool block = false)
#ifdef __cplusplus #ifdef __cplusplus
class serialIoException: public std::runtime_error class serialIoException: public std::runtime_error
{ {
public: public:
int fd; int fd;
int errorNumber; int errorNumber;
serialIoException(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_) std::runtime_error("file descriptor error, fd: " + std::to_string(fd_) + " error: " + strerror(errorNumber_) + "\n"),
{} fd(fd_), errorNumber(errorNumber_)
{}
}; };
#endif #endif