S3FC project page

S3FC home page

---

               

---

s3_socket_tcp.cc

Go to the documentation of this file.

/*
 * Stone Three Foundation Class (s3fc) provides a number of utility classes.
 * Copyright (C) 2001 by Stone Three Signal Processing (Pty) Ltd.
 *
 * Authored by Stone Three Signal Processing (Pty) Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Please see the file 'COPYING' in the source root directory.
 */

#include <s3fc/s3_socket_tcp.h>
#include <s3fc/s3_thread_base.h>
#include <s3fc/s3_macros.h>
#include <sstream>
#ifndef _WIN32
#include <sys/time.h>
#endif

s3_socket_tcp::s3_socket_tcp(int newsock, bool new_set_reuseaddr)
   throw(s3_generic_exception) :
   set_reuseaddr(new_set_reuseaddr), my_errno(0), my_h_errno(0)
{
   if(newsock == INVALID_SOCKET)
   {
      if ( !initialize() )
      {
    throw s3_generic_exception("s3_socket_tcp::s3_socket_tcp()",
                "Could not initialize socket");
      }
   }
   else
   {
      sock = newsock;
   }
}

s3_socket_tcp::s3_socket_tcp(const s3_socket_tcp& template_sock)
   throw(s3_generic_exception) :
   set_reuseaddr(template_sock.set_reuseaddr), my_errno(0), my_h_errno(0)
{
   if ( !initialize() )
   {
      throw s3_generic_exception("s3_socket_tcp::s3_socket_tcp()",
             "Could not initialize socket");
   }
}

s3_socket_tcp::~s3_socket_tcp()
{
   close(false); //don't reinitialize
}

bool s3_socket_tcp::initialize()
{
   set_errnos(); //reset errors here in case we miss a return
   if( (sock = ::socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == 1)
   {
      S3FC_DBG2_("s3_socket_tcp::initialize()", "::socket() failed");
      sock = INVALID_SOCKET;
      set_errnos(errno);
      return false; //don't set socket options
   }
   S3FC_DBG2_("s3_socket_tcp::initialize()", "::socket() ok");
   
   // SO_REUSEADDR gets rid of timeout after socket use.
   int optval = 1;
   if( set_reuseaddr )
   {
      if( setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &optval,
           sizeof(int)) != 0 )
      {
    set_errnos(errno);
    return false;
      }
   }
   return true;
}

void s3_socket_tcp::set_errnos(int new_errno, int new_h_errno)
{
   my_errno = new_errno;
   my_h_errno = new_h_errno;
}

void s3_socket_tcp::change_socket(int newsock)
{
   close(false);
   sock = newsock;
}

bool s3_socket_tcp::bind(in_addr_t addr, in_port_t port)
{
   S3FC_DBG_("s3_socket_tcp::bind(addr,port="<< port << ")");
   set_errnos();   
   sockaddr_in my_addr;
   my_addr.sin_family = AF_INET;
   my_addr.sin_addr.s_addr = htonl(addr);
   my_addr.sin_port = htons(port);
   if ( ::bind(sock, (struct sockaddr*)&my_addr, sizeof(my_addr)) != 0 )
   {
      S3FC_DBG2_("s3_socket_tcp::bind()", "::bind() failed");
      set_errnos(errno);
      return false;
   }
   S3FC_DBG2_("s3_socket_tcp::bind()", "::bind() ok");
   return true;   
}

bool s3_socket_tcp::listen(int backlog)
{
   S3FC_DBG_( "s3_socket_tcp::listen(backlog=" << backlog << ")");
   set_errnos();   
   if( ::listen(sock, backlog) != 0 )
   {
      S3FC_DBG2_("s3_socket_tcp::listen()", "::listen() failed");
      set_errnos(errno);
      return false;
   }
   S3FC_DBG2_("s3_socket_tcp::listen()", "::listen() ok");
   return true;   
}

bool s3_socket_tcp::accept(s3_socket_tcp& newsock, sockaddr_in* clientname)
{
   S3FC_DBG_("s3_socket_tcp::accept()");
   set_errnos();
   int accepted_socket;
#ifdef _WIN32
   int size;
#else
   socklen_t size;
#endif
   size = clientname != 0 ? sizeof(*clientname) : 0;
   if( (accepted_socket =
   ::accept(sock, (struct sockaddr*)&clientname, &size)) == -1)
   {
      S3FC_DBG2_( "s3_socket_tcp::accept()", "::accept() failed" );
      set_errnos(errno);
      return false;
   }
   S3FC_DBG2_("s3_socket_tcp::accept()", "::accept() ok");
   newsock.change_socket(accepted_socket);
   return true;   
}

