| /*************************************************************************** |
| * _ _ ____ _ |
| * Project ___| | | | _ \| | |
| * / __| | | | |_) | | |
| * | (__| |_| | _ <| |___ |
| * \___|\___/|_| \_\_____| |
| * |
| * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al. |
| * |
| * This software is licensed as described in the file COPYING, which |
| * you should have received as part of this distribution. The terms |
| * are also available at https://curl.se/docs/copyright.html. |
| * |
| * You may opt to use, copy, modify, merge, publish, distribute and/or sell |
| * copies of the Software, and permit persons to whom the Software is |
| * furnished to do so, under the terms of the COPYING file. |
| * |
| * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY |
| * KIND, either express or implied. |
| * |
| * SPDX-License-Identifier: curl |
| * |
| ***************************************************************************/ |
| #include "curl_setup.h" |
| |
| #include "socketpair.h" |
| #include "urldata.h" |
| #include "rand.h" |
| #include "curlx/nonblock.h" |
| |
| #ifndef CURL_DISABLE_SOCKETPAIR |
| |
| /* choose implementation */ |
| #ifdef USE_EVENTFD |
| |
| #include <sys/eventfd.h> |
| |
| static int wakeup_eventfd(curl_socket_t socks[2], bool nonblocking) |
| { |
| int efd = eventfd(0, nonblocking ? EFD_CLOEXEC | EFD_NONBLOCK : EFD_CLOEXEC); |
| if(efd == -1) { |
| socks[0] = socks[1] = CURL_SOCKET_BAD; |
| return -1; |
| } |
| socks[0] = socks[1] = efd; |
| return 0; |
| } |
| |
| #elif defined(HAVE_PIPE) |
| |
| #ifdef HAVE_FCNTL |
| #include <fcntl.h> |
| #endif |
| |
| static int wakeup_pipe(curl_socket_t socks[2], bool nonblocking) |
| { |
| #ifdef HAVE_PIPE2 |
| int flags = nonblocking ? O_NONBLOCK | O_CLOEXEC : O_CLOEXEC; |
| if(pipe2(socks, flags)) |
| return -1; |
| #else |
| if(pipe(socks)) |
| return -1; |
| #ifdef HAVE_FCNTL |
| if(fcntl(socks[0], F_SETFD, FD_CLOEXEC) || |
| fcntl(socks[1], F_SETFD, FD_CLOEXEC)) { |
| sclose(socks[0]); |
| sclose(socks[1]); |
| socks[0] = socks[1] = CURL_SOCKET_BAD; |
| return -1; |
| } |
| #endif |
| if(nonblocking) { |
| if(curlx_nonblock(socks[0], TRUE) < 0 || |
| curlx_nonblock(socks[1], TRUE) < 0) { |
| sclose(socks[0]); |
| sclose(socks[1]); |
| socks[0] = socks[1] = CURL_SOCKET_BAD; |
| return -1; |
| } |
| } |
| #endif |
| |
| return 0; |
| } |
| |
| #elif defined(HAVE_SOCKETPAIR) /* !USE_EVENTFD && !HAVE_PIPE */ |
| |
| #ifndef USE_UNIX_SOCKETS |
| #error "unsupported Unix domain and socketpair build combo" |
| #endif |
| |
| static int wakeup_socketpair(curl_socket_t socks[2], bool nonblocking) |
| { |
| int type = SOCK_STREAM; |
| #ifdef SOCK_CLOEXEC |
| type |= SOCK_CLOEXEC; |
| #endif |
| #ifdef SOCK_NONBLOCK |
| if(nonblocking) |
| type |= SOCK_NONBLOCK; |
| #endif |
| |
| if(CURL_SOCKETPAIR(AF_UNIX, type, 0, socks)) |
| return -1; |
| #ifndef SOCK_NONBLOCK |
| if(nonblocking) { |
| if(curlx_nonblock(socks[0], TRUE) < 0 || |
| curlx_nonblock(socks[1], TRUE) < 0) { |
| sclose(socks[0]); |
| sclose(socks[1]); |
| socks[0] = socks[1] = CURL_SOCKET_BAD; |
| return -1; |
| } |
| } |
| #endif |
| #ifdef USE_SO_NOSIGPIPE |
| if(Curl_sock_nosigpipe(socks[1]) < 0) { |
| sclose(socks[0]); |
| sclose(socks[1]); |
| socks[0] = socks[1] = CURL_SOCKET_BAD; |
| return -1; |
| } |
| #endif /* USE_SO_NOSIGPIPE */ |
| |
| return 0; |
| } |
| |
| #else /* !USE_EVENTFD && !HAVE_PIPE && !HAVE_SOCKETPAIR */ |
| |
| #ifdef HAVE_NETDB_H |
| #include <netdb.h> |
| #endif |
| #ifdef HAVE_NETINET_IN_H |
| #include <netinet/in.h> /* for IPPROTO_TCP */ |
| #endif |
| #ifdef HAVE_ARPA_INET_H |
| #include <arpa/inet.h> |
| #endif |
| |
| #ifndef INADDR_LOOPBACK |
| #define INADDR_LOOPBACK 0x7f000001 |
| #endif |
| |
| #include "select.h" /* for Curl_poll */ |
| |
| static int wakeup_inet(curl_socket_t socks[2], bool nonblocking) |
| { |
| union { |
| struct sockaddr_in inaddr; |
| struct sockaddr addr; |
| } a; |
| curl_socket_t listener; |
| curl_socklen_t addrlen = sizeof(a.inaddr); |
| int reuse = 1; |
| struct pollfd pfd[1]; |
| |
| listener = CURL_SOCKET(AF_INET, SOCK_STREAM, IPPROTO_TCP); |
| if(listener == CURL_SOCKET_BAD) |
| return -1; |
| |
| memset(&a, 0, sizeof(a)); |
| a.inaddr.sin_family = AF_INET; |
| a.inaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); |
| a.inaddr.sin_port = 0; |
| |
| socks[0] = socks[1] = CURL_SOCKET_BAD; |
| |
| #if defined(_WIN32) || defined(__CYGWIN__) |
| /* do not set SO_REUSEADDR on Windows */ |
| (void)reuse; |
| #ifdef SO_EXCLUSIVEADDRUSE |
| { |
| int exclusive = 1; |
| if(setsockopt(listener, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, |
| (char *)&exclusive, (curl_socklen_t)sizeof(exclusive)) == -1) |
| goto error; |
| } |
| #endif |
| #else |
| if(setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, |
| (char *)&reuse, (curl_socklen_t)sizeof(reuse)) == -1) |
| goto error; |
| #endif |
| if(bind(listener, &a.addr, sizeof(a.inaddr)) == -1) |
| goto error; |
| if(getsockname(listener, &a.addr, &addrlen) == -1 || |
| addrlen < (int)sizeof(a.inaddr)) |
| goto error; |
| if(listen(listener, 1) == -1) |
| goto error; |
| socks[0] = CURL_SOCKET(AF_INET, SOCK_STREAM, 0); |
| if(socks[0] == CURL_SOCKET_BAD) |
| goto error; |
| if(connect(socks[0], &a.addr, sizeof(a.inaddr)) == -1) |
| goto error; |
| |
| /* use non-blocking accept to make sure we do not block forever */ |
| if(curlx_nonblock(listener, TRUE) < 0) |
| goto error; |
| pfd[0].fd = listener; |
| pfd[0].events = POLLIN; |
| pfd[0].revents = 0; |
| (void)Curl_poll(pfd, 1, 1000); /* one second */ |
| socks[1] = CURL_ACCEPT(listener, NULL, NULL); |
| if(socks[1] == CURL_SOCKET_BAD) |
| goto error; |
| else { |
| struct curltime start = curlx_now(); |
| char rnd[9]; |
| char check[sizeof(rnd)]; |
| char *p = &check[0]; |
| size_t s = sizeof(check); |
| |
| if(Curl_rand(NULL, (unsigned char *)rnd, sizeof(rnd))) |
| goto error; |
| |
| /* write data to the socket */ |
| swrite(socks[0], rnd, sizeof(rnd)); |
| /* verify that we read the correct data */ |
| do { |
| ssize_t nread; |
| |
| pfd[0].fd = socks[1]; |
| pfd[0].events = POLLIN; |
| pfd[0].revents = 0; |
| (void)Curl_poll(pfd, 1, 1000); /* one second */ |
| |
| nread = sread(socks[1], p, s); |
| if(nread == -1) { |
| int sockerr = SOCKERRNO; |
| /* Do not block forever */ |
| if(curlx_timediff_ms(curlx_now(), start) > (60 * 1000)) |
| goto error; |
| if( |
| #ifdef USE_WINSOCK |
| /* This is how Windows does it */ |
| (SOCKEWOULDBLOCK == sockerr) |
| #else |
| /* errno may be EWOULDBLOCK or on some systems EAGAIN when it |
| returned due to its inability to send off data without |
| blocking. We therefore treat both error codes the same here */ |
| (SOCKEWOULDBLOCK == sockerr) || (EAGAIN == sockerr) || |
| (SOCKEINTR == sockerr) || (SOCKEINPROGRESS == sockerr) |
| #endif |
| ) { |
| continue; |
| } |
| goto error; |
| } |
| s -= nread; |
| if(s) { |
| p += nread; |
| continue; |
| } |
| if(memcmp(rnd, check, sizeof(check))) |
| goto error; |
| break; |
| } while(1); |
| } |
| |
| if(nonblocking) |
| if(curlx_nonblock(socks[0], TRUE) < 0 || |
| curlx_nonblock(socks[1], TRUE) < 0) |
| goto error; |
| #ifdef USE_SO_NOSIGPIPE |
| if(Curl_sock_nosigpipe(socks[1]) < 0) |
| goto error; |
| #endif |
| sclose(listener); |
| return 0; |
| |
| error: |
| sclose(listener); |
| sclose(socks[0]); |
| sclose(socks[1]); |
| socks[0] = socks[1] = CURL_SOCKET_BAD; |
| return -1; |
| } |
| |
| #endif /* choose implementation */ |
| |
| int Curl_wakeup_init(curl_socket_t socks[2], bool nonblocking) |
| { |
| #ifdef USE_EVENTFD |
| return wakeup_eventfd(socks, nonblocking); |
| #elif defined(HAVE_PIPE) |
| return wakeup_pipe(socks, nonblocking); |
| #elif defined(HAVE_SOCKETPAIR) |
| return wakeup_socketpair(socks, nonblocking); |
| #else |
| return wakeup_inet(socks, nonblocking); |
| #endif |
| } |
| |
| #if defined(USE_EVENTFD) || defined(HAVE_PIPE) |
| |
| #define wakeup_write write |
| #define wakeup_read read |
| #define wakeup_close close |
| |
| #else /* !USE_EVENTFD && !HAVE_PIPE */ |
| |
| #define wakeup_write swrite |
| #define wakeup_read sread |
| #define wakeup_close sclose |
| |
| #endif |
| |
| int Curl_wakeup_signal(curl_socket_t socks[2]) |
| { |
| int err = 0; |
| #ifdef USE_EVENTFD |
| const uint64_t buf[1] = { 1 }; |
| #else |
| const char buf[1] = { 1 }; |
| #endif |
| |
| while(1) { |
| err = 0; |
| if(wakeup_write(socks[1], buf, sizeof(buf)) < 0) { |
| err = SOCKERRNO; |
| #ifdef USE_WINSOCK |
| if(err == SOCKEWOULDBLOCK) |
| err = 0; /* wakeup is already ongoing */ |
| #else |
| if(SOCKEINTR == err) |
| continue; |
| if((err == SOCKEWOULDBLOCK) || (err == EAGAIN)) |
| err = 0; /* wakeup is already ongoing */ |
| #endif |
| } |
| break; |
| } |
| return err; |
| } |
| |
| CURLcode Curl_wakeup_consume(curl_socket_t socks[2], bool all) |
| { |
| char buf[64]; |
| ssize_t rc; |
| CURLcode result = CURLE_OK; |
| |
| do { |
| rc = wakeup_read(socks[0], buf, sizeof(buf)); |
| if(!rc) |
| break; |
| else if(rc < 0) { |
| #ifdef USE_WINSOCK |
| if(SOCKERRNO == SOCKEWOULDBLOCK) |
| break; |
| #else |
| if(SOCKEINTR == SOCKERRNO) |
| continue; |
| if((SOCKERRNO == SOCKEWOULDBLOCK) || (SOCKERRNO == EAGAIN)) |
| break; |
| #endif |
| result = CURLE_READ_ERROR; |
| break; |
| } |
| } while(all); |
| return result; |
| } |
| |
| void Curl_wakeup_destroy(curl_socket_t socks[2]) |
| { |
| #ifndef USE_EVENTFD |
| if(socks[1] != CURL_SOCKET_BAD) |
| wakeup_close(socks[1]); |
| #endif |
| if(socks[0] != CURL_SOCKET_BAD) |
| wakeup_close(socks[0]); |
| socks[0] = socks[1] = CURL_SOCKET_BAD; |
| } |
| |
| #endif /* !CURL_DISABLE_SOCKETPAIR */ |
