Socket.h

/*
 * Copyright 2003 Michael A. Marsh, Cornell University. All rights reserved.
 * This software is released under the modified BSD license.
 * See the file LICENSE in the top-level directory for details.
 */
//
// $Id: Socket.h,v 1.4 2005/01/21 19:44:17 mmarsh Exp $
//
// $Log: Socket.h,v $
// Revision 1.4  2005/01/21 19:44:17  mmarsh
// Updated for compatibility with Doxygen 1.4.1
//
// Revision 1.3  2004/05/19 15:56:56  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:31:50  mmarsh
// *** empty log message ***
//
//

#ifndef __CODEX_QUORUM_SOCKET_H__
#define __CODEX_QUORUM_SOCKET_H__

#include <sys/types.h>
#include <sys/socket.h>
#include "QSExceptions.h"
#include <vector>
#include <queue>

namespace CODEX_Quorum
{
   class RemoteServer;
   class Message;

   class SocketBase
   {
      public :
         typedef std::queue< Message* > MsgQueueType;

         enum StateType
         {
            kRead,
            kWrite,
            kError
         };

         SocketBase( int   domain=PF_INET   ,
                     int   type=SOCK_STREAM ,
                     int   protocol=0       ,
                     bool  blocking=false   );
         virtual ~SocketBase();

         virtual void setup(int port, int backlog);

         virtual void setup(struct sockaddr* my_addr,
                            socklen_t addrlen,
                            int backlog);

         virtual void connect(const RemoteServer& server);

          virtual SocketBase* accept();

         virtual size_t readFrom( void* output, size_t maxSize=1024 ) const;

         virtual size_t readAll( Message& msg, size_t length = 0 ) const;

         virtual void writeTo( const Message& input ) const;

         virtual int set_fd( fd_set* fd_bitmap, StateType s ) const;

         virtual bool isset_fd( const fd_set* fd_bitmap, StateType s ) const;

         virtual void flush() const;

      protected :

         SocketBase( const SocketBase& aOther );

         virtual SocketBase* clone();


         virtual SocketBase* protected_accept();

         virtual void finish_accept();
         virtual void protected_bind(int port);
         virtual void protected_bind(struct sockaddr* my_addr,
                                     socklen_t addrlen);
         virtual void protected_listen(int backlog);

         void setSocket( int socketFD );
         void setBacklog( int backlog );
         void setPort( int port );

         int  domain()   const { return m_domain; }
         int  type()     const { return m_type; }
         int  protocol() const { return m_protocol; }
         bool blocking() const { return m_blocking; }
         int  port()     const { return m_port; }
         int  backlog()  const { return m_backlog; }
         int  socket()   const { return m_socket; }

         virtual int internal_write( const unsigned char* output,
                                     size_t maxSize ) const;

         mutable MsgQueueType  m_msgQueue;

         mutable unsigned int  m_msgOffset;

      private :
         int   m_domain;
         int   m_type;
         int   m_protocol;
         bool  m_blocking;
         int   m_port;
         int   m_backlog;

         int   m_socket;
   };



   //------ Exceptions ------//

   class QSESocketBase : public QSExceptionBase
   {
      public :
         QSESocketBase( const string& fname, int line, unsigned long error ) :
            QSExceptionBase( fname, line ),
            m_error( error )
         {}

         virtual ~QSESocketBase() {}

         unsigned long error() const { return m_error; }

      protected :
         void derivedMsg() const;
         virtual void errMsg() const = 0;

         unsigned long m_error;
   };

   class QSESocketBaseBadSocket : public QSESocketBase
   {
      public :
         QSESocketBaseBadSocket( const string& fname,
                                 int line,
                                 int domain,
                                 int type,
                                 int protocol,
                                 unsigned long error ) :
            QSESocketBase( fname, line, error ),
            m_domain( domain ),
            m_type( type ),
            m_protocol( protocol )
         {}
         int domain()   const { return m_domain; }
         int type()     const { return m_type; }
         int protocol() const { return m_protocol; }

      protected :
         void errMsg() const;

