Socket.h

Go to the documentation of this file.

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4; -*-
// vim: set shiftwidth=4 softtabstop=4 expandtab:
/*
 ********************************************************************
 ** NIDAS: NCAR In-situ Data Acquistion Software
 **
 ** 2006, Copyright University Corporation for Atmospheric Research
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
 ** the Free Software Foundation; either version 2 of the License, or
 ** (at your option) any later version.
 **
 ** This program is distributed in the hope that it will be useful,
 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ** GNU General Public License for more details.
 **
 ** The LICENSE.txt file accompanying this software contains
 ** a copy of the GNU General Public License. If it is not found,
 ** write to the Free Software Foundation, Inc.,
 ** 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 **
 ********************************************************************
*/
/*

    C++ classes supporting TCP, UDP and Unix sockets.

*/

#ifndef NIDAS_UTIL_SOCKET_H
#define NIDAS_UTIL_SOCKET_H

#include "Inet4SocketAddress.h"
#include "Inet4NetworkInterface.h"
#include "Inet4PacketInfo.h"
#include "UnixSocketAddress.h"
#include "Inet4Address.h"
#include "IOException.h"
#include "EOFException.h"
#include "DatagramPacket.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>

#include <net/if.h>   // IFF_* bits for network interface flags

#include <netinet/in.h>
#include <ctime>
#include <cassert>

#include <vector>

namespace nidas { namespace util {

class Socket;

class SocketImpl {
public:

    SocketImpl(int domain,int type) throw(IOException);

    SocketImpl(int fd, const SocketAddress& remoteaddr) throw(IOException);

    SocketImpl(const SocketImpl& x);

    SocketImpl& operator = (const SocketImpl& rhs);

    ~SocketImpl();

    int getFd() const { return _fd; }

    int getDomain() const { return _sockdomain; }

    void setBacklog(int val) { _backlog = val; }

    const SocketAddress& getLocalSocketAddress() const throw()
    {
        return *_localaddr;
    }

    int getLocalPort() const throw()
    {
        return _localaddr->getPort();
    }

    const SocketAddress& getRemoteSocketAddress() const throw()
    {
        return *_remoteaddr;
    }

    int getRemotePort() const throw()
    {
        return _remoteaddr->getPort();
    }

    void setReuseAddress(bool val) { _reuseaddr = val; }

    void setNonBlocking(bool val) throw(IOException);

    bool isNonBlocking() const throw(IOException);

    void setTcpNoDelay(bool val) throw(IOException);

    bool getTcpNoDelay() throw(IOException);

    void setTimeout(int val);

    int getTimeout() const;

    void setKeepAlive(bool val) throw(IOException);

    bool getKeepAlive() const throw(IOException);

    void setKeepAliveIdleSecs(int val) throw(IOException);

    int getKeepAliveIdleSecs() const throw(IOException);

    int getInQueueSize() const throw(IOException);

    int getOutQueueSize() const throw(IOException);

    void close() throw(IOException);

    void bind(int port)
    throw(IOException);

    void bind(const Inet4Address& addr,int port)
    throw(IOException);

    void bind(const SocketAddress& sockaddr)
    throw(IOException);

    void listen() throw(IOException);

    Socket* accept() throw(IOException);

    void connect(const std::string& dest,int port)
    throw(UnknownHostException,IOException);

    void connect(const Inet4Address& addr,int port)
    throw(IOException);

    void connect(const SocketAddress& addr)
    throw(IOException);

    void receive(DatagramPacketBase& packet) throw(IOException);

    void receive(DatagramPacketBase& packet,Inet4PacketInfo& info,int flags=0) throw(IOException);;
    size_t recv(void* buf, size_t len, int flags=0)
    throw(IOException);

    size_t recvfrom(void* buf, size_t len, int flags,
        SocketAddress& from) throw(IOException);


    void send(const DatagramPacketBase& packet,int flags=0) throw(IOException);

    size_t send(const void* buf, size_t len, int flags = 0)
    throw(IOException);

    size_t send(const struct iovec* iov, int iovcnt, int flags = 0)
    throw(IOException);

    size_t sendto(const void* buf, size_t len, int flags,
        const SocketAddress& to) throw(IOException);

    size_t sendto(const struct iovec* iov, int iovcnt, int flags,const SocketAddress& to)
    throw(IOException);

    void sendall(const void* buf, size_t len, int flags = 0)
    throw(IOException);

    void joinGroup(Inet4Address groupAddr) throw(IOException);

    /*
    void joinGroup(Inet4Address groupAddr,Inet4Address iaddr) throw(IOException);
    */

