tinc-vpn.org Git - tinc/blob - src/net_socket.c

   1 /*
   2     net_socket.c -- Handle various kinds of sockets.
   3     Copyright (C) 1998-2005 Ivo Timmermans,
   4                   2000-2017 Guus Sliepen <guus@tinc-vpn.org>
   5                   2006      Scott Lamb <slamb@slamb.org>
   6                   2009      Florian Forster <octo@verplant.org>
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation; either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License along
  19     with this program; if not, write to the Free Software Foundation, Inc.,
  20     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21 */
  22
  23 #include "system.h"
  24
  25 #include "address_cache.h"
  26 #include "conf.h"
  27 #include "connection.h"
  28 #include "control_common.h"
  29 #include "list.h"
  30 #include "logger.h"
  31 #include "meta.h"
  32 #include "names.h"
  33 #include "net.h"
  34 #include "netutl.h"
  35 #include "protocol.h"
  36 #include "utils.h"
  37 #include "xalloc.h"
  38
  39 int addressfamily = AF_UNSPEC;
  40 int maxtimeout = 900;
  41 int seconds_till_retry = 5;
  42 int udp_rcvbuf = 1024 * 1024;
  43 int udp_sndbuf = 1024 * 1024;
  44 int max_connection_burst = 10;
  45 int fwmark;
  46
  47 listen_socket_t listen_socket[MAXSOCKETS];
  48 int listen_sockets;
  49 #ifndef HAVE_MINGW
  50 io_t unix_socket;
  51 #endif
  52 list_t *outgoing_list = NULL;
  53
  54 /* Setup sockets */
  55
  56 static void configure_tcp(connection_t *c) {
  57         int option;
  58
  59 #ifdef O_NONBLOCK
  60         int flags = fcntl(c->socket, F_GETFL);
  61
  62         if(fcntl(c->socket, F_SETFL, flags | O_NONBLOCK) < 0) {
  63                 logger(DEBUG_ALWAYS, LOG_ERR, "fcntl for %s fd %d: %s", c->hostname, c->socket, strerror(errno));
  64         }
  65
  66 #elif defined(WIN32)
  67         unsigned long arg = 1;
  68
  69         if(ioctlsocket(c->socket, FIONBIO, &arg) != 0) {
  70                 logger(DEBUG_ALWAYS, LOG_ERR, "ioctlsocket for %s fd %d: %s", c->hostname, c->socket, sockstrerror(sockerrno));
  71         }
  72
  73 #endif
  74
  75 #if defined(TCP_NODELAY)
  76         option = 1;
  77         setsockopt(c->socket, IPPROTO_TCP, TCP_NODELAY, (void *)&option, sizeof(option));
  78 #endif
  79
  80 #if defined(IP_TOS) && defined(IPTOS_LOWDELAY)
  81         option = IPTOS_LOWDELAY;
  82         setsockopt(c->socket, IPPROTO_IP, IP_TOS, (void *)&option, sizeof(option));
  83 #endif
  84
  85 #if defined(IPV6_TCLASS) && defined(IPTOS_LOWDELAY)
  86         option = IPTOS_LOWDELAY;
  87         setsockopt(c->socket, IPPROTO_IPV6, IPV6_TCLASS, (void *)&option, sizeof(option));
  88 #endif
  89
  90 #if defined(SO_MARK)
  91
  92         if(fwmark) {
  93                 setsockopt(c->socket, SOL_SOCKET, SO_MARK, (void *)&fwmark, sizeof(fwmark));
  94         }
  95
  96 #endif
  97 }
  98
  99 static bool bind_to_interface(int sd) {
 100         char *iface;
 101
 102 #if defined(SOL_SOCKET) && defined(SO_BINDTODEVICE)
 103         struct ifreq ifr;
 104         int status;
 105 #endif /* defined(SOL_SOCKET) && defined(SO_BINDTODEVICE) */
 106
 107         if(!get_config_string(lookup_config(config_tree, "BindToInterface"), &iface)) {
 108                 return true;
 109         }
 110
 111 #if defined(SOL_SOCKET) && defined(SO_BINDTODEVICE)
 112         memset(&ifr, 0, sizeof(ifr));
 113         strncpy(ifr.ifr_ifrn.ifrn_name, iface, IFNAMSIZ);
 114         ifr.ifr_ifrn.ifrn_name[IFNAMSIZ - 1] = 0;
 115
 116         status = setsockopt(sd, SOL_SOCKET, SO_BINDTODEVICE, (void *)&ifr, sizeof(ifr));
 117
 118         if(status) {
 119                 logger(DEBUG_ALWAYS, LOG_ERR, "Can't bind to interface %s: %s", iface,
 120                        sockstrerror(sockerrno));
 121                 return false;
 122         }
 123
 124 #else /* if !defined(SOL_SOCKET) || !defined(SO_BINDTODEVICE) */
 125         logger(DEBUG_ALWAYS, LOG_WARNING, "%s not supported on this platform", "BindToInterface");
 126 #endif
 127
 128         return true;
 129 }
 130
 131 static bool bind_to_address(connection_t *c) {
 132         int s = -1;
 133
 134         for(int i = 0; i < listen_sockets && listen_socket[i].bindto; i++) {
 135                 if(listen_socket[i].sa.sa.sa_family != c->address.sa.sa_family) {
 136                         continue;
 137                 }
 138
 139                 if(s >= 0) {
 140                         return false;
 141                 }
 142
 143                 s = i;
 144         }
 145
 146         if(s < 0) {
 147                 return false;
 148         }
 149
 150         sockaddr_t sa = listen_socket[s].sa;
 151
 152         if(sa.sa.sa_family == AF_INET) {
 153                 sa.in.sin_port = 0;
 154         } else if(sa.sa.sa_family == AF_INET6) {
 155                 sa.in6.sin6_port = 0;
 156         }
 157
 158         if(bind(c->socket, &sa.sa, SALEN(sa.sa))) {
 159                 logger(DEBUG_CONNECTIONS, LOG_WARNING, "Can't bind outgoing socket: %s", sockstrerror(sockerrno));
 160                 return false;
 161         }
 162
 163         return true;
 164 }
 165
 166 int setup_listen_socket(const sockaddr_t *sa) {
 167         int nfd;
 168         char *addrstr;
 169         int option;
 170         char *iface;
 171
 172         nfd = socket(sa->sa.sa_family, SOCK_STREAM, IPPROTO_TCP);
 173
 174         if(nfd < 0) {
 175                 logger(DEBUG_STATUS, LOG_ERR, "Creating metasocket failed: %s", sockstrerror(sockerrno));
 176                 return -1;
 177         }
 178
 179 #ifdef FD_CLOEXEC
 180         fcntl(nfd, F_SETFD, FD_CLOEXEC);
 181 #endif
 182
 183         /* Optimize TCP settings */
 184
 185         option = 1;
 186         setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, (void *)&option, sizeof(option));
 187
 188 #if defined(IPV6_V6ONLY)
 189
 190         if(sa->sa.sa_family == AF_INET6) {
 191                 setsockopt(nfd, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&option, sizeof(option));
 192         }
 193
 194 #else
 195 #warning IPV6_V6ONLY not defined
 196 #endif
 197
 198 #if defined(SO_MARK)
 199
 200         if(fwmark) {
 201                 setsockopt(nfd, SOL_SOCKET, SO_MARK, (void *)&fwmark, sizeof(fwmark));
 202         }
 203
 204 #endif
 205
 206         if(get_config_string
 207                         (lookup_config(config_tree, "BindToInterface"), &iface)) {
 208 #if defined(SOL_SOCKET) && defined(SO_BINDTODEVICE)
 209                 struct ifreq ifr;
 210
 211                 memset(&ifr, 0, sizeof(ifr));
 212                 strncpy(ifr.ifr_ifrn.ifrn_name, iface, IFNAMSIZ);
 213
 214                 if(setsockopt(nfd, SOL_SOCKET, SO_BINDTODEVICE, (void *)&ifr, sizeof(ifr))) {
 215                         closesocket(nfd);
 216                         logger(DEBUG_ALWAYS, LOG_ERR, "Can't bind to interface %s: %s", iface,
 217                                sockstrerror(sockerrno));
 218                         return -1;
 219                 }
 220
 221 #else
 222                 logger(DEBUG_ALWAYS, LOG_WARNING, "%s not supported on this platform", "BindToInterface");
 223 #endif
 224         }
 225
 226         if(bind(nfd, &sa->sa, SALEN(sa->sa))) {
 227                 closesocket(nfd);
 228                 addrstr = sockaddr2hostname(sa);
 229                 logger(DEBUG_ALWAYS, LOG_ERR, "Can't bind to %s/tcp: %s", addrstr, sockstrerror(sockerrno));
 230                 free(addrstr);
 231                 return -1;
 232         }
 233
 234         if(listen(nfd, 3)) {
 235                 closesocket(nfd);
 236                 logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "listen", sockstrerror(sockerrno));
 237                 return -1;
 238         }
 239
 240         return nfd;
 241 }
 242
 243 int setup_vpn_in_socket(const sockaddr_t *sa) {
 244         int nfd;
 245         char *addrstr;
 246         int option;
 247
 248         nfd = socket(sa->sa.sa_family, SOCK_DGRAM, IPPROTO_UDP);
 249
 250         if(nfd < 0) {
 251                 logger(DEBUG_ALWAYS, LOG_ERR, "Creating UDP socket failed: %s", sockstrerror(sockerrno));
 252                 return -1;
 253         }
 254
 255 #ifdef FD_CLOEXEC
 256         fcntl(nfd, F_SETFD, FD_CLOEXEC);
 257 #endif
 258
 259 #ifdef O_NONBLOCK
 260         {
 261                 int flags = fcntl(nfd, F_GETFL);
 262
 263                 if(fcntl(nfd, F_SETFL, flags | O_NONBLOCK) < 0) {
 264                         closesocket(nfd);
 265                         logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "fcntl",
 266                                strerror(errno));
 267                         return -1;
 268                 }
 269         }
 270 #elif defined(WIN32)
 271         {
 272                 unsigned long arg = 1;
 273
 274                 if(ioctlsocket(nfd, FIONBIO, &arg) != 0) {
 275                         closesocket(nfd);
 276                         logger(DEBUG_ALWAYS, LOG_ERR, "Call to `%s' failed: %s", "ioctlsocket", sockstrerror(sockerrno));
 277                         return -1;
 278                 }
 279         }
 280 #endif
 281
 282         option = 1;
 283         setsockopt(nfd, SOL_SOCKET, SO_REUSEADDR, (void *)&option, sizeof(option));
 284         setsockopt(nfd, SOL_SOCKET, SO_BROADCAST, (void *)&option, sizeof(option));
 285
 286         if(udp_rcvbuf && setsockopt(nfd, SOL_SOCKET, SO_RCVBUF, (void *)&udp_rcvbuf, sizeof(udp_rcvbuf))) {
 287                 logger(DEBUG_ALWAYS, LOG_WARNING, "Can't set UDP SO_RCVBUF to %i: %s", udp_rcvbuf, sockstrerror(sockerrno));
 288         }
 289
 290         if(udp_sndbuf && setsockopt(nfd, SOL_SOCKET, SO_SNDBUF, (void *)&udp_sndbuf, sizeof(udp_sndbuf))) {
 291                 logger(DEBUG_ALWAYS, LOG_WARNING, "Can't set UDP SO_SNDBUF to %i: %s", udp_sndbuf, sockstrerror(sockerrno));
 292         }
 293
 294 #if defined(IPV6_V6ONLY)
 295
 296         if(sa->sa.sa_family == AF_INET6) {
 297                 setsockopt(nfd, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&option, sizeof(option));
 298         }
 299
 300 #endif
 301
 302 #if defined(IP_DONTFRAG) && !defined(IP_DONTFRAGMENT)
 303 #define IP_DONTFRAGMENT IP_DONTFRAG
 304 #endif
 305
 306 #if defined(IP_MTU_DISCOVER) && defined(IP_PMTUDISC_DO)
 307
 308         if(myself->options & OPTION_PMTU_DISCOVERY) {
 309                 option = IP_PMTUDISC_DO;
 310                 setsockopt(nfd, IPPROTO_IP, IP_MTU_DISCOVER, (void *)&option, sizeof(option));
 311         }
 312
 313 #elif defined(IP_DONTFRAGMENT)
 314
 315         if(myself->options & OPTION_PMTU_DISCOVERY) {
 316                 option = 1;
 317                 setsockopt(nfd, IPPROTO_IP, IP_DONTFRAGMENT, (void *)&option, sizeof(option));
 318         }
 319
 320 #endif
 321
 322 #if defined(IPV6_MTU_DISCOVER) && defined(IPV6_PMTUDISC_DO)
 323
 324         if(myself->options & OPTION_PMTU_DISCOVERY) {
 325                 option = IPV6_PMTUDISC_DO;
 326                 setsockopt(nfd, IPPROTO_IPV6, IPV6_MTU_DISCOVER, (void *)&option, sizeof(option));
 327         }
 328
 329 #elif defined(IPV6_DONTFRAG)
 330
 331         if(myself->options & OPTION_PMTU_DISCOVERY) {
 332                 option = 1;
 333                 setsockopt(nfd, IPPROTO_IPV6, IPV6_DONTFRAG, (void *)&option, sizeof(option));
 334         }
 335
 336 #endif
 337
 338 #if defined(SO_MARK)
 339
 340         if(fwmark) {
 341                 setsockopt(nfd, SOL_SOCKET, SO_MARK, (void *)&fwmark, sizeof(fwmark));
 342         }
 343
 344 #endif
 345
 346         if(!bind_to_interface(nfd)) {
 347                 closesocket(nfd);
 348                 return -1;
 349         }
 350
 351         if(bind(nfd, &sa->sa, SALEN(sa->sa))) {
 352                 closesocket(nfd);
 353                 addrstr = sockaddr2hostname(sa);
 354                 logger(DEBUG_ALWAYS, LOG_ERR, "Can't bind to %s/udp: %s", addrstr, sockstrerror(sockerrno));
 355                 free(addrstr);
 356                 return -1;
 357         }
 358
 359         return nfd;
 360 } /* int setup_vpn_in_socket */
 361
 362 static void retry_outgoing_handler(void *data) {
 363         setup_outgoing_connection(data, true);
 364 }
 365
 366 void retry_outgoing(outgoing_t *outgoing) {
 367         outgoing->timeout += 5;
 368
 369         if(outgoing->timeout > maxtimeout) {
 370                 outgoing->timeout = maxtimeout;
 371         }
 372
 373         timeout_add(&outgoing->ev, retry_outgoing_handler, outgoing, &(struct timeval) {
 374                 outgoing->timeout, rand() % 100000
 375         });
 376
 377         logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Trying to re-establish outgoing connection in %d seconds", outgoing->timeout);
 378 }
 379
 380 void finish_connecting(connection_t *c) {
 381         logger(DEBUG_CONNECTIONS, LOG_INFO, "Connected to %s (%s)", c->name, c->hostname);
 382
 383         c->last_ping_time = now.tv_sec;
 384         c->status.connecting = false;
 385
 386         send_id(c);
 387 }
 388
 389 static void do_outgoing_pipe(connection_t *c, char *command) {
 390 #ifndef HAVE_MINGW
 391         int fd[2];
 392
 393         if(socketpair(AF_UNIX, SOCK_STREAM, 0, fd)) {
 394                 logger(DEBUG_ALWAYS, LOG_ERR, "Could not create socketpair: %s", sockstrerror(sockerrno));
 395                 return;
 396         }
 397
 398         if(fork()) {
 399                 c->socket = fd[0];
 400                 close(fd[1]);
 401                 logger(DEBUG_CONNECTIONS, LOG_DEBUG, "Using proxy %s", command);
 402                 return;
 403         }
 404
 405         close(0);
 406         close(1);
 407         close(fd[0]);
 408         dup2(fd[1], 0);
 409         dup2(fd[1], 1);
 410         close(fd[1]);
 411
 412         // Other filedescriptors should be closed automatically by CLOEXEC
 413
 414         char *host = NULL;
 415         char *port = NULL;
 416
 417         sockaddr2str(&c->address, &host, &port);
 418         setenv("REMOTEADDRESS", host, true);
 419         setenv("REMOTEPORT", port, true);
 420         setenv("NODE", c->name, true);
 421         setenv("NAME", myself->name, true);
 422
 423         if(netname) {
 424                 setenv("NETNAME", netname, true);
 425         }
 426
 427         int result = system(command);
 428
 429         if(result < 0) {
 430                 logger(DEBUG_ALWAYS, LOG_ERR, "Could not execute %s: %s", command, strerror(errno));
 431         } else if(result) {
 432                 logger(DEBUG_ALWAYS, LOG_ERR, "%s exited with non-zero status %d", command, result);
 433         }
 434
 435         exit(result);
 436 #else
 437         logger(DEBUG_ALWAYS, LOG_ERR, "Proxy type exec not supported on this platform!");
 438         return;
 439 #endif
 440 }
 441
 442 static void handle_meta_write(connection_t *c) {
 443         if(c->outbuf.len <= c->outbuf.offset) {
 444                 return;
 445         }
 446
 447         ssize_t outlen = send(c->socket, c->outbuf.data + c->outbuf.offset, c->outbuf.len - c->outbuf.offset, 0);
 448
 449         if(outlen <= 0) {
 450                 if(!sockerrno || sockerrno == EPIPE) {
 451                         logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Connection closed by %s (%s)", c->name, c->hostname);
 452                 } else if(sockwouldblock(sockerrno)) {
 453                         logger(DEBUG_META, LOG_DEBUG, "Sending %d bytes to %s (%s) would block", c->outbuf.len - c->outbuf.offset, c->name, c->hostname);
 454                         return;
 455                 } else {
 456                         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));
 457                 }
 458
 459                 terminate_connection(c, c->edge);
 460                 return;
 461         }
 462
 463         buffer_read(&c->outbuf, outlen);
 464
 465         if(!c->outbuf.len) {
 466                 io_set(&c->io, IO_READ);
 467         }
 468 }
 469
 470 static void handle_meta_io(void *data, int flags) {
 471         connection_t *c = data;
 472
 473         if(c->status.connecting) {
 474                 /*
 475                    The event loop does not protect against spurious events. Verify that we are actually connected
 476                    by issuing an empty send() call.
 477
 478                    Note that the behavior of send() on potentially unconnected sockets differ between platforms:
 479                    +------------+-----------+-------------+-----------+
 480                    |   Event    |   POSIX   |    Linux    |  Windows  |
 481                    +------------+-----------+-------------+-----------+
 482                    | Spurious   | ENOTCONN  | EWOULDBLOCK | ENOTCONN  |
 483                    | Failed     | ENOTCONN  | (cause)     | ENOTCONN  |
 484                    | Successful | (success) | (success)   | (success) |
 485                    +------------+-----------+-------------+-----------+
 486                 */
 487                 if(send(c->socket, NULL, 0, 0) != 0) {
 488                         if(sockwouldblock(sockerrno)) {
 489                                 return;
 490                         }
 491
 492                         int socket_error;
 493
 494                         if(!socknotconn(sockerrno)) {
 495                                 socket_error = sockerrno;
 496                         } else {
 497                                 socklen_t len = sizeof(socket_error);
 498                                 getsockopt(c->socket, SOL_SOCKET, SO_ERROR, (void *)&socket_error, &len);
 499                         }
 500
 501                         if(socket_error) {
 502                                 logger(DEBUG_CONNECTIONS, LOG_DEBUG, "Error while connecting to %s (%s): %s", c->name, c->hostname, sockstrerror(socket_error));
 503                                 terminate_connection(c, false);
 504                         }
 505
 506                         return;
 507                 }
 508
 509                 c->status.connecting = false;
 510                 finish_connecting(c);
 511         }
 512
 513         if(flags & IO_WRITE) {
 514                 handle_meta_write(c);
 515         } else {
 516                 handle_meta_connection_data(c);
 517         }
 518 }
 519
 520 bool do_outgoing_connection(outgoing_t *outgoing) {
 521         const sockaddr_t *sa;
 522         struct addrinfo *proxyai = NULL;
 523         int result;
 524
 525 begin:
 526         sa = get_recent_address(outgoing->address_cache);
 527
 528         if(!sa) {
 529                 logger(DEBUG_CONNECTIONS, LOG_ERR, "Could not set up a meta connection to %s", outgoing->node->name);
 530                 retry_outgoing(outgoing);
 531                 return false;
 532         }
 533
 534         connection_t *c = new_connection();
 535         c->outgoing = outgoing;
 536         memcpy(&c->address, sa, SALEN(sa->sa));
 537         c->hostname = sockaddr2hostname(&c->address);
 538
 539         logger(DEBUG_CONNECTIONS, LOG_INFO, "Trying to connect to %s (%s)", outgoing->node->name, c->hostname);
 540
 541         if(!proxytype) {
 542                 c->socket = socket(c->address.sa.sa_family, SOCK_STREAM, IPPROTO_TCP);
 543                 configure_tcp(c);
 544         } else if(proxytype == PROXY_EXEC) {
 545                 do_outgoing_pipe(c, proxyhost);
 546         } else {
 547                 proxyai = str2addrinfo(proxyhost, proxyport, SOCK_STREAM);
 548
 549                 if(!proxyai) {
 550                         free_connection(c);
 551                         goto begin;
 552                 }
 553
 554                 logger(DEBUG_CONNECTIONS, LOG_INFO, "Using proxy at %s port %s", proxyhost, proxyport);
 555                 c->socket = socket(proxyai->ai_family, SOCK_STREAM, IPPROTO_TCP);
 556                 configure_tcp(c);
 557         }
 558
 559         if(c->socket == -1) {
 560                 logger(DEBUG_CONNECTIONS, LOG_ERR, "Creating socket for %s failed: %s", c->hostname, sockstrerror(sockerrno));
 561                 free_connection(c);
 562                 goto begin;
 563         }
 564
 565 #ifdef FD_CLOEXEC
 566         fcntl(c->socket, F_SETFD, FD_CLOEXEC);
 567 #endif
 568
 569         if(proxytype != PROXY_EXEC) {
 570 #if defined(IPV6_V6ONLY)
 571                 int option = 1;
 572
 573                 if(c->address.sa.sa_family == AF_INET6) {
 574                         setsockopt(c->socket, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&option, sizeof(option));
 575                 }
 576
 577 #endif
 578
 579                 bind_to_interface(c->socket);
 580                 bind_to_address(c);
 581         }
 582
 583         /* Connect */
 584
 585         if(!proxytype) {
 586                 result = connect(c->socket, &c->address.sa, SALEN(c->address.sa));
 587         } else if(proxytype == PROXY_EXEC) {
 588                 result = 0;
 589         } else {
 590                 if(!proxyai) {
 591                         abort();
 592                 }
 593
 594                 result = connect(c->socket, proxyai->ai_addr, proxyai->ai_addrlen);
 595                 freeaddrinfo(proxyai);
 596         }
 597
 598         if(result == -1 && !sockinprogress(sockerrno)) {
 599                 logger(DEBUG_CONNECTIONS, LOG_ERR, "Could not connect to %s (%s): %s", outgoing->node->name, c->hostname, sockstrerror(sockerrno));
 600                 free_connection(c);
 601
 602                 goto begin;
 603         }
 604
 605         /* Now that there is a working socket, fill in the rest and register this connection. */
 606
 607         c->last_ping_time = time(NULL);
 608         c->status.connecting = true;
 609         c->name = xstrdup(outgoing->node->name);
 610 #ifndef DISABLE_LEGACY
 611         c->outcipher = myself->connection->outcipher;
 612         c->outdigest = myself->connection->outdigest;
 613 #endif
 614         c->outmaclength = myself->connection->outmaclength;
 615         c->outcompression = myself->connection->outcompression;
 616         c->last_ping_time = now.tv_sec;
 617
 618         connection_add(c);
 619
 620         io_add(&c->io, handle_meta_io, c, c->socket, IO_READ | IO_WRITE);
 621
 622         return true;
 623 }
 624
 625 void setup_outgoing_connection(outgoing_t *outgoing, bool verbose) {
 626         timeout_del(&outgoing->ev);
 627
 628         node_t *n = outgoing->node;
 629
 630         if(n->connection) {
 631                 logger(DEBUG_CONNECTIONS, LOG_INFO, "Already connected to %s", n->name);
 632
 633                 if(!n->connection->outgoing) {
 634                         n->connection->outgoing = outgoing;
 635                         return;
 636                 } else {
 637                         goto remove;
 638                 }
 639         }
 640
 641         if(!outgoing->address_cache) {
 642                 outgoing->address_cache = open_address_cache(n);
 643         }
 644
 645         do_outgoing_connection(outgoing);
 646         return;
 647
 648 remove:
 649         list_delete(outgoing_list, outgoing);
 650 }
 651
 652 /*
 653   accept a new tcp connect and create a
 654   new connection
 655 */
 656 void handle_new_meta_connection(void *data, int flags) {
 657         listen_socket_t *l = data;
 658         connection_t *c;
 659         sockaddr_t sa;
 660         int fd;
 661         socklen_t len = sizeof(sa);
 662
 663         fd = accept(l->tcp.fd, &sa.sa, &len);
 664
 665         if(fd < 0) {
 666                 logger(DEBUG_ALWAYS, LOG_ERR, "Accepting a new connection failed: %s", sockstrerror(sockerrno));
 667                 return;
 668         }
 669
 670         sockaddrunmap(&sa);
 671
 672         // Check if we get many connections from the same host
 673
 674         static sockaddr_t prev_sa;
 675
 676         if(!sockaddrcmp_noport(&sa, &prev_sa)) {
 677                 static int samehost_burst;
 678                 static int samehost_burst_time;
 679
 680                 if(now.tv_sec - samehost_burst_time > samehost_burst) {
 681                         samehost_burst = 0;
 682                 } else {
 683                         samehost_burst -= now.tv_sec - samehost_burst_time;
 684                 }
 685
 686                 samehost_burst_time = now.tv_sec;
 687                 samehost_burst++;
 688
 689                 if(samehost_burst > max_connection_burst) {
 690                         tarpit(fd);
 691                         return;
 692                 }
 693         }
 694
 695         memcpy(&prev_sa, &sa, sizeof(sa));
 696
 697         // Check if we get many connections from different hosts
 698
 699         static int connection_burst;
 700         static int connection_burst_time;
 701
 702         if(now.tv_sec - connection_burst_time > connection_burst) {
 703                 connection_burst = 0;
 704         } else {
 705                 connection_burst -= now.tv_sec - connection_burst_time;
 706         }
 707
 708         connection_burst_time = now.tv_sec;
 709         connection_burst++;
 710
 711         if(connection_burst >= max_connection_burst) {
 712                 connection_burst = max_connection_burst;
 713                 tarpit(fd);
 714                 return;
 715         }
 716
 717         // Accept the new connection
 718
 719         c = new_connection();
 720         c->name = xstrdup("<unknown>");
 721 #ifndef DISABLE_LEGACY
 722         c->outcipher = myself->connection->outcipher;
 723         c->outdigest = myself->connection->outdigest;
 724 #endif
 725         c->outmaclength = myself->connection->outmaclength;
 726         c->outcompression = myself->connection->outcompression;
 727
 728         c->address = sa;
 729         c->hostname = sockaddr2hostname(&sa);
 730         c->socket = fd;
 731         c->last_ping_time = now.tv_sec;
 732
 733         logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Connection from %s", c->hostname);
 734
 735         io_add(&c->io, handle_meta_io, c, c->socket, IO_READ);
 736
 737         configure_tcp(c);
 738
 739         connection_add(c);
 740
 741         c->allow_request = ID;
 742 }
 743
 744 #ifndef HAVE_MINGW
 745 /*
 746   accept a new UNIX socket connection
 747 */
 748 void handle_new_unix_connection(void *data, int flags) {
 749         io_t *io = data;
 750         connection_t *c;
 751         sockaddr_t sa;
 752         int fd;
 753         socklen_t len = sizeof(sa);
 754
 755         fd = accept(io->fd, &sa.sa, &len);
 756
 757         if(fd < 0) {
 758                 logger(DEBUG_ALWAYS, LOG_ERR, "Accepting a new connection failed: %s", sockstrerror(sockerrno));
 759                 return;
 760         }
 761
 762         sockaddrunmap(&sa);
 763
 764         c = new_connection();
 765         c->name = xstrdup("<control>");
 766         c->address = sa;
 767         c->hostname = xstrdup("localhost port unix");
 768         c->socket = fd;
 769         c->last_ping_time = now.tv_sec;
 770
 771         logger(DEBUG_CONNECTIONS, LOG_NOTICE, "Connection from %s", c->hostname);
 772
 773         io_add(&c->io, handle_meta_io, c, c->socket, IO_READ);
 774
 775         connection_add(c);
 776
 777         c->allow_request = ID;
 778 }
 779 #endif
 780
 781 static void free_outgoing(outgoing_t *outgoing) {
 782         timeout_del(&outgoing->ev);
 783
 784         if(outgoing->address_cache) {
 785                 close_address_cache(outgoing->address_cache);
 786         }
 787
 788         free(outgoing);
 789 }
 790
 791 void try_outgoing_connections(void) {
 792         /* If there is no outgoing list yet, create one. Otherwise, mark all outgoings as deleted. */
 793
 794         if(!outgoing_list) {
 795                 outgoing_list = list_alloc((list_action_t)free_outgoing);
 796         } else {
 797                 for list_each(outgoing_t, outgoing, outgoing_list) {
 798                         outgoing->timeout = -1;
 799                 }
 800         }
 801
 802         /* Make sure there is one outgoing_t in the list for each ConnectTo. */
 803
 804         for(config_t *cfg = lookup_config(config_tree, "ConnectTo"); cfg; cfg = lookup_config_next(config_tree, cfg)) {
 805                 char *name;
 806                 get_config_string(cfg, &name);
 807
 808                 if(!check_id(name)) {
 809                         logger(DEBUG_ALWAYS, LOG_ERR,
 810                                "Invalid name for outgoing connection in %s line %d",
 811                                cfg->file, cfg->line);
 812                         free(name);
 813                         continue;
 814                 }
 815
 816                 if(!strcmp(name, myself->name)) {
 817                         free(name);
 818                         continue;
 819                 }
 820
 821                 bool found = false;
 822
 823                 for list_each(outgoing_t, outgoing, outgoing_list) {
 824                         if(!strcmp(outgoing->node->name, name)) {
 825                                 found = true;
 826                                 outgoing->timeout = 0;
 827                                 break;
 828                         }
 829                 }
 830
 831                 if(!found) {
 832                         outgoing_t *outgoing = xzalloc(sizeof(*outgoing));
 833                         node_t *n = lookup_node(name);
 834
 835                         if(!n) {
 836                                 n = new_node();
 837                                 n->name = xstrdup(name);
 838                                 node_add(n);
 839                         }
 840
 841                         outgoing->node = n;
 842                         list_insert_tail(outgoing_list, outgoing);
 843                         setup_outgoing_connection(outgoing, true);
 844                 }
 845         }
 846
 847         /* Terminate any connections whose outgoing_t is to be deleted. */
 848
 849         for list_each(connection_t, c, connection_list) {
 850                 if(c->outgoing && c->outgoing->timeout == -1) {
 851                         c->outgoing = NULL;
 852                         logger(DEBUG_CONNECTIONS, LOG_INFO, "No more outgoing connection to %s", c->name);
 853                         terminate_connection(c, c->edge);
 854                 }
 855         }
 856
 857         /* Delete outgoing_ts for which there is no ConnectTo. */
 858
 859         for list_each(outgoing_t, outgoing, outgoing_list)
 860                 if(outgoing->timeout == -1) {
 861                         list_delete_node(outgoing_list, node);
 862                 }
 863 }