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);
 
    SocketImpl(int fd, const SocketAddress& remoteaddr);
 
    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
    {
        return *_localaddr;
    }
 
    int getLocalPort() const
    {
        return _localaddr->getPort();
    }
 
    const SocketAddress& getRemoteSocketAddress() const
    {
        return *_remoteaddr;
    }
 
    int getRemotePort() const
    {
        return _remoteaddr->getPort();
    }
 
    void setReuseAddress(bool val) { _reuseaddr = val; }
 
    void setNonBlocking(bool val);
 
    bool isNonBlocking() const;
 
    void setTcpNoDelay(bool val);
 
    bool getTcpNoDelay();
 
    void setTimeout(int val);
 
    int getTimeout() const;
 
    void setKeepAlive(bool val);
 
    bool getKeepAlive() const;
 
    void setKeepAliveIdleSecs(int val);
 
    int getKeepAliveIdleSecs() const;
 
    int getInQueueSize() const;
 
    int getOutQueueSize() const;
 
    void close();
 
    void bind(int port);
 
    void bind(const Inet4Address& addr, int port);
 
    void bind(const SocketAddress& sockaddr);
 
    void listen();
 
    Socket* accept();
 
    void connect(const std::string& dest, int port);
 
    void connect(const Inet4Address& addr, int port);
 
    void connect(const SocketAddress& addr);
 
    void receive(DatagramPacketBase& packet);
 
    void receive(DatagramPacketBase& packet, Inet4PacketInfo& info, int flags=0);
 
    size_t recv(void* buf, size_t len, int flags=0);
 
    size_t recvfrom(void* buf, size_t len, int flags, SocketAddress& from);
 
    void send(const DatagramPacketBase& packet,int flags=0);
 
    size_t send(const void* buf, size_t len, int flags = 0);
 
    size_t send(const struct iovec* iov, int iovcnt, int flags = 0);
 
    size_t sendto(const void* buf, size_t len, int flags,
                  const SocketAddress& to);
 
    size_t sendto(const struct iovec* iov, int iovcnt, int flags,
                  const SocketAddress& to);
 
    void sendall(const void* buf, size_t len, int flags = 0);
 
    void joinGroup(Inet4Address groupAddr);
 
    /*
    void joinGroup(Inet4Address groupAddr,Inet4Address iaddr) throw(IOException);
    */
 
    void joinGroup(Inet4Address groupAddr, const Inet4NetworkInterface&);
 
    void leaveGroup(Inet4Address groupAddr);
 
    void leaveGroup(Inet4Address groupAddr, const Inet4NetworkInterface& iaddr);
 
    void setReceiveBufferSize(int size);
 
    int getReceiveBufferSize();
 
    void setSendBufferSize(int size);
 
    int getSendBufferSize();
 
    void setTimeToLive(int val);
 
    int getTimeToLive() const;
 
    void setPktInfo(bool val);
 
    bool getPktInfo() const
    {
        return _pktInfo;
    }
 
    void setMulticastLoop(bool val);
 
    bool getMulticastLoop() const;
 
    void setInterface(Inet4Address maddr, const Inet4NetworkInterface& iaddr);
 
    void setInterface(Inet4Address iaddr);
 
    Inet4NetworkInterface getInterface() const;
 
    Inet4NetworkInterface getInterface(const std::string& name) const;
 
    Inet4NetworkInterface findInterface(const Inet4Address&) const;
 
    std::list<Inet4NetworkInterface> getInterfaces() const;
 
    void setBroadcastEnable(bool val);
 
    bool getBroadcastEnable() const;
 
protected:
 
    int _sockdomain;
    int _socktype;
    SocketAddress* _localaddr;
    SocketAddress* _remoteaddr;
    int _fd;
    int _backlog;
    bool _reuseaddr;
    bool _hasTimeout;
    struct timespec _timeout;
 
    bool _pktInfo;
 
    void getLocalAddr();
 
    void getRemoteAddr();
};
 
class Socket {
public:
 
    Socket(int domain=AF_INET);
 
    Socket(const Inet4Address& addr,int port);
 
    Socket(const std::string& host, int port);
 
    Socket(const SocketAddress& addr);
 
    Socket(int fd, const SocketAddress& raddr);
 
    ~Socket() throw() {
    }
 
    void close()
    {
        _impl.close();
    }
 
    static std::vector<Socket*> createSocketPair(int type=SOCK_STREAM);
 
    void setTimeout(int val) { _impl.setTimeout(val); }
 
    void setNonBlocking(bool val)
    {
        _impl.setNonBlocking(val);
    }
 
    bool isNonBlocking() const
    {
    return _impl.isNonBlocking();
    }
 
    void setTcpNoDelay(bool val)
    {
    _impl.setTcpNoDelay(val);
    }
 
    bool getTcpNoDelay()
    {
    return _impl.getTcpNoDelay();
    }
 
    void setKeepAlive(bool val)
    {
        _impl.setKeepAlive(val);
    }
 