    void joinGroup(Inet4Address groupAddr,const Inet4NetworkInterface&) throw(IOException);
    void leaveGroup(Inet4Address groupAddr) throw(IOException);

    void leaveGroup(Inet4Address groupAddr,const Inet4NetworkInterface& iaddr)
        throw(IOException);

    void setReceiveBufferSize(int size) throw(IOException);

    int getReceiveBufferSize() throw(IOException);

    void setSendBufferSize(int size) throw(IOException);

    int getSendBufferSize() throw(IOException);

    void setTimeToLive(int val) throw(IOException);

    int getTimeToLive() const throw(IOException);

    void setPktInfo(bool val) throw(IOException);

    bool getPktInfo() const { return _pktInfo; }

    void setMulticastLoop(bool val) throw(IOException);

    bool getMulticastLoop() const throw(IOException);

    void setInterface(Inet4Address maddr,const Inet4NetworkInterface& iaddr) throw(IOException);

    void setInterface(Inet4Address iaddr) throw(IOException);

    Inet4NetworkInterface getInterface() const throw(IOException);

    Inet4NetworkInterface getInterface(const std::string& name) const throw(IOException);

    Inet4NetworkInterface findInterface(const Inet4Address&) const throw(IOException);

    std::list<Inet4NetworkInterface> getInterfaces() const throw(IOException);

    void setBroadcastEnable(bool val) throw(IOException);

    bool getBroadcastEnable() const throw(IOException);

protected:

    int _sockdomain;
    int _socktype;
    SocketAddress* _localaddr;
    SocketAddress* _remoteaddr;
    int _fd;
    int _backlog;
    bool _reuseaddr;
    bool _hasTimeout;
    struct timespec _timeout;

    bool _pktInfo;

    void getLocalAddr() throw(IOException);

    void getRemoteAddr() throw(IOException);

};

class Socket {
public:

    Socket(int domain=AF_INET) throw(IOException);

    Socket(const Inet4Address& addr,int port)
        throw(IOException);

    Socket(const std::string& host,int port)
        throw(UnknownHostException,IOException);

    Socket(const SocketAddress& addr) throw(IOException);

    Socket(int fd, const SocketAddress& raddr) throw(IOException);

    ~Socket() throw() {
    }

    void close() throw(IOException)
    {
        _impl.close();
    }

    static std::vector<Socket*> createSocketPair(int type=SOCK_STREAM)
        throw(IOException);

    void setTimeout(int val) { _impl.setTimeout(val); }

    void setNonBlocking(bool val) throw(IOException)
    {
    _impl.setNonBlocking(val);
    }

    bool isNonBlocking() const throw(IOException)
    {
    return _impl.isNonBlocking();
    }

    void setTcpNoDelay(bool val) throw(IOException)
    {
    _impl.setTcpNoDelay(val);
    }

    bool getTcpNoDelay() throw(IOException)
    {
    return _impl.getTcpNoDelay();
    }

    void setKeepAlive(bool val) throw(IOException)
    {
        _impl.setKeepAlive(val);
    }

    bool getKeepAlive() throw(IOException)
    {
        return _impl.getKeepAlive();
    }

    void setKeepAliveIdleSecs(int val) throw(IOException)
    {
        _impl.setKeepAliveIdleSecs(val);
    }

    int getKeepAliveIdleSecs() throw(IOException)
    {
        return _impl.getKeepAliveIdleSecs();
    }

    int getInQueueSize() const throw(IOException)
    {
        return _impl.getInQueueSize();
    }

    int getOutQueueSize() const throw(IOException)
    {
        return _impl.getOutQueueSize();
    }

    std::list<Inet4NetworkInterface> getInterfaces() const throw(IOException)
    {
        return _impl.getInterfaces();
    }

    void connect(const std::string& host,int port)
    throw(UnknownHostException,IOException)
    {
    _impl.connect(host,port);
    }

    void connect(const Inet4Address& addr, int port)
    throw(IOException)
    {
    _impl.connect(addr,port);
    }

    void connect(const SocketAddress& addr)
    throw(IOException)
    {
    _impl.connect(addr);
    }

    int getFd() const { return _impl.getFd(); }

    size_t recv(void* buf, size_t len, int flags = 0)
    throw(IOException) {
    return _impl.recv(buf,len,flags);
    }

    size_t send(const void* buf, size_t len, int flags=MSG_NOSIGNAL)
    throw(IOException) {
    return _impl.send(buf,len,flags);
    }

    size_t send(const struct iovec* iov, int iovcnt, int flags=MSG_NOSIGNAL)
    throw(IOException) {
    return _impl.send(iov,iovcnt,flags);
    }

