www.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                 return false;
 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 %d: %s\n", pid, strerror(errno));
 955                                 return 1;
 956                         }
 957
 958                         fprintf(stderr, "Sent TERM signal to process with PID %d.\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                         continue;
1034                 }
1035
1036                 buf[0] = 0;
1037                 if(!fgets(buf, sizeof buf, f)) {
1038                         fprintf(stderr, "Invalid invitation file %s", fname);
1039                         fclose(f);
1040                         continue;
1041                 }
1042                 fclose(f);
1043
1044                 char *eol = buf + strlen(buf);
1045                 while(strchr("\t \r\n", *--eol))
1046                         *eol = 0;
1047                 if(strncmp(buf, "Name = ", 7) || !check_id(buf + 7)) {
1048                         fprintf(stderr, "Invalid invitation file %s", fname);
1049                         continue;
1050                 }
1051
1052                 found = true;
1053                 printf("%s %s\n", ent->d_name, buf + 7);
1054         }
1055
1056         closedir(dir);
1057
1058         if(!found)
1059                 fprintf(stderr, "No outstanding invitations.\n");
1060
1061         return 0;
1062 }
1063
1064 static int cmd_dump(int argc, char *argv[]) {
1065         bool only_reachable = false;
1066
1067         if(argc > 2 && !strcasecmp(argv[1], "reachable")) {
1068                 if(strcasecmp(argv[2], "nodes")) {
1069                         fprintf(stderr, "`reachable' only supported for nodes.\n");
1070                         usage(true);
1071                         return 1;
1072                 }
1073                 only_reachable = true;
1074                 argv++;
1075                 argc--;
1076         }
1077
1078         if(argc != 2) {
1079                 fprintf(stderr, "Invalid number of arguments.\n");
1080                 usage(true);
1081                 return 1;
1082         }
1083
1084         if(!strcasecmp(argv[1], "invitations"))
1085                 return dump_invitations();
1086
1087         if(!connect_tincd(true))
1088                 return 1;
1089
1090         int do_graph = 0;
1091
1092         if(!strcasecmp(argv[1], "nodes"))
1093                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_NODES);
1094         else if(!strcasecmp(argv[1], "edges"))
1095                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_EDGES);
1096         else if(!strcasecmp(argv[1], "subnets"))
1097                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_SUBNETS);
1098         else if(!strcasecmp(argv[1], "connections"))
1099                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_CONNECTIONS);
1100         else if(!strcasecmp(argv[1], "graph")) {
1101                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_NODES);
1102                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_EDGES);
1103                 do_graph = 1;
1104         } else if(!strcasecmp(argv[1], "digraph")) {
1105                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_NODES);
1106                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_EDGES);
1107                 do_graph = 2;
1108         } else {
1109                 fprintf(stderr, "Unknown dump type '%s'.\n", argv[1]);
1110                 usage(true);
1111                 return 1;
1112         }
1113
1114         if(do_graph == 1)
1115                 printf("graph {\n");
1116         else if(do_graph == 2)
1117                 printf("digraph {\n");
1118
1119         while(recvline(fd, line, sizeof line)) {
1120                 char node1[4096], node2[4096];
1121                 int n = sscanf(line, "%d %d %4095s %4095s", &code, &req, node1, node2);
1122                 if(n == 2) {
1123                         if(do_graph && req == REQ_DUMP_NODES)
1124                                 continue;
1125                         else {
1126                                 if(do_graph)
1127                                         printf("}\n");
1128                                 return 0;
1129                         }
1130                 }
1131                 if(n < 2)
1132                         break;
1133
1134                 char node[4096];
1135                 char id[4096];
1136                 char from[4096];
1137                 char to[4096];
1138                 char subnet[4096];
1139                 char host[4096];
1140                 char port[4096];
1141                 char local_host[4096];
1142                 char local_port[4096];
1143                 char via[4096];
1144                 char nexthop[4096];
1145                 int cipher, digest, maclength, compression, distance, socket, weight;
1146                 short int pmtu, minmtu, maxmtu;
1147                 unsigned int options, status_int;
1148                 node_status_t status;
1149                 long int last_state_change;
1150
1151                 switch(req) {
1152                         case REQ_DUMP_NODES: {
1153                                 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);
1154                                 if(n != 17) {
1155                                         fprintf(stderr, "Unable to parse node dump from tincd: %s\n", line);
1156                                         return 1;
1157                                 }
1158
1159                                 memcpy(&status, &status_int, sizeof status);
1160
1161                                 if(do_graph) {
1162                                         const char *color = "black";
1163                                         if(!strcmp(host, "MYSELF"))
1164                                                 color = "green";
1165                                         else if(!status.reachable)
1166                                                 color = "red";
1167                                         else if(strcmp(via, node))
1168                                                 color = "orange";
1169                                         else if(!status.validkey)
1170                                                 color = "black";
1171                                         else if(minmtu > 0)
1172                                                 color = "green";
1173                                         printf(" %s [label = \"%s\", color = \"%s\"%s];\n", node, node, color, strcmp(host, "MYSELF") ? "" : ", style = \"filled\"");
1174                                 } else {
1175                                         if(only_reachable && !status.reachable)
1176                                                 continue;
1177                                         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",
1178                                                         node, id, host, port, cipher, digest, maclength, compression, options, status_int, nexthop, via, distance, pmtu, minmtu, maxmtu);
1179                                 }
1180                         } break;
1181
1182                         case REQ_DUMP_EDGES: {
1183                                 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);
1184                                 if(n != 8) {
1185                                         fprintf(stderr, "Unable to parse edge dump from tincd.\n");
1186                                         return 1;
1187                                 }
1188
1189                                 if(do_graph) {
1190                                         float w = 1 + 65536.0 / weight;
1191                                         if(do_graph == 1 && strcmp(node1, node2) > 0)
1192                                                 printf(" %s -- %s [w = %f, weight = %f];\n", node1, node2, w, w);
1193                                         else if(do_graph == 2)
1194                                                 printf(" %s -> %s [w = %f, weight = %f];\n", node1, node2, w, w);
1195                                 } else {
1196                                         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);
1197                                 }
1198                         } break;
1199
1200                         case REQ_DUMP_SUBNETS: {
1201                                 int n = sscanf(line, "%*d %*d %4095s %4095s", subnet, node);
1202                                 if(n != 2) {
1203                                         fprintf(stderr, "Unable to parse subnet dump from tincd.\n");
1204                                         return 1;
1205                                 }
1206                                 printf("%s owner %s\n", strip_weight(subnet), node);
1207                         } break;
1208
1209                         case REQ_DUMP_CONNECTIONS: {
1210                                 int n = sscanf(line, "%*d %*d %4095s %4095s port %4095s %x %d %x", node, host, port, &options, &socket, &status_int);
1211                                 if(n != 6) {
1212                                         fprintf(stderr, "Unable to parse connection dump from tincd.\n");
1213                                         return 1;
1214                                 }
1215                                 printf("%s at %s port %s options %x socket %d status %x\n", node, host, port, options, socket, status_int);
1216                         } break;
1217
1218                         default:
1219                                 fprintf(stderr, "Unable to parse dump from tincd.\n");
1220                                 return 1;
1221                 }
1222         }
1223
1224         fprintf(stderr, "Error receiving dump.\n");
1225         return 1;
1226 }
1227
1228 static int cmd_purge(int argc, char *argv[]) {
1229         if(argc > 1) {
1230                 fprintf(stderr, "Too many arguments!\n");
1231                 return 1;
1232         }
1233
1234         if(!connect_tincd(true))
1235                 return 1;
1236
1237         sendline(fd, "%d %d", CONTROL, REQ_PURGE);
1238         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_PURGE || result) {
1239                 fprintf(stderr, "Could not purge old information.\n");
1240                 return 1;
1241         }
1242
1243         return 0;
1244 }
1245
1246 static int cmd_debug(int argc, char *argv[]) {
1247         if(argc != 2) {
1248                 fprintf(stderr, "Invalid number of arguments.\n");
1249                 return 1;
1250         }
1251
1252         if(!connect_tincd(true))
1253                 return 1;
1254
1255         int debuglevel = atoi(argv[1]);
1256         int origlevel;
1257
1258         sendline(fd, "%d %d %d", CONTROL, REQ_SET_DEBUG, debuglevel);
1259         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &origlevel) != 3 || code != CONTROL || req != REQ_SET_DEBUG) {
1260                 fprintf(stderr, "Could not set debug level.\n");
1261                 return 1;
1262         }
1263
1264         fprintf(stderr, "Old level %d, new level %d.\n", origlevel, debuglevel);
1265         return 0;
1266 }
1267
1268 static int cmd_retry(int argc, char *argv[]) {
1269         if(argc > 1) {
1270                 fprintf(stderr, "Too many arguments!\n");
1271                 return 1;
1272         }
1273
1274         if(!connect_tincd(true))
1275                 return 1;
1276
1277         sendline(fd, "%d %d", CONTROL, REQ_RETRY);
1278         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_RETRY || result) {
1279                 fprintf(stderr, "Could not retry outgoing connections.\n");
1280                 return 1;
1281         }
1282
1283         return 0;
1284 }
1285
1286 static int cmd_connect(int argc, char *argv[]) {
1287         if(argc != 2) {
1288                 fprintf(stderr, "Invalid number of arguments.\n");
1289                 return 1;
1290         }
1291
1292         if(!check_id(argv[1])) {
1293                 fprintf(stderr, "Invalid name for node.\n");
1294                 return 1;
1295         }
1296
1297         if(!connect_tincd(true))
1298                 return 1;
1299
1300         sendline(fd, "%d %d %s", CONTROL, REQ_CONNECT, argv[1]);
1301         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_CONNECT || result) {
1302                 fprintf(stderr, "Could not connect to %s.\n", argv[1]);
1303                 return 1;
1304         }
1305
1306         return 0;
1307 }
1308
1309 static int cmd_disconnect(int argc, char *argv[]) {
1310         if(argc != 2) {
1311                 fprintf(stderr, "Invalid number of arguments.\n");
1312                 return 1;
1313         }
1314
1315         if(!check_id(argv[1])) {
1316                 fprintf(stderr, "Invalid name for node.\n");
1317                 return 1;
1318         }
1319
1320         if(!connect_tincd(true))
1321                 return 1;
1322
1323         sendline(fd, "%d %d %s", CONTROL, REQ_DISCONNECT, argv[1]);
1324         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_DISCONNECT || result) {
1325                 fprintf(stderr, "Could not disconnect %s.\n", argv[1]);
1326                 return 1;
1327         }
1328
1329         return 0;
1330 }
1331
1332 static int cmd_top(int argc, char *argv[]) {
1333         if(argc > 1) {
1334                 fprintf(stderr, "Too many arguments!\n");
1335                 return 1;
1336         }
1337
1338 #ifdef HAVE_CURSES
1339         if(!connect_tincd(true))
1340                 return 1;
1341
1342         top(fd);
1343         return 0;
1344 #else
1345         fprintf(stderr, "This version of tinc was compiled without support for the curses library.\n");
1346         return 1;
1347 #endif
1348 }
1349
1350 static int cmd_pcap(int argc, char *argv[]) {
1351         if(argc > 2) {
1352                 fprintf(stderr, "Too many arguments!\n");
1353                 return 1;
1354         }
1355
1356         if(!connect_tincd(true))
1357                 return 1;
1358
1359         pcap(fd, stdout, argc > 1 ? atoi(argv[1]) : 0);
1360         return 0;
1361 }
1362
1363 #ifdef SIGINT
1364 static void sigint_handler(int sig) {
1365         fprintf(stderr, "\n");
1366         shutdown(fd, SHUT_RDWR);
1367 }
1368 #endif
1369
1370 static int cmd_log(int argc, char *argv[]) {
1371         if(argc > 2) {
1372                 fprintf(stderr, "Too many arguments!\n");
1373                 return 1;
1374         }
1375
1376         if(!connect_tincd(true))
1377                 return 1;
1378
1379 #ifdef SIGINT
1380         signal(SIGINT, sigint_handler);
1381 #endif
1382
1383         logcontrol(fd, stdout, argc > 1 ? atoi(argv[1]) : -1);
1384
1385 #ifdef SIGINT
1386         signal(SIGINT, SIG_DFL);
1387 #endif
1388
1389         close(fd);
1390         fd = -1;
1391         return 0;
1392 }
1393
1394 static int cmd_pid(int argc, char *argv[]) {
1395         if(argc > 1) {
1396                 fprintf(stderr, "Too many arguments!\n");
1397                 return 1;
1398         }
1399
1400         if(!connect_tincd(true) || !pid)
1401                 return 1;
1402
1403         printf("%d\n", pid);
1404         return 0;
1405 }
1406
1407 int rstrip(char *value) {
1408         int len = strlen(value);
1409         while(len && strchr("\t\r\n ", value[len - 1]))
1410                 value[--len] = 0;
1411         return len;
1412 }
1413
1414 char *get_my_name(bool verbose) {
1415         FILE *f = fopen(tinc_conf, "r");
1416         if(!f) {
1417                 if(verbose)
1418                         fprintf(stderr, "Could not open %s: %s\n", tinc_conf, strerror(errno));
1419                 return NULL;
1420         }
1421
1422         char buf[4096];
1423         char *value;
1424         while(fgets(buf, sizeof buf, f)) {
1425                 int len = strcspn(buf, "\t =");
1426                 value = buf + len;
1427                 value += strspn(value, "\t ");
1428                 if(*value == '=') {
1429                         value++;
1430                         value += strspn(value, "\t ");
1431                 }
1432                 if(!rstrip(value))
1433                         continue;
1434                 buf[len] = 0;
1435                 if(strcasecmp(buf, "Name"))
1436                         continue;
1437                 if(*value) {
1438                         fclose(f);
1439                         return replace_name(value);
1440                 }
1441         }
1442
1443         fclose(f);
1444         if(verbose)
1445                 fprintf(stderr, "Could not find Name in %s.\n", tinc_conf);
1446         return NULL;
1447 }
1448
1449 ecdsa_t *get_pubkey(FILE *f) {
1450         char buf[4096];
1451         char *value;
1452         while(fgets(buf, sizeof buf, f)) {
1453                 int len = strcspn(buf, "\t =");
1454                 value = buf + len;
1455                 value += strspn(value, "\t ");
1456                 if(*value == '=') {
1457                         value++;
1458                         value += strspn(value, "\t ");
1459                 }
1460                 if(!rstrip(value))
1461                         continue;
1462                 buf[len] = 0;
1463                 if(strcasecmp(buf, "Ed25519PublicKey"))
1464                         continue;
1465                 if(*value)
1466                         return ecdsa_set_base64_public_key(value);
1467         }
1468
1469         return NULL;
1470 }
1471
1472 const var_t variables[] = {
1473         /* Server configuration */
1474         {"AddressFamily", VAR_SERVER},
1475         {"AutoConnect", VAR_SERVER | VAR_SAFE},
1476         {"BindToAddress", VAR_SERVER | VAR_MULTIPLE},
1477         {"BindToInterface", VAR_SERVER},
1478         {"Broadcast", VAR_SERVER | VAR_SAFE},
1479         {"BroadcastSubnet", VAR_SERVER | VAR_MULTIPLE | VAR_SAFE},
1480         {"ConnectTo", VAR_SERVER | VAR_MULTIPLE | VAR_SAFE},
1481         {"DecrementTTL", VAR_SERVER},
1482         {"Device", VAR_SERVER},
1483         {"DeviceStandby", VAR_SERVER},
1484         {"DeviceType", VAR_SERVER},
1485         {"DirectOnly", VAR_SERVER},
1486         {"Ed25519PrivateKeyFile", VAR_SERVER},
1487         {"ExperimentalProtocol", VAR_SERVER},
1488         {"Forwarding", VAR_SERVER},
1489         {"GraphDumpFile", VAR_SERVER | VAR_OBSOLETE},
1490         {"Hostnames", VAR_SERVER},
1491         {"IffOneQueue", VAR_SERVER},
1492         {"Interface", VAR_SERVER},
1493         {"KeyExpire", VAR_SERVER},
1494         {"ListenAddress", VAR_SERVER | VAR_MULTIPLE},
1495         {"LocalDiscovery", VAR_SERVER},
1496         {"MACExpire", VAR_SERVER},
1497         {"MaxConnectionBurst", VAR_SERVER},
1498         {"MaxOutputBufferSize", VAR_SERVER},
1499         {"MaxTimeout", VAR_SERVER},
1500         {"Mode", VAR_SERVER | VAR_SAFE},
1501         {"Name", VAR_SERVER},
1502         {"PingInterval", VAR_SERVER},
1503         {"PingTimeout", VAR_SERVER},
1504         {"PriorityInheritance", VAR_SERVER},
1505         {"PrivateKey", VAR_SERVER | VAR_OBSOLETE},
1506         {"PrivateKeyFile", VAR_SERVER},
1507         {"ProcessPriority", VAR_SERVER},
1508         {"Proxy", VAR_SERVER},
1509         {"ReplayWindow", VAR_SERVER},
1510         {"ScriptsExtension", VAR_SERVER},
1511         {"ScriptsInterpreter", VAR_SERVER},
1512         {"StrictSubnets", VAR_SERVER},
1513         {"TunnelServer", VAR_SERVER},
1514         {"UDPDiscovery", VAR_SERVER},
1515         {"UDPDiscoveryKeepaliveInterval", VAR_SERVER},
1516         {"UDPDiscoveryInterval", VAR_SERVER},
1517         {"UDPDiscoveryTimeout", VAR_SERVER},
1518         {"MTUInfoInterval", VAR_SERVER},
1519         {"UDPInfoInterval", VAR_SERVER},
1520         {"UDPRcvBuf", VAR_SERVER},
1521         {"UDPSndBuf", VAR_SERVER},
1522         {"UPnP", VAR_SERVER},
1523         {"UPnPDiscoverWait", VAR_SERVER},
1524         {"UPnPRefreshPeriod", VAR_SERVER},
1525         {"VDEGroup", VAR_SERVER},
1526         {"VDEPort", VAR_SERVER},
1527         /* Host configuration */
1528         {"Address", VAR_HOST | VAR_MULTIPLE},
1529         {"Cipher", VAR_SERVER | VAR_HOST},
1530         {"ClampMSS", VAR_SERVER | VAR_HOST},
1531         {"Compression", VAR_SERVER | VAR_HOST},
1532         {"Digest", VAR_SERVER | VAR_HOST},
1533         {"Ed25519PublicKey", VAR_HOST},
1534         {"Ed25519PublicKeyFile", VAR_SERVER | VAR_HOST},
1535         {"IndirectData", VAR_SERVER | VAR_HOST},
1536         {"MACLength", VAR_SERVER | VAR_HOST},
1537         {"PMTU", VAR_SERVER | VAR_HOST},
1538         {"PMTUDiscovery", VAR_SERVER | VAR_HOST},
1539         {"Port", VAR_HOST},
1540         {"PublicKey", VAR_HOST | VAR_OBSOLETE},
1541         {"PublicKeyFile", VAR_SERVER | VAR_HOST | VAR_OBSOLETE},
1542         {"Subnet", VAR_HOST | VAR_MULTIPLE | VAR_SAFE},
1543         {"TCPOnly", VAR_SERVER | VAR_HOST},
1544         {"Weight", VAR_HOST | VAR_SAFE},
1545         {NULL, 0}
1546 };
1547
1548 static int cmd_config(int argc, char *argv[]) {
1549         if(argc < 2) {
1550                 fprintf(stderr, "Invalid number of arguments.\n");
1551                 return 1;
1552         }
1553
1554         if(strcasecmp(argv[0], "config"))
1555                 argv--, argc++;
1556
1557         int action = -2;
1558         if(!strcasecmp(argv[1], "get")) {
1559                 argv++, argc--;
1560         } else if(!strcasecmp(argv[1], "add")) {
1561                 argv++, argc--, action = 1;
1562         } else if(!strcasecmp(argv[1], "del")) {
1563                 argv++, argc--, action = -1;
1564         } else if(!strcasecmp(argv[1], "replace") || !strcasecmp(argv[1], "set") || !strcasecmp(argv[1], "change")) {
1565                 argv++, argc--, action = 0;
1566         }
1567
1568         if(argc < 2) {
1569                 fprintf(stderr, "Invalid number of arguments.\n");
1570                 return 1;
1571         }
1572
1573         // Concatenate the rest of the command line
1574         strncpy(line, argv[1], sizeof line - 1);
1575         for(int i = 2; i < argc; i++) {
1576                 strncat(line, " ", sizeof line - 1 - strlen(line));
1577                 strncat(line, argv[i], sizeof line - 1 - strlen(line));
1578         }
1579
1580         // Liberal parsing into node name, variable name and value.
1581         char *node = NULL;
1582         char *variable;
1583         char *value;
1584         int len;
1585
1586         len = strcspn(line, "\t =");
1587         value = line + len;
1588         value += strspn(value, "\t ");
1589         if(*value == '=') {
1590                 value++;
1591                 value += strspn(value, "\t ");
1592         }
1593         line[len] = '\0';
1594         variable = strchr(line, '.');
1595         if(variable) {
1596                 node = line;
1597                 *variable++ = 0;
1598         } else {
1599                 variable = line;
1600         }
1601
1602         if(!*variable) {
1603                 fprintf(stderr, "No variable given.\n");
1604                 return 1;
1605         }
1606
1607         if(action >= 0 && !*value) {
1608                 fprintf(stderr, "No value for variable given.\n");
1609                 return 1;
1610         }
1611
1612         if(action < -1 && *value)
1613                 action = 0;
1614
1615         /* Some simple checks. */
1616         bool found = false;
1617         bool warnonremove = false;
1618
1619         for(int i = 0; variables[i].name; i++) {
1620                 if(strcasecmp(variables[i].name, variable))
1621                         continue;
1622
1623                 found = true;
1624                 variable = (char *)variables[i].name;
1625
1626                 /* Discourage use of obsolete variables. */
1627
1628                 if(variables[i].type & VAR_OBSOLETE && action >= 0) {
1629                         if(force) {
1630                                 fprintf(stderr, "Warning: %s is an obsolete variable!\n", variable);
1631                         } else {
1632                                 fprintf(stderr, "%s is an obsolete variable! Use --force to use it anyway.\n", variable);
1633                                 return 1;
1634                         }
1635                 }
1636
1637                 /* Don't put server variables in host config files */
1638
1639                 if(node && !(variables[i].type & VAR_HOST) && action >= 0) {
1640                         if(force) {
1641                                 fprintf(stderr, "Warning: %s is not a host configuration variable!\n", variable);
1642                         } else {
1643                                 fprintf(stderr, "%s is not a host configuration variable! Use --force to use it anyway.\n", variable);
1644                                 return 1;
1645                         }
1646                 }
1647
1648                 /* Should this go into our own host config file? */
1649
1650                 if(!node && !(variables[i].type & VAR_SERVER)) {
1651                         node = get_my_name(true);
1652                         if(!node)
1653                                 return 1;
1654                 }
1655
1656                 /* Change "add" into "set" for variables that do not allow multiple occurences.
1657                    Turn on warnings when it seems variables might be removed unintentionally. */
1658
1659                 if(action == 1 && !(variables[i].type & VAR_MULTIPLE)) {
1660                         warnonremove = true;
1661                         action = 0;
1662                 } else if(action == 0 && (variables[i].type & VAR_MULTIPLE)) {
1663                         warnonremove = true;
1664                 }
1665
1666                 break;
1667         }
1668
1669         if(node && !check_id(node)) {
1670                 fprintf(stderr, "Invalid name for node.\n");
1671                 return 1;
1672         }
1673
1674         if(!found) {
1675                 if(force || action < 0) {
1676                         fprintf(stderr, "Warning: %s is not a known configuration variable!\n", variable);
1677                 } else {
1678                         fprintf(stderr, "%s: is not a known configuration variable! Use --force to use it anyway.\n", variable);
1679                         return 1;
1680                 }
1681         }
1682
1683         // Open the right configuration file.
1684         char filename[PATH_MAX];
1685         if(node)
1686                 snprintf(filename, sizeof filename, "%s" SLASH "%s", hosts_dir, node);
1687         else
1688                 snprintf(filename, sizeof filename, "%s", tinc_conf);
1689
1690         FILE *f = fopen(filename, "r");
1691         if(!f) {
1692                 fprintf(stderr, "Could not open configuration file %s: %s\n", filename, strerror(errno));
1693                 return 1;
1694         }
1695
1696         char tmpfile[PATH_MAX];
1697         FILE *tf = NULL;
1698
1699         if(action >= -1) {
1700                 snprintf(tmpfile, sizeof tmpfile, "%s.config.tmp", filename);
1701                 tf = fopen(tmpfile, "w");
1702                 if(!tf) {
1703                         fprintf(stderr, "Could not open temporary file %s: %s\n", tmpfile, strerror(errno));
1704                         fclose(f);
1705                         return 1;
1706                 }
1707         }
1708
1709         // Copy the file, making modifications on the fly, unless we are just getting a value.
1710         char buf1[4096];
1711         char buf2[4096];
1712         bool set = false;
1713         bool removed = false;
1714         found = false;
1715
1716         while(fgets(buf1, sizeof buf1, f)) {
1717                 buf1[sizeof buf1 - 1] = 0;
1718                 strncpy(buf2, buf1, sizeof buf2);
1719
1720                 // Parse line in a simple way
1721                 char *bvalue;
1722                 int len;
1723
1724                 len = strcspn(buf2, "\t =");
1725                 bvalue = buf2 + len;
1726                 bvalue += strspn(bvalue, "\t ");
1727                 if(*bvalue == '=') {
1728                         bvalue++;
1729                         bvalue += strspn(bvalue, "\t ");
1730                 }
1731                 rstrip(bvalue);
1732                 buf2[len] = '\0';
1733
1734                 // Did it match?
1735                 if(!strcasecmp(buf2, variable)) {
1736                         // Get
1737                         if(action < -1) {
1738                                 found = true;
1739                                 printf("%s\n", bvalue);
1740                         // Del
1741                         } else if(action == -1) {
1742                                 if(!*value || !strcasecmp(bvalue, value)) {
1743                                         removed = true;
1744                                         continue;
1745                                 }
1746                         // Set
1747                         } else if(action == 0) {
1748                                 // Warn if "set" was used for variables that can occur multiple times
1749                                 if(warnonremove && strcasecmp(bvalue, value))
1750                                         fprintf(stderr, "Warning: removing %s = %s\n", variable, bvalue);
1751
1752                                 // Already set? Delete the rest...
1753                                 if(set)
1754                                         continue;
1755
1756                                 // Otherwise, replace.
1757                                 if(fprintf(tf, "%s = %s\n", variable, value) < 0) {
1758                                         fprintf(stderr, "Error writing to temporary file %s: %s\n", tmpfile, strerror(errno));
1759                                         return 1;
1760                                 }
1761                                 set = true;
1762                                 continue;
1763                         // Add
1764                         } else if(action > 0) {
1765                                 // Check if we've already seen this variable with the same value
1766                                 if(!strcasecmp(bvalue, value))
1767                                         found = true;
1768                         }
1769                 }
1770
1771                 if(action >= -1) {
1772                         // Copy original line...
1773                         if(fputs(buf1, tf) < 0) {
1774                                 fprintf(stderr, "Error writing to temporary file %s: %s\n", tmpfile, strerror(errno));
1775                                 return 1;
1776                         }
1777
1778                         // Add newline if it is missing...
1779                         if(*buf1 && buf1[strlen(buf1) - 1] != '\n') {
1780                                 if(fputc('\n', tf) < 0) {
1781                                         fprintf(stderr, "Error writing to temporary file %s: %s\n", tmpfile, strerror(errno));
1782                                         return 1;
1783                                 }
1784                         }
1785                 }
1786         }
1787
1788         // Make sure we read everything...
1789         if(ferror(f) || !feof(f)) {
1790                 fprintf(stderr, "Error while reading from configuration file %s: %s\n", filename, strerror(errno));
1791                 return 1;
1792         }
1793
1794         if(fclose(f)) {
1795                 fprintf(stderr, "Error closing configuration file %s: %s\n", filename, strerror(errno));
1796                 return 1;
1797         }
1798
1799         // Add new variable if necessary.
1800         if((action > 0 && !found)|| (action == 0 && !set)) {
1801                 if(fprintf(tf, "%s = %s\n", variable, value) < 0) {
1802                         fprintf(stderr, "Error writing to temporary file %s: %s\n", tmpfile, strerror(errno));
1803                         return 1;
1804                 }
1805         }
1806
1807         if(action < -1) {
1808                 if(found) {
1809                         return 0;
1810                 } else {
1811                         fprintf(stderr, "No matching configuration variables found.\n");
1812                         return 1;
1813                 }
1814         }
1815
1816         // Make sure we wrote everything...
1817         if(fclose(tf)) {
1818                 fprintf(stderr, "Error closing temporary file %s: %s\n", tmpfile, strerror(errno));
1819                 return 1;
1820         }
1821
1822         // Could we find what we had to remove?
1823         if(action < 0 && !removed) {
1824                 remove(tmpfile);
1825                 fprintf(stderr, "No configuration variables deleted.\n");
1826                 return 1;
1827         }
1828
1829         // Replace the configuration file with the new one
1830 #ifdef HAVE_MINGW
1831         if(remove(filename)) {
1832                 fprintf(stderr, "Error replacing file %s: %s\n", filename, strerror(errno));
1833                 return 1;
1834         }
1835 #endif
1836         if(rename(tmpfile, filename)) {
1837                 fprintf(stderr, "Error renaming temporary file %s to configuration file %s: %s\n", tmpfile, filename, strerror(errno));
1838                 return 1;
1839         }
1840
1841         // Silently try notifying a running tincd of changes.
1842         if(connect_tincd(false))
1843                 sendline(fd, "%d %d", CONTROL, REQ_RELOAD);
1844
1845         return 0;
1846 }
1847
1848 static bool try_bind(int port) {
1849         struct addrinfo *ai = NULL, *aip;
1850         struct addrinfo hint = {
1851                 .ai_flags = AI_PASSIVE,
1852                 .ai_family = AF_UNSPEC,
1853                 .ai_socktype = SOCK_STREAM,
1854                 .ai_protocol = IPPROTO_TCP,
1855         };
1856
1857         bool success = true;
1858         char portstr[16];
1859         snprintf(portstr, sizeof portstr, "%d", port);
1860
1861         if(getaddrinfo(NULL, portstr, &hint, &ai) || !ai)
1862                 return false;
1863
1864         for(aip = ai; aip; aip = aip->ai_next) {
1865                 int fd = socket(ai->ai_family, SOCK_STREAM, IPPROTO_TCP);
1866                 if(!fd) {
1867                         success = false;
1868                         break;
1869                 }
1870
1871                 int result = bind(fd, ai->ai_addr, ai->ai_addrlen);
1872                 closesocket(fd);
1873                 if(result) {
1874                         success = false;
1875                         break;
1876                 }
1877         }
1878
1879         freeaddrinfo(ai);
1880         return success;
1881 }
1882
1883 int check_port(char *name) {
1884         if(try_bind(655))
1885                 return 655;
1886
1887         fprintf(stderr, "Warning: could not bind to port 655. ");
1888
1889         for(int i = 0; i < 100; i++) {
1890                 int port = 0x1000 + (rand() & 0x7fff);
1891                 if(try_bind(port)) {
1892                         char filename[PATH_MAX];
1893                         snprintf(filename, sizeof filename, "%s" SLASH "hosts" SLASH "%s", confbase, name);
1894                         FILE *f = fopen(filename, "a");
1895                         if(!f) {
1896                                 fprintf(stderr, "Could not open %s: %s\n", filename, strerror(errno));
1897                                 fprintf(stderr, "Please change tinc's Port manually.\n");
1898                                 return 0;
1899                         }
1900
1901                         fprintf(f, "Port = %d\n", port);
1902                         fclose(f);
1903                         fprintf(stderr, "Tinc will instead listen on port %d.\n", port);
1904                         return port;
1905                 }
1906         }
1907
1908         fprintf(stderr, "Please change tinc's Port manually.\n");
1909         return 0;
1910 }
1911
1912 static int cmd_init(int argc, char *argv[]) {
1913         if(!access(tinc_conf, F_OK)) {
1914                 fprintf(stderr, "Configuration file %s already exists!\n", tinc_conf);
1915                 return 1;
1916         }
1917
1918         if(argc > 2) {
1919                 fprintf(stderr, "Too many arguments!\n");
1920                 return 1;
1921         } else if(argc < 2) {
1922                 if(tty) {
1923                         char buf[1024];
1924                         fprintf(stderr, "Enter the Name you want your tinc node to have: ");
1925                         if(!fgets(buf, sizeof buf, stdin)) {
1926                                 fprintf(stderr, "Error while reading stdin: %s\n", strerror(errno));
1927                                 return 1;
1928                         }
1929                         int len = rstrip(buf);
1930                         if(!len) {
1931                                 fprintf(stderr, "No name given!\n");
1932                                 return 1;
1933                         }
1934                         name = strdup(buf);
1935                 } else {
1936                         fprintf(stderr, "No Name given!\n");
1937                         return 1;
1938                 }
1939         } else {
1940                 name = strdup(argv[1]);
1941                 if(!*name) {
1942                         fprintf(stderr, "No Name given!\n");
1943                         return 1;
1944                 }
1945         }
1946
1947         if(!check_id(name)) {
1948                 fprintf(stderr, "Invalid Name! Only a-z, A-Z, 0-9 and _ are allowed characters.\n");
1949                 return 1;
1950         }
1951
1952         if(!confbase_given && mkdir(confdir, 0755) && errno != EEXIST) {
1953                 fprintf(stderr, "Could not create directory %s: %s\n", confdir, strerror(errno));
1954                 return 1;
1955         }
1956
1957         if(mkdir(confbase, 0777) && errno != EEXIST) {
1958                 fprintf(stderr, "Could not create directory %s: %s\n", confbase, strerror(errno));
1959                 return 1;
1960         }
1961
1962         if(mkdir(hosts_dir, 0777) && errno != EEXIST) {
1963                 fprintf(stderr, "Could not create directory %s: %s\n", hosts_dir, strerror(errno));
1964                 return 1;
1965         }
1966
1967         FILE *f = fopen(tinc_conf, "w");
1968         if(!f) {
1969                 fprintf(stderr, "Could not create file %s: %s\n", tinc_conf, strerror(errno));
1970                 return 1;
1971         }
1972
1973         fprintf(f, "Name = %s\n", name);
1974         fclose(f);
1975
1976 #ifndef DISABLE_LEGACY
1977         if(!rsa_keygen(2048, false))
1978                 return 1;
1979 #endif
1980
1981         if(!ed25519_keygen(false))
1982                 return 1;
1983
1984         check_port(name);
1985
1986 #ifndef HAVE_MINGW
1987         char filename[PATH_MAX];
1988         snprintf(filename, sizeof filename, "%s" SLASH "tinc-up", confbase);
1989         if(access(filename, F_OK)) {
1990                 FILE *f = fopenmask(filename, "w", 0777);
1991                 if(!f) {
1992                         fprintf(stderr, "Could not create file %s: %s\n", filename, strerror(errno));
1993                         return 1;
1994                 }
1995                 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");
1996                 fclose(f);
1997         }
1998 #endif
1999
2000         return 0;
2001
2002 }
2003
2004 static int cmd_generate_keys(int argc, char *argv[]) {
2005 #ifdef DISABLE_LEGACY
2006         if(argc > 1) {
2007 #else
2008         if(argc > 2) {
2009 #endif
2010                 fprintf(stderr, "Too many arguments!\n");
2011                 return 1;
2012         }
2013
2014         if(!name)
2015                 name = get_my_name(false);
2016
2017 #ifndef DISABLE_LEGACY
2018         if(!rsa_keygen(argc > 1 ? atoi(argv[1]) : 2048, true))
2019                 return 1;
2020 #endif
2021
2022         if(!ed25519_keygen(true))
2023                 return 1;
2024
2025         return 0;
2026 }
2027
2028 #ifndef DISABLE_LEGACY
2029 static int cmd_generate_rsa_keys(int argc, char *argv[]) {
2030         if(argc > 2) {
2031                 fprintf(stderr, "Too many arguments!\n");
2032                 return 1;
2033         }
2034
2035         if(!name)
2036                 name = get_my_name(false);
2037
2038         return !rsa_keygen(argc > 1 ? atoi(argv[1]) : 2048, true);
2039 }
2040 #endif
2041
2042 static int cmd_generate_ed25519_keys(int argc, char *argv[]) {
2043         if(argc > 1) {
2044                 fprintf(stderr, "Too many arguments!\n");
2045                 return 1;
2046         }
2047
2048         if(!name)
2049                 name = get_my_name(false);
2050
2051         return !ed25519_keygen(true);
2052 }
2053
2054 static int cmd_help(int argc, char *argv[]) {
2055         usage(false);
2056         return 0;
2057 }
2058
2059 static int cmd_version(int argc, char *argv[]) {
2060         if(argc > 1) {
2061                 fprintf(stderr, "Too many arguments!\n");
2062                 return 1;
2063         }
2064
2065         version();
2066         return 0;
2067 }
2068
2069 static int cmd_info(int argc, char *argv[]) {
2070         if(argc != 2) {
2071                 fprintf(stderr, "Invalid number of arguments.\n");
2072                 return 1;
2073         }
2074
2075         if(!connect_tincd(true))
2076                 return 1;
2077
2078         return info(fd, argv[1]);
2079 }
2080
2081 static const char *conffiles[] = {
2082         "tinc.conf",
2083         "tinc-up",
2084         "tinc-down",
2085         "subnet-up",
2086         "subnet-down",
2087         "host-up",
2088         "host-down",
2089         NULL,
2090 };
2091
2092 static int cmd_edit(int argc, char *argv[]) {
2093         if(argc != 2) {
2094                 fprintf(stderr, "Invalid number of arguments.\n");
2095                 return 1;
2096         }
2097
2098         char filename[PATH_MAX] = "";
2099
2100         if(strncmp(argv[1], "hosts" SLASH, 6)) {
2101                 for(int i = 0; conffiles[i]; i++) {
2102                         if(!strcmp(argv[1], conffiles[i])) {
2103                                 snprintf(filename, sizeof filename, "%s" SLASH "%s", confbase, argv[1]);
2104                                 break;
2105                         }
2106                 }
2107         } else {
2108                 argv[1] += 6;
2109         }
2110
2111         if(!*filename) {
2112                 snprintf(filename, sizeof filename, "%s" SLASH "%s", hosts_dir, argv[1]);
2113                 char *dash = strchr(argv[1], '-');
2114                 if(dash) {
2115                         *dash++ = 0;
2116                         if((strcmp(dash, "up") && strcmp(dash, "down")) || !check_id(argv[1])) {
2117                                 fprintf(stderr, "Invalid configuration filename.\n");
2118                                 return 1;
2119                         }
2120                 }
2121         }
2122
2123         char *command;
2124 #ifndef HAVE_MINGW
2125         xasprintf(&command, "\"%s\" \"%s\"", getenv("VISUAL") ?: getenv("EDITOR") ?: "vi", filename);
2126 #else
2127         xasprintf(&command, "edit \"%s\"", filename);
2128 #endif
2129         int result = system(command);
2130         free(command);
2131         if(result)
2132                 return result;
2133
2134         // Silently try notifying a running tincd of changes.
2135         if(connect_tincd(false))
2136                 sendline(fd, "%d %d", CONTROL, REQ_RELOAD);
2137
2138         return 0;
2139 }
2140
2141 static int export(const char *name, FILE *out) {
2142         char filename[PATH_MAX];
2143         snprintf(filename, sizeof filename, "%s" SLASH "%s", hosts_dir, name);
2144         FILE *in = fopen(filename, "r");
2145         if(!in) {
2146                 fprintf(stderr, "Could not open configuration file %s: %s\n", filename, strerror(errno));
2147                 return 1;
2148         }
2149
2150         fprintf(out, "Name = %s\n", name);
2151         char buf[4096];
2152         while(fgets(buf, sizeof buf, in)) {
2153                 if(strcspn(buf, "\t =") != 4 || strncasecmp(buf, "Name", 4))
2154                         fputs(buf, out);
2155         }
2156
2157         if(ferror(in)) {
2158                 fprintf(stderr, "Error while reading configuration file %s: %s\n", filename, strerror(errno));
2159                 fclose(in);
2160                 return 1;
2161         }
2162
2163         fclose(in);
2164         return 0;
2165 }
2166
2167 static int cmd_export(int argc, char *argv[]) {
2168         if(argc > 1) {
2169                 fprintf(stderr, "Too many arguments!\n");
2170                 return 1;
2171         }
2172
2173         char *name = get_my_name(true);
2174         if(!name)
2175                 return 1;
2176
2177         int result = export(name, stdout);
2178         if(!tty)
2179                 fclose(stdout);
2180
2181         free(name);
2182         return result;
2183 }
2184
2185 static int cmd_export_all(int argc, char *argv[]) {
2186         if(argc > 1) {
2187                 fprintf(stderr, "Too many arguments!\n");
2188                 return 1;
2189         }
2190
2191         DIR *dir = opendir(hosts_dir);
2192         if(!dir) {
2193                 fprintf(stderr, "Could not open host configuration directory %s: %s\n", hosts_dir, strerror(errno));
2194                 return 1;
2195         }
2196
2197         bool first = true;
2198         int result = 0;
2199         struct dirent *ent;
2200
2201         while((ent = readdir(dir))) {
2202                 if(!check_id(ent->d_name))
2203                         continue;
2204
2205                 if(first)
2206                         first = false;
2207                 else
2208                         printf("#---------------------------------------------------------------#\n");
2209
2210                 result |= export(ent->d_name, stdout);
2211         }
2212
2213         closedir(dir);
2214         if(!tty)
2215                 fclose(stdout);
2216         return result;
2217 }
2218
2219 static int cmd_import(int argc, char *argv[]) {
2220         if(argc > 1) {
2221                 fprintf(stderr, "Too many arguments!\n");
2222                 return 1;
2223         }
2224
2225         FILE *in = stdin;
2226         FILE *out = NULL;
2227
2228         char buf[4096];
2229         char name[4096];
2230         char filename[PATH_MAX] = "";
2231         int count = 0;
2232         bool firstline = true;
2233
2234         while(fgets(buf, sizeof buf, in)) {
2235                 if(sscanf(buf, "Name = %4095s", name) == 1) {
2236                         firstline = false;
2237
2238                         if(!check_id(name)) {
2239                                 fprintf(stderr, "Invalid Name in input!\n");
2240                                 return 1;
2241                         }
2242
2243                         if(out)
2244                                 fclose(out);
2245
2246                         snprintf(filename, sizeof filename, "%s" SLASH "%s", hosts_dir, name);
2247
2248                         if(!force && !access(filename, F_OK)) {
2249                                 fprintf(stderr, "Host configuration file %s already exists, skipping.\n", filename);
2250                                 out = NULL;
2251                                 continue;
2252                         }
2253
2254                         out = fopen(filename, "w");
2255                         if(!out) {
2256                                 fprintf(stderr, "Error creating configuration file %s: %s\n", filename, strerror(errno));
2257                                 return 1;
2258                         }
2259
2260                         count++;
2261                         continue;
2262                 } else if(firstline) {
2263                         fprintf(stderr, "Junk at the beginning of the input, ignoring.\n");
2264                         firstline = false;
2265                 }
2266
2267
2268                 if(!strcmp(buf, "#---------------------------------------------------------------#\n"))
2269                         continue;
2270
2271                 if(out) {
2272                         if(fputs(buf, out) < 0) {
2273                                 fprintf(stderr, "Error writing to host configuration file %s: %s\n", filename, strerror(errno));
2274                                 return 1;
2275                         }
2276                 }
2277         }
2278
2279         if(out)
2280                 fclose(out);
2281
2282         if(count) {
2283                 fprintf(stderr, "Imported %d host configuration files.\n", count);
2284                 return 0;
2285         } else {
2286                 fprintf(stderr, "No host configuration files imported.\n");
2287                 return 1;
2288         }
2289 }
2290
2291 static int cmd_exchange(int argc, char *argv[]) {
2292         return cmd_export(argc, argv) ?: cmd_import(argc, argv);
2293 }
2294
2295 static int cmd_exchange_all(int argc, char *argv[]) {
2296         return cmd_export_all(argc, argv) ?: cmd_import(argc, argv);
2297 }
2298
2299 static int switch_network(char *name) {
2300         if(strcmp(name, ".")) {
2301                 if(!check_netname(name, false)) {
2302                         fprintf(stderr, "Invalid character in netname!\n");
2303                         return 1;
2304                 }
2305
2306                 if(!check_netname(name, true))
2307                         fprintf(stderr, "Warning: unsafe character in netname!\n");
2308         }
2309
2310         if(fd >= 0) {
2311                 close(fd);
2312                 fd = -1;
2313         }
2314
2315         free_names();
2316         netname = strcmp(name, ".") ? xstrdup(name) : NULL;
2317         make_names(false);
2318
2319         free(tinc_conf);
2320         free(hosts_dir);
2321         free(prompt);
2322
2323         xasprintf(&tinc_conf, "%s" SLASH "tinc.conf", confbase);
2324         xasprintf(&hosts_dir, "%s" SLASH "hosts", confbase);
2325         xasprintf(&prompt, "%s> ", identname);
2326
2327         return 0;
2328 }
2329
2330 static int cmd_network(int argc, char *argv[]) {
2331         if(argc > 2) {
2332                 fprintf(stderr, "Too many arguments!\n");
2333                 return 1;
2334         }
2335
2336         if(argc == 2)
2337                 return switch_network(argv[1]);
2338
2339         DIR *dir = opendir(confdir);
2340         if(!dir) {
2341                 fprintf(stderr, "Could not read directory %s: %s\n", confdir, strerror(errno));
2342                 return 1;
2343         }
2344
2345         struct dirent *ent;
2346         while((ent = readdir(dir))) {
2347                 if(*ent->d_name == '.')
2348                         continue;
2349
2350                 if(!strcmp(ent->d_name, "tinc.conf")) {
2351                         printf(".\n");
2352                         continue;
2353                 }
2354
2355                 char fname[PATH_MAX];
2356                 snprintf(fname, sizeof fname, "%s/%s/tinc.conf", confdir, ent->d_name);
2357                 if(!access(fname, R_OK))
2358                         printf("%s\n", ent->d_name);
2359         }
2360
2361         closedir(dir);
2362
2363         return 0;
2364 }
2365
2366 static int cmd_fsck(int argc, char *argv[]) {
2367         if(argc > 1) {
2368                 fprintf(stderr, "Too many arguments!\n");
2369                 return 1;
2370         }
2371
2372         return fsck(orig_argv[0]);
2373 }
2374
2375 static void *readfile(FILE *in, size_t *len) {
2376         size_t count = 0;
2377         size_t alloced = 4096;
2378         char *buf = xmalloc(alloced);
2379
2380         while(!feof(in)) {
2381                 size_t read = fread(buf + count, 1, alloced - count, in);
2382                 if(!read)
2383                         break;
2384                 count += read;
2385                 if(count >= alloced) {
2386                         alloced *= 2;
2387                         buf = xrealloc(buf, alloced);
2388                 }
2389         }
2390
2391         if(len)
2392                 *len = count;
2393
2394         return buf;
2395 }
2396
2397 static int cmd_sign(int argc, char *argv[]) {
2398         if(argc > 2) {
2399                 fprintf(stderr, "Too many arguments!\n");
2400                 return 1;
2401         }
2402
2403         if(!name) {
2404                 name = get_my_name(true);
2405                 if(!name)
2406                         return 1;
2407         }
2408
2409         char fname[PATH_MAX];
2410         snprintf(fname, sizeof fname, "%s" SLASH "ed25519_key.priv", confbase);
2411         FILE *fp = fopen(fname, "r");
2412         if(!fp) {
2413                 fprintf(stderr, "Could not open %s: %s\n", fname, strerror(errno));
2414                 return 1;
2415         }
2416
2417         ecdsa_t *key = ecdsa_read_pem_private_key(fp);
2418
2419         if(!key) {
2420                 fprintf(stderr, "Could not read private key from %s\n", fname);
2421                 fclose(fp);
2422                 return 1;
2423         }
2424
2425         fclose(fp);
2426
2427         FILE *in;
2428
2429         if(argc == 2) {
2430                 in = fopen(argv[1], "rb");
2431                 if(!in) {
2432                         fprintf(stderr, "Could not open %s: %s\n", argv[1], strerror(errno));
2433                         ecdsa_free(key);
2434                         return 1;
2435                 }
2436         } else {
2437                 in = stdin;
2438         }
2439
2440         size_t len;
2441         char *data = readfile(in, &len);
2442         if(in != stdin)
2443                 fclose(in);
2444         if(!data) {
2445                 fprintf(stderr, "Error reading %s: %s\n", argv[1], strerror(errno));
2446                 ecdsa_free(key);
2447                 return 1;
2448         }
2449
2450         // Ensure we sign our name and current time as well
2451         long t = time(NULL);
2452         char *trailer;
2453         xasprintf(&trailer, " %s %ld", name, t);
2454         int trailer_len = strlen(trailer);
2455
2456         data = xrealloc(data, len + trailer_len);
2457         memcpy(data + len, trailer, trailer_len);
2458         free(trailer);
2459
2460         char sig[87];
2461         if(!ecdsa_sign(key, data, len + trailer_len, sig)) {
2462                 fprintf(stderr, "Error generating signature\n");
2463                 free(data);
2464                 ecdsa_free(key);
2465                 return 1;
2466         }
2467         b64encode(sig, sig, 64);
2468         ecdsa_free(key);
2469
2470         fprintf(stdout, "Signature = %s %ld %s\n", name, t, sig);
2471         fwrite(data, len, 1, stdout);
2472
2473         free(data);
2474         return 0;
2475 }
2476
2477 static int cmd_verify(int argc, char *argv[]) {
2478         if(argc < 2) {
2479                 fprintf(stderr, "Not enough arguments!\n");
2480                 return 1;
2481         }
2482
2483         if(argc > 3) {
2484                 fprintf(stderr, "Too many arguments!\n");
2485                 return 1;
2486         }
2487
2488         char *node = argv[1];
2489         if(!strcmp(node, ".")) {
2490                 if(!name) {
2491                         name = get_my_name(true);
2492                         if(!name)
2493                                 return 1;
2494                 }
2495                 node = name;
2496         } else if(!strcmp(node, "*")) {
2497                 node = NULL;
2498         } else {
2499                 if(!check_id(node)) {
2500                         fprintf(stderr, "Invalid node name\n");
2501                         return 1;
2502                 }
2503         }
2504
2505         FILE *in;
2506
2507         if(argc == 3) {
2508                 in = fopen(argv[2], "rb");
2509                 if(!in) {
2510                         fprintf(stderr, "Could not open %s: %s\n", argv[2], strerror(errno));
2511                         return 1;
2512                 }
2513         } else {
2514                 in = stdin;
2515         }
2516
2517         size_t len;
2518         char *data = readfile(in, &len);
2519         if(in != stdin)
2520                 fclose(in);
2521         if(!data) {
2522                 fprintf(stderr, "Error reading %s: %s\n", argv[1], strerror(errno));
2523                 return 1;
2524         }
2525
2526         char *newline = memchr(data, '\n', len);
2527         if(!newline || (newline - data > MAX_STRING_SIZE - 1)) {
2528                 fprintf(stderr, "Invalid input\n");
2529                 free(data);
2530                 return 1;
2531         }
2532
2533         *newline++ = '\0';
2534         size_t skip = newline - data;
2535
2536         char signer[MAX_STRING_SIZE] = "";
2537         char sig[MAX_STRING_SIZE] = "";
2538         long t = 0;
2539
2540         if(sscanf(data, "Signature = %s %ld %s", signer, &t, sig) != 3 || strlen(sig) != 86 || !t || !check_id(signer)) {
2541                 fprintf(stderr, "Invalid input\n");
2542                 free(data);
2543                 return 1;
2544         }
2545
2546         if(node && strcmp(node, signer)) {
2547                 fprintf(stderr, "Signature is not made by %s\n", node);
2548                 free(data);
2549                 return 1;
2550         }
2551
2552         if(!node)
2553                 node = signer;
2554
2555         char *trailer;
2556         xasprintf(&trailer, " %s %ld", signer, t);
2557         int trailer_len = strlen(trailer);
2558
2559         data = xrealloc(data, len + trailer_len);
2560         memcpy(data + len, trailer, trailer_len);
2561         free(trailer);
2562
2563         newline = data + skip;
2564
2565         char fname[PATH_MAX];
2566         snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, node);
2567         FILE *fp = fopen(fname, "r");
2568         if(!fp) {
2569                 fprintf(stderr, "Could not open %s: %s\n", fname, strerror(errno));
2570                 free(data);
2571                 return 1;
2572         }
2573
2574         ecdsa_t *key = get_pubkey(fp);
2575         if(!key) {
2576                 rewind(fp);
2577                 key = ecdsa_read_pem_public_key(fp);
2578         }
2579         if(!key) {
2580                 fprintf(stderr, "Could not read public key from %s\n", fname);
2581                 fclose(fp);
2582                 free(data);
2583                 return 1;
2584         }
2585
2586         fclose(fp);
2587
2588         if(b64decode(sig, sig, 86) != 64 || !ecdsa_verify(key, newline, len + trailer_len - (newline - data), sig)) {
2589                 fprintf(stderr, "Invalid signature\n");
2590                 free(data);
2591                 ecdsa_free(key);
2592                 return 1;
2593         }
2594
2595         ecdsa_free(key);
2596
2597         fwrite(newline, len - (newline - data), 1, stdout);
2598
2599         free(data);
2600         return 0;
2601 }
2602
2603 static const struct {
2604         const char *command;
2605         int (*function)(int argc, char *argv[]);
2606         bool hidden;
2607 } commands[] = {
2608         {"start", cmd_start},
2609         {"stop", cmd_stop},
2610         {"restart", cmd_restart},
2611         {"reload", cmd_reload},
2612         {"dump", cmd_dump},
2613         {"list", cmd_dump},
2614         {"purge", cmd_purge},
2615         {"debug", cmd_debug},
2616         {"retry", cmd_retry},
2617         {"connect", cmd_connect},
2618         {"disconnect", cmd_disconnect},
2619         {"top", cmd_top},
2620         {"pcap", cmd_pcap},
2621         {"log", cmd_log},
2622         {"pid", cmd_pid},
2623         {"config", cmd_config, true},
2624         {"add", cmd_config},
2625         {"del", cmd_config},
2626         {"get", cmd_config},
2627         {"set", cmd_config},
2628         {"init", cmd_init},
2629         {"generate-keys", cmd_generate_keys},
2630 #ifndef DISABLE_LEGACY
2631         {"generate-rsa-keys", cmd_generate_rsa_keys},
2632 #endif
2633         {"generate-ed25519-keys", cmd_generate_ed25519_keys},
2634         {"help", cmd_help},
2635         {"version", cmd_version},
2636         {"info", cmd_info},
2637         {"edit", cmd_edit},
2638         {"export", cmd_export},
2639         {"export-all", cmd_export_all},
2640         {"import", cmd_import},
2641         {"exchange", cmd_exchange},
2642         {"exchange-all", cmd_exchange_all},
2643         {"invite", cmd_invite},
2644         {"join", cmd_join},
2645         {"network", cmd_network},
2646         {"fsck", cmd_fsck},
2647         {"sign", cmd_sign},
2648         {"verify", cmd_verify},
2649         {NULL, NULL},
2650 };
2651
2652 #ifdef HAVE_READLINE
2653 static char *complete_command(const char *text, int state) {
2654         static int i;
2655
2656         if(!state)
2657                 i = 0;
2658         else
2659                 i++;
2660
2661         while(commands[i].command) {
2662                 if(!commands[i].hidden && !strncasecmp(commands[i].command, text, strlen(text)))
2663                         return xstrdup(commands[i].command);
2664                 i++;
2665         }
2666
2667         return NULL;
2668 }
2669
2670 static char *complete_dump(const char *text, int state) {
2671         const char *matches[] = {"reachable", "nodes", "edges", "subnets", "connections", "graph", NULL};
2672         static int i;
2673
2674         if(!state)
2675                 i = 0;
2676         else
2677                 i++;
2678
2679         while(matches[i]) {
2680                 if(!strncasecmp(matches[i], text, strlen(text)))
2681                         return xstrdup(matches[i]);
2682                 i++;
2683         }
2684
2685         return NULL;
2686 }
2687
2688 static char *complete_config(const char *text, int state) {
2689         static int i;
2690
2691         if(!state)
2692                 i = 0;
2693         else
2694                 i++;
2695
2696         while(variables[i].name) {
2697                 char *dot = strchr(text, '.');
2698                 if(dot) {
2699                         if((variables[i].type & VAR_HOST) && !strncasecmp(variables[i].name, dot + 1, strlen(dot + 1))) {
2700                                 char *match;
2701                                 xasprintf(&match, "%.*s.%s", (int)(dot - text), text, variables[i].name);
2702                                 return match;
2703                         }
2704                 } else {
2705                         if(!strncasecmp(variables[i].name, text, strlen(text)))
2706                                 return xstrdup(variables[i].name);
2707                 }
2708                 i++;
2709         }
2710
2711         return NULL;
2712 }
2713
2714 static char *complete_info(const char *text, int state) {
2715         static int i;
2716         if(!state) {
2717                 i = 0;
2718                 if(!connect_tincd(false))
2719                         return NULL;
2720                 // Check the list of nodes
2721                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_NODES);
2722                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_SUBNETS);
2723         }
2724
2725         while(recvline(fd, line, sizeof line)) {
2726                 char item[4096];
2727                 int n = sscanf(line, "%d %d %4095s", &code, &req, item);
2728                 if(n == 2) {
2729                         i++;
2730                         if(i >= 2)
2731                                 break;
2732                         else
2733                                 continue;
2734                 }
2735
2736                 if(n != 3) {
2737                         fprintf(stderr, "Unable to parse dump from tincd, n = %d, i = %d.\n", n, i);
2738                         break;
2739                 }
2740
2741                 if(!strncmp(item, text, strlen(text)))
2742                         return xstrdup(strip_weight(item));
2743         }
2744
2745         return NULL;
2746 }
2747
2748 static char *complete_nothing(const char *text, int state) {
2749         return NULL;
2750 }
2751
2752 static char **completion (const char *text, int start, int end) {
2753         char **matches = NULL;
2754
2755         if(!start)
2756                 matches = rl_completion_matches(text, complete_command);
2757         else if(!strncasecmp(rl_line_buffer, "dump ", 5))
2758                 matches = rl_completion_matches(text, complete_dump);
2759         else if(!strncasecmp(rl_line_buffer, "add ", 4))
2760                 matches = rl_completion_matches(text, complete_config);
2761         else if(!strncasecmp(rl_line_buffer, "del ", 4))
2762                 matches = rl_completion_matches(text, complete_config);
2763         else if(!strncasecmp(rl_line_buffer, "get ", 4))
2764                 matches = rl_completion_matches(text, complete_config);
2765         else if(!strncasecmp(rl_line_buffer, "set ", 4))
2766                 matches = rl_completion_matches(text, complete_config);
2767         else if(!strncasecmp(rl_line_buffer, "info ", 5))
2768                 matches = rl_completion_matches(text, complete_info);
2769
2770         return matches;
2771 }
2772 #endif
2773
2774 static int cmd_shell(int argc, char *argv[]) {
2775         xasprintf(&prompt, "%s> ", identname);
2776         int result = 0;
2777         char buf[4096];
2778         char *line = NULL;
2779         int maxargs = argc + 16;
2780         char **nargv = xmalloc(maxargs * sizeof *nargv);
2781
2782         for(int i = 0; i < argc; i++)
2783                 nargv[i] = argv[i];
2784
2785 #ifdef HAVE_READLINE
2786         rl_readline_name = "tinc";
2787         rl_completion_entry_function = complete_nothing;
2788         rl_attempted_completion_function = completion;
2789         rl_filename_completion_desired = 0;
2790         char *copy = NULL;
2791 #endif
2792
2793         while(true) {
2794 #ifdef HAVE_READLINE
2795                 if(tty) {
2796                         free(copy);
2797                         free(line);
2798                         rl_basic_word_break_characters = "\t\n ";
2799                         line = readline(prompt);
2800                         if(line)
2801                                 copy = xstrdup(line);
2802                 } else {
2803                         line = fgets(buf, sizeof buf, stdin);
2804                 }
2805 #else
2806                 if(tty)
2807                         fputs(prompt, stdout);
2808
2809                 line = fgets(buf, sizeof buf, stdin);
2810 #endif
2811
2812                 if(!line)
2813                         break;
2814
2815                 /* Ignore comments */
2816
2817                 if(*line == '#')
2818                         continue;
2819
2820                 /* Split */
2821
2822                 int nargc = argc;
2823                 char *p = line + strspn(line, " \t\n");
2824                 char *next = strtok(p, " \t\n");
2825
2826                 while(p && *p) {
2827                         if(nargc >= maxargs) {
2828                                 maxargs *= 2;
2829                                 nargv = xrealloc(nargv, maxargs * sizeof *nargv);
2830                         }
2831
2832                         nargv[nargc++] = p;
2833                         p = next;
2834                         next = strtok(NULL, " \t\n");
2835                 }
2836
2837                 if(nargc == argc)
2838                         continue;
2839
2840                 if(!strcasecmp(nargv[argc], "exit") || !strcasecmp(nargv[argc], "quit")) {
2841                         free(nargv);
2842                         return result;
2843                 }
2844
2845                 bool found = false;
2846
2847                 for(int i = 0; commands[i].command; i++) {
2848                         if(!strcasecmp(nargv[argc], commands[i].command)) {
2849                                 result |= commands[i].function(nargc - argc - 1, nargv + argc + 1);
2850                                 found = true;
2851                                 break;
2852                         }
2853                 }
2854
2855 #ifdef HAVE_READLINE
2856                 if(tty && found)
2857                         add_history(copy);
2858 #endif
2859
2860                 if(!found) {
2861                         fprintf(stderr, "Unknown command `%s'.\n", nargv[argc]);
2862                         result |= 1;
2863                 }
2864         }
2865
2866         free(nargv);
2867
2868         if(tty)
2869                 printf("\n");
2870         return result;
2871 }
2872
2873
2874 int main(int argc, char *argv[]) {
2875         program_name = argv[0];
2876         orig_argv = argv;
2877         orig_argc = argc;
2878         tty = isatty(0) && isatty(1);
2879
2880         if(!parse_options(argc, argv))
2881                 return 1;
2882
2883         make_names(false);
2884         xasprintf(&tinc_conf, "%s" SLASH "tinc.conf", confbase);
2885         xasprintf(&hosts_dir, "%s" SLASH "hosts", confbase);
2886
2887         if(show_version) {
2888                 version();
2889                 return 0;
2890         }
2891
2892         if(show_help) {
2893                 usage(false);
2894                 return 0;
2895         }
2896
2897 #ifdef HAVE_MINGW
2898         static struct WSAData wsa_state;
2899
2900         if(WSAStartup(MAKEWORD(2, 2), &wsa_state)) {
2901                 fprintf(stderr, "System call `%s' failed: %s", "WSAStartup", winerror(GetLastError()));
2902                 return false;
2903         }
2904 #endif
2905
2906         srand(time(NULL));
2907         crypto_init();
2908
2909         if(optind >= argc)
2910                 return cmd_shell(argc, argv);
2911
2912         for(int i = 0; commands[i].command; i++) {
2913                 if(!strcasecmp(argv[optind], commands[i].command))
2914                         return commands[i].function(argc - optind, argv + optind);
2915         }
2916
2917         fprintf(stderr, "Unknown command `%s'.\n", argv[optind]);
2918         usage(true);
2919         return 1;
2920 }