/home/vlg/develop/libASSA/libassa/assa/Socket.h

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                               Socket.h
//------------------------------------------------------------------------------
//  Copyright (C) 1997-2002,2005  Vladislav Grinchenko 
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//------------------------------------------------------------------------------
//
//  This class is a direct derivative from my Unix Network Programming
//  class work on generalizing object-oriented network interfaces.
//
//------------------------------------------------------------------------------
//  Created: 03/22/1999
//------------------------------------------------------------------------------

#ifndef SOCKET_H
#define SOCKET_H

#include <sys/stat.h>
#include <sys/time.h>
#include <limits.h>             // for INT_MAX
#include <stdio.h>              // for EOF
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>              // for fcntl(2)

#ifdef linux
#  include <sys/ioctl.h>        // ioctl(2)
#endif

#ifdef sun                      // ioctl(2)
#  include <unistd.h>
#  include <stropts.h>
#  include <sys/filio.h>
#endif

#include "assa/Address.h"

#define BYTES_LEFT_IN_SOCKBUF(s) ((s).eof () ? -1 : (s).in_avail ())

#define BYTES_LEFT_IN_SIN (cin.eof () ? -1 : cin.rdbuf ()->in_avail ())


namespace ASSA {

class Streambuf;        // Forward declaration

class Socket {
public:
    static const int PGSIZE;

    enum io_state_t { 
        goodbit = 0,  
        eofbit  = 1,  
        failbit = 2,  
        badbit  = 4   
    };

    typedef int iostate;
    typedef unsigned char IOState;

    enum opt_t 
    { 
        reuseaddr,   
        rcvlowat,    
        sndlowat,    
        nonblocking  
    };

    Socket();

    virtual ~Socket();

    virtual bool open(const int domain_) =0;

    virtual bool close() =0;

    virtual bool connect (const Address& address_);

    virtual bool bind (const Address& my_address_) =0;

    virtual int write (const char* buf_, const u_int size_); 

    int getBytesAvail (void) const;

    virtual int read (char* buf_, const u_int size_);

    int ignore (int n_ = INT_MAX, int delim_ = EOF);

    virtual handler_t getHandler() const = 0;

    virtual const int getDomain() const = 0;

    virtual Streambuf* rdbuf () { return 0; }

    virtual Streambuf* rdbuf (Streambuf* /*sb_*/) { return 0; }

    virtual int in_avail () const = 0;

    virtual Socket& flush ();

    bool turnOptionOn (opt_t opt_);

    bool turnOptionOff (opt_t opt_);

    bool setOption (opt_t opt_, int arg_);

    int  getOption (opt_t opt_) const;

    operator void* () const;

    bool operator! () const;

    iostate rdstate () const { return m_state; }

    void clear (iostate state_ = Socket::goodbit);

    void setstate (iostate flag_);

    bool good () const { return m_state == 0; }

    bool eof ()  const { return m_state & Socket::eofbit; }

    bool fail () const 
    { 
        return m_state & (Socket::failbit | Socket::badbit);
    }

    bool bad ()  const { return m_state & Socket::badbit; }

    void dumpState () const;

    static size_t xdr_length (const std::string& s_) 
    { 
        return (4 + s_.length () + s_.length () % 4);
    }

    Socket& operator>> (char& c);

    Socket& operator>> (unsigned char& c_) 
    { 
        return operator>>((char&) c_); 
    }

    Socket& operator>> (signed char& c_) 
    { 
        return operator>>((char&) c_); 
    }

    Socket& operator>> (std::string& s_);

    Socket& operator>> (short& n_);

    Socket& operator>> (unsigned short& n_);

    Socket& operator>> (int& n_);

    Socket& operator>> (unsigned int& n_);

    Socket& operator>> (long& n_);

    Socket& operator>> (unsigned long& n_);

    Socket& operator>> (float& n_);

    Socket& operator>> (double& n_);

    Socket& operator<< (char c);

    Socket& operator<< (unsigned char c_) 
    { 
        return (*this) << (char) c_; 
    }

    Socket& operator<< (signed char c_) 
    { 
        return (*this) << (char) c_; 
    }

    Socket& operator<< (const std::string& s_);

    Socket& operator<< (short n_);

    Socket& operator<< (unsigned short n_);

    Socket& operator<< (int n_);

    Socket& operator<< (unsigned int n_);

    Socket& operator<< (long n_);

    Socket& operator<< (unsigned long n_);

    Socket& operator<< (float n_);

    Socket& operator<< (double n_);

    Socket& operator<< (Socket& (*f) (Socket&))
    {
        return (f (*this));
    }

    static bool is_little_endian ();

    static void close_handler (handler_t& socket_)
    {
#if defined (WIN32)
        closesocket (socket_);
#else
		::close (socket_);
#endif
        disable_handler (socket_);
    }

    static string decode_fcntl_flags (long mask_);

/*------------------------------------------------------------------
 * Protected Members
 *------------------------------------------------------------------
 */
protected:
    int set_option (int level_, int optname_, int val_);

    int set_fd_options (long flags_);

    int clear_fd_options (long flags_);

protected:
    handler_t m_fd;             // u_int, INVALID_SOCKET=(SOCKET)(~0)

    int m_type;

#if defined (WIN32)
    bool m_nonblocking;     // We cannot retrieve the status of the 
                            // socket. So, we remember what it was instead.
#endif

    IOState m_state;

//------------------------------------------------------------------------------
// Inline functions
//------------------------------------------------------------------------------

private:
    Socket (const Socket&);
    Socket& operator= (const Socket&);
};

//------------------------------------------------------------------------------
// Inline functions
//------------------------------------------------------------------------------

inline
Socket::Socket() 
    : 
    m_fd (BAD_HANDLER),
    m_type(0),
#if defined (WIN32)
    m_nonblocking (false),
#endif
    m_state(Socket::badbit)
{
    trace_with_mask("Socket::Socket",SOCKTRACE);
}

inline
Socket::~Socket ()
{ 
    trace_with_mask("Socket::~Socket",SOCKTRACE); 
}

inline bool
Socket::connect (const Address& /* address_ */) 
{
    trace_with_mask("Socket::connect",SOCKTRACE);
    return false; 
}

inline int 
Socket::write(const char* /*buf_*/, const u_int /*size_*/) 
{ 
    trace_with_mask("Socket::write",SOCKTRACE); 
    return -1; 
}

inline int 
Socket::read(char* /*buf_*/, const u_int /*size_*/)  
{ 
    trace_with_mask("Socket::read()",SOCKTRACE);
    return -1; 
}

inline
Socket::operator void*() const 
{
    return fail() ? (void *)0 : (void *)(-1); 
}

inline bool
Socket::operator!() const 
{ 
    return fail(); 
}


inline void 
Socket::clear(iostate state_)
{ 
    m_state = is_valid_handler (m_fd) ? state_ : state_ | Socket::badbit; 
}

inline void 
Socket::setstate(iostate flag_) 
{ 
    m_state |= flag_; 
}

inline
Socket& flush (Socket& os_)
{
    os_.flush ();
    return (os_);
}

inline 
Socket& endl (Socket& os_)
{
    char c = '\n';
    os_.write (&c, 1);
    os_.flush ();
    return (os_);
}

inline
Socket& ends (Socket& os_)
{
    char c = '\0';
    os_.write (&c, 1);
    return (os_);
}

} // end namespace ASSA

#include "assa/Streambuf.h"

#endif // SOCKET_H

---