    void sendall(const void* buf, size_t len, int flags=MSG_NOSIGNAL)
    throw(IOException) {
    return _impl.sendall(buf,len,flags);
    }

    void setReceiveBufferSize(int size) throw(IOException)
    {
        _impl.setReceiveBufferSize(size);
    }
    int getReceiveBufferSize() throw(IOException)
    {
        return _impl.getReceiveBufferSize();
    }

    void setSendBufferSize(int size) throw(IOException)
    {
        _impl.setSendBufferSize(size);
    }
    int getSendBufferSize() throw(IOException)
    {
        return _impl.getSendBufferSize();
    }

    const SocketAddress& getRemoteSocketAddress() const throw()
    {
    return _impl.getRemoteSocketAddress();
    }
    int getRemotePort() const throw() {
        return _impl.getRemotePort();
    }

    const SocketAddress& getLocalSocketAddress() const throw()
    {
    return _impl.getLocalSocketAddress();
    }

    int getLocalPort() const throw() {
    return _impl.getLocalPort();
    }

    int getDomain() const { return _impl.getDomain(); }

protected:
    SocketImpl _impl;
};

class ServerSocket {
public:

    ServerSocket(int port=0,int backlog=10) throw(IOException);

    ServerSocket(const Inet4Address& bindAddr, int port,int backlog=10)
        throw(IOException);

    ServerSocket(const SocketAddress& bindAddr,int backlog=10)
        throw(IOException);

    ~ServerSocket() throw() {
    }

    int getFd() const { return _impl.getFd(); }

    void close() throw(IOException);

    Socket* accept() throw(IOException)
    {
        return _impl.accept();
    }

    void setReceiveBufferSize(int size) throw(IOException)
    {
        _impl.setReceiveBufferSize(size);
    }
    int getReceiveBufferSize() throw(IOException)
    {
        return _impl.getReceiveBufferSize();
    }

    void setSendBufferSize(int size) throw(IOException)
    {
        _impl.setSendBufferSize(size);
    }
    int getSendBufferSize() throw(IOException)
    {
        return _impl.getSendBufferSize();
    }

    const SocketAddress& getLocalSocketAddress() const throw()
    {
    return _impl.getLocalSocketAddress();
    }

    int getLocalPort() const throw() { return _impl.getLocalPort(); }

    int getDomain() const { return _impl.getDomain(); }

    void setNonBlocking(bool val) throw(IOException)
    {
        _impl.setNonBlocking(val);
    }

    bool isNonBlocking() const throw(IOException)
    {
        return _impl.isNonBlocking();
    }

protected:
    SocketImpl _impl;

};

class DatagramSocket {
public:

    DatagramSocket() throw(IOException);

    DatagramSocket(int port) throw(IOException);

    DatagramSocket(const Inet4Address& addr,int port)
        throw(IOException);

    DatagramSocket(const SocketAddress& addr)
        throw(IOException);

    virtual ~DatagramSocket() throw()
    {
    }

    void close() throw(IOException)
    {
        _impl.close();
    }

    void setTimeout(int val) {
        _impl.setTimeout(val);
    }

    void connect(const std::string& host,int port)
    throw(UnknownHostException,IOException)
    {
    _impl.connect(host,port);
    }

    void connect(const Inet4Address& addr, int port)
    throw(IOException)
    {
    _impl.connect(addr,port);
    }

    void connect(const SocketAddress& addr)
    throw(IOException)
    {
    _impl.connect(addr);
    }

    void bind(const Inet4Address& addr, int port)
    throw(IOException)
    {
    _impl.bind(addr,port);
    }

    void bind(const SocketAddress& addr)
    throw(IOException)
    {
    _impl.bind(addr);
    }

    int getFd() const { return _impl.getFd(); }

    void receive(DatagramPacketBase& packet) throw(IOException)
    {
    _impl.receive(packet);
    }

    void receive(DatagramPacketBase& packet,Inet4PacketInfo& info,int flags=0) throw(IOException)
    {
    _impl.receive(packet,info,flags);
    }

    void send(const DatagramPacketBase& packet,int flags=0) throw(IOException)
    {
    _impl.send(packet,flags);
    }

    size_t recv(void* buf, size_t len, int flags=0) throw(IOException)
    {
    return _impl.recv(buf,len,flags);
    }

    size_t recvfrom(void* buf, size_t len, int flags,
    SocketAddress& from) throw(IOException)
    {
        return _impl.recvfrom(buf,len,flags,from);
    }

    size_t send(const void* buf, size_t len, int flags = 0)
    throw(IOException) {
    return _impl.send(buf,len,flags);
    }

