---

socketinstance.h

Go to the documentation of this file.

/********************************************************************
        Copyright (c) 2001, Lee Patterson & Ant Works Software
        http://ssobjects.sourceforge.net

        Original source from Inside Visual C++

        created  :  5/14/1998
        filename :  socketinstance.h
        author   :  Lee Patterson (lee@antws.com)
        
        purpose  :  Base socket class. Also http and telnet 
                    classes. Defaults to blocking mode.

        notes    :  Typical client session would look like this:
                    
                    ...
                    SocketInstance sConnection;
                    try
                    {
                        //open connection
                        puts("Connecting to server...");
                        SockAddr saServer(szHost,iPort);
                        if(isalpha(szHost[0]))  //check if szHost is in "host.com" format or "255.255.255.255"
                            saServer = SocketInstance::getHostByName(szHost,iPort);
                        sConnection.create();
                        sConnection.connect(saServer);
                        //we are connected, so some transfering
                        ...
                        sConnection.close();
                    }
                    catch(GeneralException* e)
                    {
                        sConnection.cleanup();
                        LOG("error %s",e->getErrorMsg());
                    }
                    ...
                    
                    A server would look like this:
                    
                    ...
                    SocketInstance sClient;
                    SockAddr saClient;
                    SockAddr saServer(INADDR_ANY,atoi(argv[1]));
                    SocketInstance sListen;
                    try
                    {
                        sListen.create();
                        sListen.bind(saServer);
                        sListen.listen();
                        while(bWantMoreConnections)
                        {
                            sListen.accept(sClient,saClient);
                            //we got a connection ...
                            sClient.close();
                        }
                        sListen.close();
                    }
                    catch(GeneralException* e)
                    {
                        sConnection.cleanup();
                        LOG("error %s",e->getErrorMsg());
                    }
                    ...
                    
                    

*********************************************************************/

#ifndef SOCKETINSTANCE_H
#define SOCKETINSTANCE_H

#ifdef OS_LINUX
#define USE_POLL
#endif

#define __SockAddr__
#define __SocketInstance__
#define __SocketInstanceException__
#define __TelnetSocket__
#define __HttpBlockingSocket__

#ifdef WIN32
#include <winsock.h>
#endif

#include <sys/types.h>
#include <ctype.h>
#include "msdefs.h"
#include <stdio.h>

#ifndef WIN32
# include <netinet/in.h>
# include <netdb.h>
# ifndef USE_POLL
#   include <sys/select.h>    //not using select, using poll instead as select gave me some headaches
# else
#   include <sys/poll.h>
# endif
# include <arpa/inet.h>
# include <sys/time.h>
# include <sys/types.h>
# include <sys/socket.h>
# include <unistd.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include "generalexception.h"
#include "errno.h"

enum {
    DEFAULT_SOCKET_TIMEOUT=600,     //10 minutes
    NO_TIMEOUT=0,                   //never time out    
};

#define TELNET_PORT         23
#define WEB_PORT            80

#ifndef WIN32
# define WSAEWOULDBLOCK       EWOULDBLOCK
# define SOCKET_ERROR        (-1)
# define INVALID_SOCKET      (-1)
# define closesocket(s)      close(s)
# define WSAGetLastError()   errno

typedef int SOCKET;
typedef struct sockaddr        SOCKADDR;

typedef struct sockaddr_in     SOCKADDR_IN;
typedef struct sockaddr_in*    LPSOCKADDR_IN;
#endif

#ifdef WIN32
  typedef int socklen_t;
#endif

typedef struct timeval  TIMEVAL;
typedef unsigned long   ULONG;
typedef unsigned short  USHORT;

typedef const struct sockaddr* LPCSOCKADDR;
typedef struct sockaddr*       LPSOCKADDR;

namespace ssobjects
{



// member functions truly block and must not be used in UI threads
// use this class as an alternative to the MFC CSocket class

#ifdef __SocketInstanceException__
#define throwSocketInstanceException(m) (throw SocketInstanceException(m,__FILE__,__LINE__))

class SocketInstanceException : public GeneralException
{
public:
    SocketInstanceException(const char* pchMessage,const char* pFname,const int iLine) : GeneralException(pchMessage,pFname,iLine){}
    ~SocketInstanceException(){}
};
#endif

#ifdef __SocketInstance__
class SockAddr;

class SocketInstance 
{
  public:
    SOCKET m_hSocket;
    bool   m_bThrowExceptionOnReadClose;
    SocketInstance() : m_hSocket(0),m_bThrowExceptionOnReadClose(true) {}
    SOCKET getSocket() const {return m_hSocket;}
    void setExceptionOnReadClose(const bool bThrowException=true);  
    void cleanup();
    void create(const int nType = SOCK_STREAM);
    void close();
    void bind(LPCSOCKADDR psa);
    void listen();
    void connect(LPCSOCKADDR psa);
    bool accept(SocketInstance& s, LPSOCKADDR psa);
    bool accept(SocketInstance* s, LPSOCKADDR psa);
    int send(const char* pch, const int nSize, const int nSecs=DEFAULT_SOCKET_TIMEOUT);
    int write(const char* pch, const int nSize, const int nSecs=DEFAULT_SOCKET_TIMEOUT);
    int recv(char* pch, const int nSize, const int nSecs=DEFAULT_SOCKET_TIMEOUT);
    int sendDatagram(const char* pch, const int nSize, LPCSOCKADDR psa, 
                     const int nSecs=10);
    int receiveDatagram(char* pch, const int nSize, LPSOCKADDR psa, 
                        const int nSecs=10);
    void getPeerAddr(LPSOCKADDR psa);
    void getSockAddr(LPSOCKADDR psa);
    static SockAddr getHostByName(const char* pchName, 
                                    const USHORT ushPort = 0);
    static const char* getHostByAddr(LPCSOCKADDR psa);
    operator SOCKET()
    { return m_hSocket; }
    
