Do not try to dereference myself->connection->config_tree.
[tinc] / src / tincctl.c
1 /*
2     tincctl.c -- Controlling a running tincd
3     Copyright (C) 2007-2009 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 #include "xalloc.h"
25 #include "protocol.h"
26 #include "control_common.h"
27 #include "rsagen.h"
28 #include "utils.h"
29
30 /* The name this program was run with. */
31 char *program_name = NULL;
32
33 /* If nonzero, display usage information and exit. */
34 bool show_help = false;
35
36 /* If nonzero, print the version on standard output and exit.  */
37 bool show_version = false;
38
39 /* If nonzero, it will attempt to kill a running tincd and exit. */
40 int kill_tincd = 0;
41
42 /* If nonzero, generate public/private keypair for this host/net. */
43 int generate_keys = 0;
44
45 static char *name = NULL;
46 static char *identname = NULL;                          /* program name for syslog */
47 static char *controlcookiename = NULL;                  /* cookie file location */
48 static char controlcookie[1024];
49 char *netname = NULL;
50 char *confbase = NULL;
51
52 #ifdef HAVE_MINGW
53 static struct WSAData wsa_state;
54 #endif
55
56 static struct option const long_options[] = {
57         {"config", required_argument, NULL, 'c'},
58         {"net", required_argument, NULL, 'n'},
59         {"help", no_argument, NULL, 1},
60         {"version", no_argument, NULL, 2},
61         {"controlcookie", required_argument, NULL, 5},
62         {NULL, 0, NULL, 0}
63 };
64
65 static void usage(bool status) {
66         if(status)
67                 fprintf(stderr, "Try `%s --help\' for more information.\n",
68                                 program_name);
69         else {
70                 printf("Usage: %s [options] command\n\n", program_name);
71                 printf("Valid options are:\n"
72                                 "  -c, --config=DIR              Read configuration options from DIR.\n"
73                                 "  -n, --net=NETNAME             Connect to net NETNAME.\n"
74                                 "      --controlcookie=FILENAME  Read control socket from FILENAME.\n"
75                                 "      --help                    Display this help and exit.\n"
76                                 "      --version                 Output version information and exit.\n"
77                                 "\n"
78                                 "Valid commands are:\n"
79                                 "  start                      Start tincd.\n"
80                                 "  stop                       Stop tincd.\n"
81                                 "  restart                    Restart tincd.\n"
82                                 "  reload                     Reload configuration of running tincd.\n"
83                                 "  pid                        Show PID of currently running tincd.\n"
84                                 "  generate-keys [bits]       Generate a new public/private keypair.\n"
85                                 "  dump                       Dump a list of one of the following things:\n"
86                                 "    nodes                    - all known nodes in the VPN\n"
87                                 "    edges                    - all known connections in the VPN\n"
88                                 "    subnets                  - all known subnets in the VPN\n"
89                                 "    connections              - all meta connections with ourself\n"
90                                 "    graph                    - graph of the VPN in dotty format\n"
91                                 "  purge                      Purge unreachable nodes\n"
92                                 "  debug N                    Set debug level\n"
93                                 "  retry                      Retry all outgoing connections\n"
94                                 "  reload                     Partial reload of configuration\n"
95                                 "  disconnect NODE            Close meta connection with NODE\n"
96                                 "\n");
97                 printf("Report bugs to tinc@tinc-vpn.org.\n");
98         }
99 }
100
101 static bool parse_options(int argc, char **argv) {
102         int r;
103         int option_index = 0;
104
105         while((r = getopt_long(argc, argv, "c:n:", long_options, &option_index)) != EOF) {
106                 switch (r) {
107                         case 0:                         /* long option */
108                                 break;
109
110                         case 'c':                               /* config file */
111                                 confbase = xstrdup(optarg);
112                                 break;
113
114                         case 'n':                               /* net name given */
115                                 netname = xstrdup(optarg);
116                                 break;
117
118                         case 1:                                 /* show help */
119                                 show_help = true;
120                                 break;
121
122                         case 2:                                 /* show version */
123                                 show_version = true;
124                                 break;
125
126                         case 5:                                 /* open control socket here */
127                                 controlcookiename = xstrdup(optarg);
128                                 break;
129
130                         case '?':
131                                 usage(true);
132                                 return false;
133
134                         default:
135                                 break;
136                 }
137         }
138
139         return true;
140 }
141
142 FILE *ask_and_open(const char *filename, const char *what, const char *mode) {
143         FILE *r;
144         char *directory;
145         char buf[PATH_MAX];
146         char buf2[PATH_MAX];
147         size_t len;
148
149         /* Check stdin and stdout */
150         if(isatty(0) && isatty(1)) {
151                 /* Ask for a file and/or directory name. */
152                 fprintf(stdout, "Please enter a file to save %s to [%s]: ",
153                                 what, filename);
154                 fflush(stdout);
155
156                 if(fgets(buf, sizeof buf, stdin) < 0) {
157                         fprintf(stderr, "Error while reading stdin: %s\n",
158                                         strerror(errno));
159                         return NULL;
160                 }
161
162                 len = strlen(buf);
163                 if(len)
164                         buf[--len] = 0;
165
166                 if(len)
167                         filename = buf;
168         }
169
170 #ifdef HAVE_MINGW
171         if(filename[0] != '\\' && filename[0] != '/' && !strchr(filename, ':')) {
172 #else
173         if(filename[0] != '/') {
174 #endif
175                 /* The directory is a relative path or a filename. */
176                 directory = get_current_dir_name();
177                 snprintf(buf2, sizeof buf2, "%s/%s", directory, filename);
178                 filename = buf2;
179         }
180
181         umask(0077);                            /* Disallow everything for group and other */
182
183         /* Open it first to keep the inode busy */
184
185         r = fopen(filename, mode);
186
187         if(!r) {
188                 fprintf(stderr, "Error opening file `%s': %s\n", filename, strerror(errno));
189                 return NULL;
190         }
191
192         return r;
193 }
194
195 /*
196   Generate a public/private RSA keypair, and ask for a file to store
197   them in.
198 */
199 static bool keygen(int bits) {
200         rsa_t key;
201         FILE *f;
202         char *filename;
203
204         fprintf(stderr, "Generating %d bits keys:\n", bits);
205
206         if(!rsa_generate(&key, bits, 0x10001)) {
207                 fprintf(stderr, "Error during key generation!\n");
208                 return false;
209         } else
210                 fprintf(stderr, "Done.\n");
211
212         xasprintf(&filename, "%s/rsa_key.priv", confbase);
213         f = ask_and_open(filename, "private RSA key", "a");
214
215         if(!f)
216                 return false;
217   
218 #ifdef HAVE_FCHMOD
219         /* Make it unreadable for others. */
220         fchmod(fileno(f), 0600);
221 #endif
222                 
223         if(ftell(f))
224                 fprintf(stderr, "Appending key to existing contents.\nMake sure only one key is stored in the file.\n");
225
226         rsa_write_pem_private_key(&key, f);
227
228         fclose(f);
229         free(filename);
230
231         if(name)
232                 xasprintf(&filename, "%s/hosts/%s", confbase, name);
233         else
234                 xasprintf(&filename, "%s/rsa_key.pub", confbase);
235
236         f = ask_and_open(filename, "public RSA key", "a");
237
238         if(!f)
239                 return false;
240
241         if(ftell(f))
242                 fprintf(stderr, "Appending key to existing contents.\nMake sure only one key is stored in the file.\n");
243
244         rsa_write_pem_public_key(&key, f);
245
246         fclose(f);
247         free(filename);
248
249         return true;
250 }
251
252 /*
253   Set all files and paths according to netname
254 */
255 static void make_names(void) {
256 #ifdef HAVE_MINGW
257         HKEY key;
258         char installdir[1024] = "";
259         long len = sizeof installdir;
260 #endif
261
262         if(netname)
263                 xasprintf(&identname, "tinc.%s", netname);
264         else
265                 identname = xstrdup("tinc");
266
267 #ifdef HAVE_MINGW
268         if(!RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\tinc", 0, KEY_READ, &key)) {
269                 if(!RegQueryValueEx(key, NULL, 0, 0, installdir, &len)) {
270                         if(!confbase) {
271                                 if(netname)
272                                         xasprintf(&confbase, "%s/%s", installdir, netname);
273                                 else
274                                         xasprintf(&confbase, "%s", installdir);
275                         }
276                 }
277                 if(!controlcookiename)
278                         xasprintf(&controlcookiename, "%s/cookie", confbase);
279                 RegCloseKey(key);
280                 if(*installdir)
281                         return;
282         }
283 #endif
284
285         if(!controlcookiename)
286                 xasprintf(&controlcookiename, "%s/run/%s.cookie", LOCALSTATEDIR, identname);
287
288         if(netname) {
289                 if(!confbase)
290                         xasprintf(&confbase, CONFDIR "/tinc/%s", netname);
291                 else
292                         fprintf(stderr, "Both netname and configuration directory given, using the latter...\n");
293         } else {
294                 if(!confbase)
295                         xasprintf(&confbase, CONFDIR "/tinc");
296         }
297 }
298
299 static bool recvline(int fd, char *line, size_t len) {
300         static char buffer[4096];
301         static size_t blen = 0;
302         char *newline = NULL;
303
304         while(!(newline = memchr(buffer, '\n', blen))) {
305                 int result = recv(fd, buffer + blen, sizeof buffer - blen, 0);
306                 if(result == -1 && errno == EINTR)
307                         continue;
308                 else if(result <= 0)
309                         return false;
310                 blen += result;
311         }
312
313         if(newline - buffer >= len)
314                 return false;
315
316         len = newline - buffer;
317
318         memcpy(line, buffer, len);
319         line[len] = 0;
320         memmove(buffer, newline + 1, blen - len - 1);
321         blen -= len + 1;
322
323         return true;
324 }
325
326 static bool sendline(int fd, char *format, ...) {
327         static char buffer[4096];
328         char *p = buffer;
329         size_t blen = 0;
330         va_list ap;
331
332         va_start(ap, format);
333         blen = vsnprintf(buffer, sizeof buffer, format, ap);
334         va_end(ap);
335
336         if(blen < 0 || blen >= sizeof buffer)
337                 return false;
338
339         buffer[blen] = '\n';
340         blen++;
341
342         while(blen) {
343                 int result = send(fd, p, blen, 0);
344                 if(result == -1 && errno == EINTR)
345                         continue;
346                 else if(result <= 0);
347                         return false;
348                 p += result;
349                 blen -= result;
350         }
351
352         return true;    
353 }
354
355 int main(int argc, char *argv[], char *envp[]) {
356         int fd;
357         int result;
358         int port;
359         int pid;
360
361         program_name = argv[0];
362
363         if(!parse_options(argc, argv))
364                 return 1;
365         
366         make_names();
367
368         if(show_version) {
369                 printf("%s version %s (built %s %s, protocol %d)\n", PACKAGE,
370                            VERSION, __DATE__, __TIME__, PROT_CURRENT);
371                 printf("Copyright (C) 1998-2009 Ivo Timmermans, Guus Sliepen and others.\n"
372                                 "See the AUTHORS file for a complete list.\n\n"
373                                 "tinc comes with ABSOLUTELY NO WARRANTY.  This is free software,\n"
374                                 "and you are welcome to redistribute it under certain conditions;\n"
375                                 "see the file COPYING for details.\n");
376
377                 return 0;
378         }
379
380         if(show_help) {
381                 usage(false);
382                 return 0;
383         }
384
385         if(optind >= argc) {
386                 fprintf(stderr, "Not enough arguments.\n");
387                 usage(true);
388                 return 1;
389         }
390
391         // First handle commands that don't involve connecting to a running tinc daemon.
392
393         if(!strcasecmp(argv[optind], "generate-keys")) {
394                 return !keygen(optind > argc ? atoi(argv[optind + 1]) : 2048);
395         }
396
397         if(!strcasecmp(argv[optind], "start")) {
398                 argv[optind] = NULL;
399                 execve(SBINDIR "/tincd", argv, envp);
400                 fprintf(stderr, "Could not start tincd: %s", strerror(errno));
401                 return 1;
402         }
403
404         /*
405          * Now handle commands that do involve connecting to a running tinc daemon.
406          * Authenticate the server by ensuring the parent directory can be
407          * traversed only by root. Note this is not totally race-free unless all
408          * ancestors are writable only by trusted users, which we don't verify.
409          */
410
411         FILE *f = fopen(controlcookiename, "r");
412         if(!f) {
413                 fprintf(stderr, "Could not open control socket cookie file %s: %s\n", controlcookiename, strerror(errno));
414                 return 1;
415         }
416         if(fscanf(f, "%1024s %d %d", controlcookie, &port, &pid) != 3) {
417                 fprintf(stderr, "Could not parse control socket cookie file %s\n", controlcookiename);
418                 return 1;
419         }
420
421 #ifdef HAVE_MINGW
422         if(WSAStartup(MAKEWORD(2, 2), &wsa_state)) {
423                 fprintf(stderr, "System call `%s' failed: %s", "WSAStartup", winerror(GetLastError()));
424                 return 1;
425         }
426 #endif
427
428         struct sockaddr_in addr;
429         memset(&addr, 0, sizeof addr);
430         addr.sin_family = AF_INET;
431         addr.sin_addr.s_addr = htonl(0x7f000001);
432         addr.sin_port = htons(port);
433
434         fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
435         if(fd < 0) {
436                 fprintf(stderr, "Cannot create TCP socket: %s\n", sockstrerror(sockerrno));
437                 return 1;
438         }
439
440 #ifdef HAVE_MINGW
441         unsigned long arg = 0;
442
443         if(ioctlsocket(fd, FIONBIO, &arg) != 0) {
444                 fprintf(stderr, "ioctlsocket failed: %s", sockstrerror(sockerrno));
445         }
446 #endif
447
448         if(connect(fd, (struct sockaddr *)&addr, sizeof addr) < 0) {
449                         
450                 fprintf(stderr, "Cannot connect to %s: %s\n", controlcookiename, sockstrerror(sockerrno));
451                 return 1;
452         }
453
454         char line[4096];
455         char data[4096];
456         int code, version, req;
457
458         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %s %d", &code, data, &version) != 3 || code != 0) {
459                 fprintf(stderr, "Cannot read greeting from control socket: %s\n",
460                                 sockstrerror(sockerrno));
461                 return 1;
462         }
463
464         sendline(fd, "%d ^%s %d", ID, controlcookie, TINC_CTL_VERSION_CURRENT);
465         
466         if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &version, &pid) != 3 || code != 4 || version != TINC_CTL_VERSION_CURRENT) {
467                 fprintf(stderr, "Could not fully establish control socket connection\n");
468                 return 1;
469         }
470
471         if(!strcasecmp(argv[optind], "pid")) {
472                 printf("%d\n", pid);
473                 return 0;
474         }
475
476         if(!strcasecmp(argv[optind], "stop")) {
477                 sendline(fd, "%d %d", CONTROL, REQ_STOP);
478                 if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_STOP || result) {
479                         fprintf(stderr, "Could not stop tinc daemon\n");
480                         return 1;
481                 }
482                 return 0;
483         }
484
485         if(!strcasecmp(argv[optind], "reload")) {
486                 sendline(fd, "%d %d", CONTROL, REQ_RELOAD);
487                 if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_RELOAD || result) {
488                         fprintf(stderr, "Could not reload tinc daemon\n");
489                         return 1;
490                 }
491                 return 0;
492         }
493
494         if(!strcasecmp(argv[optind], "restart")) {
495                 sendline(fd, "%d %d", CONTROL, REQ_RESTART);
496                 if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_RESTART || result) {
497                         fprintf(stderr, "Could not restart tinc daemon\n");
498                         return 1;
499                 }
500                 return 0;
501         }
502
503         if(!strcasecmp(argv[optind], "retry")) {
504                 sendline(fd, "%d %d", CONTROL, REQ_RETRY);
505                 if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_RETRY || result) {
506                         fprintf(stderr, "Could not retry outgoing connections\n");
507                         return 1;
508                 }
509                 return 0;
510         }
511
512         if(!strcasecmp(argv[optind], "dump")) {
513                 if(argc < optind + 2) {
514                         fprintf(stderr, "Not enough arguments.\n");
515                         usage(true);
516                         return 1;
517                 }
518
519                 bool do_graph = false;
520                 int dumps = 1;
521
522                 if(!strcasecmp(argv[optind+1], "nodes"))
523                         sendline(fd, "%d %d", CONTROL, REQ_DUMP_NODES);
524                 else if(!strcasecmp(argv[optind+1], "edges"))
525                         sendline(fd, "%d %d", CONTROL, REQ_DUMP_EDGES);
526                 else if(!strcasecmp(argv[optind+1], "subnets"))
527                         sendline(fd, "%d %d", CONTROL, REQ_DUMP_SUBNETS);
528                 else if(!strcasecmp(argv[optind+1], "connections"))
529                         sendline(fd, "%d %d", CONTROL, REQ_DUMP_CONNECTIONS);
530                 else if(!strcasecmp(argv[optind+1], "graph")) {
531                         sendline(fd, "%d %d", CONTROL, REQ_DUMP_NODES);
532                         sendline(fd, "%d %d", CONTROL, REQ_DUMP_EDGES);
533                         do_graph = true;
534                         dumps = 2;
535                         printf("digraph {\n");
536                 } else {
537                         fprintf(stderr, "Unknown dump type '%s'.\n", argv[optind+1]);
538                         usage(true);
539                         return 1;
540                 }
541
542                 while(recvline(fd, line, sizeof line)) {
543                         char node1[4096], node2[4096];
544                         int n = sscanf(line, "%d %d %s to %s", &code, &req, node1, node2);
545                         if(n == 2) {
546                                 if(do_graph && req == REQ_DUMP_NODES)
547                                         continue;
548                                 else {
549                                         if(do_graph)
550                                                 printf("}\n");
551                                         return 0;
552                                 }
553                         }
554                         if(n < 2)
555                                 break;
556
557                         if(!do_graph)
558                                 printf("%s\n", line + 5);
559                         else {
560                                 if(req == REQ_DUMP_NODES)
561                                         printf(" %s [label = \"%s\"];\n", node1, node1);
562                                 else
563                                         printf(" %s -> %s;\n", node1, node2);
564                         }
565                 }
566
567                 fprintf(stderr, "Error receiving dump\n");
568                 return 1;
569         }
570
571         if(!strcasecmp(argv[optind], "purge")) {
572                 sendline(fd, "%d %d", CONTROL, REQ_PURGE);
573                 if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_PURGE || result) {
574                         fprintf(stderr, "Could not purge tinc daemon\n");
575                         return 1;
576                 }
577                 return 0;
578         }
579
580         if(!strcasecmp(argv[optind], "debug")) {
581                 int debuglevel, origlevel;
582
583                 if(argc != optind + 2) {
584                         fprintf(stderr, "Invalid arguments.\n");
585                         return 1;
586                 }
587                 debuglevel = atoi(argv[optind+1]);
588
589                 sendline(fd, "%d %d %d", CONTROL, REQ_SET_DEBUG, debuglevel);
590                 if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &origlevel) != 3 || code != CONTROL || req != REQ_SET_DEBUG) {
591                         fprintf(stderr, "Could not purge tinc daemon\n");
592                         return 1;
593                 }
594
595                 fprintf(stderr, "Old level %d, new level %d\n", origlevel, debuglevel);
596                 return 0;
597         }
598
599         if(!strcasecmp(argv[optind], "connect")) {
600                 if(argc != optind + 2) {
601                         fprintf(stderr, "Invalid arguments.\n");
602                         return 1;
603                 }
604                 char *name = argv[optind + 1];
605
606                 sendline(fd, "%d %d %s", CONTROL, REQ_CONNECT, name);
607                 if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_CONNECT || result) {
608                         fprintf(stderr, "Could not connect to %s\n", name);
609                         return 1;
610                 }
611                 return 0;
612         }
613
614         if(!strcasecmp(argv[optind], "disconnect")) {
615                 if(argc != optind + 2) {
616                         fprintf(stderr, "Invalid arguments.\n");
617                         return 1;
618                 }
619                 char *name = argv[optind + 1];
620
621                 sendline(fd, "%d %d %s", CONTROL, REQ_DISCONNECT, name);
622                 if(!recvline(fd, line, sizeof line) || sscanf(line, "%d %d %d", &code, &req, &result) != 3 || code != CONTROL || req != REQ_DISCONNECT || result) {
623                         fprintf(stderr, "Could not disconnect %s\n", name);
624                         return 1;
625                 }
626                 return 0;
627         }
628
629         fprintf(stderr, "Unknown command `%s'.\n", argv[optind]);
630         usage(true);
631         
632         close(fd);
633
634         return 0;
635 }