Cx.hh

/*
** Stechec project is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** The complete GNU General Public Licence Notice can be found as the
** `NOTICE' file in the root directory.
**
** Copyright (C) 2007 Prologin
*/

#ifndef CX_HH_
# define CX_HH_

# include "datatfs/Packet.hh"
# include "misc/Exception.hh"

const unsigned CX_TOKEN_START = 0x8000;

enum eCxToken {
  CX_INIT = CX_TOKEN_START,
  CX_ACCEPT,
  CX_DENY,
  CX_QUERYLIST,
  CX_LIST,
  CX_JOIN,
  CX_READY,
  CX_ABORT,
  CX_ERROR,
  CX_TOKEN_LAST,
};

class NetError : public Exception
{
public:  
  NetError(const std::string& msg);
};

class NetSysError : public NetError
{
public:  
  NetSysError(const std::string& msg);
};


const unsigned PACKET_SIZE_MAX  = 2048;
const unsigned BUF_SEND_SIZE    = PACKET_SIZE_MAX * 4;
const unsigned BUF_RECV_SIZE    = PACKET_SIZE_MAX * 2;

const int CX_CLOSED     = 0x00;
const int CX_READ       = 0x01;
const int CX_WRITE      = 0x02;
const int CX_RW         = 0x03;
const int CX_CONNECTING = 0x04;
const int CX_LISTENING  = 0x08;


class Cx
{
  template<typename> friend class CxPool;

public:
  Cx();
  virtual ~Cx();

  bool poll(int timeout = 0);

  void begin();
  void commit();
  void send(const Packet& pkt);

  Packet* receive();

  friend std::ostream& operator<< (std::ostream& os, const Cx& cx);
  
protected:
  virtual bool pollInternal(int* timeout) = 0;
  virtual int recvData(bool use_exception) = 0;
  virtual void sendData(unsigned char* data, unsigned size) = 0;

  virtual void print(std::ostream& os) const;
  
  int       fd_;                          
  int       state_;                       
  char          last_error_[64];              

  // Send buffer
  unsigned char buff_send_[BUF_SEND_SIZE];    
  bool      batch_send_;              
  unsigned  buff_send_tail_;          

  // Receive buffer
  unsigned char buff_recv_[BUF_RECV_SIZE];    
  unsigned  buff_recv_head_;
  unsigned  buff_recv_tail_;

private:
  bool arrangeReadBuffer();
};


inline void  Cx::print(std::ostream&) const
{
}

inline std::ostream& operator<< (std::ostream& os, const Cx& cx)
{
  cx.print(os);
  return os;
}

//
// Cx packets, managed by clients and server, not by rules.
//

struct CxInit : public Packet
{
  CxInit()
   : Packet(CX_INIT, -1) { data_size = sizeof(*this); }
  int binary_version;
};

struct CxDeny : public Packet
{
  CxDeny()
   : Packet(CX_DENY, -1) { data_size = sizeof(*this); }
  int reason[16];
};

struct CxList : public Packet
{
  CxList()
   : Packet(CX_LIST, -1) { data_size = sizeof(*this); }
  int server_name[8];
  int game_uid;
  int nb_coach;
  int nb_viewer;
};

struct CxJoin : public Packet
{
  CxJoin(int player_id = -1)
    : Packet(CX_JOIN, player_id) { data_size = sizeof(*this); }
  int rules_name[8];
  int server_lib[16];
  int rules_major;
  int rules_minor;
  int game_uid;
  int is_coach;
  int client_extid;
};

struct CxError : public Packet
{
  CxError(int player_id = -1)
    : Packet(CX_ERROR, player_id) { data_size = sizeof(*this); }
  int msg[16];
};

#endif /* !CX_HH_ */

---