/Users/mourrain/Devel/mmx/basix/src/socket_port.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : socket_port.cpp
* DESCRIPTION: Ports for sockets
* COPYRIGHT  : (C) 2010  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#include <basix/posix_port.hpp>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>


namespace mmx {

/******************************************************************************
* Socket ports
******************************************************************************/

class socket_port_rep: public posix_port_rep {
  string host;
  int    pnr;
  int    role;

public:
  syntactic expression () const {
    if (role == 0)
      return syn ("socket_server_port", syntactic (host), syntactic (pnr));
    else if (role == 1)
      return syn ("socket_accept_port", syntactic (host), syntactic (pnr));
    else
      return syn ("socket_client_port", syntactic (host), syntactic (pnr));
  }

  void send (const char* s, nat len) {
    if (this->alive) {
      nat total= 0;          // how many bytes we've sent
      nat bytes_left= len;   // how many we have left to send
      nat n= 0;
      while (total < len) {
        n= ::send (this->fd, s+total, bytes_left, 0);
        if (n == ((nat) -1)) break;
        total += n;
        bytes_left -= n;
      }
    }
  }

  void feed () {
    if (this->pos > ((N(this->buffer) >> 1) + 1024)) {
      this->buffer= this->buffer (this->pos, N(this->buffer));
      this->pos= 0;
    }
    while (this->alive && wait (0)) {
      char tempout[1024];
      int r= recv (this->fd, tempout, 1024, 0);
      if (r <= 0) { this->alive= false; break; }
      else this->buffer << string (tempout, r);
    }
  }

  port accept ();

public:
  inline socket_port_rep (const string& host2, int pnr2, int role2, int fd):
    posix_port_rep (3, fd),
    host (host2), pnr (pnr2), role (role2) {}
  inline ~socket_port_rep () {
    close (this->fd); }
};

port
socket_port (const string& host, int pnr, int role, int fd) {
  return (port_rep*) new socket_port_rep (host, pnr, role, fd);
}

/******************************************************************************
* Socket servers
******************************************************************************/

port
socket_server_port (const string& host, int pnr) {
  // get the server
  int fd;
  if ((fd = socket (PF_INET, SOCK_STREAM, 0)) == -1)
    return error_port ("call to 'socket' failed");

  // lose the pesky "address already in use" error message
  int yes= 1;
  if (setsockopt (fd, SOL_SOCKET, SO_REUSEADDR,
                  &yes, sizeof (int)) == -1)
    return error_port ("call to 'setsockopt' failed");

  // bind
  struct sockaddr_in local_address;
  local_address.sin_family = AF_INET;
  local_address.sin_addr.s_addr = INADDR_ANY;
  local_address.sin_port = htons (pnr);
  memset (local_address.sin_zero, '\0', sizeof local_address.sin_zero);
  if (bind (fd, (struct sockaddr *) &local_address,
            sizeof (local_address)) == -1)
    return error_port ("call to 'bind' failed");

  // listen
  if (::listen (fd, 10) == -1)
    return error_port ("call to 'listen' failed");
  return socket_port (host, pnr, 0, fd);
}

/******************************************************************************
* Accepting a client
******************************************************************************/

port
socket_port_rep::accept () {
  ASSERT (role == 0, "socket server port expected");
  if (!this->alive || !wait (0)) return error_port ("no incoming connection");
  struct sockaddr_in remote_address;
  socklen_t addrlen= sizeof (remote_address);
  int client=
    ::accept (this->fd, (struct sockaddr *) &remote_address, &addrlen);
  if (client == -1)
    return error_port ("Call to 'accept' failed");
  else {
    string addr= inet_ntoa (remote_address.sin_addr);
    return socket_port (host, pnr, 1, client);
  }
}

/******************************************************************************
* Socket clients
******************************************************************************/

port
socket_client_port (const string& host, int pnr) {
  // getting host
  char* _host= as_charp (host);
  struct hostent *hp = gethostbyname (_host);
  free_charp (_host);
  if (hp == NULL) return error_port ("no connection for '" * host * "'");

  // creating socket
  int fd= socket (AF_INET, SOCK_STREAM, 0);
  if (fd < 0) return error_port ("socket could not be created");

  // connecting to socket
  struct sockaddr_in insock;
  string where= host * ":" * as_string (pnr);
  memset ((char*) &insock, 0, sizeof (insock));
  insock.sin_family = AF_INET;
  insock.sin_port = htons ((unsigned short) pnr);
  memcpy ((char*) &insock.sin_addr, hp->h_addr, hp->h_length);
  if (connect (fd, (struct sockaddr*) &insock, sizeof (insock)) < 0)
    return error_port ("refused connection to '" * where * "'");

  // testing whether it works
  int flags = O_NONBLOCK;
  if (fcntl (fd, F_SETFL, flags) < 0)
    return error_port ("non working connection to '" * where * "'");
  return socket_port (host, pnr, 2, fd);
}

} // namespace mmx