libt2n: (gerd) add lots of error handling code, unit tests for this error handling...

[libt2n] / src / socket_handler.cpp

diff --git a/src/socket_handler.cpp b/src/socket_handler.cpp
index 0082886..532c7f8 100644 (file)
--- a/src/socket_handler.cpp
+++ b/src/socket_handler.cpp
@@ -50,6 +50,7 @@ socket_handler::socket_handler(int _sock, socket_type_value _socket_type)
 : sock(_sock)
 , recv_buffer_size( default_recv_buffer_size )
 , write_block_size( default_write_block_size )
+, write_timeout( default_write_timeout )
 , socket_type(_socket_type)
 {
 }
@@ -126,9 +127,9 @@ void socket_handler::set_recv_buffer_size(unsigned int new_recv_buffer_size)
  * @brief set new size for the data chunks when writeing.
  * @param new_write_block_size the new chunk size.
  *
- * The write block size determines the amound of data which is tried to write
+ * The write block size determines the amount of data which is tried to write
  * to the socket when data needs to be sended.
- * Since writeing data is done in a loop, this does not limit the amunt of data which can
+ * Since writing data is done in a loop, this does not limit the amunt of data which can
  * be written.
  *
  * The value is normalized to be at least 512 bytes and at max 32K bytes.
@@ -139,6 +140,20 @@ void socket_handler::set_write_block_size(unsigned int new_write_block_size)
 } //
 
 
+/**
+ * @brief set new timeout for writing a block
+ * @param new_write_timeout the new timeout in usecs, -1: wait endless
+ *
+ * The write timeout determines the maximum amount of time that is waited
+ * between writing each block. If the timeout is exceeded, write will
+ * throw t2n_transfer_error
+ */
+void socket_handler::set_write_timeout(long long new_write_timeout)
+{
+    write_block_size=new_write_timeout;
+} //
+
+
 /** @brief check if new data is waiting on the raw socket
     @param[in,out] usec_timeout wait until new data is found, max timeout usecs.
             -1: wait endless
@@ -216,11 +231,7 @@ bool socket_handler::fill_buffer(std::string& buffer)
             try_again=true;
         }
         else
-        {
-            LOGSTREAM(error,"error reading from socket : " << strerror(errno));
-            // TODO: exception?
-            return false;
-        }
+            EXCEPTIONSTREAM(error,t2n_transfer_error,"error reading from socket : " << strerror(errno));
     }
 
     // End-of-file
@@ -261,35 +272,15 @@ void socket_handler::socket_write(const std::string& data)
             write_size = data.size()-offset;
 
         int rtn;
-        while ((rtn=::write(sock, data.data()+offset, write_size)) &&
-               rtn == -1 && (errno == EAGAIN || errno == EINTR))
+        while ((rtn=::write(sock, data.data()+offset, write_size)) == -1 &&
+               (errno == EAGAIN || errno == EINTR))
         {
-            fd_set write_set[1];
-            fd_set except_set[1];
-            FD_ZERO(write_set);
-            FD_ZERO(except_set);
-            FD_SET(sock, write_set);
-            FD_SET(sock, except_set);
-            // let's wait for the socket to become writable again...
-            //TODO: use a timeout here?
-            int n= ::select(sock+1, NULL, write_set, except_set, NULL);
-            if (n==1 && ! FD_ISSET(sock,write_set) && FD_ISSET(sock, except_set))
-            {
-                // if we are selected but cannot write and have an exception
-                // we have serious trouble...
-                LOGSTREAM(error,"exception on socket; cannot write any more.");
-                //TODO: exception?
-                return;
-            }
+            wait_ready_to_write(sock,write_timeout);
             LOGSTREAM(debug,"resuming write() call after EAGAIN or EINTR");
         }
 
         if (rtn == -1)
-        {
-            LOGSTREAM(error,"write() returned " << strerror(errno));
-            // TODO: exception?
-            return;
-        }
+            EXCEPTIONSTREAM(error,t2n_transfer_error,"write() returned " << strerror(errno));
         else if (rtn != write_size)
         {
             LOGSTREAM(debug,"write() wrote " << rtn << " bytes, should have been "
@@ -306,4 +297,49 @@ void socket_handler::socket_write(const std::string& data)
     return;
 } // eo socket_handler::socket_write(const std::string&)
 
+/// wait until the socket is ready to write again
+void socket_handler::wait_ready_to_write(int socket, long long write_block_timeout)
+{
+    // prepare socket sets
+    fd_set write_set[1];
+    fd_set except_set[1];
+    FD_ZERO(write_set);
+    FD_ZERO(except_set);
+    FD_SET(socket, write_set);
+    FD_SET(socket, except_set);
+
+    // prepare timeout struct
+    struct timeval tval;
+    struct timeval *timeout_ptr;
+
+    if (write_block_timeout == -1)
+        timeout_ptr = NULL;
+    else
+    {
+        timeout_ptr = &tval;
+
+        // convert timeout from long long usec to int sec + int usec
+        tval.tv_sec = write_block_timeout / 1000000;
+        tval.tv_usec = write_block_timeout % 1000000;
+    }
+
+    // let's wait for the socket to become writable again...
+    int rtn;
+    while ((rtn=::select(socket+1, NULL, write_set, except_set, timeout_ptr)) ==-1 && errno == EINTR);
+
+    if (rtn > 0 && (!FD_ISSET(socket,write_set)) && FD_ISSET(socket, except_set))
+    {
+        // if we are selected but cannot write and have an exception
+        // we have serious trouble...
+        EXCEPTIONSTREAM(error,t2n_transfer_error,"exception on socket; cannot write any more.");
+    }
+
+    if (rtn==0)
+        EXCEPTIONSTREAM(error,t2n_transfer_error,"timeout on select() for write");
+
+    if (rtn==-1)
+        EXCEPTIONSTREAM(error,t2n_transfer_error,"cannot select() for write: " << strerror(errno));
+}
+
+
 }