source: csserver.c hush-3.0b4/auxiliary/net/cs

  // csserver.cc
  
  include <net/cs/csserver.h>
  include <net/cs/csserverimp.h>
  include <net/cs/samlib.h>
  
  include <stdio.h>
  include <string.h>
  include <sys/time.h>
  
  //---------------------------- csserver implementation ---------------------
  
  csserver::csserver(csserverimp* imp, csaddress* addr)
  {
      init(imp, addr);
  }
  
  int csserver::init(csserverimp* imp, csaddress* addr)
  {
      _imp = imp;
  
      if (_imp == NULL)
      {
          warn("csserver::init(imp, addr) : _imp = NULL");
          return -1;
      }
  
      return _imp -> init_imp(addr);
  }
  
  csserver::~csserver()
  {
      _imp = NULL;
  }
  
  int csserver::connected() const
  {
      return _imp -> connected_imp();
  }
  
  void csserver::bind(handler* h) const
  {
      _imp -> bind_imp(h);
  }
  
  void csserver::unbind() const
  {
      _imp -> unbind_imp();
  }
  
  listen_connection* csserver::listenconn() const
  {
      return _imp -> listenconn_imp();
  }
  
  data_connection* csserver::conn(int fd) const
  {
      return _imp -> conn_imp(fd);
  }
  
  void csserver::closeall()
  {
      _imp -> closeall_imp();
  }
  
  data_connection* csserver::select(fd_set* fds)
  {
      return _imp -> select_imp(fds);
  }
  
  void csserver::close(data_connection* conn)
  {
      _imp -> close_imp(conn);
  }
  
  int csserver::broadcast(const char* buffer, int nrbytes)
  {
      return _imp -> broadcast_imp(buffer, nrbytes);
  }
  
  int csserver::broadcastmsg(const char* buffer, int nrbytes)
  {
      return _imp -> broadcastmsg_imp(buffer, nrbytes);
  }
  
  data_connection* csserver::newconnection()
  {
      return _imp -> newconnection_imp();
  }
  
  int csserver::read(data_connection* conn, char* buffer, int maxnrbytes)
  {
      return _imp -> read_imp(conn, buffer, maxnrbytes);
  }
  
  int csserver::readmsg(data_connection* conn, char* buffer, int maxnrbytes)
  {
      return _imp -> readmsg_imp(conn, buffer, maxnrbytes);
  }
  
  int csserver::write(data_connection* conn, const char* buffer, int nrbytes)
  {
      return _imp -> write_imp(conn, buffer, nrbytes);
  }
  
  int csserver::writemsg(data_connection* conn, const char* buffer, 
                         int nrbytes)
  {
      return _imp -> writemsg_imp(conn, buffer, nrbytes);
  }
  

Hush Online Technology hush@cs.vu.nl 09/09/98