/* Copyright 2000-2004 The Apache Software Foundation
		 *
		 * Licensed under the Apache License, Version 2.0 (the "License");
		 * you may not use this file except in compliance with the License.
		 * You may obtain a copy of the License at
		 *
		 *     http://www.apache.org/licenses/LICENSE-2.0
		 *
		 * Unless required by applicable law or agreed to in writing, software
		 * distributed under the License is distributed on an "AS IS" BASIS,
		 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		 * See the License for the specific language governing permissions and
		 * limitations under the License.
		 */
		
		#include "apr_arch_networkio.h"
		#include "apr_support.h"
		
		#if APR_HAS_SENDFILE
		/* This file is needed to allow us access to the apr_file_t internals. */
		#include "apr_arch_file_io.h"
		#endif /* APR_HAS_SENDFILE */
		
		/* sys/sysctl.h is only needed on FreeBSD for include_hdrs_in_length() */
		#if defined(__FreeBSD__) && defined(HAVE_SYS_SYSCTL_H)
		#include <sys/sysctl.h>
		#endif
		
		apr_status_t apr_socket_send(apr_socket_t *sock, const char *buf, 
		                             apr_size_t *len)
           2    {
           2        apr_ssize_t rv;
		    
           2        if (sock->options & APR_INCOMPLETE_WRITE) {
      ######            sock->options &= ~APR_INCOMPLETE_WRITE;
      ######            goto do_select;
		    }
		
           2        do {
           2            rv = write(sock->socketdes, buf, (*len));
           2        } while (rv == -1 && errno == EINTR);
		
           2        if (rv == -1 && (errno == EAGAIN || errno == EWOULDBLOCK) 
		                 && (sock->timeout > 0)) {
      ######            apr_status_t arv;
		do_select:
      ######            arv = apr_wait_for_io_or_timeout(NULL, sock, 0);
      ######            if (arv != APR_SUCCESS) {
      ######                *len = 0;
      ######                return arv;
		        }
		        else {
      ######                do {
      ######                    rv = write(sock->socketdes, buf, (*len));
      ######                } while (rv == -1 && errno == EINTR);
		        }
		    }
           2        if (rv == -1) {
      ######            *len = 0;
      ######            return errno;
		    }
           2        if ((sock->timeout > 0) && (rv < *len)) {
      ######            sock->options |= APR_INCOMPLETE_WRITE;
		    }
           2        (*len) = rv;
           2        return APR_SUCCESS;
		}
		
		apr_status_t apr_socket_recv(apr_socket_t *sock, char *buf, apr_size_t *len)
           3    {
           3        apr_ssize_t rv;
           3        apr_status_t arv;
		
           3        if (sock->options & APR_INCOMPLETE_READ) {
      ######            sock->options &= ~APR_INCOMPLETE_READ;
      ######            goto do_select;
		    }
		
           3        do {
           3            rv = read(sock->socketdes, buf, (*len));
           3        } while (rv == -1 && errno == EINTR);
		
           3        if ((rv == -1) && (errno == EAGAIN || errno == EWOULDBLOCK)
		                   && (sock->timeout > 0)) {
		do_select:
           1            arv = apr_wait_for_io_or_timeout(NULL, sock, 1);
           1            if (arv != APR_SUCCESS) {
           1                *len = 0;
           1                return arv;
		        }
		        else {
      ######                do {
      ######                    rv = read(sock->socketdes, buf, (*len));
      ######                } while (rv == -1 && errno == EINTR);
		        }
		    }
           2        if (rv == -1) {
      ######            (*len) = 0;
      ######            return errno;
		    }
           2        if ((sock->timeout > 0) && (rv < *len)) {
           1            sock->options |= APR_INCOMPLETE_READ;
		    }
           2        (*len) = rv;
           2        if (rv == 0) {
      ######            return APR_EOF;
		    }
           2        return APR_SUCCESS;
		}
		
		apr_status_t apr_socket_sendto(apr_socket_t *sock, apr_sockaddr_t *where,
		                               apr_int32_t flags, const char *buf,
		                               apr_size_t *len)
           4    {
           4        apr_ssize_t rv;
		
           4        do {
           4            rv = sendto(sock->socketdes, buf, (*len), flags, 
		                    (const struct sockaddr*)&where->sa, 
		                    where->salen);
           4        } while (rv == -1 && errno == EINTR);
		
           4        if ((rv == -1) && (errno == EAGAIN || errno == EWOULDBLOCK)
		                   && (sock->timeout > 0)) {
      ######            apr_status_t arv = apr_wait_for_io_or_timeout(NULL, sock, 0);
      ######            if (arv != APR_SUCCESS) {
      ######                *len = 0;
      ######                return arv;
		        } else {
      ######                do {
      ######                    rv = sendto(sock->socketdes, buf, (*len), flags,
		                            (const struct sockaddr*)&where->sa,
		                            where->salen);
      ######                } while (rv == -1 && errno == EINTR);
		        }
		    }
           4        if (rv == -1) {
      ######            *len = 0;
      ######            return errno;
		    }
           4        *len = rv;
           4        return APR_SUCCESS;
		}
		
		apr_status_t apr_socket_recvfrom(apr_sockaddr_t *from, apr_socket_t *sock,
		                                 apr_int32_t flags, char *buf, 
		                                 apr_size_t *len)
           4    {
           4        apr_ssize_t rv;
		
           4        do {
           4            rv = recvfrom(sock->socketdes, buf, (*len), flags, 
		                      (struct sockaddr*)&from->sa, &from->salen);
           4        } while (rv == -1 && errno == EINTR);
		
           4        if ((rv == -1) && (errno == EAGAIN || errno == EWOULDBLOCK)
		                   && (sock->timeout > 0)) {
      ######            apr_status_t arv = apr_wait_for_io_or_timeout(NULL, sock, 1);
      ######            if (arv != APR_SUCCESS) {
      ######                *len = 0;
      ######                return arv;
		        } else {
      ######                do {
      ######                    rv = recvfrom(sock->socketdes, buf, (*len), flags,
		                              (struct sockaddr*)&from->sa, &from->salen);
      ######                } while (rv == -1 && errno == EINTR);
		        }
		    }
           4        if (rv == -1) {
      ######            (*len) = 0;
      ######            return errno;
		    }
		
           4        (*len) = rv;
           4        if (rv == 0 && sock->type == SOCK_STREAM) {
      ######            return APR_EOF;
		    }
		
           4        return APR_SUCCESS;
		}
		
		#ifdef HAVE_WRITEV
		apr_status_t apr_socket_sendv(apr_socket_t * sock, const struct iovec *vec,
		                              apr_int32_t nvec, apr_size_t *len)
      ######    {
      ######        apr_ssize_t rv;
      ######        apr_size_t requested_len = 0;
      ######        apr_int32_t i;
		
      ######        for (i = 0; i < nvec; i++) {
      ######            requested_len += vec[i].iov_len;
		    }
		
      ######        if (sock->options & APR_INCOMPLETE_WRITE) {
      ######            sock->options &= ~APR_INCOMPLETE_WRITE;
      ######            goto do_select;
		    }
		
      ######        do {
      ######            rv = writev(sock->socketdes, vec, nvec);
      ######        } while (rv == -1 && errno == EINTR);
		
      ######        if ((rv == -1) && (errno == EAGAIN || errno == EWOULDBLOCK) 
		                   && (sock->timeout > 0)) {
      ######            apr_status_t arv;
		do_select:
      ######            arv = apr_wait_for_io_or_timeout(NULL, sock, 0);
      ######            if (arv != APR_SUCCESS) {
      ######                *len = 0;
      ######                return arv;
		        }
		        else {
      ######                do {
      ######                    rv = writev(sock->socketdes, vec, nvec);
      ######                } while (rv == -1 && errno == EINTR);
		        }
		    }
      ######        if (rv == -1) {
      ######            *len = 0;
      ######            return errno;
		    }
      ######        if ((sock->timeout > 0) && (rv < requested_len)) {
      ######            sock->options |= APR_INCOMPLETE_WRITE;
		    }
      ######        (*len) = rv;
      ######        return APR_SUCCESS;
		}
		#endif
		
		#if APR_HAS_SENDFILE
		
		/* TODO: Verify that all platforms handle the fd the same way,
		 * i.e. that they don't move the file pointer.
		 */
		/* TODO: what should flags be?  int_32? */
		
		/* Define a structure to pass in when we have a NULL header value */
		static apr_hdtr_t no_hdtr;
		
		#if defined(__linux__) && defined(HAVE_WRITEV)
		
		apr_status_t apr_socket_sendfile(apr_socket_t *sock, apr_file_t *file,
		                                 apr_hdtr_t *hdtr, apr_off_t *offset,
		                                 apr_size_t *len, apr_int32_t flags)
      ######    {
      ######        off_t off = *offset;
      ######        int rv, nbytes = 0, total_hdrbytes, i;
      ######        apr_status_t arv;
		
      ######        if (!hdtr) {
      ######            hdtr = &no_hdtr;
		    }
		
		    /* Ignore flags for now. */
      ######        flags = 0;
		
      ######        if (hdtr->numheaders > 0) {
      ######            apr_size_t hdrbytes;
		
		        /* cork before writing headers */
      ######            rv = apr_socket_opt_set(sock, APR_TCP_NOPUSH, 1);
      ######            if (rv != APR_SUCCESS) {
      ######                return rv;
		        }
		
		        /* Now write the headers */
      ######            arv = apr_socket_sendv(sock, hdtr->headers, hdtr->numheaders,
		                               &hdrbytes);
      ######            if (arv != APR_SUCCESS) {
      ######                *len = 0;
      ######                return errno;
		        }
      ######            nbytes += hdrbytes;
		
		        /* If this was a partial write and we aren't doing timeouts, 
		         * return now with the partial byte count; this is a non-blocking 
		         * socket.
		         */
      ######            total_hdrbytes = 0;
      ######            for (i = 0; i < hdtr->numheaders; i++) {
      ######                total_hdrbytes += hdtr->headers[i].iov_len;
		        }
      ######            if (hdrbytes < total_hdrbytes) {
      ######                *len = hdrbytes;
      ######                return apr_socket_opt_set(sock, APR_TCP_NOPUSH, 0);
		        }
		    }
		
      ######        if (sock->options & APR_INCOMPLETE_WRITE) {
      ######            sock->options &= ~APR_INCOMPLETE_WRITE;
      ######            goto do_select;
		    }
		
      ######        do {
      ######            rv = sendfile(sock->socketdes,    /* socket */
		                      file->filedes, /* open file descriptor of the file to be sent */
		                      &off,    /* where in the file to start */
		                      *len);   /* number of bytes to send */
      ######        } while (rv == -1 && errno == EINTR);
		
      ######        if ((rv == -1) && 
