upd_send.c: Use write_nonblock() rather than write_all().

To this aim, move write_nonblock() from send_common.c to fd.c.

diff --git a/fd.c b/fd.c
index 6042a58f531af44e941f012fdc273d78c2f9fb37..9942eb925f33f86068d04729faf74bcd41a4566b 100644 (file)
--- a/fd.c
+++ b/fd.c
@@ -40,6 +40,45 @@ int write_all(int fd, const char *buf, size_t *len)
        return 1;
 }
 
        return 1;
 }
 

+/**
+ * Write a buffer to a non-blocking file descriptor.
+ *
+ * \param fd The file descriptor.
+ * \param buf the buffer to write.
+ * \param len the number of bytes of \a buf.
+ * \param max_bytes_per_write Do not write more than that many bytes at once.
+ *
+ * If \a max_bytes_per_write is non-zero, do not send more than that many bytes
+ * per write().
+ *
+ * EAGAIN is not considered an error condition.  For example CCID3 has a
+ * sending wait queue which fills up and is emptied asynchronously. The EAGAIN
+ * case means that there is currently no space in the wait queue, but this can
+ * change at any moment.
+ *
+ * \return Negative on errors, number of bytes written else.
+ */
+int write_nonblock(int fd, const char *buf, size_t len,
+               size_t max_bytes_per_write)
+{
+       size_t written = 0;
+       int ret = 0;
+
+       while (written < len) {
+               size_t num = len - written;
+
+               if (max_bytes_per_write && max_bytes_per_write < num)
+                       num = max_bytes_per_write;
+               ret = write(fd, buf + written, num);
+               if (ret < 0 && errno == EAGAIN)
+                       return written;
+               if (ret < 0)
+                       return -ERRNO_TO_PARA_ERROR(errno);
+               written += ret;
+       }
+       return written;
+}
+

 /**
  * Check whether a file exists.
  *
 /**
  * Check whether a file exists.
  *

diff --git a/fd.h b/fd.h
index ae3624d76b4cf3d06c99f24a6d5090abd8ed959a..041a7732d3169ced0cbda3d9aa40727d0841f6c5 100644 (file)
--- a/fd.h
+++ b/fd.h
@@ -25,3 +25,5 @@ int mmap_full_file(const char *filename, int open_mode, void **map,
 int para_munmap(void *start, size_t length);
 int write_ok(int fd);
 void valid_fd_012(void);
 int para_munmap(void *start, size_t length);
 int write_ok(int fd);
 void valid_fd_012(void);

+int write_nonblock(int fd, const char *buf, size_t len,
+               size_t max_bytes_per_write);

diff --git a/send_common.c b/send_common.c
index 30cf939d7d9675e9eb9aaf6c59fa244a35207721..e1f3b11d435dcc8ba5b2d7131ed455df9e1005a7 100644 (file)
--- a/send_common.c
+++ b/send_common.c
@@ -93,45 +93,6 @@ void shutdown_clients(struct sender_status *ss)
                shutdown_client(sc, ss);
 }
 
                shutdown_client(sc, ss);
 }
 

-/**
- * Write a buffer to a non-blocking file descriptor.
- *
- * \param fd The file descriptor.
- * \param buf the buffer to write.
- * \param len the number of bytes of \a buf.
- * \param max_bytes_per_write Do not write more than that many bytes at once.
- *
- * If \a max_bytes_per_write is non-zero, do not send more than that many bytes
- * per write().
- *
- * EAGAIN is not considered an error condition.  For example CCID3 has a
- * sending wait queue which fills up and is emptied asynchronously. The EAGAIN
- * case means that there is currently no space in the wait queue, but this can
- * change at any moment.
- *
- * \return Negative on errors, number of bytes written else.
- */
-static int write_nonblock(int fd, const char *buf, size_t len,
-               size_t max_bytes_per_write)
-{
-       size_t written = 0;
-       int ret = 0;
-
-       while (written < len) {
-               size_t num = len - written;
-
-               if (max_bytes_per_write && max_bytes_per_write < num)
-                       num = max_bytes_per_write;
-               ret = write(fd, buf + written, num);
-               if (ret < 0 && errno == EAGAIN)
-                       return written;
-               if (ret < 0)
-                       return -ERRNO_TO_PARA_ERROR(errno);
-               written += ret;
-       }
-       return written;
-}
-

 static int queue_chunk_or_shutdown(struct sender_client *sc,
                struct sender_status *ss, const char *buf, size_t num_bytes)
 {
 static int queue_chunk_or_shutdown(struct sender_client *sc,
                struct sender_status *ss, const char *buf, size_t num_bytes)
 {

diff --git a/udp_send.c b/udp_send.c
index 50161c1333642d2021b47c3b0a05ff4bd43f10f6..8bbcbae7fa611473d1abd67a65d70506380aa8a5 100644 (file)
--- a/udp_send.c
+++ b/udp_send.c
@@ -61,14 +61,13 @@ static void udp_send_buf(char *buf, size_t len)
        int ret;
 
        list_for_each_entry_safe(ut, tmp, &targets, node) {
        int ret;
 
        list_for_each_entry_safe(ut, tmp, &targets, node) {

-               size_t written = len;

                if (ut->fd < 0)
                        continue;
                if (ut->fd < 0)
                        continue;

-               ret = write_all(ut->fd, buf, &written);
+               ret = write_nonblock(ut->fd, buf, len, len);

                if (ret < 0) /* TODO: Use chunk queueing */
                        return udp_delete_target(ut, "send error");
                if (ret < 0) /* TODO: Use chunk queueing */
                        return udp_delete_target(ut, "send error");

-               if (written != len)
-                       PARA_WARNING_LOG("short write %zu/%zu\n", written, len);
+               if (ret != len)
+                       PARA_WARNING_LOG("short write %zu/%zu\n", ret, len);

        }
 }
 
        }
 }