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

   1 /*
   2     protocol_key.c -- handle the meta-protocol, key exchange
   3     Copyright (C) 1999-2005 Ivo Timmermans,
   4                   2000-2017 Guus Sliepen <guus@tinc-vpn.org>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License along
  17     with this program; if not, write to the Free Software Foundation, Inc.,
  18     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #include "system.h"
  22
  23 #include "cipher.h"
  24 #include "connection.h"
  25 #include "crypto.h"
  26 #include "logger.h"
  27 #include "net.h"
  28 #include "netutl.h"
  29 #include "node.h"
  30 #include "protocol.h"
  31 #include "route.h"
  32 #include "sptps.h"
  33 #include "utils.h"
  34
  35 #ifndef DISABLE_LEGACY
  36 static bool mykeyused = false;
  37 #endif
  38
  39 void send_key_changed(void) {
  40 #ifndef DISABLE_LEGACY
  41         send_request(everyone, "%d %x %s", KEY_CHANGED, rand(), myself->name);
  42
  43         /* Immediately send new keys to directly connected nodes to keep UDP mappings alive */
  44
  45         for list_each(connection_t, c, connection_list) {
  46                 if(c->edge && c->node && c->node->status.reachable && !c->node->status.sptps) {
  47                         send_ans_key(c->node);
  48                 }
  49         }
  50
  51 #endif
  52
  53         /* Force key exchange for connections using SPTPS */
  54
  55         if(experimental) {
  56                 for splay_each(node_t, n, node_tree) {
  57                         if(n->status.reachable && n->status.validkey && n->status.sptps) {
  58                                 sptps_force_kex(&n->sptps);
  59                         }
  60                 }
  61         }
  62 }
  63
  64 bool key_changed_h(connection_t *c, const char *request) {
  65         char name[MAX_STRING_SIZE];
  66         node_t *n;
  67
  68         if(sscanf(request, "%*d %*x " MAX_STRING, name) != 1) {
  69                 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "KEY_CHANGED",
  70                        c->name, c->hostname);
  71                 return false;
  72         }
  73
  74         if(seen_request(request)) {
  75                 return true;
  76         }
  77
  78         n = lookup_node(name);
  79
  80         if(!n) {
  81                 logger(DEBUG_ALWAYS, LOG_ERR, "Got %s from %s (%s) origin %s which does not exist",
  82                        "KEY_CHANGED", c->name, c->hostname, name);
  83                 return true;
  84         }
  85
  86         if(!n->status.sptps) {
  87                 n->status.validkey = false;
  88                 n->last_req_key = 0;
  89         }
  90
  91         /* Tell the others */
  92
  93         if(!tunnelserver) {
  94                 forward_request(c, request);
  95         }
  96
  97         return true;
  98 }
  99
 100 static bool send_sptps_data_myself(void *handle, uint8_t type, const void *data, size_t len) {
 101         return send_sptps_data(handle, myself, type, data, len);
 102 }
 103
 104 static bool send_initial_sptps_data(void *handle, uint8_t type, const void *data, size_t len) {
 105         (void)type;
 106         node_t *to = handle;
 107         to->sptps.send_data = send_sptps_data_myself;
 108         char buf[len * 4 / 3 + 5];
 109
 110         b64encode(data, buf, len);
 111
 112         return send_request(to->nexthop->connection, "%d %s %s %d %s", REQ_KEY, myself->name, to->name, REQ_KEY, buf);
 113 }
 114
 115 bool send_req_key(node_t *to) {
 116         if(to->status.sptps) {
 117                 if(!node_read_ecdsa_public_key(to)) {
 118                         logger(DEBUG_PROTOCOL, LOG_DEBUG, "No Ed25519 key known for %s (%s)", to->name, to->hostname);
 119                         send_request(to->nexthop->connection, "%d %s %s %d", REQ_KEY, myself->name, to->name, REQ_PUBKEY);
 120                         return true;
 121                 }
 122
 123                 char label[25 + strlen(myself->name) + strlen(to->name)];
 124                 snprintf(label, sizeof(label), "tinc UDP key expansion %s %s", myself->name, to->name);
 125                 sptps_stop(&to->sptps);
 126                 to->status.validkey = false;
 127                 to->status.waitingforkey = true;
 128                 to->last_req_key = now.tv_sec;
 129                 to->incompression = myself->incompression;
 130                 return sptps_start(&to->sptps, to, true, true, myself->connection->ecdsa, to->ecdsa, label, sizeof(label), send_initial_sptps_data, receive_sptps_record);
 131         }
 132
 133         return send_request(to->nexthop->connection, "%d %s %s", REQ_KEY, myself->name, to->name);
 134 }
 135
 136 /* REQ_KEY is overloaded to allow arbitrary requests to be routed between two nodes. */
 137
 138 static bool req_key_ext_h(connection_t *c, const char *request, node_t *from, node_t *to, int reqno) {
 139         (void)c;
 140
 141         /* If this is a SPTPS packet, see if sending UDP info helps.
 142            Note that we only do this if we're the destination or the static relay;
 143            otherwise every hop would initiate its own UDP info message, resulting in elevated chatter. */
 144         if((reqno == REQ_KEY || reqno == SPTPS_PACKET) && to->via == myself) {
 145                 send_udp_info(myself, from);
 146         }
 147
 148         if(reqno == SPTPS_PACKET) {
 149                 /* This is a SPTPS data packet. */
 150
 151                 char buf[MAX_STRING_SIZE];
 152                 int len;
 153
 154                 if(sscanf(request, "%*d %*s %*s %*d " MAX_STRING, buf) != 1 || !(len = b64decode(buf, buf, strlen(buf)))) {
 155                         logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s) to %s (%s): %s", "SPTPS_PACKET", from->name, from->hostname, to->name, to->hostname, "invalid SPTPS data");
 156                         return true;
 157                 }
 158
 159                 if(to != myself) {
 160                         /* We don't just forward the request, because we want to use UDP if it's available. */
 161                         if(forwarding_mode == FMODE_INTERNAL) {
 162                                 send_sptps_data(to, from, 0, buf, len);
 163                                 try_tx(to, true);
 164                         }
 165                 } else {
 166                         /* The packet is for us */
 167                         if(!sptps_receive_data(&from->sptps, buf, len)) {
 168                                 /* Uh-oh. It might be that the tunnel is stuck in some corrupted state,
 169                                    so let's restart SPTPS in case that helps. But don't do that too often
 170                                    to prevent storms. */
 171                                 if(from->last_req_key < now.tv_sec - 10) {
 172                                         logger(DEBUG_PROTOCOL, LOG_ERR, "Failed to decode TCP packet from %s (%s), restarting SPTPS", from->name, from->hostname);
 173                                         send_req_key(from);
 174                                 }
 175
 176                                 return true;
 177                         }
 178
 179                         send_mtu_info(myself, from, MTU);
 180                 }
 181
 182                 return true;
 183         }
 184
 185         /* Requests that are not SPTPS data packets are forwarded as-is. */
 186
 187         if(to != myself) {
 188                 return send_request(to->nexthop->connection, "%s", request);
 189         }
 190
 191         /* The request is for us */
 192
 193         switch(reqno) {
 194         case REQ_PUBKEY: {
 195                 if(!node_read_ecdsa_public_key(from)) {
 196                         /* Request their key *before* we send our key back. Otherwise the first SPTPS packet from them will get dropped. */
 197                         logger(DEBUG_PROTOCOL, LOG_DEBUG, "Preemptively requesting Ed25519 key for %s (%s)", from->name, from->hostname);
 198                         send_request(from->nexthop->connection, "%d %s %s %d", REQ_KEY, myself->name, from->name, REQ_PUBKEY);
 199                 }
 200
 201                 char *pubkey = ecdsa_get_base64_public_key(myself->connection->ecdsa);
 202                 send_request(from->nexthop->connection, "%d %s %s %d %s", REQ_KEY, myself->name, from->name, ANS_PUBKEY, pubkey);
 203                 free(pubkey);
 204                 return true;
 205         }
 206
 207         case ANS_PUBKEY: {
 208                 if(node_read_ecdsa_public_key(from)) {
 209                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Got ANS_PUBKEY from %s (%s) even though we already have his pubkey", from->name, from->hostname);
 210                         return true;
 211                 }
 212
 213                 char pubkey[MAX_STRING_SIZE];
 214
 215                 if(sscanf(request, "%*d %*s %*s %*d " MAX_STRING, pubkey) != 1 || !(from->ecdsa = ecdsa_set_base64_public_key(pubkey))) {
 216                         logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s): %s", "ANS_PUBKEY", from->name, from->hostname, "invalid pubkey");
 217                         return true;
 218                 }
 219
 220                 logger(DEBUG_PROTOCOL, LOG_INFO, "Learned Ed25519 public key from %s (%s)", from->name, from->hostname);
 221                 append_config_file(from->name, "Ed25519PublicKey", pubkey);
 222                 return true;
 223         }
 224
 225         case REQ_KEY: {
 226                 if(!node_read_ecdsa_public_key(from)) {
 227                         logger(DEBUG_PROTOCOL, LOG_DEBUG, "No Ed25519 key known for %s (%s)", from->name, from->hostname);
 228                         send_request(from->nexthop->connection, "%d %s %s %d", REQ_KEY, myself->name, from->name, REQ_PUBKEY);
 229                         return true;
 230                 }
 231
 232                 if(from->sptps.label) {
 233                         logger(DEBUG_ALWAYS, LOG_DEBUG, "Got REQ_KEY from %s while we already started a SPTPS session!", from->name);
 234                 }
 235
 236                 char buf[MAX_STRING_SIZE];
 237                 size_t len;
 238
 239                 if(sscanf(request, "%*d %*s %*s %*d " MAX_STRING, buf) != 1 || !(len = b64decode(buf, buf, strlen(buf)))) {
 240                         logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s): %s", "REQ_SPTPS_START", from->name, from->hostname, "invalid SPTPS data");
 241                         return true;
 242                 }
 243
 244                 char label[25 + strlen(from->name) + strlen(myself->name)];
 245                 snprintf(label, sizeof(label), "tinc UDP key expansion %s %s", from->name, myself->name);
 246                 sptps_stop(&from->sptps);
 247                 from->status.validkey = false;
 248                 from->status.waitingforkey = true;
 249                 from->last_req_key = now.tv_sec;
 250                 sptps_start(&from->sptps, from, false, true, myself->connection->ecdsa, from->ecdsa, label, sizeof(label), send_sptps_data_myself, receive_sptps_record);
 251                 sptps_receive_data(&from->sptps, buf, len);
 252                 send_mtu_info(myself, from, MTU);
 253                 return true;
 254         }
 255
 256         default:
 257                 logger(DEBUG_ALWAYS, LOG_ERR, "Unknown extended REQ_KEY request from %s (%s): %s", from->name, from->hostname, request);
 258                 return true;
 259         }
 260 }
 261
 262 bool req_key_h(connection_t *c, const char *request) {
 263         char from_name[MAX_STRING_SIZE];
 264         char to_name[MAX_STRING_SIZE];
 265         node_t *from, *to;
 266         int reqno = 0;
 267
 268         if(sscanf(request, "%*d " MAX_STRING " " MAX_STRING " %d", from_name, to_name, &reqno) < 2) {
 269                 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "REQ_KEY", c->name,
 270                        c->hostname);
 271                 return false;
 272         }
 273
 274         if(!check_id(from_name) || !check_id(to_name)) {
 275                 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s): %s", "REQ_KEY", c->name, c->hostname, "invalid name");
 276                 return false;
 277         }
 278
 279         from = lookup_node(from_name);
 280
 281         if(!from) {
 282                 logger(DEBUG_ALWAYS, LOG_ERR, "Got %s from %s (%s) origin %s which does not exist in our connection list",
 283                        "REQ_KEY", c->name, c->hostname, from_name);
 284                 return true;
 285         }
 286
 287         to = lookup_node(to_name);
 288
 289         if(!to) {
 290                 logger(DEBUG_ALWAYS, LOG_ERR, "Got %s from %s (%s) destination %s which does not exist in our connection list",
 291                        "REQ_KEY", c->name, c->hostname, to_name);
 292                 return true;
 293         }
 294
 295         /* Check if this key request is for us */
 296
 297         if(to == myself) {                      /* Yes */
 298                 if(!from->status.reachable) {
 299                         logger(DEBUG_ALWAYS, LOG_ERR, "Got %s from %s (%s) origin %s which is not reachable",
 300                                "REQ_KEY", c->name, c->hostname, from_name);
 301                         return true;
 302                 }
 303
 304                 /* Is this an extended REQ_KEY message? */
 305                 if(experimental && reqno) {
 306                         return req_key_ext_h(c, request, from, to, reqno);
 307                 }
 308
 309                 /* No, just send our key back */
 310                 send_ans_key(from);
 311         } else {
 312                 if(tunnelserver) {
 313                         return true;
 314                 }
 315
 316                 if(!to->status.reachable) {
 317                         logger(DEBUG_PROTOCOL, LOG_WARNING, "Got %s from %s (%s) destination %s which is not reachable",
 318                                "REQ_KEY", c->name, c->hostname, to_name);
 319                         return true;
 320                 }
 321
 322                 /* Is this an extended REQ_KEY message? */
 323                 if(experimental && reqno) {
 324                         return req_key_ext_h(c, request, from, to, reqno);
 325                 }
 326
 327                 send_request(to->nexthop->connection, "%s", request);
 328         }
 329
 330         return true;
 331 }
 332
 333 bool send_ans_key(node_t *to) {
 334         if(to->status.sptps) {
 335                 abort();
 336         }
 337
 338 #ifdef DISABLE_LEGACY
 339         return false;
 340 #else
 341         size_t keylen = myself->incipher ? cipher_keylength(myself->incipher) : 1;
 342         char key[keylen * 2 + 1];
 343
 344         randomize(key, keylen);
 345
 346         cipher_close(to->incipher);
 347         digest_close(to->indigest);
 348
 349         if(myself->incipher) {
 350                 to->incipher = cipher_open_by_nid(cipher_get_nid(myself->incipher));
 351
 352                 if(!to->incipher) {
 353                         abort();
 354                 }
 355
 356                 if(!cipher_set_key(to->incipher, key, false)) {
 357                         abort();
 358                 }
 359         }
 360
 361         if(myself->indigest) {
 362                 to->indigest = digest_open_by_nid(digest_get_nid(myself->indigest), digest_length(myself->indigest));
 363
 364                 if(!to->indigest) {
 365                         abort();
 366                 }
 367
 368                 if(!digest_set_key(to->indigest, key, keylen)) {
 369                         abort();
 370                 }
 371         }
 372
 373         to->incompression = myself->incompression;
 374
 375         bin2hex(key, key, keylen);
 376
 377         // Reset sequence number and late packet window
 378         mykeyused = true;
 379         to->received_seqno = 0;
 380         to->received = 0;
 381
 382         if(replaywin) {
 383                 memset(to->late, 0, replaywin);
 384         }
 385
 386         to->status.validkey_in = true;
 387
 388         return send_request(to->nexthop->connection, "%d %s %s %s %d %d %d %d", ANS_KEY,
 389                             myself->name, to->name, key,
 390                             cipher_get_nid(to->incipher),
 391                             digest_get_nid(to->indigest),
 392                             (int)digest_length(to->indigest),
 393                             to->incompression);
 394 #endif
 395 }
 396
 397 bool ans_key_h(connection_t *c, const char *request) {
 398         char from_name[MAX_STRING_SIZE];
 399         char to_name[MAX_STRING_SIZE];
 400         char key[MAX_STRING_SIZE];
 401         char address[MAX_STRING_SIZE] = "";
 402         char port[MAX_STRING_SIZE] = "";
 403         int cipher, digest, maclength, compression;
 404         node_t *from, *to;
 405
 406         if(sscanf(request, "%*d "MAX_STRING" "MAX_STRING" "MAX_STRING" %d %d %d %d "MAX_STRING" "MAX_STRING,
 407                         from_name, to_name, key, &cipher, &digest, &maclength,
 408                         &compression, address, port) < 7) {
 409                 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s)", "ANS_KEY", c->name,
 410                        c->hostname);
 411                 return false;
 412         }
 413
 414         if(!check_id(from_name) || !check_id(to_name)) {
 415                 logger(DEBUG_ALWAYS, LOG_ERR, "Got bad %s from %s (%s): %s", "ANS_KEY", c->name, c->hostname, "invalid name");
 416                 return false;
 417         }
 418
 419         from = lookup_node(from_name);
 420
 421         if(!from) {
 422                 logger(DEBUG_ALWAYS, LOG_ERR, "Got %s from %s (%s) origin %s which does not exist in our connection list",
 423                        "ANS_KEY", c->name, c->hostname, from_name);
 424                 return true;
 425         }
 426
 427         to = lookup_node(to_name);
 428
 429         if(!to) {
 430                 logger(DEBUG_ALWAYS, LOG_ERR, "Got %s from %s (%s) destination %s which does not exist in our connection list",
 431                        "ANS_KEY", c->name, c->hostname, to_name);
 432                 return true;
 433         }
 434
 435         /* Forward it if necessary */
 436
 437         if(to != myself) {
 438                 if(tunnelserver) {
 439                         return true;
 440                 }
 441
 442                 if(!to->status.reachable) {
 443                         logger(DEBUG_ALWAYS, LOG_WARNING, "Got %s from %s (%s) destination %s which is not reachable",
 444                                "ANS_KEY", c->name, c->hostname, to_name);
 445                         return true;
 446                 }
 447
 448                 if(!*address && from->address.sa.sa_family != AF_UNSPEC && to->minmtu) {
 449                         char *address, *port;
 450                         logger(DEBUG_PROTOCOL, LOG_DEBUG, "Appending reflexive UDP address to ANS_KEY from %s to %s", from->name, to->name);
 451                         sockaddr2str(&from->address, &address, &port);
 452                         send_request(to->nexthop->connection, "%s %s %s", request, address, port);
 453                         free(address);
 454                         free(port);
 455                         return true;
 456                 }
 457
 458                 return send_request(to->nexthop->connection, "%s", request);
 459         }
 460
 461 #ifndef DISABLE_LEGACY
 462         /* Don't use key material until every check has passed. */
 463         cipher_close(from->outcipher);
 464         digest_close(from->outdigest);
 465 #endif
 466
 467         if(!from->status.sptps) {
 468                 from->status.validkey = false;
 469         }
 470
 471         switch(compression) {
 472         case 12:
 473 #ifdef HAVE_LZ4
 474                 break;
 475 #else
 476                 logger(DEBUG_ALWAYS, LOG_ERR, "Node %s (%s) uses bogus compression level!", from->name, from->hostname);
 477                 logger(DEBUG_ALWAYS, LOG_ERR, "LZ4 compression is unavailable on this node.");
 478                 return true;
 479 #endif
 480
 481         case 11:
 482         case 10:
 483 #ifdef HAVE_LZO
 484                 break;
 485 #else
 486                 logger(DEBUG_ALWAYS, LOG_ERR, "Node %s (%s) uses bogus compression level!", from->name, from->hostname);
 487                 logger(DEBUG_ALWAYS, LOG_ERR, "LZO compression is unavailable on this node.");
 488                 return true;
 489 #endif
 490
 491         case 9:
 492         case 8:
 493         case 7:
 494         case 6:
 495         case 5:
 496         case 4:
 497         case 3:
 498         case 2:
 499         case 1:
 500 #ifdef HAVE_ZLIB
 501                 break;
 502 #else
 503                 logger(DEBUG_ALWAYS, LOG_ERR, "Node %s (%s) uses bogus compression level!", from->name, from->hostname);
 504                 logger(DEBUG_ALWAYS, LOG_ERR, "ZLIB compression is unavailable on this node.");
 505                 return true;
 506 #endif
 507
 508         case 0:
 509                 break;
 510
 511         default:
 512                 logger(DEBUG_ALWAYS, LOG_ERR, "Node %s (%s) uses bogus compression level!", from->name, from->hostname);
 513                 logger(DEBUG_ALWAYS, LOG_ERR, "Compression level %i is unrecognized by this node.", compression);
 514                 return true;
 515         }
 516
 517         from->outcompression = compression;
 518
 519         /* SPTPS or old-style key exchange? */
 520
 521         if(from->status.sptps) {
 522                 char buf[strlen(key)];
 523                 size_t len = b64decode(key, buf, strlen(key));
 524
 525                 if(!len || !sptps_receive_data(&from->sptps, buf, len)) {
 526                         /* Uh-oh. It might be that the tunnel is stuck in some corrupted state,
 527                            so let's restart SPTPS in case that helps. But don't do that too often
 528                            to prevent storms.
 529                            Note that simply relying on handshake timeout is not enough, because
 530                            that doesn't apply to key regeneration. */
 531                         if(from->last_req_key < now.tv_sec - 10) {
 532                                 logger(DEBUG_PROTOCOL, LOG_ERR, "Failed to decode handshake TCP packet from %s (%s), restarting SPTPS", from->name, from->hostname);
 533                                 send_req_key(from);
 534                         }
 535
 536                         return true;
 537                 }
 538
 539                 if(from->status.validkey) {
 540                         if(*address && *port) {
 541                                 logger(DEBUG_PROTOCOL, LOG_DEBUG, "Using reflexive UDP address from %s: %s port %s", from->name, address, port);
 542                                 sockaddr_t sa = str2sockaddr(address, port);
 543                                 update_node_udp(from, &sa);
 544                         }
 545                 }
 546
 547                 send_mtu_info(myself, from, MTU);
 548
 549                 return true;
 550         }
 551
 552 #ifdef DISABLE_LEGACY
 553         logger(DEBUG_ALWAYS, LOG_ERR, "Node %s (%s) uses legacy protocol!", from->name, from->hostname);
 554         return false;
 555 #else
 556         /* Check and lookup cipher and digest algorithms */
 557
 558         if(cipher) {
 559                 if(!(from->outcipher = cipher_open_by_nid(cipher))) {
 560                         logger(DEBUG_ALWAYS, LOG_ERR, "Node %s (%s) uses unknown cipher!", from->name, from->hostname);
 561                         return false;
 562                 }
 563         } else {
 564                 from->outcipher = NULL;
 565         }
 566
 567         if(digest) {
 568                 if(!(from->outdigest = digest_open_by_nid(digest, maclength))) {
 569                         logger(DEBUG_ALWAYS, LOG_ERR, "Node %s (%s) uses unknown digest!", from->name, from->hostname);
 570                         return false;
 571                 }
 572         } else {
 573                 from->outdigest = NULL;
 574         }
 575
 576         if((size_t)maclength != digest_length(from->outdigest)) {
 577                 logger(DEBUG_ALWAYS, LOG_ERR, "Node %s (%s) uses bogus MAC length!", from->name, from->hostname);
 578                 return false;
 579         }
 580
 581         /* Process key */
 582
 583         size_t keylen = hex2bin(key, key, sizeof(key));
 584
 585         if(keylen != (from->outcipher ? cipher_keylength(from->outcipher) : 1)) {
 586                 logger(DEBUG_ALWAYS, LOG_ERR, "Node %s (%s) uses wrong keylength!", from->name, from->hostname);
 587                 return true;
 588         }
 589
 590         /* Update our copy of the origin's packet key */
 591
 592         if(from->outcipher && !cipher_set_key(from->outcipher, key, true)) {
 593                 return false;
 594         }
 595
 596         if(from->outdigest && !digest_set_key(from->outdigest, key, keylen)) {
 597                 return false;
 598         }
 599
 600         from->status.validkey = true;
 601         from->sent_seqno = 0;
 602
 603         if(*address && *port) {
 604                 logger(DEBUG_PROTOCOL, LOG_DEBUG, "Using reflexive UDP address from %s: %s port %s", from->name, address, port);
 605                 sockaddr_t sa = str2sockaddr(address, port);
 606                 update_node_udp(from, &sa);
 607         }
 608
 609         return true;
 610 #endif
 611 }