mi32/socket.h

Go to the documentation of this file.

#ifndef INC_MI32_SOCKET_H
#define INC_MI32_SOCKET_H

#ifndef INC_MI32_GENERICRW_H
#include <mi32/genericrw.h>
#endif

#ifndef INC_MI32_MILIST_H
#include <mi32/milist.h>
#endif

#if defined(DEBUG) && !defined(INC_STDIO_H)
#include <stdio.h>   // For FILE typedef needed in debug mode
#define  INC_STDIO_H
#endif

// The rest of the world uses these but for Windows, they're defined in winsock.h
// and we don't want to force the programmer to include that mess.
//    struct sockaddr;
//    struct sockaddr_in;
//    struct in_addr;



#ifdef MISYSTEMDLL
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class STRUTF8;
class MISTRING;
#endif

class CLASSLIBEXPORT MISOCKET : public GENERICRW {
   public:

      enum FAMILY {
         FAMILY_NONE = 0,     
         FAMILY_LOCAL = 1,    
         FAMILY_INET = 2      
         };

      enum TYPE {
         TYPE_NONE = 0,       
         TYPE_STREAM = 1,     
         TYPE_DGRAM = 2       
         };

      class IPADDRLIST;

      struct CLASSLIBEXPORT IPADDR {
         union {  
            struct { UINT8 s_b1, s_b2, s_b3, s_b4; } S_un_b;
            UINT32 S_addr; 
            } S_un;

         IPADDR (
            ); 

         IPADDR (
            UINT32 addr
            );

         int Compare (
            const MISOCKET::IPADDR& rhs
            ) const;

         static void GetAddressList (
            IPADDRLIST& AddrList,         
            bool OnlyRoutable = false     
            );

         void GetString (
            MISTRING& mistr,
            bool bDoReverseDNSLookup
            ) const;
            
         bool IsLoopbackAddr (
            ) const;
         
         bool IsRoutable (
            ) const;
         
         bool SetByName (
            const char* name
            );

         };    // MISOCKET::IPADDR


      struct CLASSLIBEXPORT ADDR {

         unsigned short sa_family;  // For compatibility with struct sockaddr
         char __ss_pad1[6];
         INT64 __ss_align;          // Assures correct alignment
         char __ss_pad2[112];

         ADDR (
            );
         
         ADDR (
            const MISOCKET::IPADDR& ip,
            int port
            );

         void GetAddress (
            MISTRING& mistr,
            bool bDoReverseDNSLookup
            ) const;

         MISOCKET::FAMILY GetFamily (
            ) const;
         
         const MISOCKET::IPADDR& GetIPAddress (
            ) const;

         const char* GetLocalName (
            ) const;

         int GetPort (
            ) const;

         void Set (
            const MISOCKET::IPADDR& ip,
            int port
            );

         void SetFamily (
            MISOCKET::FAMILY family
            );

         void SetLocalName (
            const char* name
            );

         protected:
            const char* GetBytePtr (int offset) const;
            char* GetBytePtr (int offset);
            UINT16 GetUINT16(int offset) const;
            UINT32 GetUINT32(int offset) const;
            void SetUINT16(int offset, UINT16 val);
            void SetUINT32(int offset, UINT32 val);

         }; // MISOCKET::ADDR




      class CLASSLIBEXPORT CLIENT {
         public:
            CLIENT();

            CLIENT (
               MISOCKET* sock, 
               bool bTakeOwnership = true
               );

            virtual ~CLIENT();

            bool CallOnAccept (
               MISOCKET* socket,
               const MISOCKET::ADDR& addr
               );

            void CallOnClose (
               );

            void CallOnConnect (
               );

            void CallOnReadReady (
               );

            void CallOnTimeOut (
               );
            
            void CallOnWriteReady (
               );

            ERRVALUE Connect (
               const MISOCKET::ADDR& address
               );

            MISOCKET* GetSocket (
               ) const;


            bool IsConnected (
               ) const;

            void SetSocket (
               MISOCKET* sock,
               bool bTakeOwnership = true
               );
            
         protected:

            // A resource locking class which will prevent Destroy() from actually
            // deleting the client.
            class LOCK {
               public:
                  LOCK (
                     CLIENT* client
                     ) :
                     m_client(client) 
                     {
                     if (m_client != 0) m_client->Lock();
                     }
                  ~LOCK (
                     ) {
                     if (m_client != 0) m_client->Unlock();
                     }
               private:
                  CLIENT* m_client;
               };

            void Destroy (
               );

         private:

            virtual bool v_OnAccept (
               MISOCKET* socket,
               const MISOCKET::ADDR& addr
               );