      private :
         int  m_domain;
         int  m_type;
         int  m_protocol;
   };

   class QSESocketBaseCannotBind : public QSESocketBase
   {
      public :
         QSESocketBaseCannotBind( const string& fname,
                                  int line,
                                  int socket,
                                  unsigned long error ) :
            QSESocketBase( fname, line, error ),
            m_socket( socket )
         {}
         int socket() const { return m_socket; }

      protected :
         void errMsg() const;

      private :
         int  m_socket;
   };

   class QSESocketBaseListenFailed : public QSESocketBase
   {
      public :
         QSESocketBaseListenFailed( const string& fname,
                                    int line,
                                    int socket,
                                    int backlog,
                                    unsigned long error ) :
            QSESocketBase( fname, line, error ),
            m_socket( socket ),
            m_backlog( backlog )
         {}
         int socket()  const { return m_socket; }
         int backlog() const { return m_backlog; }

      protected :
         void errMsg() const;

      private :
         int  m_socket;
         int  m_backlog;
   };

   class QSESocketBaseAcceptFailed : public QSESocketBase
   {
      public :
         QSESocketBaseAcceptFailed( const string& fname,
                                    int line,
                                    int socket,
                                    unsigned long error ) :
            QSESocketBase( fname, line, error ),
            m_socket( socket )
         {}
         int socket() const { return m_socket; }

      protected :
         void errMsg() const;

      private :
         int  m_socket;
   };

   class QSESocketBaseCannotConnect : public QSESocketBase
   {
      public :
         QSESocketBaseCannotConnect( const string& fname,
                                     int line,
                                     int socket,
                                     const RemoteServer& server,
                                     unsigned long error ) :
            QSESocketBase( fname, line, error ),
            m_socket( socket ),
            m_server( server )
         {}
         int                 socket() const { return m_socket; }
         const RemoteServer& server() const { return m_server; }

      protected :
         void errMsg() const;

      private :
         int            m_socket;
         const RemoteServer&  m_server;
   };

   class QSESocketBaseSocketClosed : public QSESocketBase
   {
      public :
         QSESocketBaseSocketClosed( const string& fname,
                                    int line,
                                    int socket,
                                    unsigned long error ) :
            QSESocketBase( fname, line, error ),
            m_socket( socket )
         {}

         int socket() const { return m_socket; }

      protected :
         void errMsg() const;

      private :
         int  m_socket;
   };

   class QSESocketBaseReadFailed : public QSESocketBase
   {
      public :
         QSESocketBaseReadFailed( const string& fname,
                                  int line,
                                  int socket,
                                  unsigned long error ) :
            QSESocketBase( fname, line, error ),
            m_socket( socket )
         {}
         int socket() const { return m_socket; }

      protected :
         void errMsg() const;

      private :
         int  m_socket;
   };

   class QSESocketBaseWriteFailed : public QSESocketBase
   {
      public :
         QSESocketBaseWriteFailed( const string& fname,
                                   int line,
                                   int socket,
                                   unsigned long error ) :
            QSESocketBase( fname, line, error ),
            m_socket( socket )
         {}
         int socket() const { return m_socket; }

      protected :
         void errMsg() const;

      private :
         int  m_socket;
   };

   class QSESocketBaseMessageTooLong : public QSESocketBase
   {
      public :
         QSESocketBaseMessageTooLong( const string& fname,
                                      int line,
                                      int socket,
                                      unsigned long error ) :
            QSESocketBase( fname, line, error ),
            m_socket( socket )
         {}

         int socket() const { return m_socket; }

      protected :
         void errMsg() const;

      private :
         int  m_socket;
   };

   class QSESocketBaseMessageTooShort : public QSESocketBase
   {
      public :
         QSESocketBaseMessageTooShort( const string& fname,
                                       int line,
                                       int socket,
                                       unsigned long error ) :
            QSESocketBase( fname, line, error ),
            m_socket( socket )
         {}

         int socket() const { return m_socket; }

      protected :
         void errMsg() const;

      private :
         int  m_socket;
   };

}

#endif /* __CODEX_QUORUM_SOCKET_H__ */

---