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