X-Git-Url: http://developer.intra2net.com/git/?p=libt2n;a=blobdiff_plain;f=src%2Fsocket_handler.cpp;h=00828860e757337e084482b3313c4286da8e172a;hp=ed37e4d739e99088de339260913c6be6511afcb7;hb=517d1214577af263bb4d6821e4e7ad9ba8c94901;hpb=45a2ebc9695c4d7be6548b7e0f800d117ae56a0b

diff --git a/src/socket_handler.cpp b/src/socket_handler.cpp
index ed37e4d..0082886 100644
--- a/src/socket_handler.cpp
+++ b/src/socket_handler.cpp
@@ -35,6 +35,7 @@
 
 #include <sstream>
 #include <iostream>
+#include <algorithm>
 
 #include "socket_handler.hxx"
 #include "t2n_exception.hxx"
@@ -45,6 +46,15 @@ using namespace std;
 namespace libt2n
 {
 
+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 )
+, socket_type(_socket_type)
+{
+}
+
+
 /// set options like fast reuse and keepalive every socket should have
 void socket_handler::set_socket_options(int sock)
 {
@@ -96,6 +106,39 @@ bool socket_handler::is_closed()
     return !(r & O_ACCMODE);
 }
 
+
+/**
+ * @brief set a new size for the receive buffer.
+ * @param new_recv_buffer_size the new size for the receive buffer.
+ *
+ * The receive buffer determines the amount of data which is tried to read at once
+ * from the underlying socket.
+ *
+ * The value is normalized to be at least 512 bytes and at max 32K bytes.
+ */
+void socket_handler::set_recv_buffer_size(unsigned int new_recv_buffer_size)
+{
+    recv_buffer_size= std::max( 512u, std::min( 32u * 1024u, 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
+ * 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
+ * be written.
+ *
+ * The value is normalized to be at least 512 bytes and at max 32K bytes.
+ */
+void socket_handler::set_write_block_size(unsigned int new_write_block_size)
+{
+    write_block_size= std::max( 512u, std::min( 32u * 1024u, new_write_block_size ));
+} //
+
+
 /** @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
@@ -126,6 +169,7 @@ bool socket_handler::data_waiting(long long usec_timeout,long long* usec_timeout
     int ret=select (FD_SETSIZE, &active_fd_set, NULL, NULL, timeout_ptr);
 
     // return the timeout we did not use
+    // todo: this is linux specific according to man 2 select
     if (usec_timeout > 0 && usec_timeout_remaining != NULL)
         *usec_timeout_remaining=(tval.tv_sec*1000000)+tval.tv_usec;
 
@@ -190,7 +234,7 @@ bool socket_handler::fill_buffer(std::string& buffer)
     // Data read -> store it
     if (nbytes > 0)
     {
-        buffer.assign(socket_buffer,nbytes);
+        buffer.append(socket_buffer,nbytes);
         LOGSTREAM(debug,nbytes << " bytes read");
     }
 
@@ -220,7 +264,23 @@ void socket_handler::socket_write(const std::string& data)
         while ((rtn=::write(sock, data.data()+offset, write_size)) &&
                rtn == -1 && (errno == EAGAIN || errno == EINTR))
         {
-            usleep (80000);
+            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;
+            }
             LOGSTREAM(debug,"resuming write() call after EAGAIN or EINTR");
         }
 
@@ -232,11 +292,10 @@ void socket_handler::socket_write(const std::string& data)
         }
         else if (rtn != write_size)
         {
-            LOGSTREAM(error,"write() wrote " << rtn << " bytes, should have been " 
+            LOGSTREAM(debug,"write() wrote " << rtn << " bytes, should have been "
                 << write_size << " (complete: " << data.size() << ")");
 
-            // TODO: exception?
-            return;
+            write_size = rtn;
         }
 
         offset += write_size;
@@ -245,6 +304,6 @@ void socket_handler::socket_write(const std::string& data)
     LOGSTREAM(debug,"wrote " << data.size() << " bytes");
 
     return;
-}
+} // eo socket_handler::socket_write(const std::string&)
 
 }