+static void do_outgoing_pipe(connection_t *c, const char *command) {
+#ifndef HAVE_MINGW
+ int fd[2];
+
+ if(socketpair(AF_UNIX, SOCK_STREAM, 0, fd)) {
+ logger(DEBUG_ALWAYS, LOG_ERR, "Could not create socketpair: %s", sockstrerror(sockerrno));
+ return;
+ }
+
+ if(fork()) {
+ c->socket = fd[0];
+ close(fd[1]);
+ logger(DEBUG_CONNECTIONS, LOG_DEBUG, "Using proxy %s", command);
+ return;
+ }
+
+ close(0);
+ close(1);
+ close(fd[0]);
+ dup2(fd[1], 0);
+ dup2(fd[1], 1);
+ close(fd[1]);
+
+ // Other filedescriptors should be closed automatically by CLOEXEC
+
+ char *host = NULL;
+ char *port = NULL;
+
+ sockaddr2str(&c->address, &host, &port);
+ setenv("REMOTEADDRESS", host, true);
+ setenv("REMOTEPORT", port, true);
+ setenv("NODE", c->name, true);
+ setenv("NAME", myself->name, true);
+
+ if(netname) {
+ setenv("NETNAME", netname, true);
+ }
+
+ int result = system(command);
+
+ if(result < 0) {
+ logger(DEBUG_ALWAYS, LOG_ERR, "Could not execute %s: %s", command, strerror(errno));
+ } else if(result) {
+ logger(DEBUG_ALWAYS, LOG_ERR, "%s exited with non-zero status %d", command, result);
+ }
+
+ exit(result);
+#else
+ (void)c;
+ (void)command;
+ logger(DEBUG_ALWAYS, LOG_ERR, "Proxy type exec not supported on this platform!");
+ return;
+#endif
+}
+
+static void handle_meta_write(connection_t *c) {
+ if(c->outbuf.len <= c->outbuf.offset) {
+ return;
+ }
+
+ ssize_t outlen = send(c->socket, c->outbuf.data + c->outbuf.offset, c->outbuf.len - c->outbuf.offset, 0);
+
+ if(outlen <= 0) {
+ if(!sockerrno || sockerrno == EPIPE) {
+ logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Connection closed by %s (%s)", c->name, c->hostname);
+ } else if(sockwouldblock(sockerrno)) {
+ logger(DEBUG_META, LOG_DEBUG, "Sending %d bytes to %s (%s) would block", c->outbuf.len - c->outbuf.offset, c->name, c->hostname);
+ return;
+ } else {
+ logger(DEBUG_CONNECTIONS, LOG_ERR, "Could not send %d bytes of data to %s (%s): %s", c->outbuf.len - c->outbuf.offset, c->name, c->hostname, sockstrerror(sockerrno));
+ }
+
+ terminate_connection(c, c->edge);
+ return;
+ }
+
+ buffer_read(&c->outbuf, outlen);
+
+ if(!c->outbuf.len) {
+ io_set(&c->io, IO_READ);
+ }
+}
+
+static void handle_meta_io(void *data, int flags) {
+ connection_t *c = data;
+
+ if(c->status.connecting) {
+ /*
+ The event loop does not protect against spurious events. Verify that we are actually connected
+ by issuing an empty send() call.
+
+ Note that the behavior of send() on potentially unconnected sockets differ between platforms:
+ +------------+-----------+-------------+-----------+
+ | Event | POSIX | Linux | Windows |
+ +------------+-----------+-------------+-----------+
+ | Spurious | ENOTCONN | EWOULDBLOCK | ENOTCONN |
+ | Failed | ENOTCONN | (cause) | ENOTCONN |
+ | Successful | (success) | (success) | (success) |
+ +------------+-----------+-------------+-----------+
+ */
+ if(send(c->socket, NULL, 0, 0) != 0) {
+ if(sockwouldblock(sockerrno)) {
+ return;
+ }
+
+ int socket_error;
+
+ if(!socknotconn(sockerrno)) {
+ socket_error = sockerrno;
+ } else {
+ socklen_t len = sizeof(socket_error);
+ getsockopt(c->socket, SOL_SOCKET, SO_ERROR, (void *)&socket_error, &len);
+ }
+
+ if(socket_error) {
+ logger(DEBUG_CONNECTIONS, LOG_DEBUG, "Error while connecting to %s (%s): %s", c->name, c->hostname, sockstrerror(socket_error));
+ terminate_connection(c, false);
+ }
+
+ return;
+ }
+
+ c->status.connecting = false;
+ finish_connecting(c);
+ }
+
+ if(flags & IO_WRITE) {
+ handle_meta_write(c);
+ } else {
+ handle_meta_connection_data(c);
+ }
+}
+
+bool do_outgoing_connection(outgoing_t *outgoing) {
+ const sockaddr_t *sa;
+ struct addrinfo *proxyai = NULL;
+ int result;
+
+begin:
+ sa = get_recent_address(outgoing->node->address_cache);
+
+ if(!sa) {
+ logger(DEBUG_CONNECTIONS, LOG_ERR, "Could not set up a meta connection to %s", outgoing->node->name);
+ retry_outgoing(outgoing);
+ return false;
+ }
+
+ connection_t *c = new_connection();
+ c->outgoing = outgoing;
+ memcpy(&c->address, sa, SALEN(sa->sa));
+ c->hostname = sockaddr2hostname(&c->address);
+
+ logger(DEBUG_CONNECTIONS, LOG_INFO, "Trying to connect to %s (%s)", outgoing->node->name, c->hostname);
+
+ if(!proxytype) {
+ c->socket = socket(c->address.sa.sa_family, SOCK_STREAM, IPPROTO_TCP);
+ configure_tcp(c);
+ } else if(proxytype == PROXY_EXEC) {
+ do_outgoing_pipe(c, proxyhost);
+ } else {
+ proxyai = str2addrinfo(proxyhost, proxyport, SOCK_STREAM);
+
+ if(!proxyai) {
+ free_connection(c);
+ goto begin;
+ }
+
+ logger(DEBUG_CONNECTIONS, LOG_INFO, "Using proxy at %s port %s", proxyhost, proxyport);
+ c->socket = socket(proxyai->ai_family, SOCK_STREAM, IPPROTO_TCP);
+ configure_tcp(c);
+ }
+
+ if(c->socket == -1) {
+ logger(DEBUG_CONNECTIONS, LOG_ERR, "Creating socket for %s failed: %s", c->hostname, sockstrerror(sockerrno));
+ free_connection(c);
+ goto begin;
+ }
+
+#ifdef FD_CLOEXEC
+ fcntl(c->socket, F_SETFD, FD_CLOEXEC);
+#endif
+
+ if(proxytype != PROXY_EXEC) {
+#if defined(IPV6_V6ONLY)
+ int option = 1;
+
+ if(c->address.sa.sa_family == AF_INET6) {
+ setsockopt(c->socket, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&option, sizeof(option));
+ }
+
+#endif
+
+ bind_to_interface(c->socket);
+ bind_to_address(c);
+ }
+
+ /* Connect */
+
+ if(!proxytype) {
+ result = connect(c->socket, &c->address.sa, SALEN(c->address.sa));
+ } else if(proxytype == PROXY_EXEC) {
+ result = 0;
+ } else {
+ if(!proxyai) {
+ abort();
+ }
+
+ result = connect(c->socket, proxyai->ai_addr, proxyai->ai_addrlen);
+ freeaddrinfo(proxyai);
+ }
+
+ if(result == -1 && !sockinprogress(sockerrno)) {
+ logger(DEBUG_CONNECTIONS, LOG_ERR, "Could not connect to %s (%s): %s", outgoing->node->name, c->hostname, sockstrerror(sockerrno));
+ free_connection(c);
+
+ goto begin;
+ }
+
+ /* Now that there is a working socket, fill in the rest and register this connection. */
+
+ c->last_ping_time = time(NULL);
+ c->status.connecting = true;
+ c->name = xstrdup(outgoing->node->name);
+#ifndef DISABLE_LEGACY
+ c->outcipher = myself->connection->outcipher;
+ c->outdigest = myself->connection->outdigest;
+#endif
+ c->outmaclength = myself->connection->outmaclength;
+ c->outcompression = myself->connection->outcompression;
+ c->last_ping_time = now.tv_sec;
+
+ connection_add(c);
+
+ io_add(&c->io, handle_meta_io, c, c->socket, IO_READ | IO_WRITE);
+
+ return true;
+}
+
+void setup_outgoing_connection(outgoing_t *outgoing, bool verbose) {
+ (void)verbose;
+ timeout_del(&outgoing->ev);
+
+ node_t *n = outgoing->node;
+
+ if(!n->address_cache) {
+ n->address_cache = open_address_cache(n);
+ }
+
+ if(n->connection) {
+ logger(DEBUG_CONNECTIONS, LOG_INFO, "Already connected to %s", n->name);
+
+ if(!n->connection->outgoing) {
+ n->connection->outgoing = outgoing;
+ return;
+ } else {
+ goto remove;
+ }
+ }
+
+ do_outgoing_connection(outgoing);
+ return;
+
+remove:
+ list_delete(outgoing_list, outgoing);