            virtual void v_OnClose (
               );

            virtual void v_OnConnect (
               );

            virtual void v_OnReadReady (
               );

            virtual void v_OnTimeOut (
               );
            
            virtual void v_OnWriteReady (
               );
#ifndef GENERATING_DOXYGEN_OUTPUT
         private:
            CLIENT(const CLIENT&);  // private and unimplemented
            CLIENT& operator=(const CLIENT&);
            friend class LOCK;      // Only MISOCKET::CLIENT::LOCK can call Lock/Unlock

            MISOCKET* m_sock;
            bool m_bWeOwnSocket;
            bool m_bNeedToDestroy;
            int m_LockCount;

            void Lock();

            void Unlock();
#endif   // GENERATING_DOXYGEN_OUTPUT
         };


      MISOCKET (
         );

      virtual ~MISOCKET (
         );


      MISOCKET* Accept (
         ADDR& address        
         );

      ERRVALUE Bind (
         const ADDR& address
         );

      ERRVALUE Connect (
         const ADDR& address
         );

      const ADDR& GetAddress (
         ) const;

      void GetAddress (
         MISTRING& mistr,
         bool bDoReverseDNSLookup = false
         ) const;
      
      bool GetSockName (
         ADDR& addr
         ) const;

      int GetTimeOut (
         ) const;
         
      bool IsNonBlocking (
         ) const;

      ERRVALUE Listen (
         );

      ERRVALUE ReadStr (
         STRUTF8& string
         );

      void SetTimeOut (
         int seconds    // XXX Make this double seconds or integer ms
         );

      void SetNonBlocking (
         bool bNonBlocking = true
         );
      
      ERRVALUE Socket (
         FAMILY family,       
         TYPE type = TYPE_STREAM    
         );

      ERRVALUE WriteStr (
         const char* str
         );

#ifndef GENERATING_DOXYGEN_OUTPUT
      // These are public so that implementations can derive from them
      // but they're not exported from misystem
      class FACTORY;
      class IMPL;

#ifdef DEBUG
      // These three are only in the debug build
      void DumpDebugState (
         );
      void SetDebugFile (
         FILE*
         );
      void SetCloseDebug (
         );
#endif
#endif

   private:
#ifndef GENERATING_DOXYGEN_OUTPUT
      IMPL* m_impl;

      // Copy constructor and assignment operators are private - do not use
      MISOCKET(const MISOCKET&);
      MISOCKET& operator=(const MISOCKET&);
      // For internal use.
      MISOCKET(IMPL*);

      friend class CLIENT; // I only want CLIENT to be able to call SetClient()
      friend class IMPL;   // I only want CLIENT to be able to call SetClient()

      void SetClient (
         CLIENT* client
         );
      
      
      // Methods overridden from the base class (GENERICRW)
      
      GENERICRW::CAPABILITIES v_GetCapabilities (
         ) const;

      // For this implementation, return the ammount of data available to read
      // right now.
      INT64 v_GetSize (
         ) const;

      INT64 v_GetSizeLimit (
         ) const;

      // Note: Read will block if AllowPartial is false and the requested
      // ammount of data is not available, unless the socket is marked
      // NonBlocking.  If it's marked non-blocking and there is not enough
      // data available, Read will return 0.
      INT32 v_Read (
         void* buffer,
         INT32 numbytes,
         bool AllowPartial = false
         );

      ERRVALUE v_Resize (
         INT64 newsize
         );

      INT64 v_Seek (
         INT64 offet,
         SEEKFROM from
         );

      INT64 v_Tell (
         ) const;

      ERRVALUE v_Write (
         const void* buffer,
         INT32 numbytes
         );


#endif   // GENERATING_DOXYGEN_OUTPUT
   };

inline bool operator== (
   const MISOCKET::IPADDR& lhs,
   const MISOCKET::IPADDR& rhs
   ) { return (lhs.Compare(rhs) == 0); }

inline bool operator!= (
   const MISOCKET::IPADDR& lhs,
   const MISOCKET::IPADDR& rhs
   ) { return (lhs.Compare(rhs) != 0); }

inline bool operator< (
   const MISOCKET::IPADDR& lhs,
   const MISOCKET::IPADDR& rhs
   ) { return (lhs.Compare(rhs) == -1); }

class CLASSLIBEXPORT MISOCKET::IPADDRLIST : public MILIST<MISOCKET::IPADDR> {};

#undef CLASSLIBEXPORT

#endif // INC_MI32_SOCKET_H
// vim: ts=3 sw=3

---