mmr/Livox-SDK
Archived
1
0
Fork 0
Code Issues 105 Pull Requests 11 Actions Packages Projects Releases 9 Wiki Activity

feat:replace boost library with C++11 std library

Browse Source
This commit is contained in:
Livox-SDK
2020-04-01 20:53:55 +08:00
parent 6d06233944
commit d3258bbd97
1936 changed files with 241862 additions and 60153 deletions
Download Patch File Download Diff File Expand all files Collapse all files
third_party/apr/apr-1.6.5/network_io/unix/inet_ntop.c
Vendored
+243
View File
@@ -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
third_party/apr/apr-1.6.5/network_io/unix/inet_pton.c
Vendored
+240
View File
@@ -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
third_party/apr/apr-1.6.5/network_io/unix/multicast.c
Vendored
+313
View File
@@ -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
}
third_party/apr/apr-1.6.5/network_io/unix/sendrecv.c
Vendored
+1110
View File
File diff suppressed because it is too large Load Diff
third_party/apr/apr-1.6.5/network_io/unix/sockaddr.c
Vendored
+1185
View File
File diff suppressed because it is too large Load Diff
third_party/apr/apr-1.6.5/network_io/unix/socket_util.c
Vendored
+75
View File
@@ -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;
}
third_party/apr/apr-1.6.5/network_io/unix/sockets.c
Vendored
+572
View File
@@ -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)
third_party/apr/apr-1.6.5/network_io/unix/sockopt.c
Vendored
+465
View File
@@ -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
}