Make send_queued_chunks() public.

The udp sender will start to use it soon. Make it take the fd and
the chunk queue instead of a struct sender_client as the udp sender
does not use struct sender_client.

diff --git a/send.h b/send.h
index 967f8d53e84723fa7fb02e3cab0aa2b4859f87d8..c1ed00cf33a628e3aec9862874a2d1d3d1809ebe 100644 (file)
--- a/send.h
+++ b/send.h
@@ -141,3 +141,5 @@ int generic_com_on(struct sender_status *ss, unsigned protocol);
 void generic_com_off(struct sender_status *ss);
 char *generic_sender_help(void);
 struct sender_client *accept_sender_client(struct sender_status *ss);
 void generic_com_off(struct sender_status *ss);
 char *generic_sender_help(void);
 struct sender_client *accept_sender_client(struct sender_status *ss);

+int send_queued_chunks(int fd, struct chunk_queue *cq,
+               size_t max_bytes_per_write);

diff --git a/send_common.c b/send_common.c
index e1f3b11d435dcc8ba5b2d7131ed455df9e1005a7..d1dcaeb199e4b8f55b5871bfc89664acdc4d56d3 100644 (file)
--- a/send_common.c
+++ b/send_common.c
@@ -102,23 +102,31 @@ static int queue_chunk_or_shutdown(struct sender_client *sc,
        return ret;
 }
 
        return ret;
 }
 

-/* return: negative on errors, zero if not everything was sent, one otherwise */
-static int send_queued_chunks(struct sender_client *sc,
+/**
+ * Try to empty the chunk queue for this fd.
+ *
+ * \param fd The file descriptor.
+ * \param cq The list of queued chunks.
+ * \param max_bytes_per_write Do not send more than this in one go.
+ *
+ * \return Negative on errors, zero if not everything was sent, one otherwise.
+ */
+int send_queued_chunks(int fd, struct chunk_queue *cq,

                size_t max_bytes_per_write)
 {
        struct queued_chunk *qc;
                size_t max_bytes_per_write)
 {
        struct queued_chunk *qc;

-       while ((qc = cq_peek(sc->cq))) {
+       while ((qc = cq_peek(cq))) {

                const char *buf;
                size_t len;
                int ret;
                cq_get(qc, &buf, &len);
                const char *buf;
                size_t len;
                int ret;
                cq_get(qc, &buf, &len);

-               ret = write_nonblock(sc->fd, buf, len, max_bytes_per_write);
+               ret = write_nonblock(fd, buf, len, max_bytes_per_write);

                if (ret < 0)
                        return ret;
                if (ret < 0)
                        return ret;

-               cq_update(sc->cq, ret);
+               cq_update(cq, ret);

                if (ret != len)
                        return 0;
                if (ret != len)
                        return 0;

-               cq_dequeue(sc->cq);
+               cq_dequeue(cq);

        }
        return 1;
 }
        }
        return 1;
 }


@@ -153,7 +161,7 @@ void send_chunk(struct sender_client *sc, struct sender_status *ss,
                }
                sc->header_sent = 1;
        }
                }
                sc->header_sent = 1;
        }

-       ret = send_queued_chunks(sc, max_bytes_per_write);
+       ret = send_queued_chunks(sc->fd, sc->cq, max_bytes_per_write);

        if (ret < 0) {
                shutdown_client(sc, ss);
                goto out;
        if (ret < 0) {
                shutdown_client(sc, ss);
                goto out;