feat:replace boost library with C++11 std library
This commit is contained in:
Livox-SDK
@@ -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 */
|
||||
@@ -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"
|
||||
@@ -0,0 +1 @@
|
||||
#include "../unix/inet_ntop.c"
|
||||
@@ -0,0 +1 @@
|
||||
#include "../unix/inet_pton.c"
|
||||
+132
@@ -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;
|
||||
}
|
||||
+155
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
#include "../unix/sockaddr.c"
|
||||
@@ -0,0 +1 @@
|
||||
#include "../unix/socket_util.c"
|
||||
+317
@@ -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)
|
||||
|
||||
+144
@@ -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;
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
}
|
||||
+1110
File diff suppressed because it is too large
Load Diff
+1185
File diff suppressed because it is too large
Load Diff
@@ -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;
|
||||
}
|
||||
|
||||
+572
@@ -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)
|
||||
+465
@@ -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
|
||||
}
|
||||
@@ -0,0 +1,457 @@
|
||||
/* 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 cur_len;
|
||||
apr_int32_t nvec = 0;
|
||||
int i, j = 0;
|
||||
DWORD dwBytes = 0;
|
||||
WSABUF *pWsaBuf;
|
||||
|
||||
for (i = 0; i < in_vec; i++) {
|
||||
cur_len = vec[i].iov_len;
|
||||
nvec++;
|
||||
while (cur_len > APR_DWORD_MAX) {
|
||||
nvec++;
|
||||
cur_len -= APR_DWORD_MAX;
|
||||
}
|
||||
}
|
||||
|
||||
pWsaBuf = (nvec <= WSABUF_ON_STACK) ? _alloca(sizeof(WSABUF) * (nvec))
|
||||
: malloc(sizeof(WSABUF) * (nvec));
|
||||
if (!pWsaBuf)
|
||||
return APR_ENOMEM;
|
||||
|
||||
for (i = 0; i < in_vec; i++) {
|
||||
char * base = vec[i].iov_base;
|
||||
cur_len = vec[i].iov_len;
|
||||
|
||||
do {
|
||||
if (cur_len > APR_DWORD_MAX) {
|
||||
pWsaBuf[j].buf = base;
|
||||
pWsaBuf[j].len = APR_DWORD_MAX;
|
||||
cur_len -= APR_DWORD_MAX;
|
||||
base += APR_DWORD_MAX;
|
||||
}
|
||||
else {
|
||||
pWsaBuf[j].buf = base;
|
||||
pWsaBuf[j].len = (DWORD)cur_len;
|
||||
cur_len = 0;
|
||||
}
|
||||
j++;
|
||||
|
||||
} while (cur_len > 0);
|
||||
}
|
||||
#ifndef _WIN32_WCE
|
||||
rv = WSASend(sock->socketdes, pWsaBuf, nvec, &dwBytes, 0, NULL, NULL);
|
||||
if (rv == SOCKET_ERROR) {
|
||||
rc = apr_get_netos_error();
|
||||
}
|
||||
#else
|
||||
for (i = 0; i < nvec; 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 (nvec > 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
|
||||
|
||||
@@ -0,0 +1,538 @@
|
||||
/* 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"
|
||||
|
||||
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)
|
||||
{
|
||||
if (listen(sock->socketdes, backlog) == 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);
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user