Add some more derived files to .gitignore.

[paraslash.git] / send_common.c

diff --git a/send_common.c b/send_common.c
index 3d87008850a8ab3c39b3f1711d5aca1b2e2f3a45..d1dcaeb199e4b8f55b5871bfc89664acdc4d56d3 100644 (file)
--- a/send_common.c
+++ b/send_common.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (C) 2005-2008 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2005-2009 Andre Noll <maan@systemlinux.org>

  *
  * Licensed under the GPL v2. For licencing details see COPYING.
  */
  *
  * Licensed under the GPL v2. For licencing details see COPYING.
  */


@@ -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)
 {


@@ -141,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;
 }


@@ -192,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;