Return to network_darwin_sendfile.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src

Annotation of embedaddon/lighttpd/src/network_darwin_sendfile.c, revision 1.1

1.1     ! misho       1: #include "first.h"
        !             2: 
        !             3: #include "network_backends.h"
        !             4: 
        !             5: #if defined(USE_DARWIN_SENDFILE)
        !             6: 
        !             7: #include "network.h"
        !             8: #include "log.h"
        !             9: 
        !            10: #include <sys/types.h>
        !            11: #include <sys/socket.h>
        !            12: #include <sys/uio.h>
        !            13: 
        !            14: #include <errno.h>
        !            15: #include <string.h>
        !            16: 
        !            17: int network_write_file_chunk_sendfile(server *srv, connection *con, int fd, chunkqueue *cq, off_t *p_max_bytes) {
        !            18:        chunk* const c = cq->first;
        !            19:        off_t offset, written = 0;
        !            20:        off_t toSend;
        !            21:        int r;
        !            22: 
        !            23:        force_assert(NULL != c);
        !            24:        force_assert(FILE_CHUNK == c->type);
        !            25:        force_assert(c->offset >= 0 && c->offset <= c->file.length);
        !            26: 
        !            27:        offset = c->file.start + c->offset;
        !            28:        toSend = c->file.length - c->offset;
        !            29:        if (toSend > *p_max_bytes) toSend = *p_max_bytes;
        !            30: 
        !            31:        if (0 == toSend) {
        !            32:                chunkqueue_remove_finished_chunks(cq);
        !            33:                return 0;
        !            34:        }
        !            35: 
        !            36:        if (0 != network_open_file_chunk(srv, con, cq)) return -1;
        !            37: 
        !            38:        /* Darwin sendfile() */
        !            39:        written = toSend;
        !            40:        if (-1 == (r = sendfile(c->file.fd, fd, offset, &written, NULL, 0))) {
        !            41:                switch(errno) {
        !            42:                case EAGAIN:
        !            43:                case EINTR:
        !            44:                        /* for EAGAIN/EINTR written still contains the sent bytes */
        !            45:                        break; /* try again later */
        !            46:                case EPIPE:
        !            47:                case ENOTCONN:
        !            48:                        return -2;
        !            49:                case EINVAL:
        !            50:                case ENOSYS:
        !            51:              #if defined(ENOTSUP) \
        !            52:                && (!defined(EOPNOTSUPP) || EOPNOTSUPP != ENOTSUP)
        !            53:                case ENOTSUP:
        !            54:              #endif
        !            55:              #ifdef EOPNOTSUPP
        !            56:                case EOPNOTSUPP:
        !            57:              #endif
        !            58:              #ifdef ESOCKTNOSUPPORT
        !            59:                case ESOCKTNOSUPPORT:
        !            60:              #endif
        !            61:              #ifdef EAFNOSUPPORT
        !            62:                case EAFNOSUPPORT:
        !            63:              #endif
        !            64:                      #ifdef USE_MMAP
        !            65:                        return network_write_file_chunk_mmap(srv, con, fd, cq, p_max_bytes);
        !            66:                      #else
        !            67:                        return network_write_file_chunk_no_mmap(srv, con, fd, cq, p_max_bytes);
        !            68:                      #endif
        !            69:                default:
        !            70:                        log_error_write(srv, __FILE__, __LINE__, "ssd", "sendfile: ", strerror(errno), errno);
        !            71:                        return -1;
        !            72:                }
        !            73:        }
        !            74: 
        !            75:        if (written >= 0) {
        !            76:                chunkqueue_mark_written(cq, written);
        !            77:                *p_max_bytes -= written;
        !            78:        }
        !            79: 
        !            80:        return (r >= 0 && written == toSend) ? 0 : -3;
        !            81: }
        !            82: 
        !            83: #endif /* USE_DARWIN_SENDFILE */