bool s3_socket_tcp::connect(const std::string& IP_address, in_port_t port)
{
   S3FC_DBG_( "s3_socket_tcp::connect(IP_address=" << IP_address
         << ",port=" << port << ")" );
   
   set_errnos();   
   hostent *he = gethostbyname(IP_address.c_str());
   if (he == 0)
   {
      S3FC_DBG2_("s3_socket_tcp::connect()", "gethostbyname failed");
      if ( h_errno >= 0 )
      {
    set_errnos(-1, h_errno);
      }
      else
      {
    set_errnos(errno, 0);
      }
      return false;
   }
   
   sockaddr_in addr;
   memset(&addr, 0, sizeof(addr));
   memcpy(&addr.sin_addr, he->h_addr, he->h_length);
   addr.sin_port = htons(port);
   addr.sin_family = he->h_addrtype;
   
   if ( ::connect(sock, (struct sockaddr *)&addr, sizeof(addr)) != 0 )
   {
      S3FC_DBG2_("s3_socket_tcp::connect()", "::connect() failed");
      set_errnos(errno);
      return false;
   }
   S3FC_DBG2_("s3_socket_tcp::connect()", "::connect() ok");
   return true;   
}

bool s3_socket_tcp::close(bool reinit) throw(s3_generic_exception)
{
   S3FC_DBG_("s3_socket_tcp::close()");
   
   set_errnos();
   int ret = 0;
   if ( is_valid() )
   {
      S3FC_DBG2_("s3_socket_tcp::close()", "closing socket");
#ifdef _WIN32
      ret = closesocket(sock);
#else
      ret = ::close(sock);
#endif
   }
   sock = INVALID_SOCKET;
   if ( ret != 0 )
   {
      S3FC_DBG2_("s3_socket_tcp::close()", "::close() failed");
      set_errnos(errno);
      return false;
   }
   S3FC_DBG2_("s3_socket_tcp::close()", "::close() ok");
   if ( reinit && !initialize() ) //for listen() or connect() after close
   {
      throw s3_generic_exception("s3_socket_tcp::close()",
             "Could not reinitialize socket");
   }
   return true;
}

std::string s3_socket_tcp::get_error() const
{
   S3FC_DBG2_( "s3_socket_tcp::get_error()", "my_errno = " << my_errno
          << ", " << "my_h_errno = " << my_h_errno );

   std::string error_string;
   if ( my_errno >= 0 )
   {
#ifdef _WIN32
      std::stringstream ss;
      ss << "WSAGetLastError: " << my_errno;
      error_string = ss.str();
#else
      error_string = strerror(my_errno);
#endif
   }
   else if ( my_h_errno > 0 )
   {
#ifdef _WIN32
      std::stringstream ss;
      ss << "WSAGetLastError: (h) " << my_h_errno;
      error_string = ss.str();
#else
      error_string = hstrerror(my_h_errno);
#endif
   }   
   else if ( my_errno == -1 )
   {
      error_string = "Connection closed";
   }
   else if ( my_errno == -2 )
   {
      error_string = "Termination semaphore posted";
   }
   else
   {
      error_string = "Unknown error";
   }

   S3FC_DBG_("error_string = " << error_string);

   return error_string;
}

bool s3_socket_tcp::read(void *data, int size, s3_semaphore *term)
{
   S3FC_DBG2_("s3_socket_tcp::read()", "socket = " << sock);

   set_errnos();
   int rem_size = size;
   int e = 0;
   // changed unsigned char* to char* for WIN32 recv [fswane].
   char *buf = reinterpret_cast<char*>(data);
   do
   {
      // If a thread canceller is available, call it.
      s3_thread_base::test_cancel();
      
      // Test cancellation of the read via semaphore.
      if (term != 0 && term->try_wait())
      {
    set_errnos(-2);
    return false;
      }
      
      switch (select_rd(1) )
      {
      case -1 : return false; // errno already set
      case  0 : continue;     // Just a timeout so carry on
      case  1 : break;        // I smell data !!
      default: throw s3_generic_exception("s3_socket_tcp::read()",
                 "select_rd() returned an invalid value");
      }
      
      errno = 0;
#ifdef _WIN32
      int ret = recv(sock, buf, rem_size, 0);
      /*
       * Checkking for errors and if the remote socket disconnected.
       * The logic is as follow:
       *  - The return value will be zero if the remote socket disconnected.
       *  - The return value will be SOCKET_ERROR if some error condition 
       *    occured.
       *  - Otherwise ther return value indicates how many bytes were read.
       *
       * 30 May 2002: Jan Pool <jpool@stonethree.com>
       */
      if ( ( ret == 0 ) || ( ret == SOCKET_ERROR ) )
      {
    if ( ret == SOCKET_ERROR )
    {
       // Get error number.
       e = WSAGetLastError();
       if (e == WSAEWOULDBLOCK) 
       {
          /*
      * No data: select probably timed out, but since we are in 
      * non-blocking mode the resv fall through.
      * This error code saves the day.
      */
          continue;
       } 
       else if (e == WSAENOTCONN)
       {
          // This indicates that the socket is not connected
          // I think it means the socket was never connected <jp>
          set_errnos(-1);
       }
       else
       {
          set_errnos(e);
       }
    }
    else
    {
       set_errnos(-1); // Remote socket disconnected.
    }
    return false;
      }
#else
      int ret = recv(sock, buf, rem_size, MSG_DONTWAIT);
      e = errno;
      // loop if no data available
      if (e == EAGAIN) 
      {
    continue;
      }
      else if ( (ret <= 0 ) || (e != 0) ) // Some other error...
      {
         // ugly, but I cannot find another way to see
         // if the connection was closed by peer !!FIXME
         if (e == 0)
    {
       set_errnos(-1);
    }
    else
    {
       set_errnos(e);
    }
    return false;  
      }
#endif
      // if we can assume that no error has occured [goof]
      // Account for new data and update pointers
      rem_size -= ret;  // Remaining data to acquire
      buf = buf + ret; // update pointer into buffer
      
      // removed some #if 0'ed code here [albert]
   }
   while (rem_size > 0);
   
   return true;
}

