---

simpleserver.h

Go to the documentation of this file.

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

       created  :  December <19, 2000
       filename :  simpleserver.h
       author   :  Lee Patterson (lee@antws.com)
       purpose  :  Simple server is a class that you dirive from to
                   create a fully functional server. The simple server
                   class handles creating a listen socket, reading a full
                   packet from a client connection, idling the server.

                   You only need to override processSingleMsg() in order 
                   to process packets that come from a client socket.
                   See the section "user overrideables" below for what 
                   methods you would tipically call.

                   Override idle() method if you want to do things on a 
                   regular basis without waiting for a packet from a client.

                   The two ways of constructing a simple server are for a 
                   single threaded server, and a multi threaded server.

                   NOTE: Any shared data in your dirived classes should be 
                   in the SimpleManager and passed into the simple server. 
                   If you idle in the manager, you should idle the same way
                   in the server. The simple server however should check if 
                   it is running multi threaded, and only idle shared data
                   if it is running single threaded.

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

#ifndef SIMPLESERVER_H
#define SIMPLESERVER_H

#ifdef _WIN32
# include <time.h>
#else
# include <sys/time.h>
# include <unistd.h>
#endif

#include "packetbuffer.h"
#include "flags.h"
#include "linkedlist.h"
#include "bufferedsocket.h"
#include "threadutils.h"
#include "packetmessageque.h"
#include "serversocket.h"
#include "simplemanager.h"

namespace ssobjects
{

#define throwSimpleServerException(m) (throw SimpleServerException(m,__FILE__,__LINE__))

class SimpleServerException : public GeneralException
{
  public: // Constructor/destructor
    SimpleServerException(char* pchMessage,const char* pFname,const int iLine) 
      : GeneralException(pchMessage,pFname,iLine){};
};

class ServerSocket;
class ServerHandler;
class SimpleManager;

class SimpleServer : public ThreadHandler
{
    friend SimpleManager;

  public:
    enum 
      {
      MIN_FREQ=10   
      };

  public:     //construction
    SimpleServer(const SockAddr& saBind,
                 const unsigned32 nFreq=1000,
                 const unsigned32 nMaxConnections=100);   
    SimpleServer(ServerSocket* const psocket,
                 const unsigned32 nFreq);                 
    virtual ~SimpleServer();
        
  protected:  //user overridables
    virtual void    processSingleMsg(PacketMessage* pmsg) = 0;

    virtual void    idle(unsigned32 nTimer=0) {UNUSED_ALWAYS(nTimer);}
      

  public:     //server controls
    virtual void    startServer();                                              
    virtual void    killServer();                                               
    virtual void    pauseIncomingConnections();                                 
    virtual void    sendPacket(ServerSocket* psocket,const PacketBuffer& packet);   
    virtual void    sendPacket(ServerSocket* psocket,const PacketBuffer* ppacket);  
    virtual void    send2All(const PacketBuffer& packet);                           
    virtual void    send2All(const PacketBuffer* ppacket);                          
    virtual void    removeSocket(ServerSocket* psocket);                        

  public:
    static bool     canBind(SockAddr& saBind);                                
    unsigned32      getTicks();                                                 
    bool            isThreaded() { return m_bUsingThread; }                     

    //nothing servicable beyond this point
  protected:
    threadReturn    ThreadHandlerProc(void);                //main handler routine
    void            processMessages();
    bool            processSockets(int iReady);
    void            processSelectError();
    void            acceptConnection();
    int             getMaxFD();                             //return highest connected sock fd
    long            getSleepTime();                         //how many usecs to sleep according to idle frequency
    void            addMsg(PacketMessage* pmsg) { m_que.add(pmsg); }
    void            queClosedMessage(ServerSocket* psocketRemoving);

  private:    //unused overrides
    SimpleServer(const SimpleServer& server);
    SimpleServer& operator=(const SimpleServer& server);
        
  protected:
    SocketInstance          m_sListen;
    SockAddr                m_saServer;
    LinkedList<ServerSocket>    m_listClients;
    PacketMessageQue        m_que;
    unsigned32              m_nIdleFrequency;       //how often idle will be called
    unsigned32              m_nMaxCon;
    bool                    m_bUsingThread;
    bool                    m_bPause;      
    unsigned32              m_nSleepTime;
    struct timeval          m_tvServerStarted;
    fd_set                  m_rset,m_wset;
};

};

#endif //SIMPLESERVER_H

---