Add Sendfile to APR. This is not well tested, and a test case is needed.

I did some minor cleanup work, mainly to integrate sendfile into the APR
autoconf stuff.
Submitted by:	John Zedlewski
Reviewed by:    Ryan Bloom


git-svn-id: http://svn.apache.org/repos/asf/apr/apr/trunk@59503 13f79535-47bb-0310-9956-ffa450edef68

2 files changed, 386 insertions, 0 deletions

diff --git a/network_io/unix/networkio.h b/network_io/unix/networkio.h
index 2cb64086f..d64a11d60 100644
--- a/network_io/unix/networkio.h
+++ b/network_io/unix/networkio.h
@@ -62,6 +62,12 @@
 #include "apr_lib.h"
 
 /* System headers the network I/O library needs */
+#if HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#if HAVE_SYS_UIO_H
+#include <sys/uio.h>
+#endif
 #if HAVE_POLL_H
 #include <poll.h>
 #endif
diff --git a/network_io/unix/sendrecv.c b/network_io/unix/sendrecv.c
index 1db9178bd..15d3c8d2d 100644
--- a/network_io/unix/sendrecv.c
+++ b/network_io/unix/sendrecv.c
@@ -57,6 +57,19 @@
 
 #include "networkio.h"
 
+#ifdef HAVE_SENDFILE
+/* This file is needed to allow us access to the ap_file_t internals. */
+#include "../../file_io/unix/fileio.h"
+
+/* Glibc2.1.1 fails to define TCP_CORK.  This is a bug that will be 
+ *fixed in the next release.  It should be 3
+ */
+#if !defined(TCP_CORK) && defined(__linux__)
+#define TCP_CORK 3
+#endif
+
+#endif /* HAVE_SENDFILE */
+
 /* ***APRDOC********************************************************
  * ap_status_t ap_send(ap_socket_t *, const char *, ap_ssize_t *, time_t)
  *    Send data over a network.
@@ -172,3 +185,370 @@ ap_status_t ap_recv(struct socket_t *sock, char *buf, ap_ssize_t *len)
     return APR_SUCCESS;
 }
 
+/* ***APRDOC********************************************************
+ * ap_status_t ap_sendv(ap_socket_t *, const struct iovec *, ap_int32_t, ap_int32_t *)
+ *    Send multiple packets of data over a network.
+ * arg 1) The socket to send the data over.
+ * arg 2) The array of iovec structs containing the data to send 
+ * arg 3) The number of iovec structs in the array
+ * arg 4) Receives the number of bytes actually written
+ * NOTE:  This functions acts like a blocking write by default.  To change 
+ *        this behavior, use ap_setsocketopt with the APR_SO_TIMEOUT option.
+ *        The number of bytes actually sent is stored in argument 3.
+ */
+ap_status_t ap_sendv(struct socket_t * sock, const struct iovec * vec,
+                     ap_int32_t nvec, ap_int32_t * nbytes)
+{
+    ssize_t rv;
+
+    do {
+        rv = writev(sock->socketdes, vec, nvec);
+    } while (rv == -1 && errno == EINTR);
+
+    if (rv == -1 && errno == EAGAIN && sock->timeout != 0) {
+        struct timeval *tv;
+        fd_set fdset;
+        int srv;
+
+        do {
+            FD_ZERO(&fdset);
+            FD_SET(sock->socketdes, &fdset);
+            if (sock->timeout < 0) {
+        	tv = NULL;
+            }
+            else {
+        	tv = ap_palloc(sock->cntxt, sizeof(struct timeval));
+        	tv->tv_sec = sock->timeout;
+        	tv->tv_usec = 0;
+            }
+            srv = select(FD_SETSIZE, NULL, &fdset, NULL, tv);
+        } while (srv == -1 && errno == EINTR);
+
+        if (srv == 0) {
+            (*nbytes) = -1;
+            return APR_TIMEUP;
+        }
+        else if (srv < 0) {
+            (*nbytes) = -1;
+            return errno;
+        }
+        else {
+            do {
+        	rv = writev(sock->socketdes, vec, nvec);
+            } while (rv == -1 && errno == EINTR);
+        }
+    }
+    (*nbytes) = rv;
+    return APR_SUCCESS;
+}
+
+#if defined(HAVE_SENDFILE)
+/* ***APRDOC********************************************************
+ * ap_status_t ap_sendfile(ap_socket_t *, ap_file_t *, ap_hdtr_t *, 
+ *                         ap_off_t *, ap_size_t *, ap_int32_t flags)
+ *    Send a file from an open file descriptor to a socket, along with 
+ *    optional headers and trailers
+ * arg 1) The socket to which we're writing
+ * arg 2) The open file from which to read
+ * arg 3) A structure containing the headers and trailers to send
+ * arg 4) Offset into the file where we should begin writing
+ * arg 5) Number of bytes to send 
+ * arg 6) OS-specific flags to pass to sendfile()
+ * NOTE:  This functions acts like a blocking write by default.  To change 
+ *        this behavior, use ap_setsocketopt with the APR_SO_TIMEOUT option.
+ *        The number of bytes actually sent is stored in argument 4.
+ */
+
+ /* TODO: Verify that all platforms handle the fd the same way 
+  *     (i.e. not moving current file pointer)
+  *     - Should flags be an int_32 or what?
+  */
+
+#if defined(__linux__) && defined(HAVE_WRITEV)
+ap_status_t ap_sendfile(ap_socket_t * sock, ap_file_t * file,
+        		ap_hdtr_t * hdtr, ap_off_t * offset, ap_size_t * len,
+        		ap_int32_t flags)
+{
+    off_t off = *offset;
+    int corkflag = 1;
+    int rv, nbytes = 0;
+
+    /* TCP_CORK keeps us from sending partial frames when we shouldn't */
+    rv = setsockopt(sock->socketdes, SOL_TCP, TCP_CORK,
+        	    (const void *) &corkflag, sizeof(corkflag));
+    if (rv == -1) {
+        return errno;
+    }
+
+    /* Now write the headers */
+    if (hdtr->numheaders > 0) {
+        ap_int32_t hdrbytes;
+        rv = ap_sendv(sock, hdtr->headers, hdtr->numheaders, &hdrbytes);
+        if (rv != APR_SUCCESS) {
+            return errno;
+        }
+        nbytes += hdrbytes;
+    }
+
+    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 && sock->timeout != 0) {
+        struct timeval *tv;
+        fd_set fdset;
+        int srv;
+        do {
+            FD_ZERO(&fdset);
+            FD_SET(sock->socketdes, &fdset);
+            if (sock->timeout < 0) {
+        	tv = NULL;
+            }
+            else {
+        	tv = ap_palloc(sock->cntxt, sizeof(struct timeval));
+        	tv->tv_sec = sock->timeout;
+        	tv->tv_usec = 0;
+            }
+            srv = select(FD_SETSIZE, NULL, &fdset, NULL, tv);
+        } while (srv == -1 && errno == EINTR);
+
+        if (srv == 0) {
+            (*len) = -1;
+            return APR_TIMEUP;
+        }
+        else if (srv < 0) {
+            (*len) = -1;
+            return errno;
+        }
+        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) {
+        return errno;
+    }
+
+    nbytes += rv;
+
+    /* Now write the footers */
+    if (hdtr->numtrailers > 0) {
+        ap_int32_t trbytes;
+        rv = ap_sendv(sock, hdtr->trailers, hdtr->numtrailers, &trbytes);
+        if (rv == -1) {
+            return errno;
+        }
+        nbytes += trbytes;
+    }
+
+    /* Uncork to send queued frames */
+    corkflag = 0;
+    rv = setsockopt(sock->socketdes, SOL_TCP, TCP_CORK,
+                    (const void *) &corkflag, sizeof(corkflag));
+
+    (*len) = nbytes;
+    return APR_SUCCESS;
+}
+
+/* These are just demos of how the code for the other OSes.
+ * I haven't tested these, but they're right in terms of interface.
+ * I just wanted to see what types of vars would be required from other OSes. 
+ */
+
+#elif defined(__FreeBSD__)
+/* Release 3.1 or greater */
+ap_status_t ap_sendfile(ap_socket_t * sock, ap_file_t * file,
+        		ap_hdtr_t * hdtr, ap_off_t * offset, ap_size_t * len,
+        		ap_int32_t flags)
+{
+    off_t nbytes;
+    int rv;
+    struct sf_hdtr headerstruct;
+
+    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 {
+        rv = sendfile(file->filedes,	/* open file descriptor of the file to be sent */
+        	      sock->socketdes,	/* socket */
+        	      *offset,	/* where in the file to start */
+        	      (size_t) * len,	/* number of bytes to send */
+        	      &headerstruct,	/* Headers/footers */
+        	      &nbytes,	/* number of bytes written */
+        	      flags	/* undefined, set to 0 */
+            );
+    } while (rv == -1 && errno == EINTR);
+
+    if (rv == -1 && errno == EAGAIN && sock->timeout != 0) {
+        struct timeval *tv;
+        fd_set fdset;
+        int srv;
+
+        do {
+            FD_ZERO(&fdset);
+            FD_SET(sock->socketdes, &fdset);
+            if (sock->timeout < 0) {
+        	tv = NULL;
+            }
+            else {
+        	tv = ap_palloc(sock->cntxt, sizeof(struct timeval));
+        	tv->tv_sec = sock->timeout;
+        	tv->tv_usec = 0;
+            }
+            srv = select(FD_SETSIZE, NULL, &fdset, NULL, tv);
+        } while (srv == -1 && errno == EINTR);
+
+        if (srv == 0) {
+            (*len) = -1;
+            return APR_TIMEUP;
+        }
+        else if (srv < 0) {
+            (*len) = -1;
+            return errno;
+        }
+        else {
+            do {
+        	rv = sendfile(file->filedes,	/* open file descriptor of the file to be sent */
+        		      sock->socketdes,	/* socket */
+        		      *offset,	/* where in the file to start */
+        		      (size_t) * len,	/* number of bytes to send */
+        		      &headerstruct,	/* Headers/footers */
+        		      &nbytes,	/* number of bytes written */
+        		      flags	/* undefined, set to 0 */
+        	    );
+            } while (rv == -1 && errno == EINTR);
+        }
+    }
+
+
+    if (rv == -1) {
+        return errno;
+    }
+
+    (*len) = nbytes;
+    return APR_SUCCESS;
+}
+
+#elif defined(__HPUX__)
+
+/* HP-UX Version 10.30 or greater */
+ap_status_t ap_sendfile(ap_socket_t * sock, ap_file_t * file,
+        		ap_hdtr_t * hdtr, ap_off_t * offset, ap_size_t * len,
+        		ap_int32_t flags)
+{
+    int i, ptr = 0;
+    size_t nbytes = 0, headerlen = 0, trailerlen = 0;
+    struct sf_hdtr headerstruct;
+    struct iovec hdtrarray[2];
+    void *headerbuf, *trailerbuf;
+
+
+    /* HP-UX can only send one header iovec and one footer iovec */
+
+    for (i = 0; i < hdtr->numheaders; i++) {
+        headerlen += hdtr->headers[i].iov_len;
+    }
+
+    headerbuf = ap_palloc(sock->cntxt, headerlen);
+
+    for (i = 0; i < hdtr->numheaders; i++) {
+        memcpy(headerbuf, hdtr->headers[i].iov_base + ptr,
+               hdtr->headers[i].iov_len);
+        ptr += hdtr->headers[i].iov_len;
+    }
+
+    for (i = 0; i < hdtr->numtrailers; i++) {
+        trailerlen += hdtr->headers[i].iov_len;
+    }
+
+    trailerbuf = ap_palloc(sock->cntxt, trailerlen);
+
+    for (i = 0; i < hdtr->numtrailers; i++) {
+        memcpy(trailerbuf, hdtr->trailers[i].iov_base + ptr,
+               hdtr->trailers[i].iov_len);
+        ptr += hdtr->trailers[i].iov_len;
+    }
+
+    hdtrarray[0].iov_base = headerbuf;
+    hdtrarray[0].iov_len = headerlen;
+    hdtrarray[1].iov_base = trailerbuf;
+    hdtrarray[1].iov_len = trailerlen;
+
+    do {
+        rv = sendfile(sock->socketdes,	/* socket  */
+        	      file->filedes,	/* file descriptor to send */
+        	      *offset,	/* where in the file to start */
+        	      nbytes,	/* number of bytes to send */
+        	      hdtrarray,	/* Headers/footers */
+        	      flags	/* undefined, set to 0 */
+            );
+    } while (rv == -1 && errno == EINTR);
+
+    if (rv == -1 && errno == EAGAIN && sock->timeout != 0) {
+        struct timeval *tv;
+        fd_set fdset;
+        int srv;
+
+        do {
+            FD_ZERO(&fdset);
+            FD_SET(sock->socketdes, &fdset);
+            if (sock->timeout < 0) {
+        	tv = NULL;
+            }
+            else {
+        	tv = ap_palloc(sock->cntxt, sizeof(struct timeval));
+        	tv->tv_sec = sock->timeout;
+        	tv->tv_usec = 0;
+            }
+            srv = select(FD_SETSIZE, NULL, &fdset, NULL, tv);
+        } while (srv == -1 && errno == EINTR);
+
+        if (srv == 0) {
+            (*len) = -1;
+            return APR_TIMEUP;
+        }
+        else if (srv < 0) {
+            (*len) = -1;
+            return errno;
+        }
+        else {
+            do {
+        	rv = sendfile(sock->socketdes,	/* socket  */
+        		      file->filedes,	/* file descriptor to send */
+        		      *offset,	/* where in the file to start */
+        		      nbytes,	/* number of bytes to send */
+        		      hdtrarray,	/* Headers/footers */
+        		      flags	/* undefined, set to 0 */
+        	    );
+            } while (rv == -1 && errno == EINTR);
+        }
+    }
+
+
+    if (rv == -1) {
+        return errno;
+    }
+
+
+    /* Set len to the number of bytes written */
+    (*len) = rv;
+    return APR_SUCCESS;
+}
+#else
+/* TODO: Add AIX support */
+#endif /* __linux__, __FreeBSD__, __HPUX__ */
+#endif /* HAVE_SENDFILE */
+