Return to network_write_no_mmap.c CVS log

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

Annotation of embedaddon/lighttpd/src/network_write_no_mmap.c, revision 1.1.1.1

1.1       misho       1: #include "first.h"
                      2: 
                      3: #include "network_backends.h"
                      4: 
                      5: #include "network.h"
                      6: #include "fdevent.h"
                      7: #include "log.h"
                      8: #include "stat_cache.h"
                      9: 
                     10: #include "sys-socket.h"
                     11: 
                     12: #include <sys/time.h>
                     13: #include <stdlib.h>
                     14: 
                     15: #include <fcntl.h>
                     16: #include <sys/stat.h>
                     17: #include <unistd.h>
                     18: 
                     19: #include <errno.h>
                     20: #include <string.h>
                     21: 
                     22: int network_open_file_chunk(server *srv, connection *con, chunkqueue *cq) {
                     23:        chunk* const c = cq->first;
                     24:        off_t file_size, offset, toSend;
                     25: 
                     26:        force_assert(NULL != c);
                     27:        force_assert(FILE_CHUNK == c->type);
                     28:        force_assert(c->offset >= 0 && c->offset <= c->file.length);
                     29: 
                     30:        offset = c->file.start + c->offset;
                     31:        toSend = c->file.length - c->offset;
                     32: 
                     33:        if (-1 == c->file.fd) {
                     34:                stat_cache_entry *sce = NULL;
                     35: 
                     36:                if (HANDLER_ERROR == stat_cache_get_entry(srv, con, c->file.name, &sce)) {
                     37:                        log_error_write(srv, __FILE__, __LINE__, "ssb", "stat-cache failed:", strerror(errno), c->file.name);
                     38:                        return -1;
                     39:                }
                     40: 
                     41:                if (-1 == (c->file.fd = open(c->file.name->ptr, O_RDONLY|O_NOCTTY))) {
                     42:                        log_error_write(srv, __FILE__, __LINE__, "ssb", "open failed:", strerror(errno), c->file.name);
                     43:                        return -1;
                     44:                }
                     45:                fd_close_on_exec(c->file.fd);
                     46: 
                     47:                file_size = sce->st.st_size;
                     48:        } else {
                     49:                struct stat st;
                     50:                if (-1 == fstat(c->file.fd, &st)) {
                     51:                        log_error_write(srv, __FILE__, __LINE__, "ss", "fstat failed:", strerror(errno));
                     52:                        return -1;
                     53:                }
                     54:                file_size = st.st_size;
                     55:        }
                     56: 
                     57:        if (offset > file_size || toSend > file_size || offset > file_size - toSend) {
                     58:                log_error_write(srv, __FILE__, __LINE__, "sb", "file was shrinked:", c->file.name);
                     59:                return -1;
                     60:        }
                     61: 
                     62:        return 0;
                     63: }
                     64: 
                     65: int network_write_file_chunk_no_mmap(server *srv, connection *con, int fd, chunkqueue *cq, off_t *p_max_bytes) {
                     66:        chunk* const c = cq->first;
                     67:        off_t offset, toSend;
                     68:        ssize_t r;
                     69: 
                     70:        force_assert(NULL != c);
                     71:        force_assert(FILE_CHUNK == c->type);
                     72:        force_assert(c->offset >= 0 && c->offset <= c->file.length);
                     73: 
                     74:        offset = c->file.start + c->offset;
                     75:        toSend = c->file.length - c->offset;
                     76:        if (toSend > 64*1024) toSend = 64*1024; /* max read 64kb in one step */
                     77:        if (toSend > *p_max_bytes) toSend = *p_max_bytes;
                     78: 
                     79:        if (0 == toSend) {
                     80:                chunkqueue_remove_finished_chunks(cq);
                     81:                return 0;
                     82:        }
                     83: 
                     84:        if (0 != network_open_file_chunk(srv, con, cq)) return -1;
                     85: 
                     86:        buffer_string_prepare_copy(srv->tmp_buf, toSend);
                     87: 
                     88:        if (-1 == lseek(c->file.fd, offset, SEEK_SET)) {
                     89:                log_error_write(srv, __FILE__, __LINE__, "ss", "lseek: ", strerror(errno));
                     90:                return -1;
                     91:        }
                     92:        if (-1 == (toSend = read(c->file.fd, srv->tmp_buf->ptr, toSend))) {
                     93:                log_error_write(srv, __FILE__, __LINE__, "ss", "read: ", strerror(errno));
                     94:                return -1;
                     95:        }
                     96: 
                     97: #if defined(__WIN32)
                     98:        if ((r = send(fd, srv->tmp_buf->ptr, toSend, 0)) < 0) {
                     99:                int lastError = WSAGetLastError();
                    100:                switch (lastError) {
                    101:                case WSAEINTR:
                    102:                case WSAEWOULDBLOCK:
                    103:                        break;
                    104:                case WSAECONNRESET:
                    105:                case WSAETIMEDOUT:
                    106:                case WSAECONNABORTED:
                    107:                        return -2;
                    108:                default:
                    109:                        log_error_write(srv, __FILE__, __LINE__, "sdd",
                    110:                                "send failed: ", lastError, fd);
                    111:                        return -1;
                    112:                }
                    113:        }
                    114: #else /* __WIN32 */
                    115:        if ((r = write(fd, srv->tmp_buf->ptr, toSend)) < 0) {
                    116:                switch (errno) {
                    117:                case EAGAIN:
                    118:                case EINTR:
                    119:                        break;
                    120:                case EPIPE:
                    121:                case ECONNRESET:
                    122:                        return -2;
                    123:                default:
                    124:                        log_error_write(srv, __FILE__, __LINE__, "ssd",
                    125:                                "write failed:", strerror(errno), fd);
                    126:                        return -1;
                    127:                }
                    128:        }
                    129: #endif /* __WIN32 */
                    130: 
                    131:        if (r >= 0) {
                    132:                *p_max_bytes -= r;
                    133:                chunkqueue_mark_written(cq, r);
                    134:        }
                    135: 
                    136:        return (r > 0 && r == toSend) ? 0 : -3;
                    137: }