    bool getKeepAlive()
    {
        return _impl.getKeepAlive();
    }
 
    void setKeepAliveIdleSecs(int val)
    {
        _impl.setKeepAliveIdleSecs(val);
    }
 
    int getKeepAliveIdleSecs()
    {
        return _impl.getKeepAliveIdleSecs();
    }
 
    int getInQueueSize() const
    {
        return _impl.getInQueueSize();
    }
 
    int getOutQueueSize() const
    {
        return _impl.getOutQueueSize();
    }
 
    std::list<Inet4NetworkInterface> getInterfaces() const
    {
        return _impl.getInterfaces();
    }
 
    void connect(const std::string& host,int port)
    {
        _impl.connect(host,port);
    }
 
    void connect(const Inet4Address& addr, int port)
    {
        _impl.connect(addr,port);
    }
 
    void connect(const SocketAddress& addr)
    {
        _impl.connect(addr);
    }
 
    int getFd() const
    {
        return _impl.getFd();
    }
 
    size_t recv(void* buf, size_t len, int flags = 0)
    {
        return _impl.recv(buf,len,flags);
    }
 
    size_t send(const void* buf, size_t len, int flags=MSG_NOSIGNAL)
    {
        return _impl.send(buf,len,flags);
    }
 
    size_t send(const struct iovec* iov, int iovcnt, int flags=MSG_NOSIGNAL)
    {
        return _impl.send(iov,iovcnt,flags);
    }
 
    void sendall(const void* buf, size_t len, int flags=MSG_NOSIGNAL)
    {
        return _impl.sendall(buf,len,flags);
    }
 
    void setReceiveBufferSize(int size)
    {
        _impl.setReceiveBufferSize(size);
    }
 
    int getReceiveBufferSize()
    {
        return _impl.getReceiveBufferSize();
    }
 
    void setSendBufferSize(int size)
    {
        _impl.setSendBufferSize(size);
    }
 
    int getSendBufferSize()
    {
        return _impl.getSendBufferSize();
    }
 
    const SocketAddress& getRemoteSocketAddress() const
    {
        return _impl.getRemoteSocketAddress();
    }
 
    int getRemotePort() const {
        return _impl.getRemotePort();
    }
 
    const SocketAddress& getLocalSocketAddress() const
    {
        return _impl.getLocalSocketAddress();
    }
 
    int getLocalPort() const {
        return _impl.getLocalPort();
    }
 
    int getDomain() const
    {
        return _impl.getDomain();
    }
 
protected:
    SocketImpl _impl;
};
 
class ServerSocket {
public:
 
    ServerSocket(int port=0,int backlog=10);
 
    ServerSocket(const Inet4Address& bindAddr, int port, int backlog=10);
 
    ServerSocket(const SocketAddress& bindAddr, int backlog=10);
 
    ~ServerSocket() {
    }
 
    int getFd() const {
        return _impl.getFd();
    }
 
    void close();
 
    Socket* accept()
    {
        return _impl.accept();
    }
 
    void setReceiveBufferSize(int size)
    {
        _impl.setReceiveBufferSize(size);
    }
 
    int getReceiveBufferSize()
    {
        return _impl.getReceiveBufferSize();
    }
 
    void setSendBufferSize(int size)
    {
        _impl.setSendBufferSize(size);
    }
 
    int getSendBufferSize()
    {
        return _impl.getSendBufferSize();
    }
 
    const SocketAddress& getLocalSocketAddress() const
    {
        return _impl.getLocalSocketAddress();
    }
 
    int getLocalPort() const {
        return _impl.getLocalPort();
    }
 
    int getDomain() const {
        return _impl.getDomain();
    }
 
    void setNonBlocking(bool val)
    {
        _impl.setNonBlocking(val);
    }
 
    bool isNonBlocking() const
    {
        return _impl.isNonBlocking();
    }
 
protected:
    SocketImpl _impl;
 
};
 
class DatagramSocket {
public:
 
    DatagramSocket();
 
    DatagramSocket(int port);
 
    DatagramSocket(const Inet4Address& addr, int port);
 
    DatagramSocket(const SocketAddress& addr);
 
    virtual ~DatagramSocket() throw()
    {
    }
 
    void close()
    {
        _impl.close();
    }
 
    void setTimeout(int val) {
        _impl.setTimeout(val);
    }
 
    void connect(const std::string& host, int port)
    {
        _impl.connect(host,port);
    }
 
    void connect(const Inet4Address& addr, int port)
    {
        _impl.connect(addr,port);
    }
 
    void connect(const SocketAddress& addr)
    {
        _impl.connect(addr);
    }
 
    void bind(const Inet4Address& addr, int port)
    {
        _impl.bind(addr,port);
    }
 
    void bind(const SocketAddress& addr)
    {
        _impl.bind(addr);
    }
 
    int getFd() const {
        return _impl.getFd();
    }
 
    void receive(DatagramPacketBase& packet)
    {
        _impl.receive(packet);
    }
 