    size_t send(const struct iovec* iov, int iovcnt, int flags=MSG_NOSIGNAL)
    throw(IOException) {
    return _impl.send(iov,iovcnt,flags);
    }

    size_t sendto(const void* buf, size_t len, int flags,
    const SocketAddress& to) throw(IOException)
    {
        return _impl.sendto(buf,len,flags,to);
    }

    size_t sendto(const struct iovec* iov, int iovcnt, int flags,
    const SocketAddress& to) throw(IOException)
    {
        return _impl.sendto(iov,iovcnt,flags,to);
    }

    const SocketAddress& getLocalSocketAddress() const throw()
    {
    return _impl.getLocalSocketAddress();
    }

    int getLocalPort() const throw() {
    return _impl.getLocalPort();
    }

    void setNonBlocking(bool val) throw(IOException)
    {
    _impl.setNonBlocking(val);
    }

    bool isNonBlocking() const throw(IOException)
    {
    return _impl.isNonBlocking();
    }

    void setReceiveBufferSize(int size) throw(IOException)
    {
        _impl.setReceiveBufferSize(size);
    }

    int getReceiveBufferSize() throw(IOException)
    {
        return _impl.getReceiveBufferSize();
    }

    void setSendBufferSize(int size) throw(IOException)
    {
        _impl.setSendBufferSize(size);
    }
    int getSendBufferSize() throw(IOException)
    {
        return _impl.getSendBufferSize();
    }

    std::list<Inet4NetworkInterface> getInterfaces() const throw(IOException)
    {
        return _impl.getInterfaces();
    }

    void setBroadcastEnable(bool val) throw(IOException)
    {
        _impl.setBroadcastEnable(val);
    }

    bool getBroadcastEnable() const throw(IOException)
    {
        return _impl.getBroadcastEnable();
    }

    void setPktInfo(bool val) throw(IOException)
    {
        _impl.setPktInfo(val);
    }

protected:
    SocketImpl _impl;
};

class MulticastSocket: public DatagramSocket {
public:

    MulticastSocket() throw(IOException): DatagramSocket()
    {
    // setInterface(Inet4Address(INADDR_ANY),Inet4Address(INADDR_ANY));
    }

    MulticastSocket(int port) throw(IOException) : DatagramSocket(port)
    {
    // setInterface(Inet4Address(INADDR_ANY),Inet4Address(INADDR_ANY));
    }

    MulticastSocket(const Inet4SocketAddress& addr)
        throw(IOException) : DatagramSocket(addr)
    {
    // setInterface(Inet4Address(INADDR_ANY),Inet4Address(INADDR_ANY));
    }

    void joinGroup(Inet4Address groupAddr) throw(IOException) {
        _impl.joinGroup(groupAddr);
    }

    /*
    void joinGroup(Inet4Address groupAddr,Inet4Address iaddr) throw(IOException) {
        _impl.joinGroup(groupAddr,iaddr);
    }
    */

    void joinGroup(Inet4Address groupAddr,const Inet4NetworkInterface & iface) throw(IOException) {
        _impl.joinGroup(groupAddr,iface);
    }

    void leaveGroup(Inet4Address groupAddr) throw(IOException) {
        _impl.leaveGroup(groupAddr);
    }

    void leaveGroup(Inet4Address groupAddr, const Inet4NetworkInterface& iface)
        throw(IOException)
    {
        _impl.leaveGroup(groupAddr,iface);
    }

    void setTimeToLive(int val) throw(IOException)
    {
        _impl.setTimeToLive(val);
    }

    int getTimeToLive() const throw(IOException)
    {
        return _impl.getTimeToLive();
    }

    void setMulticastLoop(bool val) throw(IOException)
    {
        _impl.setTimeToLive(val);
    }

    bool getMulticastLoop() const throw(IOException)
    {
        return _impl.getTimeToLive();
    }

    void setInterface(Inet4Address maddr,const Inet4NetworkInterface& iface) throw(IOException) {
        _impl.setInterface(maddr,iface);
    }

    void setInterface(Inet4Address iaddr) throw(IOException) {
        _impl.setInterface(iaddr);
    }

    Inet4NetworkInterface getInterface() const throw(IOException) {
        return _impl.getInterface();
    }

    Inet4NetworkInterface findInterface(const Inet4Address& iaddr) const
        throw(IOException)
    {
        return _impl.findInterface(iaddr);
    }

    std::list<Inet4NetworkInterface> getInterfaces() const throw(IOException)
    {
        return _impl.getInterfaces();
    }

protected:
};

}}  // namespace nidas namespace util

#endif