Read and write wrappers

To be able to live without short reads. Needed by tests as well.

git-svn-id: svn://bind10.isc.org/svn/bind10/branches/vorner-sockcreator@3147 e5f2f494-b856-4b98-b285-d166d9295462

src/bin/sockcreator/sockcreator.cc

@@ -14,6 +14,9 @@
 
 #include "sockcreator.h"
 
+#include <unistd.h>
+#include <cerrno>
+
 namespace isc {
 namespace socket_creator {
 
@@ -35,5 +38,47 @@ run(const int input_fd, const int output_fd, const get_sock_t get_sock,
     // TODO Implement
 }
 
+bool
+write_data(const int fd, const char *buffer, const size_t length) {
+    size_t rest(length);
+    // Just keep writing until all is written
+    while(rest) {
+        ssize_t written(write(fd, buffer, rest));
+        if(rest == -1) {
+            if(errno == EINTR) { // Just keep going
+                continue;
+            } else {
+                return false;
+            }
+        } else { // Wrote something
+            rest -= written;
+            buffer += written;
+        }
+    }
+    return true;
+}
+
+ssize_t
+read_data(const int fd, char *buffer, const size_t length) {
+    size_t rest(length), already(0);
+    while(rest) { // Stil something to read
+        ssize_t amount(read(fd, buffer, rest));
+        if(rest == -1) {
+            if(errno == EINTR) { // Continue on interrupted call
+                continue;
+            } else {
+                return -1;
+            }
+        } else if(amount) {
+            already += amount;
+            rest -= amount;
+            buffer += amount;
+        } else { // EOF
+            return already;
+        }
+    }
+    return already;
+}
+
 } // End of the namespaces
 }

src/bin/sockcreator/sockcreator.h

@@ -96,6 +96,38 @@ run(const int input_fd, const int output_fd,
     const get_sock_t get_sock_fun = get_sock,
     const send_fd_t send_fd_fun = send_fd);
 
+/*
+ * \short write() that writes everything.
+ * Wrapper around write(). The difference is, it never writes less data
+ * and looks successfull (eg. it blocks until all data are written).
+ * Retries on signals.
+ *
+ * \return True if sucessfull, false otherwise. The errno variable is left
+ *     intact.
+ * \param fd Where to write.
+ * \param data The buffer to write.
+ * \param length How much data is there to write.
+ *
+ * TODO: Shouldn't this be in some kind of library?
+ */
+bool
+write_data(const int fd, const char *data, const size_t length);
+
+/*
+ * \short read() that reads everything.
+ * Wrapper around read(). It does not do short reads, if it returns less,
+ * it means there was EOF. It retries on signals.
+ *
+ * \return Number of bytes read or -1 on error.
+ * \param fd Where to read data from.
+ * \param data Where to put the data.
+ * \param length How many of them.
+ *
+ * TODO: Shouldn't this be in some kind of library?
+ */
+ssize_t
+read_data(const int fd, char *buffer, const size_t length);
+
 } // End of the namespaces
 }