Adding upstream version 1.7.2.upstream/1.7.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

22 files changed, 6692 insertions, 0 deletions

diff --git a/network_io/beos/sendrecv.c b/network_io/beos/sendrecv.c
new file mode 100644
index 0000000..201abf8
--- /dev/null
+++ b/network_io/beos/sendrecv.c
@@ -0,0 +1,216 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_private.h"
+#if BEOS_BONE /* BONE uses the unix code - woohoo */
+#include "../unix/sendrecv.c"
+#else
+#include "apr_arch_networkio.h"
+#include "apr_time.h"
+
+static apr_status_t wait_for_io_or_timeout(apr_socket_t *sock, int for_read)
+{
+    struct timeval tv, *tvptr;
+    fd_set fdset;
+    int srv;
+
+    do {
+        FD_ZERO(&fdset);
+        FD_SET(sock->socketdes, &fdset);
+        if (sock->timeout < 0) {
+            tvptr = NULL;
+        }
+        else {
+            tv.tv_sec = sock->timeout / APR_USEC_PER_SEC;
+            tv.tv_usec = sock->timeout % APR_USEC_PER_SEC;
+            tvptr = &tv;
+        }
+        srv = select(sock->socketdes + 1,
+            for_read ? &fdset : NULL,
+            for_read ? NULL : &fdset, 
+            NULL,
+            tvptr);
+            /* TODO - timeout should be smaller on repeats of this loop */
+    } while (srv == -1 && errno == EINTR);
+
+    if (srv == 0) {
+        return APR_TIMEUP;
+    }
+    else if (srv < 0) {
+        return errno;
+    }
+    return APR_SUCCESS;
+}
+
+#define SEND_WAIT APR_USEC_PER_SEC / 10
+
+APR_DECLARE(apr_status_t) apr_socket_send(apr_socket_t *sock, const char *buf,
+                                          apr_size_t *len)
+{
+    apr_ssize_t rv;
+	
+    do {
+        rv = send(sock->socketdes, buf, (*len), 0);
+    } while (rv == -1 && errno == EINTR);
+
+    if (rv == -1 && errno == EWOULDBLOCK && sock->timeout > 0) {
+        apr_int32_t snooze_val = SEND_WAIT;
+        apr_int32_t zzz = 0;  
+        
+        do {
+            rv = send(sock->socketdes, buf, (*len), 0);
+            if (rv == -1 && errno == EWOULDBLOCK){
+                apr_sleep (snooze_val);
+                zzz += snooze_val;
+                snooze_val += SEND_WAIT;
+                /* have we passed our timeout value */
+                if (zzz > (sock->timeout * APR_USEC_PER_SEC))
+                    break;
+            }
+        } while (rv == -1 && (errno == EINTR || errno == EWOULDBLOCK));
+    }
+    if (rv == -1) {
+        *len = 0;
+        return errno;
+    }
+    (*len) = rv;
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_socket_recv(apr_socket_t *sock, char *buf, 
+                                          apr_size_t *len)
+{
+    apr_ssize_t rv;
+   
+    do {
+        rv = recv(sock->socketdes, buf, (*len), 0);
+    } while (rv == -1 && errno == EINTR);
+
+    if (rv == -1 && errno == EWOULDBLOCK && sock->timeout > 0) {
+        apr_status_t arv = wait_for_io_or_timeout(sock, 1);
+        if (arv != APR_SUCCESS) {
+            *len = 0;
+            return arv;
+        }
+        else {
+            do {
+                rv = recv(sock->socketdes, buf, (*len), 0);
+            } while (rv == -1 && errno == EINTR);
+        }
+    }
+    if (rv == -1) {
+        (*len) = 0;
+        return errno;
+    }
+    (*len) = rv;
+    if (rv == 0)
+        return APR_EOF;
+    return APR_SUCCESS;
+}
+
+/* BeOS doesn't have writev for sockets so we use the following instead...
+ */
+APR_DECLARE(apr_status_t) apr_socket_sendv(apr_socket_t * sock, 
+                                           const struct iovec *vec,
+                                           apr_int32_t nvec, apr_size_t *len)
+{
+    *len = vec[0].iov_len;
+    return apr_socket_send(sock, vec[0].iov_base, len);
+}
+
+APR_DECLARE(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);
+
+    if (rv == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)
+        && sock->timeout != 0) {
+        apr_status_t arv = wait_for_io_or_timeout(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_DECLARE(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;
+
+    if (from == NULL){
+        return APR_ENOMEM;
+        /* Not sure if this is correct.  Maybe we should just allocate
+           the memory??
+         */
+    }
+
+    do {
+        rv = recvfrom(sock->socketdes, buf, (*len), flags,
+                      (struct sockaddr*)&from->sa, &from->salen);
+    } while (rv == -1 && errno == EINTR);
+
+    if (rv == -1 && (errno == EAGAIN || errno == EWOULDBLOCK) &&
+        sock->timeout != 0) {
+        apr_status_t arv = wait_for_io_or_timeout(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;
+    }
+	
+    from->port = ntohs(from->sa.sin.sin_port);
+	
+    (*len) = rv;
+    if (rv == 0)
+        return APR_EOF;
+
+    return APR_SUCCESS;
+}
+
+#endif /* ! BEOS_BONE */
diff --git a/network_io/beos/socketcommon.c b/network_io/beos/socketcommon.c
new file mode 100644
index 0000000..b9f594b
--- /dev/null
+++ b/network_io/beos/socketcommon.c
@@ -0,0 +1,6 @@
+#include "../unix/inet_ntop.c"
+#include "../unix/inet_pton.c"
+#include "../unix/sockets.c"
+#include "../unix/sockaddr.c"
+#include "../unix/sockopt.c"
+#include "../unix/socket_util.c"
diff --git a/network_io/os2/inet_ntop.c b/network_io/os2/inet_ntop.c
new file mode 100644
index 0000000..f1f79d4
--- /dev/null
+++ b/network_io/os2/inet_ntop.c
@@ -0,0 +1 @@
+#include "../unix/inet_ntop.c"
diff --git a/network_io/os2/inet_pton.c b/network_io/os2/inet_pton.c
new file mode 100644
index 0000000..dbd3ac4
--- /dev/null
+++ b/network_io/os2/inet_pton.c
@@ -0,0 +1 @@
+#include "../unix/inet_pton.c"
diff --git a/network_io/os2/os2calls.c b/network_io/os2/os2calls.c
new file mode 100644
index 0000000..6bf1fcd
--- /dev/null
+++ b/network_io/os2/os2calls.c
@@ -0,0 +1,132 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_network_io.h"
+#include "apr_portable.h"
+#include "apr_general.h"
+#include "apr_lib.h"
+
+static int os2_socket_init(int, int ,int);
+
+int (*apr_os2_socket)(int, int, int) = os2_socket_init;
+int (*apr_os2_select)(int *, int, int, int, long) = NULL;
+int (*apr_os2_sock_errno)() = NULL;
+int (*apr_os2_accept)(int, struct sockaddr *, int *) = NULL;
+int (*apr_os2_bind)(int, struct sockaddr *, int) = NULL;
+int (*apr_os2_connect)(int, struct sockaddr *, int) = NULL;
+int (*apr_os2_getpeername)(int, struct sockaddr *, int *) = NULL;
+int (*apr_os2_getsockname)(int, struct sockaddr *, int *) = NULL;
+int (*apr_os2_getsockopt)(int, int, int, char *, int *) = NULL;
+int (*apr_os2_ioctl)(int, int, caddr_t, int) = NULL;
+int (*apr_os2_listen)(int, int) = NULL;
+int (*apr_os2_recv)(int, char *, int, int) = NULL;
+int (*apr_os2_send)(int, const char *, int, int) = NULL;
+int (*apr_os2_setsockopt)(int, int, int, char *, int) = NULL;
+int (*apr_os2_shutdown)(int, int) = NULL;
+int (*apr_os2_soclose)(int) = NULL;
+int (*apr_os2_writev)(int, struct iovec *, int) = NULL;
+int (*apr_os2_sendto)(int, const char *, int, int, const struct sockaddr *, int);
+int (*apr_os2_recvfrom)(int, char *, int, int, struct sockaddr *, int *);
+
+static HMODULE hSO32DLL;
+
+static int os2_fn_link()
+{
+    DosEnterCritSec(); /* Stop two threads doing this at the same time */
+
+    if (apr_os2_socket == os2_socket_init) {
+        ULONG rc;
+        char errorstr[200];
+
+        rc = DosLoadModule(errorstr, sizeof(errorstr), "SO32DLL", &hSO32DLL);
+
+        if (rc)
+            return APR_OS2_STATUS(rc);
+
+        rc = DosQueryProcAddr(hSO32DLL, 0, "SOCKET", &apr_os2_socket);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "SELECT", &apr_os2_select);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "SOCK_ERRNO", &apr_os2_sock_errno);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "ACCEPT", &apr_os2_accept);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "BIND", &apr_os2_bind);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "CONNECT", &apr_os2_connect);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "GETPEERNAME", &apr_os2_getpeername);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "GETSOCKNAME", &apr_os2_getsockname);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "GETSOCKOPT", &apr_os2_getsockopt);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "IOCTL", &apr_os2_ioctl);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "LISTEN", &apr_os2_listen);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "RECV", &apr_os2_recv);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "SEND", &apr_os2_send);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "SETSOCKOPT", &apr_os2_setsockopt);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "SHUTDOWN", &apr_os2_shutdown);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "SOCLOSE", &apr_os2_soclose);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "WRITEV", &apr_os2_writev);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "SENDTO", &apr_os2_sendto);
+
+        if (!rc)
+            rc = DosQueryProcAddr(hSO32DLL, 0, "RECVFROM", &apr_os2_recvfrom);
+
+        if (rc)
+            return APR_OS2_STATUS(rc);
+    }
+
+    DosExitCritSec();
+    return APR_SUCCESS;
+}
+
+
+
+static int os2_socket_init(int domain, int type, int protocol)
+{
+    int rc = os2_fn_link();
+    if (rc == APR_SUCCESS)
+        return apr_os2_socket(domain, type, protocol);
+    return rc;
+}
diff --git a/network_io/os2/sendrecv.c b/network_io/os2/sendrecv.c
new file mode 100644
index 0000000..839ff3f
--- /dev/null
+++ b/network_io/os2/sendrecv.c
@@ -0,0 +1,155 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_errno.h"
+#include "apr_general.h"
+#include "apr_network_io.h"
+#include "apr_lib.h"
+#include <sys/time.h>
+
+APR_DECLARE(apr_status_t) apr_socket_send(apr_socket_t *sock, const char *buf,
+                                          apr_size_t *len)
+{
+    apr_ssize_t rv;
+    int fds, err = 0;
+
+    if (*len > 65536) {
+        *len = 65536;
+    }
+
+    do {
+        if (!sock->nonblock || err == SOCEWOULDBLOCK) {
+            fds = sock->socketdes;
+            rv = select(&fds, 0, 1, 0, sock->timeout >= 0 ? sock->timeout/1000 : -1);
+
+            if (rv != 1) {
+                *len = 0;
+                err = sock_errno();
+
+                if (rv == 0)
+                    return APR_TIMEUP;
+
+                if (err == SOCEINTR)
+                    continue;
+
+                return APR_OS2_STATUS(err);
+            }
+        }
+
+        rv = send(sock->socketdes, buf, (*len), 0);
+        err = rv < 0 ? sock_errno() : 0;
+    } while (err == SOCEINTR || err == SOCEWOULDBLOCK);
+
+    if (err) {
+        *len = 0;
+        return APR_OS2_STATUS(err);
+    }
+
+    (*len) = rv;
+    return APR_SUCCESS;
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_socket_recv(apr_socket_t *sock, char *buf,
+                                          apr_size_t *len)
+{
+    apr_ssize_t rv;
+    int fds, err = 0;
+
+    do {
+        if (!sock->nonblock || (err == SOCEWOULDBLOCK && sock->timeout != 0)) {
+            fds = sock->socketdes;
+            rv = select(&fds, 1, 0, 0, sock->timeout >= 0 ? sock->timeout/1000 : -1);
+
+            if (rv != 1) {
+                *len = 0;
+                err = sock_errno();
+
+                if (rv == 0)
+                    return APR_TIMEUP;
+
+                if (err == SOCEINTR)
+                    continue;
+
+                return APR_OS2_STATUS(err);
+            }
+        }
+
+        rv = recv(sock->socketdes, buf, (*len), 0);
+        err = rv < 0 ? sock_errno() : 0;
+    } while (err == SOCEINTR || (err == SOCEWOULDBLOCK && sock->timeout != 0));
+
+    if (err) {
+        *len = 0;
+        return APR_OS2_STATUS(err);
+    }
+
+    (*len) = rv;
+    return rv == 0 ? APR_EOF : APR_SUCCESS;
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_socket_sendv(apr_socket_t *sock, 
+                                           const struct iovec *vec, 
+                                           apr_int32_t nvec, apr_size_t *len)
+{
+    apr_status_t rv;
+    struct iovec *tmpvec;
+    int fds, err = 0;
+    int nv_tosend, total = 0;
+
+    /* Make sure writev() only gets fed 64k at a time */
+    for ( nv_tosend = 0; nv_tosend < nvec && total + vec[nv_tosend].iov_len < 65536; nv_tosend++ ) {
+        total += vec[nv_tosend].iov_len;
+    }
+
+    tmpvec = alloca(sizeof(struct iovec) * nv_tosend);
+    memcpy(tmpvec, vec, sizeof(struct iovec) * nv_tosend);
+
+    do {
+        if (!sock->nonblock || err == SOCEWOULDBLOCK) {
+            fds = sock->socketdes;
+            rv = select(&fds, 0, 1, 0, sock->timeout >= 0 ? sock->timeout/1000 : -1);
+
+            if (rv != 1) {
+                *len = 0;
+                err = sock_errno();
+
+                if (rv == 0)
+                    return APR_TIMEUP;
+
+                if (err == SOCEINTR)
+                    continue;
+
+                return APR_OS2_STATUS(err);
+            }
+        }
+
+        rv = writev(sock->socketdes, tmpvec, nv_tosend);
+        err = rv < 0 ? sock_errno() : 0;
+    } while (err == SOCEINTR || err == SOCEWOULDBLOCK);
+
+    if (err) {
+        *len = 0;
+        return APR_OS2_STATUS(err);
+    }
+
+    *len = rv;
+    return APR_SUCCESS;
+}
diff --git a/network_io/os2/sendrecv_udp.c b/network_io/os2/sendrecv_udp.c
new file mode 100644
index 0000000..c0dcd85
--- /dev/null
+++ b/network_io/os2/sendrecv_udp.c
@@ -0,0 +1,104 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_errno.h"
+#include "apr_general.h"
+#include "apr_network_io.h"
+#include "apr_support.h"
+#include "apr_lib.h"
+#include <sys/time.h>
+
+
+APR_DECLARE(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;
+    int serrno;
+
+    do {
+        rv = sendto(sock->socketdes, buf, (*len), flags, 
+                    (struct sockaddr*)&where->sa,
+                    where->salen);
+    } while (rv == -1 && (serrno = sock_errno()) == EINTR);
+
+    if (rv == -1 && serrno == SOCEWOULDBLOCK && 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 && (serrno = sock_errno()) == SOCEINTR);
+        }
+    }
+
+    if (rv == -1) {
+        *len = 0;
+        return APR_FROM_OS_ERROR(serrno);
+    }
+
+    *len = rv;
+    return APR_SUCCESS;
+}
+
+
+
+APR_DECLARE(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;
+    int serrno;
+
+    do {
+        rv = recvfrom(sock->socketdes, buf, (*len), flags, 
+                      (struct sockaddr*)&from->sa, &from->salen);
+    } while (rv == -1 && (serrno = sock_errno()) == EINTR);
+
+    if (rv == -1 && serrno == SOCEWOULDBLOCK && 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 && (serrno = sock_errno()) == EINTR);
+        }
+    }
+
+    if (rv == -1) {
+        (*len) = 0;
+        return APR_FROM_OS_ERROR(serrno);
+    }
+
+    (*len) = rv;
+
+    if (rv == 0 && sock->type == SOCK_STREAM)
+        return APR_EOF;
+
+    return APR_SUCCESS;
+}
diff --git a/network_io/os2/sockaddr.c b/network_io/os2/sockaddr.c
new file mode 100644
index 0000000..2afe4b7
--- /dev/null
+++ b/network_io/os2/sockaddr.c
@@ -0,0 +1 @@
+#include "../unix/sockaddr.c"
diff --git a/network_io/os2/socket_util.c b/network_io/os2/socket_util.c
new file mode 100644
index 0000000..cdc1cea
--- /dev/null
+++ b/network_io/os2/socket_util.c
@@ -0,0 +1 @@
+#include "../unix/socket_util.c"
diff --git a/network_io/os2/sockets.c b/network_io/os2/sockets.c
new file mode 100644
index 0000000..bb951e4
--- /dev/null
+++ b/network_io/os2/sockets.c
@@ -0,0 +1,317 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_arch_inherit.h"
+#include "apr_network_io.h"
+#include "apr_general.h"
+#include "apr_portable.h"
+#include "apr_lib.h"
+#include "apr_strings.h"
+#include <errno.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <netinet/tcp.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include "apr_arch_os2calls.h"
+
+static apr_status_t socket_cleanup(void *sock)
+{
+    apr_socket_t *thesocket = sock;
+
+    if (thesocket->socketdes < 0) {
+        return APR_EINVALSOCK;
+    }
+
+    if (soclose(thesocket->socketdes) == 0) {
+        thesocket->socketdes = -1;
+        return APR_SUCCESS;
+    }
+    else {
+        return APR_OS2_STATUS(sock_errno());
+    }
+}
+
+static void set_socket_vars(apr_socket_t *sock, int family, int type, int protocol)
+{
+    sock->type = type;
+    sock->protocol = protocol;
+    apr_sockaddr_vars_set(sock->local_addr, family, 0);
+    apr_sockaddr_vars_set(sock->remote_addr, family, 0);
+}
+
+static void alloc_socket(apr_socket_t **new, apr_pool_t *p)
+{
+    *new = (apr_socket_t *)apr_pcalloc(p, sizeof(apr_socket_t));
+    (*new)->pool = p;
+    (*new)->local_addr = (apr_sockaddr_t *)apr_pcalloc((*new)->pool,
+                                                       sizeof(apr_sockaddr_t));
+    (*new)->local_addr->pool = p;
+
+    (*new)->remote_addr = (apr_sockaddr_t *)apr_pcalloc((*new)->pool,
+                                                        sizeof(apr_sockaddr_t));
+    (*new)->remote_addr->pool = p;
+    (*new)->remote_addr_unknown = 1;
+
+    /* Create a pollset with room for one descriptor. */
+    /* ### check return codes */
+    (void) apr_pollset_create(&(*new)->pollset, 1, p, 0);
+}
+
+APR_DECLARE(apr_status_t) apr_socket_protocol_get(apr_socket_t *sock, int *protocol)
+{
+    *protocol = sock->protocol;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_socket_create(apr_socket_t **new, int family, int type,
+                                            int protocol, apr_pool_t *cont)
+{
+    int downgrade = (family == AF_UNSPEC);
+    apr_pollfd_t pfd;
+
+    if (family == AF_UNSPEC) {
+#if APR_HAVE_IPV6
+        family = AF_INET6;
+#else
+        family = AF_INET;
+#endif
+    }
+
+    alloc_socket(new, cont);
+
+    (*new)->socketdes = socket(family, type, protocol);
+#if APR_HAVE_IPV6
+    if ((*new)->socketdes < 0 && downgrade) {
+        family = AF_INET;
+        (*new)->socketdes = socket(family, type, protocol);
+    }
+#endif
+
+    if ((*new)->socketdes < 0) {
+        return APR_OS2_STATUS(sock_errno());
+    }
+    set_socket_vars(*new, family, type, protocol);
+
+    (*new)->timeout = -1;
+    (*new)->nonblock = FALSE;
+    apr_pool_cleanup_register((*new)->pool, (void *)(*new), 
+                        socket_cleanup, apr_pool_cleanup_null);
+
+    return APR_SUCCESS;
+} 
+
+APR_DECLARE(apr_status_t) apr_socket_shutdown(apr_socket_t *thesocket, 
+                                              apr_shutdown_how_e how)
+{
+    if (shutdown(thesocket->socketdes, how) == 0) {
+        return APR_SUCCESS;
+    }
+    else {
+        return APR_OS2_STATUS(sock_errno());
+    }
+}
+
+APR_DECLARE(apr_status_t) apr_socket_close(apr_socket_t *thesocket)
+{
+    apr_pool_cleanup_kill(thesocket->pool, thesocket, socket_cleanup);
+    return socket_cleanup(thesocket);
+}
+
+APR_DECLARE(apr_status_t) apr_socket_bind(apr_socket_t *sock,
+                                          apr_sockaddr_t *sa)
+{
+    if (bind(sock->socketdes, 
+             (struct sockaddr *)&sa->sa,
+             sa->salen) == -1)
+        return APR_OS2_STATUS(sock_errno());
+    else {
+        sock->local_addr = sa;
+        /* XXX IPv6 - this assumes sin_port and sin6_port at same offset */
+        if (sock->local_addr->sa.sin.sin_port == 0) { /* no need for ntohs() when comparing w/ 0 */
+            sock->local_port_unknown = 1; /* kernel got us an ephemeral port */
+        }
+        return APR_SUCCESS;
+    }
+}
+
+APR_DECLARE(apr_status_t) apr_socket_listen(apr_socket_t *sock, 
+                                            apr_int32_t backlog)
+{
+    if (listen(sock->socketdes, backlog) == -1)
+        return APR_OS2_STATUS(sock_errno());
+    else
+        return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_socket_accept(apr_socket_t **new, 
+                                            apr_socket_t *sock,
+                                            apr_pool_t *connection_context)
+{
+    alloc_socket(new, connection_context);
+    set_socket_vars(*new, sock->local_addr->sa.sin.sin_family, SOCK_STREAM, sock->protocol);
+
+    (*new)->timeout = -1;
+    (*new)->nonblock = FALSE;
+
+    (*new)->socketdes = accept(sock->socketdes, 
+                               (struct sockaddr *)&(*new)->remote_addr->sa,
+                               &(*new)->remote_addr->salen);
+
+    if ((*new)->socketdes < 0) {
+        return APR_OS2_STATUS(sock_errno());
+    }
+
+    *(*new)->local_addr = *sock->local_addr;
+    (*new)->local_addr->pool = connection_context;
+    (*new)->remote_addr->port = ntohs((*new)->remote_addr->sa.sin.sin_port);
+
+    /* fix up any pointers which are no longer valid */
+    if (sock->local_addr->sa.sin.sin_family == AF_INET) {
+        (*new)->local_addr->ipaddr_ptr = &(*new)->local_addr->sa.sin.sin_addr;
+    }
+
+    apr_pool_cleanup_register((*new)->pool, (void *)(*new), 
+                        socket_cleanup, apr_pool_cleanup_null);
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_socket_connect(apr_socket_t *sock,
+                                             apr_sockaddr_t *sa)
+{
+    if ((connect(sock->socketdes, (struct sockaddr *)&sa->sa.sin, 
+                 sa->salen) < 0) &&
+        (sock_errno() != SOCEINPROGRESS)) {
+        return APR_OS2_STATUS(sock_errno());
+    }
+    else {
+        int namelen = sizeof(sock->local_addr->sa.sin);
+        getsockname(sock->socketdes, (struct sockaddr *)&sock->local_addr->sa.sin, 
+                    &namelen);
+        sock->remote_addr = sa;
+        return APR_SUCCESS;
+    }
+}
+
+APR_DECLARE(apr_status_t) apr_socket_type_get(apr_socket_t *sock, int *type)
+{
+    *type = sock->type;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_socket_data_get(void **data, const char *key,
+                                     apr_socket_t *sock)
+{
+    sock_userdata_t *cur = sock->userdata;
+
+    *data = NULL;
+
+    while (cur) {
+        if (!strcmp(cur->key, key)) {
+            *data = cur->data;
+            break;
+        }
+        cur = cur->next;
+    }
+
+    return APR_SUCCESS;
+}
+
+
+
+APR_DECLARE(apr_status_t) apr_socket_data_set(apr_socket_t *sock, void *data, const char *key,
+                                     apr_status_t (*cleanup) (void *))
+{
+    sock_userdata_t *new = apr_palloc(sock->pool, sizeof(sock_userdata_t));
+
+    new->key = apr_pstrdup(sock->pool, key);
+    new->data = data;
+    new->next = sock->userdata;
+    sock->userdata = new;
+
+    if (cleanup) {
+        apr_pool_cleanup_register(sock->pool, data, cleanup, cleanup);
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_sock_get(apr_os_sock_t *thesock, apr_socket_t *sock)
+{
+    *thesock = sock->socketdes;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_sock_make(apr_socket_t **apr_sock, 
+                                           apr_os_sock_info_t *os_sock_info, 
+                                           apr_pool_t *cont)
+{
+    alloc_socket(apr_sock, cont);
+    set_socket_vars(*apr_sock, os_sock_info->family, os_sock_info->type, os_sock_info->protocol);
+    (*apr_sock)->timeout = -1;
+    (*apr_sock)->socketdes = *os_sock_info->os_sock;
+    if (os_sock_info->local) {
+        memcpy(&(*apr_sock)->local_addr->sa.sin, 
+               os_sock_info->local, 
+               (*apr_sock)->local_addr->salen);
+        /* XXX IPv6 - this assumes sin_port and sin6_port at same offset */
+        (*apr_sock)->local_addr->port = ntohs((*apr_sock)->local_addr->sa.sin.sin_port);
+    }
+    else {
+        (*apr_sock)->local_port_unknown = (*apr_sock)->local_interface_unknown = 1;
+    }
+    if (os_sock_info->remote) {
+        memcpy(&(*apr_sock)->remote_addr->sa.sin, 
+               os_sock_info->remote,
+               (*apr_sock)->remote_addr->salen);
+        /* XXX IPv6 - this assumes sin_port and sin6_port at same offset */
+        (*apr_sock)->remote_addr->port = ntohs((*apr_sock)->remote_addr->sa.sin.sin_port);
+    }
+    else {
+        (*apr_sock)->remote_addr_unknown = 1;
+    }
+        
+    apr_pool_cleanup_register((*apr_sock)->pool, (void *)(*apr_sock), 
+                        socket_cleanup, apr_pool_cleanup_null);
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_sock_put(apr_socket_t **sock, apr_os_sock_t *thesock, apr_pool_t *cont)
+{
+    if (cont == NULL) {
+        return APR_ENOPOOL;
+    }
+    if ((*sock) == NULL) {
+        alloc_socket(sock, cont);
+        set_socket_vars(*sock, AF_INET, SOCK_STREAM, 0);
+        (*sock)->timeout = -1;
+    }
+
+    (*sock)->local_port_unknown = (*sock)->local_interface_unknown = 1;
+    (*sock)->remote_addr_unknown = 1;
+    (*sock)->socketdes = *thesock;
+    return APR_SUCCESS;
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(socket);
+
+APR_IMPLEMENT_INHERIT_SET(socket, inherit, pool, socket_cleanup)
+
+APR_IMPLEMENT_INHERIT_UNSET(socket, inherit, pool, socket_cleanup)
+
diff --git a/network_io/os2/sockopt.c b/network_io/os2/sockopt.c
new file mode 100644
index 0000000..094cd24
--- /dev/null
+++ b/network_io/os2/sockopt.c
@@ -0,0 +1,144 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_network_io.h"
+#include "apr_general.h"
+#include "apr_lib.h"
+#include "apr_strings.h"
+#include <errno.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <netinet/tcp.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <sys/so_ioctl.h>
+
+
+APR_DECLARE(apr_status_t) apr_socket_timeout_set(apr_socket_t *sock, 
+                                                 apr_interval_time_t t)
+{
+    sock->timeout = t;
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_socket_opt_set(apr_socket_t *sock, 
+                                             apr_int32_t opt, apr_int32_t on)
+{
+    int one;
+    struct linger li;
+
+    if (on)
+        one = 1;
+    else
+        one = 0;
+
+    if (opt & APR_SO_KEEPALIVE) {
+        if (setsockopt(sock->socketdes, SOL_SOCKET, SO_KEEPALIVE, (void *)&one, sizeof(int)) == -1) {
+            return APR_OS2_STATUS(sock_errno());
+        }
+    }
+    if (opt & APR_SO_DEBUG) {
+        if (setsockopt(sock->socketdes, SOL_SOCKET, SO_DEBUG, (void *)&one, sizeof(int)) == -1) {
+            return APR_OS2_STATUS(sock_errno());
+        }
+    }
+    if (opt & APR_SO_BROADCAST) {
+        if (setsockopt(sock->socketdes, SOL_SOCKET, SO_BROADCAST, (void *)&one, sizeof(int)) == -1) {
+            return APR_FROM_OS_ERROR(sock_errno());
+        }
+    }
+    if (opt & APR_SO_REUSEADDR) {
+        if (setsockopt(sock->socketdes, SOL_SOCKET, SO_REUSEADDR, (void *)&one, sizeof(int)) == -1) {
+            return APR_OS2_STATUS(sock_errno());
+        }
+    }
+    if (opt & APR_SO_SNDBUF) {
+        if (setsockopt(sock->socketdes, SOL_SOCKET, SO_SNDBUF, (void *)&on, sizeof(int)) == -1) {
+            return APR_OS2_STATUS(sock_errno());
+        }
+    }
+    if (opt & APR_SO_NONBLOCK) {
+        if (ioctl(sock->socketdes, FIONBIO, (caddr_t)&one, sizeof(one)) == -1) {
+            return APR_OS2_STATUS(sock_errno());
+        } else {
+            sock->nonblock = one;
+        }
+    }
+    if (opt & APR_SO_LINGER) {
+        li.l_onoff = on;
+        li.l_linger = APR_MAX_SECS_TO_LINGER;
+        if (setsockopt(sock->socketdes, SOL_SOCKET, SO_LINGER, (char *) &li, sizeof(struct linger)) == -1) {
+            return APR_OS2_STATUS(sock_errno());
+        }
+    }
+    if (opt & APR_TCP_NODELAY) {
+        if (setsockopt(sock->socketdes, IPPROTO_TCP, TCP_NODELAY, (void *)&on, sizeof(int)) == -1) {
+            return APR_OS2_STATUS(sock_errno());
+        }
+    }
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_socket_timeout_get(apr_socket_t *sock, 
+                                                 apr_interval_time_t *t)
+{
+    *t = sock->timeout;
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_socket_opt_get(apr_socket_t *sock, 
+                                             apr_int32_t opt, apr_int32_t *on)
+{
+    switch(opt) {
+    default:
+        return APR_EINVAL;
+    }
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_socket_atmark(apr_socket_t *sock, int *atmark)
+{
+    int oobmark;
+
+    if (ioctl(sock->socketdes, SIOCATMARK, (void*)&oobmark, sizeof(oobmark)) < 0) {
+        return APR_OS2_STATUS(sock_errno());
+    }
+
+    *atmark = (oobmark != 0);
+
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_gethostname(char *buf, apr_int32_t len, 
+                                          apr_pool_t *cont)
+{
+    if (gethostname(buf, len) == -1) {
+        buf[0] = '\0';
+        return APR_OS2_STATUS(sock_errno());
+    }
+    else if (!memchr(buf, '\0', len)) { /* buffer too small */
+        buf[0] = '\0';
+        return APR_ENAMETOOLONG;
+    }
+    return APR_SUCCESS;
+}
diff --git a/network_io/unix/inet_ntop.c b/network_io/unix/inet_ntop.c
new file mode 100644
index 0000000..78dd3ba
--- /dev/null
+++ b/network_io/unix/inet_ntop.c
@@ -0,0 +1,243 @@
+/* Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ */
+
+#include "apr_private.h"
+#include "apr_arch_networkio.h"
+#include "apr_strings.h"
+
+#if APR_HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#if APR_HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#if APR_HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#if APR_HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#include <string.h>
+#if APR_HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#include <stdio.h>
+
+#ifndef IN6ADDRSZ
+#define IN6ADDRSZ   16
+#endif
+
+#ifndef INT16SZ
+#define INT16SZ sizeof(apr_int16_t)
+#endif
+
+#ifndef __P
+#define __P(x) x
+#endif
+
+#if !defined(EAFNOSUPPORT) && defined(WSAEAFNOSUPPORT)
+#define EAFNOSUPPORT WSAEAFNOSUPPORT
+#endif
+
+/*
+ * WARNING: Don't even consider trying to compile this on a system where
+ * sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
+ */
+
+static const char *inet_ntop4 __P((const unsigned char *src, char *dst, apr_size_t size));
+#if APR_HAVE_IPV6
+static const char *inet_ntop6 __P((const unsigned char *src, char *dst, apr_size_t size));
+#endif
+
+/* char *
+ * inet_ntop(af, src, dst, size)
+ *	convert a network format address to presentation format.
+ * return:
+ *	pointer to presentation format address (`dst'), or NULL (see errno).
+ * author:
+ *	Paul Vixie, 1996.
+ */
+const char *
+apr_inet_ntop(int af, const void *src, char *dst, apr_size_t size)
+{
+	switch (af) {
+	case AF_INET:
+		return (inet_ntop4(src, dst, size));
+#if APR_HAVE_IPV6
+	case AF_INET6:
+		return (inet_ntop6(src, dst, size));
+#endif
+	default:
+		errno = EAFNOSUPPORT;
+		return (NULL);
+	}
+	/* NOTREACHED */
+}
+
+/* const char *
+ * inet_ntop4(src, dst, size)
+ *	format an IPv4 address, more or less like inet_ntoa()
+ * return:
+ *	`dst' (as a const)
+ * notes:
+ *	(1) uses no statics
+ *	(2) takes a u_char* not an in_addr as input
+ * author:
+ *	Paul Vixie, 1996.
+ */
+static const char *
+inet_ntop4(const unsigned char *src, char *dst, apr_size_t size)
+{
+	const apr_size_t MIN_SIZE = 16; /* space for 255.255.255.255\0 */
+	int n = 0;
+	char *next = dst;
+
+	if (size < MIN_SIZE) {
+	    errno = ENOSPC;
+	    return NULL;
+	}
+	do {
+	    unsigned char u = *src++;
+	    if (u > 99) {
+		*next++ = '0' + u/100;
+		u %= 100;
+		*next++ = '0' + u/10;
+		u %= 10;
+	    }
+	    else if (u > 9) {
+		*next++ = '0' + u/10;
+		u %= 10;
+	    }
+	    *next++ = '0' + u;
+	    *next++ = '.';
+	    n++;
+	} while (n < 4);
+	*--next = 0;
+	return dst;
+}
+
+#if APR_HAVE_IPV6
+/* const char *
+ * inet_ntop6(src, dst, size)
+ *	convert IPv6 binary address into presentation (printable) format
+ * author:
+ *	Paul Vixie, 1996.
+ */
+static const char *
+inet_ntop6(const unsigned char *src, char *dst, apr_size_t size)
+{
+    /*
+     * Note that int32_t and int16_t need only be "at least" large enough
+     * to contain a value of the specified size.  On some systems, like
+     * Crays, there is no such thing as an integer variable with 16 bits.
+     * Keep this in mind if you think this function should have been coded
+     * to use pointer overlays.  All the world's not a VAX.
+     */
+    char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"], *tp;
+    struct { int base, len; } best = {-1, 0}, cur = {-1, 0};
+    unsigned int words[IN6ADDRSZ / INT16SZ];
+    int i;
+    const unsigned char *next_src, *src_end;
+    unsigned int *next_dest;
+
+    /*
+     * Preprocess:
+     *	Copy the input (bytewise) array into a wordwise array.
+     *	Find the longest run of 0x00's in src[] for :: shorthanding.
+     */
+    next_src = src;
+    src_end = src + IN6ADDRSZ;
+    next_dest = words;
+    i = 0;
+    do {
+        unsigned int next_word = (unsigned int)*next_src++;
+        next_word <<= 8;
+        next_word |= (unsigned int)*next_src++;
+        *next_dest++ = next_word;
+
+        if (next_word == 0) {
+            if (cur.base == -1) {
+                cur.base = i;
+                cur.len = 1;
+            }
+            else {
+                cur.len++;
+            }
+        } else {
+            if (cur.base != -1) {
+                if (best.base == -1 || cur.len > best.len) {
+                    best = cur;
+                }
+                cur.base = -1;
+            }
+        }
+
+        i++;
+    } while (next_src < src_end);
+
+    if (cur.base != -1) {
+        if (best.base == -1 || cur.len > best.len) {
+            best = cur;
+        }
+    }
+    if (best.base != -1 && best.len < 2) {
+        best.base = -1;
+    }
+
+    /*
+     * Format the result.
+     */
+    tp = tmp;
+    for (i = 0; i < (IN6ADDRSZ / INT16SZ);) {
+        /* Are we inside the best run of 0x00's? */
+        if (i == best.base) {
+            *tp++ = ':';
+            i += best.len;
+            continue;
+        }
+        /* Are we following an initial run of 0x00s or any real hex? */
+        if (i != 0) {
+            *tp++ = ':';
+        }
+        /* Is this address an encapsulated IPv4? */
+        if (i == 6 && best.base == 0 &&
+            (best.len == 6 || (best.len == 5 && words[5] == 0xffff))) {
+            if (!inet_ntop4(src+12, tp, sizeof tmp - (tp - tmp))) {
+                return (NULL);
+            }
+            tp += strlen(tp);
+            break;
+        }
+        tp += apr_snprintf(tp, sizeof tmp - (tp - tmp), "%x", words[i]);
+        i++;
+    }
+    /* Was it a trailing run of 0x00's? */
+    if (best.base != -1 && (best.base + best.len) == (IN6ADDRSZ / INT16SZ)) {
+        *tp++ = ':';
+    }
+    *tp++ = '\0';
+
+    /*
+     * Check for overflow, copy, and we're done.
+     */
+    if ((apr_size_t)(tp - tmp) > size) {
+        errno = ENOSPC;
+        return (NULL);
+    }
+    strcpy(dst, tmp);
+    return (dst);
+}
+#endif
diff --git a/network_io/unix/inet_pton.c b/network_io/unix/inet_pton.c
new file mode 100644
index 0000000..d41f749
--- /dev/null
+++ b/network_io/unix/inet_pton.c
@@ -0,0 +1,240 @@
+/* Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ */
+
+#include "apr_private.h"
+#include "apr_arch_networkio.h"
+
+#if APR_HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#if APR_HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+#if APR_HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#if APR_HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#include <string.h>
+#if APR_HAVE_ERRNO_H
+#include <errno.h>
+#endif
+
+#ifndef IN6ADDRSZ
+#define IN6ADDRSZ   16
+#endif
+
+#ifndef INT16SZ
+#define INT16SZ sizeof(apr_int16_t)
+#endif
+
+#ifndef INADDRSZ
+#define INADDRSZ    4
+#endif
+
+#ifndef __P
+#define __P(x) x
+#endif
+
+#if !defined(EAFNOSUPPORT) && defined(WSAEAFNOSUPPORT)
+#define EAFNOSUPPORT WSAEAFNOSUPPORT
+#endif
+
+/*
+ * WARNING: Don't even consider trying to compile this on a system where
+ * sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
+ */
+
+static int	inet_pton4 __P((const char *src, unsigned char *dst));
+#if APR_HAVE_IPV6
+static int	inet_pton6 __P((const char *src, unsigned char *dst));
+#endif
+
+/* int
+ * inet_pton(af, src, dst)
+ *	convert from presentation format (which usually means ASCII printable)
+ *	to network format (which is usually some kind of binary format).
+ * return:
+ *	1 if the address was valid for the specified address family
+ *	0 if the address wasn't valid (`dst' is untouched in this case)
+ *	-1 if some other error occurred (`dst' is untouched in this case, too)
+ * author:
+ *	Paul Vixie, 1996.
+ */
+int
+apr_inet_pton(int af, const char *src, void *dst)
+{
+	switch (af) {
+	case AF_INET:
+		return (inet_pton4(src, dst));
+#if APR_HAVE_IPV6
+	case AF_INET6:
+		return (inet_pton6(src, dst));
+#endif
+	default:
+		errno = EAFNOSUPPORT;
+		return (-1);
+	}
+	/* NOTREACHED */
+}
+
+/* int
+ * inet_pton4(src, dst)
+ *	like inet_aton() but without all the hexadecimal and shorthand.
+ * return:
+ *	1 if `src' is a valid dotted quad, else 0.
+ * notice:
+ *	does not touch `dst' unless it's returning 1.
+ * author:
+ *	Paul Vixie, 1996.
+ */
+static int
+inet_pton4(const char *src, unsigned char *dst)
+{
+    static const char digits[] = "0123456789";
+    int saw_digit, octets, ch;
+    unsigned char tmp[INADDRSZ], *tp;
+
+    saw_digit = 0;
+    octets = 0;
+    *(tp = tmp) = 0;
+    while ((ch = *src++) != '\0') {
+	const char *pch;
+
+	if ((pch = strchr(digits, ch)) != NULL) {
+	    unsigned int new = *tp * 10 + (unsigned int)(pch - digits);
+
+	    if (new > 255)
+		return (0);
+	    *tp = new;
+	    if (! saw_digit) {
+		if (++octets > 4)
+		    return (0);
+		saw_digit = 1;
+	    }
+	} else if (ch == '.' && saw_digit) {
+	    if (octets == 4)
+		return (0);
+	    *++tp = 0;
+	    saw_digit = 0;
+	} else
+		return (0);
+    }
+    if (octets < 4)
+	return (0);
+
+    memcpy(dst, tmp, INADDRSZ);
+    return (1);
+}
+
+#if APR_HAVE_IPV6
+/* int
+ * inet_pton6(src, dst)
+ *	convert presentation level address to network order binary form.
+ * return:
+ *	1 if `src' is a valid [RFC1884 2.2] address, else 0.
+ * notice:
+ *	(1) does not touch `dst' unless it's returning 1.
+ *	(2) :: in a full address is silently ignored.
+ * credit:
+ *	inspired by Mark Andrews.
+ * author:
+ *	Paul Vixie, 1996.
+ */
+static int
+inet_pton6(const char *src, unsigned char *dst)
+{
+	static const char xdigits_l[] = "0123456789abcdef",
+			  xdigits_u[] = "0123456789ABCDEF";
+	unsigned char tmp[IN6ADDRSZ], *tp, *endp, *colonp;
+	const char *xdigits, *curtok;
+	int ch, saw_xdigit;
+	unsigned int val;
+
+	memset((tp = tmp), '\0', IN6ADDRSZ);
+	endp = tp + IN6ADDRSZ;
+	colonp = NULL;
+	/* Leading :: requires some special handling. */
+	if (*src == ':')
+		if (*++src != ':')
+			return (0);
+	curtok = src;
+	saw_xdigit = 0;
+	val = 0;
+	while ((ch = *src++) != '\0') {
+		const char *pch;
+
+		if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
+			pch = strchr((xdigits = xdigits_u), ch);
+		if (pch != NULL) {
+			val <<= 4;
+			val |= (pch - xdigits);
+			if (val > 0xffff)
+				return (0);
+			saw_xdigit = 1;
+			continue;
+		}
+		if (ch == ':') {
+			curtok = src;
+			if (!saw_xdigit) {
+				if (colonp)
+					return (0);
+				colonp = tp;
+				continue;
+			}
+			if (tp + INT16SZ > endp)
+				return (0);
+			*tp++ = (unsigned char) (val >> 8) & 0xff;
+			*tp++ = (unsigned char) val & 0xff;
+			saw_xdigit = 0;
+			val = 0;
+			continue;
+		}
+		if (ch == '.' && ((tp + INADDRSZ) <= endp) &&
+		    inet_pton4(curtok, tp) > 0) {
+			tp += INADDRSZ;
+			saw_xdigit = 0;
+			break;	/* '\0' was seen by inet_pton4(). */
+		}
+		return (0);
+	}
+	if (saw_xdigit) {
+		if (tp + INT16SZ > endp)
+			return (0);
+		*tp++ = (unsigned char) (val >> 8) & 0xff;
+		*tp++ = (unsigned char) val & 0xff;
+	}
+	if (colonp != NULL) {
+		/*
+		 * Since some memmove()'s erroneously fail to handle
+		 * overlapping regions, we'll do the shift by hand.
+		 */
+		const apr_ssize_t n = tp - colonp;
+		apr_ssize_t i;
+
+		for (i = 1; i <= n; i++) {
+			endp[- i] = colonp[n - i];
+			colonp[n - i] = 0;
+		}
+		tp = endp;
+	}
+	if (tp != endp)
+		return (0);
+	memcpy(dst, tmp, IN6ADDRSZ);
+	return (1);
+}
+#endif
diff --git a/network_io/unix/multicast.c b/network_io/unix/multicast.c
new file mode 100644
index 0000000..a604b06
--- /dev/null
+++ b/network_io/unix/multicast.c
@@ -0,0 +1,313 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_network_io.h"
+#include "apr_support.h"
+#include "apr_portable.h"
+#include "apr_arch_inherit.h"
+
+#ifdef HAVE_GETIFADDRS
+#include <net/if.h>
+#include <ifaddrs.h>
+#endif
+
+#ifdef HAVE_STRUCT_IPMREQ
+static void fill_mip_v4(struct ip_mreq *mip, apr_sockaddr_t *mcast,
+                        apr_sockaddr_t *iface)
+{
+    mip->imr_multiaddr = mcast->sa.sin.sin_addr;
+    if (iface == NULL) {
+        mip->imr_interface.s_addr = INADDR_ANY;
+    }
+    else {
+        mip->imr_interface = iface->sa.sin.sin_addr;
+    }
+}
+
+/* This function is only interested in AF_INET6 sockets, so a noop
+ * "return 0" implementation for the !APR_HAVE_IPV6 build is
+ * sufficient. */
+static unsigned int find_if_index(const apr_sockaddr_t *iface)
+{
+    unsigned int index = 0;
+#if defined(HAVE_GETIFADDRS) && APR_HAVE_IPV6 
+    struct ifaddrs *ifp, *ifs;
+
+    /**
+     * TODO: getifaddrs is only portable to *BSD and OS X. Using ioctl 
+     *       and SIOCGIFCONF is needed for Linux/Solaris support.
+     *       
+     *       There is a wrapper that takes the messy ioctl interface into 
+     *       getifaddrs. The license is acceptable, but, It is a fairly large 
+     *       chunk of code.
+     */
+    if (getifaddrs(&ifs) != 0) {
+        return 0;
+    }
+
+    for (ifp = ifs; ifp; ifp = ifp->ifa_next) {
+        if (ifp->ifa_addr != NULL && ifp->ifa_addr->sa_family == AF_INET6) {
+            if (memcmp(&iface->sa.sin6.sin6_addr,
+                       &((struct sockaddr_in6*)ifp->ifa_addr)->sin6_addr,
+                       sizeof(iface->sa.sin6.sin6_addr)) == 0) {
+                index = if_nametoindex(ifp->ifa_name);
+                break;
+            }
+        }
+    }
+
+    freeifaddrs(ifs);
+#endif
+    return index;
+}
+
+#if APR_HAVE_IPV6
+static void fill_mip_v6(struct ipv6_mreq *mip, const apr_sockaddr_t *mcast,
+                        const apr_sockaddr_t *iface)
+{
+    memcpy(&mip->ipv6mr_multiaddr, mcast->ipaddr_ptr,
+           sizeof(mip->ipv6mr_multiaddr));
+
+    if (iface == NULL) {
+        mip->ipv6mr_interface = 0;
+    }
+    else {
+        mip->ipv6mr_interface = find_if_index(iface);
+    }
+}
+
+#endif
+
+static int sock_is_ipv4(apr_socket_t *sock)
+{
+    if (sock->local_addr->family == APR_INET)
+        return 1;
+    return 0;
+}
+
+#if APR_HAVE_IPV6
+static int sock_is_ipv6(apr_socket_t *sock)
+{
+    if (sock->local_addr->family == APR_INET6)
+        return 1;
+    return 0;
+}
+#endif
+
+static apr_status_t do_mcast(int type, apr_socket_t *sock,
+                             apr_sockaddr_t *mcast, apr_sockaddr_t *iface,
+                             apr_sockaddr_t *source)
+{
+    struct ip_mreq mip4;
+    apr_status_t rv = APR_SUCCESS;
+#if APR_HAVE_IPV6
+    struct ipv6_mreq mip6;
+#endif
+#ifdef GROUP_FILTER_SIZE
+    struct group_source_req mip;
+    int ip_proto;
+#endif
+
+    if (source != NULL) {
+#ifdef GROUP_FILTER_SIZE
+        if (sock_is_ipv4(sock)) {
+            ip_proto = IPPROTO_IP;
+        } 
+#if APR_HAVE_IPV6
+        else if (sock_is_ipv6(sock)) {
+            ip_proto = IPPROTO_IPV6;
+        }
+#endif
+        else {
+            return APR_ENOTIMPL;
+        }
+
+        if (type == IP_ADD_MEMBERSHIP)
+            type = MCAST_JOIN_SOURCE_GROUP;
+        else if (type == IP_DROP_MEMBERSHIP)
+            type = MCAST_LEAVE_SOURCE_GROUP;
+        else
+            return APR_ENOTIMPL;
+
+        mip.gsr_interface = find_if_index(iface);
+        memcpy(&mip.gsr_group, mcast->ipaddr_ptr, sizeof(mip.gsr_group));
+        memcpy(&mip.gsr_source, source->ipaddr_ptr, sizeof(mip.gsr_source));
+
+        if (setsockopt(sock->socketdes, ip_proto, type, (const void *) &mip,
+                       sizeof(mip)) == -1) {
+            rv = errno;
+        }
+#else
+        /* We do not support Source-Specific Multicast. */
+        return APR_ENOTIMPL;
+#endif
+    }
+    else {
+        if (sock_is_ipv4(sock)) {
+
+            fill_mip_v4(&mip4, mcast, iface);
+
+            if (setsockopt(sock->socketdes, IPPROTO_IP, type,
+                           (const void *) &mip4, sizeof(mip4)) == -1) {
+                rv = errno;
+            }
+        }
+#if APR_HAVE_IPV6 && defined(IPV6_JOIN_GROUP) && defined(IPV6_LEAVE_GROUP)
+        else if (sock_is_ipv6(sock)) {
+            if (type == IP_ADD_MEMBERSHIP) {
+                type = IPV6_JOIN_GROUP;
+            }
+            else if (type == IP_DROP_MEMBERSHIP) {
+                type = IPV6_LEAVE_GROUP;
+            }
+            else {
+                return APR_ENOTIMPL;
+            }
+
+            fill_mip_v6(&mip6, mcast, iface);
+
+            if (setsockopt(sock->socketdes, IPPROTO_IPV6, type,
+                           (const void *) &mip6, sizeof(mip6)) == -1) {
+                rv = errno;
+            }
+        }
+#endif
+        else {
+            rv = APR_ENOTIMPL;
+        }
+    }
+    return rv;
+}
+
+/* Set the IP_MULTICAST_TTL or IP_MULTICAST_LOOP option, or IPv6
+ * equivalents, for the socket, to the given value.  Note that this
+ * function *only works* for those particular option types. */
+static apr_status_t do_mcast_opt(int type, apr_socket_t *sock,
+                                 apr_byte_t value)
+{
+    apr_status_t rv = APR_SUCCESS;
+
+    if (sock_is_ipv4(sock)) {
+        /* For the IP_MULTICAST_* options, this must be a (char *)
+         * pointer. */
+        if (setsockopt(sock->socketdes, IPPROTO_IP, type,
+                       (const void *) &value, sizeof(value)) == -1) {
+            rv = errno;
+        }
+    }
+#if APR_HAVE_IPV6
+    else if (sock_is_ipv6(sock)) {
+        /* For the IPV6_* options, an (int *) pointer must be used. */
+        int ivalue = value;
+
+        if (type == IP_MULTICAST_TTL) {
+            type = IPV6_MULTICAST_HOPS;
+        }
+        else if (type == IP_MULTICAST_LOOP) {
+            type = IPV6_MULTICAST_LOOP;
+        }
+        else {
+            return APR_ENOTIMPL;
+        }
+
+        if (setsockopt(sock->socketdes, IPPROTO_IPV6, type,
+                       (const void *) &ivalue, sizeof(ivalue)) == -1) {
+            rv = errno;
+        }
+    }
+#endif
+    else {
+        rv = APR_ENOTIMPL;
+    }
+
+    return rv;
+}
+#endif
+
+APR_DECLARE(apr_status_t) apr_mcast_join(apr_socket_t *sock,
+                                         apr_sockaddr_t *join,
+                                         apr_sockaddr_t *iface,
+                                         apr_sockaddr_t *source)
+{
+#if defined(IP_ADD_MEMBERSHIP) && defined(HAVE_STRUCT_IPMREQ)
+    return do_mcast(IP_ADD_MEMBERSHIP, sock, join, iface, source);
+#else
+    return APR_ENOTIMPL;
+#endif
+}
+
+APR_DECLARE(apr_status_t) apr_mcast_leave(apr_socket_t *sock,
+                                          apr_sockaddr_t *addr,
+                                          apr_sockaddr_t *iface,
+                                          apr_sockaddr_t *source)
+{
+#if defined(IP_DROP_MEMBERSHIP) && defined(HAVE_STRUCT_IPMREQ)
+    return do_mcast(IP_DROP_MEMBERSHIP, sock, addr, iface, source);
+#else
+    return APR_ENOTIMPL;
+#endif
+}
+
+APR_DECLARE(apr_status_t) apr_mcast_hops(apr_socket_t *sock, apr_byte_t ttl)
+{
+#if defined(IP_MULTICAST_TTL) && defined(HAVE_STRUCT_IPMREQ)
+    return do_mcast_opt(IP_MULTICAST_TTL, sock, ttl);
+#else
+    return APR_ENOTIMPL;
+#endif
+}
+
+APR_DECLARE(apr_status_t) apr_mcast_loopback(apr_socket_t *sock,
+                                             apr_byte_t opt)
+{
+#if defined(IP_MULTICAST_LOOP) && defined(HAVE_STRUCT_IPMREQ)
+    return do_mcast_opt(IP_MULTICAST_LOOP, sock, opt);
+#else
+    return APR_ENOTIMPL;
+#endif
+}
+
+APR_DECLARE(apr_status_t) apr_mcast_interface(apr_socket_t *sock,
+                                              apr_sockaddr_t *iface)
+{
+#if defined(IP_MULTICAST_IF) && defined(HAVE_STRUCT_IPMREQ)
+    apr_status_t rv = APR_SUCCESS;
+
+    if (sock_is_ipv4(sock)) {
+        if (setsockopt(sock->socketdes, IPPROTO_IP, IP_MULTICAST_IF,
+                       (const void *) &iface->sa.sin.sin_addr,
+                       sizeof(iface->sa.sin.sin_addr)) == -1) {
+            rv = errno;
+        }
+    }
+#if APR_HAVE_IPV6
+    else if (sock_is_ipv6(sock)) {
+        unsigned int idx = find_if_index(iface);
+        if (setsockopt(sock->socketdes, IPPROTO_IPV6, IPV6_MULTICAST_IF,
+                       (const void *) &idx, sizeof(idx)) == -1) {
+            rv = errno;
+        }
+    }
+#endif
+    else {
+        rv = APR_ENOTIMPL;
+    }
+    return rv;
+#else
+    return APR_ENOTIMPL;
+#endif
+}
diff --git a/network_io/unix/sendrecv.c b/network_io/unix/sendrecv.c
new file mode 100644
index 0000000..4c0e0a6
--- /dev/null
+++ b/network_io/unix/sendrecv.c
@@ -0,0 +1,1110 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 */
+
+/* osreldate.h is only needed on FreeBSD for sendfile detection */
+#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;
+    }
+
+    /*
+     * Check if we have a valid address. recvfrom() with MSG_PEEK may return
+     * success without filling in the address.
+     */
+    if (from->salen > APR_OFFSETOF(struct sockaddr_in, sin_port)) {
+        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
+
+/* 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(__GNU__)) && 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
+    /* 64-bit apr_off_t but no sendfile64(): fail if trying to send
+     * past the 2Gb limit. */
+    off_t off;
+    
+    if ((apr_int64_t)*offset + *len > INT_MAX) {
+        return EINVAL;
+    }
+    
+    off = *offset;
+
+#else
+    off_t off = *offset;
+
+    /* Multiple reports have shown sendfile failing with EINVAL if
+     * passed a >=2Gb count value on some 64-bit kernels.  It won't
+     * noticably hurt performance to limit each call to <2Gb at a
+     * time, so avoid that issue here: */
+    if (sizeof(off_t) == 8 && *len > INT_MAX) {
+        *len = INT_MAX;
+    }
+#endif
+
+    if (!hdtr) {
+        hdtr = &no_hdtr;
+    }
+
+    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);
+
+    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,    /* 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(DARWIN)
+
+/* OS/X Release 10.5 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)
+{
+    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;
+
+    /* Ignore flags for now. */
+    flags = 0;
+
+    if (!hdtr) {
+        hdtr = &no_hdtr;
+    }
+
+    /* OS X can send the headers/footers as part of the system call, 
+     * but how it counts bytes isn't documented properly. We use 
+     * apr_socket_sendv() instead.
+     */
+     if (hdtr->numheaders > 0) {
+        apr_size_t hbytes;
+        int i;
+
+        /* Now write the headers */
+        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, /* file to be sent */
+                      sock->socketdes, /* socket */
+                      *offset,       /* where in the file to start */
+                      &nbytes,       /* number of bytes to write/written */
+                      NULL,          /* Headers/footers */
+                      flags);        /* undefined, set to 0 */
+
+        if (rv == -1) {
+            if (errno == EAGAIN) {
+                if (sock->timeout > 0) {
+                    sock->options |= APR_INCOMPLETE_WRITE;
+                }
+                /* BSD'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) {
+                    bytes_sent += nbytes;
+                    /* normal exit for a big file & non-blocking io */
+                    (*len) = bytes_sent;
+                    return APR_SUCCESS;
+                }
+            }
+        }
+        else {       /* rv == 0 (or the kernel is broken) */
+            bytes_sent += nbytes;
+            if (nbytes == 0) {
+                /* Most likely the file got smaller after the stat.
+                 * Return an error so the caller can do the Right Thing.
+                 */
+                (*len) = bytes_sent;
+                return APR_EOF;
+            }
+        }
+    } while (rv == -1 && (errno == EINTR || errno == EAGAIN));
+
+    /* Now write the footers */
+    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__)
+
+/* 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;
+#if defined(__FreeBSD_version) && __FreeBSD_version < 460001
+    int i;
+#endif
+    struct sf_hdtr headerstruct;
+    apr_size_t bytes_to_send = *len;
+
+    /* Ignore flags for now. */
+    flags = 0;
+
+    if (!hdtr) {
+        hdtr = &no_hdtr;
+    }
+
+#if defined(__FreeBSD_version) && __FreeBSD_version < 460001
+    else if (hdtr->numheaders) {
+
+        /* 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 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;
+        }
+    }
+#endif
+
+    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 APR_HAS_LARGE_FILES && defined(HAVE_SENDFILE64)
+    /* later HP-UXes have a sendfile64() */
+#define sendfile sendfile64
+    apr_off_t off = *offset;
+
+#elif APR_HAS_LARGE_FILES && SIZEOF_OFF_T == 4
+    /* HP-UX 11.00 doesn't have a sendfile64(): fail if trying to send
+     * past the 2Gb limit */
+    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;
+    }
+
+    /* 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->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;
+        }
+
+        /* XXX:  BUHHH? wow, what a memory leak! */
+        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) {       /* any bytes to send from the file? */
+            rc = sendfile(sock->socketdes,      /* socket  */
+                          file->filedes,        /* file descriptor to send */
+                          off,                  /* 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);
+
+    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,    /* socket  */
+                                  file->filedes,      /* file descriptor to send */
+                                  off,                /* 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->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
+            /* Keepalives make apr_palloc a bad idea */
+            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;
+    }
+
+    /* 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);
+
+    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), /* 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
+ */
+
+#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;
+    }
+
+    /* Ignore flags for now. */
+    flags = 0;
+
+    /* Calculate how much space we need. */
+    vecs = hdtr->numheaders + hdtr->numtrailers + 1;
+    sfv = apr_palloc(sock->pool, 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;
+        /* Cast to unsigned long to prevent sign extension of the
+         * pointer value for the LFS case; see PR 39463. */
+        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 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 = (unsigned long)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 (nbytes == 0) {
+        /* Most likely the file got smaller after the stat.
+         * Return an error so the caller can do the Right Thing.
+         */
+        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 /* __linux__, __FreeBSD__, __DragonFly__, __HPUX__, _AIX, __MVS__,
+	  Tru64/OSF1 */
+
+#endif /* APR_HAS_SENDFILE */
diff --git a/network_io/unix/sockaddr.c b/network_io/unix/sockaddr.c
new file mode 100644
index 0000000..a31867d
--- /dev/null
+++ b/network_io/unix/sockaddr.c
@@ -0,0 +1,1293 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_strings.h"
+#include "apr.h"
+#include "apr_lib.h"
+#include "apr_strings.h"
+#include "apr_private.h"
+
+#if APR_HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef HAVE_NET_IF_H
+#include <net/if.h>
+#endif
+
+#if defined(HAVE_IF_INDEXTONAME) && defined(_MSC_VER)
+#include "arch/win32/apr_arch_misc.h"
+#endif
+
+#define APR_WANT_STRFUNC
+#include "apr_want.h"
+
+struct apr_ipsubnet_t {
+    int family;
+#if APR_HAVE_IPV6
+    apr_uint32_t sub[4]; /* big enough for IPv4 and IPv6 addresses */
+    apr_uint32_t mask[4];
+#else
+    apr_uint32_t sub[1];
+    apr_uint32_t mask[1];
+#endif
+};
+
+#if !defined(NETWARE) && !defined(WIN32)
+#ifdef HAVE_SET_H_ERRNO
+#define SET_H_ERRNO(newval) set_h_errno(newval)
+#else
+#define SET_H_ERRNO(newval) h_errno = (newval)
+#endif
+#else
+#define SET_H_ERRNO(newval)
+#endif
+
+#if APR_HAS_THREADS && !defined(GETHOSTBYNAME_IS_THREAD_SAFE) && \
+    defined(HAVE_GETHOSTBYNAME_R)
+/* This is the maximum size that may be returned from the reentrant
+ * gethostbyname_r function.  If the system tries to use more, it
+ * should return ERANGE.
+ */
+#define GETHOSTBYNAME_BUFLEN 512
+#endif
+
+#ifdef _AIX
+/* Some levels of AIX getaddrinfo() don't like servname = "0", so
+ * set servname to "1" when port is 0 and fix it up later.
+ */
+#define AIX_SERVNAME_HACK 1
+#else
+#define AIX_SERVNAME_HACK 0
+#endif
+
+#ifdef _WIN32_WCE
+/* XXX: BS solution.  Need an HAVE_GETSERVBYNAME and actually
+ * do something here, to provide the obvious proto mappings.
+ */
+static void *getservbyname(const char *name, const char *proto)
+{
+    return NULL;
+}
+#endif
+
+static apr_status_t get_local_addr(apr_socket_t *sock)
+{
+    sock->local_addr->salen = sizeof(sock->local_addr->sa);
+    if (getsockname(sock->socketdes, (struct sockaddr *)&sock->local_addr->sa,
+                    &sock->local_addr->salen) < 0) {
+        return apr_get_netos_error();
+    }
+    else {
+        sock->local_port_unknown = sock->local_interface_unknown = 0;
+        /* XXX assumes sin_port and sin6_port at same offset */
+        sock->local_addr->port = ntohs(sock->local_addr->sa.sin.sin_port);
+        return APR_SUCCESS;
+    }
+}
+
+static apr_status_t get_remote_addr(apr_socket_t *sock)
+{
+    sock->remote_addr->salen = sizeof(sock->remote_addr->sa);
+    if (getpeername(sock->socketdes, (struct sockaddr *)&sock->remote_addr->sa,
+                    &sock->remote_addr->salen) < 0) {
+        return apr_get_netos_error();
+    }
+    else {
+        sock->remote_addr_unknown = 0;
+        /* XXX assumes sin_port and sin6_port at same offset */
+        sock->remote_addr->port = ntohs(sock->remote_addr->sa.sin.sin_port);
+        return APR_SUCCESS;
+    }
+}
+
+APR_DECLARE(apr_status_t) apr_sockaddr_ip_getbuf(char *buf, apr_size_t buflen,
+                                                 apr_sockaddr_t *sockaddr)
+{
+#if APR_HAVE_SOCKADDR_UN
+    if (sockaddr->family == APR_UNIX) {
+        const char *ptr = sockaddr->ipaddr_ptr;
+        apr_size_t len = apr_cpystrn(buf, ptr, buflen) - buf;
+        /* assumes that sockaddr->ipaddr_ptr is nul terminated */
+        return ptr[len] ? APR_ENOSPC : APR_SUCCESS;
+    }
+#endif
+
+    if (!apr_inet_ntop(sockaddr->family, sockaddr->ipaddr_ptr, buf, buflen)) {
+        return APR_ENOSPC;
+    }
+
+#if APR_HAVE_IPV6
+    if (sockaddr->family == AF_INET6 
+        && IN6_IS_ADDR_V4MAPPED((struct in6_addr *)sockaddr->ipaddr_ptr)
+        && buflen > strlen("::ffff:")) {
+        /* This is an IPv4-mapped IPv6 address; drop the leading
+         * part of the address string so we're left with the familiar
+         * IPv4 format.
+         */
+        memmove(buf, buf + strlen("::ffff:"),
+                strlen(buf + strlen("::ffff:"))+1);
+    }
+
+    /* ensure NUL termination if the buffer is too short */
+    buf[buflen-1] = '\0';
+
+#ifdef HAVE_IF_INDEXTONAME
+    /* Append scope name for link-local addresses. */
+    if (sockaddr->family == AF_INET6
+        && IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)sockaddr->ipaddr_ptr)) {
+        char scbuf[IF_NAMESIZE], *p = buf + strlen(buf);
+
+        if (if_indextoname(sockaddr->sa.sin6.sin6_scope_id, scbuf) == scbuf) {
+            /* Space check, need room for buf + '%' + scope + '\0'.
+             * Assert: buflen >= strlen(buf) + strlen(scbuf) + 2
+             * Equiv:  buflen >= (p-buf) + strlen(buf) + 2
+             * Thus, fail in inverse condition: */
+            if (buflen < strlen(scbuf) + (p - buf) + 2) {
+                return APR_ENOSPC;
+            }
+            *p++ = '%';
+            memcpy(p, scbuf, strlen(scbuf) + 1);
+        }
+    }    
+#endif /* HAVE_IF_INDEXTONAME */
+#endif /* APR_HAVE_IPV6 */
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_sockaddr_ip_get(char **addr,
+                                              apr_sockaddr_t *sockaddr)
+{
+    *addr = apr_palloc(sockaddr->pool, sockaddr->addr_str_len);
+    return apr_sockaddr_ip_getbuf(*addr, sockaddr->addr_str_len, sockaddr);
+}
+
+void apr_sockaddr_vars_set(apr_sockaddr_t *addr, int family, apr_port_t port)
+{
+    addr->family = family;
+    addr->sa.sin.sin_family = family;
+    if (port) {
+        /* XXX IPv6: assumes sin_port and sin6_port at same offset */
+        addr->sa.sin.sin_port = htons(port);
+        addr->port = port;
+    }
+#if AIX_SERVNAME_HACK
+    else {
+        addr->sa.sin.sin_port = htons(port);
+    }
+#endif
+
+    if (family == APR_INET) {
+        addr->salen = sizeof(struct sockaddr_in);
+        addr->addr_str_len = 16;
+        addr->ipaddr_ptr = &(addr->sa.sin.sin_addr);
+        addr->ipaddr_len = sizeof(struct in_addr);
+    }
+#if APR_HAVE_IPV6
+    else if (family == APR_INET6) {
+        addr->salen = sizeof(struct sockaddr_in6);
+        addr->addr_str_len = 46;
+        addr->ipaddr_ptr = &(addr->sa.sin6.sin6_addr);
+        addr->ipaddr_len = sizeof(struct in6_addr);
+    }
+#endif
+#if APR_HAVE_SOCKADDR_UN
+    else if (family == APR_UNIX) {
+        addr->salen = sizeof(struct sockaddr_un);
+        addr->addr_str_len = sizeof(addr->sa.unx.sun_path);;
+        addr->ipaddr_ptr = &(addr->sa.unx.sun_path);
+        addr->ipaddr_len = addr->addr_str_len;
+    }
+#endif
+}
+
+APR_DECLARE(apr_status_t) apr_socket_addr_get(apr_sockaddr_t **sa,
+                                           apr_interface_e which,
+                                           apr_socket_t *sock)
+{
+    if (which == APR_LOCAL) {
+        if (sock->local_interface_unknown || sock->local_port_unknown) {
+            apr_status_t rv = get_local_addr(sock);
+
+            if (rv != APR_SUCCESS) {
+                return rv;
+            }
+        }
+        *sa = sock->local_addr;
+    }
+    else if (which == APR_REMOTE) {
+        if (sock->remote_addr_unknown) {
+            apr_status_t rv = get_remote_addr(sock);
+
+            if (rv != APR_SUCCESS) {
+                return rv;
+            }
+        }
+        *sa = sock->remote_addr;
+    }
+    else {
+        *sa = NULL;
+        return APR_EINVAL;
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_parse_addr_port(char **addr,
+                                              char **scope_id,
+                                              apr_port_t *port,
+                                              const char *str,
+                                              apr_pool_t *p)
+{
+    const char *ch, *lastchar;
+    int big_port;
+    apr_size_t addrlen;
+
+    *addr = NULL;         /* assume not specified */
+    *scope_id = NULL;     /* assume not specified */
+    *port = 0;            /* assume not specified */
+
+    /* First handle the optional port number.  That may be all that
+     * is specified in the string.
+     */
+    ch = lastchar = str + strlen(str) - 1;
+    while (ch >= str && apr_isdigit(*ch)) {
+        --ch;
+    }
+
+    if (ch < str) {       /* Entire string is the port. */
+        big_port = atoi(str);
+        if (big_port < 1 || big_port > 65535) {
+            return APR_EINVAL;
+        }
+        *port = big_port;
+        return APR_SUCCESS;
+    }
+
+    if (*ch == ':' && ch < lastchar) { /* host and port number specified */
+        if (ch == str) {               /* string starts with ':' -- bad */
+            return APR_EINVAL;
+        }
+        big_port = atoi(ch + 1);
+        if (big_port < 1 || big_port > 65535) {
+            return APR_EINVAL;
+        }
+        *port = big_port;
+        lastchar = ch - 1;
+    }
+
+    /* now handle the hostname */
+    addrlen = lastchar - str + 1;
+
+/* XXX we don't really have to require APR_HAVE_IPV6 for this; 
+ * just pass char[] for ipaddr (so we don't depend on struct in6_addr)
+ * and always define APR_INET6 
+ */
+#if APR_HAVE_IPV6
+    if (*str == '[') {
+        const char *end_bracket = memchr(str, ']', addrlen);
+        struct in6_addr ipaddr;
+        const char *scope_delim;
+
+        if (!end_bracket || end_bracket != lastchar) {
+            *port = 0;
+            return APR_EINVAL;
+        }
+
+        /* handle scope id; this is the only context where it is allowed */
+        scope_delim = memchr(str, '%', addrlen);
+        if (scope_delim) {
+            if (scope_delim == end_bracket - 1) { /* '%' without scope id */
+                *port = 0;
+                return APR_EINVAL;
+            }
+            addrlen = scope_delim - str - 1;
+            *scope_id = apr_pstrmemdup(p, scope_delim + 1, end_bracket - scope_delim - 1);
+        }
+        else {
+            addrlen = addrlen - 2; /* minus 2 for '[' and ']' */
+        }
+
+        *addr = apr_pstrmemdup(p, str + 1, addrlen);
+        if (apr_inet_pton(AF_INET6, *addr, &ipaddr) != 1) {
+            *addr = NULL;
+            *scope_id = NULL;
+            *port = 0;
+            return APR_EINVAL;
+        }
+    }
+    else 
+#endif
+    {
+        /* XXX If '%' is not a valid char in a DNS name, we *could* check 
+         *     for bogus scope ids first.
+         */
+        *addr = apr_pstrmemdup(p, str, addrlen);
+    }
+    return APR_SUCCESS;
+}
+
+#if defined(HAVE_GETADDRINFO)
+
+static apr_status_t call_resolver(apr_sockaddr_t **sa,
+                                  const char *hostname, apr_int32_t family,
+                                  apr_port_t port, apr_int32_t flags, 
+                                  apr_pool_t *p)
+{
+    struct addrinfo hints, *ai, *ai_list;
+    apr_sockaddr_t *prev_sa;
+    int error;
+    char *servname = NULL; 
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = family;
+    hints.ai_socktype = SOCK_STREAM;
+#ifdef HAVE_GAI_ADDRCONFIG
+    if (family == APR_UNSPEC) {
+        /* By default, only look up addresses using address types for
+         * which a local interface is configured, i.e. no IPv6 if no
+         * IPv6 interfaces configured. */
+        hints.ai_flags = AI_ADDRCONFIG;
+    }
+#endif
+
+#ifdef __MVS__
+    /* z/OS will not return IPv4 address under AF_UNSPEC if any IPv6 results 
+     * are returned, w/o AI_ALL. 
+     */
+    if (family == APR_UNSPEC) { 
+       hints.ai_flags |= AI_ALL;
+    }
+#endif
+
+    if(hostname == NULL) {
+#ifdef AI_PASSIVE 
+        /* If hostname is NULL, assume we are trying to bind to all
+         * interfaces. */
+        hints.ai_flags |= AI_PASSIVE;
+#endif
+        /* getaddrinfo according to RFC 2553 must have either hostname
+         * or servname non-NULL.
+         */
+#ifdef OSF1
+        /* The Tru64 5.0 getaddrinfo() can only resolve services given
+         * by the name listed in /etc/services; a numeric or unknown
+         * servname gets an EAI_SERVICE error.  So just resolve the
+         * appropriate anyaddr and fill in the port later. */
+        hostname = family == AF_INET6 ? "::" : "0.0.0.0";
+        servname = NULL;
+#ifdef AI_NUMERICHOST
+        hints.ai_flags |= AI_NUMERICHOST;
+#endif
+#else
+#if AIX_SERVNAME_HACK
+        if (!port) {
+            servname = "1";
+        }
+        else
+#endif /* AIX_SERVNAME_HACK */
+        servname = apr_itoa(p, port);
+#endif /* OSF1 */
+    }
+    error = getaddrinfo(hostname, servname, &hints, &ai_list);
+#ifdef HAVE_GAI_ADDRCONFIG
+    /*
+     * Using AI_ADDRCONFIG involves some unfortunate guesswork because it
+     * does not consider loopback addresses when trying to determine if
+     * IPv4 or IPv6 is configured on a system (see RFC 3493).
+     * This is a problem if one actually wants to listen on or connect to
+     * the loopback address of a protocol family that is not otherwise
+     * configured on the system. See PR 52709.
+     * To work around some of the problems, retry without AI_ADDRCONFIG
+     * in case of EAI_ADDRFAMILY.
+     * XXX: apr_sockaddr_info_get() should really accept a flag to determine
+     * XXX: if AI_ADDRCONFIG's guesswork is wanted and if the address is
+     * XXX: to be used for listen() or connect().
+     *
+     * In case of EAI_BADFLAGS, AI_ADDRCONFIG is not supported.
+     */
+    if ((family == APR_UNSPEC) && (error == EAI_BADFLAGS
+#ifdef EAI_ADDRFAMILY
+                                   || error == EAI_ADDRFAMILY
+#endif
+                                                             )) {
+        hints.ai_flags &= ~AI_ADDRCONFIG;
+        error = getaddrinfo(hostname, servname, &hints, &ai_list);
+    }
+#endif
+    if (error) {
+#if defined(WIN32)
+        return apr_get_netos_error();
+#else
+        if (error == EAI_SYSTEM) {
+            return errno ? errno : APR_EGENERAL;
+        }
+        else 
+        {
+            /* issues with representing this with APR's error scheme:
+             * glibc uses negative values for these numbers, perhaps so 
+             * they don't conflict with h_errno values...  Tru64 uses 
+             * positive values which conflict with h_errno values
+             */
+#if defined(NEGATIVE_EAI)
+            error = -error;
+#endif
+            return error + APR_OS_START_EAIERR;
+        }
+#endif /* WIN32 */
+    }
+
+    prev_sa = NULL;
+    ai = ai_list;
+    while (ai) { /* while more addresses to report */
+        apr_sockaddr_t *new_sa;
+
+        /* Ignore anything bogus: getaddrinfo in some old versions of
+         * glibc will return AF_UNIX entries for APR_UNSPEC+AI_PASSIVE
+         * lookups. */
+#if APR_HAVE_IPV6
+        if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6) {
+#else
+        if (ai->ai_family != AF_INET) {
+#endif
+            ai = ai->ai_next;
+            continue;
+        }
+
+        new_sa = apr_pcalloc(p, sizeof(apr_sockaddr_t));
+
+        new_sa->pool = p;
+        memcpy(&new_sa->sa, ai->ai_addr, ai->ai_addrlen);
+        apr_sockaddr_vars_set(new_sa, ai->ai_family, port);
+
+        if (!prev_sa) { /* first element in new list */
+            if (hostname) {
+                new_sa->hostname = apr_pstrdup(p, hostname);
+            }
+            *sa = new_sa;
+        }
+        else {
+            new_sa->hostname = prev_sa->hostname;
+            prev_sa->next = new_sa;
+        }
+
+        prev_sa = new_sa;
+        ai = ai->ai_next;
+    }
+    freeaddrinfo(ai_list);
+
+    if (prev_sa == NULL) {
+        /*
+         * getaddrinfo returned only useless entries and *sa is still empty.
+         * This should be treated as an error.
+         */
+        return APR_EGENERAL;
+    }
+
+    return APR_SUCCESS;
+}
+
+static apr_status_t find_addresses(apr_sockaddr_t **sa, 
+                                   const char *hostname, apr_int32_t family,
+                                   apr_port_t port, apr_int32_t flags, 
+                                   apr_pool_t *p)
+{
+    if (flags & APR_IPV4_ADDR_OK) {
+        apr_status_t error = call_resolver(sa, hostname, AF_INET, port, flags, p);
+
+#if APR_HAVE_IPV6
+        if (error) {
+            family = AF_INET6; /* try again */
+        }
+        else
+#endif
+        return error;
+    }
+#if APR_HAVE_IPV6
+    else if (flags & APR_IPV6_ADDR_OK) {
+        apr_status_t error = call_resolver(sa, hostname, AF_INET6, port, flags, p);
+
+        if (error) {
+            family = AF_INET; /* try again */
+        }
+        else {
+            return APR_SUCCESS;
+        }
+    }
+#endif
+
+    return call_resolver(sa, hostname, family, port, flags, p);
+}
+
+#else /* end of HAVE_GETADDRINFO code */
+
+static apr_status_t find_addresses(apr_sockaddr_t **sa, 
+                                   const char *hostname, apr_int32_t family,
+                                   apr_port_t port, apr_int32_t flags, 
+                                   apr_pool_t *p)
+{
+    struct hostent *hp;
+    apr_sockaddr_t *prev_sa;
+    int curaddr;
+#if APR_HAS_THREADS && !defined(GETHOSTBYNAME_IS_THREAD_SAFE) && \
+    defined(HAVE_GETHOSTBYNAME_R) && !defined(BEOS)
+#ifdef GETHOSTBYNAME_R_HOSTENT_DATA
+    struct hostent_data hd;
+#else
+    /* If you see ERANGE, that means GETHOSBYNAME_BUFLEN needs to be
+     * bumped. */
+    char tmp[GETHOSTBYNAME_BUFLEN];
+#endif
+    int hosterror;
+#endif
+    struct hostent hs;
+    struct in_addr ipaddr;
+    char *addr_list[2];
+    const char *orig_hostname = hostname;
+
+    if (hostname == NULL) {
+        /* if we are given a NULL hostname, assume '0.0.0.0' */
+        hostname = "0.0.0.0";
+    }
+
+    if (*hostname >= '0' && *hostname <= '9' &&
+        strspn(hostname, "0123456789.") == strlen(hostname)) {
+
+        ipaddr.s_addr = inet_addr(hostname);
+        addr_list[0] = (char *)&ipaddr;
+        addr_list[1] = NULL; /* just one IP in list */
+        hs.h_addr_list = (char **)addr_list;
+        hp = &hs;
+    }
+    else {
+#if APR_HAS_THREADS && !defined(GETHOSTBYNAME_IS_THREAD_SAFE) && \
+    defined(HAVE_GETHOSTBYNAME_R) && !defined(BEOS)
+#if defined(GETHOSTBYNAME_R_HOSTENT_DATA)
+        /* AIX, HP/UX, D/UX et alia */
+        gethostbyname_r(hostname, &hs, &hd);
+        hp = &hs;
+#else
+#if defined(GETHOSTBYNAME_R_GLIBC2)
+        /* Linux glibc2+ */
+        gethostbyname_r(hostname, &hs, tmp, GETHOSTBYNAME_BUFLEN - 1, 
+                        &hp, &hosterror);
+#else
+        /* Solaris, Irix et alia */
+        hp = gethostbyname_r(hostname, &hs, tmp, GETHOSTBYNAME_BUFLEN - 1,
+                             &hosterror);
+#endif /* !defined(GETHOSTBYNAME_R_GLIBC2) */
+        if (!hp) {
+            return (hosterror + APR_OS_START_SYSERR);
+        }
+#endif /* !defined(GETHOSTBYNAME_R_HOSTENT_DATA) */
+#else
+        hp = gethostbyname(hostname);
+#endif
+
+        if (!hp) {
+#ifdef WIN32
+            return apr_get_netos_error();
+#else
+            return (h_errno + APR_OS_START_SYSERR);
+#endif
+        }
+    }
+
+    prev_sa = NULL;
+    curaddr = 0;
+    while (hp->h_addr_list[curaddr]) {
+        apr_sockaddr_t *new_sa = apr_pcalloc(p, sizeof(apr_sockaddr_t));
+
+        new_sa->pool = p;
+        new_sa->sa.sin.sin_addr = *(struct in_addr *)hp->h_addr_list[curaddr];
+        apr_sockaddr_vars_set(new_sa, AF_INET, port);
+
+        if (!prev_sa) { /* first element in new list */
+            if (orig_hostname) {
+                new_sa->hostname = apr_pstrdup(p, orig_hostname);
+            }
+            *sa = new_sa;
+        }
+        else {
+            new_sa->hostname = prev_sa->hostname;
+            prev_sa->next = new_sa;
+        }
+
+        prev_sa = new_sa;
+        ++curaddr;
+    }
+
+    if (prev_sa == NULL) {
+        /* this should not happen but no result should be treated as error */
+        return APR_EGENERAL;
+    }
+
+    return APR_SUCCESS;
+}
+
+#endif /* end of !HAVE_GETADDRINFO code */
+
+APR_DECLARE(apr_status_t) apr_sockaddr_info_get(apr_sockaddr_t **sa,
+                                                const char *hostname, 
+                                                apr_int32_t family, apr_port_t port,
+                                                apr_int32_t flags, apr_pool_t *p)
+{
+    apr_int32_t masked;
+    *sa = NULL;
+
+    if ((masked = flags & (APR_IPV4_ADDR_OK | APR_IPV6_ADDR_OK))) {
+        if (!hostname ||
+            family != APR_UNSPEC ||
+            masked == (APR_IPV4_ADDR_OK | APR_IPV6_ADDR_OK)) {
+            return APR_EINVAL;
+        }
+#if !APR_HAVE_IPV6
+        if (flags & APR_IPV6_ADDR_OK) {
+            return APR_ENOTIMPL;
+        }
+#endif
+    }
+    if (family == APR_UNSPEC && hostname && *hostname == '/') {
+        family = APR_UNIX;
+    }
+    if (family == APR_UNIX) {
+#if APR_HAVE_SOCKADDR_UN
+        if (hostname && *hostname == '/') {
+            *sa = apr_pcalloc(p, sizeof(apr_sockaddr_t));
+            (*sa)->pool = p;
+            apr_cpystrn((*sa)->sa.unx.sun_path, hostname,
+                        sizeof((*sa)->sa.unx.sun_path));
+            (*sa)->hostname = apr_pstrdup(p, hostname);
+            (*sa)->family = APR_UNIX;
+            (*sa)->sa.unx.sun_family = APR_UNIX;
+            (*sa)->salen = sizeof(struct sockaddr_un);
+            (*sa)->addr_str_len = sizeof((*sa)->sa.unx.sun_path);
+            (*sa)->ipaddr_ptr = &((*sa)->sa.unx.sun_path);
+            (*sa)->ipaddr_len = (*sa)->addr_str_len;
+
+            return APR_SUCCESS;
+        }
+        else
+#endif
+        {
+            *sa = NULL;
+            return APR_ENOTIMPL;
+        }
+    }
+#if !APR_HAVE_IPV6
+    /* What may happen is that APR is not IPv6-enabled, but we're still
+     * going to call getaddrinfo(), so we have to tell the OS we only
+     * want IPv4 addresses back since we won't know what to do with
+     * IPv6 addresses.
+     */
+    if (family == APR_UNSPEC) {
+        family = APR_INET;
+    }
+#endif
+
+    return find_addresses(sa, hostname, family, port, flags, p);
+}
+
+APR_DECLARE(apr_status_t) apr_sockaddr_info_copy(apr_sockaddr_t **dst,
+                                                 const apr_sockaddr_t *src,
+                                                 apr_pool_t *p)
+{
+    apr_sockaddr_t *d;
+    const apr_sockaddr_t *s;
+
+    for (*dst = d = NULL, s = src; s; s = s->next) {
+        if (!d) {
+            *dst = d = apr_pmemdup(p, s, sizeof *s);
+        }
+        else {
+            d = d->next = apr_pmemdup(p, s, sizeof *s);
+        }
+        if (s->hostname) {
+            if (s == src || s->hostname != src->hostname) {
+                d->hostname = apr_pstrdup(p, s->hostname);
+            }
+            else {
+                d->hostname = (*dst)->hostname;
+            }
+        }
+        if (s->servname) {
+            if (s == src || s->servname != src->servname) {
+                d->servname = apr_pstrdup(p, s->servname);
+            }
+            else {
+                d->servname = (*dst)->servname;
+            }
+        }
+        d->pool = p;
+        apr_sockaddr_vars_set(d, s->family, s->port);
+    }
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_getnameinfo(char **hostname,
+                                          apr_sockaddr_t *sockaddr,
+                                          apr_int32_t flags)
+{
+#if defined(HAVE_GETNAMEINFO)
+    int rc;
+#if defined(NI_MAXHOST)
+    char tmphostname[NI_MAXHOST];
+#else
+    char tmphostname[256];
+#endif
+
+    /* don't know if it is portable for getnameinfo() to set h_errno;
+     * clear it then see if it was set */
+    SET_H_ERRNO(0);
+
+    /* default flags are NI_NAMREQD; otherwise, getnameinfo() will return
+     * a numeric address string if it fails to resolve the host name;
+     * that is *not* what we want here
+     *
+     * For IPv4-mapped IPv6 addresses, drop down to IPv4 before calling
+     * getnameinfo() to avoid getnameinfo bugs (MacOS X, glibc).
+     */
+#if APR_HAVE_IPV6
+    if (sockaddr->family == AF_INET6 &&
+        IN6_IS_ADDR_V4MAPPED(&sockaddr->sa.sin6.sin6_addr)) {
+        struct sockaddr_in tmpsa;
+        tmpsa.sin_family = AF_INET;
+        tmpsa.sin_port = 0;
+        tmpsa.sin_addr.s_addr = ((apr_uint32_t *)sockaddr->ipaddr_ptr)[3];
+#ifdef SIN6_LEN
+        tmpsa.sin_len = sizeof(tmpsa);
+#endif
+
+        rc = getnameinfo((const struct sockaddr *)&tmpsa, sizeof(tmpsa),
+                         tmphostname, sizeof(tmphostname), NULL, 0,
+                         flags != 0 ? flags : NI_NAMEREQD);
+    }
+#if APR_HAVE_SOCKADDR_UN
+    else if (sockaddr->family == APR_UNIX) {
+        *hostname = sockaddr->hostname;
+        return APR_SUCCESS;
+    }
+#endif
+    else
+#endif
+    rc = getnameinfo((const struct sockaddr *)&sockaddr->sa, sockaddr->salen,
+                     tmphostname, sizeof(tmphostname), NULL, 0,
+                     flags != 0 ? flags : NI_NAMEREQD);
+    if (rc != 0) {
+        *hostname = NULL;
+
+#ifndef WIN32
+        /* something went wrong. Look at the EAI_ error code */
+        if (rc == EAI_SYSTEM) {
+            /* EAI_SYSTEM      System error returned in errno. */
+            /* IMHO, Implementations that set h_errno a simply broken. */
+            if (h_errno) { /* for broken implementations which set h_errno */
+                return h_errno + APR_OS_START_SYSERR;
+            }
+            else { /* "normal" case */
+                return errno + APR_OS_START_SYSERR;
+            }
+        }
+        else 
+#endif
+        {
+#if defined(NEGATIVE_EAI)
+            if (rc < 0) rc = -rc;
+#endif
+            return rc + APR_OS_START_EAIERR; /* return the EAI_ error */
+        }
+    }
+    *hostname = sockaddr->hostname = apr_pstrdup(sockaddr->pool, 
+                                                 tmphostname);
+    return APR_SUCCESS;
+#else
+#if APR_HAS_THREADS && !defined(GETHOSTBYADDR_IS_THREAD_SAFE) && \
+    defined(HAVE_GETHOSTBYADDR_R) && !defined(BEOS)
+#ifdef GETHOSTBYNAME_R_HOSTENT_DATA
+    struct hostent_data hd;
+#else
+    char tmp[GETHOSTBYNAME_BUFLEN];
+#endif
+    int hosterror;
+    struct hostent hs, *hptr;
+
+#if defined(GETHOSTBYNAME_R_HOSTENT_DATA)
+    /* AIX, HP/UX, D/UX et alia */
+    gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr, 
+                  sizeof(struct in_addr), AF_INET, &hs, &hd);
+    hptr = &hs;
+#else
+#if defined(GETHOSTBYNAME_R_GLIBC2)
+    /* Linux glibc2+ */
+    gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr, 
+                    sizeof(struct in_addr), AF_INET,
+                    &hs, tmp, GETHOSTBYNAME_BUFLEN - 1, &hptr, &hosterror);
+#else
+    /* Solaris, Irix et alia */
+    hptr = gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr, 
+                           sizeof(struct in_addr), AF_INET,
+                           &hs, tmp, GETHOSTBYNAME_BUFLEN, &hosterror);
+#endif /* !defined(GETHOSTBYNAME_R_GLIBC2) */
+    if (!hptr) {
+        *hostname = NULL;
+        return hosterror + APR_OS_START_SYSERR;
+    }
+#endif /* !defined(GETHOSTBYNAME_R_HOSTENT_DATA) */
+#else
+    struct hostent *hptr;
+    hptr = gethostbyaddr((char *)&sockaddr->sa.sin.sin_addr, 
+                         sizeof(struct in_addr), AF_INET);
+#endif
+
+    if (hptr) {
+        *hostname = sockaddr->hostname = apr_pstrdup(sockaddr->pool, hptr->h_name);
+        return APR_SUCCESS;
+    }
+    *hostname = NULL;
+#if defined(WIN32)
+    return apr_get_netos_error();
+#elif defined(OS2)
+    return h_errno;
+#else
+    return h_errno + APR_OS_START_SYSERR;
+#endif
+#endif
+}
+
+APR_DECLARE(apr_status_t) apr_getservbyname(apr_sockaddr_t *sockaddr,
+                                            const char *servname)
+{
+#if APR_HAS_THREADS && !defined(GETSERVBYNAME_IS_THREAD_SAFE) && \
+    defined(HAVE_GETSERVBYNAME_R) && \
+    (defined(GETSERVBYNAME_R_GLIBC2) || defined(GETSERVBYNAME_R_SOLARIS) || \
+     defined(GETSERVBYNAME_R_OSF1))
+    struct servent se;
+#if defined(GETSERVBYNAME_R_OSF1)
+    struct servent_data sed;
+
+    memset(&sed, 0, sizeof(sed)); /* must zero fill before use */
+#else
+#if defined(GETSERVBYNAME_R_GLIBC2)
+    struct servent *res;
+#endif
+    char buf[1024];
+#endif
+#else
+    struct servent *se;
+#endif
+
+    if (servname == NULL)
+        return APR_EINVAL;
+
+#if APR_HAS_THREADS && !defined(GETSERVBYNAME_IS_THREAD_SAFE) && \
+    defined(HAVE_GETSERVBYNAME_R) && \
+    (defined(GETSERVBYNAME_R_GLIBC2) || defined(GETSERVBYNAME_R_SOLARIS) || \
+     defined(GETSERVBYNAME_R_OSF1))
+#if defined(GETSERVBYNAME_R_GLIBC2)
+    if (getservbyname_r(servname, NULL,
+                        &se, buf, sizeof(buf), &res) == 0 && res != NULL) {
+        sockaddr->port = ntohs(res->s_port);
+        sockaddr->servname = apr_pstrdup(sockaddr->pool, servname);
+        sockaddr->sa.sin.sin_port = res->s_port;
+        return APR_SUCCESS;
+    }
+#elif defined(GETSERVBYNAME_R_SOLARIS)
+    if (getservbyname_r(servname, NULL, &se, buf, sizeof(buf)) != NULL) {
+        sockaddr->port = ntohs(se.s_port);
+        sockaddr->servname = apr_pstrdup(sockaddr->pool, servname);
+        sockaddr->sa.sin.sin_port = se.s_port;
+        return APR_SUCCESS;
+    }
+#elif defined(GETSERVBYNAME_R_OSF1)
+    if (getservbyname_r(servname, NULL, &se, &sed) == 0) {
+        sockaddr->port = ntohs(se.s_port);
+        sockaddr->servname = apr_pstrdup(sockaddr->pool, servname);
+        sockaddr->sa.sin.sin_port = se.s_port;
+        return APR_SUCCESS;
+    }
+#endif
+#else
+    if ((se = getservbyname(servname, NULL)) != NULL){
+        sockaddr->port = ntohs(se->s_port);
+        sockaddr->servname = apr_pstrdup(sockaddr->pool, servname);
+        sockaddr->sa.sin.sin_port = se->s_port;
+        return APR_SUCCESS;
+    }
+#endif
+    return APR_ENOENT;
+}
+
+#define V4MAPPED_EQUAL(a,b)                                   \
+((a)->sa.sin.sin_family == AF_INET &&                         \
+ (b)->sa.sin.sin_family == AF_INET6 &&                        \
+ IN6_IS_ADDR_V4MAPPED((struct in6_addr *)(b)->ipaddr_ptr) &&  \
+ !memcmp((a)->ipaddr_ptr,                                     \
+         &((struct in6_addr *)(b)->ipaddr_ptr)->s6_addr[12],  \
+         (a)->ipaddr_len))
+
+#if APR_HAVE_IPV6
+#define SCOPE_OR_ZERO(sa_) ((sa_)->family != AF_INET6 ? 0 :   \
+                            ((sa_)->sa.sin6.sin6_scope_id))
+#else
+#define SCOPE_OR_ZERO(sa_) (0)
+#endif
+
+APR_DECLARE(int) apr_sockaddr_equal(const apr_sockaddr_t *addr1,
+                                    const apr_sockaddr_t *addr2)
+{
+    if (addr1->ipaddr_len == addr2->ipaddr_len
+        && !memcmp(addr1->ipaddr_ptr, addr2->ipaddr_ptr, addr1->ipaddr_len)
+        && SCOPE_OR_ZERO(addr1) == SCOPE_OR_ZERO(addr2)) {
+        return 1;
+    }
+#if APR_HAVE_IPV6
+    if (V4MAPPED_EQUAL(addr1, addr2)) {
+        return 1;
+    }
+    if (V4MAPPED_EQUAL(addr2, addr1)) {
+        return 1;
+    }
+#endif
+    return 0; /* not equal */
+}
+
+APR_DECLARE(int) apr_sockaddr_is_wildcard(const apr_sockaddr_t *addr)
+{
+    static const char inaddr_any[
+#if APR_HAVE_IPV6
+        sizeof(struct in6_addr)
+#else
+        sizeof(struct in_addr)
+#endif
+    ] = {0};
+
+    if (addr->ipaddr_ptr /* IP address initialized */
+        && addr->ipaddr_len <= sizeof inaddr_any) { /* else bug elsewhere? */
+        if (!memcmp(inaddr_any, addr->ipaddr_ptr, addr->ipaddr_len)) {
+            return 1;
+        }
+#if APR_HAVE_IPV6
+    if (addr->family == AF_INET6
+        && IN6_IS_ADDR_V4MAPPED((struct in6_addr *)addr->ipaddr_ptr)) {
+        struct in_addr *v4 = (struct in_addr *)&((apr_uint32_t *)addr->ipaddr_ptr)[3];
+
+        if (!memcmp(inaddr_any, v4, sizeof *v4)) {
+            return 1;
+        }
+    }
+#endif
+    }
+    return 0;
+}
+
+static apr_status_t parse_network(apr_ipsubnet_t *ipsub, const char *network)
+{
+    /* legacy syntax for ip addrs: a.b.c. ==> a.b.c.0/24 for example */
+    int shift;
+    char *s, *t;
+    int octet;
+    char buf[sizeof "255.255.255.255"];
+
+    if (strlen(network) < sizeof buf) {
+        strcpy(buf, network);
+    }
+    else {
+        return APR_EBADIP;
+    }
+
+    /* parse components */
+    s = buf;
+    ipsub->sub[0] = 0;
+    ipsub->mask[0] = 0;
+    shift = 24;
+    while (*s) {
+        t = s;
+        if (!apr_isdigit(*t)) {
+            return APR_EBADIP;
+        }
+        while (apr_isdigit(*t)) {
+            ++t;
+        }
+        if (*t == '.') {
+            *t++ = 0;
+        }
+        else if (*t) {
+            return APR_EBADIP;
+        }
+        if (shift < 0) {
+            return APR_EBADIP;
+        }
+        octet = atoi(s);
+        if (octet < 0 || octet > 255) {
+            return APR_EBADIP;
+        }
+        ipsub->sub[0] |= octet << shift;
+        ipsub->mask[0] |= 0xFFUL << shift;
+        s = t;
+        shift -= 8;
+    }
+    ipsub->sub[0] = ntohl(ipsub->sub[0]);
+    ipsub->mask[0] = ntohl(ipsub->mask[0]);
+    ipsub->family = AF_INET;
+    return APR_SUCCESS;
+}
+
+/* return values:
+ * APR_EINVAL     not an IP address; caller should see if it is something else
+ * APR_BADIP      IP address portion is is not valid
+ * APR_BADMASK    mask portion is not valid
+ */
+
+static apr_status_t parse_ip(apr_ipsubnet_t *ipsub, const char *ipstr, int network_allowed)
+{
+    /* supported flavors of IP:
+     *
+     * . IPv6 numeric address string (e.g., "fe80::1")
+     * 
+     *   IMPORTANT: Don't store IPv4-mapped IPv6 address as an IPv6 address.
+     *
+     * . IPv4 numeric address string (e.g., "127.0.0.1")
+     *
+     * . IPv4 network string (e.g., "9.67")
+     *
+     *   IMPORTANT: This network form is only allowed if network_allowed is on.
+     */
+    int rc;
+
+#if APR_HAVE_IPV6
+    rc = apr_inet_pton(AF_INET6, ipstr, ipsub->sub);
+    if (rc == 1) {
+        if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)ipsub->sub)) {
+            /* apr_ipsubnet_test() assumes that we don't create IPv4-mapped IPv6
+             * addresses; this of course forces the user to specify IPv4 addresses
+             * in a.b.c.d style instead of ::ffff:a.b.c.d style.
+             */
+            return APR_EBADIP;
+        }
+        ipsub->family = AF_INET6;
+    }
+    else
+#endif
+    {
+        rc = apr_inet_pton(AF_INET, ipstr, ipsub->sub);
+        if (rc == 1) {
+            ipsub->family = AF_INET;
+        }
+    }
+    if (rc != 1) {
+        if (network_allowed) {
+            return parse_network(ipsub, ipstr);
+        }
+        else {
+            return APR_EBADIP;
+        }
+    }
+    return APR_SUCCESS;
+}
+
+static int looks_like_ip(const char *ipstr)
+{
+    if (strlen(ipstr) == 0) {
+        return 0;
+    }
+    
+    if (strchr(ipstr, ':')) {
+        /* definitely not a hostname; assume it is intended to be an IPv6 address */
+        return 1;
+    }
+
+    /* simple IPv4 address string check */
+    while ((*ipstr == '.') || apr_isdigit(*ipstr))
+        ipstr++;
+    return (*ipstr == '\0');
+}
+
+static void fix_subnet(apr_ipsubnet_t *ipsub)
+{
+    /* in case caller specified more bits in network address than are
+     * valid according to the mask, turn off the extra bits
+     */
+    int i;
+
+    for (i = 0; i < sizeof ipsub->mask / sizeof(apr_int32_t); i++) {
+        ipsub->sub[i] &= ipsub->mask[i];
+    }
+}
+
+/* be sure not to store any IPv4 address as a v4-mapped IPv6 address */
+APR_DECLARE(apr_status_t) apr_ipsubnet_create(apr_ipsubnet_t **ipsub, const char *ipstr, 
+                                              const char *mask_or_numbits, apr_pool_t *p)
+{
+    apr_status_t rv;
+    char *endptr;
+    long bits, maxbits = 32;
+
+    /* filter out stuff which doesn't look remotely like an IP address; this helps 
+     * callers like mod_access which have a syntax allowing hostname or IP address;
+     * APR_EINVAL tells the caller that it was probably not intended to be an IP
+     * address
+     */
+    if (!looks_like_ip(ipstr)) {
+        return APR_EINVAL;
+    }
+
+    *ipsub = apr_pcalloc(p, sizeof(apr_ipsubnet_t));
+
+    /* assume ipstr is an individual IP address, not a subnet */
+    memset((*ipsub)->mask, 0xFF, sizeof (*ipsub)->mask);
+
+    rv = parse_ip(*ipsub, ipstr, mask_or_numbits == NULL);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    if (mask_or_numbits) {
+#if APR_HAVE_IPV6
+        if ((*ipsub)->family == AF_INET6) {
+            maxbits = 128;
+        }
+#endif
+        bits = strtol(mask_or_numbits, &endptr, 10);
+        if (*endptr == '\0' && bits > 0 && bits <= maxbits) {
+            /* valid num-bits string; fill in mask appropriately */
+            int cur_entry = 0;
+            apr_int32_t cur_bit_value;
+
+            memset((*ipsub)->mask, 0, sizeof (*ipsub)->mask);
+            while (bits > 32) {
+                (*ipsub)->mask[cur_entry] = 0xFFFFFFFF; /* all 32 bits */
+                bits -= 32;
+                ++cur_entry;
+            }
+            cur_bit_value = 0x80000000;
+            while (bits) {
+                (*ipsub)->mask[cur_entry] |= cur_bit_value;
+                --bits;
+                cur_bit_value /= 2;
+            }
+            (*ipsub)->mask[cur_entry] = htonl((*ipsub)->mask[cur_entry]);
+        }
+        else if (apr_inet_pton(AF_INET, mask_or_numbits, (*ipsub)->mask) == 1 &&
+            (*ipsub)->family == AF_INET) {
+            /* valid IPv4 netmask */
+        }
+        else {
+            return APR_EBADMASK;
+        }
+    }
+
+    fix_subnet(*ipsub);
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(int) apr_ipsubnet_test(apr_ipsubnet_t *ipsub, apr_sockaddr_t *sa)
+{
+#if APR_HAVE_IPV6
+    /* XXX This line will segv on Win32 build with APR_HAVE_IPV6,
+     * but without the IPV6 drivers installed.
+     */
+    if (sa->family == AF_INET) {
+        if (ipsub->family == AF_INET &&
+            ((sa->sa.sin.sin_addr.s_addr & ipsub->mask[0]) == ipsub->sub[0])) {
+            return 1;
+        }
+    }
+    else if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)sa->ipaddr_ptr)) {
+        if (ipsub->family == AF_INET &&
+            (((apr_uint32_t *)sa->ipaddr_ptr)[3] & ipsub->mask[0]) == ipsub->sub[0]) {
+            return 1;
+        }
+    }
+    else if (sa->family == AF_INET6 && ipsub->family == AF_INET6) {
+        apr_uint32_t *addr = (apr_uint32_t *)sa->ipaddr_ptr;
+
+        if ((addr[0] & ipsub->mask[0]) == ipsub->sub[0] &&
+            (addr[1] & ipsub->mask[1]) == ipsub->sub[1] &&
+            (addr[2] & ipsub->mask[2]) == ipsub->sub[2] &&
+            (addr[3] & ipsub->mask[3]) == ipsub->sub[3]) {
+            return 1;
+        }
+    }
+#else
+    if ((sa->sa.sin.sin_addr.s_addr & ipsub->mask[0]) == ipsub->sub[0]) {
+        return 1;
+    }
+#endif /* APR_HAVE_IPV6 */
+    return 0; /* no match */
+}
+
+APR_DECLARE(apr_status_t) apr_sockaddr_zone_set(apr_sockaddr_t *sa,
+                                                const char *zone_id)
+{
+#if !APR_HAVE_IPV6 || !defined(HAVE_IF_NAMETOINDEX)
+    return APR_ENOTIMPL;
+#else
+    unsigned int idx;
+    
+    if (sa->family != APR_INET6
+        || !IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)sa->ipaddr_ptr)) {
+        return APR_EBADIP;
+    }
+
+    idx = if_nametoindex(zone_id);
+    if (idx) {
+        sa->sa.sin6.sin6_scope_id = idx;
+        return APR_SUCCESS;
+    }
+
+    if (errno != ENODEV) {
+        return errno;
+    }
+    else {
+        char *endptr;
+        apr_int64_t i = apr_strtoi64(zone_id, &endptr, 10);
+
+        if (*endptr != '\0' || errno || i < 1 || i > APR_INT16_MAX) {
+            return APR_EGENERAL;
+        }
+
+        sa->sa.sin6.sin6_scope_id = (unsigned int) i;
+        return APR_SUCCESS;
+    }
+#endif
+}
+
+APR_DECLARE(apr_status_t) apr_sockaddr_zone_get(const apr_sockaddr_t *sa,
+                                                const char **name,
+                                                apr_uint32_t *id,
+                                                apr_pool_t *p)
+{
+#if !APR_HAVE_IPV6 || !defined(HAVE_IF_INDEXTONAME)
+    return APR_ENOTIMPL;
+#else
+    if (sa->family != APR_INET6 || !sa->sa.sin6.sin6_scope_id) {
+        return APR_EBADIP;
+    }        
+
+    if (name) {
+        char *buf = apr_palloc(p, IF_NAMESIZE);
+        if (if_indextoname(sa->sa.sin6.sin6_scope_id, buf) == NULL)
+            return errno;
+        *name = buf;
+    }
+
+    if (id) *id = sa->sa.sin6.sin6_scope_id;
+    
+    return APR_SUCCESS;
+#endif
+}
diff --git a/network_io/unix/socket_util.c b/network_io/unix/socket_util.c
new file mode 100644
index 0000000..93fe259
--- /dev/null
+++ b/network_io/unix/socket_util.c
@@ -0,0 +1,75 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_network_io.h"
+#include "apr_poll.h"
+
+APR_DECLARE(apr_status_t) apr_socket_atreadeof(apr_socket_t *sock, int *atreadeof)
+{
+    apr_pollfd_t pfds[1];
+    apr_status_t rv;
+    apr_int32_t  nfds;
+
+    /* The purpose here is to return APR_SUCCESS only in cases in
+     * which it can be unambiguously determined whether or not the
+     * socket will return EOF on next read.  In case of an unexpected
+     * error, return that. */
+
+    pfds[0].reqevents = APR_POLLIN;
+    pfds[0].desc_type = APR_POLL_SOCKET;
+    pfds[0].desc.s = sock;
+
+    do {
+        rv = apr_poll(&pfds[0], 1, &nfds, 0);
+    } while (APR_STATUS_IS_EINTR(rv));
+
+    if (APR_STATUS_IS_TIMEUP(rv)) {
+        /* Read buffer empty -> subsequent reads would block, so,
+         * definitely not at EOF. */
+        *atreadeof = 0;
+        return APR_SUCCESS;
+    }
+    else if (rv) {
+        /* Some other error -> unexpected error. */
+        return rv;
+    }
+    /* Many platforms return only APR_POLLIN; OS X returns APR_POLLHUP|APR_POLLIN */
+    else if (nfds == 1 && (pfds[0].rtnevents & APR_POLLIN)  == APR_POLLIN) {
+        apr_sockaddr_t unused;
+        apr_size_t len = 1;
+        char buf;
+
+        /* The socket is readable - peek to see whether it returns EOF
+         * without consuming bytes from the socket buffer. */
+        rv = apr_socket_recvfrom(&unused, sock, MSG_PEEK, &buf, &len);
+        if (rv == APR_EOF) {
+            *atreadeof = 1;
+            return APR_SUCCESS;
+        }
+        else if (rv) {
+            /* Read error -> unexpected error. */
+            return rv;
+        }
+        else {
+            *atreadeof = 0;
+            return APR_SUCCESS;
+        }
+    }
+
+    /* Should not fall through here. */
+    return APR_EGENERAL;
+}
+
diff --git a/network_io/unix/sockets.c b/network_io/unix/sockets.c
new file mode 100644
index 0000000..206c654
--- /dev/null
+++ b/network_io/unix/sockets.c
@@ -0,0 +1,572 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_network_io.h"
+#include "apr_strings.h"
+#include "apr_support.h"
+#include "apr_portable.h"
+#include "apr_arch_inherit.h"
+
+#ifdef BEOS_R5
+#undef close
+#define close closesocket
+#endif /* BEOS_R5 */
+
+#if APR_HAVE_SOCKADDR_UN
+#define GENERIC_INADDR_ANY_LEN  sizeof(struct sockaddr_un)
+#else
+#define GENERIC_INADDR_ANY_LEN  16
+#endif
+
+/* big enough for IPv4, IPv6 and optionaly sun_path */
+static char generic_inaddr_any[GENERIC_INADDR_ANY_LEN] = {0};
+
+static apr_status_t socket_cleanup(void *sock)
+{
+    apr_socket_t *thesocket = sock;
+    int sd = thesocket->socketdes;
+
+#if APR_HAVE_SOCKADDR_UN
+    if (thesocket->bound && thesocket->local_addr->family == APR_UNIX) {
+        /* XXX: Check for return values ? */
+        unlink(thesocket->local_addr->hostname);
+    }
+#endif        
+    /* Set socket descriptor to -1 before close(), so that there is no
+     * chance of returning an already closed FD from apr_os_sock_get().
+     */
+    thesocket->socketdes = -1;
+
+    if (close(sd) == 0) {
+        return APR_SUCCESS;
+    }
+    else {
+        /* Restore, close() was not successful. */
+        thesocket->socketdes = sd;
+
+        return errno;
+    }
+}
+
+static apr_status_t socket_child_cleanup(void *sock)
+{
+    apr_socket_t *thesocket = sock;
+    if (close(thesocket->socketdes) == 0) {
+        thesocket->socketdes = -1;
+        return APR_SUCCESS;
+    }
+    else {
+        return errno;
+    }
+}
+
+static void set_socket_vars(apr_socket_t *sock, int family, int type, int protocol)
+{
+    sock->type = type;
+    sock->protocol = protocol;
+    apr_sockaddr_vars_set(sock->local_addr, family, 0);
+    apr_sockaddr_vars_set(sock->remote_addr, family, 0);
+    sock->options = 0;
+#if defined(BEOS) && !defined(BEOS_BONE)
+    /* BeOS pre-BONE has TCP_NODELAY on by default and it can't be
+     * switched off!
+     */
+    sock->options |= APR_TCP_NODELAY;
+#endif
+}
+
+static void alloc_socket(apr_socket_t **new, apr_pool_t *p)
+{
+    *new = (apr_socket_t *)apr_pcalloc(p, sizeof(apr_socket_t));
+    (*new)->pool = p;
+    (*new)->local_addr = (apr_sockaddr_t *)apr_pcalloc((*new)->pool,
+                                                       sizeof(apr_sockaddr_t));
+    (*new)->local_addr->pool = p;
+    (*new)->remote_addr = (apr_sockaddr_t *)apr_pcalloc((*new)->pool,
+                                                        sizeof(apr_sockaddr_t));
+    (*new)->remote_addr->pool = p;
+    (*new)->remote_addr_unknown = 1;
+#ifndef WAITIO_USES_POLL
+    /* Create a pollset with room for one descriptor. */
+    /* ### check return codes */
+    (void) apr_pollset_create(&(*new)->pollset, 1, p, 0);
+#endif
+}
+
+apr_status_t apr_socket_protocol_get(apr_socket_t *sock, int *protocol)
+{
+    *protocol = sock->protocol;
+    return APR_SUCCESS;
+}
+
+apr_status_t apr_socket_create(apr_socket_t **new, int ofamily, int type,
+                               int protocol, apr_pool_t *cont)
+{
+    int family = ofamily, flags = 0;
+    int oprotocol = protocol;
+
+#ifdef HAVE_SOCK_CLOEXEC
+    flags |= SOCK_CLOEXEC;
+#endif
+
+    if (family == APR_UNSPEC) {
+#if APR_HAVE_IPV6
+        family = APR_INET6;
+#else
+        family = APR_INET;
+#endif
+    }
+#if APR_HAVE_SOCKADDR_UN
+    if (family == APR_UNIX) {
+        protocol = 0;
+    }
+#endif
+    alloc_socket(new, cont);
+
+#ifndef BEOS_R5
+    (*new)->socketdes = socket(family, type|flags, protocol);
+#else
+    /* For some reason BeOS R5 has an unconventional protocol numbering,
+     * so we need to translate here. */
+    switch (protocol) {
+    case 0:
+        (*new)->socketdes = socket(family, type|flags, 0);
+        break;
+    case APR_PROTO_TCP:
+        (*new)->socketdes = socket(family, type|flags, IPPROTO_TCP);
+        break;
+    case APR_PROTO_UDP:
+        (*new)->socketdes = socket(family, type|flags, IPPROTO_UDP);
+        break;
+    case APR_PROTO_SCTP:
+    default:
+        errno = EPROTONOSUPPORT;
+        (*new)->socketdes = -1;
+        break;
+    }
+#endif /* BEOS_R5 */
+
+#if APR_HAVE_IPV6
+    if ((*new)->socketdes < 0 && ofamily == APR_UNSPEC) {
+        family = APR_INET;
+        (*new)->socketdes = socket(family, type|flags, protocol);
+    }
+#endif
+
+    if ((*new)->socketdes < 0) {
+        return errno;
+    }
+    set_socket_vars(*new, family, type, oprotocol);
+
+#ifndef HAVE_SOCK_CLOEXEC
+    {
+        int flags;
+        apr_status_t rv;
+
+        if ((flags = fcntl((*new)->socketdes, F_GETFD)) == -1) {
+            rv = errno;
+            close((*new)->socketdes);
+            (*new)->socketdes = -1;
+            return rv;
+        }
+
+        flags |= FD_CLOEXEC;
+        if (fcntl((*new)->socketdes, F_SETFD, flags) == -1) {
+            rv = errno;
+            close((*new)->socketdes);
+            (*new)->socketdes = -1;
+            return rv;
+        }
+    }
+#endif
+
+    (*new)->timeout = -1;
+    (*new)->inherit = 0;
+    apr_pool_cleanup_register((*new)->pool, (void *)(*new), socket_cleanup,
+                              socket_child_cleanup);
+
+    return APR_SUCCESS;
+} 
+
+apr_status_t apr_socket_shutdown(apr_socket_t *thesocket, 
+                                 apr_shutdown_how_e how)
+{
+    return (shutdown(thesocket->socketdes, how) == -1) ? errno : APR_SUCCESS;
+}
+
+apr_status_t apr_socket_close(apr_socket_t *thesocket)
+{
+    return apr_pool_cleanup_run(thesocket->pool, thesocket, socket_cleanup);
+}
+
+apr_status_t apr_socket_bind(apr_socket_t *sock, apr_sockaddr_t *sa)
+{
+    if (bind(sock->socketdes, 
+             (struct sockaddr *)&sa->sa, sa->salen) == -1) {
+        return errno;
+    }
+    else {
+        sock->local_addr = sa;
+        /* XXX IPv6 - this assumes sin_port and sin6_port at same offset */
+#if APR_HAVE_SOCKADDR_UN
+        if (sock->local_addr->family == APR_UNIX) {
+            sock->bound = 1;
+            sock->local_port_unknown = 1;
+        }
+        else
+#endif
+        if (sock->local_addr->sa.sin.sin_port == 0) { /* no need for ntohs() when comparing w/ 0 */
+            sock->local_port_unknown = 1; /* kernel got us an ephemeral port */
+        }
+        return APR_SUCCESS;
+    }
+}
+
+apr_status_t apr_socket_listen(apr_socket_t *sock, apr_int32_t backlog)
+{
+    if (listen(sock->socketdes, backlog) == -1)
+        return errno;
+    else
+        return APR_SUCCESS;
+}
+
+apr_status_t apr_socket_accept(apr_socket_t **new, apr_socket_t *sock,
+                               apr_pool_t *connection_context)
+{
+    int s;
+    apr_sockaddr_t sa;
+
+    sa.salen = sizeof(sa.sa);
+
+#ifdef HAVE_ACCEPT4
+    {
+        int flags = SOCK_CLOEXEC;
+
+#if defined(SOCK_NONBLOCK) && APR_O_NONBLOCK_INHERITED
+        /* With FreeBSD accept4() (avail in 10+), O_NONBLOCK is not inherited
+         * (unlike Linux).  Mimic the accept() behavior here in a way that
+         * may help other platforms.
+         */
+        if (apr_is_option_set(sock, APR_SO_NONBLOCK) == 1) {
+            flags |= SOCK_NONBLOCK;
+        }
+#endif
+        s = accept4(sock->socketdes, (struct sockaddr *)&sa.sa, &sa.salen, flags);
+    }
+#else
+    s = accept(sock->socketdes, (struct sockaddr *)&sa.sa, &sa.salen);
+#endif
+
+    if (s < 0) {
+        return errno;
+    }
+#ifdef TPF
+    if (s == 0) { 
+        /* 0 is an invalid socket for TPF */
+        return APR_EINTR;
+    }
+#endif
+    alloc_socket(new, connection_context);
+
+    /* Set up socket variables -- note that it may be possible for
+     * *new to be an AF_INET socket when sock is AF_INET6 in some
+     * dual-stack configurations, so ensure that the remote_/local_addr
+     * structures are adjusted for the family of the accepted
+     * socket: */
+    set_socket_vars(*new, sa.sa.sin.sin_family, SOCK_STREAM, sock->protocol);
+
+#ifndef HAVE_POLL
+    (*new)->connected = 1;
+#endif
+    (*new)->timeout = -1;
+
+    (*new)->remote_addr_unknown = 0;
+
+    (*new)->socketdes = s;
+
+    /* Copy in peer's address. */
+    (*new)->remote_addr->sa = sa.sa;
+    (*new)->remote_addr->salen = sa.salen;
+
+    *(*new)->local_addr = *sock->local_addr;
+
+    /* The above assignment just overwrote the pool entry. Setting the local_addr 
+       pool for the accepted socket back to what it should be.  Otherwise all 
+       allocations for this socket will come from a server pool that is not
+       freed until the process goes down.*/
+    (*new)->local_addr->pool = connection_context;
+
+    /* fix up any pointers which are no longer valid */
+    if (sock->local_addr->sa.sin.sin_family == AF_INET) {
+        (*new)->local_addr->ipaddr_ptr = &(*new)->local_addr->sa.sin.sin_addr;
+    }
+#if APR_HAVE_IPV6
+    else if (sock->local_addr->sa.sin.sin_family == AF_INET6) {
+        (*new)->local_addr->ipaddr_ptr = &(*new)->local_addr->sa.sin6.sin6_addr;
+    }
+#endif
+#if APR_HAVE_SOCKADDR_UN
+    else if (sock->local_addr->sa.sin.sin_family == AF_UNIX) {
+        *(*new)->remote_addr = *sock->local_addr;
+        (*new)->local_addr->ipaddr_ptr = &((*new)->local_addr->sa.unx.sun_path);
+        (*new)->remote_addr->ipaddr_ptr = &((*new)->remote_addr->sa.unx.sun_path);
+    }
+    if (sock->local_addr->sa.sin.sin_family != AF_UNIX)
+#endif
+    (*new)->remote_addr->port = ntohs((*new)->remote_addr->sa.sin.sin_port);
+    if (sock->local_port_unknown) {
+        /* not likely for a listening socket, but theoretically possible :) */
+        (*new)->local_port_unknown = 1;
+    }
+
+#if APR_TCP_NODELAY_INHERITED
+    if (apr_is_option_set(sock, APR_TCP_NODELAY) == 1) {
+        apr_set_option(*new, APR_TCP_NODELAY, 1);
+    }
+#endif /* TCP_NODELAY_INHERITED */
+#if APR_O_NONBLOCK_INHERITED
+    if (apr_is_option_set(sock, APR_SO_NONBLOCK) == 1) {
+        apr_set_option(*new, APR_SO_NONBLOCK, 1);
+    }
+#endif /* APR_O_NONBLOCK_INHERITED */
+
+    if (sock->local_interface_unknown ||
+        !memcmp(sock->local_addr->ipaddr_ptr,
+                generic_inaddr_any,
+                sock->local_addr->ipaddr_len)) {
+        /* If the interface address inside the listening socket's local_addr wasn't 
+         * up-to-date, we don't know local interface of the connected socket either.
+         *
+         * If the listening socket was not bound to a specific interface, we
+         * don't know the local_addr of the connected socket.
+         */
+        (*new)->local_interface_unknown = 1;
+    }
+
+#ifndef HAVE_ACCEPT4
+    {
+        int flags;
+        apr_status_t rv;
+
+        if ((flags = fcntl((*new)->socketdes, F_GETFD)) == -1) {
+            rv = errno;
+            close((*new)->socketdes);
+            (*new)->socketdes = -1;
+            return rv;
+        }
+
+        flags |= FD_CLOEXEC;
+        if (fcntl((*new)->socketdes, F_SETFD, flags) == -1) {
+            rv = errno;
+            close((*new)->socketdes);
+            (*new)->socketdes = -1;
+            return rv;
+        }
+    }
+#endif
+
+    (*new)->inherit = 0;
+    apr_pool_cleanup_register((*new)->pool, (void *)(*new), socket_cleanup,
+                              socket_cleanup);
+    return APR_SUCCESS;
+}
+
+apr_status_t apr_socket_connect(apr_socket_t *sock, apr_sockaddr_t *sa)
+{
+    int rc;        
+
+    do {
+        rc = connect(sock->socketdes,
+                     (const struct sockaddr *)&sa->sa.sin,
+                     sa->salen);
+    } while (rc == -1 && errno == EINTR);
+
+    /* we can see EINPROGRESS the first time connect is called on a non-blocking
+     * socket; if called again, we can see EALREADY
+     */
+    if ((rc == -1) && (errno == EINPROGRESS || errno == EALREADY)
+                   && (sock->timeout > 0)) {
+        rc = apr_wait_for_io_or_timeout(NULL, sock, 0);
+        if (rc != APR_SUCCESS) {
+            return rc;
+        }
+
+#ifdef SO_ERROR
+        {
+            int error;
+            apr_socklen_t len = sizeof(error);
+            if ((rc = getsockopt(sock->socketdes, SOL_SOCKET, SO_ERROR, 
+                                 (char *)&error, &len)) < 0) {
+                return errno;
+            }
+            if (error) {
+                return error;
+            }
+        }
+#endif /* SO_ERROR */
+    }
+
+    if (memcmp(sa->ipaddr_ptr, generic_inaddr_any, sa->ipaddr_len)) {
+        /* A real remote address was passed in.  If the unspecified
+         * address was used, the actual remote addr will have to be
+         * determined using getpeername() if required. */
+        sock->remote_addr_unknown = 0;
+
+        /* Copy the address structure details in. */
+        sock->remote_addr->sa = sa->sa;
+        sock->remote_addr->salen = sa->salen;
+        /* Adjust ipaddr_ptr et al. */
+        apr_sockaddr_vars_set(sock->remote_addr, sa->family, sa->port);
+    }
+
+    if (sock->local_addr->port == 0) {
+        /* connect() got us an ephemeral port */
+        sock->local_port_unknown = 1;
+    }
+#if APR_HAVE_SOCKADDR_UN
+    if (sock->local_addr->sa.sin.sin_family == AF_UNIX) {
+        /* Assign connect address as local. */
+        sock->local_addr = sa;
+    }
+    else
+#endif
+    if (!memcmp(sock->local_addr->ipaddr_ptr,
+                generic_inaddr_any,
+                sock->local_addr->ipaddr_len)) {
+        /* not bound to specific local interface; connect() had to assign
+         * one for the socket
+         */
+        sock->local_interface_unknown = 1;
+    }
+
+    if (rc == -1 && errno != EISCONN) {
+        return errno;
+    }
+
+#ifndef HAVE_POLL
+    sock->connected=1;
+#endif
+    return APR_SUCCESS;
+}
+
+apr_status_t apr_socket_type_get(apr_socket_t *sock, int *type)
+{
+    *type = sock->type;
+    return APR_SUCCESS;
+}
+
+apr_status_t apr_socket_data_get(void **data, const char *key, apr_socket_t *sock)
+{
+    sock_userdata_t *cur = sock->userdata;
+
+    *data = NULL;
+
+    while (cur) {
+        if (!strcmp(cur->key, key)) {
+            *data = cur->data;
+            break;
+        }
+        cur = cur->next;
+    }
+
+    return APR_SUCCESS;
+}
+
+apr_status_t apr_socket_data_set(apr_socket_t *sock, void *data, const char *key,
+                                 apr_status_t (*cleanup) (void *))
+{
+    sock_userdata_t *new = apr_palloc(sock->pool, sizeof(sock_userdata_t));
+
+    new->key = apr_pstrdup(sock->pool, key);
+    new->data = data;
+    new->next = sock->userdata;
+    sock->userdata = new;
+
+    if (cleanup) {
+        apr_pool_cleanup_register(sock->pool, data, cleanup, cleanup);
+    }
+
+    return APR_SUCCESS;
+}
+
+apr_status_t apr_os_sock_get(apr_os_sock_t *thesock, apr_socket_t *sock)
+{
+    *thesock = sock->socketdes;
+    return APR_SUCCESS;
+}
+
+apr_status_t apr_os_sock_make(apr_socket_t **apr_sock, 
+                              apr_os_sock_info_t *os_sock_info, 
+                              apr_pool_t *cont)
+{
+    alloc_socket(apr_sock, cont);
+    set_socket_vars(*apr_sock, os_sock_info->family, os_sock_info->type, os_sock_info->protocol);
+    (*apr_sock)->timeout = -1;
+    (*apr_sock)->socketdes = *os_sock_info->os_sock;
+    if (os_sock_info->local) {
+        memcpy(&(*apr_sock)->local_addr->sa.sin, 
+               os_sock_info->local, 
+               (*apr_sock)->local_addr->salen);
+        /* XXX IPv6 - this assumes sin_port and sin6_port at same offset */
+        (*apr_sock)->local_addr->port = ntohs((*apr_sock)->local_addr->sa.sin.sin_port);
+    }
+    else {
+        (*apr_sock)->local_port_unknown = (*apr_sock)->local_interface_unknown = 1;
+    }
+    if (os_sock_info->remote) {
+#ifndef HAVE_POLL
+        (*apr_sock)->connected = 1;
+#endif
+        memcpy(&(*apr_sock)->remote_addr->sa.sin, 
+               os_sock_info->remote,
+               (*apr_sock)->remote_addr->salen);
+        /* XXX IPv6 - this assumes sin_port and sin6_port at same offset */
+        (*apr_sock)->remote_addr->port = ntohs((*apr_sock)->remote_addr->sa.sin.sin_port);
+    }
+    else {
+        (*apr_sock)->remote_addr_unknown = 1;
+    }
+        
+    (*apr_sock)->inherit = 0;
+    apr_pool_cleanup_register((*apr_sock)->pool, (void *)(*apr_sock), 
+                              socket_cleanup, socket_cleanup);
+    return APR_SUCCESS;
+}
+
+apr_status_t apr_os_sock_put(apr_socket_t **sock, apr_os_sock_t *thesock, 
+                           apr_pool_t *cont)
+{
+    /* XXX Bogus assumption that *sock points at anything legit */
+    if ((*sock) == NULL) {
+        alloc_socket(sock, cont);
+        /* XXX IPv6 figure out the family here! */
+        /* XXX figure out the actual socket type here */
+        /* *or* just decide that apr_os_sock_put() has to be told the family and type */
+        set_socket_vars(*sock, APR_INET, SOCK_STREAM, 0);
+        (*sock)->timeout = -1;
+    }
+    (*sock)->local_port_unknown = (*sock)->local_interface_unknown = 1;
+    (*sock)->remote_addr_unknown = 1;
+    (*sock)->socketdes = *thesock;
+    return APR_SUCCESS;
+}
+
+APR_POOL_IMPLEMENT_ACCESSOR(socket)
+
+APR_IMPLEMENT_INHERIT_SET(socket, inherit, pool, socket_cleanup)
+
+APR_IMPLEMENT_INHERIT_UNSET(socket, inherit, pool, socket_cleanup)
diff --git a/network_io/unix/sockopt.c b/network_io/unix/sockopt.c
new file mode 100644
index 0000000..6194e9b
--- /dev/null
+++ b/network_io/unix/sockopt.c
@@ -0,0 +1,465 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_strings.h"
+
+
+static apr_status_t soblock(int sd)
+{
+/* BeOS uses setsockopt at present for non blocking... */
+#ifndef BEOS
+    int fd_flags;
+
+    fd_flags = fcntl(sd, F_GETFL, 0);
+#if defined(O_NONBLOCK)
+    fd_flags &= ~O_NONBLOCK;
+#elif defined(O_NDELAY)
+    fd_flags &= ~O_NDELAY;
+#elif defined(FNDELAY)
+    fd_flags &= ~FNDELAY;
+#else
+#error Please teach APR how to make sockets blocking on your platform.
+#endif
+    if (fcntl(sd, F_SETFL, fd_flags) == -1) {
+        return errno;
+    }
+#else
+    int on = 0;
+    if (setsockopt(sd, SOL_SOCKET, SO_NONBLOCK, &on, sizeof(int)) < 0)
+        return errno;
+#endif /* BEOS */
+    return APR_SUCCESS;
+}
+
+static apr_status_t sononblock(int sd)
+{
+#ifndef BEOS
+    int fd_flags;
+
+    fd_flags = fcntl(sd, F_GETFL, 0);
+#if defined(O_NONBLOCK)
+    fd_flags |= O_NONBLOCK;
+#elif defined(O_NDELAY)
+    fd_flags |= O_NDELAY;
+#elif defined(FNDELAY)
+    fd_flags |= FNDELAY;
+#else
+#error Please teach APR how to make sockets non-blocking on your platform.
+#endif
+    if (fcntl(sd, F_SETFL, fd_flags) == -1) {
+        return errno;
+    }
+#else
+    int on = 1;
+    if (setsockopt(sd, SOL_SOCKET, SO_NONBLOCK, &on, sizeof(int)) < 0)
+        return errno;
+#endif /* BEOS */
+    return APR_SUCCESS;
+}
+
+
+apr_status_t apr_socket_timeout_set(apr_socket_t *sock, apr_interval_time_t t)
+{
+    apr_status_t stat;
+
+    /* If our new timeout is non-negative and our old timeout was
+     * negative, then we need to ensure that we are non-blocking.
+     * Conversely, if our new timeout is negative and we had
+     * non-negative timeout, we must make sure our socket is blocking.
+     * We want to avoid calling fcntl more than necessary on the
+     * socket.
+     */
+    if (t >= 0 && sock->timeout < 0) {
+        if (apr_is_option_set(sock, APR_SO_NONBLOCK) != 1) {
+            if ((stat = sononblock(sock->socketdes)) != APR_SUCCESS) {
+                return stat;
+            }
+            apr_set_option(sock, APR_SO_NONBLOCK, 1);
+        }
+    } 
+    else if (t < 0 && sock->timeout >= 0) {
+        if (apr_is_option_set(sock, APR_SO_NONBLOCK) != 0) { 
+            if ((stat = soblock(sock->socketdes)) != APR_SUCCESS) { 
+                return stat; 
+            }
+            apr_set_option(sock, APR_SO_NONBLOCK, 0);
+        } 
+    }
+    /* must disable the incomplete read support if we disable
+     * a timeout
+     */
+    if (t <= 0) {
+        sock->options &= ~APR_INCOMPLETE_READ;
+    }
+    sock->timeout = t;
+    return APR_SUCCESS;
+}
+
+
+apr_status_t apr_socket_opt_set(apr_socket_t *sock, 
+                                apr_int32_t opt, apr_int32_t on)
+{
+    int one;
+    apr_status_t rv;
+
+    if (on)
+        one = 1;
+    else
+        one = 0;
+    switch(opt) {
+    case APR_SO_KEEPALIVE:
+#ifdef SO_KEEPALIVE
+        if (on != apr_is_option_set(sock, APR_SO_KEEPALIVE)) {
+            if (setsockopt(sock->socketdes, SOL_SOCKET, SO_KEEPALIVE, (void *)&one, sizeof(int)) == -1) {
+                return errno;
+            }
+            apr_set_option(sock, APR_SO_KEEPALIVE, on);
+        }
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_SO_DEBUG:
+        if (on != apr_is_option_set(sock, APR_SO_DEBUG)) {
+            if (setsockopt(sock->socketdes, SOL_SOCKET, SO_DEBUG, (void *)&one, sizeof(int)) == -1) {
+                return errno;
+            }
+            apr_set_option(sock, APR_SO_DEBUG, on);
+        }
+        break;
+    case APR_SO_BROADCAST:
+#ifdef SO_BROADCAST
+        if (on != apr_is_option_set(sock, APR_SO_BROADCAST)) {
+            if (setsockopt(sock->socketdes, SOL_SOCKET, SO_BROADCAST, (void *)&one, sizeof(int)) == -1) {
+                return errno;
+            }
+            apr_set_option(sock, APR_SO_BROADCAST, on);
+        }
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_SO_REUSEADDR:
+        if (on != apr_is_option_set(sock, APR_SO_REUSEADDR)) {
+            if (setsockopt(sock->socketdes, SOL_SOCKET, SO_REUSEADDR, (void *)&one, sizeof(int)) == -1) {
+                return errno;
+            }
+            apr_set_option(sock, APR_SO_REUSEADDR, on);
+        }
+        break;
+    case APR_SO_SNDBUF:
+#ifdef SO_SNDBUF
+        if (setsockopt(sock->socketdes, SOL_SOCKET, SO_SNDBUF, (void *)&on, sizeof(int)) == -1) {
+            return errno;
+        }
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_SO_RCVBUF:
+#ifdef SO_RCVBUF
+        if (setsockopt(sock->socketdes, SOL_SOCKET, SO_RCVBUF, (void *)&on, sizeof(int)) == -1) {
+            return errno;
+        }
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_SO_NONBLOCK:
+        if (apr_is_option_set(sock, APR_SO_NONBLOCK) != on) {
+            if (on) {
+                if ((rv = sononblock(sock->socketdes)) != APR_SUCCESS) 
+                    return rv;
+            }
+            else {
+                if ((rv = soblock(sock->socketdes)) != APR_SUCCESS)
+                    return rv;
+            }
+            apr_set_option(sock, APR_SO_NONBLOCK, on);
+        }
+        break;
+    case APR_SO_LINGER:
+#ifdef SO_LINGER
+        if (apr_is_option_set(sock, APR_SO_LINGER) != on) {
+            struct linger li;
+            li.l_onoff = on;
+            li.l_linger = APR_MAX_SECS_TO_LINGER;
+            if (setsockopt(sock->socketdes, SOL_SOCKET, SO_LINGER, (char *) &li, sizeof(struct linger)) == -1) {
+                return errno;
+            }
+            apr_set_option(sock, APR_SO_LINGER, on);
+        }
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_TCP_DEFER_ACCEPT:
+#if defined(TCP_DEFER_ACCEPT)
+        if (apr_is_option_set(sock, APR_TCP_DEFER_ACCEPT) != on) {
+            int optlevel = IPPROTO_TCP;
+            int optname = TCP_DEFER_ACCEPT;
+
+            if (setsockopt(sock->socketdes, optlevel, optname, 
+                           (void *)&on, sizeof(int)) == -1) {
+                return errno;
+            }
+            apr_set_option(sock, APR_TCP_DEFER_ACCEPT, on);
+        }
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_TCP_NODELAY:
+#if defined(TCP_NODELAY)
+        if (apr_is_option_set(sock, APR_TCP_NODELAY) != on) {
+            int optlevel = IPPROTO_TCP;
+            int optname = TCP_NODELAY;
+
+#if APR_HAVE_SCTP
+            if (sock->protocol == IPPROTO_SCTP) {
+                optlevel = IPPROTO_SCTP;
+                optname = SCTP_NODELAY;
+            }
+#endif
+            if (setsockopt(sock->socketdes, optlevel, optname, (void *)&on, sizeof(int)) == -1) {
+                return errno;
+            }
+            apr_set_option(sock, APR_TCP_NODELAY, on);
+        }
+#else
+        /* BeOS pre-BONE has TCP_NODELAY set by default.
+         * As it can't be turned off we might as well check if they're asking
+         * for it to be turned on!
+         */
+#ifdef BEOS
+        if (on == 1)
+            return APR_SUCCESS;
+        else
+#endif
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_TCP_NOPUSH:
+#if APR_TCP_NOPUSH_FLAG
+        /* TCP_NODELAY and TCP_CORK are mutually exclusive on Linux
+         * kernels < 2.6; on newer kernels they can be used together
+         * and TCP_CORK takes preference, which is the desired
+         * behaviour.  On older kernels, TCP_NODELAY must be toggled
+         * to "off" whilst TCP_CORK is in effect. */
+        if (apr_is_option_set(sock, APR_TCP_NOPUSH) != on) {
+#ifndef HAVE_TCP_NODELAY_WITH_CORK
+            int optlevel = IPPROTO_TCP;
+            int optname = TCP_NODELAY;
+
+#if APR_HAVE_SCTP
+            if (sock->protocol == IPPROTO_SCTP) {
+                optlevel = IPPROTO_SCTP;
+                optname = SCTP_NODELAY;
+            }
+#endif
+            /* OK we're going to change some settings here... */
+            if (apr_is_option_set(sock, APR_TCP_NODELAY) == 1 && on) {
+                /* Now toggle TCP_NODELAY to off, if TCP_CORK is being
+                 * turned on: */
+                int tmpflag = 0;
+                if (setsockopt(sock->socketdes, optlevel, optname,
+                               (void*)&tmpflag, sizeof(int)) == -1) {
+                    return errno;
+                }
+                apr_set_option(sock, APR_RESET_NODELAY, 1);
+                apr_set_option(sock, APR_TCP_NODELAY, 0);
+            } else if (on) {
+                apr_set_option(sock, APR_RESET_NODELAY, 0);
+            }
+#endif /* HAVE_TCP_NODELAY_WITH_CORK */
+
+            /* OK, now we can just set the TCP_NOPUSH flag accordingly...*/
+            if (setsockopt(sock->socketdes, IPPROTO_TCP, APR_TCP_NOPUSH_FLAG,
+                           (void*)&on, sizeof(int)) == -1) {
+                return errno;
+            }
+            apr_set_option(sock, APR_TCP_NOPUSH, on);
+#ifndef HAVE_TCP_NODELAY_WITH_CORK
+            if (!on && apr_is_option_set(sock, APR_RESET_NODELAY)) {
+                /* Now, if TCP_CORK was just turned off, turn
+                 * TCP_NODELAY back on again if it was earlier toggled
+                 * to off: */
+                int tmpflag = 1;
+                if (setsockopt(sock->socketdes, optlevel, optname,
+                               (void*)&tmpflag, sizeof(int)) == -1) {
+                    return errno;
+                }
+                apr_set_option(sock, APR_RESET_NODELAY,0);
+                apr_set_option(sock, APR_TCP_NODELAY, 1);
+            }
+#endif /* HAVE_TCP_NODELAY_WITH_CORK */
+        }
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_INCOMPLETE_READ:
+        apr_set_option(sock, APR_INCOMPLETE_READ, on);
+        break;
+    case APR_IPV6_V6ONLY:
+#if APR_HAVE_IPV6 && defined(IPV6_V6ONLY)
+        /* we don't know the initial setting of this option,
+         * so don't check sock->options since that optimization
+         * won't work
+         */
+        if (setsockopt(sock->socketdes, IPPROTO_IPV6, IPV6_V6ONLY,
+                       (void *)&on, sizeof(int)) == -1) {
+            return errno;
+        }
+        apr_set_option(sock, APR_IPV6_V6ONLY, on);
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    case APR_SO_FREEBIND:
+#if defined(IP_FREEBIND)
+        if (setsockopt(sock->socketdes, SOL_IP, IP_FREEBIND,
+                       (void *)&one, sizeof(int)) == -1) {
+            return errno;
+        }
+        apr_set_option(sock, APR_SO_FREEBIND, on);
+#elif 0 /* defined(IP_BINDANY) ... */
+        /* TODO: insert FreeBSD support here, note family specific
+         * options, IP_BINDANY vs IPV6_BINDANY */
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    default:
+        return APR_EINVAL;
+    }
+
+    return APR_SUCCESS; 
+}         
+
+
+apr_status_t apr_socket_timeout_get(apr_socket_t *sock, apr_interval_time_t *t)
+{
+    *t = sock->timeout;
+    return APR_SUCCESS;
+}
+
+
+apr_status_t apr_socket_opt_get(apr_socket_t *sock, 
+                                apr_int32_t opt, apr_int32_t *on)
+{
+    switch(opt) {
+        default:
+            *on = apr_is_option_set(sock, opt);
+    }
+    return APR_SUCCESS;
+}
+
+
+apr_status_t apr_socket_atmark(apr_socket_t *sock, int *atmark)
+{
+#ifndef BEOS_R5
+    int oobmark;
+
+    if (ioctl(sock->socketdes, SIOCATMARK, (void*) &oobmark) < 0)
+        return apr_get_netos_error();
+
+    *atmark = (oobmark != 0);
+
+    return APR_SUCCESS;
+#else /* BEOS_R5 */
+    return APR_ENOTIMPL;
+#endif
+}
+
+apr_status_t apr_gethostname(char *buf, apr_int32_t len, apr_pool_t *cont)
+{
+#ifdef BEOS_R5
+    if (gethostname(buf, len) == 0) {
+#else
+    if (gethostname(buf, len) != 0) {
+#endif  
+        buf[0] = '\0';
+        return errno;
+    }
+    else if (!memchr(buf, '\0', len)) { /* buffer too small */
+        /* note... most platforms just truncate in this condition
+         *         linux+glibc return an error
+         */
+        buf[0] = '\0';
+        return APR_ENAMETOOLONG;
+    }
+    return APR_SUCCESS;
+}
+
+#if APR_HAS_SO_ACCEPTFILTER
+apr_status_t apr_socket_accept_filter(apr_socket_t *sock, char *nonconst_name, 
+                                      char *nonconst_args)
+{
+    /* these should have been const; act like they are */
+    const char *name = nonconst_name;
+    const char *args = nonconst_args;
+
+    struct accept_filter_arg af;
+    socklen_t optlen = sizeof(af);
+
+    /* FreeBSD returns an error if the filter is already set; ignore
+     * this call if we previously set it to the same value.
+     */
+    if ((getsockopt(sock->socketdes, SOL_SOCKET, SO_ACCEPTFILTER,
+                    &af, &optlen)) == 0) {
+        if (!strcmp(name, af.af_name) && !strcmp(args, af.af_arg)) {
+            return APR_SUCCESS;
+        }
+    }
+
+    /* Uhh, at least in FreeBSD 9 the fields are declared as arrays of
+     * these lengths; did sizeof not work in some ancient release?
+     *
+     * FreeBSD kernel sets the last byte to a '\0'.
+     */
+    apr_cpystrn(af.af_name, name, 16);
+    apr_cpystrn(af.af_arg, args, 256 - 16);
+
+    if ((setsockopt(sock->socketdes, SOL_SOCKET, SO_ACCEPTFILTER,
+          &af, sizeof(af))) < 0) {
+        return errno;
+    }
+    return APR_SUCCESS;
+}
+#endif
+
+APR_PERMS_SET_IMPLEMENT(socket)
+{
+#if APR_HAVE_SOCKADDR_UN
+    apr_status_t rv = APR_SUCCESS;
+    apr_socket_t *socket = (apr_socket_t *)thesocket;
+
+    if (socket->local_addr->family == APR_UNIX) {
+        if (!(perms & APR_FPROT_GSETID))
+            gid = -1;
+        if (fchown(socket->socketdes, uid, gid) < 0) {
+            rv = errno;
+        }
+    }
+    else
+        rv = APR_EINVAL;
+    return rv;
+#else
+    return APR_ENOTIMPL;
+#endif
+}
diff --git a/network_io/win32/sendrecv.c b/network_io/win32/sendrecv.c
new file mode 100644
index 0000000..6620e13
--- /dev/null
+++ b/network_io/win32/sendrecv.c
@@ -0,0 +1,442 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_errno.h"
+#include "apr_general.h"
+#include "apr_network_io.h"
+#include "apr_lib.h"
+#include "apr_arch_file_io.h"
+#if APR_HAVE_TIME_H
+#include <time.h>
+#endif
+
+/* MAX_SEGMENT_SIZE is the maximum amount of data that will be sent to a client
+ * in one call of TransmitFile. This number must be small enough to give the 
+ * slowest client time to receive the data before the socket timeout triggers.
+ * The same problem can exist with apr_socket_send(). In that case, we rely on
+ * the application to adjust socket timeouts and max send segment 
+ * sizes appropriately.
+ * For example, Apache will in most cases call apr_socket_send() with less
+ * than 8193 bytes.
+ */
+#define MAX_SEGMENT_SIZE 65536
+#define WSABUF_ON_STACK 50
+
+APR_DECLARE(apr_status_t) apr_socket_send(apr_socket_t *sock, const char *buf,
+                                          apr_size_t *len)
+{
+    apr_ssize_t rv;
+    WSABUF wsaData;
+    int lasterror;
+    DWORD dwBytes = 0;
+
+    wsaData.len = (u_long)*len;
+    wsaData.buf = (char*) buf;
+
+#ifndef _WIN32_WCE
+    rv = WSASend(sock->socketdes, &wsaData, 1, &dwBytes, 0, NULL, NULL);
+#else
+    rv = send(sock->socketdes, wsaData.buf, wsaData.len, 0);
+    dwBytes = rv;
+#endif
+    if (rv == SOCKET_ERROR) {
+        lasterror = apr_get_netos_error();
+        *len = 0;
+        return lasterror;
+    }
+
+    *len = dwBytes;
+
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_socket_recv(apr_socket_t *sock, char *buf,
+                                          apr_size_t *len) 
+{
+    apr_ssize_t rv;
+    WSABUF wsaData;
+    int lasterror;
+    DWORD dwBytes = 0;
+    DWORD flags = 0;
+
+    wsaData.len = (u_long)*len;
+    wsaData.buf = (char*) buf;
+
+#ifndef _WIN32_WCE
+    rv = WSARecv(sock->socketdes, &wsaData, 1, &dwBytes, &flags, NULL, NULL);
+#else
+    rv = recv(sock->socketdes, wsaData.buf, wsaData.len, 0);
+    dwBytes = rv;
+#endif
+    if (rv == SOCKET_ERROR) {
+        lasterror = apr_get_netos_error();
+        *len = 0;
+        return lasterror;
+    }
+
+    *len = dwBytes;
+    return dwBytes == 0 ? APR_EOF : APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_socket_sendv(apr_socket_t *sock,
+                                           const struct iovec *vec,
+                                           apr_int32_t in_vec, apr_size_t *nbytes)
+{
+    apr_status_t rc = APR_SUCCESS;
+    apr_ssize_t rv;
+    apr_size_t total_len;
+    apr_int32_t i;
+    DWORD dwBytes = 0;
+    WSABUF *pWsaBuf;
+
+    total_len = 0;
+    for (i = 0; i < in_vec; i++) {
+        apr_size_t iov_len = vec[i].iov_len;
+        if (iov_len > (apr_size_t)MAXDWORD - total_len) {
+            /* WSASend() returns NumberOfBytesSent as DWORD, so the total size
+               should be less than that. */
+            return APR_EINVAL;
+        }
+        total_len += iov_len;
+    }
+
+    pWsaBuf = (in_vec <= WSABUF_ON_STACK) ? _alloca(sizeof(WSABUF) * (in_vec))
+                                          : malloc(sizeof(WSABUF) * (in_vec));
+    if (!pWsaBuf)
+        return APR_ENOMEM;
+
+    for (i = 0; i < in_vec; i++) {
+        pWsaBuf[i].buf = vec[i].iov_base;
+        pWsaBuf[i].len = (ULONG) vec[i].iov_len;
+    }
+#ifndef _WIN32_WCE
+    rv = WSASend(sock->socketdes, pWsaBuf, in_vec, &dwBytes, 0, NULL, NULL);
+    if (rv == SOCKET_ERROR) {
+        rc = apr_get_netos_error();
+    }
+#else
+    for (i = 0; i < in_vec; i++) {
+        rv = send(sock->socketdes, pWsaBuf[i].buf, pWsaBuf[i].len, 0);
+        if (rv == SOCKET_ERROR) {
+            rc = apr_get_netos_error();
+            break;
+        }
+        dwBytes += rv;
+    }
+#endif
+    if (in_vec > WSABUF_ON_STACK)
+        free(pWsaBuf);
+
+    *nbytes = dwBytes;
+    return rc;
+}
+
+
+APR_DECLARE(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;
+
+    rv = sendto(sock->socketdes, buf, (int)*len, flags, 
+                (const struct sockaddr*)&where->sa, 
+                where->salen);
+    if (rv == SOCKET_ERROR) {
+        *len = 0;
+        return apr_get_netos_error();
+    }
+
+    *len = rv;
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(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);
+
+    rv = recvfrom(sock->socketdes, buf, (int)*len, flags, 
+                  (struct sockaddr*)&from->sa, &from->salen);
+    if (rv == SOCKET_ERROR) {
+        (*len) = 0;
+        return apr_get_netos_error();
+    }
+
+    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;
+}
+
+
+#if APR_HAS_SENDFILE
+static apr_status_t collapse_iovec(char **off, apr_size_t *len, 
+                                   struct iovec *iovec, int numvec, 
+                                   char *buf, apr_size_t buflen)
+{
+    if (numvec == 1) {
+        *off = iovec[0].iov_base;
+        *len = iovec[0].iov_len;
+    }
+    else {
+        int i;
+        for (i = 0; i < numvec; i++) {
+            *len += iovec[i].iov_len;
+        }
+
+        if (*len > buflen) {
+            *len = 0;
+            return APR_INCOMPLETE;
+        }
+
+        *off = buf;
+
+        for (i = 0; i < numvec; i++) {
+            memcpy(buf, iovec[i].iov_base, iovec[i].iov_len);
+            buf += iovec[i].iov_len;
+        }
+    }
+    return APR_SUCCESS;
+}
+
+
+/*
+ * apr_status_t apr_socket_sendfile(apr_socket_t *, apr_file_t *, apr_hdtr_t *, 
+ *                                 apr_off_t *, apr_size_t *, apr_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 out of the file
+ * arg 6) APR flags that are mapped to OS specific flags
+ */
+APR_DECLARE(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 status = APR_SUCCESS;
+    apr_status_t rv;
+    apr_off_t curoff = *offset;
+    DWORD dwFlags = 0;
+    apr_size_t nbytes;
+    TRANSMIT_FILE_BUFFERS tfb, *ptfb = NULL;
+    apr_size_t bytes_to_send;   /* Bytes to send out of the file (not including headers) */
+    int disconnected = 0;
+    int sendv_trailers = 0;
+    char hdtrbuf[4096];
+
+    if (apr_os_level < APR_WIN_NT) {
+        return APR_ENOTIMPL;
+    }
+
+    /* Use len to keep track of number of total bytes sent (including headers) */
+    bytes_to_send = *len;
+    *len = 0;
+
+    /* Handle the goofy case of sending headers/trailers and a zero byte file */
+    if (!bytes_to_send && hdtr) {
+        if (hdtr->numheaders) {
+            rv = apr_socket_sendv(sock, hdtr->headers, hdtr->numheaders, 
+                                  &nbytes);
+            if (rv != APR_SUCCESS)
+                return rv;
+            *len += nbytes;
+        }
+        if (hdtr->numtrailers) {
+            rv = apr_socket_sendv(sock, hdtr->trailers, hdtr->numtrailers,
+                                  &nbytes);
+            if (rv != APR_SUCCESS)
+                return rv;
+            *len += nbytes;
+        }
+        return APR_SUCCESS;
+    }
+
+    memset(&tfb, '\0', sizeof (tfb));
+
+    /* Collapse the headers into a single buffer */
+    if (hdtr && hdtr->numheaders) {
+        apr_size_t head_length = tfb.HeadLength;
+        ptfb = &tfb;
+        nbytes = 0;
+        rv = collapse_iovec((char **)&ptfb->Head, &head_length, 
+                            hdtr->headers, hdtr->numheaders, 
+                            hdtrbuf, sizeof(hdtrbuf));
+
+        tfb.HeadLength = (DWORD)head_length;
+
+        /* If not enough buffer, punt to sendv */
+        if (rv == APR_INCOMPLETE) {
+            rv = apr_socket_sendv(sock, hdtr->headers, hdtr->numheaders, &nbytes);
+            if (rv != APR_SUCCESS)
+                return rv;
+            *len += nbytes;
+            ptfb = NULL;
+        }
+    }
+
+    /* Initialize the overlapped structure used on TransmitFile
+     */
+    if (!sock->overlapped) {
+        sock->overlapped = apr_pcalloc(sock->pool, sizeof(OVERLAPPED));
+        sock->overlapped->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+    }
+    while (bytes_to_send) {
+        DWORD xmitbytes;
+
+        if (bytes_to_send > MAX_SEGMENT_SIZE) {
+            xmitbytes = MAX_SEGMENT_SIZE;
+        }
+        else {
+            /* Last call to TransmitFile() */
+            xmitbytes = (DWORD)bytes_to_send;
+            /* Collapse the trailers into a single buffer */
+            if (hdtr && hdtr->numtrailers) {
+                apr_size_t tail_length = tfb.TailLength;
+                ptfb = &tfb;
+                rv = collapse_iovec((char**) &ptfb->Tail, &tail_length,
+                                    hdtr->trailers, hdtr->numtrailers,
+                                    hdtrbuf + ptfb->HeadLength,
+                                    sizeof(hdtrbuf) - ptfb->HeadLength);
+
+                tfb.TailLength = (DWORD)tail_length;
+
+                if (rv == APR_INCOMPLETE) {
+                    /* If not enough buffer, punt to sendv, later */
+                    sendv_trailers = 1;
+                }
+            }
+            /* Disconnect the socket after last send */
+            if ((flags & APR_SENDFILE_DISCONNECT_SOCKET)
+                    && !sendv_trailers) {
+                dwFlags |= TF_REUSE_SOCKET;
+                dwFlags |= TF_DISCONNECT;
+                disconnected = 1;
+            }
+        }
+
+        sock->overlapped->Offset = (DWORD)(curoff);
+#if APR_HAS_LARGE_FILES
+        sock->overlapped->OffsetHigh = (DWORD)(curoff >> 32);
+#endif  
+        /* XXX BoundsChecker claims dwFlags must not be zero. */
+        rv = TransmitFile(sock->socketdes,  /* socket */
+                          file->filehand, /* open file descriptor of the file to be sent */
+                          xmitbytes,      /* number of bytes to send. 0=send all */
+                          0,              /* Number of bytes per send. 0=use default */
+                          sock->overlapped,    /* OVERLAPPED structure */
+                          ptfb,           /* header and trailer buffers */
+                          dwFlags);       /* flags to control various aspects of TransmitFile */
+        if (!rv) {
+            status = apr_get_netos_error();
+            if ((status == APR_FROM_OS_ERROR(ERROR_IO_PENDING)) ||
+                (status == APR_FROM_OS_ERROR(WSA_IO_PENDING))) 
+            {
+                rv = WaitForSingleObject(sock->overlapped->hEvent, 
+                                         (DWORD)(sock->timeout >= 0 
+                                                 ? sock->timeout_ms : INFINITE));
+                if (rv == WAIT_OBJECT_0) {
+                    status = APR_SUCCESS;
+                    if (!disconnected) {
+                        if (!WSAGetOverlappedResult(sock->socketdes,
+                                                    sock->overlapped,
+                                                    &xmitbytes,
+                                                    FALSE,
+                                                    &dwFlags)) {
+                            status = apr_get_netos_error();
+                        }
+                        /* Ugly code alert: WSAGetOverlappedResult returns
+                         * a count of all bytes sent. This loop only
+                         * tracks bytes sent out of the file.
+                         */
+                        else if (ptfb) {
+                            xmitbytes -= (ptfb->HeadLength + ptfb->TailLength);
+                        }
+                    }
+                }
+                else if (rv == WAIT_TIMEOUT) {
+                    status = APR_FROM_OS_ERROR(WAIT_TIMEOUT);
+                }
+                else if (rv == WAIT_ABANDONED) {
+                    /* Hummm... WAIT_ABANDONDED is not an error code. It is
+                     * a return specific to the Win32 WAIT functions that
+                     * indicates that a thread exited while holding a
+                     * mutex. Should consider triggering an assert
+                     * to detect the condition...
+                     */
+                    status = APR_FROM_OS_ERROR(WAIT_TIMEOUT);
+                }
+                else
+                    status = apr_get_os_error();
+            }
+        }
+        if (status != APR_SUCCESS)
+            break;
+
+        bytes_to_send -= xmitbytes;
+        curoff += xmitbytes;
+        *len += xmitbytes;
+        /* Adjust len for any headers/trailers sent */
+        if (ptfb) {
+            *len += (ptfb->HeadLength + ptfb->TailLength);
+            memset(&tfb, '\0', sizeof (tfb));
+            ptfb = NULL;
+        }
+    }
+
+    if (status == APR_SUCCESS) {
+        if (sendv_trailers) {
+            rv = apr_socket_sendv(sock, hdtr->trailers, hdtr->numtrailers, &nbytes);
+            if (rv != APR_SUCCESS)
+                return rv;
+            *len += nbytes;
+        }
+
+    
+        /* Mark the socket as disconnected, but do not close it.
+         * Note: The application must have stored the socket prior to making
+         * the call to apr_socket_sendfile in order to either reuse it 
+         * or close it.
+         */
+        if (disconnected) {
+            sock->disconnected = 1;
+            sock->socketdes = INVALID_SOCKET;
+        }
+    }
+
+    return status;
+}
+
+#endif
+
diff --git a/network_io/win32/sockets.c b/network_io/win32/sockets.c
new file mode 100644
index 0000000..5013bba
--- /dev/null
+++ b/network_io/win32/sockets.c
@@ -0,0 +1,559 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_network_io.h"
+#include "apr_general.h"
+#include "apr_lib.h"
+#include "apr_portable.h"
+#include "apr_strings.h"
+#include <string.h>
+#include "apr_arch_inherit.h"
+#include "apr_arch_misc.h"
+
+/* Borrow the definition of SOMAXCONN_HINT() from Windows SDK 8,
+ * in case the SDK we are building against doesn't have it.
+ */
+#ifndef SOMAXCONN_HINT
+#define SOMAXCONN_HINT(b) (-(b))
+#endif
+
+static char generic_inaddr_any[16] = {0}; /* big enough for IPv4 or IPv6 */
+
+static apr_status_t socket_cleanup(void *sock)
+{
+    apr_socket_t *thesocket = sock;
+
+    if (thesocket->socketdes != INVALID_SOCKET) {
+        if (closesocket(thesocket->socketdes) == SOCKET_ERROR) {
+            return apr_get_netos_error();
+        }
+        thesocket->socketdes = INVALID_SOCKET;
+    }
+#if APR_HAS_SENDFILE
+    if (thesocket->overlapped) {
+        CloseHandle(thesocket->overlapped->hEvent);
+        thesocket->overlapped = NULL;
+    }
+#endif
+    return APR_SUCCESS;
+}
+
+static void set_socket_vars(apr_socket_t *sock, int family, int type, int protocol)
+{
+    sock->type = type;
+    sock->protocol = protocol;
+    apr_sockaddr_vars_set(sock->local_addr, family, 0);
+    apr_sockaddr_vars_set(sock->remote_addr, family, 0);
+#if APR_HAVE_IPV6
+    /* hard-coded behavior for older Windows IPv6 */
+    if (apr_os_level < APR_WIN_VISTA && family == AF_INET6) {
+        apr_set_option(sock, APR_IPV6_V6ONLY, 1);
+    }
+#endif
+}                                                                                                  
+static void alloc_socket(apr_socket_t **new, apr_pool_t *p)
+{
+    *new = (apr_socket_t *)apr_pcalloc(p, sizeof(apr_socket_t));
+    (*new)->pool = p;
+    (*new)->local_addr = (apr_sockaddr_t *)apr_pcalloc((*new)->pool,
+                                                       sizeof(apr_sockaddr_t));
+    (*new)->local_addr->pool = p;
+    
+    (*new)->remote_addr = (apr_sockaddr_t *)apr_pcalloc((*new)->pool,
+                                                        sizeof(apr_sockaddr_t));
+    (*new)->remote_addr->pool = p;
+    (*new)->remote_addr_unknown = 1;
+
+    /* Create a pollset with room for one descriptor. */
+    /* ### check return codes */
+    (void) apr_pollset_create(&(*new)->pollset, 1, p, 0);
+}
+
+APR_DECLARE(apr_status_t) apr_socket_protocol_get(apr_socket_t *sock,
+                                                  int *protocol)
+{
+    *protocol = sock->protocol;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_socket_create(apr_socket_t **new, int family,
+                                            int type, int protocol, 
+                                            apr_pool_t *cont)
+{
+#if APR_HAVE_IPV6
+    int downgrade = (family == AF_UNSPEC);
+#endif
+
+    if (family == AF_UNSPEC) {
+#if APR_HAVE_IPV6
+        family = AF_INET6;
+#else
+        family = AF_INET;
+#endif
+    }
+
+    alloc_socket(new, cont);
+
+    /* For right now, we are not using socket groups.  We may later.
+     * No flags to use when creating a socket, so use 0 for that parameter as well.
+     */
+    (*new)->socketdes = socket(family, type, protocol);
+#if APR_HAVE_IPV6
+    if ((*new)->socketdes == INVALID_SOCKET && downgrade) {
+        family = AF_INET;
+        (*new)->socketdes = socket(family, type, protocol);
+    }
+#endif
+
+    if ((*new)->socketdes == INVALID_SOCKET) {
+        return apr_get_netos_error();
+    }
+
+#ifdef WIN32
+    /* Socket handles are never truly inheritable, there are too many
+     * bugs associated.  WSADuplicateSocket will copy them, but for our
+     * purposes, always transform the socket() created as a non-inherited
+     * handle
+     */
+#if APR_HAS_UNICODE_FS && !defined(_WIN32_WCE)
+    IF_WIN_OS_IS_UNICODE {
+        /* A different approach.  Many users report errors such as 
+         * (32538)An operation was attempted on something that is not 
+         * a socket.  : Parent: WSADuplicateSocket failed...
+         *
+         * This appears that the duplicated handle is no longer recognized
+         * as a socket handle.  SetHandleInformation should overcome that
+         * problem by not altering the handle identifier.  But this won't
+         * work on 9x - it's unsupported.
+         */
+        SetHandleInformation((HANDLE) (*new)->socketdes, 
+                             HANDLE_FLAG_INHERIT, 0);
+    }
+#if APR_HAS_ANSI_FS
+    /* only if APR_HAS_ANSI_FS && APR_HAS_UNICODE_FS */
+    ELSE_WIN_OS_IS_ANSI
+#endif
+#endif
+#if APR_HAS_ANSI_FS || defined(_WIN32_WCE)
+    {
+        HANDLE hProcess = GetCurrentProcess();
+        HANDLE dup;
+        if (DuplicateHandle(hProcess, (HANDLE) (*new)->socketdes, hProcess, 
+                            &dup, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
+            closesocket((*new)->socketdes);
+            (*new)->socketdes = (SOCKET) dup;
+        }
+    }
+#endif
+
+#endif /* def WIN32 */
+
+    set_socket_vars(*new, family, type, protocol);
+
+    (*new)->timeout = -1;
+    (*new)->disconnected = 0;
+
+    apr_pool_cleanup_register((*new)->pool, (void *)(*new), 
+                        socket_cleanup, apr_pool_cleanup_null);
+
+    return APR_SUCCESS;
+} 
+
+APR_DECLARE(apr_status_t) apr_socket_shutdown(apr_socket_t *thesocket,
+                                              apr_shutdown_how_e how)
+{
+    int winhow = 0;
+
+#ifdef SD_RECEIVE
+    switch (how) {
+        case APR_SHUTDOWN_READ: {
+            winhow = SD_RECEIVE;
+            break;
+        }
+        case APR_SHUTDOWN_WRITE: {
+            winhow = SD_SEND;
+            break;
+        }
+        case APR_SHUTDOWN_READWRITE: {
+            winhow = SD_BOTH;
+            break;
+        }
+        default:
+            return APR_BADARG;
+    }
+#endif
+    if (shutdown(thesocket->socketdes, winhow) == 0) {
+        return APR_SUCCESS;
+    }
+    else {
+        return apr_get_netos_error();
+    }
+}
+
+APR_DECLARE(apr_status_t) apr_socket_close(apr_socket_t *thesocket)
+{
+    apr_pool_cleanup_kill(thesocket->pool, thesocket, socket_cleanup);
+    return socket_cleanup(thesocket);
+}
+
+APR_DECLARE(apr_status_t) apr_socket_bind(apr_socket_t *sock,
+                                          apr_sockaddr_t *sa)
+{
+    if (bind(sock->socketdes, 
+             (struct sockaddr *)&sa->sa, 
+             sa->salen) == -1) {
+        return apr_get_netos_error();
+    }
+    else {
+        sock->local_addr = sa;
+        if (sock->local_addr->sa.sin.sin_port == 0) {
+            sock->local_port_unknown = 1; /* ephemeral port */
+        }
+        return APR_SUCCESS;
+    }
+}
+
+APR_DECLARE(apr_status_t) apr_socket_listen(apr_socket_t *sock,
+                                            apr_int32_t backlog)
+{
+    int backlog_val;
+
+    if (apr_os_level >= APR_WIN_8) {
+        /* Starting from Windows 8, listen() accepts a special SOMAXCONN_HINT()
+         * arg that allows setting the listen backlog value to a larger
+         * value than the predefined Winsock 2 limit (several hundred).
+         * https://blogs.msdn.microsoft.com/winsdk/2015/06/01/winsocks-listen-backlog-offers-more-flexibility-in-windows-8/
+         */
+        backlog_val = SOMAXCONN_HINT(backlog);
+    }
+    else {
+        backlog_val = backlog;
+    }
+
+    if (listen(sock->socketdes, backlog_val) == SOCKET_ERROR)
+        return apr_get_netos_error();
+    else
+        return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_socket_accept(apr_socket_t **new, 
+                                            apr_socket_t *sock, apr_pool_t *p)
+{
+    SOCKET s;
+#if APR_HAVE_IPV6
+    struct sockaddr_storage sa;
+#else
+    struct sockaddr sa;
+#endif
+    int salen = sizeof(sock->remote_addr->sa);
+
+    /* Don't allocate the memory until after we call accept. This allows
+       us to work with nonblocking sockets. */
+    s = accept(sock->socketdes, (struct sockaddr *)&sa, &salen);
+    if (s == INVALID_SOCKET) {
+        return apr_get_netos_error();
+    }
+
+    alloc_socket(new, p);
+    set_socket_vars(*new, sock->local_addr->sa.sin.sin_family, SOCK_STREAM, 
+                    sock->protocol);
+
+    (*new)->timeout = -1;   
+    (*new)->disconnected = 0;
+
+    (*new)->socketdes = s;
+    /* XXX next line looks bogus w.r.t. AF_INET6 support */
+    (*new)->remote_addr->salen = sizeof((*new)->remote_addr->sa);
+    memcpy (&(*new)->remote_addr->sa, &sa, salen);
+    *(*new)->local_addr = *sock->local_addr;
+    (*new)->remote_addr_unknown = 0;
+
+    /* The above assignment just overwrote the pool entry. Setting the local_addr 
+       pool for the accepted socket back to what it should be.  Otherwise all 
+       allocations for this socket will come from a server pool that is not
+       freed until the process goes down.*/
+    (*new)->local_addr->pool = p;
+
+    /* fix up any pointers which are no longer valid */
+    if (sock->local_addr->sa.sin.sin_family == AF_INET) {
+        (*new)->local_addr->ipaddr_ptr = &(*new)->local_addr->sa.sin.sin_addr;
+    }
+#if APR_HAVE_IPV6
+    else if (sock->local_addr->sa.sin.sin_family == AF_INET6) {
+        (*new)->local_addr->ipaddr_ptr = &(*new)->local_addr->sa.sin6.sin6_addr;
+    }
+#endif
+    (*new)->remote_addr->port = ntohs((*new)->remote_addr->sa.sin.sin_port);
+    if (sock->local_port_unknown) {
+        /* not likely for a listening socket, but theoretically possible :) */
+        (*new)->local_port_unknown = 1;
+    }
+
+#if APR_TCP_NODELAY_INHERITED
+    if (apr_is_option_set(sock, APR_TCP_NODELAY) == 1) {
+        apr_set_option(*new, APR_TCP_NODELAY, 1);
+    }
+#endif /* TCP_NODELAY_INHERITED */
+#if APR_O_NONBLOCK_INHERITED
+    if (apr_is_option_set(sock, APR_SO_NONBLOCK) == 1) {
+        apr_set_option(*new, APR_SO_NONBLOCK, 1);
+    }
+#endif /* APR_O_NONBLOCK_INHERITED */
+
+    if (sock->local_interface_unknown ||
+        !memcmp(sock->local_addr->ipaddr_ptr,
+                generic_inaddr_any,
+                sock->local_addr->ipaddr_len)) {
+        /* If the interface address inside the listening socket's local_addr wasn't
+         * up-to-date, we don't know local interface of the connected socket either.
+         *
+         * If the listening socket was not bound to a specific interface, we
+         * don't know the local_addr of the connected socket.
+         */
+        (*new)->local_interface_unknown = 1;
+    }
+
+    apr_pool_cleanup_register((*new)->pool, (void *)(*new), 
+                        socket_cleanup, apr_pool_cleanup_null);
+    return APR_SUCCESS;
+}
+
+static apr_status_t wait_for_connect(apr_socket_t *sock)
+{
+    int rc;
+    struct timeval tv, *tvptr;
+    fd_set wfdset, efdset;
+
+    /* wait for the connect to complete or timeout */
+    FD_ZERO(&wfdset);
+    FD_SET(sock->socketdes, &wfdset);
+    FD_ZERO(&efdset);
+    FD_SET(sock->socketdes, &efdset);
+
+    if (sock->timeout < 0) {
+        tvptr = NULL;
+    }
+    else {
+        /* casts for winsock/timeval definition */
+        tv.tv_sec =  (long)apr_time_sec(sock->timeout);
+        tv.tv_usec = (int)apr_time_usec(sock->timeout);
+        tvptr = &tv;
+    }
+    rc = select(FD_SETSIZE+1, NULL, &wfdset, &efdset, tvptr);
+    if (rc == SOCKET_ERROR) {
+        return apr_get_netos_error();
+    }
+    else if (!rc) {
+        return APR_FROM_OS_ERROR(WSAETIMEDOUT);
+    }
+    /* Evaluate the efdset */
+    if (FD_ISSET(sock->socketdes, &efdset)) {
+        /* The connect failed. */
+        int rclen = sizeof(rc);
+        if (getsockopt(sock->socketdes, SOL_SOCKET, SO_ERROR, (char*) &rc, &rclen)) {
+            return apr_get_netos_error();
+        }
+        return APR_FROM_OS_ERROR(rc);
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_socket_connect(apr_socket_t *sock, 
+                                             apr_sockaddr_t *sa)
+{
+    apr_status_t rv;
+
+    if ((sock->socketdes == INVALID_SOCKET) || (!sock->local_addr)) {
+        return APR_ENOTSOCK;
+    }
+
+    if (connect(sock->socketdes, (const struct sockaddr *)&sa->sa.sin,
+                sa->salen) == SOCKET_ERROR) {
+        rv = apr_get_netos_error();
+    }
+    else {
+        rv = APR_SUCCESS;
+    }
+
+    if (rv == APR_FROM_OS_ERROR(WSAEWOULDBLOCK)) {
+        if (sock->timeout == 0) {
+            /* Tell the app that the connect is in progress...
+             * Gotta play some games here.  connect on Unix will return 
+             * EINPROGRESS under the same circumstances that Windows 
+             * returns WSAEWOULDBLOCK. Do some adhoc canonicalization...
+             */
+            rv = APR_FROM_OS_ERROR(WSAEINPROGRESS);
+        }
+        else {
+            rv = wait_for_connect(sock);
+            if (rv != APR_SUCCESS) {
+                return rv;
+            }
+        }
+    }
+
+    if (memcmp(sa->ipaddr_ptr, generic_inaddr_any, sa->ipaddr_len)) {
+        /* A real remote address was passed in.  If the unspecified
+         * address was used, the actual remote addr will have to be
+         * determined using getpeername() if required. */
+        sock->remote_addr_unknown = 0;
+
+        /* Copy the address structure details in. */
+        sock->remote_addr = sa;
+    }
+
+    if (sock->local_addr->sa.sin.sin_port == 0) {
+        /* connect() got us an ephemeral port */
+        sock->local_port_unknown = 1;
+    }
+    if (!memcmp(sock->local_addr->ipaddr_ptr,
+                generic_inaddr_any,
+                sock->local_addr->ipaddr_len)) {
+        /* not bound to specific local interface; connect() had to assign
+         * one for the socket
+         */
+        sock->local_interface_unknown = 1;
+    }
+
+    if (rv != APR_SUCCESS && rv != APR_FROM_OS_ERROR(WSAEISCONN)) {
+        return rv;
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_socket_type_get(apr_socket_t *sock, int *type)
+{
+    *type = sock->type;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_socket_data_get(void **data, const char *key,
+                                             apr_socket_t *sock)
+{
+    sock_userdata_t *cur = sock->userdata;
+
+    *data = NULL;
+
+    while (cur) {
+        if (!strcmp(cur->key, key)) {
+            *data = cur->data;
+            break;
+        }
+        cur = cur->next;
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_socket_data_set(apr_socket_t *sock, void *data,
+                                             const char *key,
+                                             apr_status_t (*cleanup)(void *))
+{
+    sock_userdata_t *new = apr_palloc(sock->pool, sizeof(sock_userdata_t));
+
+    new->key = apr_pstrdup(sock->pool, key);
+    new->data = data;
+    new->next = sock->userdata;
+    sock->userdata = new;
+
+    if (cleanup) {
+        apr_pool_cleanup_register(sock->pool, data, cleanup, cleanup);
+    }
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_sock_get(apr_os_sock_t *thesock,
+                                          apr_socket_t *sock)
+{
+    *thesock = sock->socketdes;
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_sock_make(apr_socket_t **apr_sock,
+                                           apr_os_sock_info_t *os_sock_info,
+                                           apr_pool_t *cont)
+{
+    alloc_socket(apr_sock, cont);
+    set_socket_vars(*apr_sock, os_sock_info->family, os_sock_info->type, os_sock_info->protocol);
+    (*apr_sock)->timeout = -1;
+    (*apr_sock)->disconnected = 0;
+    (*apr_sock)->socketdes = *os_sock_info->os_sock;
+    if (os_sock_info->local) {
+        memcpy(&(*apr_sock)->local_addr->sa.sin, 
+               os_sock_info->local, 
+               (*apr_sock)->local_addr->salen);
+        (*apr_sock)->local_addr->pool = cont;
+        /* XXX IPv6 - this assumes sin_port and sin6_port at same offset */
+        (*apr_sock)->local_addr->port = ntohs((*apr_sock)->local_addr->sa.sin.sin_port);
+    }
+    else {
+        (*apr_sock)->local_port_unknown = (*apr_sock)->local_interface_unknown = 1;
+    }
+    if (os_sock_info->remote) {
+        memcpy(&(*apr_sock)->remote_addr->sa.sin, 
+               os_sock_info->remote,
+               (*apr_sock)->remote_addr->salen);
+        (*apr_sock)->remote_addr->pool = cont;
+        /* XXX IPv6 - this assumes sin_port and sin6_port at same offset */
+        (*apr_sock)->remote_addr->port = ntohs((*apr_sock)->remote_addr->sa.sin.sin_port);
+        (*apr_sock)->remote_addr_unknown = 0;
+    }
+        
+    apr_pool_cleanup_register((*apr_sock)->pool, (void *)(*apr_sock), 
+                        socket_cleanup, apr_pool_cleanup_null);
+
+    return APR_SUCCESS;
+}
+
+APR_DECLARE(apr_status_t) apr_os_sock_put(apr_socket_t **sock,
+                                          apr_os_sock_t *thesock,
+                                          apr_pool_t *cont)
+{
+    if ((*sock) == NULL) {
+        alloc_socket(sock, cont);
+        /* XXX figure out the actual socket type here */
+        /* *or* just decide that apr_os_sock_put() has to be told the family and type */
+        set_socket_vars(*sock, AF_INET, SOCK_STREAM, 0);
+        (*sock)->timeout = -1;
+        (*sock)->disconnected = 0;
+    }
+    (*sock)->local_port_unknown = (*sock)->local_interface_unknown = 1;
+    (*sock)->remote_addr_unknown = 1;
+    (*sock)->socketdes = *thesock;
+    return APR_SUCCESS;
+}
+
+
+/* Sockets cannot be inherited through the standard sockets
+ * inheritence.  WSADuplicateSocket must be used.
+ * This is not trivial to implement.
+ */
+
+APR_DECLARE(apr_status_t) apr_socket_inherit_set(apr_socket_t *socket)    
+{    
+    return APR_ENOTIMPL;
+}    
+
+APR_DECLARE(apr_status_t) apr_socket_inherit_unset(apr_socket_t *socket)    
+{    
+    return APR_ENOTIMPL;
+}    
+
+APR_POOL_IMPLEMENT_ACCESSOR(socket);
diff --git a/network_io/win32/sockopt.c b/network_io/win32/sockopt.c
new file mode 100644
index 0000000..463eeeb
--- /dev/null
+++ b/network_io/win32/sockopt.c
@@ -0,0 +1,302 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_arch_misc.h" /* apr_os_level */
+#include "apr_network_io.h"
+#include "apr_general.h"
+#include "apr_strings.h"
+#include <string.h>
+
+/* IPV6_V6ONLY is missing from pre-Windows 2008 SDK as well as MinGW
+ * (at least up through 1.0.16).
+ * Runtime support is a separate issue.
+ */
+#ifndef IPV6_V6ONLY
+#define IPV6_V6ONLY 27
+#endif
+
+static apr_status_t soblock(SOCKET sd)
+{
+    u_long zero = 0;
+
+    if (ioctlsocket(sd, FIONBIO, &zero) == SOCKET_ERROR) {
+        return apr_get_netos_error();
+    }
+    return APR_SUCCESS;
+}
+
+static apr_status_t sononblock(SOCKET sd)
+{
+    u_long one = 1;
+
+    if (ioctlsocket(sd, FIONBIO, &one) == SOCKET_ERROR) {
+        return apr_get_netos_error();
+    }
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_socket_timeout_set(apr_socket_t *sock, apr_interval_time_t t)
+{
+    apr_status_t stat;
+
+    if (t == 0) {
+        /* Set the socket non-blocking if it was previously blocking */
+        if (sock->timeout != 0) {
+            if ((stat = sononblock(sock->socketdes)) != APR_SUCCESS)
+                return stat;
+        }
+    }
+    else if (t > 0) {
+        /* Set the socket to blocking if it was previously non-blocking */
+        if (sock->timeout == 0 || apr_is_option_set(sock, APR_SO_NONBLOCK)) {
+            if ((stat = soblock(sock->socketdes)) != APR_SUCCESS)
+                return stat;
+            apr_set_option(sock, APR_SO_NONBLOCK, 0);
+        }
+        /* Reset socket timeouts if the new timeout differs from the old timeout */
+        if (sock->timeout != t) 
+        {
+            /* Win32 timeouts are in msec, represented as int */
+            sock->timeout_ms = (int)apr_time_as_msec(t);
+            setsockopt(sock->socketdes, SOL_SOCKET, SO_RCVTIMEO, 
+                       (char *) &sock->timeout_ms, 
+                       sizeof(sock->timeout_ms));
+            setsockopt(sock->socketdes, SOL_SOCKET, SO_SNDTIMEO, 
+                       (char *) &sock->timeout_ms, 
+                       sizeof(sock->timeout_ms));
+        }
+    }
+    else if (t < 0) {
+        int zero = 0;
+        /* Set the socket to blocking with infinite timeouts */
+        if ((stat = soblock(sock->socketdes)) != APR_SUCCESS)
+            return stat;
+        setsockopt(sock->socketdes, SOL_SOCKET, SO_RCVTIMEO, 
+                   (char *) &zero, sizeof(zero));
+        setsockopt(sock->socketdes, SOL_SOCKET, SO_SNDTIMEO, 
+                   (char *) &zero, sizeof(zero));
+    }
+    sock->timeout = t;
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_socket_opt_set(apr_socket_t *sock,
+                                             apr_int32_t opt, apr_int32_t on)
+{
+    int one;
+    apr_status_t stat;
+
+    one = on ? 1 : 0;
+
+    switch (opt) {
+    case APR_SO_KEEPALIVE:
+        if (on != apr_is_option_set(sock, APR_SO_KEEPALIVE)) {
+            if (setsockopt(sock->socketdes, SOL_SOCKET, SO_KEEPALIVE, 
+                           (void *)&one, sizeof(int)) == -1) {
+                return apr_get_netos_error();
+            }
+            apr_set_option(sock, APR_SO_KEEPALIVE, on);
+        }
+        break;
+    case APR_SO_DEBUG:
+        if (on != apr_is_option_set(sock, APR_SO_DEBUG)) {
+            if (setsockopt(sock->socketdes, SOL_SOCKET, SO_DEBUG, 
+                           (void *)&one, sizeof(int)) == -1) {
+                return apr_get_netos_error();
+            }
+            apr_set_option(sock, APR_SO_DEBUG, on);
+        }
+        break;
+    case APR_SO_SNDBUF:
+        if (setsockopt(sock->socketdes, SOL_SOCKET, SO_SNDBUF,
+                       (void *)&on, sizeof(int)) == -1) {
+            return apr_get_netos_error();
+        }
+        break;
+    case APR_SO_RCVBUF:
+        if (setsockopt(sock->socketdes, SOL_SOCKET, SO_RCVBUF,
+                       (void *)&on, sizeof(int)) == -1) {
+            return apr_get_netos_error();
+        }
+        break;
+    case APR_SO_BROADCAST:
+        if (on != apr_is_option_set(sock, APR_SO_BROADCAST)) {
+           if (setsockopt(sock->socketdes, SOL_SOCKET, SO_BROADCAST, 
+                           (void *)&one, sizeof(int)) == -1) {
+                return apr_get_netos_error();
+            }
+            apr_set_option(sock, APR_SO_BROADCAST, on);
+        }
+        break;
+    case APR_SO_REUSEADDR:
+        if (on != apr_is_option_set(sock, APR_SO_REUSEADDR)) {
+            if (setsockopt(sock->socketdes, SOL_SOCKET, SO_REUSEADDR, 
+                           (void *)&one, sizeof(int)) == -1) {
+                return apr_get_netos_error();
+            }
+            apr_set_option(sock, APR_SO_REUSEADDR, on);
+        }
+        break;
+    case APR_SO_NONBLOCK:
+        if (apr_is_option_set(sock, APR_SO_NONBLOCK) != on) {
+            if (on) {
+                if ((stat = sononblock(sock->socketdes)) != APR_SUCCESS) 
+                    return stat;
+            }
+            else {
+                if ((stat = soblock(sock->socketdes)) != APR_SUCCESS)
+                    return stat;
+            }
+            apr_set_option(sock, APR_SO_NONBLOCK, on);
+        }
+        break;
+    case APR_SO_LINGER:
+    {
+        if (apr_is_option_set(sock, APR_SO_LINGER) != on) {
+            struct linger li;
+            li.l_onoff = on;
+            li.l_linger = APR_MAX_SECS_TO_LINGER;
+            if (setsockopt(sock->socketdes, SOL_SOCKET, SO_LINGER, 
+                           (char *) &li, sizeof(struct linger)) == -1) {
+                return apr_get_netos_error();
+            }
+            apr_set_option(sock, APR_SO_LINGER, on);
+        }
+        break;
+    }
+    case APR_TCP_DEFER_ACCEPT:
+#if defined(TCP_DEFER_ACCEPT)
+        if (apr_is_option_set(sock, APR_TCP_DEFER_ACCEPT) != on) {
+            int optlevel = IPPROTO_TCP;
+            int optname = TCP_DEFER_ACCEPT;
+
+            if (setsockopt(sock->socketdes, optlevel, optname, 
+                           (void *)&on, sizeof(int)) == -1) {
+                return apr_get_netos_error();
+            }
+            apr_set_option(sock, APR_TCP_DEFER_ACCEPT, on);
+        }
+#else
+        return APR_ENOTIMPL;
+#endif
+    case APR_TCP_NODELAY:
+        if (apr_is_option_set(sock, APR_TCP_NODELAY) != on) {
+            int optlevel = IPPROTO_TCP;
+            int optname = TCP_NODELAY;
+
+#if APR_HAVE_SCTP
+            if (sock->protocol == IPPROTO_SCTP) {
+                optlevel = IPPROTO_SCTP;
+                optname = SCTP_NODELAY;
+            }
+#endif
+            if (setsockopt(sock->socketdes, optlevel, optname,
+                           (void *)&on, sizeof(int)) == -1) {
+                return apr_get_netos_error();
+            }
+            apr_set_option(sock, APR_TCP_NODELAY, on);
+        }
+        break;
+    case APR_IPV6_V6ONLY:
+#if APR_HAVE_IPV6
+        if (apr_os_level < APR_WIN_VISTA && 
+            sock->local_addr->family == AF_INET6) {
+            /* apr_set_option() called at socket creation */
+            if (on) {
+                return APR_SUCCESS;
+            }
+            else {
+                return APR_ENOTIMPL;
+            }
+        }
+        /* we don't know the initial setting of this option,
+         * so don't check sock->options since that optimization
+         * won't work
+         */
+        if (setsockopt(sock->socketdes, IPPROTO_IPV6, IPV6_V6ONLY,
+                       (void *)&on, sizeof(int)) == -1) {
+            return apr_get_netos_error();
+        }
+        apr_set_option(sock, APR_IPV6_V6ONLY, on);
+#else
+        return APR_ENOTIMPL;
+#endif
+        break;
+    default:
+        return APR_EINVAL;
+        break;
+    }
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_socket_timeout_get(apr_socket_t *sock, apr_interval_time_t *t)
+{
+    *t = sock->timeout;
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_socket_opt_get(apr_socket_t *sock,
+                                             apr_int32_t opt, apr_int32_t *on)
+{
+    switch (opt) {
+    case APR_SO_DISCONNECTED:
+        *on = sock->disconnected;
+        break;
+    case APR_SO_KEEPALIVE:
+    case APR_SO_DEBUG:
+    case APR_SO_REUSEADDR:
+    case APR_SO_NONBLOCK:
+    case APR_SO_LINGER:
+    default:
+        *on = apr_is_option_set(sock, opt);
+        break;
+    }
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_socket_atmark(apr_socket_t *sock, int *atmark)
+{
+    u_long oobmark;
+
+    if (ioctlsocket(sock->socketdes, SIOCATMARK, (void*) &oobmark) < 0)
+        return apr_get_netos_error();
+
+    *atmark = (oobmark != 0);
+
+    return APR_SUCCESS;
+}
+
+
+APR_DECLARE(apr_status_t) apr_gethostname(char *buf, int len,
+                                          apr_pool_t *cont)
+{
+    if (gethostname(buf, len) == -1) {
+        buf[0] = '\0';
+        return apr_get_netos_error();
+    }
+    else if (!memchr(buf, '\0', len)) { /* buffer too small */
+        buf[0] = '\0';
+        return APR_ENAMETOOLONG;
+    }
+    return APR_SUCCESS;
+}
+