X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=send_common.c;h=d1dcaeb199e4b8f55b5871bfc89664acdc4d56d3;hp=43aeb2b3b7597d4d5e46dfc51b036c5868d0cda1;hb=f85e05c0b3951e7d3119983c118c82d71f2662a3;hpb=04a8d064400936dc6ecd3b137397cb2ce2cc25d7 diff --git a/send_common.c b/send_common.c index 43aeb2b3..d1dcaeb1 100644 --- a/send_common.c +++ b/send_common.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2008 Andre Noll + * Copyright (C) 2005-2009 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -62,6 +62,8 @@ static int open_sender(unsigned l4type, int port) * Close the file descriptor given by \a sc, remove it from the close-on-fork * list, destroy the chunk queue of this client, delete the client from the * list of connected clients and free the sender_client struct. + * + * \sa shutdown_clients(). */ void shutdown_client(struct sender_client *sc, struct sender_status *ss) { @@ -76,79 +78,55 @@ void shutdown_client(struct sender_client *sc, struct sender_status *ss) ss->num_clients--; } -void shutdown_clients(struct sender_status *ss) -{ - struct sender_client *sc, *tmp; - list_for_each_entry_safe(sc, tmp, &ss->client_list, node) - 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(). + * Shut down all clients connected to a paraslash sender. * - * 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. + * \param ss The sender whose clients are to be shut down. * - * \return Negative on errors, number of bytes written else. + * This just loops over all connected clients and calls shutdown_client() + * for each client. */ -static int write_nonblock(int fd, const char *buf, size_t len, - size_t max_bytes_per_write) +void shutdown_clients(struct sender_status *ss) { - 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; + struct sender_client *sc, *tmp; + list_for_each_entry_safe(sc, tmp, &ss->client_list, node) + shutdown_client(sc, ss); } static int queue_chunk_or_shutdown(struct sender_client *sc, - struct sender_status *ss, long unsigned chunk_num, - size_t sent) + struct sender_status *ss, const char *buf, size_t num_bytes) { - int ret = cq_enqueue(sc->cq, chunk_num, sent); + int ret = cq_enqueue(sc->cq, buf, num_bytes); if (ret < 0) shutdown_client(sc, ss); 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; - while ((qc = cq_peek(sc->cq))) { - char *buf; + while ((qc = cq_peek(cq))) { + 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; - cq_update(sc->cq, ret); + cq_update(cq, ret); if (ret != len) return 0; - cq_dequeue(sc->cq); + cq_dequeue(cq); } return 1; } @@ -162,29 +140,28 @@ static int send_queued_chunks(struct sender_client *sc, * \param current_chunk The number of the chunk to write. * \param buf The data to write. * \param len The number of bytes of \a buf. + * \param header_buf The audio file header. + * \param header_len The number of bytes of \a header_buf. * * On errors, the client is shut down. If only a part of the buffer could be * written, the remainder is put into the chunk queue for that client. */ void send_chunk(struct sender_client *sc, struct sender_status *ss, size_t max_bytes_per_write, long unsigned current_chunk, - const char *buf, size_t len) + const char *buf, size_t len, const char *header_buf, + size_t header_len) { int ret; if (!sc->header_sent && current_chunk) { - size_t header_len; - char *header_buf; - - vss_get_header(&header_buf, &header_len); if (header_buf && header_len > 0) { - ret = queue_chunk_or_shutdown(sc, ss, -1U, 0); + ret = queue_chunk_or_shutdown(sc, ss, header_buf, header_len); if (ret < 0) goto out; } 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; @@ -192,7 +169,7 @@ void send_chunk(struct sender_client *sc, struct sender_status *ss, if (!len) goto out; if (!ret) { /* still data left in the queue */ - ret = queue_chunk_or_shutdown(sc, ss, current_chunk, 0); + ret = queue_chunk_or_shutdown(sc, ss, buf, len); goto out; } ret = write_nonblock(sc->fd, buf, len, max_bytes_per_write); @@ -201,7 +178,7 @@ void send_chunk(struct sender_client *sc, struct sender_status *ss, goto out; } if (ret != len) - ret = queue_chunk_or_shutdown(sc, ss, current_chunk, ret); + ret = queue_chunk_or_shutdown(sc, ss, buf + ret, len - ret); out: if (ret < 0) PARA_NOTICE_LOG("%s\n", para_strerror(-ret));