---

packetbuffer.h

Go to the documentation of this file.

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

        created  :  5/24/1999
        filename :  packet.h
        author   :  Lee Patterson (lee@antws.com)
        
        purpose  :  Packet class for sending data over sockets
                
*********************************************************************/

#ifndef PACKETBUFFER_H
#define PACKETBUFFER_H

#include <time.h>
#include "defs.h"
#include "generalexception.h"
#include "logs.h"


namespace ssobjects
{


class ClientConnector;
class BufferedSocket;
class PacketBuffer;
class Communicable;

//typedefs for static headerSize function can get the correct size

#define typeCookie unsigned16
#define typeBufferSize unsigned32
#define typeCommand unsigned16

//TODO: need a copy construtor
class PacketBufferHeader
{
    friend PacketBuffer;
    friend Communicable;
  public:
    //header block starts here -->
    typeBufferSize  m_nBufferSize;        
    typeCookie      m_wCookie;            
    typeCommand     m_wCommand;           
    // <--
    static unsigned32 m_nMaxPacketSize;   
    bool        m_bNetworkReady;          
  public:
    PacketBufferHeader() : m_nBufferSize(0),m_wCookie(0),m_wCommand(0),m_bNetworkReady(false){};
    PacketBufferHeader(unsigned16 wCommand,unsigned16 wCookie) : m_nBufferSize(0),m_wCookie(wCookie),m_wCommand(wCommand),m_bNetworkReady(false){};
    void        makeNetworkReady(bool bOverrideFailsave=false);         
    void        makeHostReady(bool bOverrideFailsafe=false);            
    unsigned8*  getHeader() const {return (unsigned8*)&m_nBufferSize;}  
    unsigned32  getBufferSize() const {return m_nBufferSize;}           
    unsigned16  getCookie() const {return m_wCookie;}                   
    unsigned16  getCmd() const {return m_wCommand;}                     
    void        reset();                                                
    bool        isValid();                                              
    bool        isNetworkReady() const {return m_bNetworkReady;}        

    static      unsigned32 getMaxPacketSize();                          
    static      unsigned32 setMaxPacketSize(unsigned32);                
    static unsigned32  getSize() 
    {return sizeof(typeBufferSize)+sizeof(typeCookie)+sizeof(typeCommand);} 
};

class PacketBuffer 
{
  public:
    enum    //standard commands
      {
      pcInvalid=0,        
      pcLogin,            
      pcLoginOkay,        
      pcLoginBad,         
      pcLogout,           
      pcGetVersion,       
      pcVersion,          
      pcPing,             
      pcPong,             
      pcStatus,           
      pcNetFileStart,     
      pcNetFileData,      
      pcNetFileEnd,       
      pcClosed,           
      pcNewConnection,    
      pcAuthenticate,     
      pcAuthReply,        

      //debugging packets
      pcNoop=100,         

      pcUser=256,         
      };

    enum 
      {
      pkCookie=0x4C50                 
      }; 
    enum 
      {
      DefaultPacketBufferSize=1000    
      };  

    //TODO: packet header should be protected but isn't as I need the info in the servsocket class, and hadn't thought of making it a friend till now :)
    PacketBufferHeader  m_packetHeader;             
  protected:
    unsigned8*      m_Buffer;                   

    unsigned8*      m_pPointer;                 
    bool            m_bUsed;                    
    unsigned32      m_nID;                      
    unsigned32      m_nBufferSizeMax;           

    //static data
    static  unsigned32    m_nUniqueID;          

    //static methods
  public:
    static unsigned32     getHeaderSize()     {return PacketBufferHeader::getSize();}
    virtual void makeNetworkReady(bool bOverrideFailsave=false);        
    virtual void makeHostReady(bool bOverrideFailsave=false);           
        
    //friend methods
  protected:
    friend ClientConnector;                       
    friend BufferedSocket;                        
    virtual void receive(BufferedSocket*);        
    virtual void transmit(BufferedSocket*);       
    virtual void process() {}               

