libH/Socket.hpp

Go to the documentation of this file.

/*
  
  Copyright (c) 2007, Tim Burrell
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at 

        http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and 
  limitations under the License. 
  
*/

#ifndef __Socket_h
#define __Socket_h

#if HAVE_CONFIG_H
#include "config.h"
#endif

#include "SocketInterface.hpp"
#include "SocketEventWatcher.hpp"
#include "DynamicBuffer.hpp"
#include <cstdlib>
#include <boost/shared_ptr.hpp>
#include <sys/types.h>
#ifndef WIN32
#include <sys/socket.h>
#include <netinet/in.h> // Internet address structures
#else
#include <winsock.h>
#endif
#ifdef HAVE_OPENSSL
#include <openssl/ssl.h>
#endif

// Namespace

namespace H {

// Typedef's / Defines
        
typedef enum {
#ifndef WIN32
        SOCKET_INTERNET                 = PF_INET,
        SOCKET_UNIX                     = PF_UNIX,
        SOCKET_INTERNET2                = PF_INET6
#else
        SOCKET_INTERNET                 = AF_INET,
        SOCKET_UNIX                     = AF_UNIX,
        #ifdef AF_INET  6
        SOCKET_INTERNET2                = AF_INET6
        #endif
#endif
} SocketDomain;

typedef enum {
        SOCKET_STREAM                   = SOCK_STREAM,
        SOCKET_DGRAM                    = SOCK_DGRAM,
        SOCKET_RAW                      = SOCK_RAW,
        SOCKET_SEQPACKET                = SOCK_SEQPACKET,
        SOCKET_RDM                      = SOCK_RDM
} SocketType;

typedef enum {
        SOCKET_PROTO_TCP                = IPPROTO_TCP,
        SOCKET_PROTO_UDP                = IPPROTO_UDP
} SocketProtocol;


#ifndef SOCKET_ERROR
        #define SOCKET_ERROR    -1
#endif
                
// Class Definition

class Socket : public SocketInterface {
public:
        // Public Member Functions
        boost::shared_ptr<Socket>       accept();                       
        void                            bind(int Port);                 
        void                            closeSocket();                  
        void                            connect(std::string Host, int Port); 
        void                            createSocket(SocketDomain Domain = SOCKET_INTERNET, SocketType Type = SOCKET_STREAM); 
        std::string                     getAddress() const;             
        int                             getOldSocket() const;           
        int                             getSocket() const;              
        bool                            isSocketValid() const;          
        void                            listen();                       
        void                            processEvents();                
        int                             readIntoBuffer(DynamicBuffer<char> & Buffer); 
        void                            setEventWatcher(SocketEventWatcher * pWatcher); 
        void                            setMessageMode(bool Enabled);   
        void                            setTo(Socket const & SocketToBecome); 
        void                            shutdown();                     
        int                             write(const char * Buffer, int BufLen); 
        void                            writeMessage(std::string const & Message, bool FormatMessage = true); 
        
        // Construction / Deconstruction
        Socket();                                                       
        Socket(Socket const & InitFrom);                                
        virtual ~Socket();                                              

protected:
        // Private Member Functions
        void                            addToMessageBuffer(char * Data, int BufLen); 
        void                            handleSocketDisconnect();       
        void                            handleSocketRead(DynamicBuffer<char> & ReadBuffer); 
        void                            init();                         
        int                             read(char * Buffer, int BufLen);
        void                            setAddress();                   
        void                            threadProcRead();               

        // Private Member Variables
        std::string                     mAddress;                       
        int                             mBacklog;                       
        SocketDomain                    mDomain;                        
        SocketEventWatcher *            mpEventWatcher;                 
        int                             mOldSocket;                     
        int                             mPort;                          
        bool                            mProcessing;                    
        SocketProtocol                  mProtocol;                      
        DynamicBuffer<char>             mMessageBuffer;                 
        bool                            mMessageMode;                   
        struct sockaddr_in              mSockAddr;                      
        socklen_t                       mSockAddrLen;                   
        int                             mSocket;                        
        SocketType                      mType;                          
        
private:        
        struct SocketReadThreadProc {
                SocketReadThreadProc(Socket * pSocketRead) : mpSocketRead(pSocketRead) {
                        mpSocketRead->mThreading = false;
                };
                
                void operator()() {
                        mpSocketRead->mThreading = true;
                        mpSocketRead->threadProcRead();
                        mpSocketRead->mThreading = false;
                }
                
                Socket *                mpSocketRead;                   
        };              
        bool                            mThreading;                     
        SocketReadThreadProc            mThreadProcRead;                
};


} // H namespace

#endif // __Socket_h

---