usocket.hpp

/************************************************************************
*
*  usocket.hpp: simple sockets
 *  Ubit GUI Toolkit - Version 6
 *  (C) 2009 | Eric Lecolinet | TELECOM ParisTech | 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.
* ***********************************************************************/

#ifndef _usocket_hpp_
#define _usocket_hpp_ 1
#include <ubit/udefs.hpp>
#include <ubit/ustr.hpp>

extern "C" {
  struct sockaddr_in;
}

namespace ubit {
  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 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;
  USource* 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;}
    
  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;
  USource* input;
};

/* ==================================================== [Elc] ======= */
class UIObuf {
public:
  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!)
};

/* ==================================================== [Elc] ======= */
class UOutbuf : public UIObuf {
public:
  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);
};

  /* ==================================================== [Elc] ======= */
class UInbuf : public UIObuf {
public:
  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