    //overloadable methods
  public:
    virtual unsigned32  getPacketSize()    const {return (unsigned32)(getHeaderSize() + getBufferSize());}  
    virtual unsigned32  getBufferSizeMax() const {return m_nBufferSizeMax;}                                 
    virtual unsigned32  getBufferSize()    const {return m_packetHeader.getBufferSize();}                   
    virtual unsigned8*  getBuffer()        const;                                                           
    virtual unsigned8*  getPointer()       const;                                                           
    virtual unsigned8*  getHeader()        const {return m_packetHeader.getHeader();}                       
    virtual unsigned8*  resizeBuffer(unsigned32 nNewSize);                                                  

  public:
    PacketBuffer(const PacketBuffer&);                                  
    PacketBuffer& PacketBuffer::operator=(const PacketBuffer& packet);      
    PacketBuffer(unsigned16 wCmd,unsigned32 nSize=DefaultPacketBufferSize); 
    PacketBuffer();                                                         
    virtual ~PacketBuffer();

    //regular methods
    unsigned32  getID()       {return m_nID;}                           
    unsigned16  getCmd() const {return m_packetHeader.getCmd();}        
    unsigned16  cookie() const {return m_packetHeader.getCookie();}     
    void        rewind()      {m_pPointer = m_Buffer;}                  
    void        reset();                                                
    void        append(unsigned8* pdata,unsigned32 nSize);              

  public:
    //overloads
    void operator << (const char*);   
    void operator << (char*);         
    void operator << (CStr&);     
    void operator << (signed32);      
    void operator << (unsigned32);    
    void operator << (signed16);      
    void operator << (unsigned16);    
    void operator << (unsigned8);     
    void operator << (double);        
    void operator << (float);         
    
    void operator >> (char*);         
    void operator >> (CStr&);     
    void operator >> (signed32&);     
    void operator >> (unsigned32&);   
    void operator >> (signed16&);     
    void operator >> (unsigned16&);   
    void operator >> (unsigned8&);    
    void operator >> (double&);       
    void operator >> (float&);        
};

#define throwPacketBufferException(m) (throw PacketBufferException(m,__FILE__,__LINE__))

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

class NetFile : public PacketBuffer
{
  protected:  //attributes
    unsigned32 m_nFileSize;
    CStr       m_strFilename;
    unsigned8* m_pFileData;

  protected:  //methods
    virtual void receive(BufferedSocket* psocket);
    virtual void transmit(BufferedSocket* psocket);

  public:     //construction
    NetFile(const char* pszFilename,unsigned32 nSize,unsigned8* pdata);
    NetFile() : m_nFileSize(0),m_strFilename(),m_pFileData(0){};
    virtual ~NetFile();

  public:     //user callable methods
    CONSTCHAR*       getFilename()   {return m_strFilename;}
    const unsigned32  getSize()      {return m_nFileSize;}
    unsigned8*        getData()      {return m_pFileData;}

  private:
    //unused overloads
    NetFile(const NetFile&);
    NetFile& operator=(const NetFile&);
};

#define throwNetFileException(m) (throw NetFileException(m,__FILE__,__LINE__))

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

//
// all objects that will be sent over internet will be derived from 
// this class. You must override the two pure virtual methods to impliment
// your new object. You don't override process(). Just the pure methods.
//
// All communicable objects can be ACKed or NAKed. 
//
class Communicable : public PacketBuffer
{
  public:
    Communicable() {}
    Communicable(unsigned16 wCmd) : PacketBuffer(wCmd) {}
//        Communicable(PacketBuffer* ppacket) {extract(ppacket);}   //example of how to call extract

  protected:
    //extract data from packet, and fill your class data when receiving
    //you should override extraceData, and call extract when constructing with a packet pointer
    //
    virtual void extract(PacketBuffer* ppacket) {extractHeader(ppacket); extractData(ppacket);}
    virtual void extractData(PacketBuffer*)=0;
    virtual void extractHeader(PacketBuffer* ppacket) 
    {
      //TODO: should use a copy constructor or something to copy entire header
      //TODO  in one shot instead of each member
      m_packetHeader.m_nBufferSize = ppacket->m_packetHeader.m_nBufferSize;
      m_packetHeader.m_wCookie     = ppacket->m_packetHeader.m_wCookie;
      m_packetHeader.m_wCommand    = ppacket->m_packetHeader.m_wCommand;
    }

    //take your class data, and put it into our packet buffer for sending
    virtual void stuff()=0;
    virtual void process() {extract(this);}      //you don't override this
};

  };  //namespace

#endif

---