| /* 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_FROM_OS_ERROR(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; |
| int oprotocol = protocol; |
| |
| if (family == AF_UNSPEC) { |
| #if APR_HAVE_IPV6 |
| family = AF_INET6; |
| #else |
| family = AF_INET; |
| #endif |
| } |
| |
| if (family == APR_UNIX) { |
| protocol = 0; |
| } |
| |
| 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_FROM_OS_ERROR(sock_errno()); |
| } |
| set_socket_vars(*new, family, type, oprotocol); |
| |
| (*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_FROM_OS_ERROR(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_FROM_OS_ERROR(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_FROM_OS_ERROR(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_FROM_OS_ERROR(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_FROM_OS_ERROR(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) |
| |