(errno == EAGAIN || errno == EWOULDBLOCK) 
		                   && (sock->timeout > 0)) {
		do_select:
		        arv = apr_wait_for_io_or_timeout(NULL, sock, 0);
      ######            if (arv != APR_SUCCESS) {
      ######                *len = 0;
      ######                return arv;
      ######            }
		        else {
		            do {
      ######                    rv = sendfile(sock->socketdes,    /* socket */
      ######                                  file->filedes, /* open file descriptor of the file to be sent */
		                              &off,    /* where in the file to start */
		                              *len);    /* number of bytes to send */
		            } while (rv == -1 && errno == EINTR);
      ######            }
		    }
		
		    if (rv == -1) {
      ######            *len = nbytes;
      ######            rv = errno;
      ######            apr_socket_opt_set(sock, APR_TCP_NOPUSH, 0);
      ######            return rv;
      ######        }
		
		    nbytes += rv;
      ######    
		    if (rv < *len) {
      ######            *len = nbytes;
      ######            arv = apr_socket_opt_set(sock, APR_TCP_NOPUSH, 0);
      ######            if (rv > 0) {
      ######                    
		            /* If this was a partial write, return now with the 
		             * partial byte count;  this is a non-blocking socket.
		             */
		
		            if (sock->timeout > 0) {
      ######                    sock->options |= APR_INCOMPLETE_WRITE;
      ######                }
		            return arv;
      ######            }
		        else {
		            /* If the file got smaller mid-request, eventually the offset
		             * becomes equal to the new file size and the kernel returns 0.  
		             * Make this an error so the caller knows to log something and
		             * exit.
		             */
		            return APR_EOF;
      ######            }
		    }
		
		    /* Now write the footers */
		    if (hdtr->numtrailers > 0) {
      ######            apr_size_t trbytes;
      ######            arv = apr_socket_sendv(sock, hdtr->trailers, hdtr->numtrailers, 
      ######                                   &trbytes);
		        nbytes += trbytes;
      ######            if (arv != APR_SUCCESS) {
      ######                *len = nbytes;
      ######                rv = errno;
      ######                apr_socket_opt_set(sock, APR_TCP_NOPUSH, 0);
      ######                return rv;
      ######            }
		    }
		
		    apr_socket_opt_set(sock, APR_TCP_NOPUSH, 0);
      ######        
		    (*len) = nbytes;
      ######        return rv < 0 ? errno : APR_SUCCESS;
      ######    }
		
		#elif defined(__FreeBSD__)
		
		static int include_hdrs_in_length(void)
		{
		#ifdef HAVE_SYS_SYSCTL_H
		/* this assumes: 
		 *   if the header exists, so does the sysctlbyname() syscall, and 
		 *   if the header doesn't exist, the kernel is really old
		 */
		
		/* see 
		 * http://www.freebsd.org/cgi/cvsweb.cgi/src/sys/sys/param.h#rev1.61.2.29 
		 * for kernel version number
		 * 
		 * http://www.freebsd.org/cgi/cvsweb.cgi/src/sys/kern/uipc_syscalls.c#rev1.65.2.10
		 * for the sendfile patch
		 */
		#define KERNEL_WITH_SENDFILE_LENGTH_FIX 460001
		
		    typedef enum { UNKNOWN = 0, 
		                   NEW, 
		                   OLD 
		                 } api_e;
		
		    static api_e api; 
		    int kernel_version;  
		    apr_size_t kernel_version_size;
		
		    if (api != UNKNOWN) {
		        return (api == OLD);
		    }
		    kernel_version = 0;    /* silence compiler warning */
		    kernel_version_size = sizeof(kernel_version);
		    if (sysctlbyname("kern.osreldate", &kernel_version, 
		                     &kernel_version_size, NULL, NULL) == 0 &&
		        kernel_version < KERNEL_WITH_SENDFILE_LENGTH_FIX) {
		        api = OLD;
		        return 1;
		    }
		    /* size of kern.osreldate's output might change in the future 
		     * causing the sysctlbyname to fail,
		     * but if it's the future, we should use the newer API 
		     */
		    api = NEW;
		    return 0;
		#else
		    /* the build system's kernel is older than 3.4.  Use the old API */
		    return 1;
		#endif
		}
		
		/* Release 3.1 or greater */
		apr_status_t apr_socket_sendfile(apr_socket_t * sock, apr_file_t * file,
		                                 apr_hdtr_t * hdtr, apr_off_t * offset,
		                                 apr_size_t * len, apr_int32_t flags)
		{
		    off_t nbytes = 0;
		    int rv, i;
		    struct sf_hdtr headerstruct;
		    apr_size_t bytes_to_send = *len;
		
		    /* Ignore flags for now. */
		    flags = 0;
		
		    if (!hdtr) {
		        hdtr = &no_hdtr;
		    }
		
		    else if (hdtr->numheaders && include_hdrs_in_length()) {
		
		        /* On early versions of FreeBSD sendfile, the number of bytes to send 
		         * must include the length of the headers.  Don't look at the man page 
		         * for this :(  Instead, look at the the logic in 
		         * src/sys/kern/uipc_syscalls::sendfile().
		         *
		         * This was fixed in the middle of 4.6-STABLE
		         */
		        for (i = 0; i < hdtr->numheaders; i++) {
		            bytes_to_send += hdtr->headers[i].iov_len;
		        }
		    }
		
		    headerstruct.headers = hdtr->headers;
		    headerstruct.hdr_cnt = hdtr->numheaders;
		    headerstruct.trailers = hdtr->trailers;
		    headerstruct.trl_cnt = hdtr->numtrailers;
		
		    /* FreeBSD can send the headers/footers as part of the system call */
		    do {
		        if (sock->options & APR_INCOMPLETE_WRITE) {
		            apr_status_t arv;
		            sock->options &= ~APR_INCOMPLETE_WRITE;
		            arv = apr_wait_for_io_or_timeout(NULL, sock, 0);
		            if (arv != APR_SUCCESS) {
		                *len = 0;
		                return arv;
		            }
		        }
		        if (bytes_to_send) {
		            /* We won't dare call sendfile() if we don't have
		             * header or file bytes to send because bytes_to_send == 0
		             * means send the whole file.
		             */
		            rv = sendfile(file->filedes, /* file to be sent */
		                          sock->socketdes, /* socket */
		                          *offset,       /* where in the file to start */
		                          bytes_to_send, /* number of bytes to send */
		                          &headerstruct, /* Headers/footers */
		                          &nbytes,       /* number of bytes written */
		                          flags);        /* undefined, set to 0 */
		
		            if (rv == -1) {
		                if (errno == EAGAIN) {
		                    if (sock->timeout > 0) {
		                        sock->options |= APR_INCOMPLETE_WRITE;
		                    }
		                    /* FreeBSD's sendfile can return -1/EAGAIN even if it
		                     * sent bytes.  Sanitize the result so we get normal EAGAIN
		                     * semantics w.r.t. bytes sent.
		                     */
		                    if (nbytes) {
		                        /* normal exit for a big file & non-blocking io */
		                        (*len) = nbytes;
		                        return APR_SUCCESS;
		                    }
		                }
		            }
		            else {       /* rv == 0 (or the kernel is broken) */
		                if (nbytes == 0) {
		                    /* Most likely the file got smaller after the stat.
		                     * Return an error so the caller can do the Right Thing.
		                     */
		                    (*len) = nbytes;
		                    return APR_EOF;
		                }
		            }
		        }    
		        else {
		            /* just trailer bytes... use writev()
		             */
		            rv = writev(sock->socketdes,
		                        hdtr->trailers,
		                        hdtr->numtrailers);
		            if (rv > 0) {
		                nbytes = rv;
		                rv = 0;
		            }
		            else {
		                nbytes = 0;
		            }
		        }
		        if ((rv == -1) && (errno == EAGAIN) 
		                       && (sock->timeout > 0)) {
		            apr_status_t arv = apr_wait_for_io_or_timeout(NULL, sock, 0);
		            if (arv != APR_SUCCESS) {
		                *len = 0;
		                return arv;
		            }
		        }
		    } while (rv == -1 && (errno == EINTR || errno == EAGAIN));
		
		    (*len) = nbytes;
		    if (rv == -1) {
		        return errno;
		    }
		    return APR_SUCCESS;
		}
		
		#elif defined(__hpux) || defined(__hpux__)
		
		/* HP cc in ANSI mode defines __hpux; gcc defines __hpux__ */
		
		/* HP-UX Version 10.30 or greater
		 * (no worries, because we only get here if autoconfiguration found sendfile)
		 */
		
		/* ssize_t sendfile(int s, int fd, off_t offset, size_t nbytes,
		 *                  const struct iovec *hdtrl, int flags);
		 *
		 * nbytes is the number of bytes to send just from the file; as with FreeBSD, 
		 * if nbytes == 0, the rest of the file (from offset) is sent
		 */
		
		apr_status_t apr_socket_sendfile(apr_socket_t *sock, apr_file_t *file,
		                                 apr_hdtr_t *hdtr, apr_off_t *offset,
		                                 apr_size_t *len, apr_int32_t flags)
		{
		    int i;
		    apr_ssize_t rc;
		    apr_size_t nbytes = *len, headerlen, trailerlen;
		    struct iovec hdtrarray[2];
		    char *headerbuf, *trailerbuf;
		
		    if (!hdtr) {
		        hdtr = &no_hdtr;
		    }
		
		    /* Ignore flags for now. */
		    flags = 0;
		
		    /* HP-UX can only send one header iovec and one footer iovec; try to
		     * only allocate storage to combine input iovecs when we really have to
		     */
		
		    switch(hdtr->numheaders) {
		    case 0:
		        hdtrarray[0].iov_base = NULL;
		        hdtrarray[0].iov_len = 0;
		        break;
		    case 1:
		        hdtrarray[0] = hdtr->headers[0];
		        break;
		    default:
		        headerlen = 0;
		        for (i = 0; i < hdtr->numheaders; i++) {
		            headerlen += hdtr->headers[i].iov_len;
		        }  
		
		        /* XXX:  BUHHH? wow, what a memory leak! */
		        headerbuf = hdtrarray[0].iov_base = apr_palloc(sock->cntxt, headerlen);
		        hdtrarray[0].iov_len = headerlen;
		
		        for (i = 0; i < hdtr->numheaders; i++) {
		            memcpy(headerbuf, hdtr->headers[i].iov_base,
		                   hdtr->headers[i].iov_len);
		            headerbuf += hdtr->headers[i].iov_len;
		        }
		    }
		
		    switch(hdtr->numtrailers) {
		    case 0:
		        hdtrarray[1].iov_base = NULL;
		        hdtrarray[1].iov_len = 0;
		        break;
		    case 1:
		        hdtrarray[1] = hdtr->trailers[0];
		        break;
		    default:
		        trailerlen = 0;
		        for (i = 0; i < hdtr->numtrailers; i++) {
		            trailerlen += hdtr->trailers[i].iov_len;
		        }
		
		        /* XXX:  BUHHH? wow, what a memory leak! */
		        trailerbuf = hdtrarray[1].iov_base = apr_palloc(sock->cntxt, trailerlen);
		        hdtrarray[1].iov_len = trailerlen;
		
		        for (i = 0; i < hdtr->numtrailers; i++) {
		            memcpy(trailerbuf, hdtr->trailers[i].iov_base,
		                   hdtr->trailers[i].iov_len);
		            trailerbuf += hdtr->trailers[i].iov_len;
		        }
		    }
		
		    do {
		        if (nbytes) {       /* any bytes to send from the file? */
		            rc = sendfile(sock->socketdes,      /* socket  */
		                          file->filedes,        /* file descriptor to send */
		                          *offset,              /* where in the file to start */
		                          nbytes,               /* number of bytes to send from file */
		                          hdtrarray,            /* Headers/footers */
		                          flags);               /* undefined, set to 0 */
		        }
		        else {              /* we can't call sendfile() with no bytes to send from the file */
		            rc = writev(sock->socketdes, hdtrarray, 2);
		        }
		    } while (rc == -1 && errno == EINTR);
		
		    if ((rc == -1) && (errno == EAGAIN || errno == EWOULDBLOCK) 
		                   && (sock->timeout > 0)) {
		        apr_status_t arv = apr_wait_for_io_or_timeout(NULL, sock, 0);
		
		        if (arv != APR_SUCCESS) {
		            *len = 0;
		            return arv;
		        }
		        else {
		            do {
		                if (nbytes) {
		                    rc = sendfile(sock->socketdes,    /* socket  */
		                                  file->filedes,      /* file descriptor to send */
		                                  *offset,            /* where in the file to start */
		                                  nbytes,             /* number of bytes to send from file */
		                                  hdtrarray,          /* Headers/footers */
		                                  flags);             /* undefined, set to 0 */
		                }
		                else {      /* we can't call sendfile() with no bytes to send from the file */
		                    rc = writev(sock->socketdes, hdtrarray, 2);
		                }
		            } while (rc == -1 && errno == EINTR);
		        }
		    }
		
		    if (rc == -1) {
		        *len = 0;
		        return errno;
		    }
		
		    /* Set len to the number of bytes written */
		    *len = rc;
		    return APR_SUCCESS;
		}
		#elif defined(_AIX) || defined(__MVS__)
		/* AIX and OS/390 have the same send_file() interface.
		 *
		 * subtle differences:
		 *   AIX doesn't update the file ptr but OS/390 does
		 *
		 * availability (correctly determined by autoconf):
		 *
		 * AIX -  version 4.3.2 with APAR IX85388, or version 4.3.3 and above
		 * OS/390 - V2R7 and above
		 */
		apr_status_t apr_socket_sendfile(apr_socket_t * sock, apr_file_t * file,
		                                 apr_hdtr_t * hdtr, apr_off_t * offset,
		                                 apr_size_t * len, apr_int32_t flags)
		{
		    int i, ptr, rv = 0;
		    void * hbuf=NULL, * tbuf=NULL;
		    apr_status_t arv;
		    struct sf_parms parms;
		
		    if (!hdtr) {
		        hdtr = &no_hdtr;
		    }
		
		    /* Ignore flags for now. */
		    flags = 0;
		
		    /* word to the wise: by default, AIX stores files sent by send_file()
		     * in the network buffer cache...  there are supposedly scenarios
		     * where the most recent copy of the file won't be sent, but I can't
		     * recreate the potential problem, perhaps because of the way we
		     * use send_file()...  if you suspect such a problem, try turning
		     * on the SF_SYNC_CACHE flag
		     */
		
		    /* AIX can also send the headers/footers as part of the system call */
		    parms.header_length = 0;
		    if (hdtr && hdtr->numheaders) {
		        if (hdtr->numheaders == 1) {
		            parms.header_data = hdtr->headers[0].iov_base;
		            parms.header_length = hdtr->headers[0].iov_len;
		        }
		        else {
		            for (i = 0; i < hdtr->numheaders; i++) {
		                parms.header_length += hdtr->headers[i].iov_len;
		            }
		#if 0
		            /* Keepalives make apr_palloc a bad idea */
		            hbuf = malloc(parms.header_length);
		#else
		            /* but headers are small, so maybe we can hold on to the
		             * memory for the life of the socket...
		             */
		            hbuf = apr_palloc(sock->cntxt, parms.header_length);
		#endif
		            ptr = 0;
		            for (i = 0; i < hdtr->numheaders; i++) {
		                memcpy((char *)hbuf + ptr, hdtr->headers[i].iov_base,
		                       hdtr->headers[i].iov_len);
		                ptr += hdtr->headers[i].iov_len;
		            }
		            parms.header_data = hbuf;
		        }
		    }
		    else parms.header_data = NULL;
		    parms.trailer_length = 0;
		    if (hdtr && hdtr->numtrailers) {
		        if (hdtr->numtrailers == 1) {
		            parms.trailer_data = hdtr->trailers[0].iov_base;
		            parms.trailer_length = hdtr->trailers[0].iov_len;
		        }
		        else {
		            for (i = 0; i < hdtr->numtrailers; i++) {
		                parms.trailer_length += hdtr->trailers[i].iov_len;
		            }
		#if 0
		            /* Keepalives make apr_palloc a bad idea */
		            tbuf = malloc(parms.trailer_length);
		#else
		            tbuf = apr_palloc(sock->cntxt, parms.trailer_length);
		#endif
		            ptr = 0;
		            for (i = 0; i < hdtr->numtrailers; i++) {
		                memcpy((char *)tbuf + ptr, hdtr->trailers[i].iov_base,
		                       hdtr->trailers[i].iov_len);
		                ptr += hdtr->trailers[i].iov_len;
		            }
		            parms.trailer_data = tbuf;
		        }
		    }
		    else {
		        parms.trailer_data = NULL;
		    }
		
		    /* Whew! Headers and trailers set up. Now for the file data */
		
		    parms.file_descriptor = file->filedes;
		    parms.file_offset = *offset;
		    parms.file_bytes = *len;
		
		    /* O.K. All set up now. Let's go to town */
		
		    if (sock->options & APR_INCOMPLETE_WRITE) {
		        sock->options &= ~APR_INCOMPLETE_WRITE;
		        goto do_select;
		    }
		
		    do {
		        rv = send_file(&(sock->socketdes), /* socket */
		                       &(parms),           /* all data */
		                       flags);             /* flags */
		    } while (rv == -1 && errno == EINTR);
		
		    if ((rv == -1) && (errno == EAGAIN || errno == EWOULDBLOCK) 
		                   && (sock->timeout > 0)) {
		do_select:
		        arv = apr_wait_for_io_or_timeout(NULL, sock, 0);
		        if (arv != APR_SUCCESS) {
		            *len = 0;
		            return arv;
		        }
		        else {
		            do {
		                rv = send_file(&(sock->socketdes), /* socket */
		                               &(parms),           /* all data */
		                               flags);             /* flags */
		            } while (rv == -1 && errno == EINTR);
		        }
		    }
		
		    (*len) = parms.bytes_sent;
		
		#if 0
		    /* Clean up after ourselves */
		    if(hbuf) free(hbuf);
		    if(tbuf) free(tbuf);
		#endif
		
		    if (rv == -1) {
		        return errno;
		    }
		
		    if ((sock->timeout > 0)
		          && (parms.bytes_sent 
		                < (parms.file_bytes + parms.header_length + parms.trailer_length))) {
		        sock->options |= APR_INCOMPLETE_WRITE;
		    }
		
		    return APR_SUCCESS;
		}
		#elif defined(__osf__) && defined (__alpha)
		/* Tru64's sendfile implementation doesn't work, and we need to make sure that
		 * we don't use it until it is fixed.  If it is used as it is now, it will
		 * hang the machine and the only way to fix it is a reboot.
		 */
		#elif defined(HAVE_SENDFILEV)
		/* Solaris 8's sendfilev() interface 
		 *
		 * SFV_FD_SELF refers to our memory space.
		 *
		 * Required Sparc patches (or newer):
		 * 111297-01, 108528-09, 109472-06, 109234-03, 108995-02, 111295-01, 109025-03,
		 * 108991-13
		 * Required x86 patches (or newer):
		 * 111298-01, 108529-09, 109473-06, 109235-04, 108996-02, 111296-01, 109026-04,
		 * 108992-13
		 */
		apr_status_t apr_socket_sendfile(apr_socket_t *sock, apr_file_t *file,
		                                 apr_hdtr_t *hdtr, apr_off_t *offset,
		                                 apr_size_t *len, apr_int32_t flags)
		{
		    apr_status_t rv, arv;
		    apr_size_t nbytes;
		    sendfilevec_t *sfv;
		    int vecs, curvec, i, repeat;
		    apr_size_t requested_len = 0;
		
		    if (!hdtr) {
		        hdtr = &no_hdtr;
		    }
		
		    /* Ignore flags for now. */
		    flags = 0;
		
		    /* Calculate how much space we need. */
		    vecs = hdtr->numheaders + hdtr->numtrailers + 1;
		    sfv = apr_palloc(sock->cntxt, sizeof(sendfilevec_t) * vecs);
		
		    curvec = 0;
		
		    /* Add the headers */
		    for (i = 0; i < hdtr->numheaders; i++, curvec++) {
		        sfv[curvec].sfv_fd = SFV_FD_SELF;
		        sfv[curvec].sfv_flag = 0;
		        sfv[curvec].sfv_off = (off_t)hdtr->headers[i].iov_base;
		        sfv[curvec].sfv_len = hdtr->headers[i].iov_len;
		        requested_len += sfv[curvec].sfv_len;
		    }
		
		    /* If the len is 0, we skip the file. */
		    if (*len)
		    {
		        sfv[curvec].sfv_fd = file->filedes;
		        sfv[curvec].sfv_flag = 0;
		        sfv[curvec].sfv_off = *offset;
		        sfv[curvec].sfv_len = *len; 
		        requested_len += sfv[curvec].sfv_len;
		
		        curvec++;
		    }
		    else {
		        vecs--;
		    }
		
		    /* Add the footers */
		    for (i = 0; i < hdtr->numtrailers; i++, curvec++) {
		        sfv[curvec].sfv_fd = SFV_FD_SELF;
		        sfv[curvec].sfv_flag = 0;
		        sfv[curvec].sfv_off = (off_t)hdtr->trailers[i].iov_base;
		        sfv[curvec].sfv_len = hdtr->trailers[i].iov_len;
		        requested_len += sfv[curvec].sfv_len;
		    }
		
		    /* If the last write couldn't send all the requested data,
		     * wait for the socket to become writable before proceeding
		     */
		    if (sock->options & APR_INCOMPLETE_WRITE) {
		        sock->options &= ~APR_INCOMPLETE_WRITE;
		        arv = apr_wait_for_io_or_timeout(NULL, sock, 0);
		        if (arv != APR_SUCCESS) {
		            *len = 0;
		            return arv;
		        }
		    }
		 
		    /* Actually do the sendfilev
		     *
		     * Solaris may return -1/EAGAIN even if it sent bytes on a non-block sock.
		     *
		     * If no bytes were originally sent (nbytes == 0) and we are on a TIMEOUT 
		     * socket (which as far as the OS is concerned is a non-blocking socket), 
		     * we want to retry after waiting for the other side to read the data (as 
		     * determined by poll).  Once it is clear to send, we want to retry
		     * sending the sendfilevec_t once more.
		     */
		    arv = 0;
		    do {
		        /* Clear out the repeat */
		        repeat = 0;
		
		        /* socket, vecs, number of vecs, bytes written */
		        rv = sendfilev(sock->socketdes, sfv, vecs, &nbytes);
		
		        if (rv == -1 && errno == EAGAIN) {
		            if (nbytes) {
		                rv = 0;
		            }
		            else if (!arv && (sock->timeout > 0)) {
		                apr_status_t t = apr_wait_for_io_or_timeout(NULL, sock, 0);
		
		                if (t != APR_SUCCESS) {
		                    *len = 0;
		                    return t;
		                }
		
		                arv = 1; 
		                repeat = 1;
		            }
		        }
		    } while ((rv == -1 && errno == EINTR) || repeat);
		
		    if (rv == -1) {
		        *len = 0;
		        return errno;
		    }
		
		    /* Update how much we sent */
		    *len = nbytes;
		    if ((sock->timeout > 0) && (*len < requested_len)) {
		        sock->options |= APR_INCOMPLETE_WRITE;
		    }
		    return APR_SUCCESS;
		}
		#else
		#error APR has detected sendfile on your system, but nobody has written a
		#error version of it for APR yet.  To get past this, either write 
		#error apr_socket_sendfile or change APR_HAS_SENDFILE in apr.h to 0.
		#endif /* __linux__, __FreeBSD__, __HPUX__, _AIX, __MVS__, Tru64/OSF1 */
		
		#endif /* APR_HAS_SENDFILE */