git.meshlink.io Git - meshlink/blob - src/libmeshlink.c

   1 /*
   2     libmeshlink.h -- Tincd Library
   3     Copyright (C) 2014 Guus Sliepen <guus@tinc-vpn.org> Saverio Proto <zioproto@gmail.com>
   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 "libmeshlink.h"
  21 #include LZO1X_H
  22 #ifdef HAVE_SYS_MMAN_H
  23 #include <sys/mman.h>
  24 #endif
  25 #include "crypto.h"
  26 #include "ecdsagen.h"
  27 char *hosts_dir = NULL;
  28 static char *name = NULL;
  29 char *tinc_conf = NULL;
  30 static bool tty = false;
  31
  32 #ifdef HAVE_MLOCKALL
  33 /* If nonzero, disable swapping for this process. */
  34 static bool do_mlock = false;
  35 #endif
  36
  37 /*
  38   initialize network
  39 */
  40 bool setup_meshlink_network(void) {
  41         init_connections();
  42         init_subnets();
  43         init_nodes();
  44         init_edges();
  45         init_requests();
  46
  47         if(get_config_int(lookup_config(config_tree, "PingInterval"), &pinginterval)) {
  48                 if(pinginterval < 1) {
  49                         pinginterval = 86400;
  50                 }
  51         } else
  52                 pinginterval = 60;
  53
  54         if(!get_config_int(lookup_config(config_tree, "PingTimeout"), &pingtimeout))
  55                 pingtimeout = 5;
  56         if(pingtimeout < 1 || pingtimeout > pinginterval)
  57                 pingtimeout = pinginterval;
  58
  59         //TODO: check if this makes sense in libmeshlink
  60         if(!get_config_int(lookup_config(config_tree, "MaxOutputBufferSize"), &maxoutbufsize))
  61                 maxoutbufsize = 10 * MTU;
  62
  63         if(!setup_myself())
  64                 return false;
  65
  66         if(!init_control())
  67                 return false;
  68
  69         /* Run subnet-up scripts for our own subnets */
  70
  71         subnet_update(myself, NULL, true);
  72
  73         return true;
  74 }
  75
  76 /* Open a file with the desired permissions, minus the umask.
  77    Also, if we want to create an executable file, we call fchmod()
  78    to set the executable bits. */
  79
  80 FILE *fopenmask(const char *filename, const char *mode, mode_t perms) {
  81         mode_t mask = umask(0);
  82         perms &= ~mask;
  83         umask(~perms);
  84         FILE *f = fopen(filename, mode);
  85 #ifdef HAVE_FCHMOD
  86         if((perms & 0444) && f)
  87                 fchmod(fileno(f), perms);
  88 #endif
  89         umask(mask);
  90         return f;
  91 }
  92
  93 static void disable_old_keys(const char *filename, const char *what) {
  94         char tmpfile[PATH_MAX] = "";
  95         char buf[1024];
  96         bool disabled = false;
  97         bool block = false;
  98         bool error = false;
  99         FILE *r, *w;
 100
 101         r = fopen(filename, "r");
 102         if(!r)
 103                 return;
 104
 105         snprintf(tmpfile, sizeof tmpfile, "%s.tmp", filename);
 106
 107         struct stat st = {.st_mode = 0600};
 108         fstat(fileno(r), &st);
 109         w = fopenmask(tmpfile, "w", st.st_mode);
 110
 111         while(fgets(buf, sizeof buf, r)) {
 112                 if(!block && !strncmp(buf, "-----BEGIN ", 11)) {
 113                         if((strstr(buf, " EC ") && strstr(what, "ECDSA")) || (strstr(buf, " RSA ") && strstr(what, "RSA"))) {
 114                                 disabled = true;
 115                                 block = true;
 116                         }
 117                 }
 118
 119                 bool ecdsapubkey = !strncasecmp(buf, "ECDSAPublicKey", 14) && strchr(" \t=", buf[14]) && strstr(what, "ECDSA");
 120
 121                 if(ecdsapubkey)
 122                         disabled = true;
 123
 124                 if(w) {
 125                         if(block || ecdsapubkey)
 126                                 fputc('#', w);
 127                         if(fputs(buf, w) < 0) {
 128                                 error = true;
 129                                 break;
 130                         }
 131                 }
 132
 133                 if(block && !strncmp(buf, "-----END ", 9))
 134                         block = false;
 135         }
 136
 137         if(w)
 138                 if(fclose(w) < 0)
 139                         error = true;
 140         if(ferror(r) || fclose(r) < 0)
 141                 error = true;
 142
 143         if(disabled) {
 144                 if(!w || error) {
 145                         fprintf(stderr, "Warning: old key(s) found, remove them by hand!\n");
 146                         if(w)
 147                                 unlink(tmpfile);
 148                         return;
 149                 }
 150
 151 #ifdef HAVE_MINGW
 152                 // We cannot atomically replace files on Windows.
 153                 char bakfile[PATH_MAX] = "";
 154                 snprintf(bakfile, sizeof bakfile, "%s.bak", filename);
 155                 if(rename(filename, bakfile) || rename(tmpfile, filename)) {
 156                         rename(bakfile, filename);
 157 #else
 158                 if(rename(tmpfile, filename)) {
 159 #endif
 160                         fprintf(stderr, "Warning: old key(s) found, remove them by hand!\n");
 161                 } else  {
 162 #ifdef HAVE_MINGW
 163                         unlink(bakfile);
 164 #endif
 165                         fprintf(stderr, "Warning: old key(s) found and disabled.\n");
 166                 }
 167         }
 168
 169         unlink(tmpfile);
 170 }
 171
 172 static FILE *ask_and_open(const char *filename, const char *what, const char *mode, bool ask, mode_t perms) {
 173         FILE *r;
 174         char *directory;
 175         char buf[PATH_MAX];
 176         char buf2[PATH_MAX];
 177
 178         /* Check stdin and stdout */
 179         if(ask && tty) {
 180                 /* Ask for a file and/or directory name. */
 181                 fprintf(stderr, "Please enter a file to save %s to [%s]: ", what, filename);
 182
 183                 if(fgets(buf, sizeof buf, stdin) == NULL) {
 184                         fprintf(stderr, "Error while reading stdin: %s\n", strerror(errno));
 185                         return NULL;
 186                 }
 187
 188                 size_t len = strlen(buf);
 189                 if(len)
 190                         buf[--len] = 0;
 191
 192                 if(len)
 193                         filename = buf;
 194         }
 195
 196 #ifdef HAVE_MINGW
 197         if(filename[0] != '\\' && filename[0] != '/' && !strchr(filename, ':')) {
 198 #else
 199         if(filename[0] != '/') {
 200 #endif
 201                 /* The directory is a relative path or a filename. */
 202                 directory = get_current_dir_name();
 203                 snprintf(buf2, sizeof buf2, "%s" SLASH "%s", directory, filename);
 204                 filename = buf2;
 205         }
 206
 207         disable_old_keys(filename, what);
 208
 209         /* Open it first to keep the inode busy */
 210
 211         r = fopenmask(filename, mode, perms);
 212
 213         if(!r) {
 214                 fprintf(stderr, "Error opening file `%s': %s\n", filename, strerror(errno));
 215                 return NULL;
 216         }
 217
 218         return r;
 219 }
 220
 221 /*
 222   Generate a public/private ECDSA keypair, and ask for a file to store
 223   them in.
 224 */
 225 bool ecdsa_keygen(bool ask) {
 226         ecdsa_t *key;
 227         FILE *f;
 228         char *pubname, *privname;
 229
 230         fprintf(stderr, "Generating ECDSA keypair:\n");
 231
 232         if(!(key = ecdsa_generate())) {
 233                 fprintf(stderr, "Error during key generation!\n");
 234                 return false;
 235         } else
 236                 fprintf(stderr, "Done.\n");
 237
 238         xasprintf(&privname, "%s" SLASH "ecdsa_key.priv", confbase);
 239         f = ask_and_open(privname, "private ECDSA key", "a", ask, 0600);
 240         free(privname);
 241
 242         if(!f)
 243                 return false;
 244
 245         if(!ecdsa_write_pem_private_key(key, f)) {
 246                 fprintf(stderr, "Error writing private key!\n");
 247                 ecdsa_free(key);
 248                 fclose(f);
 249                 return false;
 250         }
 251
 252         fclose(f);
 253
 254         if(name)
 255                 xasprintf(&pubname, "%s" SLASH "hosts" SLASH "%s", confbase, name);
 256         else
 257                 xasprintf(&pubname, "%s" SLASH "ecdsa_key.pub", confbase);
 258
 259         f = ask_and_open(pubname, "public ECDSA key", "a", ask, 0666);
 260         free(pubname);
 261
 262         if(!f)
 263                 return false;
 264
 265         char *pubkey = ecdsa_get_base64_public_key(key);
 266         fprintf(f, "ECDSAPublicKey = %s\n", pubkey);
 267         free(pubkey);
 268
 269         fclose(f);
 270         ecdsa_free(key);
 271
 272         return true;
 273 }
 274
 275 /*
 276   Generate a public/private RSA keypair, and ask for a file to store
 277   them in.
 278 */
 279 bool rsa_keygen(int bits, bool ask) {
 280         rsa_t *key;
 281         FILE *f;
 282         char *pubname, *privname;
 283
 284         fprintf(stderr, "Generating %d bits keys:\n", bits);
 285
 286         if(!(key = rsa_generate(bits, 0x10001))) {
 287                 fprintf(stderr, "Error during key generation!\n");
 288                 return false;
 289         } else
 290                 fprintf(stderr, "Done.\n");
 291
 292         xasprintf(&privname, "%s" SLASH "rsa_key.priv", confbase);
 293         f = ask_and_open(privname, "private RSA key", "a", ask, 0600);
 294         free(privname);
 295
 296         if(!f)
 297                 return false;
 298
 299         if(!rsa_write_pem_private_key(key, f)) {
 300                 fprintf(stderr, "Error writing private key!\n");
 301                 fclose(f);
 302                 rsa_free(key);
 303                 return false;
 304         }
 305
 306         fclose(f);
 307
 308         if(name)
 309                 xasprintf(&pubname, "%s" SLASH "hosts" SLASH "%s", confbase, name);
 310         else
 311                 xasprintf(&pubname, "%s" SLASH "rsa_key.pub", confbase);
 312
 313         f = ask_and_open(pubname, "public RSA key", "a", ask, 0666);
 314         free(pubname);
 315
 316         if(!f)
 317                 return false;
 318
 319         if(!rsa_write_pem_public_key(key, f)) {
 320                 fprintf(stderr, "Error writing public key!\n");
 321                 fclose(f);
 322                 rsa_free(key);
 323                 return false;
 324         }
 325
 326         fclose(f);
 327         rsa_free(key);
 328
 329         return true;
 330 }
 331
 332 static bool try_bind(int port) {
 333         struct addrinfo *ai = NULL;
 334         struct addrinfo hint = {
 335                 .ai_flags = AI_PASSIVE,
 336                 .ai_family = AF_UNSPEC,
 337                 .ai_socktype = SOCK_STREAM,
 338                 .ai_protocol = IPPROTO_TCP,
 339         };
 340
 341         char portstr[16];
 342         snprintf(portstr, sizeof portstr, "%d", port);
 343
 344         if(getaddrinfo(NULL, portstr, &hint, &ai) || !ai)
 345                 return false;
 346
 347         while(ai) {
 348                 int fd = socket(ai->ai_family, SOCK_STREAM, IPPROTO_TCP);
 349                 if(!fd)
 350                         return false;
 351                 int result = bind(fd, ai->ai_addr, ai->ai_addrlen);
 352                 closesocket(fd);
 353                 if(result)
 354                         return false;
 355                 ai = ai->ai_next;
 356         }
 357
 358         return true;
 359 }
 360
 361 int check_port(char *name) {
 362         if(try_bind(655))
 363                 return 655;
 364
 365         fprintf(stderr, "Warning: could not bind to port 655. ");
 366
 367         for(int i = 0; i < 100; i++) {
 368                 int port = 0x1000 + (rand() & 0x7fff);
 369                 if(try_bind(port)) {
 370                         char *filename;
 371                         xasprintf(&filename, "%s" SLASH "hosts" SLASH "%s", confbase, name);
 372                         FILE *f = fopen(filename, "a");
 373                         free(filename);
 374                         if(!f) {
 375                                 fprintf(stderr, "Please change tinc's Port manually.\n");
 376                                 return 0;
 377                         }
 378
 379                         fprintf(f, "Port = %d\n", port);
 380                         fclose(f);
 381                         fprintf(stderr, "Tinc will instead listen on port %d.\n", port);
 382                         return port;
 383                 }
 384         }
 385
 386         fprintf(stderr, "Please change tinc's Port manually.\n");
 387         return 0;
 388 }
 389 //tinc_setup() should basically do what cmd_init() from src/tincctl.c does, except it doesn't have to generate a tinc-up script.
 390 bool tinc_setup(const char* confbaseapi, const char* name) {
 391         confbase = confbaseapi;
 392         make_names();
 393         xasprintf(&tinc_conf, "%s" SLASH "tinc.conf", confbase);
 394         xasprintf(&hosts_dir, "%s" SLASH "hosts", confbase);
 395         if(!access(tinc_conf, F_OK)) {
 396                 fprintf(stderr, "Configuration file %s already exists!\n", tinc_conf);
 397                 return false;
 398         }
 399
 400         if(!check_id(name)) {
 401                 fprintf(stderr, "Invalid Name! Only a-z, A-Z, 0-9 and _ are allowed characters.\n");
 402                 return false;
 403         }
 404
 405         if(!confbase_given && mkdir(confdir, 0755) && errno != EEXIST) {
 406                 fprintf(stderr, "Could not create directory %s: %s\n", confdir, strerror(errno));
 407                 return false;
 408         }
 409
 410         if(mkdir(confbase, 0777) && errno != EEXIST) {
 411                 fprintf(stderr, "Could not create directory %s: %s\n", confbase, strerror(errno));
 412                 return false;
 413         }
 414
 415         if(mkdir(hosts_dir, 0777) && errno != EEXIST) {
 416                 fprintf(stderr, "Could not create directory %s: %s\n", hosts_dir, strerror(errno));
 417                 return false;
 418         }
 419
 420         FILE *f = fopen(tinc_conf, "w");
 421         if(!f) {
 422                 fprintf(stderr, "Could not create file %s: %s\n", tinc_conf, strerror(errno));
 423                 return 1;
 424         }
 425
 426         fprintf(f, "Name = %s\n", name);
 427         fclose(f);
 428
 429         if(!rsa_keygen(2048, false) || !ecdsa_keygen(false))
 430                 return false;
 431
 432         check_port(name);
 433
 434         return true;
 435
 436 }
 437
 438
 439 bool tinc_start(const char* confbaseapi) {
 440         pthread_t tincThread;
 441         confbase = confbaseapi;
 442         pthread_create(&tincThread,NULL,tinc_main_thread,confbaseapi);
 443         pthread_detach(tincThread);
 444 return true;
 445 }
 446
 447 bool tinc_main_thread(void * in) {
 448
 449 static bool status = false;
 450
 451 /* If nonzero, write log entries to a separate file. */
 452 bool use_logfile = false;
 453
 454 confbase = (char*) in;
 455
 456         openlogger("tinc", use_logfile?LOGMODE_FILE:LOGMODE_STDERR);
 457
 458         init_configuration(&config_tree);
 459
 460         /* Slllluuuuuuurrrrp! */
 461
 462         gettimeofday(&now, NULL);
 463         srand(now.tv_sec + now.tv_usec);
 464         crypto_init();
 465
 466         if(!read_server_config())
 467                 return false;
 468
 469 #ifdef HAVE_LZO
 470         if(lzo_init() != LZO_E_OK) {
 471                 logger(DEBUG_ALWAYS, LOG_ERR, "Error initializing LZO compressor!");
 472                 return false;
 473         }
 474 #endif
 475
 476         //char *priority = NULL; //shoud be not needed in libmeshlink
 477
 478 #ifdef HAVE_MLOCKALL
 479         /* Lock all pages into memory if requested.
 480          * This has to be done after daemon()/fork() so it works for child.
 481          * No need to do that in parent as it's very short-lived. */
 482         if(do_mlock && mlockall(MCL_CURRENT | MCL_FUTURE) != 0) {
 483                 logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "mlockall",
 484                    strerror(errno));
 485                 return 1;
 486         }
 487 #endif
 488
 489         /* Setup sockets and open device. */
 490
 491         if(!setup_meshlink_network())
 492                 goto end;
 493
 494         /* Change process priority */
 495         //should be not needed in libmeshlink
 496         //if(get_config_string(lookup_config(config_tree, "ProcessPriority"), &priority)) {
 497         //      if(!strcasecmp(priority, "Normal")) {
 498         //              if (setpriority(NORMAL_PRIORITY_CLASS) != 0) {
 499         //                      logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setpriority", strerror(errno));
 500         //                      goto end;
 501         //              }
 502         //      } else if(!strcasecmp(priority, "Low")) {
 503         //              if (setpriority(BELOW_NORMAL_PRIORITY_CLASS) != 0) {
 504         //                             logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setpriority", strerror(errno));
 505         //                      goto end;
 506         //              }
 507         //      } else if(!strcasecmp(priority, "High")) {
 508         //              if (setpriority(HIGH_PRIORITY_CLASS) != 0) {
 509         //                      logger(DEBUG_ALWAYS, LOG_ERR, "System call `%s' failed: %s", "setpriority", strerror(errno));
 510         //                      goto end;
 511         //              }
 512         //      } else {
 513         //              logger(DEBUG_ALWAYS, LOG_ERR, "Invalid priority `%s`!", priority);
 514         //              goto end;
 515         //      }
 516         //}
 517
 518         /* drop privileges */
 519         //if (!drop_privs())
 520         //      goto end;
 521
 522         /* Start main loop. It only exits when tinc is killed. */
 523
 524         logger(DEBUG_ALWAYS, LOG_NOTICE, "Ready");
 525
 526         try_outgoing_connections();
 527
 528         status = main_loop();
 529
 530         /* Shutdown properly. */
 531
 532 end:
 533         close_network_connections();
 534
 535         logger(DEBUG_ALWAYS, LOG_NOTICE, "Terminating");
 536
 537         //free(priority);
 538
 539         crypto_exit();
 540
 541         exit_configuration(&config_tree);
 542         free(cmdline_conf);
 543         free_names();
 544
 545         return status;
 546
 547 }
 548
 549 bool tinc_stop();
 550
 551 bool route_meshlink(node_t *source,vpn_packet_t *packet) {
 552
 553         printf("data %s\n",packet->data);
 554         printf("data 11%s\n",packet->data+11);
 555         printf("data 32%s\n",packet->data+32);
 556         node_t* owner = NULL;
 557
 558         tincpackethdr* hdr = (tincpackethdr*)packet->data;
 559         owner = lookup_node(hdr->destination);
 560
 561         if (owner == NULL) {
 562         //Lookup failed
 563         printf("NULL\n");
 564         return false;
 565         }
 566         printf("lookupnode %s\n",owner->name);
 567
 568         if(!owner->status.reachable) {
 569         //Do some here
 570         return false;
 571         }
 572
 573         //TODO: I skipped here a lot of checks !
 574
 575         send_packet(owner,packet);
 576
 577 }
 578 // can be called from any thread
 579 bool tinc_send_packet(node_t *receiver, const char* buf, unsigned int len) {
 580
 581         vpn_packet_t packet;
 582         tincpackethdr* hdr = malloc(sizeof(tincpackethdr));
 583
 584         if (sizeof(hdr) + len > MAXSIZE) {
 585
 586         //log something
 587         return false;
 588         }
 589
 590         memcpy(hdr->destination,receiver->name,sizeof(hdr->destination));
 591         memcpy(hdr->source,myself->name,sizeof(hdr->source));
 592
 593         packet.priority = 0;
 594
 595         memcpy(packet.data,hdr,32);
 596         memcpy(packet.data+32,buf,len);
 597
 598         myself->in_packets++;
 599         myself->in_bytes += packet.len;
 600         route_meshlink(myself, &packet);
 601
 602 return true;
 603 }
 604
 605 // handler runs in tinc thread and should return immediately
 606 bool tinc_set_packet_receive_handler(void (*handler)(const char* sender, const char* buf, unsigned int len));
 607
 608
 609 //It might also be a good idea to add the option of looking up hosts by public
 610 //key (fingerprints) instead of names.
 611
 612 node_t *tinc_get_host(const char *name) {
 613
 614
 615
 616 };
 617
 618 bool tinc_get_hosts(node_t** hosts);
 619
 620 bool tinc_sign(const char* payload, unsigned int len, const char** signature);
 621
 622 int tinc_verify(const char* sender, const char* payload, unsigned int plen, const char* signature, unsigned int slen);
 623
 624 /*
 625 TODO: It would be good to add a void pointer here that will be passed on to the
 626 handler function whenever it is called, or have a void pointer in node_t
 627 that can be filled in by the application. That way, you can easily link an
 628 application-specific data structure to a node_t.
 629 */
 630 void channel_set_packet_send_handler(int (*handler)(const char* receiver, const char* buf, unsigned int len));
 631 void channel_packet_receive_handler(const char* sender, const char* buf, unsigned int len);
 632
 633 bool channel_open(const char* partner, void(*read)(int id, const char* buf, unsigned int len), void(*result)(int result, int id));
 634 void channel_close(int id);
 635 bool channel_write(int id, const char* buf, unsigned int len, void(*result)(int result, int id, unsigned int written));
 636
 637
 638 //We do need some more functions. First of all, we need to be able to add nodes
 639 //to a VPN. To do that, either an invitation protocol should be used:
 640
 641 bool tinc_join_network(const char *invitation);
 642 const char *tinc_generate_invitation(const char *name);
 643
 644 /*
 645 Or two nodes should exchange some information (their name, address, public
 646 key). If the application provides a way to exchange some data with another
 647 node, then:
 648 */
 649
 650 bool tinc_export(char *buf, size_t *len);
 651 node_t *tinc_import(const char *buf, size_t len);
 652 /*
 653 Last but not least, some way to get rid of unwanted nodes. Simplest is a
 654 function that just blacklists a node.
 655 Which should immediately cause the local tincd to ignore any data from that
 656 host from that point on. Of course, a somewhat centrally managed,
 657 automatically distributed blacklist or whitelist would be the next step.
 658 */
 659 bool tinc_blacklist(node_t *host);
 660
 661
 662
 663