osaSocket.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s):  Peter Kazanzides, Ali Uneri
  Created on: 2009

  (C) Copyright 2007-2013 Johns Hopkins University (JHU), All Rights Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---
*/

#ifndef _osaSocket_h
#define _osaSocket_h

#include <cisstCommon/cmnAssert.h>
#include <cisstCommon/cmnGenericObject.h>
#include <cisstCommon/cmnLogger.h>
#include <cisstCommon/cmnPortability.h>
// Always include last
#include <cisstOSAbstraction/osaExport.h>

#if (CISST_OS != CISST_WINDOWS)
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
#define SOCKET int
#endif

//#define OSA_SOCKET_WITH_STREAM

#ifdef OSA_SOCKET_WITH_STREAM
// forward declaration
class osaSocket;

template <class _element, class _trait = std::char_traits<_element> >
class osaSocketStreambuf: public std::basic_streambuf<_element, _trait>
{
 public:

    typedef std::basic_streambuf<_element, _trait> BaseClassType;

    osaSocketStreambuf(osaSocket * socket):
        Socket(socket)
    {
        CMN_ASSERT(this->Socket);
    }

 protected:
    typedef typename std::basic_streambuf<_element, _trait>::int_type int_type;

    virtual int sync(void);

    virtual std::streamsize xsputn(const _element * s, std::streamsize n);

    virtual std::streamsize xsgetn(_element * s, std::streamsize n);

    virtual int_type overflow(int_type c = _trait::eof());

 private:
    osaSocket * Socket;
};



template <class _element, class _trait>
int osaSocketStreambuf<_element, _trait>::sync(void)
{
    // do nothing, flush on this->socket?
    return 0;
}


template <class _element, class _trait>
std::streamsize
osaSocketStreambuf<_element, _trait>::xsputn(const _element *s, std::streamsize n)
{
    return this->Socket->Send(s, n);
}


template <class _element, class _trait>
std::streamsize
osaSocketStreambuf<_element, _trait>::xsgetn(_element * s, std::streamsize n)
{
    return this->Socket->Receive(s, n);
}


template <class _element, class _trait>
typename osaSocketStreambuf<_element, _trait>::int_type
osaSocketStreambuf<_element, _trait>::overflow(int_type c)
{
    // follow the basic_streambuf standard
    if (_trait::eq_int_type(_trait::eof(), c))
        return (_trait::not_eof(c));
    char cCopy = _trait::to_char_type(c);
    return this->Socket->Send(&cCopy, 1);
}

#endif // OSA_SOCKET_WITH_STREAM

struct CISST_EXPORT osaIPandPort {
    std::string IP;
    unsigned short Port;

    osaIPandPort() : IP(""), Port(0) {}
    osaIPandPort(const std::string &ip, short port) : IP(ip), Port(port) {}
    ~osaIPandPort() {}

    bool operator == (const osaIPandPort &other) const;
    bool operator != (const osaIPandPort &other) const;

    // For STL maps and sets
    bool operator < (const osaIPandPort &other) const;
};

class CISST_EXPORT osaSocket : public cmnGenericObject
#ifdef OSA_SOCKET_WITH_STREAM
, public std::iostream
#endif // OSA_SOCKET_WITH_STREAM
{
    CMN_DECLARE_SERVICES(CMN_NO_DYNAMIC_CREATION, CMN_LOG_ALLOW_DEFAULT);

    enum { INTERNALS_SIZE = 16 };
    char Internals[INTERNALS_SIZE];

    static unsigned int SizeOfInternals(void);

#ifdef OSA_SOCKET_WITH_STREAM
    osaSocketStreambuf<char> Streambuf;
#endif // OSA_SOCKET_WITH_STREAM

 public:
    enum SocketTypes { UDP, TCP };

    osaSocket(SocketTypes type = TCP);

    ~osaSocket(void);

    int GetIdentifier(void) const {
        return SocketFD;
    };

    static std::string GetLocalhostIP(void);

    static int GetLocalhostIP(std::vector<std::string> & IPaddress);

    bool AssignPort(unsigned short port);

    void SetDestination(const std::string & host, unsigned short port);

    void SetDestination(const osaIPandPort & ip_port);

    bool GetDestination(std::string & host, unsigned short &port) const;

    bool GetDestination(osaIPandPort & ip_port) const;

    bool Connect(void);

    bool Connect(const std::string & host, unsigned short port);

    bool Connect(const osaIPandPort & ip_port);

    int Send(const char * bufsend, unsigned int msglen, double timeoutSec = 0.0 );

    int Send(const std::string & bufsend, double timeoutSec = 0.0 );

    int SendAsPackets(const char * bufsend, unsigned int msglen, unsigned int packetSize, double timeoutSec = 0.0);

    int SendAsPackets(const std::string & bufsend, unsigned int packetSize, double timeoutSec = 0.0);

    int Receive(char * bufrecv, unsigned int maxlen, double timeoutSec = 0.0);

    int ReceiveAsPackets(std::string & bufrecv, char *packetBuffer, unsigned int packetSize,
                         double timeoutStartSec = 0.0, double timeoutNextSec = 0.0);

    bool Close(void);

    bool IsConnected(void);

#ifdef OSA_SOCKET_WITH_STREAM

    virtual std::basic_streambuf<char> * rdbuf(void) {
        return &Streambuf;
    }
#endif // OSA_SOCKET_WITH_STREAM

 protected:

    osaSocket(void * socketFDPtr);

    unsigned long GetIP(const std::string & host) const;

    SocketTypes SocketType;
    int SocketFD;
    bool Connected;

    friend class osaSocketServer;
};

CMN_DECLARE_SERVICES_INSTANTIATION(osaSocket);

#endif  // _osaSocket_h