Tanl Linguistic Pipeline

search/ixe/io/Socket.cpp

/*
**      IXE
**      io/Socket.cpp
** ----------------------------------------------------------------------
**      Copyright (c) 2004  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of IXE.
**
**  IXE is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  IXE is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#include "io/Socket.h"

// standard
#include <errno.h>
#ifndef _WIN32
# include <netdb.h>             // gethostbyname()
#endif

namespace IXE {
namespace io {

AbstractSocket::AbstractSocket(SOCKET sock, InetAddress inetAddress,
                               in_port_t port) :
  sock(sock),
  inetAddress(inetAddress),
  port(port)
{ }

AbstractSocket::~AbstractSocket()
{
  close();
}

void AbstractSocket::close()
{
  if (sock != INVALID_SOCKET) {
    closesocket(sock);
    sock = INVALID_SOCKET;
  }
}

bool AbstractSocket::isOpen() const
{
  return sock != INVALID_SOCKET;
}

size_t AbstractSocket::read(char* buffer, size_t len)
{
  int read = ::recv(sock, buffer, len, MSG_NOSIGNAL);
  if (read <= 0)
    close();
  return read;
}

size_t AbstractSocket::readAll(char* buffer, size_t len)
{
  char* start = buffer;
  int read;
  while (len > 0 && (read = ::recv(sock, buffer, len, MSG_NOSIGNAL)) != len) {
    if (read <= 0) {
      close();
      return buffer - start;
    }
    buffer += read;
    len -= read;
  }
  return buffer - start + len;
}

size_t AbstractSocket::write(char const* buffer, size_t len)
{
  int retval = ::send(sock, buffer, len, MSG_NOSIGNAL);
  if (retval <= 0)
    close();
  return retval;
}

// Client Sockets
//

Socket::Socket(SOCKET sock, InetAddress inetAddress, in_port_t port) :
  AbstractSocket(sock, inetAddress, port)
{ }

Socket::Socket(char const* host, int port)
{
  connect(host, port);
  if (sock == INVALID_SOCKET)
    throw IOError("connect");
}

bool Socket::connect(char const* host, int port)
{
  if (host == 0 || host[0] == '\0')
    host = "localhost";
  struct hostent* hp = ::gethostbyname(host);
  if (hp == 0 || hp->h_addrtype != AF_INET)
    return false;

  this->port = port;
  ::memcpy((char*)&inetAddress, hp->h_addr_list[0], sizeof(inetAddress));

  return open();
}

bool Socket::open()
{
  struct sockaddr_in addr;
  addr.sin_port = htons(port);
  addr.sin_family = AF_INET;
  ::memcpy((char*)&addr.sin_addr, &inetAddress, sizeof(inetAddress));

  sock = ::socket(PF_INET, SOCK_STREAM, 0);
  if (sock == INVALID_SOCKET)
    return false;

  int retval;
  while ((retval = ::connect(sock, (struct sockaddr*)&addr, sizeof(addr)))
         == INVALID_SOCKET && (errno == EINTR))
    ;
  if (retval == SOCKET_ERROR) {
    closesocket(sock);
    return false;
  }

  int const enabled = 1;
# ifdef TCP_NODELAY
  // make sure to turn off TCP coalescence, i.e. disable Nagle algorithm
  /* The Nagle algorithm says that we should delay sending partial
   * packets in hopes of getting more data.  We don't want to do
   * this; we are not telnet.  There are bad interactions between
   * persistent connections and Nagle's algorithm that have very severe
   * performance penalties.
   */
  setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char*)&enabled, sizeof(int));
# endif

# ifdef SO_KEEPALIVE
  setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (const char*)&enabled, sizeof(int));
# endif

  return true;
}

#ifdef _WIN32
class WinSockInitializer {
public:
  WinSockInitializer() {
    int wVersionRequested = MAKEWORD(2, 0); 
    WSADATA wsaData;
    WSAStartup(wVersionRequested, &wsaData);
    int sockopt = SO_SYNCHRONOUS_NONALERT;
    setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (char *)&sockopt,
               sizeof(sockopt));
  }
  ~WinSockInitializer() {
    WSACleanup();
  }

} winSockInitializer;
#endif

} // io
} // IXE

 

Copyright © 2005-2011 G. Attardi. Generated on 3 Mar 2011 by doxygen 1.6.1.