bool s3_socket_tcp::write(void *data, int size, int max_packet,
           s3_semaphore *term)
{
   S3FC_DBG_("s3_socket_tcp::write() called");

   set_errnos();   
   int rem_size = size;
   int packet_size = size;
   int e = 0;
   // changed unsigned char* to char* for WIN32 recv [fswane].
   char *buf = (char *) data;

   if (max_packet > size )
   {
      packet_size = max_packet; //was packet_size = size
   }
   // Get all the data out the door
   do
   {
      s3_thread_base::test_cancel();
      
      // Test cancellation of the read via semaphore.
      if (term != 0 && term->try_wait())
      {
    set_errnos(-2);
    return false;
      }

      switch (select_wr(1) )
      {
      case -1 : return false; // errno already set
      case  0 : continue;     // Just a timeout so carry on
      case  1 : break;        // I smell data !!
      default: throw s3_generic_exception("s3_socket_tcp::write()",
                 "select_wr() returned an invalid value");
      }
    
      errno = 0;
#ifdef _WIN32
      int ret = send(sock, buf, packet_size, 0);
      if (ret == SOCKET_ERROR) e = WSAGetLastError();
      // loop if no data available
      if (e == WSAEWOULDBLOCK) 
      {
    continue;
      } 
      else if (ret == SOCKET_ERROR)
      {
    set_errnos(e);
    return false;
      }
#else
      int ret = send(sock, buf, packet_size, MSG_DONTWAIT | MSG_NOSIGNAL);
      e = errno;
      if ( e == EAGAIN)
      {
         continue;  // just nothing available
      }
      else if ( (ret < 0 ) || (e != 0) ) // Some other error...
      {
         // Something we cannot handle has happened
    set_errnos(e);
    return false;
      }
#endif
      // if we get here, we can assume that no error has occured [goof]
      // Update our counters for the data we have received
      rem_size = rem_size - ret;  // Remaining data to acquire
      buf = buf + ret; // update pointer into buffer
      if (rem_size < packet_size) packet_size = rem_size;
      
      //removed some #if 0'ed code [albert]
   }
   while (rem_size > 0);

   return true;
}

int s3_socket_tcp::select_rd(int delay)
{
   fd_set fds, fde;
   timeval tv;
   // Set select to timeout after a second.
   tv.tv_sec = delay;
   tv.tv_usec = 0;
   // Set up the FD and timeout for select
   FD_ZERO(&fds);
   FD_ZERO(&fde);
   FD_SET(sock, &fds);
   FD_SET(sock, &fde);
   errno = 0;
   int ret = select(sock+1, &fds, 0, &fde, &tv);
   if ( ( ret == -1 ) ||  FD_ISSET(sock, &fde) )
   {
      set_errnos(errno);
      return -1;
   }
   if (ret == 0 ) // Nothing happened so return timeout
   {
      return 0;
   }
   if ( FD_ISSET(sock, &fds) ) // Data available for read on socket
   {
      return 1;
   }
   // Shuts compiler up. This is an impossible return
   return -2;
}

int s3_socket_tcp::select_wr(int delay)
{
   fd_set fds, fde;
   timeval tv;
   // Set select to timeout after a second.
   tv.tv_sec = delay;
   tv.tv_usec = 0;
   // Set up the FD and timeout for select
   FD_ZERO(&fds);
   FD_ZERO(&fde);
   FD_SET(sock, &fds);
   FD_SET(sock, &fde);
   errno = 0;
   int ret = select(sock+1, 0, &fds, &fde, &tv);
   if ( ( ret == -1 ) ||  FD_ISSET(sock, &fde) )
   {
      set_errnos(errno);
      return -1;
   }
   if (ret == 0 ) // Nothing happened so return timeout
   {
      return 0;
   }
   if ( FD_ISSET(sock, &fds) ) // Data available for read on socket
   {
      return 1;
   }
   // Shuts compiler up. This is an impossible return
   return -2;
   
}

---

Send comments to: s3fc@stonethree.com