Prefer ncurses over curses.
[tinc] / src / invitation.c
1 /*
2     invitation.c -- Create and accept invitations
3     Copyright (C) 2013 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 "control_common.h"
23 #include "crypto.h"
24 #include "ecdsa.h"
25 #include "ecdsagen.h"
26 #include "invitation.h"
27 #include "names.h"
28 #include "netutl.h"
29 #include "rsagen.h"
30 #include "script.h"
31 #include "sptps.h"
32 #include "tincctl.h"
33 #include "utils.h"
34 #include "xalloc.h"
35
36 int addressfamily = AF_UNSPEC;
37
38 static void scan_for_hostname(const char *filename, char **hostname, char **port) {
39         if(!filename || (*hostname && *port))
40                 return;
41
42         FILE *f = fopen(filename, "r");
43         if(!f)
44                 return;
45
46         while(fgets(line, sizeof line, f)) {
47                 if(!rstrip(line))
48                         continue;
49                 char *p = line, *q;
50                 p += strcspn(p, "\t =");
51                 if(!*p)
52                         continue;
53                 q = p + strspn(p, "\t ");
54                 if(*q == '=')
55                         q += 1 + strspn(q + 1, "\t ");
56                 *p = 0;
57                 p = q + strcspn(q, "\t ");
58                 if(*p)
59                         *p++ = 0;
60                 p += strspn(p, "\t ");
61                 p[strcspn(p, "\t ")] = 0;
62
63                 if(!*port && !strcasecmp(line, "Port")) {
64                         *port = xstrdup(q);
65                 } else if(!*hostname && !strcasecmp(line, "Address")) {
66                         *hostname = xstrdup(q);
67                         if(*p) {
68                                 free(*port);
69                                 *port = xstrdup(p);
70                         }
71                 }
72
73                 if(*hostname && *port)
74                         break;
75         }
76
77         fclose(f);
78 }
79
80 char *get_my_hostname() {
81         char *hostname = NULL;
82         char *port = NULL;
83         char *hostport = NULL;
84         char *name = get_my_name(false);
85         char *filename = NULL;
86
87         // Use first Address statement in own host config file
88         if(check_id(name)) {
89                 xasprintf(&filename, "%s" SLASH "hosts" SLASH "%s", confbase, name);
90                 scan_for_hostname(filename, &hostname, &port);
91                 scan_for_hostname(tinc_conf, &hostname, &port);
92         }
93
94         if(hostname)
95                 goto done;
96
97         // If that doesn't work, guess externally visible hostname
98         fprintf(stderr, "Trying to discover externally visible hostname...\n");
99         struct addrinfo *ai = str2addrinfo("tinc-vpn.org", "80", SOCK_STREAM);
100         struct addrinfo *aip = ai;
101         static const char request[] = "GET http://tinc-vpn.org/host.cgi HTTP/1.0\r\n\r\n";
102
103         while(aip) {
104                 int s = socket(aip->ai_family, aip->ai_socktype, aip->ai_protocol);
105                 if(s >= 0) {
106                         if(connect(s, aip->ai_addr, aip->ai_addrlen)) {
107                                 closesocket(s);
108                                 s = -1;
109                         }
110                 }
111                 if(s >= 0) {
112                         send(s, request, sizeof request - 1, 0);
113                         int len = recv(s, line, sizeof line - 1, MSG_WAITALL);
114                         if(len > 0) {
115                                 line[len] = 0;
116                                 if(line[len - 1] == '\n')
117                                         line[--len] = 0;
118                                 char *p = strrchr(line, '\n');
119                                 if(p && p[1])
120                                         hostname = xstrdup(p + 1);
121                         }
122                         closesocket(s);
123                         if(hostname)
124                                 break;
125                 }
126                 aip = aip->ai_next;
127                 continue;
128         }
129
130         if(ai)
131                 freeaddrinfo(ai);
132
133         // Check that the hostname is reasonable
134         if(hostname) {
135                 for(char *p = hostname; *p; p++) {
136                         if(isalnum(*p) || *p == '-' || *p == '.' || *p == ':')
137                                 continue;
138                         // If not, forget it.
139                         free(hostname);
140                         hostname = NULL;
141                         break;
142                 }
143         }
144
145 again:
146         printf("Please enter your host's external address or hostname");
147         if(hostname)
148                 printf(" [%s]", hostname);
149         printf(": ");
150         fflush(stdout);
151
152         if(!fgets(line, sizeof line, stdin)) {
153                 fprintf(stderr, "Error while reading stdin: %s\n", strerror(errno));
154                 free(hostname);
155                 return NULL;
156         }
157
158         if(!rstrip(line)) {
159                 if(hostname)
160                         goto save;
161                 else
162                         goto again;
163         }
164
165         for(char *p = line; *p; p++) {
166                 if(isalnum(*p) || *p == '-' || *p == '.')
167                         continue;
168                 fprintf(stderr, "Invalid address or hostname.\n");
169                 goto again;
170         }
171
172         free(hostname);
173         hostname = xstrdup(line);
174
175 save:
176         if(filename) {
177                 FILE *f = fopen(filename, "a");
178                 if(f) {
179                         fprintf(f, "\nAddress = %s\n", hostname);
180                         fclose(f);
181                 } else {
182                         fprintf(stderr, "Could not append Address to %s: %s\n", filename, strerror(errno));
183                 }
184         }
185
186 done:
187         if(port) {
188                 if(strchr(hostname, ':'))
189                         xasprintf(&hostport, "[%s]:%s", hostname, port);
190                 else
191                         xasprintf(&hostport, "%s:%s", hostname, port);
192         } else {
193                 hostport = hostname;
194                 hostname = NULL;
195         }
196
197         free(hostname);
198         free(port);
199         free(filename);
200         return hostport;
201 }
202
203 static bool fcopy(FILE *out, const char *filename) {
204         FILE *in = fopen(filename, "r");
205         if(!in) {
206                 fprintf(stderr, "Could not open %s: %s\n", filename, strerror(errno));
207                 return false;
208         }
209
210         char buf[1024];
211         size_t len;
212         while((len = fread(buf, 1, sizeof buf, in)))
213                 fwrite(buf, len, 1, out);
214         fclose(in);
215         return true;
216 }
217
218 int cmd_invite(int argc, char *argv[]) {
219         if(argc < 2) {
220                 fprintf(stderr, "Not enough arguments!\n");
221                 return 1;
222         }
223
224         // Check validity of the new node's name
225         if(!check_id(argv[1])) {
226                 fprintf(stderr, "Invalid name for node.\n");
227                 return 1;
228         }
229
230         char *myname = get_my_name(true);
231         if(!myname)
232                 return 1;
233
234         // Ensure no host configuration file with that name exists
235         char *filename = NULL;
236         xasprintf(&filename, "%s" SLASH "hosts" SLASH "%s", confbase, argv[1]);
237         if(!access(filename, F_OK)) {
238                 free(filename);
239                 fprintf(stderr, "A host config file for %s already exists!\n", argv[1]);
240                 return 1;
241         }
242         free(filename);
243
244         // If a daemon is running, ensure no other nodes now about this name
245         bool found = false;
246         if(connect_tincd(false)) {
247                 sendline(fd, "%d %d", CONTROL, REQ_DUMP_NODES);
248
249                 while(recvline(fd, line, sizeof line)) {
250                         char node[4096];
251                         int code, req;
252                         if(sscanf(line, "%d %d %s", &code, &req, node) != 3)
253                                 break;
254                         if(!strcmp(node, argv[1]))
255                                 found = true;
256                 }
257
258                 if(found) {
259                         fprintf(stderr, "A node with name %s is already known!\n", argv[1]);
260                         return 1;
261                 }
262         }
263
264         char hash[25];
265
266         xasprintf(&filename, "%s" SLASH "invitations", confbase);
267         if(mkdir(filename, 0700) && errno != EEXIST) {
268                 fprintf(stderr, "Could not create directory %s: %s\n", filename, strerror(errno));
269                 free(filename);
270                 return 1;
271         }
272
273         // Count the number of valid invitations, clean up old ones
274         DIR *dir = opendir(filename);
275         if(!dir) {
276                 fprintf(stderr, "Could not read directory %s: %s\n", filename, strerror(errno));
277                 free(filename);
278                 return 1;
279         }
280
281         errno = 0;
282         int count = 0;
283         struct dirent *ent;
284         time_t deadline = time(NULL) - 604800; // 1 week in the past
285
286         while((ent = readdir(dir))) {
287                 if(strlen(ent->d_name) != 24)
288                         continue;
289                 char *invname;
290                 struct stat st;
291                 xasprintf(&invname, "%s" SLASH "%s", filename, ent->d_name);
292                 if(!stat(invname, &st)) {
293                         if(deadline < st.st_mtime)
294                                 count++;
295                         else
296                                 unlink(invname);
297                 } else {
298                         fprintf(stderr, "Could not stat %s: %s\n", invname, strerror(errno));
299                         errno = 0;
300                 }
301                 free(invname);
302         }
303
304         if(errno) {
305                 fprintf(stderr, "Error while reading directory %s: %s\n", filename, strerror(errno));
306                 closedir(dir);
307                 free(filename);
308                 return 1;
309         }
310                 
311         closedir(dir);
312         free(filename);
313
314         ecdsa_t *key;
315         xasprintf(&filename, "%s" SLASH "invitations" SLASH "ecdsa_key.priv", confbase);
316
317         // Remove the key if there are no outstanding invitations.
318         if(!count)
319                 unlink(filename);
320
321         // Create a new key if necessary.
322         FILE *f = fopen(filename, "r");
323         if(!f) {
324                 if(errno != ENOENT) {
325                         fprintf(stderr, "Could not read %s: %s\n", filename, strerror(errno));
326                         free(filename);
327                         return 1;
328                 }
329
330                 key = ecdsa_generate();
331                 if(!key) {
332                         free(filename);
333                         return 1;
334                 }
335                 f = fopen(filename, "w");
336                 if(!f) {
337                         fprintf(stderr, "Could not write %s: %s\n", filename, strerror(errno));
338                         free(filename);
339                         return 1;
340                 }
341                 chmod(filename, 0600);
342                 ecdsa_write_pem_private_key(key, f);
343                 fclose(f);
344
345                 if(connect_tincd(false))
346                         sendline(fd, "%d %d", CONTROL, REQ_RELOAD);
347         } else {
348                 key = ecdsa_read_pem_private_key(f);
349                 fclose(f);
350                 if(!key)
351                         fprintf(stderr, "Could not read private key from %s\n", filename);
352         }
353
354         free(filename);
355         if(!key)
356                 return 1;
357
358         // Create a hash of the key.
359         char *fingerprint = ecdsa_get_base64_public_key(key);
360         digest_t *digest = digest_open_by_name("sha256", 18);
361         if(!digest)
362                 abort();
363         digest_create(digest, fingerprint, strlen(fingerprint), hash);
364         b64encode_urlsafe(hash, hash, 18);
365
366         // Create a random cookie for this invitation.
367         char cookie[25];
368         randomize(cookie, 18);
369
370         // Create a filename that doesn't reveal the cookie itself
371         char buf[18 + strlen(fingerprint)];
372         char cookiehash[25];
373         memcpy(buf, cookie, 18);
374         memcpy(buf + 18, fingerprint, sizeof buf - 18);
375         digest_create(digest, buf, sizeof buf, cookiehash);
376         b64encode_urlsafe(cookiehash, cookiehash, 18);
377
378         b64encode_urlsafe(cookie, cookie, 18);
379
380         // Create a file containing the details of the invitation.
381         xasprintf(&filename, "%s" SLASH "invitations" SLASH "%s", confbase, cookiehash);
382         int ifd = open(filename, O_RDWR | O_CREAT | O_EXCL, 0600);
383         if(!ifd) {
384                 fprintf(stderr, "Could not create invitation file %s: %s\n", filename, strerror(errno));
385                 free(filename);
386                 return 1;
387         }
388         f = fdopen(ifd, "w");
389         if(!f)
390                 abort();
391
392         // Get the local address
393         char *address = get_my_hostname();
394
395         // Fill in the details.
396         fprintf(f, "Name = %s\n", argv[1]);
397         if(netname)
398                 fprintf(f, "NetName = %s\n", netname);
399         fprintf(f, "ConnectTo = %s\n", myname);
400
401         // Copy Broadcast and Mode
402         FILE *tc = fopen(tinc_conf, "r");
403         if(tc) {
404                 char buf[1024];
405                 while(fgets(buf, sizeof buf, tc)) {
406                         if((!strncasecmp(buf, "Mode", 4) && strchr(" \t=", buf[4]))
407                                         || (!strncasecmp(buf, "Broadcast", 9) && strchr(" \t=", buf[9])))
408                                 fputs(buf, f);
409                 }
410                 fclose(tc);
411         }
412
413         fprintf(f, "#---------------------------------------------------------------#\n");
414         fprintf(f, "Name = %s\n", myname);
415
416         char *filename2;
417         xasprintf(&filename2, "%s" SLASH "hosts" SLASH "%s", confbase, myname);
418         fcopy(f, filename2);
419         fclose(f);
420         free(filename2);
421
422         // Create an URL from the local address, key hash and cookie
423         char *url;
424         xasprintf(&url, "%s/%s%s", address, hash, cookie);
425
426         // Call the inviation-created script
427         char *envp[6] = {};
428         xasprintf(&envp[0], "NAME=%s", myname);
429         xasprintf(&envp[1], "NETNAME=%s", netname);
430         xasprintf(&envp[2], "NODE=%s", argv[1]);
431         xasprintf(&envp[3], "INVITATION_FILE=%s", filename);
432         xasprintf(&envp[4], "INVITATION_URL=%s", url);
433         execute_script("invitation-created", envp);
434         for(int i = 0; i < 6 && envp[i]; i++)
435                 free(envp[i]);
436
437         puts(url);
438         free(url);
439         free(filename);
440         free(address);
441
442         return 0;
443 }
444
445 static int sock;
446 static char cookie[18];
447 static sptps_t sptps;
448 static char *data;
449 static size_t datalen;
450 static bool success = false;
451
452 static char cookie[18], hash[18];
453
454 static char *get_line(const char **data) {
455         if(!data || !*data)
456                 return NULL;
457
458         if(!**data) {
459                 *data = NULL;
460                 return NULL;
461         }
462
463         static char line[1024];
464         const char *end = strchr(*data, '\n');
465         size_t len = end ? end - *data : strlen(*data);
466         if(len >= sizeof line) {
467                 fprintf(stderr, "Maximum line length exceeded!\n");
468                 return NULL;
469         }
470         if(len && !isprint(**data))
471                 abort();
472
473         memcpy(line, *data, len);
474         line[len] = 0;
475
476         if(end)
477                 *data = end + 1;
478         else
479                 *data = NULL;
480
481         return line;
482 }
483
484 static char *get_value(const char *data, const char *var) {
485         char *line = get_line(&data);
486         if(!line)
487                 return NULL;
488
489         char *sep = line + strcspn(line, " \t=");
490         char *val = sep + strspn(sep, " \t");
491         if(*val == '=')
492                 val += 1 + strspn(val + 1, " \t");
493         *sep = 0;
494         if(strcasecmp(line, var))
495                 return NULL;
496         return val;
497 }
498
499 static char *grep(const char *data, const char *var) {
500         static char value[1024];
501
502         const char *p = data;
503         int varlen = strlen(var);
504
505         // Skip all lines not starting with var
506         while(strncasecmp(p, var, varlen) || !strchr(" \t=", p[varlen])) {
507                 p = strchr(p, '\n');
508                 if(!p)
509                         break;
510                 else
511                         p++;
512         }
513
514         if(!p)
515                 return NULL;
516
517         p += varlen;
518         p += strspn(p, " \t");
519         if(*p == '=')
520                 p += 1 + strspn(p + 1, " \t");
521
522         const char *e = strchr(p, '\n');
523         if(!e)
524                 return xstrdup(p);
525
526         if(e - p >= sizeof value) {
527                 fprintf(stderr, "Maximum line length exceeded!\n");
528                 return NULL;
529         }
530
531         memcpy(value, p, e - p);
532         value[e - p] = 0;
533         return value;
534 }
535
536 static bool finalize_join(void) {
537         char *name = xstrdup(get_value(data, "Name"));
538         if(!name) {
539                 fprintf(stderr, "No Name found in invitation!\n");
540                 return false;
541         }
542
543         if(!check_id(name)) {
544                 fprintf(stderr, "Invalid Name found in invitation: %s!\n", name);
545                 return false;
546         }
547
548         if(!netname)
549                 netname = grep(data, "NetName");
550
551         bool ask_netname = false;
552         char temp_netname[32];
553
554 make_names:
555         if(!confbasegiven) {
556                 free(confbase);
557                 confbase = NULL;
558         }
559
560         make_names();
561
562         free(tinc_conf);
563         free(hosts_dir);
564
565         xasprintf(&tinc_conf, "%s" SLASH "tinc.conf", confbase);
566         xasprintf(&hosts_dir, "%s" SLASH "hosts", confbase);
567
568         if(!access(tinc_conf, F_OK)) {
569                 fprintf(stderr, "Configuration file %s already exists!\n", tinc_conf);
570                 if(!tty || confbasegiven)
571                         return false;
572
573                 // Generate a random netname, ask for a better one later.
574                 ask_netname = true;
575                 snprintf(temp_netname, sizeof temp_netname, "join_%x", rand());
576                 netname = temp_netname;
577                 goto make_names;
578         }       
579
580         if(mkdir(confbase, 0777) && errno != EEXIST) {
581                 fprintf(stderr, "Could not create directory %s: %s\n", confbase, strerror(errno));
582                 return false;
583         }
584
585         if(mkdir(hosts_dir, 0777) && errno != EEXIST) {
586                 fprintf(stderr, "Could not create directory %s: %s\n", hosts_dir, strerror(errno));
587                 return false;
588         }
589
590         FILE *f = fopen(tinc_conf, "w");
591         if(!f) {
592                 fprintf(stderr, "Could not create file %s: %s\n", tinc_conf, strerror(errno));
593                 return false;
594         }
595
596         fprintf(f, "Name = %s\n", name);
597
598         char *filename;
599         xasprintf(&filename, "%s" SLASH "%s", hosts_dir, name);
600         FILE *fh = fopen(filename, "w");
601         if(!fh) {
602                 fprintf(stderr, "Could not create file %s: %s\n", filename, strerror(errno));
603                 return false;
604         }
605
606         // Filter first chunk on approved keywords, split between tinc.conf and hosts/Name
607         // Other chunks go unfiltered to their respective host config files
608         const char *p = data;
609         char *l, *value;
610
611         while((l = get_line(&p))) {
612                 // Ignore comments
613                 if(*l == '#')
614                         continue;
615
616                 // Split line into variable and value
617                 int len = strcspn(l, "\t =");
618                 value = l + len;
619                 value += strspn(value, "\t ");
620                 if(*value == '=') {
621                         value++;
622                         value += strspn(value, "\t ");
623                 }
624                 l[len] = 0;
625
626                 // Is it a Name?
627                 if(!strcasecmp(l, "Name"))
628                         if(strcmp(value, name))
629                                 break;
630                         else
631                                 continue;
632                 else if(!strcasecmp(l, "NetName"))
633                         continue;
634
635                 // Check the list of known variables
636                 bool found = false;
637                 int i;
638                 for(i = 0; variables[i].name; i++) {
639                         if(strcasecmp(l, variables[i].name))
640                                 continue;
641                         found = true;
642                         break;
643                 }
644
645                 // Ignore unknown and unsafe variables
646                 if(!found) {
647                         fprintf(stderr, "Ignoring unknown variable '%s' in invitation.\n", l);
648                         continue;
649                 } else if(!(variables[i].type & VAR_SAFE)) {
650                         fprintf(stderr, "Ignoring unsafe variable '%s' in invitation.\n", l);
651                         continue;
652                 }
653
654                 // Copy the safe variable to the right config file
655                 fprintf(variables[i].type & VAR_HOST ? fh : f, "%s = %s\n", l, value);
656         }
657
658         fclose(f);
659         free(filename);
660
661         while(l && !strcasecmp(l, "Name")) {
662                 if(!check_id(value)) {
663                         fprintf(stderr, "Invalid Name found in invitation.\n");
664                         return false;
665                 }
666
667                 if(!strcmp(value, name)) {
668                         fprintf(stderr, "Secondary chunk would overwrite our own host config file.\n");
669                         return false;
670                 }
671
672                 xasprintf(&filename, "%s" SLASH "%s", hosts_dir, value);
673                 f = fopen(filename, "w");
674
675                 if(!f) {
676                         fprintf(stderr, "Could not create file %s: %s\n", filename, strerror(errno));
677                         return false;
678                 }
679
680                 while((l = get_line(&p))) {
681                         if(!strcmp(l, "#---------------------------------------------------------------#"))
682                                 continue;
683                         int len = strcspn(l, "\t =");
684                         if(len == 4 && !strncasecmp(l, "Name", 4)) {
685                                 value = l + len;
686                                 value += strspn(value, "\t ");
687                                 if(*value == '=') {
688                                         value++;
689                                         value += strspn(value, "\t ");
690                                 }
691                                 l[len] = 0;
692                                 break;
693                         }
694
695                         fputs(l, f);
696                         fputc('\n', f);
697                 }
698
699                 fclose(f);
700                 free(filename);
701         }
702
703         // Generate our key and send a copy to the server
704         ecdsa_t *key = ecdsa_generate();
705         if(!key)
706                 return false;
707
708         char *b64key = ecdsa_get_base64_public_key(key);
709         if(!b64key)
710                 return false;
711
712         xasprintf(&filename, "%s" SLASH "ecdsa_key.priv", confbase);
713         f = fopenmask(filename, "w", 0600);
714
715         if(!ecdsa_write_pem_private_key(key, f)) {
716                 fprintf(stderr, "Error writing private key!\n");
717                 ecdsa_free(key);
718                 fclose(f);
719                 return false;
720         }
721
722         fclose(f);
723
724         fprintf(fh, "ECDSAPublicKey = %s\n", b64key);
725
726         sptps_send_record(&sptps, 1, b64key, strlen(b64key));
727         free(b64key);
728
729
730         rsa_t *rsa = rsa_generate(2048, 0x1001);
731         xasprintf(&filename, "%s" SLASH "rsa_key.priv", confbase);
732         f = fopenmask(filename, "w", 0600);
733
734         rsa_write_pem_private_key(rsa, f);
735         fclose(f);
736
737         rsa_write_pem_public_key(rsa, fh);
738         fclose(fh);
739
740         ecdsa_free(key);
741         rsa_free(rsa);
742
743         check_port(name);
744
745 ask_netname:
746         if(ask_netname) {
747                 fprintf(stderr, "Enter a new netname: ");
748                 if(!fgets(line, sizeof line, stdin)) {
749                         fprintf(stderr, "Error while reading stdin: %s\n", strerror(errno));
750                         return false;
751                 }
752                 if(!*line || *line == '\n')
753                         goto ask_netname;
754
755                 line[strlen(line) - 1] = 0;
756
757                 char *newbase;
758                 xasprintf(&newbase, CONFDIR SLASH "tinc" SLASH "%s", line);
759                 if(rename(confbase, newbase)) {
760                         fprintf(stderr, "Error trying to rename %s to %s: %s\n", confbase, newbase, strerror(errno));
761                         free(newbase);
762                         goto ask_netname;
763                 }
764
765                 free(newbase);
766                 netname = line;
767                 make_names();
768         }
769
770         return true;
771 }
772
773
774 static bool invitation_send(void *handle, uint8_t type, const char *data, size_t len) {
775         while(len) {
776                 int result = send(sock, data, len, 0);
777                 if(result == -1 && errno == EINTR)
778                         continue;
779                 else if(result <= 0)
780                         return false;
781                 data += result;
782                 len -= result;
783         }
784         return true;
785 }
786
787 static bool invitation_receive(void *handle, uint8_t type, const char *msg, uint16_t len) {
788         switch(type) {
789                 case SPTPS_HANDSHAKE:
790                         return sptps_send_record(&sptps, 0, cookie, sizeof cookie);
791
792                 case 0:
793                         data = xrealloc(data, datalen + len + 1);
794                         memcpy(data + datalen, msg, len);
795                         datalen += len;
796                         data[datalen] = 0;
797                         break;
798
799                 case 1:
800                         return finalize_join();
801
802                 case 2:
803                         fprintf(stderr, "Invitation succesfully accepted.\n");
804                         shutdown(sock, SHUT_RDWR);
805                         success = true;
806                         break;
807
808                 default:
809                         return false;
810         }
811
812         return true;
813 }
814
815 int cmd_join(int argc, char *argv[]) {
816         free(data);
817         data = NULL;
818         datalen = 0;
819
820         if(argc > 2) {
821                 fprintf(stderr, "Too many arguments!\n");
822                 return 1;
823         }
824
825         // Make sure confbase exists and is accessible.
826         if(!confbase_given && mkdir(confdir, 0755) && errno != EEXIST) {
827                 fprintf(stderr, "Could not create directory %s: %s\n", confdir, strerror(errno));
828                 return 1;
829         }
830
831         if(mkdir(confbase, 0777) && errno != EEXIST) {
832                 fprintf(stderr, "Could not create directory %s: %s\n", confbase, strerror(errno));
833                 return 1;
834         }
835
836         if(access(confbase, R_OK | W_OK | X_OK)) {
837                 fprintf(stderr, "No permission to write in directory %s: %s\n", confbase, strerror(errno));
838                 return 1;
839         }
840
841         // If a netname or explicit configuration directory is specified, check for an existing tinc.conf.
842         if((netname || confbasegiven) && !access(tinc_conf, F_OK)) {
843                 fprintf(stderr, "Configuration file %s already exists!\n", tinc_conf);
844                 return 1;
845         }
846
847         // Either read the invitation from the command line or from stdin.
848         char *invitation;
849
850         if(argc > 1) {
851                 invitation = argv[1];
852         } else {
853                 if(tty) {
854                         printf("Enter invitation URL: ");
855                         fflush(stdout);
856                 }
857                 errno = EPIPE;
858                 if(!fgets(line, sizeof line, stdin)) {
859                         fprintf(stderr, "Error while reading stdin: %s\n", strerror(errno));
860                         return false;
861                 }
862                 invitation = line;
863         }
864
865         // Parse the invitation URL.
866         rstrip(line);
867
868         char *slash = strchr(invitation, '/');
869         if(!slash)
870                 goto invalid;
871
872         *slash++ = 0;
873
874         if(strlen(slash) != 48)
875                 goto invalid;
876
877         char *address = invitation;
878         char *port = NULL;
879         if(*address == '[') {
880                 address++;
881                 char *bracket = strchr(address, ']');
882                 if(!bracket)
883                         goto invalid;
884                 *bracket = 0;
885                 if(bracket[1] == ':')
886                         port = bracket + 2;
887         } else {
888                 port = strchr(address, ':');
889                 if(port)
890                         *port++ = 0;
891         }
892
893         if(!port || !*port)
894                 port = "655";
895
896         if(!b64decode(slash, hash, 18) || !b64decode(slash + 24, cookie, 18))
897                 goto invalid;
898
899         // Generate a throw-away key for the invitation.
900         ecdsa_t *key = ecdsa_generate();
901         if(!key)
902                 return 1;
903
904         char *b64key = ecdsa_get_base64_public_key(key);
905
906         // Connect to the tinc daemon mentioned in the URL.
907         struct addrinfo *ai = str2addrinfo(address, port, SOCK_STREAM);
908         if(!ai)
909                 return 1;
910
911         sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
912         if(sock <= 0) {
913                 fprintf(stderr, "Could not open socket: %s\n", strerror(errno));
914                 return 1;
915         }
916
917         if(connect(sock, ai->ai_addr, ai->ai_addrlen)) {
918                 fprintf(stderr, "Could not connect to %s port %s: %s\n", address, port, strerror(errno));
919                 closesocket(sock);
920                 return 1;
921         }
922
923         fprintf(stderr, "Connected to %s port %s...\n", address, port);
924
925         // Tell him we have an invitation, and give him our throw-away key.
926         int len = snprintf(line, sizeof line, "0 ?%s %d.%d\n", b64key, PROT_MAJOR, PROT_MINOR);
927         if(len <= 0 || len >= sizeof line)
928                 abort();
929
930         if(!sendline(sock, "0 ?%s %d.%d", b64key, PROT_MAJOR, 1)) {
931                 fprintf(stderr, "Error sending request to %s port %s: %s\n", address, port, strerror(errno));
932                 closesocket(sock);
933                 return 1;
934         }
935
936         char hisname[4096] = "";
937         int code, hismajor, hisminor = 0;
938
939         if(!recvline(sock, line, sizeof line) || sscanf(line, "%d %s %d.%d", &code, hisname, &hismajor, &hisminor) < 3 || code != 0 || hismajor != PROT_MAJOR || !check_id(hisname) || !recvline(sock, line, sizeof line) || !rstrip(line) || sscanf(line, "%d ", &code) != 1 || code != ACK || strlen(line) < 3) {
940                 fprintf(stderr, "Cannot read greeting from peer\n");
941                 closesocket(sock);
942                 return 1;
943         }
944
945         // Check if the hash of the key he gave us matches the hash in the URL.
946         char *fingerprint = line + 2;
947         digest_t *digest = digest_open_by_name("sha256", 18);
948         if(!digest)
949                 abort();
950         char hishash[18];
951         if(!digest_create(digest, fingerprint, strlen(fingerprint), hishash)) {
952                 fprintf(stderr, "Could not create digest\n%s\n", line + 2);
953                 return 1;
954         }
955         if(memcmp(hishash, hash, 18)) {
956                 fprintf(stderr, "Peer has an invalid key!\n%s\n", line + 2);
957                 return 1;
958
959         }
960         
961         ecdsa_t *hiskey = ecdsa_set_base64_public_key(fingerprint);
962         if(!hiskey)
963                 return 1;
964
965         // Start an SPTPS session
966         if(!sptps_start(&sptps, NULL, true, false, key, hiskey, "tinc invitation", 15, invitation_send, invitation_receive))
967                 return 1;
968
969         // Feed rest of input buffer to SPTPS
970         if(!sptps_receive_data(&sptps, buffer, blen))
971                 return 1;
972
973         while((len = recv(sock, line, sizeof line, 0))) {
974                 if(len < 0) {
975                         if(errno == EINTR)
976                                 continue;
977                         fprintf(stderr, "Error reading data from %s port %s: %s\n", address, port, strerror(errno));
978                         return 1;
979                 }
980
981                 if(!sptps_receive_data(&sptps, line, len))
982                         return 1;
983         }
984         
985         sptps_stop(&sptps);
986         ecdsa_free(hiskey);
987         ecdsa_free(key);
988         closesocket(sock);
989
990         if(!success) {
991                 fprintf(stderr, "Connection closed by peer, invitation cancelled.\n");
992                 return 1;
993         }
994
995         return 0;
996
997 invalid:
998         fprintf(stderr, "Invalid invitation URL.\n");
999         return 1;
1000 }