    SocketInstance& operator=(const SocketInstance& s);
    SocketInstance(const SocketInstance& s) : m_hSocket(s.m_hSocket),m_bThrowExceptionOnReadClose(s.m_bThrowExceptionOnReadClose) {}
};
#endif

#ifdef __SockAddr__

class SockAddr : public sockaddr_in 
{
  public:
    // constructors
    SockAddr()
    { sin_family = AF_INET;
    sin_port = 0;
    sin_addr.s_addr = 0; } // Default
    SockAddr(const sockaddr& sa) { memcpy(this, &sa, sizeof(SOCKADDR)); }
    SockAddr(const sockaddr_in& sin) { memcpy(this, &sin, sizeof(SOCKADDR_IN)); }
    SockAddr(const ULONG ulAddr, const USHORT ushPort = 0) // parms are host byte ordered
    { sin_family = AF_INET;
    sin_port = htons(ushPort);
    sin_addr.s_addr = htonl(ulAddr); }
#ifdef OS_LINUX
    SockAddr(const uint32_t ulAddr, const USHORT ushPort = 0) // parms are host byte ordered
    { sin_family = AF_INET;
    sin_port = htons(ushPort);
    sin_addr.s_addr = htonl(ulAddr); }
#endif
    SockAddr(const char* pchIP, const USHORT ushPort = 0) // dotted IP addr string
    { 
      if(isalpha(pchIP[0])) //check if IP is in "host.com" format or "255.255.255.255"
      {
        struct hostent* pHostEnt = gethostbyname(pchIP);
        if(pHostEnt == NULL) {
          CStr s;
          int err = WSAGetLastError();
          strerror(err);
          s.format("SockAddr GetHostByName error %d:%s",err,strerror(err));
      
          throwSocketInstanceException((const char*)s);
        }
        ULONG* pulAddr = (ULONG*) pHostEnt->h_addr_list[0];
        sin_family = AF_INET;
        sin_port = htons(ushPort);
        sin_addr.s_addr = *pulAddr; // address is already in network byte order
                
      }
      else
      {
        sin_family = AF_INET;
        sin_port = htons(ushPort);
        sin_addr.s_addr = inet_addr(pchIP); 
      }
    } // already network byte ordered
    // Return the address in dotted-decimal format
    char* dottedDecimal()
    { return inet_ntoa(sin_addr); }
    // Get port and address (even though they're public)
    USHORT port() const
    { return ntohs(sin_port); }
    ULONG ipAddr() const
    { return ntohl(sin_addr.s_addr); }
    // operators added for efficiency
    const SockAddr& operator=(const SOCKADDR& sa)
    { memcpy(this, &sa, sizeof(SOCKADDR));
    return *this; }
    const SockAddr& operator=(const SOCKADDR_IN& sin)
    { memcpy(this, &sin, sizeof(SOCKADDR_IN));
    return *this; }
    operator SOCKADDR()
    { return *((LPSOCKADDR) this); }
    operator LPSOCKADDR()
    { return (LPSOCKADDR) this; }
    operator LPSOCKADDR_IN()
    { return (LPSOCKADDR_IN) this; }
    bool operator == (const sockaddr_in& sa);     
};
#endif


#ifdef __TelnetSocket__
class TelnetSocket : public SocketInstance
{
  public:
    enum {nSizeRecv = 1024}; // max receive buffer size (> hdr line length)
    enum {FLAG_VALIDATED=1,FLAG_PLAYING=2};
    TelnetSocket();
    TelnetSocket(SocketInstance& s);
    TelnetSocket(SocketInstance* s);
    virtual ~TelnetSocket();
    int readLine(char* pch, const int nSize, const int nSecs=DEFAULT_SOCKET_TIMEOUT);
    int readResponse(char* pch, const int nSize, const int nSecs=DEFAULT_SOCKET_TIMEOUT);
    int println(const char* fmt,...);
    int print(const char* fmt,...);
    bool setLoginName(const char* name);

  public:
    //login information
    char* m_pLoginName;
    WORD m_wFlags;

  private:
    char* m_pReadBuf; // read buffer
    int m_nReadBuf; // number of bytes in the read buffer

  private:
    TelnetSocket(const TelnetSocket&);
    TelnetSocket& operator=(const TelnetSocket&);
};
#endif

#ifdef __HttpBlockingSocket__
class HttpBlockingSocket : public SocketInstance
{
  public:
    enum {nSizeRecv = 1000}; // max receive buffer size (> hdr line length)
    HttpBlockingSocket();
    ~HttpBlockingSocket();
    int readHttpHeaderLine(char* pch, const int nSize, const int nSecs);
    int readHttpResponse(char* pch, const int nSize, const int nSecs);
  private:
    char* m_pReadBuf; // read buffer
    int m_nReadBuf; // number of bytes in the read buffer
  private:
    //unused overloads
    HttpBlockingSocket(const HttpBlockingSocket&);
    HttpBlockingSocket& operator=(const HttpBlockingSocket&);
};
#endif

};

#endif

---