    void receive(DatagramPacketBase& packet, Inet4PacketInfo& info, int flags=0)
    {
        _impl.receive(packet,info,flags);
    }
 
    void send(const DatagramPacketBase& packet, int flags=0)
    {
        _impl.send(packet,flags);
    }
 
    size_t recv(void* buf, size_t len, int flags=0)
    {
        return _impl.recv(buf,len,flags);
    }
 
    size_t recvfrom(void* buf, size_t len, int flags,
                    SocketAddress& from)
    {
        return _impl.recvfrom(buf,len,flags,from);
    }
 
    size_t send(const void* buf, size_t len, int flags = 0)
    {
        return _impl.send(buf,len,flags);
    }
 
    size_t send(const struct iovec* iov, int iovcnt, int flags=MSG_NOSIGNAL)
    {
        return _impl.send(iov,iovcnt,flags);
    }
 
    size_t sendto(const void* buf, size_t len, int flags,
                  const SocketAddress& to)
    {
        return _impl.sendto(buf,len,flags,to);
    }
 
    size_t sendto(const struct iovec* iov, int iovcnt, int flags,
                  const SocketAddress& to)
    {
        return _impl.sendto(iov,iovcnt,flags,to);
    }
 
    const SocketAddress& getLocalSocketAddress() const
    {
        return _impl.getLocalSocketAddress();
    }
 
    int getLocalPort() const {
        return _impl.getLocalPort();
    }
 
    void setNonBlocking(bool val)
    {
        _impl.setNonBlocking(val);
    }
 
    bool isNonBlocking() const
    {
        return _impl.isNonBlocking();
    }
 
    void setReceiveBufferSize(int size)
    {
        _impl.setReceiveBufferSize(size);
    }
 
    int getReceiveBufferSize()
    {
        return _impl.getReceiveBufferSize();
    }
 
    void setSendBufferSize(int size)
    {
        _impl.setSendBufferSize(size);
    }
 
    int getSendBufferSize()
    {
        return _impl.getSendBufferSize();
    }
 
    std::list<Inet4NetworkInterface> getInterfaces() const
    {
        return _impl.getInterfaces();
    }
 
    void setBroadcastEnable(bool val)
    {
        _impl.setBroadcastEnable(val);
    }
 
    bool getBroadcastEnable() const
    {
        return _impl.getBroadcastEnable();
    }
 
    void setPktInfo(bool val)
    {
        _impl.setPktInfo(val);
    }
 
protected:
    SocketImpl _impl;
};
 
class MulticastSocket: public DatagramSocket {
public:
 
    MulticastSocket() : DatagramSocket()
    {
    // setInterface(Inet4Address(INADDR_ANY),Inet4Address(INADDR_ANY));
    }
 
    MulticastSocket(int port) : DatagramSocket(port)
    {
    // setInterface(Inet4Address(INADDR_ANY),Inet4Address(INADDR_ANY));
    }
 
    MulticastSocket(const Inet4SocketAddress& addr) : DatagramSocket(addr)
    {
    // setInterface(Inet4Address(INADDR_ANY),Inet4Address(INADDR_ANY));
    }
 
    void joinGroup(Inet4Address groupAddr) {
        _impl.joinGroup(groupAddr);
    }
 
    /*
    void joinGroup(Inet4Address groupAddr,Inet4Address iaddr) throw(IOException) {
        _impl.joinGroup(groupAddr,iaddr);
    }
    */
 
    void joinGroup(Inet4Address groupAddr, const Inet4NetworkInterface &iface) {
        _impl.joinGroup(groupAddr,iface);
    }
 
    void leaveGroup(Inet4Address groupAddr) {
        _impl.leaveGroup(groupAddr);
    }
 
    void leaveGroup(Inet4Address groupAddr, const Inet4NetworkInterface& iface)
    {
        _impl.leaveGroup(groupAddr,iface);
    }
 
    void setTimeToLive(int val)
    {
        _impl.setTimeToLive(val);
    }
 
    int getTimeToLive() const
    {
        return _impl.getTimeToLive();
    }
 
    void setMulticastLoop(bool val)
    {
        _impl.setTimeToLive(val);
    }
 
    bool getMulticastLoop() const
    {
        return _impl.getTimeToLive();
    }
 
    void setInterface(Inet4Address maddr, const Inet4NetworkInterface& iface) {
        _impl.setInterface(maddr,iface);
    }
 
    void setInterface(Inet4Address iaddr) {
        _impl.setInterface(iaddr);
    }
 
    Inet4NetworkInterface getInterface() const {
        return _impl.getInterface();
    }
 
    Inet4NetworkInterface findInterface(const Inet4Address& iaddr) const
    {
        return _impl.findInterface(iaddr);
    }
 
    std::list<Inet4NetworkInterface> getInterfaces() const
    {
        return _impl.getInterfaces();
    }
 
protected:
};
 
}}  // namespace nidas namespace util
 
#endif