#include "apr_arch_networkio.h"
#include "apr_support.h"
#if APR_HAS_SENDFILE
#include "apr_arch_file_io.h"
#endif
#if defined(__FreeBSD__)
#include <osreldate.h>
#endif
apr_status_t apr_socket_send(apr_socket_t *sock, const char *buf,
apr_size_t *len)
{
apr_ssize_t rv;
if (sock->options & APR_INCOMPLETE_WRITE) {
sock->options &= ~APR_INCOMPLETE_WRITE;
goto do_select;
}
do {
rv = write(sock->socketdes, buf, (*len));
} while (rv == -1 && errno == EINTR);
while (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);
}
}
if (rv == -1) {
*len = 0;
return errno;
}
if ((sock->timeout > 0) && (rv < *len)) {
sock->options |= APR_INCOMPLETE_WRITE;
}
(*len) = rv;
return APR_SUCCESS;
}
apr_status_t apr_socket_recv(apr_socket_t *sock, char *buf, apr_size_t *len)
{
apr_ssize_t rv;
apr_status_t arv;
if (sock->options & APR_INCOMPLETE_READ) {
sock->options &= ~APR_INCOMPLETE_READ;
goto do_select;
}
do {
rv = read(sock->socketdes, buf, (*len));
} while (rv == -1 && errno == EINTR);
while ((rv == -1) && (errno == EAGAIN || errno == EWOULDBLOCK)
&& (sock->timeout > 0)) {
do_select:
arv = apr_wait_for_io_or_timeout(NULL, sock, 1);
if (arv != APR_SUCCESS) {
*len = 0;
return arv;
}
else {
do {
rv = read(sock->socketdes, buf, (*len));
} while (rv == -1 && errno == EINTR);
}
}
if (rv == -1) {
(*len) = 0;
return errno;
}
if ((sock->timeout > 0) && (rv < *len)) {
sock->options |= APR_INCOMPLETE_READ;
}
(*len) = rv;
if (rv == 0) {
return APR_EOF;
}
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)
{
apr_ssize_t rv;
do {
rv = sendto(sock->socketdes, buf, (*len), flags,
(const struct sockaddr*)&where->sa,
where->salen);
} while (rv == -1 && errno == EINTR);
while ((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);
}
}
if (rv == -1) {
*len = 0;
return errno;
}
*len = rv;
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)
{
apr_ssize_t rv;
from->salen = sizeof(from->sa);
do {
rv = recvfrom(sock->socketdes, buf, (*len), flags,
(struct sockaddr*)&from->sa, &from->salen);
} while (rv == -1 && errno == EINTR);
while ((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);
}
}
if (rv == -1) {
(*len) = 0;
return errno;
}
apr_sockaddr_vars_set(from, from->sa.sin.sin_family, ntohs(from->sa.sin.sin_port));
(*len) = rv;
if (rv == 0 && sock->type == SOCK_STREAM) {
return APR_EOF;
}
return APR_SUCCESS;
}
apr_status_t apr_socket_sendv(apr_socket_t * sock, const struct iovec *vec,
apr_int32_t nvec, apr_size_t *len)
{
#ifdef HAVE_WRITEV
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);
while ((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;
#else
*len = vec[0].iov_len;
return apr_socket_send(sock, vec[0].iov_base, len);
#endif
}
#if APR_HAS_SENDFILE
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)
{
int rv, nbytes = 0, total_hdrbytes, i;
apr_status_t arv;
#if APR_HAS_LARGE_FILES && defined(HAVE_SENDFILE64)
apr_off_t off = *offset;
#define sendfile sendfile64
#elif APR_HAS_LARGE_FILES && SIZEOF_OFF_T == 4
off_t off;
if ((apr_int64_t)*offset + *len > INT_MAX) {
return EINVAL;
}
off = *offset;
#else
off_t off = *offset;
if (sizeof(off_t) == 8 && *len > INT_MAX) {
*len = INT_MAX;
}
#endif
if (!hdtr) {
hdtr = &no_hdtr;
}
flags = 0;
if (hdtr->numheaders > 0) {
apr_size_t hdrbytes;
rv = apr_socket_opt_set(sock, APR_TCP_NOPUSH, 1);
if (rv != APR_SUCCESS) {
return rv;
}
arv = apr_socket_sendv(sock, hdtr->headers, hdtr->numheaders,
&hdrbytes);
if (arv != APR_SUCCESS) {
*len = 0;
return errno;
}
nbytes += hdrbytes;
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,
file->filedes,
&off,
*len);
} while (rv == -1 && errno == EINTR);
while ((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,
file->filedes,
&off,
*len);
} 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 (sock->timeout > 0) {
sock->options |= APR_INCOMPLETE_WRITE;
}
return arv;
}
else {
return APR_EOF;
}
}
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(DARWIN)
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_off_t nbytes = 0;
apr_off_t bytes_to_send = *len;
apr_off_t bytes_sent = 0;
apr_status_t arv;
int rv = 0;
flags = 0;
if (!hdtr) {
hdtr = &no_hdtr;
}
if (hdtr->numheaders > 0) {
apr_size_t hbytes;
int i;
arv = apr_socket_sendv(sock, hdtr->headers, hdtr->numheaders,
&hbytes);
if (arv != APR_SUCCESS) {
*len = 0;
return errno;
}
bytes_sent = hbytes;
hbytes = 0;
for (i = 0; i < hdtr->numheaders; i++) {
hbytes += hdtr->headers[i].iov_len;
}
if (bytes_sent < hbytes) {
*len = bytes_sent;
return APR_SUCCESS;
}
}
do {
if (!bytes_to_send) {
break;
}
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;
}
}
nbytes = bytes_to_send;
rv = sendfile(file->filedes,
sock->socketdes,
*offset,
&nbytes,
NULL,
flags);
if (rv == -1) {
if (errno == EAGAIN) {
if (sock->timeout > 0) {
sock->options |= APR_INCOMPLETE_WRITE;
}
if (nbytes) {
bytes_sent += nbytes;
(*len) = bytes_sent;
return APR_SUCCESS;
}
}
}
else {
bytes_sent += nbytes;
if (nbytes == 0) {
(*len) = bytes_sent;
return APR_EOF;
}
}
} while (rv == -1 && (errno == EINTR || errno == EAGAIN));
if (hdtr->numtrailers > 0) {
apr_size_t tbytes;
arv = apr_socket_sendv(sock, hdtr->trailers, hdtr->numtrailers,
&tbytes);
bytes_sent += tbytes;
if (arv != APR_SUCCESS) {
*len = bytes_sent;
rv = errno;
return rv;
}
}
(*len) = bytes_sent;
if (rv == -1) {
return errno;
}
return APR_SUCCESS;
}
#elif defined(__FreeBSD__) || defined(__DragonFly__)
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;
#if defined(__FreeBSD_version) && __FreeBSD_version < 460001
int i;
#endif
struct sf_hdtr headerstruct;
apr_size_t bytes_to_send = *len;
flags = 0;
if (!hdtr) {
hdtr = &no_hdtr;
}
#if defined(__FreeBSD_version) && __FreeBSD_version < 460001
else if (hdtr->numheaders) {
for (i = 0; i < hdtr->numheaders; i++) {
bytes_to_send += hdtr->headers[i].iov_len;
}
}
#endif
headerstruct.headers = hdtr->headers;
headerstruct.hdr_cnt = hdtr->numheaders;
headerstruct.trailers = hdtr->trailers;
headerstruct.trl_cnt = hdtr->numtrailers;
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) {
rv = sendfile(file->filedes,
sock->socketdes,
*offset,
bytes_to_send,
&headerstruct,
&nbytes,
flags);
if (rv == -1) {
if (errno == EAGAIN) {
if (sock->timeout > 0) {
sock->options |= APR_INCOMPLETE_WRITE;
}
if (nbytes) {
(*len) = nbytes;
return APR_SUCCESS;
}
}
}
else {
if (nbytes == 0) {
(*len) = nbytes;
return APR_EOF;
}
}
}
else {
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__)
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 APR_HAS_LARGE_FILES && defined(HAVE_SENDFILE64)
#define sendfile sendfile64
apr_off_t off = *offset;
#elif APR_HAS_LARGE_FILES && SIZEOF_OFF_T == 4
off_t off;
if ((apr_int64_t)*offset + *len > INT_MAX) {
return EINVAL;
}
off = *offset;
#else
apr_off_t off = *offset;
#endif
if (!hdtr) {
hdtr = &no_hdtr;
}
flags = 0;
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;
}
headerbuf = hdtrarray[0].iov_base = apr_palloc(sock->pool, 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;
}
trailerbuf = hdtrarray[1].iov_base = apr_palloc(sock->pool, 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) {
rc = sendfile(sock->socketdes,
file->filedes,
off,
nbytes,
hdtrarray,
flags);
}
else {
rc = writev(sock->socketdes, hdtrarray, 2);
}
} while (rc == -1 && errno == EINTR);
while ((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,
file->filedes,
off,
nbytes,
hdtrarray,
flags);
}
else {
rc = writev(sock->socketdes, hdtrarray, 2);
}
} while (rc == -1 && errno == EINTR);
}
}
if (rc == -1) {
*len = 0;
return errno;
}
*len = rc;
return APR_SUCCESS;
}
#elif defined(_AIX) || defined(__MVS__)
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;
}
flags = 0;
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
hbuf = malloc(parms.header_length);
#else
hbuf = apr_palloc(sock->pool, 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
tbuf = malloc(parms.trailer_length);
#else
tbuf = apr_palloc(sock->pool, 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;
}
parms.file_descriptor = file->filedes;
parms.file_offset = *offset;
parms.file_bytes = *len;
if (sock->options & APR_INCOMPLETE_WRITE) {
sock->options &= ~APR_INCOMPLETE_WRITE;
goto do_select;
}
do {
rv = send_file(&(sock->socketdes),
&(parms),
flags);
} while (rv == -1 && errno == EINTR);
while ((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),
&(parms),
flags);
} while (rv == -1 && errno == EINTR);
}
}
(*len) = parms.bytes_sent;
#if 0
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)
#elif defined(HAVE_SENDFILEV)
#if APR_HAS_LARGE_FILES && defined(HAVE_SENDFILEV64)
#define sendfilevec_t sendfilevec64_t
#define sendfilev sendfilev64
#endif
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;
}
flags = 0;
vecs = hdtr->numheaders + hdtr->numtrailers + 1;
sfv = apr_palloc(sock->pool, sizeof(sendfilevec_t) * vecs);
curvec = 0;
for (i = 0; i < hdtr->numheaders; i++, curvec++) {
sfv[curvec].sfv_fd = SFV_FD_SELF;
sfv[curvec].sfv_flag = 0;
sfv[curvec].sfv_off = (unsigned long)hdtr->headers[i].iov_base;
sfv[curvec].sfv_len = hdtr->headers[i].iov_len;
requested_len += sfv[curvec].sfv_len;
}
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--;
}
for (i = 0; i < hdtr->numtrailers; i++, curvec++) {
sfv[curvec].sfv_fd = SFV_FD_SELF;
sfv[curvec].sfv_flag = 0;
sfv[curvec].sfv_off = (unsigned long)hdtr->trailers[i].iov_base;
sfv[curvec].sfv_len = hdtr->trailers[i].iov_len;
requested_len += sfv[curvec].sfv_len;
}
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;
}
}
arv = 0;
do {
repeat = 0;
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;
}
*len = nbytes;
if (nbytes == 0) {
return APR_EOF;
}
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
#endif