git.tinc-vpn.org Git - tinc/blob - src/tincctl.c

   1 /*
   2     tincctl.c -- Controlling a running tincd
   3     Copyright (C) 2007-2017 Guus Sliepen <guus@tinc-vpn.org>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "system.h"
  21
  22 #include <getopt.h>
  23
  24 #ifdef HAVE_READLINE
  25 #include "readline/readline.h"
  26 #include "readline/history.h"
  27 #endif
  28
  29 #include "xalloc.h"
  30 #include "protocol.h"
  31 #include "control_common.h"
  32 #include "crypto.h"
  33 #include "ecdsagen.h"
  34 #include "fsck.h"
  35 #include "info.h"
  36 #include "invitation.h"
  37 #include "names.h"
  38 #include "rsagen.h"
  39 #include "utils.h"
  40 #include "tincctl.h"
  41 #include "top.h"
  42 #include "version.h"
  43
  44 #ifndef MSG_NOSIGNAL
  45 #define MSG_NOSIGNAL 0
  46 #endif
  47
  48 static char **orig_argv;
  49 static int orig_argc;
  50
  51 /* If nonzero, display usage information and exit. */
  52 static bool show_help = false;
  53
  54 /* If nonzero, print the version on standard output and exit.  */
  55 static bool show_version = false;
  56
  57 static char *name = NULL;
  58 static char controlcookie[1025];
  59 char *tinc_conf = NULL;
  60 char *hosts_dir = NULL;
  61 struct timeval now;
  62
  63 // Horrible global variables...
  64 static int pid = 0;
  65 int fd = -1;
  66 char line[4096];
  67 static int code;
  68 static int req;
  69 static int result;
  70 bool force = false;
  71 bool tty = true;
  72 bool confbasegiven = false;
  73 bool netnamegiven = false;
  74 char *scriptinterpreter = NULL;
  75 char *scriptextension = "";
  76 static char *prompt;
  77 char *device = NULL;
  78 char *iface = NULL;
  79 int debug_level = -1;
  80
  81 static struct option const long_options[] = {
  82         {"batch", no_argument, NULL, 'b'},
  83         {"config", required_argument, NULL, 'c'},
  84         {"net", required_argument, NULL, 'n'},
  85         {"help", no_argument, NULL, 1},
  86         {"version", no_argument, NULL, 2},
  87         {"pidfile", required_argument, NULL, 3},
  88         {"force", no_argument, NULL, 4},
  89         {NULL, 0, NULL, 0}
  90 };
  91
  92 static void version(void) {
  93         printf("%s version %s (built %s %s, protocol %d.%d)\n", PACKAGE,
  94                    BUILD_VERSION, BUILD_DATE, BUILD_TIME, PROT_MAJOR, PROT_MINOR);
  95         printf("Copyright (C) 1998-2017 Ivo Timmermans, Guus Sliepen and others.\n"
  96                         "See the AUTHORS file for a complete list.\n\n"
  97                         "tinc comes with ABSOLUTELY NO WARRANTY.  This is free software,\n"
  98                         "and you are welcome to redistribute it under certain conditions;\n"
  99                         "see the file COPYING for details.\n");
 100 }
 101
 102 static void usage(bool status) {
 103         if(status) {
 104                 fprintf(stderr, "Try `%s --help\' for more information.\n", program_name);
 105         } else {
 106                 printf("Usage: %s [options] command\n\n", program_name);
 107                 printf("Valid options are:\n"
 108                                 "  -b, --batch             Don't ask for anything (non-interactive mode).\n"
 109                                 "  -c, --config=DIR        Read configuration options from DIR.\n"
 110                                 "  -n, --net=NETNAME       Connect to net NETNAME.\n"
 111                                 "      --pidfile=FILENAME  Read control cookie from FILENAME.\n"
 112                                 "      --force             Force some commands to work despite warnings.\n"
 113                                 "      --help              Display this help and exit.\n"
 114                                 "      --version           Output version information and exit.\n"
 115                                 "\n"
 116                                 "Valid commands are:\n"
 117                                 "  init [name]                Create initial configuration files.\n"
 118                                 "  get VARIABLE               Print current value of VARIABLE\n"
 119                                 "  set VARIABLE VALUE         Set VARIABLE to VALUE\n"
 120                                 "  add VARIABLE VALUE         Add VARIABLE with the given VALUE\n"
 121                                 "  del VARIABLE [VALUE]       Remove VARIABLE [only ones with watching VALUE]\n"
 122                                 "  start [tincd options]      Start tincd.\n"
 123                                 "  stop                       Stop tincd.\n"
 124                                 "  restart [tincd options]    Restart tincd.\n"
 125                                 "  reload                     Partially reload configuration of running tincd.\n"
 126                                 "  pid                        Show PID of currently running tincd.\n"
 127 #ifdef DISABLE_LEGACY
 128                                 "  generate-keys              Generate a new Ed25519 public/private keypair.\n"
 129 #else
 130                                 "  generate-keys [bits]       Generate new RSA and Ed25519 public/private keypairs.\n"
 131                                 "  generate-rsa-keys [bits]   Generate a new RSA public/private keypair.\n"
 132 #endif
 133                                 "  generate-ed25519-keys      Generate a new Ed25519 public/private keypair.\n"
 134                                 "  dump                       Dump a list of one of the following things:\n"
 135                                 "    [reachable] nodes        - all known nodes in the VPN\n"
 136                                 "    edges                    - all known connections in the VPN\n"
 137                                 "    subnets                  - all known subnets in the VPN\n"
 138                                 "    connections              - all meta connections with ourself\n"
 139                                 "    [di]graph                - graph of the VPN in dotty format\n"
 140                                 "    invitations              - outstanding invitations\n"
 141                                 "  info NODE|SUBNET|ADDRESS   Give information about a particular NODE, SUBNET or ADDRESS.\n"
 142                                 "  purge                      Purge unreachable nodes\n"
 143                                 "  debug N                    Set debug level\n"
 144                                 "  retry                      Retry all outgoing connections\n"
 145                                 "  disconnect NODE            Close meta connection with NODE\n"
 146 #ifdef HAVE_CURSES
 147                                 "  top                        Show real-time statistics\n"
 148 #endif
 149                                 "  pcap [snaplen]             Dump traffic in pcap format [up to snaplen bytes per packet]\n"
 150                                 "  log [level]                Dump log output [up to the specified level]\n"
 151                                 "  export                     Export host configuration of local node to standard output\n"
 152                                 "  export-all                 Export all host configuration files to standard output\n"
 153                                 "  import                     Import host configuration file(s) from standard input\n"
 154                                 "  exchange                   Same as export followed by import\n"
 155                                 "  exchange-all               Same as export-all followed by import\n"
 156                                 "  invite NODE [...]          Generate an invitation for NODE\n"
 157                                 "  join INVITATION            Join a VPN using an INVITATION\n"
 158                                 "  network [NETNAME]          List all known networks, or switch to the one named NETNAME.\n"
 159                                 "  fsck                       Check the configuration files for problems.\n"
 160                                 "  sign [FILE]                Generate a signed version of a file.\n"
 161                                 "  verify NODE [FILE]         Verify that a file was signed by the given NODE.\n"
 162                                 "\n");
 163                 printf("Report bugs to tinc@tinc-vpn.org.\n");
 164         }
 165 }
 166
 167 static bool parse_options(int argc, char **argv) {
 168         int r;
 169         int option_index = 0;
 170
 171         while((r = getopt_long(argc, argv, "+c:n:", long_options, &option_index)) != EOF) {
 172                 switch (r) {
 173                         case 0:   /* long option */
 174                                 break;
 175
 176                         case 'b':
 177                                 tty = false;
 178                                 break;
 179
 180                         case 'c': /* config file */
 181                                 confbase = xstrdup(optarg);
 182                                 confbasegiven = true;
 183                                 break;
 184
 185                         case 'n': /* net name given */
 186                                 netname = xstrdup(optarg);
 187                                 break;
 188
 189                         case 1:   /* show help */
 190                                 show_help = true;
 191                                 break;
 192
 193                         case 2:   /* show version */
 194                                 show_version = true;
 195                                 break;
 196
 197                         case 3:   /* open control socket here */
 198                                 pidfilename = xstrdup(optarg);
 199                                 break;
 200
 201                         case 4:   /* force */
 202                                 force = true;
 203                                 break;
 204
 205                         case '?': /* wrong options */
 206                                 usage(true);
 207                                 return false;
 208
 209                         default:
 210                                 break;
 211                 }
 212         }
 213
 214         if(!netname && (netname = getenv("NETNAME")))
 215                 netname = xstrdup(netname);
 216
 217         /* netname "." is special: a "top-level name" */
 218
 219         if(netname && (!*netname || !strcmp(netname, "."))) {
 220                 free(netname);
 221                 netname = NULL;
 222         }
 223
 224         if(netname && (strpbrk(netname, "\\/") || *netname == '.')) {
 225                 fprintf(stderr, "Invalid character in netname!\n");
 226                 return false;
 227         }
 228
 229         return true;
 230 }
 231
 232 /* Open a file with the desired permissions, minus the umask.
 233    Also, if we want to create an executable file, we call fchmod()
 234    to set the executable bits. */
 235
 236 FILE *fopenmask(const char *filename, const char *mode, mode_t perms) {
 237         mode_t mask = umask(0);
 238         perms &= ~mask;
 239         umask(~perms);
 240         FILE *f = fopen(filename, mode);
 241
 242         if(!f) {
 243                 fprintf(stderr, "Could not open %s: %s\n", filename, strerror(errno));
 244                 return NULL;
 245         }
 246
 247 #ifdef HAVE_FCHMOD
 248         if((perms & 0444) && f)
 249                 fchmod(fileno(f), perms);
 250 #endif
 251         umask(mask);
 252         return f;
 253 }
 254
 255 static void disable_old_keys(const char *filename, const char *what) {
 256         char tmpfile[PATH_MAX] = "";
 257         char buf[1024];
 258         bool disabled = false;
 259         bool block = false;
 260         bool error = false;
 261         FILE *r, *w;
 262
 263         r = fopen(filename, "r");
 264         if(!r)
 265                 return;
 266
 267         snprintf(tmpfile, sizeof tmpfile, "%s.tmp", filename);
 268
 269         struct stat st = {.st_mode = 0600};
 270         fstat(fileno(r), &st);
 271         w = fopenmask(tmpfile, "w", st.st_mode);
 272
 273         while(fgets(buf, sizeof buf, r)) {
 274                 if(!block && !strncmp(buf, "-----BEGIN ", 11)) {
 275                         if((strstr(buf, " ED25519 ") && strstr(what, "Ed25519")) || (strstr(buf, " RSA ") && strstr(what, "RSA"))) {
 276                                 disabled = true;
 277                                 block = true;
 278                         }
 279                 }
 280
 281                 bool ed25519pubkey = !strncasecmp(buf, "Ed25519PublicKey", 16) && strchr(" \t=", buf[16]) && strstr(what, "Ed25519");
 282
 283                 if(ed25519pubkey)
 284                         disabled = true;
 285
 286                 if(w) {
 287                         if(block || ed25519pubkey)
 288                                 fputc('#', w);
 289                         if(fputs(buf, w) < 0) {
 290                                 error = true;
 291                                 break;
 292                         }
 293                 }
 294
 295                 if(block && !strncmp(buf, "-----END ", 9))
 296                         block = false;
 297         }
 298
 299         if(w)
 300                 if(fclose(w) < 0)
 301                         error = true;
 302         if(ferror(r) || fclose(r) < 0)
 303                 error = true;
 304
 305         if(disabled) {
 306                 if(!w || error) {
 307                         fprintf(stderr, "Warning: old key(s) found, remove them by hand!\n");
 308                         if(w)
 309                                 unlink(tmpfile);
 310                         return;
 311                 }
 312
 313 #ifdef HAVE_MINGW
 314                 // We cannot atomically replace files on Windows.
 315                 char bakfile[PATH_MAX] = "";
 316                 snprintf(bakfile, sizeof bakfile, "%s.bak", filename);
 317                 if(rename(filename, bakfile) || rename(tmpfile, filename)) {
 318                         rename(bakfile, filename);
 319 #else
 320                 if(rename(tmpfile, filename)) {
 321 #endif
 322                         fprintf(stderr, "Warning: old key(s) found, remove them by hand!\n");
 323                 } else  {
 324 #ifdef HAVE_MINGW
 325                         unlink(bakfile);
 326 #endif
 327                         fprintf(stderr, "Warning: old key(s) found and disabled.\n");
 328                 }
 329         }
 330
 331         unlink(tmpfile);
 332 }
 333
 334 static FILE *ask_and_open(const char *filename, const char *what, const char *mode, bool ask, mode_t perms) {
 335         FILE *r;
 336         char directory[PATH_MAX] = ".";
 337         char buf[PATH_MAX];
 338         char buf2[PATH_MAX];
 339
 340         /* Check stdin and stdout */
 341         if(ask && tty) {
 342                 /* Ask for a file and/or directory name. */
 343                 fprintf(stderr, "Please enter a file to save %s to [%s]: ", what, filename);
 344
 345                 if(fgets(buf, sizeof buf, stdin) == NULL) {
 346                         fprintf(stderr, "Error while reading stdin: %s\n", strerror(errno));
 347                         return NULL;
 348                 }
 349
 350                 size_t len = strlen(buf);
 351                 if(len)
 352                         buf[--len] = 0;
 353
 354                 if(len)
 355                         filename = buf;
 356         }
 357
 358 #ifdef HAVE_MINGW
 359         if(filename[0] != '\\' && filename[0] != '/' && !strchr(filename, ':')) {
 360 #else
 361         if(filename[0] != '/') {
 362 #endif
 363                 /* The directory is a relative path or a filename. */
 364                 getcwd(directory, sizeof directory);
 365                 snprintf(buf2, sizeof buf2, "%s" SLASH "%s", directory, filename);
 366                 filename = buf2;
 367         }
 368
 369         disable_old_keys(filename, what);
 370
 371         /* Open it first to keep the inode busy */
 372
 373         r = fopenmask(filename, mode, perms);
 374
 375         if(!r) {
 376                 fprintf(stderr, "Error opening file `%s': %s\n", filename, strerror(errno));
 377                 return NULL;
 378         }
 379
 380         return r;
 381 }
 382
 383 /*
 384   Generate a public/private Ed25519 keypair, and ask for a file to store
 385   them in.
 386 */
 387 static bool ed25519_keygen(bool ask) {
 388         ecdsa_t *key;
 389         FILE *f;
 390         char fname[PATH_MAX];
 391
 392         fprintf(stderr, "Generating Ed25519 keypair:\n");
 393
 394         if(!(key = ecdsa_generate())) {
 395                 fprintf(stderr, "Error during key generation!\n");
 396                 return false;
 397         } else
 398                 fprintf(stderr, "Done.\n");
 399
 400         snprintf(fname, sizeof fname, "%s" SLASH "ed25519_key.priv", confbase);
 401         f = ask_and_open(fname, "private Ed25519 key", "a", ask, 0600);
 402
 403         if(!f)
 404                 goto error;
 405
 406         if(!ecdsa_write_pem_private_key(key, f)) {
 407                 fprintf(stderr, "Error writing private key!\n");
 408                 goto error;
 409         }
 410
 411         fclose(f);
 412
 413         if(name)
 414                 snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, name);
 415         else
 416                 snprintf(fname, sizeof fname, "%s" SLASH "ed25519_key.pub", confbase);
 417
 418         f = ask_and_open(fname, "public Ed25519 key", "a", ask, 0666);
 419
 420         if(!f)
 421                 return false;
 422
 423         char *pubkey = ecdsa_get_base64_public_key(key);
 424         fprintf(f, "Ed25519PublicKey = %s\n", pubkey);
 425         free(pubkey);
 426
 427         fclose(f);
 428         ecdsa_free(key);
 429
 430         return true;
 431
 432 error:
 433         if(f)
 434                 fclose(f);
 435         ecdsa_free(key);
 436         return false;
 437 }
 438
 439 #ifndef DISABLE_LEGACY
 440 /*
 441   Generate a public/private RSA keypair, and ask for a file to store
 442   them in.
 443 */
 444 static bool rsa_keygen(int bits, bool ask) {
 445         rsa_t *key;
 446         FILE *f;
 447         char fname[PATH_MAX];
 448
 449         // Make sure the key size is a multiple of 8 bits.
 450         bits &= ~0x7;
 451
 452         // Make sure that a valid key size is used.
 453         if(bits < 1024 || bits > 8192) {
 454                 fprintf(stderr, "Invalid key size %d specified! It should be between 1024 and 8192 bits.\n", bits);
 455                 return false;
 456         } else if(bits < 2048) {
 457                 fprintf(stderr, "WARNING: generating a weak %d bits RSA key! 2048 or more bits are recommended.\n", bits);
 458         }
 459
 460         fprintf(stderr, "Generating %d bits keys:\n", bits);
 461
 462         if(!(key = rsa_generate(bits, 0x10001))) {
 463                 fprintf(stderr, "Error during key generation!\n");
 464                 return false;
 465         } else
 466                 fprintf(stderr, "Done.\n");
 467
 468         snprintf(fname, sizeof fname, "%s" SLASH "rsa_key.priv", confbase);
 469         f = ask_and_open(fname, "private RSA key", "a", ask, 0600);
 470
 471         if(!f)
 472                 goto error;
 473
 474         if(!rsa_write_pem_private_key(key, f)) {
 475                 fprintf(stderr, "Error writing private key!\n");
 476                 goto error;
 477         }
 478
 479         fclose(f);
 480
 481         if(name)
 482                 snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, name);
 483         else
 484                 snprintf(fname, sizeof fname, "%s" SLASH "rsa_key.pub", confbase);
 485
 486         f = ask_and_open(fname, "public RSA key", "a", ask, 0666);
 487
 488         if(!f)
 489                 goto error;
 490
 491         if(!rsa_write_pem_public_key(key, f)) {
 492                 fprintf(stderr, "Error writing public key!\n");
 493                 goto error;
 494         }
 495
 496         fclose(f);
 497         rsa_free(key);
 498
 499         return true;
 500
 501 error:
 502         if(f)
 503                 fclose(f);
 504         rsa_free(key);
 505         return false;
 506 }
 507 #endif
 508
 509 char buffer[4096];
 510 size_t blen = 0;
 511
 512 bool recvline(int fd, char *line, size_t len) {
 513         char *newline = NULL;
 514
 515         if(!fd)
 516                 abort();
 517
 518         while(!(newline = memchr(buffer, '\n', blen))) {
 519                 int result = recv(fd, buffer + blen, sizeof buffer - blen, 0);
 520                 if(result == -1 && sockerrno == EINTR)
 521                         continue;
 522                 else if(result <= 0)
 523                         return false;
 524                 blen += result;
 525         }
 526
 527         if(newline - buffer >= len)
 528                 return false;
 529
 530         len = newline - buffer;
 531
 532         memcpy(line, buffer, len);
 533         line[len] = 0;
 534         memmove(buffer, newline + 1, blen - len - 1);
 535         blen -= len + 1;
 536
 537         return true;
 538 }
 539
 540 bool recvdata(int fd, char *data, size_t len) {
 541         if(len == -1)
 542                 len = blen;
 543
 544         while(blen < len) {
 545                 int result = recv(fd, buffer + blen, sizeof buffer - blen, 0);
 546                 if(result == -1 && sockerrno == EINTR)
 547                         continue;
 548                 else if(result <= 0)
 549                         return false;
 550                 blen += result;
 551         }
 552
 553         memcpy(data, buffer, len);
 554         memmove(buffer, buffer + len, blen - len);
 555         blen -= len;
 556
 557         return true;
 558 }
 559
 560 bool sendline(int fd, char *format, ...) {
 561         static char buffer[4096];
 562         char *p = buffer;
 563         int blen = 0;
 564         va_list ap;
 565
 566         va_start(ap, format);
 567         blen = vsnprintf(buffer, sizeof buffer, format, ap);
 568         buffer[sizeof buffer - 1] = 0;
 569         va_end(ap);
 570
 571         if(blen < 1 || blen >= sizeof buffer)
 572                 return false;
 573
 574         buffer[blen] = '\n';
 575         blen++;
 576
 577         while(blen) {
 578                 int result = send(fd, p, blen, MSG_NOSIGNAL);
 579                 if(result == -1 && sockerrno == EINTR)
 580                         continue;
 581                 else if(result <= 0)
 582                         return false;
 583                 p += result;
 584                 blen -= result;
 585         }
 586
 587         return true;
 588 }
 589
 590 static void pcap(int fd, FILE *out, int snaplen) {
 591         sendline(fd, "%d %d %d", CONTROL, REQ_PCAP, snaplen);
 592         char data[9018];
 593
 594         struct {
 595                 uint32_t magic;
 596                 uint16_t major;
 597                 uint16_t minor;
 598                 uint32_t tz_offset;
 599                 uint32_t tz_accuracy;
 600                 uint32_t snaplen;
 601                 uint32_t ll_type;
 602         } header = {
 603                 0xa1b2c3d4,
 604                 2, 4,
 605                 0, 0,
 606                 snaplen ?: sizeof data,
 607                 1,
 608         };
 609
 610         struct {
 611                 uint32_t tv_sec;
 612                 uint32_t tv_usec;
 613                 uint32_t len;
 614                 uint32_t origlen;
 615         } packet;
 616
 617         struct timeval tv;
 618
 619         fwrite(&header, sizeof header, 1, out);
 620         fflush(out);
 621
 622         char line[32];
 623         while(recvline(fd, line, sizeof line)) {
 624                 int code, req, len;
 625                 int n = sscanf(line, "%d %d %d", &code, &req, &len);
 626                 gettimeofday(&tv, NULL);
 627                 if(n != 3 || code != CONTROL || req != REQ_PCAP || len < 0 || len > sizeof data)
 628                         break;
 629                 if(!recvdata(fd, data, len))
 630                         break;
 631                 packet.tv_sec = tv.tv_sec;
 632                 packet.tv_usec = tv.tv_usec;
 633                 packet.len = len;
 634                 packet.origlen = len;
 635                 fwrite(&packet, sizeof packet, 1, out);
 636                 fwrite(data, len, 1, out);
 637                 fflush(out);
 638         }
 639 }
 640
 641 static void logcontrol(int fd, FILE *out, int level) {
 642         sendline(fd, "%d %d %d", CONTROL, REQ_LOG, level);
 643         char data[1024];
 644         char line[32];
 645
 646         while(recvline(fd, line, sizeof line)) {
 647                 int code, req, len;
 648                 int n = sscanf(line, "%d %d %d", &code, &req, &len);
 649                 if(n != 3 || code != CONTROL || req != REQ_LOG || len < 0 || len > sizeof data)
 650                         break;
 651                 if(!recvdata(fd, data, len))
 652                         break;
 653                 fwrite(data, len, 1, out);
 654                 fputc('\n', out);
 655                 fflush(out);
 656         }
 657 }
 658
 659 #ifdef HAVE_MINGW
 660 static bool remove_service(void) {
 661         SC_HANDLE manager = NULL;
 662         SC_HANDLE service = NULL;
 663         SERVICE_STATUS status = {0};
 664
 665         manager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
 666         if(!manager) {
 667                 fprintf(stderr, "Could not open service manager: %s\n", winerror(GetLastError()));
 668                 return false;
 669         }
 670
 671         service = OpenService(manager, identname, SERVICE_ALL_ACCESS);
 672
 673         if(!service) {
 674                 fprintf(stderr, "Could not open %s service: %s\n", identname, winerror(GetLastError()));
 675                 return false;
 676         }
 677
 678         if(!ControlService(service, SERVICE_CONTROL_STOP, &status))
 679                 fprintf(stderr, "Could not stop %s service: %s\n", identname, winerror(GetLastError()));
 680         else
 681                 fprintf(stderr, "%s service stopped\n", identname);
 682
 683         if(!DeleteService(service)) {
 684                 fprintf(stderr, "Could not remove %s service: %s\n", identname, winerror(GetLastError()));
 685                 return false;
 686         }
 687
 688         fprintf(stderr, "%s service removed\n", identname);
 689
 690         return true;
 691 }
 692 #endif
 693
 694 bool connect_tincd(bool verbose) {
 695         if(fd >= 0) {
 696                 fd_set r;
 697                 FD_ZERO(&r);
 698                 FD_SET(fd, &r);
 699                 struct timeval tv = {0, 0};
 700                 if(select(fd + 1, &r, NULL, NULL, &tv)) {
 701                         fprintf(stderr, "Previous connection to tincd lost, reconnecting.\n");
 702                         close(fd);
 703                         fd = -1;
 704                 } else {
 705                         return true;
 706                 }
 707         }
 708
 709         FILE *f = fopen(pidfilename, "r");
 710         if(!f) {
 711                 if(verbose)
 712                         fprintf(stderr, "Could not open pid file %s: %s\n", pidfilename, strerror(errno));
 713                 return false;
 714         }
 715
 716         char host[129];
 717         char port[129];
 718
 719         if(fscanf(f, "%20d %1024s %128s port %128s", &pid, controlcookie, host, port) != 4) {
 720                 if(verbose)
 721                         fprintf(stderr, "Could not parse pid file %s\n", pidfilename);
 722                 fclose(f);
 723                 return false;
 724         }
 725
 726         fclose(f);
 727
 728 #ifndef HAVE_MINGW
 729         if ((pid == 0) || (kill(pid, 0) && (errno == ESRCH))) {
 730                 fprintf(stderr, "Could not find tincd running at pid %d\n", pid);
 731                 /* clean up the stale socket and pid file */
 732                 unlink(pidfilename);
 733                 unlink(unixsocketname);
 734                 return false;
 735         }
 736
 737         struct sockaddr_un sa;
 738         sa.sun_family = AF_UNIX;
 739         strncpy(sa.sun_path, unixsocketname, sizeof sa.sun_path);
 740
 741         fd = socket(AF_UNIX, SOCK_STREAM, 0);
 742         if(fd < 0) {
 743                 if(verbose)
 744                         fprintf(stderr, "Cannot create UNIX socket: %s\n", sockstrerror(sockerrno));
 745                 return false;
 746         }
 747
 748         if(connect(fd, (struct sockaddr *)&sa, sizeof sa) < 0) {
 749                 if(verbose)
 750                         fprintf(stderr, "Cannot connect to UNIX socket %s: %s\n", unixsocketname, sockstrerror(sockerrno));
 751                 close(fd);
 752                 fd = -1;
 753                 return false;
 754         }
 755 #else
 756         struct addrinfo hints = {
 757                 .ai_family = AF_UNSPEC,
 758                 .ai_socktype = SOCK_STREAM,
 759                 .ai_protocol = IPPROTO_TCP,
 760                 .ai_flags = 0,
 761         };
 762
 763         struct addrinfo *res = NULL;
 764
 765         if(getaddrinfo(host, port, &hints, &res) || !res) {
 766                 if(verbose)
 767                         fprintf(stderr, "Cannot resolve %s port %s: %s", host, port, sockstrerror(sockerrno));
 768                 return false;
 769         }
 770
 771         fd = socket(res->ai_family, SOCK_STREAM, IPPROTO_TCP);
 772         if(fd < 0) {
 773                 if(verbose)
 774                         fprintf(stderr, "Cannot create TCP socket: %s\n", sockstrerror(sockerrno));
 775                 return false;
 776         }
 777
 778 #ifdef HAVE_MINGW
 779         unsigned long arg = 0;
 780
 781         if(ioctlsocket(fd, FIONBIO, &arg) != 0) {
 782                 if(verbose)
 783                         fprintf(stderr, "ioctlsocket failed: %s", sockstrerror(sockerrno));
 784         }
 785 #endif
 786
 787         if(connect(fd, res->ai_addr, res->ai_addrlen) < 0) {
 788                 if(verbose)
 789                         fprintf(stderr, "Cannot connect to %s port %s: %s\n", host, port, sockstrerror(sockerrno));
 790                 close(fd);
 791                 fd = -1;
 792                 return false;
 793         }
 794
 795         freeaddrinfo(res);
 796 #endif
 797
 798 #ifdef SO_NOSIGPIPE
 799         static const int one = 1;
 800         setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&one, sizeof one);
 801 #endif
 802
 803         char data[4096];
 804         int version;
 805
 806         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %4095s %d", &code, data, &version) != 3 || code != 0) {
 807                 if(verbose)
 808                         fprintf(stderr, "Cannot read greeting from control socket: %s\n", sockstrerror(sockerrno));
 809                 close(fd);
 810                 fd = -1;
 811                 return false;
 812         }
 813
 814         sendline(fd, "%d ^%s %d", ID, controlcookie, TINC_CTL_VERSION_CURRENT);
 815
 816         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &version, &pid) != 3 || code != 4 || version != TINC_CTL_VERSION_CURRENT) {
 817                 if(verbose)
 818                         fprintf(stderr, "Could not fully establish control socket connection\n");
 819                 close(fd);
 820                 fd = -1;
 821                 return false;
 822         }
 823
 824         return true;
 825 }
 826
 827
 828 static int cmd_start(int argc, char *argv[]) {
 829         if(connect_tincd(false)) {
 830                 if(netname)
 831                         fprintf(stderr, "A tincd is already running for net `%s' with pid %d.\n", netname, pid);
 832                 else
 833                         fprintf(stderr, "A tincd is already running with pid %d.\n", pid);
 834                 return 0;
 835         }
 836
 837         char *c;
 838         char *slash = strrchr(program_name, '/');
 839
 840 #ifdef HAVE_MINGW
 841         if ((c = strrchr(program_name, '\\')) > slash)
 842                 slash = c;
 843 #endif
 844
 845         if (slash++)
 846                 xasprintf(&c, "%.*stincd", (int)(slash - program_name), program_name);
 847         else
 848                 c = "tincd";
 849
 850         int nargc = 0;
 851         char **nargv = xzalloc((optind + argc) * sizeof *nargv);
 852
 853         char *arg0 = c;
 854 #ifdef HAVE_MINGW
 855         /*
 856            Windows has no real concept of an "argv array". A command line is just one string.
 857            The CRT of the new process will decode the command line string to generate argv before calling main(), and (by convention)
 858            it uses quotes to handle spaces in arguments.
 859            Therefore we need to quote all arguments that might contain spaces. No, execvp() won't do that for us (see MSDN).
 860            If we don't do that, then execvp() will run fine but any spaces in the filename contained in arg0 will bleed
 861            into the next arguments when the spawned process' CRT parses its command line, resulting in chaos.
 862         */
 863         xasprintf(&arg0, "\"%s\"", arg0);
 864 #endif
 865         nargv[nargc++] = arg0;
 866         for(int i = 1; i < optind; i++)
 867                 nargv[nargc++] = orig_argv[i];
 868         for(int i = 1; i < argc; i++)
 869                 nargv[nargc++] = argv[i];
 870
 871 #ifdef HAVE_MINGW
 872         int status = spawnvp(_P_WAIT, c, nargv);
 873         if (status == -1) {
 874                 fprintf(stderr, "Error starting %s: %s\n", c, strerror(errno));
 875                 return 1;
 876         }
 877         return status;
 878 #else
 879         int pfd[2] = {-1, -1};
 880         if(socketpair(AF_UNIX, SOCK_STREAM, 0, pfd)) {
 881                 fprintf(stderr, "Could not create umbilical socket: %s\n", strerror(errno));
 882                 free(nargv);
 883                 return 1;
 884         }
 885
 886         pid_t pid = fork();
 887         if(pid == -1) {
 888                 fprintf(stderr, "Could not fork: %s\n", strerror(errno));
 889                 free(nargv);
 890                 return 1;
 891         }
 892
 893         if(!pid) {
 894                 close(pfd[0]);
 895                 char buf[100];
 896                 snprintf(buf, sizeof buf, "%d", pfd[1]);
 897                 setenv("TINC_UMBILICAL", buf, true);
 898                 exit(execvp(c, nargv));
 899         } else {
 900                 close(pfd[1]);
 901         }
 902
 903         free(nargv);
 904
 905         int status = -1, result;
 906 #ifdef SIGINT
 907         signal(SIGINT, SIG_IGN);
 908 #endif
 909
 910         // Pass all log messages from the umbilical to stderr.
 911         // A nul-byte right before closure means tincd started succesfully.
 912         bool failure = true;
 913         char buf[1024];
 914         ssize_t len;
 915
 916         while((len = read(pfd[0], buf, sizeof buf)) > 0) {
 917                 failure = buf[len - 1];
 918                 if(!failure)
 919                         len--;
 920                 write(2, buf, len);
 921         }
 922
 923         if(len)
 924                 failure = true;
 925
 926         close(pfd[0]);
 927
 928         // Make sure the child process is really gone.
 929         result = waitpid(pid, &status, 0);
 930
 931 #ifdef SIGINT
 932         signal(SIGINT, SIG_DFL);
 933 #endif
 934
 935         if(failure || result != pid || !WIFEXITED(status) || WEXITSTATUS(status)) {
 936                 fprintf(stderr, "Error starting %s\n", c);
 937                 return 1;
 938         }
 939
 940         return 0;
 941 #endif
 942 }
 943
 944 static int cmd_stop(int argc, char *argv[]) {
 945         if(argc > 1) {
 946                 fprintf(stderr, "Too many arguments!\n");
 947                 return 1;
 948         }
 949
 950 #ifndef HAVE_MINGW
 951         if(!connect_tincd(true)) {
 952                 if(pid) {
 953                         if(kill(pid, SIGTERM)) {
 954                                 fprintf(stderr, "Could not send TERM signal to process with PID %u: %s\n", pid, strerror(errno));
 955                                 return 1;
 956                         }
 957
 958                         fprintf(stderr, "Sent TERM signal to process with PID %u.\n", pid);
 959                         waitpid(pid, NULL, 0);
 960                         return 0;
 961                 }
 962
 963                 return 1;
 964         }
 965
 966         sendline(fd, "%d %d", CONTROL, REQ_STOP);
 967
 968         while(recvline(fd, line, sizeof line)) {
 969                 // Wait for tincd to close the connection...
 970         }
 971 #else
 972         if(!remove_service())
 973                 return 1;
 974 #endif
 975         close(fd);
 976         pid = 0;
 977         fd = -1;
 978
 979         return 0;
 980 }
 981
 982 static int cmd_restart(int argc, char *argv[]) {
 983         cmd_stop(1, argv);
 984         return cmd_start(argc, argv);
 985 }
 986
 987 static int cmd_reload(int argc, char *argv[]) {
 988         if(argc > 1) {
 989                 fprintf(stderr, "Too many arguments!\n");
 990                 return 1;
 991         }
 992
 993         if(!connect_tincd(true))
 994                 return 1;
 995
 996         sendline(fd, "%d %d", CONTROL, REQ_RELOAD);
 997         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_RELOAD || result) {
 998                 fprintf(stderr, "Could not reload configuration.\n");
 999                 return 1;
1000         }
1001
1002         return 0;
1003
1004 }
1005
1006 static int dump_invitations(void) {
1007         char dname[PATH_MAX];
1008         snprintf(dname, sizeof dname, "%s" SLASH "invitations", confbase);
1009         DIR *dir = opendir(dname);
1010         if(!dir) {
1011                 if(errno == ENOENT) {
1012                         fprintf(stderr, "No outstanding invitations.\n");
1013                         return 0;
1014                 }
1015
1016                 fprintf(stderr, "Cannot not read directory %s: %s\n", dname, strerror(errno));
1017                 return 1;
1018         }
1019
1020         struct dirent *ent;
1021         bool found = false;
1022
1023         while((ent = readdir(dir))) {
1024                 char buf[MAX_STRING_SIZE];
1025                 if(b64decode(ent->d_name, buf, 24) != 18)
1026                         continue;
1027
1028                 char fname[PATH_MAX];
1029                 snprintf(fname, sizeof fname, "%s" SLASH "%s", dname, ent->d_name);
1030                 FILE *f = fopen(fname, "r");
1031                 if(!f) {
1032                         fprintf(stderr, "Cannot open %s: %s\n", fname, strerror(errno));
1033                         fclose(f);
1034                         continue;
1035                 }
1036
1037                 buf[0] = 0;
1038                 if(!fgets(buf, sizeof buf, f)) {
1039                         fprintf(stderr, "Invalid invitation file %s", fname);
1040                         fclose(f);
1041                         continue;
1042                 }
1043                 fclose(f);
1044
1045                 char *eol = buf + strlen(buf);
1046                 while(strchr("\t \r\n", *--eol))
1047                         *eol = 0;
1048                 if(strncmp(buf, "Name = ", 7) || !check_id(buf + 7)) {
1049                         fprintf(stderr, "Invalid invitation file %s", fname);
1050                         continue;
1051                 }
1052
1053                 found = true;
1054                 printf("%s %s\n", ent->d_name, buf + 7);
1055         }
1056
1057         closedir(dir);
1058
1059         if(!found)
1060                 fprintf(stderr, "No outstanding invitations.\n");
1061
1062         return 0;
1063 }
1064
1065 static int cmd_dump(int argc, char *argv[]) {
1066         bool only_reachable = false;
1067
1068         if(argc > 2 && !strcasecmp(argv[1], "reachable")) {
1069                 if(strcasecmp(argv[2], "nodes")) {
1070                         fprintf(stderr, "`reachable' only supported for nodes.\n");
1071                         usage(true);
1072                         return 1;
1073                 }
1074                 only_reachable = true;
1075                 argv++;
1076                 argc--;
1077         }
1078
1079         if(argc != 2) {
1080                 fprintf(stderr, "Invalid number of arguments.\n");
1081                 usage(true);
1082                 return 1;
1083         }
1084
1085         if(!strcasecmp(argv[1], "invitations"))
1086                 return dump_invitations();
1087
1088         if(!connect_tincd(true))
1089                 return 1;
1090
1091         int do_graph = 0;
1092
1093         if(!strcasecmp(argv[1], "nodes"))
1094                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_NODES);
1095         else if(!strcasecmp(argv[1], "edges"))
1096                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_EDGES);
1097         else if(!strcasecmp(argv[1], "subnets"))
1098                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_SUBNETS);
1099         else if(!strcasecmp(argv[1], "connections"))
1100                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_CONNECTIONS);
1101         else if(!strcasecmp(argv[1], "graph")) {
1102                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_NODES);
1103                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_EDGES);
1104                 do_graph = 1;
1105         } else if(!strcasecmp(argv[1], "digraph")) {
1106                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_NODES);
1107                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_EDGES);
1108                 do_graph = 2;
1109         } else {
1110                 fprintf(stderr, "Unknown dump type '%s'.\n", argv[1]);
1111                 usage(true);
1112                 return 1;
1113         }
1114
1115         if(do_graph == 1)
1116                 printf("graph {\n");
1117         else if(do_graph == 2)
1118                 printf("digraph {\n");
1119
1120         while(recvline(fd, line, sizeof line)) {
1121                 char node1[4096], node2[4096];
1122                 int n = sscanf(line, "%d %d %4095s %4095s", &code, &req, node1, node2);
1123                 if(n == 2) {
1124                         if(do_graph && req == REQ_DUMP_NODES)
1125                                 continue;
1126                         else {
1127                                 if(do_graph)
1128                                         printf("}\n");
1129                                 return 0;
1130                         }
1131                 }
1132                 if(n < 2)
1133                         break;
1134
1135                 char node[4096];
1136                 char id[4096];
1137                 char from[4096];
1138                 char to[4096];
1139                 char subnet[4096];
1140                 char host[4096];
1141                 char port[4096];
1142                 char local_host[4096];
1143                 char local_port[4096];
1144                 char via[4096];
1145                 char nexthop[4096];
1146                 int cipher, digest, maclength, compression, distance, socket, weight;
1147                 short int pmtu, minmtu, maxmtu;
1148                 unsigned int options, status_int;
1149                 node_status_t status;
1150                 long int last_state_change;
1151
1152                 switch(req) {
1153                         case REQ_DUMP_NODES: {
1154                                 int n = sscanf(line, "%*d %*d %4095s %4095s %4095s port %4095s %d %d %d %d %x %x %4095s %4095s %d %hd %hd %hd %ld", node, id, host, port, &cipher, &digest, &maclength, &compression, &options, &status_int, nexthop, via, &distance, &pmtu, &minmtu, &maxmtu, &last_state_change);
1155                                 if(n != 17) {
1156                                         fprintf(stderr, "Unable to parse node dump from tincd: %s\n", line);
1157                                         return 1;
1158                                 }
1159
1160                                 memcpy(&status, &status_int, sizeof status);
1161
1162                                 if(do_graph) {
1163                                         const char *color = "black";
1164                                         if(!strcmp(host, "MYSELF"))
1165                                                 color = "green";
1166                                         else if(!status.reachable)
1167                                                 color = "red";
1168                                         else if(strcmp(via, node))
1169                                                 color = "orange";
1170                                         else if(!status.validkey)
1171                                                 color = "black";
1172                                         else if(minmtu > 0)
1173                                                 color = "green";
1174                                         printf(" %s [label = \"%s\", color = \"%s\"%s];\n", node, node, color, strcmp(host, "MYSELF") ? "" : ", style = \"filled\"");
1175                                 } else {
1176                                         if(only_reachable && !status.reachable)
1177                                                 continue;
1178                                         printf("%s id %s at %s port %s cipher %d digest %d maclength %d compression %d options %x status %04x nexthop %s via %s distance %d pmtu %hd (min %hd max %hd)\n",
1179                                                         node, id, host, port, cipher, digest, maclength, compression, options, status_int, nexthop, via, distance, pmtu, minmtu, maxmtu);
1180                                 }
1181                         } break;
1182
1183                         case REQ_DUMP_EDGES: {
1184                                 int n = sscanf(line, "%*d %*d %4095s %4095s %4095s port %4095s %4095s port %4095s %x %d", from, to, host, port, local_host, local_port, &options, &weight);
1185                                 if(n != 8) {
1186                                         fprintf(stderr, "Unable to parse edge dump from tincd.\n");
1187                                         return 1;
1188                                 }
1189
1190                                 if(do_graph) {
1191                                         float w = 1 + 65536.0 / weight;
1192                                         if(do_graph == 1 && strcmp(node1, node2) > 0)
1193                                                 printf(" %s -- %s [w = %f, weight = %f];\n", node1, node2, w, w);
1194                                         else if(do_graph == 2)
1195                                                 printf(" %s -> %s [w = %f, weight = %f];\n", node1, node2, w, w);
1196                                 } else {
1197                                         printf("%s to %s at %s port %s local %s port %s options %x weight %d\n", from, to, host, port, local_host, local_port, options, weight);
1198                                 }
1199                         } break;
1200
1201                         case REQ_DUMP_SUBNETS: {
1202                                 int n = sscanf(line, "%*d %*d %4095s %4095s", subnet, node);
1203                                 if(n != 2) {
1204                                         fprintf(stderr, "Unable to parse subnet dump from tincd.\n");
1205                                         return 1;
1206                                 }
1207                                 printf("%s owner %s\n", strip_weight(subnet), node);
1208                         } break;
1209
1210                         case REQ_DUMP_CONNECTIONS: {
1211                                 int n = sscanf(line, "%*d %*d %4095s %4095s port %4095s %x %d %x", node, host, port, &options, &socket, &status_int);
1212                                 if(n != 6) {
1213                                         fprintf(stderr, "Unable to parse connection dump from tincd.\n");
1214                                         return 1;
1215                                 }
1216                                 printf("%s at %s port %s options %x socket %d status %x\n", node, host, port, options, socket, status_int);
1217                         } break;
1218
1219                         default:
1220                                 fprintf(stderr, "Unable to parse dump from tincd.\n");
1221                                 return 1;
1222                 }
1223         }
1224
1225         fprintf(stderr, "Error receiving dump.\n");
1226         return 1;
1227 }
1228
1229 static int cmd_purge(int argc, char *argv[]) {
1230         if(argc > 1) {
1231                 fprintf(stderr, "Too many arguments!\n");
1232                 return 1;
1233         }
1234
1235         if(!connect_tincd(true))
1236                 return 1;
1237
1238         sendline(fd, "%d %d", CONTROL, REQ_PURGE);
1239         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_PURGE || result) {
1240                 fprintf(stderr, "Could not purge old information.\n");
1241                 return 1;
1242         }
1243
1244         return 0;
1245 }
1246
1247 static int cmd_debug(int argc, char *argv[]) {
1248         if(argc != 2) {
1249                 fprintf(stderr, "Invalid number of arguments.\n");
1250                 return 1;
1251         }
1252
1253         if(!connect_tincd(true))
1254                 return 1;
1255
1256         int debuglevel = atoi(argv[1]);
1257         int origlevel;
1258
1259         sendline(fd, "%d %d %d", CONTROL, REQ_SET_DEBUG, debuglevel);
1260         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &origlevel) != 3 || code != CONTROL || req != REQ_SET_DEBUG) {
1261                 fprintf(stderr, "Could not set debug level.\n");
1262                 return 1;
1263         }
1264
1265         fprintf(stderr, "Old level %d, new level %d.\n", origlevel, debuglevel);
1266         return 0;
1267 }
1268
1269 static int cmd_retry(int argc, char *argv[]) {
1270         if(argc > 1) {
1271                 fprintf(stderr, "Too many arguments!\n");
1272                 return 1;
1273         }
1274
1275         if(!connect_tincd(true))
1276                 return 1;
1277
1278         sendline(fd, "%d %d", CONTROL, REQ_RETRY);
1279         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_RETRY || result) {
1280                 fprintf(stderr, "Could not retry outgoing connections.\n");
1281                 return 1;
1282         }
1283
1284         return 0;
1285 }
1286
1287 static int cmd_connect(int argc, char *argv[]) {
1288         if(argc != 2) {
1289                 fprintf(stderr, "Invalid number of arguments.\n");
1290                 return 1;
1291         }
1292
1293         if(!check_id(argv[1])) {
1294                 fprintf(stderr, "Invalid name for node.\n");
1295                 return 1;
1296         }
1297
1298         if(!connect_tincd(true))
1299                 return 1;
1300
1301         sendline(fd, "%d %d %s", CONTROL, REQ_CONNECT, argv[1]);
1302         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_CONNECT || result) {
1303                 fprintf(stderr, "Could not connect to %s.\n", argv[1]);
1304                 return 1;
1305         }
1306
1307         return 0;
1308 }
1309
1310 static int cmd_disconnect(int argc, char *argv[]) {
1311         if(argc != 2) {
1312                 fprintf(stderr, "Invalid number of arguments.\n");
1313                 return 1;
1314         }
1315
1316         if(!check_id(argv[1])) {
1317                 fprintf(stderr, "Invalid name for node.\n");
1318                 return 1;
1319         }
1320
1321         if(!connect_tincd(true))
1322                 return 1;
1323
1324         sendline(fd, "%d %d %s", CONTROL, REQ_DISCONNECT, argv[1]);
1325         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_DISCONNECT || result) {
1326                 fprintf(stderr, "Could not disconnect %s.\n", argv[1]);
1327                 return 1;
1328         }
1329
1330         return 0;
1331 }
1332
1333 static int cmd_top(int argc, char *argv[]) {
1334         if(argc > 1) {
1335                 fprintf(stderr, "Too many arguments!\n");
1336                 return 1;
1337         }
1338
1339 #ifdef HAVE_CURSES
1340         if(!connect_tincd(true))
1341                 return 1;
1342
1343         top(fd);
1344         return 0;
1345 #else
1346         fprintf(stderr, "This version of tinc was compiled without support for the curses library.\n");
1347         return 1;
1348 #endif
1349 }
1350
1351 static int cmd_pcap(int argc, char *argv[]) {
1352         if(argc > 2) {
1353                 fprintf(stderr, "Too many arguments!\n");
1354                 return 1;
1355         }
1356
1357         if(!connect_tincd(true))
1358                 return 1;
1359
1360         pcap(fd, stdout, argc > 1 ? atoi(argv[1]) : 0);
1361         return 0;
1362 }
1363
1364 #ifdef SIGINT
1365 static void sigint_handler(int sig) {
1366         fprintf(stderr, "\n");
1367         shutdown(fd, SHUT_RDWR);
1368 }
1369 #endif
1370
1371 static int cmd_log(int argc, char *argv[]) {
1372         if(argc > 2) {
1373                 fprintf(stderr, "Too many arguments!\n");
1374                 return 1;
1375         }
1376
1377         if(!connect_tincd(true))
1378                 return 1;
1379
1380 #ifdef SIGINT
1381         signal(SIGINT, sigint_handler);
1382 #endif
1383
1384         logcontrol(fd, stdout, argc > 1 ? atoi(argv[1]) : -1);
1385
1386 #ifdef SIGINT
1387         signal(SIGINT, SIG_DFL);
1388 #endif
1389
1390         close(fd);
1391         fd = -1;
1392         return 0;
1393 }
1394
1395 static int cmd_pid(int argc, char *argv[]) {
1396         if(argc > 1) {
1397                 fprintf(stderr, "Too many arguments!\n");
1398                 return 1;
1399         }
1400
1401         if(!connect_tincd(true) || !pid)
1402                 return 1;
1403
1404         printf("%d\n", pid);
1405         return 0;
1406 }
1407
1408 int rstrip(char *value) {
1409         int len = strlen(value);
1410         while(len && strchr("\t\r\n ", value[len - 1]))
1411                 value[--len] = 0;
1412         return len;
1413 }
1414
1415 char *get_my_name(bool verbose) {
1416         FILE *f = fopen(tinc_conf, "r");
1417         if(!f) {
1418                 if(verbose)
1419                         fprintf(stderr, "Could not open %s: %s\n", tinc_conf, strerror(errno));
1420                 return NULL;
1421         }
1422
1423         char buf[4096];
1424         char *value;
1425         while(fgets(buf, sizeof buf, f)) {
1426                 int len = strcspn(buf, "\t =");
1427                 value = buf + len;
1428                 value += strspn(value, "\t ");
1429                 if(*value == '=') {
1430                         value++;
1431                         value += strspn(value, "\t ");
1432                 }
1433                 if(!rstrip(value))
1434                         continue;
1435                 buf[len] = 0;
1436                 if(strcasecmp(buf, "Name"))
1437                         continue;
1438                 if(*value) {
1439                         fclose(f);
1440                         return replace_name(value);
1441                 }
1442         }
1443
1444         fclose(f);
1445         if(verbose)
1446                 fprintf(stderr, "Could not find Name in %s.\n", tinc_conf);
1447         return NULL;
1448 }
1449
1450 ecdsa_t *get_pubkey(FILE *f) {
1451         char buf[4096];
1452         char *value;
1453         while(fgets(buf, sizeof buf, f)) {
1454                 int len = strcspn(buf, "\t =");
1455                 value = buf + len;
1456                 value += strspn(value, "\t ");
1457                 if(*value == '=') {
1458                         value++;
1459                         value += strspn(value, "\t ");
1460                 }
1461                 if(!rstrip(value))
1462                         continue;
1463                 buf[len] = 0;
1464                 if(strcasecmp(buf, "Ed25519PublicKey"))
1465                         continue;
1466                 if(*value)
1467                         return ecdsa_set_base64_public_key(value);
1468         }
1469
1470         return NULL;
1471 }
1472
1473 const var_t variables[] = {
1474         /* Server configuration */
1475         {"AddressFamily", VAR_SERVER},
1476         {"AutoConnect", VAR_SERVER | VAR_SAFE},
1477         {"BindToAddress", VAR_SERVER | VAR_MULTIPLE},
1478         {"BindToInterface", VAR_SERVER},
1479         {"Broadcast", VAR_SERVER | VAR_SAFE},
1480         {"BroadcastSubnet", VAR_SERVER | VAR_MULTIPLE | VAR_SAFE},
1481         {"ConnectTo", VAR_SERVER | VAR_MULTIPLE | VAR_SAFE},
1482         {"DecrementTTL", VAR_SERVER},
1483         {"Device", VAR_SERVER},
1484         {"DeviceStandby", VAR_SERVER},
1485         {"DeviceType", VAR_SERVER},
1486         {"DirectOnly", VAR_SERVER},
1487         {"Ed25519PrivateKeyFile", VAR_SERVER},
1488         {"ExperimentalProtocol", VAR_SERVER},
1489         {"Forwarding", VAR_SERVER},
1490         {"GraphDumpFile", VAR_SERVER | VAR_OBSOLETE},
1491         {"Hostnames", VAR_SERVER},
1492         {"IffOneQueue", VAR_SERVER},
1493         {"Interface", VAR_SERVER},
1494         {"KeyExpire", VAR_SERVER},
1495         {"ListenAddress", VAR_SERVER | VAR_MULTIPLE},
1496         {"LocalDiscovery", VAR_SERVER},
1497         {"MACExpire", VAR_SERVER},
1498         {"MaxConnectionBurst", VAR_SERVER},
1499         {"MaxOutputBufferSize", VAR_SERVER},
1500         {"MaxTimeout", VAR_SERVER},
1501         {"Mode", VAR_SERVER | VAR_SAFE},
1502         {"Name", VAR_SERVER},
1503         {"PingInterval", VAR_SERVER},
1504         {"PingTimeout", VAR_SERVER},
1505         {"PriorityInheritance", VAR_SERVER},
1506         {"PrivateKey", VAR_SERVER | VAR_OBSOLETE},
1507         {"PrivateKeyFile", VAR_SERVER},
1508         {"ProcessPriority", VAR_SERVER},
1509         {"Proxy", VAR_SERVER},
1510         {"ReplayWindow", VAR_SERVER},
1511         {"ScriptsExtension", VAR_SERVER},
1512         {"ScriptsInterpreter", VAR_SERVER},
1513         {"StrictSubnets", VAR_SERVER},
1514         {"TunnelServer", VAR_SERVER},
1515         {"UDPDiscovery", VAR_SERVER},
1516         {"UDPDiscoveryKeepaliveInterval", VAR_SERVER},
1517         {"UDPDiscoveryInterval", VAR_SERVER},
1518         {"UDPDiscoveryTimeout", VAR_SERVER},
1519         {"MTUInfoInterval", VAR_SERVER},
1520         {"UDPInfoInterval", VAR_SERVER},
1521         {"UDPRcvBuf", VAR_SERVER},
1522         {"UDPSndBuf", VAR_SERVER},
1523         {"UPnP", VAR_SERVER},
1524         {"UPnPDiscoverWait", VAR_SERVER},
1525         {"UPnPRefreshPeriod", VAR_SERVER},
1526         {"VDEGroup", VAR_SERVER},
1527         {"VDEPort", VAR_SERVER},
1528         /* Host configuration */
1529         {"Address", VAR_HOST | VAR_MULTIPLE},
1530         {"Cipher", VAR_SERVER | VAR_HOST},
1531         {"ClampMSS", VAR_SERVER | VAR_HOST},
1532         {"Compression", VAR_SERVER | VAR_HOST},
1533         {"Digest", VAR_SERVER | VAR_HOST},
1534         {"Ed25519PublicKey", VAR_HOST},
1535         {"Ed25519PublicKeyFile", VAR_SERVER | VAR_HOST},
1536         {"IndirectData", VAR_SERVER | VAR_HOST},
1537         {"MACLength", VAR_SERVER | VAR_HOST},
1538         {"PMTU", VAR_SERVER | VAR_HOST},
1539         {"PMTUDiscovery", VAR_SERVER | VAR_HOST},
1540         {"Port", VAR_HOST},
1541         {"PublicKey", VAR_HOST | VAR_OBSOLETE},
1542         {"PublicKeyFile", VAR_SERVER | VAR_HOST | VAR_OBSOLETE},
1543         {"Subnet", VAR_HOST | VAR_MULTIPLE | VAR_SAFE},
1544         {"TCPOnly", VAR_SERVER | VAR_HOST},
1545         {"Weight", VAR_HOST | VAR_SAFE},
1546         {NULL, 0}
1547 };
1548
1549 static int cmd_config(int argc, char *argv[]) {
1550         if(argc < 2) {
1551                 fprintf(stderr, "Invalid number of arguments.\n");
1552                 return 1;
1553         }
1554
1555         if(strcasecmp(argv[0], "config"))
1556                 argv--, argc++;
1557
1558         int action = -2;
1559         if(!strcasecmp(argv[1], "get")) {
1560                 argv++, argc--;
1561         } else if(!strcasecmp(argv[1], "add")) {
1562                 argv++, argc--, action = 1;
1563         } else if(!strcasecmp(argv[1], "del")) {
1564                 argv++, argc--, action = -1;
1565         } else if(!strcasecmp(argv[1], "replace") || !strcasecmp(argv[1], "set") || !strcasecmp(argv[1], "change")) {
1566                 argv++, argc--, action = 0;
1567         }
1568
1569         if(argc < 2) {
1570                 fprintf(stderr, "Invalid number of arguments.\n");
1571                 return 1;
1572         }
1573
1574         // Concatenate the rest of the command line
1575         strncpy(line, argv[1], sizeof line - 1);
1576         for(int i = 2; i < argc; i++) {
1577                 strncat(line, " ", sizeof line - 1 - strlen(line));
1578                 strncat(line, argv[i], sizeof line - 1 - strlen(line));
1579         }
1580
1581         // Liberal parsing into node name, variable name and value.
1582         char *node = NULL;
1583         char *variable;
1584         char *value;
1585         int len;
1586
1587         len = strcspn(line, "\t =");
1588         value = line + len;
1589         value += strspn(value, "\t ");
1590         if(*value == '=') {
1591                 value++;
1592                 value += strspn(value, "\t ");
1593         }
1594         line[len] = '\0';
1595         variable = strchr(line, '.');
1596         if(variable) {
1597                 node = line;
1598                 *variable++ = 0;
1599         } else {
1600                 variable = line;
1601         }
1602
1603         if(!*variable) {
1604                 fprintf(stderr, "No variable given.\n");
1605                 return 1;
1606         }
1607
1608         if(action >= 0 && !*value) {
1609                 fprintf(stderr, "No value for variable given.\n");
1610                 return 1;
1611         }
1612
1613         if(action < -1 && *value)
1614                 action = 0;
1615
1616         /* Some simple checks. */
1617         bool found = false;
1618         bool warnonremove = false;
1619
1620         for(int i = 0; variables[i].name; i++) {
1621                 if(strcasecmp(variables[i].name, variable))
1622                         continue;
1623
1624                 found = true;
1625                 variable = (char *)variables[i].name;
1626
1627                 /* Discourage use of obsolete variables. */
1628
1629                 if(variables[i].type & VAR_OBSOLETE && action >= 0) {
1630                         if(force) {
1631                                 fprintf(stderr, "Warning: %s is an obsolete variable!\n", variable);
1632                         } else {
1633                                 fprintf(stderr, "%s is an obsolete variable! Use --force to use it anyway.\n", variable);
1634                                 return 1;
1635                         }
1636                 }
1637
1638                 /* Don't put server variables in host config files */
1639
1640                 if(node && !(variables[i].type & VAR_HOST) && action >= 0) {
1641                         if(force) {
1642                                 fprintf(stderr, "Warning: %s is not a host configuration variable!\n", variable);
1643                         } else {
1644                                 fprintf(stderr, "%s is not a host configuration variable! Use --force to use it anyway.\n", variable);
1645                                 return 1;
1646                         }
1647                 }
1648
1649                 /* Should this go into our own host config file? */
1650
1651                 if(!node && !(variables[i].type & VAR_SERVER)) {
1652                         node = get_my_name(true);
1653                         if(!node)
1654                                 return 1;
1655                 }
1656
1657                 /* Change "add" into "set" for variables that do not allow multiple occurences.
1658                    Turn on warnings when it seems variables might be removed unintentionally. */
1659
1660                 if(action == 1 && !(variables[i].type & VAR_MULTIPLE)) {
1661                         warnonremove = true;
1662                         action = 0;
1663                 } else if(action == 0 && (variables[i].type & VAR_MULTIPLE)) {
1664                         warnonremove = true;
1665                 }
1666
1667                 break;
1668         }
1669
1670         if(node && !check_id(node)) {
1671                 fprintf(stderr, "Invalid name for node.\n");
1672                 return 1;
1673         }
1674
1675         if(!found) {
1676                 if(force || action < 0) {
1677                         fprintf(stderr, "Warning: %s is not a known configuration variable!\n", variable);
1678                 } else {
1679                         fprintf(stderr, "%s: is not a known configuration variable! Use --force to use it anyway.\n", variable);
1680                         return 1;
1681                 }
1682         }
1683
1684         // Open the right configuration file.
1685         char filename[PATH_MAX];
1686         if(node)
1687                 snprintf(filename, sizeof filename, "%s" SLASH "%s", hosts_dir, node);
1688         else
1689                 snprintf(filename, sizeof filename, "%s", tinc_conf);
1690
1691         FILE *f = fopen(filename, "r");
1692         if(!f) {
1693                 fprintf(stderr, "Could not open configuration file %s: %s\n", filename, strerror(errno));
1694                 return 1;
1695         }
1696
1697         char tmpfile[PATH_MAX];
1698         FILE *tf = NULL;
1699
1700         if(action >= -1) {
1701                 snprintf(tmpfile, sizeof tmpfile, "%s.config.tmp", filename);
1702                 tf = fopen(tmpfile, "w");
1703                 if(!tf) {
1704                         fprintf(stderr, "Could not open temporary file %s: %s\n", tmpfile, strerror(errno));
1705                         fclose(f);
1706                         return 1;
1707                 }
1708         }
1709
1710         // Copy the file, making modifications on the fly, unless we are just getting a value.
1711         char buf1[4096];
1712         char buf2[4096];
1713         bool set = false;
1714         bool removed = false;
1715         found = false;
1716
1717         while(fgets(buf1, sizeof buf1, f)) {
1718                 buf1[sizeof buf1 - 1] = 0;
1719                 strncpy(buf2, buf1, sizeof buf2);
1720
1721                 // Parse line in a simple way
1722                 char *bvalue;
1723                 int len;
1724
1725                 len = strcspn(buf2, "\t =");
1726                 bvalue = buf2 + len;
1727                 bvalue += strspn(bvalue, "\t ");
1728                 if(*bvalue == '=') {
1729                         bvalue++;
1730                         bvalue += strspn(bvalue, "\t ");
1731                 }
1732                 rstrip(bvalue);
1733                 buf2[len] = '\0';
1734
1735                 // Did it match?
1736                 if(!strcasecmp(buf2, variable)) {
1737                         // Get
1738                         if(action < -1) {
1739                                 found = true;
1740                                 printf("%s\n", bvalue);
1741                         // Del
1742                         } else if(action == -1) {
1743                                 if(!*value || !strcasecmp(bvalue, value)) {
1744                                         removed = true;
1745                                         continue;
1746                                 }
1747                         // Set
1748                         } else if(action == 0) {
1749                                 // Warn if "set" was used for variables that can occur multiple times
1750                                 if(warnonremove && strcasecmp(bvalue, value))
1751                                         fprintf(stderr, "Warning: removing %s = %s\n", variable, bvalue);
1752
1753                                 // Already set? Delete the rest...
1754                                 if(set)
1755                                         continue;
1756
1757                                 // Otherwise, replace.
1758                                 if(fprintf(tf, "%s = %s\n", variable, value) < 0) {
1759                                         fprintf(stderr, "Error writing to temporary file %s: %s\n", tmpfile, strerror(errno));
1760                                         return 1;
1761                                 }
1762                                 set = true;
1763                                 continue;
1764                         // Add
1765                         } else if(action > 0) {
1766                                 // Check if we've already seen this variable with the same value
1767                                 if(!strcasecmp(bvalue, value))
1768                                         found = true;
1769                         }
1770                 }
1771
1772                 if(action >= -1) {
1773                         // Copy original line...
1774                         if(fputs(buf1, tf) < 0) {
1775                                 fprintf(stderr, "Error writing to temporary file %s: %s\n", tmpfile, strerror(errno));
1776                                 return 1;
1777                         }
1778
1779                         // Add newline if it is missing...
1780                         if(*buf1 && buf1[strlen(buf1) - 1] != '\n') {
1781                                 if(fputc('\n', tf) < 0) {
1782                                         fprintf(stderr, "Error writing to temporary file %s: %s\n", tmpfile, strerror(errno));
1783                                         return 1;
1784                                 }
1785                         }
1786                 }
1787         }
1788
1789         // Make sure we read everything...
1790         if(ferror(f) || !feof(f)) {
1791                 fprintf(stderr, "Error while reading from configuration file %s: %s\n", filename, strerror(errno));
1792                 return 1;
1793         }
1794
1795         if(fclose(f)) {
1796                 fprintf(stderr, "Error closing configuration file %s: %s\n", filename, strerror(errno));
1797                 return 1;
1798         }
1799
1800         // Add new variable if necessary.
1801         if((action > 0 && !found)|| (action == 0 && !set)) {
1802                 if(fprintf(tf, "%s = %s\n", variable, value) < 0) {
1803                         fprintf(stderr, "Error writing to temporary file %s: %s\n", tmpfile, strerror(errno));
1804                         return 1;
1805                 }
1806         }
1807
1808         if(action < -1) {
1809                 if(found) {
1810                         return 0;
1811                 } else {
1812                         fprintf(stderr, "No matching configuration variables found.\n");
1813                         return 1;
1814                 }
1815         }
1816
1817         // Make sure we wrote everything...
1818         if(fclose(tf)) {
1819                 fprintf(stderr, "Error closing temporary file %s: %s\n", tmpfile, strerror(errno));
1820                 return 1;
1821         }
1822
1823         // Could we find what we had to remove?
1824         if(action < 0 && !removed) {
1825                 remove(tmpfile);
1826                 fprintf(stderr, "No configuration variables deleted.\n");
1827                 return 1;
1828         }
1829
1830         // Replace the configuration file with the new one
1831 #ifdef HAVE_MINGW
1832         if(remove(filename)) {
1833                 fprintf(stderr, "Error replacing file %s: %s\n", filename, strerror(errno));
1834                 return 1;
1835         }
1836 #endif
1837         if(rename(tmpfile, filename)) {
1838                 fprintf(stderr, "Error renaming temporary file %s to configuration file %s: %s\n", tmpfile, filename, strerror(errno));
1839                 return 1;
1840         }
1841
1842         // Silently try notifying a running tincd of changes.
1843         if(connect_tincd(false))
1844                 sendline(fd, "%d %d", CONTROL, REQ_RELOAD);
1845
1846         return 0;
1847 }
1848
1849 static bool try_bind(int port) {
1850         struct addrinfo *ai = NULL, *aip;
1851         struct addrinfo hint = {
1852                 .ai_flags = AI_PASSIVE,
1853                 .ai_family = AF_UNSPEC,
1854                 .ai_socktype = SOCK_STREAM,
1855                 .ai_protocol = IPPROTO_TCP,
1856         };
1857
1858         bool success = true;
1859         char portstr[16];
1860         snprintf(portstr, sizeof portstr, "%d", port);
1861
1862         if(getaddrinfo(NULL, portstr, &hint, &ai) || !ai)
1863                 return false;
1864
1865         for(aip = ai; aip; aip = aip->ai_next) {
1866                 int fd = socket(ai->ai_family, SOCK_STREAM, IPPROTO_TCP);
1867                 if(!fd) {
1868                         success = false;
1869                         break;
1870                 }
1871
1872                 int result = bind(fd, ai->ai_addr, ai->ai_addrlen);
1873                 closesocket(fd);
1874                 if(result) {
1875                         success = false;
1876                         break;
1877                 }
1878         }
1879
1880         freeaddrinfo(ai);
1881         return success;
1882 }
1883
1884 int check_port(char *name) {
1885         if(try_bind(655))
1886                 return 655;
1887
1888         fprintf(stderr, "Warning: could not bind to port 655. ");
1889
1890         for(int i = 0; i < 100; i++) {
1891                 int port = 0x1000 + (rand() & 0x7fff);
1892                 if(try_bind(port)) {
1893                         char filename[PATH_MAX];
1894                         snprintf(filename, sizeof filename, "%s" SLASH "hosts" SLASH "%s", confbase, name);
1895                         FILE *f = fopen(filename, "a");
1896                         if(!f) {
1897                                 fprintf(stderr, "Could not open %s: %s\n", filename, strerror(errno));
1898                                 fprintf(stderr, "Please change tinc's Port manually.\n");
1899                                 return 0;
1900                         }
1901
1902                         fprintf(f, "Port = %d\n", port);
1903                         fclose(f);
1904                         fprintf(stderr, "Tinc will instead listen on port %d.\n", port);
1905                         return port;
1906                 }
1907         }
1908
1909         fprintf(stderr, "Please change tinc's Port manually.\n");
1910         return 0;
1911 }
1912
1913 static int cmd_init(int argc, char *argv[]) {
1914         if(!access(tinc_conf, F_OK)) {
1915                 fprintf(stderr, "Configuration file %s already exists!\n", tinc_conf);
1916                 return 1;
1917         }
1918
1919         if(argc > 2) {
1920                 fprintf(stderr, "Too many arguments!\n");
1921                 return 1;
1922         } else if(argc < 2) {
1923                 if(tty) {
1924                         char buf[1024];
1925                         fprintf(stderr, "Enter the Name you want your tinc node to have: ");
1926                         if(!fgets(buf, sizeof buf, stdin)) {
1927                                 fprintf(stderr, "Error while reading stdin: %s\n", strerror(errno));
1928                                 return 1;
1929                         }
1930                         int len = rstrip(buf);
1931                         if(!len) {
1932                                 fprintf(stderr, "No name given!\n");
1933                                 return 1;
1934                         }
1935                         name = strdup(buf);
1936                 } else {
1937                         fprintf(stderr, "No Name given!\n");
1938                         return 1;
1939                 }
1940         } else {
1941                 name = strdup(argv[1]);
1942                 if(!*name) {
1943                         fprintf(stderr, "No Name given!\n");
1944                         return 1;
1945                 }
1946         }
1947
1948         if(!check_id(name)) {
1949                 fprintf(stderr, "Invalid Name! Only a-z, A-Z, 0-9 and _ are allowed characters.\n");
1950                 return 1;
1951         }
1952
1953         if(!confbase_given && mkdir(confdir, 0755) && errno != EEXIST) {
1954                 fprintf(stderr, "Could not create directory %s: %s\n", confdir, strerror(errno));
1955                 return 1;
1956         }
1957
1958         if(mkdir(confbase, 0777) && errno != EEXIST) {
1959                 fprintf(stderr, "Could not create directory %s: %s\n", confbase, strerror(errno));
1960                 return 1;
1961         }
1962
1963         if(mkdir(hosts_dir, 0777) && errno != EEXIST) {
1964                 fprintf(stderr, "Could not create directory %s: %s\n", hosts_dir, strerror(errno));
1965                 return 1;
1966         }
1967
1968         FILE *f = fopen(tinc_conf, "w");
1969         if(!f) {
1970                 fprintf(stderr, "Could not create file %s: %s\n", tinc_conf, strerror(errno));
1971                 return 1;
1972         }
1973
1974         fprintf(f, "Name = %s\n", name);
1975         fclose(f);
1976
1977 #ifndef DISABLE_LEGACY
1978         if(!rsa_keygen(2048, false))
1979                 return 1;
1980 #endif
1981
1982         if(!ed25519_keygen(false))
1983                 return 1;
1984
1985         check_port(name);
1986
1987 #ifndef HAVE_MINGW
1988         char filename[PATH_MAX];
1989         snprintf(filename, sizeof filename, "%s" SLASH "tinc-up", confbase);
1990         if(access(filename, F_OK)) {
1991                 FILE *f = fopenmask(filename, "w", 0777);
1992                 if(!f) {
1993                         fprintf(stderr, "Could not create file %s: %s\n", filename, strerror(errno));
1994                         return 1;
1995                 }
1996                 fprintf(f, "#!/bin/sh\n\necho 'Unconfigured tinc-up script, please edit '$0'!'\n\n#ifconfig $INTERFACE <your vpn IP address> netmask <netmask of whole VPN>\n");
1997                 fclose(f);
1998         }
1999 #endif
2000
2001         return 0;
2002
2003 }
2004
2005 static int cmd_generate_keys(int argc, char *argv[]) {
2006 #ifdef DISABLE_LEGACY
2007         if(argc > 1) {
2008 #else
2009         if(argc > 2) {
2010 #endif
2011                 fprintf(stderr, "Too many arguments!\n");
2012                 return 1;
2013         }
2014
2015         if(!name)
2016                 name = get_my_name(false);
2017
2018 #ifndef DISABLE_LEGACY
2019         if(!rsa_keygen(argc > 1 ? atoi(argv[1]) : 2048, true))
2020                 return 1;
2021 #endif
2022
2023         if(!ed25519_keygen(true))
2024                 return 1;
2025
2026         return 0;
2027 }
2028
2029 #ifndef DISABLE_LEGACY
2030 static int cmd_generate_rsa_keys(int argc, char *argv[]) {
2031         if(argc > 2) {
2032                 fprintf(stderr, "Too many arguments!\n");
2033                 return 1;
2034         }
2035
2036         if(!name)
2037                 name = get_my_name(false);
2038
2039         return !rsa_keygen(argc > 1 ? atoi(argv[1]) : 2048, true);
2040 }
2041 #endif
2042
2043 static int cmd_generate_ed25519_keys(int argc, char *argv[]) {
2044         if(argc > 1) {
2045                 fprintf(stderr, "Too many arguments!\n");
2046                 return 1;
2047         }
2048
2049         if(!name)
2050                 name = get_my_name(false);
2051
2052         return !ed25519_keygen(true);
2053 }
2054
2055 static int cmd_help(int argc, char *argv[]) {
2056         usage(false);
2057         return 0;
2058 }
2059
2060 static int cmd_version(int argc, char *argv[]) {
2061         if(argc > 1) {
2062                 fprintf(stderr, "Too many arguments!\n");
2063                 return 1;
2064         }
2065
2066         version();
2067         return 0;
2068 }
2069
2070 static int cmd_info(int argc, char *argv[]) {
2071         if(argc != 2) {
2072                 fprintf(stderr, "Invalid number of arguments.\n");
2073                 return 1;
2074         }
2075
2076         if(!connect_tincd(true))
2077                 return 1;
2078
2079         return info(fd, argv[1]);
2080 }
2081
2082 static const char *conffiles[] = {
2083         "tinc.conf",
2084         "tinc-up",
2085         "tinc-down",
2086         "subnet-up",
2087         "subnet-down",
2088         "host-up",
2089         "host-down",
2090         NULL,
2091 };
2092
2093 static int cmd_edit(int argc, char *argv[]) {
2094         if(argc != 2) {
2095                 fprintf(stderr, "Invalid number of arguments.\n");
2096                 return 1;
2097         }
2098
2099         char filename[PATH_MAX] = "";
2100
2101         if(strncmp(argv[1], "hosts" SLASH, 6)) {
2102                 for(int i = 0; conffiles[i]; i++) {
2103                         if(!strcmp(argv[1], conffiles[i])) {
2104                                 snprintf(filename, sizeof filename, "%s" SLASH "%s", confbase, argv[1]);
2105                                 break;
2106                         }
2107                 }
2108         } else {
2109                 argv[1] += 6;
2110         }
2111
2112         if(!*filename) {
2113                 snprintf(filename, sizeof filename, "%s" SLASH "%s", hosts_dir, argv[1]);
2114                 char *dash = strchr(argv[1], '-');
2115                 if(dash) {
2116                         *dash++ = 0;
2117                         if((strcmp(dash, "up") && strcmp(dash, "down")) || !check_id(argv[1])) {
2118                                 fprintf(stderr, "Invalid configuration filename.\n");
2119                                 return 1;
2120                         }
2121                 }
2122         }
2123
2124         char *command;
2125 #ifndef HAVE_MINGW
2126         xasprintf(&command, "\"%s\" \"%s\"", getenv("VISUAL") ?: getenv("EDITOR") ?: "vi", filename);
2127 #else
2128         xasprintf(&command, "edit \"%s\"", filename);
2129 #endif
2130         int result = system(command);
2131         free(command);
2132         if(result)
2133                 return result;
2134
2135         // Silently try notifying a running tincd of changes.
2136         if(connect_tincd(false))
2137                 sendline(fd, "%d %d", CONTROL, REQ_RELOAD);
2138
2139         return 0;
2140 }
2141
2142 static int export(const char *name, FILE *out) {
2143         char filename[PATH_MAX];
2144         snprintf(filename, sizeof filename, "%s" SLASH "%s", hosts_dir, name);
2145         FILE *in = fopen(filename, "r");
2146         if(!in) {
2147                 fprintf(stderr, "Could not open configuration file %s: %s\n", filename, strerror(errno));
2148                 return 1;
2149         }
2150
2151         fprintf(out, "Name = %s\n", name);
2152         char buf[4096];
2153         while(fgets(buf, sizeof buf, in)) {
2154                 if(strcspn(buf, "\t =") != 4 || strncasecmp(buf, "Name", 4))
2155                         fputs(buf, out);
2156         }
2157
2158         if(ferror(in)) {
2159                 fprintf(stderr, "Error while reading configuration file %s: %s\n", filename, strerror(errno));
2160                 fclose(in);
2161                 return 1;
2162         }
2163
2164         fclose(in);
2165         return 0;
2166 }
2167
2168 static int cmd_export(int argc, char *argv[]) {
2169         if(argc > 1) {
2170                 fprintf(stderr, "Too many arguments!\n");
2171                 return 1;
2172         }
2173
2174         char *name = get_my_name(true);
2175         if(!name)
2176                 return 1;
2177
2178         int result = export(name, stdout);
2179         if(!tty)
2180                 fclose(stdout);
2181
2182         free(name);
2183         return result;
2184 }
2185
2186 static int cmd_export_all(int argc, char *argv[]) {
2187         if(argc > 1) {
2188                 fprintf(stderr, "Too many arguments!\n");
2189                 return 1;
2190         }
2191
2192         DIR *dir = opendir(hosts_dir);
2193         if(!dir) {
2194                 fprintf(stderr, "Could not open host configuration directory %s: %s\n", hosts_dir, strerror(errno));
2195                 return 1;
2196         }
2197
2198         bool first = true;
2199         int result = 0;
2200         struct dirent *ent;
2201
2202         while((ent = readdir(dir))) {
2203                 if(!check_id(ent->d_name))
2204                         continue;
2205
2206                 if(first)
2207                         first = false;
2208                 else
2209                         printf("#---------------------------------------------------------------#\n");
2210
2211                 result |= export(ent->d_name, stdout);
2212         }
2213
2214         closedir(dir);
2215         if(!tty)
2216                 fclose(stdout);
2217         return result;
2218 }
2219
2220 static int cmd_import(int argc, char *argv[]) {
2221         if(argc > 1) {
2222                 fprintf(stderr, "Too many arguments!\n");
2223                 return 1;
2224         }
2225
2226         FILE *in = stdin;
2227         FILE *out = NULL;
2228
2229         char buf[4096];
2230         char name[4096];
2231         char filename[PATH_MAX] = "";
2232         int count = 0;
2233         bool firstline = true;
2234
2235         while(fgets(buf, sizeof buf, in)) {
2236                 if(sscanf(buf, "Name = %4095s", name) == 1) {
2237                         firstline = false;
2238
2239                         if(!check_id(name)) {
2240                                 fprintf(stderr, "Invalid Name in input!\n");
2241                                 return 1;
2242                         }
2243
2244                         if(out)
2245                                 fclose(out);
2246
2247                         snprintf(filename, sizeof filename, "%s" SLASH "%s", hosts_dir, name);
2248
2249                         if(!force && !access(filename, F_OK)) {
2250                                 fprintf(stderr, "Host configuration file %s already exists, skipping.\n", filename);
2251                                 out = NULL;
2252                                 continue;
2253                         }
2254
2255                         out = fopen(filename, "w");
2256                         if(!out) {
2257                                 fprintf(stderr, "Error creating configuration file %s: %s\n", filename, strerror(errno));
2258                                 return 1;
2259                         }
2260
2261                         count++;
2262                         continue;
2263                 } else if(firstline) {
2264                         fprintf(stderr, "Junk at the beginning of the input, ignoring.\n");
2265                         firstline = false;
2266                 }
2267
2268
2269                 if(!strcmp(buf, "#---------------------------------------------------------------#\n"))
2270                         continue;
2271
2272                 if(out) {
2273                         if(fputs(buf, out) < 0) {
2274                                 fprintf(stderr, "Error writing to host configuration file %s: %s\n", filename, strerror(errno));
2275                                 return 1;
2276                         }
2277                 }
2278         }
2279
2280         if(out)
2281                 fclose(out);
2282
2283         if(count) {
2284                 fprintf(stderr, "Imported %d host configuration files.\n", count);
2285                 return 0;
2286         } else {
2287                 fprintf(stderr, "No host configuration files imported.\n");
2288                 return 1;
2289         }
2290 }
2291
2292 static int cmd_exchange(int argc, char *argv[]) {
2293         return cmd_export(argc, argv) ?: cmd_import(argc, argv);
2294 }
2295
2296 static int cmd_exchange_all(int argc, char *argv[]) {
2297         return cmd_export_all(argc, argv) ?: cmd_import(argc, argv);
2298 }
2299
2300 static int switch_network(char *name) {
2301         if(strcmp(name, ".")) {
2302                 if(!check_netname(name, false)) {
2303                         fprintf(stderr, "Invalid character in netname!\n");
2304                         return 1;
2305                 }
2306
2307                 if(!check_netname(name, true))
2308                         fprintf(stderr, "Warning: unsafe character in netname!\n");
2309         }
2310
2311         if(fd >= 0) {
2312                 close(fd);
2313                 fd = -1;
2314         }
2315
2316         free_names();
2317         netname = strcmp(name, ".") ? xstrdup(name) : NULL;
2318         make_names(false);
2319
2320         free(tinc_conf);
2321         free(hosts_dir);
2322         free(prompt);
2323
2324         xasprintf(&tinc_conf, "%s" SLASH "tinc.conf", confbase);
2325         xasprintf(&hosts_dir, "%s" SLASH "hosts", confbase);
2326         xasprintf(&prompt, "%s> ", identname);
2327
2328         return 0;
2329 }
2330
2331 static int cmd_network(int argc, char *argv[]) {
2332         if(argc > 2) {
2333                 fprintf(stderr, "Too many arguments!\n");
2334                 return 1;
2335         }
2336
2337         if(argc == 2)
2338                 return switch_network(argv[1]);
2339
2340         DIR *dir = opendir(confdir);
2341         if(!dir) {
2342                 fprintf(stderr, "Could not read directory %s: %s\n", confdir, strerror(errno));
2343                 return 1;
2344         }
2345
2346         struct dirent *ent;
2347         while((ent = readdir(dir))) {
2348                 if(*ent->d_name == '.')
2349                         continue;
2350
2351                 if(!strcmp(ent->d_name, "tinc.conf")) {
2352                         printf(".\n");
2353                         continue;
2354                 }
2355
2356                 char fname[PATH_MAX];
2357                 snprintf(fname, sizeof fname, "%s/%s/tinc.conf", confdir, ent->d_name);
2358                 if(!access(fname, R_OK))
2359                         printf("%s\n", ent->d_name);
2360         }
2361
2362         closedir(dir);
2363
2364         return 0;
2365 }
2366
2367 static int cmd_fsck(int argc, char *argv[]) {
2368         if(argc > 1) {
2369                 fprintf(stderr, "Too many arguments!\n");
2370                 return 1;
2371         }
2372
2373         return fsck(orig_argv[0]);
2374 }
2375
2376 static void *readfile(FILE *in, size_t *len) {
2377         size_t count = 0;
2378         size_t alloced = 4096;
2379         char *buf = xmalloc(alloced);
2380
2381         while(!feof(in)) {
2382                 size_t read = fread(buf + count, 1, alloced - count, in);
2383                 if(!read)
2384                         break;
2385                 count += read;
2386                 if(count >= alloced) {
2387                         alloced *= 2;
2388                         buf = xrealloc(buf, alloced);
2389                 }
2390         }
2391
2392         if(len)
2393                 *len = count;
2394
2395         return buf;
2396 }
2397
2398 static int cmd_sign(int argc, char *argv[]) {
2399         if(argc > 2) {
2400                 fprintf(stderr, "Too many arguments!\n");
2401                 return 1;
2402         }
2403
2404         if(!name) {
2405                 name = get_my_name(true);
2406                 if(!name)
2407                         return 1;
2408         }
2409
2410         char fname[PATH_MAX];
2411         snprintf(fname, sizeof fname, "%s" SLASH "ed25519_key.priv", confbase);
2412         FILE *fp = fopen(fname, "r");
2413         if(!fp) {
2414                 fprintf(stderr, "Could not open %s: %s\n", fname, strerror(errno));
2415                 return 1;
2416         }
2417
2418         ecdsa_t *key = ecdsa_read_pem_private_key(fp);
2419
2420         if(!key) {
2421                 fprintf(stderr, "Could not read private key from %s\n", fname);
2422                 fclose(fp);
2423                 return 1;
2424         }
2425
2426         fclose(fp);
2427
2428         FILE *in;
2429
2430         if(argc == 2) {
2431                 in = fopen(argv[1], "rb");
2432                 if(!in) {
2433                         fprintf(stderr, "Could not open %s: %s\n", argv[1], strerror(errno));
2434                         ecdsa_free(key);
2435                         return 1;
2436                 }
2437         } else {
2438                 in = stdin;
2439         }
2440
2441         size_t len;
2442         char *data = readfile(in, &len);
2443         if(in != stdin)
2444                 fclose(in);
2445         if(!data) {
2446                 fprintf(stderr, "Error reading %s: %s\n", argv[1], strerror(errno));
2447                 ecdsa_free(key);
2448                 return 1;
2449         }
2450
2451         // Ensure we sign our name and current time as well
2452         long t = time(NULL);
2453         char *trailer;
2454         xasprintf(&trailer, " %s %ld", name, t);
2455         int trailer_len = strlen(trailer);
2456
2457         data = xrealloc(data, len + trailer_len);
2458         memcpy(data + len, trailer, trailer_len);
2459         free(trailer);
2460
2461         char sig[87];
2462         if(!ecdsa_sign(key, data, len + trailer_len, sig)) {
2463                 fprintf(stderr, "Error generating signature\n");
2464                 free(data);
2465                 ecdsa_free(key);
2466                 return 1;
2467         }
2468         b64encode(sig, sig, 64);
2469         ecdsa_free(key);
2470
2471         fprintf(stdout, "Signature = %s %ld %s\n", name, t, sig);
2472         fwrite(data, len, 1, stdout);
2473
2474         free(data);
2475         return 0;
2476 }
2477
2478 static int cmd_verify(int argc, char *argv[]) {
2479         if(argc < 2) {
2480                 fprintf(stderr, "Not enough arguments!\n");
2481                 return 1;
2482         }
2483
2484         if(argc > 3) {
2485                 fprintf(stderr, "Too many arguments!\n");
2486                 return 1;
2487         }
2488
2489         char *node = argv[1];
2490         if(!strcmp(node, ".")) {
2491                 if(!name) {
2492                         name = get_my_name(true);
2493                         if(!name)
2494                                 return 1;
2495                 }
2496                 node = name;
2497         } else if(!strcmp(node, "*")) {
2498                 node = NULL;
2499         } else {
2500                 if(!check_id(node)) {
2501                         fprintf(stderr, "Invalid node name\n");
2502                         return 1;
2503                 }
2504         }
2505
2506         FILE *in;
2507
2508         if(argc == 3) {
2509                 in = fopen(argv[2], "rb");
2510                 if(!in) {
2511                         fprintf(stderr, "Could not open %s: %s\n", argv[2], strerror(errno));
2512                         return 1;
2513                 }
2514         } else {
2515                 in = stdin;
2516         }
2517
2518         size_t len;
2519         char *data = readfile(in, &len);
2520         if(in != stdin)
2521                 fclose(in);
2522         if(!data) {
2523                 fprintf(stderr, "Error reading %s: %s\n", argv[1], strerror(errno));
2524                 return 1;
2525         }
2526
2527         char *newline = memchr(data, '\n', len);
2528         if(!newline || (newline - data > MAX_STRING_SIZE - 1)) {
2529                 fprintf(stderr, "Invalid input\n");
2530                 free(data);
2531                 return 1;
2532         }
2533
2534         *newline++ = '\0';
2535         size_t skip = newline - data;
2536
2537         char signer[MAX_STRING_SIZE] = "";
2538         char sig[MAX_STRING_SIZE] = "";
2539         long t = 0;
2540
2541         if(sscanf(data, "Signature = %s %ld %s", signer, &t, sig) != 3 || strlen(sig) != 86 || !t || !check_id(signer)) {
2542                 fprintf(stderr, "Invalid input\n");
2543                 free(data);
2544                 return 1;
2545         }
2546
2547         if(node && strcmp(node, signer)) {
2548                 fprintf(stderr, "Signature is not made by %s\n", node);
2549                 free(data);
2550                 return 1;
2551         }
2552
2553         if(!node)
2554                 node = signer;
2555
2556         char *trailer;
2557         xasprintf(&trailer, " %s %ld", signer, t);
2558         int trailer_len = strlen(trailer);
2559
2560         data = xrealloc(data, len + trailer_len);
2561         memcpy(data + len, trailer, trailer_len);
2562         free(trailer);
2563
2564         newline = data + skip;
2565
2566         char fname[PATH_MAX];
2567         snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, node);
2568         FILE *fp = fopen(fname, "r");
2569         if(!fp) {
2570                 fprintf(stderr, "Could not open %s: %s\n", fname, strerror(errno));
2571                 free(data);
2572                 return 1;
2573         }
2574
2575         ecdsa_t *key = get_pubkey(fp);
2576         if(!key) {
2577                 rewind(fp);
2578                 key = ecdsa_read_pem_public_key(fp);
2579         }
2580         if(!key) {
2581                 fprintf(stderr, "Could not read public key from %s\n", fname);
2582                 fclose(fp);
2583                 free(data);
2584                 return 1;
2585         }
2586
2587         fclose(fp);
2588
2589         if(b64decode(sig, sig, 86) != 64 || !ecdsa_verify(key, newline, len + trailer_len - (newline - data), sig)) {
2590                 fprintf(stderr, "Invalid signature\n");
2591                 free(data);
2592                 ecdsa_free(key);
2593                 return 1;
2594         }
2595
2596         ecdsa_free(key);
2597
2598         fwrite(newline, len - (newline - data), 1, stdout);
2599
2600         free(data);
2601         return 0;
2602 }
2603
2604 static const struct {
2605         const char *command;
2606         int (*function)(int argc, char *argv[]);
2607         bool hidden;
2608 } commands[] = {
2609         {"start", cmd_start},
2610         {"stop", cmd_stop},
2611         {"restart", cmd_restart},
2612         {"reload", cmd_reload},
2613         {"dump", cmd_dump},
2614         {"list", cmd_dump},
2615         {"purge", cmd_purge},
2616         {"debug", cmd_debug},
2617         {"retry", cmd_retry},
2618         {"connect", cmd_connect},
2619         {"disconnect", cmd_disconnect},
2620         {"top", cmd_top},
2621         {"pcap", cmd_pcap},
2622         {"log", cmd_log},
2623         {"pid", cmd_pid},
2624         {"config", cmd_config, true},
2625         {"add", cmd_config},
2626         {"del", cmd_config},
2627         {"get", cmd_config},
2628         {"set", cmd_config},
2629         {"init", cmd_init},
2630         {"generate-keys", cmd_generate_keys},
2631 #ifndef DISABLE_LEGACY
2632         {"generate-rsa-keys", cmd_generate_rsa_keys},
2633 #endif
2634         {"generate-ed25519-keys", cmd_generate_ed25519_keys},
2635         {"help", cmd_help},
2636         {"version", cmd_version},
2637         {"info", cmd_info},
2638         {"edit", cmd_edit},
2639         {"export", cmd_export},
2640         {"export-all", cmd_export_all},
2641         {"import", cmd_import},
2642         {"exchange", cmd_exchange},
2643         {"exchange-all", cmd_exchange_all},
2644         {"invite", cmd_invite},
2645         {"join", cmd_join},
2646         {"network", cmd_network},
2647         {"fsck", cmd_fsck},
2648         {"sign", cmd_sign},
2649         {"verify", cmd_verify},
2650         {NULL, NULL},
2651 };
2652
2653 #ifdef HAVE_READLINE
2654 static char *complete_command(const char *text, int state) {
2655         static int i;
2656
2657         if(!state)
2658                 i = 0;
2659         else
2660                 i++;
2661
2662         while(commands[i].command) {
2663                 if(!commands[i].hidden && !strncasecmp(commands[i].command, text, strlen(text)))
2664                         return xstrdup(commands[i].command);
2665                 i++;
2666         }
2667
2668         return NULL;
2669 }
2670
2671 static char *complete_dump(const char *text, int state) {
2672         const char *matches[] = {"reachable", "nodes", "edges", "subnets", "connections", "graph", NULL};
2673         static int i;
2674
2675         if(!state)
2676                 i = 0;
2677         else
2678                 i++;
2679
2680         while(matches[i]) {
2681                 if(!strncasecmp(matches[i], text, strlen(text)))
2682                         return xstrdup(matches[i]);
2683                 i++;
2684         }
2685
2686         return NULL;
2687 }
2688
2689 static char *complete_config(const char *text, int state) {
2690         static int i;
2691
2692         if(!state)
2693                 i = 0;
2694         else
2695                 i++;
2696
2697         while(variables[i].name) {
2698                 char *dot = strchr(text, '.');
2699                 if(dot) {
2700                         if((variables[i].type & VAR_HOST) && !strncasecmp(variables[i].name, dot + 1, strlen(dot + 1))) {
2701                                 char *match;
2702                                 xasprintf(&match, "%.*s.%s", (int)(dot - text), text, variables[i].name);
2703                                 return match;
2704                         }
2705                 } else {
2706                         if(!strncasecmp(variables[i].name, text, strlen(text)))
2707                                 return xstrdup(variables[i].name);
2708                 }
2709                 i++;
2710         }
2711
2712         return NULL;
2713 }
2714
2715 static char *complete_info(const char *text, int state) {
2716         static int i;
2717         if(!state) {
2718                 i = 0;
2719                 if(!connect_tincd(false))
2720                         return NULL;
2721                 // Check the list of nodes
2722                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_NODES);
2723                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_SUBNETS);
2724         }
2725
2726         while(recvline(fd, line, sizeof line)) {
2727                 char item[4096];
2728                 int n = sscanf(line, "%d %d %4095s", &code, &req, item);
2729                 if(n == 2) {
2730                         i++;
2731                         if(i >= 2)
2732                                 break;
2733                         else
2734                                 continue;
2735                 }
2736
2737                 if(n != 3) {
2738                         fprintf(stderr, "Unable to parse dump from tincd, n = %d, i = %d.\n", n, i);
2739                         break;
2740                 }
2741
2742                 if(!strncmp(item, text, strlen(text)))
2743                         return xstrdup(strip_weight(item));
2744         }
2745
2746         return NULL;
2747 }
2748
2749 static char *complete_nothing(const char *text, int state) {
2750         return NULL;
2751 }
2752
2753 static char **completion (const char *text, int start, int end) {
2754         char **matches = NULL;
2755
2756         if(!start)
2757                 matches = rl_completion_matches(text, complete_command);
2758         else if(!strncasecmp(rl_line_buffer, "dump ", 5))
2759                 matches = rl_completion_matches(text, complete_dump);
2760         else if(!strncasecmp(rl_line_buffer, "add ", 4))
2761                 matches = rl_completion_matches(text, complete_config);
2762         else if(!strncasecmp(rl_line_buffer, "del ", 4))
2763                 matches = rl_completion_matches(text, complete_config);
2764         else if(!strncasecmp(rl_line_buffer, "get ", 4))
2765                 matches = rl_completion_matches(text, complete_config);
2766         else if(!strncasecmp(rl_line_buffer, "set ", 4))
2767                 matches = rl_completion_matches(text, complete_config);
2768         else if(!strncasecmp(rl_line_buffer, "info ", 5))
2769                 matches = rl_completion_matches(text, complete_info);
2770
2771         return matches;
2772 }
2773 #endif
2774
2775 static int cmd_shell(int argc, char *argv[]) {
2776         xasprintf(&prompt, "%s> ", identname);
2777         int result = 0;
2778         char buf[4096];
2779         char *line = NULL;
2780         int maxargs = argc + 16;
2781         char **nargv = xmalloc(maxargs * sizeof *nargv);
2782
2783         for(int i = 0; i < argc; i++)
2784                 nargv[i] = argv[i];
2785
2786 #ifdef HAVE_READLINE
2787         rl_readline_name = "tinc";
2788         rl_completion_entry_function = complete_nothing;
2789         rl_attempted_completion_function = completion;
2790         rl_filename_completion_desired = 0;
2791         char *copy = NULL;
2792 #endif
2793
2794         while(true) {
2795 #ifdef HAVE_READLINE
2796                 if(tty) {
2797                         free(copy);
2798                         free(line);
2799                         rl_basic_word_break_characters = "\t\n ";
2800                         line = readline(prompt);
2801                         if(line)
2802                                 copy = xstrdup(line);
2803                 } else {
2804                         line = fgets(buf, sizeof buf, stdin);
2805                 }
2806 #else
2807                 if(tty)
2808                         fputs(prompt, stdout);
2809
2810                 line = fgets(buf, sizeof buf, stdin);
2811 #endif
2812
2813                 if(!line)
2814                         break;
2815
2816                 /* Ignore comments */
2817
2818                 if(*line == '#')
2819                         continue;
2820
2821                 /* Split */
2822
2823                 int nargc = argc;
2824                 char *p = line + strspn(line, " \t\n");
2825                 char *next = strtok(p, " \t\n");
2826
2827                 while(p && *p) {
2828                         if(nargc >= maxargs) {
2829                                 fprintf(stderr, "next %p '%s', p %p '%s'\n", next, next, p, p);
2830                                 abort();
2831                                 maxargs *= 2;
2832                                 nargv = xrealloc(nargv, maxargs * sizeof *nargv);
2833                         }
2834
2835                         nargv[nargc++] = p;
2836                         p = next;
2837                         next = strtok(NULL, " \t\n");
2838                 }
2839
2840                 if(nargc == argc)
2841                         continue;
2842
2843                 if(!strcasecmp(nargv[argc], "exit") || !strcasecmp(nargv[argc], "quit")) {
2844                         free(nargv);
2845                         return result;
2846                 }
2847
2848                 bool found = false;
2849
2850                 for(int i = 0; commands[i].command; i++) {
2851                         if(!strcasecmp(nargv[argc], commands[i].command)) {
2852                                 result |= commands[i].function(nargc - argc - 1, nargv + argc + 1);
2853                                 found = true;
2854                                 break;
2855                         }
2856                 }
2857
2858 #ifdef HAVE_READLINE
2859                 if(tty && found)
2860                         add_history(copy);
2861 #endif
2862
2863                 if(!found) {
2864                         fprintf(stderr, "Unknown command `%s'.\n", nargv[argc]);
2865                         result |= 1;
2866                 }
2867         }
2868
2869         free(nargv);
2870
2871         if(tty)
2872                 printf("\n");
2873         return result;
2874 }
2875
2876
2877 int main(int argc, char *argv[]) {
2878         program_name = argv[0];
2879         orig_argv = argv;
2880         orig_argc = argc;
2881         tty = isatty(0) && isatty(1);
2882
2883         if(!parse_options(argc, argv))
2884                 return 1;
2885
2886         make_names(false);
2887         xasprintf(&tinc_conf, "%s" SLASH "tinc.conf", confbase);
2888         xasprintf(&hosts_dir, "%s" SLASH "hosts", confbase);
2889
2890         if(show_version) {
2891                 version();
2892                 return 0;
2893         }
2894
2895         if(show_help) {
2896                 usage(false);
2897                 return 0;
2898         }
2899
2900 #ifdef HAVE_MINGW
2901         static struct WSAData wsa_state;
2902
2903         if(WSAStartup(MAKEWORD(2, 2), &wsa_state)) {
2904                 fprintf(stderr, "System call `%s' failed: %s", "WSAStartup", winerror(GetLastError()));
2905                 return false;
2906         }
2907 #endif
2908
2909         srand(time(NULL));
2910         crypto_init();
2911
2912         if(optind >= argc)
2913                 return cmd_shell(argc, argv);
2914
2915         for(int i = 0; commands[i].command; i++) {
2916                 if(!strcasecmp(argv[optind], commands[i].command))
2917                         return commands[i].function(argc - optind, argv + optind);
2918         }
2919
2920         fprintf(stderr, "Unknown command `%s'.\n", argv[optind]);
2921         usage(true);
2922         return 1;
2923 }