usocket.hpp

/* ==================================================== ======== ======= *
*
*  usocket.hpp : simple sockets
*  Ubit Project
*  Part of the Ubit Toolkit: A Brick Construction Game Model for Creating GUIs
*  (C) 1999-2006 EricLecolinet / ENST Paris / http://www.enst.fr/~elc/ubit
*
* ***********************************************************************
* COPYRIGHT NOTICE :
* THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY AND WITHOUT EVEN THE
* IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* 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.
* SEE FILES 'COPYRIGHT' AND 'COPYING' FOR MORE DETAILS.
* ***********************************************************************
* ==================================================== [(c)Elc] ======= *
* ==================================================== ======== ======= */

#ifndef _usocket_hpp_
#define _usocket_hpp_
//pragma ident  "@(#)usocket.hpp        ubit:05.00.00"
#include <ubit/ustr.hpp>

extern "C" {
  struct sockaddr_in;
}

namespace ubit {

  class UInput;
  class UOutbuf;
  class UInbuf;

/* ==================================================== ===== ======= */
class USocket {
public:
  USocket();
  USocket(const char* remote_host, int remote_port);
  USocket(const UStr& remote_host, int remote_port);
  virtual ~USocket();

  virtual int connect(const char* remote_host, int remote_port);
  virtual void close();

  virtual void onInput(UCall&);

  //bool isBound() const;
  // returns the binding state of the Socket
  
  //bool isClosed() const;
  // returns the closed state of the Socket
  
  bool isConnected() const {return sock >= 0;}
  // returns the connection state of the Socket

  int  getRemotePort() const {return remport;}
  int  getDescriptor() const {return sock;}

  bool sendBlock(const char* buffer, unsigned short size);
  bool sendBlock(UOutbuf&);
  bool receiveBlock(UInbuf&);
  bool sendBytes(const char* buffer, unsigned int size);
  bool receiveBytes(char* buffer, unsigned int size);
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
protected:
  friend class UServerSocket;
  int remport, sock;
  struct sockaddr_in* sin;
  UInput* input;
};

/* ==================================================== [Elc] ======= */
/* ==================================================== ===== ======= */
class UServerSocket {
public:
  UServerSocket();
  
  UServerSocket(int port);

  virtual ~UServerSocket();

  virtual void onInput(UCall&);
  virtual USocket* accept();
  bool bind(int port, int backlog = 0, bool reuse_address = true);
  /* binds this socket.
    * there is no need to call this function if the constructor
    * UServerSocket(int port) was used. bind() must only be called to bind
    * an unbound socket created by UServerSocket() [without an arg].
    *
    * Args:
    * - 'backlog' specifies how many pending connections the queue will hold
    *   (a default value will be used if this arg is <= 0)
    * - 'reuse_address' specifies if the same address can be reused
    */  

  virtual void close();

  virtual USocket* createSocket() const {return new USocket();}

  bool isClosed() const {return listen_sock < 0;}
  
  //bool isBound() const;
  // returns the binding state of the ServerSocket
  
  int getLocalPort()  const {return listen_port;}
  //< returns the port on which the server is listening.
  
  int getDescriptor() const {return listen_sock;}
  //< returns the socket descriptor on which the server is listening.

protected:
  int listen_port, listen_sock;
  struct sockaddr_in* sin;
  UInput* input;
};

/* ==================================================== [Elc] ======= */
/* ==================================================== ===== ======= */
struct UIObuf {
  UIObuf();
  virtual ~UIObuf();

  const char* data() const;
  char* data();
  unsigned int size() const;
  unsigned int consumed() const;

  bool resize(unsigned short);
  bool augment(unsigned short);

protected:
  friend class USocket;
  enum {DEFAULT_BUFSIZE = 512, AUGMENT_QUANTUM = 2048};
  char* buffer;
  char  default_buffer[DEFAULT_BUFSIZE];
  unsigned int inpos, outpos;  // current pos of the input and output indexes
  unsigned int bufsize;        // total memory size (int not short!)
};

/* ==================================================== ======== ======= */
struct UOutbuf : public UIObuf {  
  void writeChar(char);
  void writeChar(unsigned char);
  void writeShort(short);
  void writeLong(long);
  void writeString(const UStr&);
  void writeString(const char*);
  void writeString(const char* s, unsigned int len);
  void writeEvent(unsigned char event_type, unsigned char event_flow,
                  long x, long y, unsigned long detail);
};

/* ==================================================== ======== ======= */
struct UInbuf : public UIObuf {
  void readChar(char&);
  void readChar(unsigned char&);
  void readShort(short&);
  void readLong(long&);
  void readString(UStr&);
  void readEvent(unsigned char& event_type, unsigned char& event_flow,
                 long& x, long& y, unsigned long& detail);
};
}
#endif
/* ==================================================== [TheEnd] ======= */
/* ==================================================== [(c)Elc] ======= */

---