17eb3bdf57b7b05f8c34c3c11b067afa7e12496d
[tinc] / src / protocol.c
1 /*
2     protocol.c -- handle the meta-protocol
3     Copyright (C) 1999-2001 Ivo Timmermans <itimmermans@bigfoot.com>,
4                   2000,2001 Guus Sliepen <guus@sliepen.warande.net>
5
6     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software
18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
20     $Id: protocol.c,v 1.28.4.94 2001/06/09 10:00:34 guus Exp $
21 */
22
23 #include "config.h"
24
25 #include <sys/types.h>
26
27 #include <stdlib.h>
28 #include <string.h>
29 #include <syslog.h>
30 #include <sys/socket.h>
31 #include <unistd.h>
32 #include <stdio.h>
33 #include <stdarg.h>
34 #include <errno.h>
35
36 #include <utils.h>
37 #include <xalloc.h>
38 #include <avl_tree.h>
39 #include <list.h>
40
41 #include <netinet/in.h>
42
43 #ifdef HAVE_OPENSSL_SHA_H
44 # include <openssl/sha.h>
45 #else
46 # include <sha.h>
47 #endif
48
49 #ifdef HAVE_OPENSSL_RAND_H
50 # include <openssl/rand.h>
51 #else
52 # include <rand.h>
53 #endif
54
55 #ifdef HAVE_OPENSSL_EVP_H
56 # include <openssl/evp.h>
57 #else
58 # include <evp.h>
59 #endif
60
61
62 #include "conf.h"
63 #include "net.h"
64 #include "netutl.h"
65 #include "protocol.h"
66 #include "meta.h"
67 #include "connection.h"
68
69 #include "system.h"
70
71 int mykeyused = 0;
72
73 int check_id(char *id)
74 {
75   int i;
76
77   for (i = 0; i < strlen(id); i++)
78     if(!isalnum(id[i]) && id[i] != '_')
79       return -1;
80   
81   return 0;
82 }
83
84 /* Generic request routines - takes care of logging and error
85    detection as well */
86
87 int send_request(connection_t *cl, const char *format, ...)
88 {
89   va_list args;
90   char buffer[MAXBUFSIZE];
91   int len, request;
92
93 cp
94   /* Use vsnprintf instead of vasprintf: faster, no memory
95      fragmentation, cleanup is automatic, and there is a limit on the
96      input buffer anyway */
97
98   va_start(args, format);
99   len = vsnprintf(buffer, MAXBUFSIZE, format, args);
100   request = va_arg(args, int);
101   va_end(args);
102
103   if(len < 0 || len > MAXBUFSIZE-1)
104     {
105       syslog(LOG_ERR, _("Output buffer overflow while sending %s to %s (%s)"), request_name[request], cl->name, cl->hostname);
106       return -1;
107     }
108
109   if(debug_lvl >= DEBUG_PROTOCOL)
110     {
111       if(debug_lvl >= DEBUG_META)
112         syslog(LOG_DEBUG, _("Sending %s to %s (%s): %s"), request_name[request], cl->name, cl->hostname, buffer);
113       else
114         syslog(LOG_DEBUG, _("Sending %s to %s (%s)"), request_name[request], cl->name, cl->hostname);
115     }
116
117   buffer[len++] = '\n';
118 cp
119   return send_meta(cl, buffer, len);
120 }
121
122 int receive_request(connection_t *cl)
123 {
124   int request;
125 cp
126   if(sscanf(cl->buffer, "%d", &request) == 1)
127     {
128       if((request < 0) || (request >= LAST) || (request_handlers[request] == NULL))
129         {
130           if(debug_lvl >= DEBUG_META)
131             syslog(LOG_DEBUG, _("Unknown request from %s (%s): %s"),
132                    cl->name, cl->hostname, cl->buffer);
133           else
134             syslog(LOG_ERR, _("Unknown request from %s (%s)"),
135                    cl->name, cl->hostname);
136                    
137           return -1;
138         }
139       else
140         {
141           if(debug_lvl >= DEBUG_PROTOCOL)
142             {
143               if(debug_lvl >= DEBUG_META)
144                 syslog(LOG_DEBUG, _("Got %s from %s (%s): %s"),
145                        request_name[request], cl->name, cl->hostname, cl->buffer);
146               else
147                 syslog(LOG_DEBUG, _("Got %s from %s (%s)"),
148                        request_name[request], cl->name, cl->hostname);
149             }
150         }
151
152       if((cl->allow_request != ALL) && (cl->allow_request != request))
153         {
154           syslog(LOG_ERR, _("Unauthorized request from %s (%s)"), cl->name, cl->hostname);
155           return -1;
156         }
157
158       if(request_handlers[request](cl))
159         /* Something went wrong. Probably scriptkiddies. Terminate. */
160         {
161           syslog(LOG_ERR, _("Error while processing %s from %s (%s)"),
162                  request_name[request], cl->name, cl->hostname);
163           return -1;
164         }
165     }
166   else
167     {
168       syslog(LOG_ERR, _("Bogus data received from %s (%s)"),
169              cl->name, cl->hostname);
170       return -1;
171     }
172 cp
173   return 0;
174 }
175
176 /* The authentication protocol is described in detail in doc/SECURITY2,
177    the rest will be described in doc/PROTOCOL. */
178
179 int send_id(connection_t *cl)
180 {
181 cp
182   return send_request(cl, "%d %s %d %lx %hd", ID, myself->name, myself->protocol_version, myself->options, myself->port);
183 }
184
185 int id_h(connection_t *cl)
186 {
187   connection_t *old;
188   unsigned short int port;
189   char name[MAX_STRING_SIZE];
190   avl_node_t *node;
191 cp
192   if(sscanf(cl->buffer, "%*d "MAX_STRING" %d %lx %hd", name, &cl->protocol_version, &cl->options, &port) != 4)
193     {
194        syslog(LOG_ERR, _("Got bad ID from %s"), cl->hostname);
195        return -1;
196     }
197
198   /* Check if version matches */
199
200   if(cl->protocol_version != myself->protocol_version)
201     {
202       syslog(LOG_ERR, _("Peer %s (%s) uses incompatible version %d"),
203              cl->name, cl->hostname, cl->protocol_version);
204       return -1;
205     }
206
207   /* Check if identity is a valid name */
208
209   if(check_id(name))
210     {
211       syslog(LOG_ERR, _("Peer %s uses invalid identity name"), cl->hostname);
212       return -1;
213     }
214   
215   /* Copy string to cl */
216   
217   if(cl->name)
218     free(cl->name);
219     
220   cl->name = xstrdup(name);
221
222   /* Load information about peer */
223
224   if(read_host_config(cl))
225     {
226       syslog(LOG_ERR, _("Peer %s had unknown identity (%s)"), cl->hostname, cl->name);
227       return -1;
228     }
229
230   /* First check if the host we connected to is already in our
231      connection list. If so, we are probably making a loop, which
232      is not desirable.
233    */
234
235   if(cl->status.outgoing)
236     {
237       if((old = lookup_id(cl->name)))
238         {
239           if(debug_lvl >= DEBUG_CONNECTIONS)
240             syslog(LOG_NOTICE, _("Uplink %s (%s) is already in our connection list"), cl->name, cl->hostname);
241           cl->status.outgoing = 0;
242           old->status.outgoing = 1;
243           terminate_connection(cl);
244           return 0;
245         }
246     }
247     
248   /* Now we can add the name to the id tree */
249   
250   id_add(cl);
251
252   /* And uhr... cl->port just changed so we have to unlink it from the connection tree and re-insert... */
253   
254   node = avl_unlink(connection_tree, cl);
255   cl->port = port;
256   avl_insert_node(connection_tree, node);
257
258   /* Read in the public key, so that we can send a metakey */
259
260   if(read_rsa_public_key(cl))
261     return -1;
262
263   cl->allow_request = METAKEY;
264 cp
265   return send_metakey(cl);
266 }
267
268 int ack_h(connection_t *cl)
269 {
270   config_t const *cfg;
271   connection_t *old, *p;
272   subnet_t *subnet;
273   avl_node_t *node, *node2;
274 cp
275   /* Okay, before we active the connection, we check if there is another entry
276      in the connection list with the same name. If so, it presumably is an
277      old connection that has timed out but we don't know it yet.
278    */
279
280   while((old = lookup_id(cl->name)))
281     {
282       if(debug_lvl >= DEBUG_CONNECTIONS)
283         syslog(LOG_NOTICE, _("Removing old entry for %s at %s in favour of new connection from %s"),
284         cl->name, old->hostname, cl->hostname);
285
286       terminate_connection(old);
287     }
288
289   /* Activate this connection */
290
291   cl->allow_request = ALL;
292   cl->status.active = 1;
293   cl->nexthop = cl;
294   cl->cipher_pkttype = EVP_bf_cbc();
295   cl->cipher_pktkeylength = cl->cipher_pkttype->key_len + cl->cipher_pkttype->iv_len;
296
297   if(debug_lvl >= DEBUG_CONNECTIONS)
298     syslog(LOG_NOTICE, _("Connection with %s (%s) activated"), cl->name, cl->hostname);
299
300   if(cl->status.outgoing)
301     seconds_till_retry = 5;     /* Reset retry timeout */
302 cp
303   /* Check some options */
304   
305   if((cfg = get_config_val(cl->config, config_indirectdata)))
306     {
307       if(cfg->data.val == stupid_true)
308         cl->options |= OPTION_INDIRECT;
309     }
310
311   if((cfg = get_config_val(cl->config, config_tcponly)))
312     {
313       if(cfg->data.val == stupid_true)
314         cl->options |= OPTION_TCPONLY;
315     }
316
317   /* Send him our subnets */
318   
319   for(node = myself->subnet_tree->head; node; node = node->next)
320     {
321       subnet = (subnet_t *)node->data;
322       send_add_subnet(cl, subnet);
323     }
324
325   /* And send him all the hosts and their subnets we know... */
326   
327   for(node = connection_tree->head; node; node = node->next)
328     {
329       p = (connection_t *)node->data;
330       
331       if(p != cl && p->status.active)
332         {
333           /* Notify others of this connection */
334
335           if(p->status.meta)
336             send_add_host(p, cl);
337
338           /* Notify new connection of everything we know */
339
340           send_add_host(cl, p);
341
342           for(node2 = p->subnet_tree->head; node2; node2 = node2->next)
343             {
344               subnet = (subnet_t *)node2->data;
345               send_add_subnet(cl, subnet);
346             }
347         }
348     }  
349 cp
350   return 0;
351 }
352
353 int send_challenge(connection_t *cl)
354 {
355   char *buffer;
356   int len, x;
357 cp
358   /* CHECKME: what is most reasonable value for len? */
359
360   len = RSA_size(cl->rsa_key);
361
362   /* Allocate buffers for the challenge */
363
364   buffer = xmalloc(len*2+1);
365
366   if(cl->hischallenge)
367     free(cl->hischallenge);
368     
369   cl->hischallenge = xmalloc(len);
370 cp
371   /* Copy random data to the buffer */
372
373   RAND_bytes(cl->hischallenge, len);
374
375 cp
376   /* Convert to hex */
377
378   bin2hex(cl->hischallenge, buffer, len);
379   buffer[len*2] = '\0';
380
381 cp
382   /* Send the challenge */
383
384   x = send_request(cl, "%d %s", CHALLENGE, buffer);
385   free(buffer);
386 cp
387   return x;
388 }
389
390 int challenge_h(connection_t *cl)
391 {
392   char buffer[MAX_STRING_SIZE];
393   int len;
394 cp
395   if(sscanf(cl->buffer, "%*d "MAX_STRING, buffer) != 1)
396     {
397        syslog(LOG_ERR, _("Got bad CHALLENGE from %s (%s)"), cl->name, cl->hostname);
398        return -1;
399     }
400
401   len = RSA_size(myself->rsa_key);
402
403   /* Check if the length of the challenge is all right */
404
405   if(strlen(buffer) != len*2)
406     {
407       syslog(LOG_ERR, _("Intruder: wrong challenge length from %s (%s)"), cl->name, cl->hostname);
408       return -1;
409     }
410
411   /* Allocate buffers for the challenge */
412
413   if(!cl->mychallenge)
414     cl->mychallenge = xmalloc(len);
415
416   /* Convert the challenge from hexadecimal back to binary */
417
418   hex2bin(buffer,cl->mychallenge,len);
419
420   cl->allow_request = CHAL_REPLY;
421
422   /* Rest is done by send_chal_reply() */
423 cp
424   return send_chal_reply(cl);
425 }
426
427 int send_chal_reply(connection_t *cl)
428 {
429   char hash[SHA_DIGEST_LENGTH*2+1];
430 cp
431   if(!cl->mychallenge)
432     {
433       syslog(LOG_ERR, _("Trying to send CHAL_REPLY to %s (%s) without a valid CHALLENGE"), cl->name, cl->hostname);
434       return -1;
435     }
436      
437   /* Calculate the hash from the challenge we received */
438
439   SHA1(cl->mychallenge, RSA_size(myself->rsa_key), hash);
440
441   /* Convert the hash to a hexadecimal formatted string */
442
443   bin2hex(hash,hash,SHA_DIGEST_LENGTH);
444   hash[SHA_DIGEST_LENGTH*2] = '\0';
445
446   /* Send the reply */
447
448 cp
449   return send_request(cl, "%d %s", CHAL_REPLY, hash);
450 }
451
452 int chal_reply_h(connection_t *cl)
453 {
454   char hishash[MAX_STRING_SIZE];
455   char myhash[SHA_DIGEST_LENGTH];
456 cp
457   if(sscanf(cl->buffer, "%*d "MAX_STRING, hishash) != 1)
458     {
459        syslog(LOG_ERR, _("Got bad CHAL_REPLY from %s (%s)"), cl->name, cl->hostname);
460        return -1;
461     }
462
463   /* Check if the length of the hash is all right */
464
465   if(strlen(hishash) != SHA_DIGEST_LENGTH*2)
466     {
467       syslog(LOG_ERR, _("Intruder: wrong challenge reply length from %s (%s)"), cl->name, cl->hostname);
468       return -1;
469     }
470
471   /* Convert the hash to binary format */
472
473   hex2bin(hishash, hishash, SHA_DIGEST_LENGTH);
474
475   /* Calculate the hash from the challenge we sent */
476
477   SHA1(cl->hischallenge, RSA_size(cl->rsa_key), myhash);
478
479   /* Verify the incoming hash with the calculated hash */
480
481   if(memcmp(hishash, myhash, SHA_DIGEST_LENGTH))
482     {
483       syslog(LOG_ERR, _("Intruder: wrong challenge reply from %s (%s)"), cl->name, cl->hostname);
484       if(debug_lvl >= DEBUG_SCARY_THINGS)
485         {
486           bin2hex(myhash, hishash, SHA_DIGEST_LENGTH);
487           hishash[SHA_DIGEST_LENGTH*2] = '\0';
488           syslog(LOG_DEBUG, _("Expected challenge reply: %s"), hishash);
489         }
490       return -1;
491     }
492
493   /* Identity has now been positively verified.
494      ack_h() handles the rest from now on.
495    */
496 cp
497   return ack_h(cl);
498 }
499
500 int send_metakey(connection_t *cl)
501 {
502   char *buffer;
503   int len, x;
504 cp
505   len = RSA_size(cl->rsa_key);
506
507   /* Allocate buffers for the meta key */
508
509   buffer = xmalloc(len*2+1);
510
511   if(!cl->cipher_outkey)
512     cl->cipher_outkey = xmalloc(len);
513     
514   if(!cl->cipher_outctx)
515     cl->cipher_outctx = xmalloc(sizeof(*cl->cipher_outctx));
516 cp
517   /* Copy random data to the buffer */
518
519   RAND_bytes(cl->cipher_outkey, len);
520
521   /* The message we send must be smaller than the modulus of the RSA key.
522      By definition, for a key of k bits, the following formula holds:
523      
524        2^(k-1) <= modulus < 2^(k)
525      
526      Where ^ means "to the power of", not "xor".
527      This means that to be sure, we must choose our message < 2^(k-1).
528      This can be done by setting the most significant bit to zero.
529   */
530   
531   cl->cipher_outkey[0] &= 0x7F;
532   
533   if(debug_lvl >= DEBUG_SCARY_THINGS)
534     {
535       bin2hex(cl->cipher_outkey, buffer, len);
536       buffer[len*2] = '\0';
537       syslog(LOG_DEBUG, _("Generated random meta key (unencrypted): %s"), buffer);
538     }
539
540   /* Encrypt the random data
541   
542      We do not use one of the PKCS padding schemes here.
543      This is allowed, because we encrypt a totally random string
544      with a length equal to that of the modulus of the RSA key.
545   */
546   
547   if(RSA_public_encrypt(len, cl->cipher_outkey, buffer, cl->rsa_key, RSA_NO_PADDING) != len)
548     {
549       syslog(LOG_ERR, _("Error during encryption of meta key for %s (%s)"), cl->name, cl->hostname);
550       free(buffer);
551       return -1;
552     }
553 cp
554   /* Convert the encrypted random data to a hexadecimal formatted string */
555
556   bin2hex(buffer, buffer, len);
557   buffer[len*2] = '\0';
558
559   /* Send the meta key */
560
561   x = send_request(cl, "%d %s", METAKEY, buffer);
562   free(buffer);
563
564   /* Further outgoing requests are encrypted with the key we just generated */
565
566   EVP_EncryptInit(cl->cipher_outctx, EVP_bf_cfb(),
567                   cl->cipher_outkey + len - EVP_bf_cfb()->key_len,
568                   cl->cipher_outkey + len - EVP_bf_cfb()->key_len - EVP_bf_cfb()->iv_len);
569
570   cl->status.encryptout = 1;
571 cp
572   return x;
573 }
574
575 int metakey_h(connection_t *cl)
576 {
577   char buffer[MAX_STRING_SIZE];
578   int len;
579 cp
580   if(sscanf(cl->buffer, "%*d "MAX_STRING, buffer) != 1)
581     {
582        syslog(LOG_ERR, _("Got bad METAKEY from %s (%s)"), cl->name, cl->hostname);
583        return -1;
584     }
585
586   len = RSA_size(myself->rsa_key);
587
588   /* Check if the length of the meta key is all right */
589
590   if(strlen(buffer) != len*2)
591     {
592       syslog(LOG_ERR, _("Intruder: wrong meta key length from %s (%s)"), cl->name, cl->hostname);
593       return -1;
594     }
595
596   /* Allocate buffers for the meta key */
597
598   if(!cl->cipher_inkey)
599     cl->cipher_inkey = xmalloc(len);
600
601   if(!cl->cipher_inctx)
602     cl->cipher_inctx = xmalloc(sizeof(*cl->cipher_inctx));
603
604   /* Convert the challenge from hexadecimal back to binary */
605
606   hex2bin(buffer,buffer,len);
607
608   /* Decrypt the meta key */
609   
610   if(RSA_private_decrypt(len, buffer, cl->cipher_inkey, myself->rsa_key, RSA_NO_PADDING) != len)        /* See challenge() */
611     {
612       syslog(LOG_ERR, _("Error during encryption of meta key for %s (%s)"), cl->name, cl->hostname);
613       return -1;
614     }
615
616   if(debug_lvl >= DEBUG_SCARY_THINGS)
617     {
618       bin2hex(cl->cipher_inkey, buffer, len);
619       buffer[len*2] = '\0';
620       syslog(LOG_DEBUG, _("Received random meta key (unencrypted): %s"), buffer);
621     }
622
623   /* All incoming requests will now be encrypted. */
624
625   EVP_DecryptInit(cl->cipher_inctx, EVP_bf_cfb(),
626                   cl->cipher_inkey + len - EVP_bf_cfb()->key_len,
627                   cl->cipher_inkey + len - EVP_bf_cfb()->key_len - EVP_bf_cfb()->iv_len);
628   
629   cl->status.decryptin = 1;
630
631   cl->allow_request = CHALLENGE;
632 cp
633   return send_challenge(cl);
634 }
635
636 /* Address and subnet information exchange */
637
638 int send_add_subnet(connection_t *cl, subnet_t *subnet)
639 {
640   int x;
641   char *netstr;
642   char *owner;
643 cp
644   if((cl->options | myself->options | subnet->owner->options) & OPTION_INDIRECT)
645     owner = myself->name;
646   else
647     owner = subnet->owner->name;
648
649   x = send_request(cl, "%d %s %s", ADD_SUBNET,
650                       owner, netstr = net2str(subnet));
651   free(netstr);
652 cp
653   return x;
654 }
655
656 int add_subnet_h(connection_t *cl)
657 {
658   char subnetstr[MAX_STRING_SIZE];
659   char name[MAX_STRING_SIZE];
660   connection_t *owner, *p;
661   subnet_t *subnet;
662   avl_node_t *node;
663 cp
664   if(sscanf(cl->buffer, "%*d "MAX_STRING" "MAX_STRING, name, subnetstr) != 2)
665     {
666       syslog(LOG_ERR, _("Got bad ADD_SUBNET from %s (%s)"), cl->name, cl->hostname);
667       return -1;
668     }
669
670   /* Check if owner name is a valid */
671
672   if(check_id(name))
673     {
674       syslog(LOG_ERR, _("Got bad ADD_SUBNET from %s (%s): invalid identity name"), cl->name, cl->hostname);
675       return -1;
676     }
677
678   /* Check if subnet string is valid */
679
680   if(!(subnet = str2net(subnetstr)))
681     {
682       syslog(LOG_ERR, _("Got bad ADD_SUBNET from %s (%s): invalid subnet string"), cl->name, cl->hostname);
683       return -1;
684     }
685
686   /* Check if somebody tries to add a subnet of ourself */
687
688   if(!strcmp(name, myself->name))
689     {
690       syslog(LOG_ERR, _("Warning: got ADD_SUBNET from %s (%s) for ourself, restarting"),
691              cl->name, cl->hostname);
692       sighup = 1;
693       return 0;
694     }
695
696   /* Check if the owner of the new subnet is in the connection list */
697
698   if(!(owner = lookup_id(name)))
699     {
700       syslog(LOG_ERR, _("Got ADD_SUBNET for %s from %s (%s) which is not in our connection list"),
701              name, cl->name, cl->hostname);
702       return -1;
703     }
704
705   /* If everything is correct, add the subnet to the list of the owner */
706
707   subnet_add(owner, subnet);
708
709   /* Tell the rest */
710   
711   for(node = connection_tree->head; node; node = node->next)
712     {
713       p = (connection_t *)node->data;
714       if(p->status.meta && p->status.active && p!= cl)
715         send_add_subnet(p, subnet);
716     }
717 cp
718   return 0;
719 }
720
721 int send_del_subnet(connection_t *cl, subnet_t *subnet)
722 {
723   int x;
724   char *netstr;
725   char *owner;
726 cp
727   if(cl->options & OPTION_INDIRECT)
728     owner = myself->name;
729   else
730     owner = subnet->owner->name;
731
732   x = send_request(cl, "%d %s %s", DEL_SUBNET, owner, netstr = net2str(subnet));
733   free(netstr);
734 cp
735   return x;
736 }
737
738 int del_subnet_h(connection_t *cl)
739 {
740   char subnetstr[MAX_STRING_SIZE];
741   char name[MAX_STRING_SIZE];
742   connection_t *owner, *p;
743   subnet_t *subnet;
744   avl_node_t *node;
745 cp
746   if(sscanf(cl->buffer, "%*d "MAX_STRING" "MAX_STRING, name, subnetstr) != 3)
747     {
748       syslog(LOG_ERR, _("Got bad DEL_SUBNET from %s (%s)"), cl->name, cl->hostname);
749       return -1;
750     }
751
752   /* Check if owner name is a valid */
753
754   if(check_id(name))
755     {
756       syslog(LOG_ERR, _("Got bad DEL_SUBNET from %s (%s): invalid identity name"), cl->name, cl->hostname);
757       return -1;
758     }
759
760   /* Check if subnet string is valid */
761
762   if(!(subnet = str2net(subnetstr)))
763     {
764       syslog(LOG_ERR, _("Got bad DEL_SUBNET from %s (%s): invalid subnet string"), cl->name, cl->hostname);
765       return -1;
766     }
767
768   free(subnetstr);
769   
770   /* Check if somebody tries to add a subnet of ourself */
771
772   if(!strcmp(name, myself->name))
773     {
774       syslog(LOG_ERR, _("Warning: got DEL_SUBNET from %s (%s) for ourself, restarting"),
775              cl->name, cl->hostname);
776       sighup = 1;
777       return 0;
778     }
779
780   /* Check if the owner of the new subnet is in the connection list */
781
782   if(!(owner = lookup_id(name)))
783     {
784       syslog(LOG_ERR, _("Got DEL_SUBNET for %s from %s (%s) which is not in our connection list"),
785              name, cl->name, cl->hostname);
786       return -1;
787     }
788
789   /* If everything is correct, delete the subnet from the list of the owner */
790
791   subnet_del(subnet);
792
793   /* Tell the rest */
794   
795   for(node = connection_tree->head; node; node = node->next)
796     {
797       p = (connection_t *)node->data;
798       if(p->status.meta && p->status.active && p!= cl)
799         send_del_subnet(p, subnet);
800     }
801 cp
802   return 0;
803 }
804
805 /* New and closed connections notification */
806
807 int send_add_host(connection_t *cl, connection_t *other)
808 {
809 cp
810   if(!((cl->options | myself->options | other->options) & OPTION_INDIRECT))
811     return send_request(cl, "%d %s %lx:%d %lx", ADD_HOST,
812                       other->name, other->address, other->port, other->options);
813   else
814     return 0;
815 }
816
817 int add_host_h(connection_t *cl)
818 {
819   connection_t *old, *new, *p;
820   char name[MAX_STRING_SIZE];
821   avl_node_t *node;
822 cp
823   new = new_connection();
824
825   if(sscanf(cl->buffer, "%*d "MAX_STRING" %lx:%hd %lx", name, &new->address, &new->port, &new->options) != 4)
826     {
827        syslog(LOG_ERR, _("Got bad ADD_HOST from %s (%s)"), cl->name, cl->hostname);
828        return -1;
829     }
830
831   /* Check if identity is a valid name */
832
833   if(check_id(name))
834     {
835       syslog(LOG_ERR, _("Got bad ADD_HOST from %s (%s): invalid identity name"), cl->name, cl->hostname);
836       free_connection(new);
837       return -1;
838     }
839
840   /* Check if somebody tries to add ourself */
841
842   if(!strcmp(name, myself->name))
843     {
844       syslog(LOG_ERR, _("Warning: got ADD_HOST from %s (%s) for ourself, restarting"), cl->name, cl->hostname);
845       sighup = 1;
846       free_connection(new);
847       return 0;
848     }
849     
850   /* Fill in more of the new connection structure */
851
852   new->hostname = hostlookup(htonl(new->address));
853
854   /* Check if the new host already exists in the connnection list */
855
856   if((old = lookup_id(name)))
857     {
858       if((new->address == old->address) && (new->port == old->port))
859         {
860           if(debug_lvl >= DEBUG_CONNECTIONS)
861             syslog(LOG_NOTICE, _("Got duplicate ADD_HOST for %s (%s) from %s (%s)"),
862                    old->name, old->hostname, name, new->hostname);
863           free_connection(new);
864           return 0;
865         }
866       else
867         {
868           if(debug_lvl >= DEBUG_CONNECTIONS)
869             syslog(LOG_NOTICE, _("Removing old entry for %s (%s) in favour of new connection"),
870                    old->name, old->hostname);
871
872           terminate_connection(old);
873         }
874     }
875
876   /* Hook it up into the connection */
877
878   new->name = xstrdup(name);
879   connection_add(new);
880   id_add(new);
881
882   /* Tell the rest about the new host */
883
884   for(node = connection_tree->head; node; node = node->next)
885     {
886       p = (connection_t *)node->data;
887       if(p->status.meta && p->status.active && p!=cl)
888         send_add_host(p, new);
889     }
890
891   /* Fill in rest of connection structure */
892
893   new->nexthop = cl;
894   new->status.active = 1;
895   new->cipher_pkttype = EVP_bf_cbc();
896   new->cipher_pktkeylength = cl->cipher_pkttype->key_len + cl->cipher_pkttype->iv_len;
897 cp
898   return 0;
899 }
900
901 int send_del_host(connection_t *cl, connection_t *other)
902 {
903 cp
904   if(!((cl->options | myself->options) & OPTION_INDIRECT))
905     return send_request(cl, "%d %s %lx:%d %lx", DEL_HOST,
906                       other->name, other->address, other->port, other->options);
907   else
908     return 0;
909 }
910
911 int del_host_h(connection_t *cl)
912 {
913   char name[MAX_STRING_SIZE];
914   ipv4_t address;
915   port_t port;
916   long int options;
917   connection_t *old, *p;
918   avl_node_t *node;
919 cp
920   if(sscanf(cl->buffer, "%*d "MAX_STRING" %lx:%hd %lx", name, &address, &port, &options) != 4)
921     {
922       syslog(LOG_ERR, _("Got bad DEL_HOST from %s (%s)"),
923              cl->name, cl->hostname);
924       return -1;
925     }
926
927   /* Check if identity is a valid name */
928
929   if(check_id(name))
930     {
931       syslog(LOG_ERR, _("Got bad DEL_HOST from %s (%s): invalid identity name"), cl->name, cl->hostname);
932       return -1;
933     }
934
935   /* Check if somebody tries to delete ourself */
936
937   if(!strcmp(name, myself->name))
938     {
939       syslog(LOG_ERR, _("Warning: got DEL_HOST from %s (%s) for ourself, restarting"),
940              cl->name, cl->hostname);
941       sighup = 1;
942       return 0;
943     }
944
945   /* Check if the new host already exists in the connnection list */
946
947   if(!(old = lookup_id(name)))
948     {
949       syslog(LOG_ERR, _("Got DEL_HOST from %s (%s) for %s which is not in our connection list"),
950              name, cl->name, cl->hostname);
951       return -1;
952     }
953   
954   /* Check if the rest matches */
955   
956   if(address!=old->address || port!=old->port || options!=old->options || cl!=old->nexthop)
957     {
958       syslog(LOG_WARNING, _("Got DEL_HOST from %s (%s) for %s which doesn't match"), cl->name, cl->hostname, old->name);
959       return 0;
960     }
961
962   /* Ok, since EVERYTHING seems to check out all right, delete it */
963
964   old->status.active = 0;
965   terminate_connection(old);
966
967   /* Tell the rest about the new host */
968
969   for(node = connection_tree->head; node; node = node->next)
970     {
971       p = (connection_t *)node->data;
972       if(p->status.meta && p->status.active && p!=cl)
973         send_del_host(p, old);
974     }
975 cp
976   return 0;
977 }
978
979 /* Status and error notification routines */
980
981 int send_status(connection_t *cl, int statusno, char *statusstring)
982 {
983 cp
984   if(!statusstring)
985     statusstring = status_text[statusno];
986 cp
987   return send_request(cl, "%d %d %s", STATUS, statusno, statusstring);
988 }
989
990 int status_h(connection_t *cl)
991 {
992   int statusno;
993   char statusstring[MAX_STRING_SIZE];
994 cp
995   if(sscanf(cl->buffer, "%*d %d "MAX_STRING, &statusno, statusstring) != 2)
996     {
997        syslog(LOG_ERR, _("Got bad STATUS from %s (%s)"),
998               cl->name, cl->hostname);
999        return -1;
1000     }
1001
1002   if(debug_lvl >= DEBUG_STATUS)
1003     {
1004       syslog(LOG_NOTICE, _("Status message from %s (%s): %s: %s"),
1005              cl->name, cl->hostname, status_text[statusno], statusstring);
1006     }
1007
1008 cp
1009   return 0;
1010 }
1011
1012 int send_error(connection_t *cl, int err, char *errstring)
1013 {
1014 cp
1015   if(!errstring)
1016     errstring = strerror(err);
1017   return send_request(cl, "%d %d %s", ERROR, err, errstring);
1018 }
1019
1020 int error_h(connection_t *cl)
1021 {
1022   int err;
1023   char errorstring[MAX_STRING_SIZE];
1024 cp
1025   if(sscanf(cl->buffer, "%*d %d "MAX_STRING, &err, errorstring) != 2)
1026     {
1027        syslog(LOG_ERR, _("Got bad ERROR from %s (%s)"),
1028               cl->name, cl->hostname);
1029        return -1;
1030     }
1031
1032   if(debug_lvl >= DEBUG_ERROR)
1033     {
1034       syslog(LOG_NOTICE, _("Error message from %s (%s): %s: %s"),
1035              cl->name, cl->hostname, strerror(err), errorstring);
1036     }
1037
1038   terminate_connection(cl);
1039 cp
1040   return 0;
1041 }
1042
1043 int send_termreq(connection_t *cl)
1044 {
1045 cp
1046   return send_request(cl, "%d", TERMREQ);
1047 }
1048
1049 int termreq_h(connection_t *cl)
1050 {
1051 cp
1052   terminate_connection(cl);
1053 cp
1054   return 0;
1055 }
1056
1057 int send_ping(connection_t *cl)
1058 {
1059   char salt[SALTLEN*2+1];
1060 cp
1061   cl->status.pinged = 1;
1062   cl->last_ping_time = time(NULL);
1063   RAND_bytes(salt, SALTLEN);
1064   bin2hex(salt, salt, SALTLEN);
1065   salt[SALTLEN*2] = '\0';
1066 cp
1067   return send_request(cl, "%d %s", PING, salt);
1068 }
1069
1070 int ping_h(connection_t *cl)
1071 {
1072 cp
1073   return send_pong(cl);
1074 }
1075
1076 int send_pong(connection_t *cl)
1077 {
1078   char salt[SALTLEN*2+1];
1079 cp
1080   RAND_bytes(salt, SALTLEN);
1081   bin2hex(salt, salt, SALTLEN);
1082   salt[SALTLEN*2] = '\0';
1083 cp
1084   return send_request(cl, "%d %s", PONG, salt);
1085 }
1086
1087 int pong_h(connection_t *cl)
1088 {
1089 cp
1090   cl->status.pinged = 0;
1091 cp
1092   return 0;
1093 }
1094
1095 /* Key exchange */
1096
1097 int send_key_changed(connection_t *from, connection_t *cl)
1098 {
1099   connection_t *p;
1100   avl_node_t *node;
1101 cp
1102   /* Only send this message if some other daemon requested our key previously.
1103      This reduces unnecessary key_changed broadcasts.
1104   */
1105
1106   if(from==myself && !mykeyused)
1107     return 0;
1108
1109   for(node = connection_tree->head; node; node = node->next)
1110     {
1111       p = (connection_t *)node->data;
1112       if(p != cl && p->status.meta && p->status.active)
1113         if(!(p->options & OPTION_INDIRECT) || from == myself)
1114           send_request(p, "%d %s", KEY_CHANGED, from->name);
1115     }
1116 cp
1117   return 0;
1118 }
1119
1120 int key_changed_h(connection_t *cl)
1121 {
1122   char from_id[MAX_STRING_SIZE];
1123   connection_t *from;
1124 cp
1125   if(sscanf(cl->buffer, "%*d "MAX_STRING, from_id) != 1)
1126     {
1127       syslog(LOG_ERR, _("Got bad KEY_CHANGED from %s (%s)"),
1128              cl->name, cl->hostname);
1129       return -1;
1130     }
1131
1132   if(!(from = lookup_id(from_id)))
1133     {
1134       syslog(LOG_ERR, _("Got KEY_CHANGED from %s (%s) origin %s which does not exist in our connection list"),
1135              cl->name, cl->hostname, from_id);
1136       return -1;
1137     }
1138
1139   from->status.validkey = 0;
1140   from->status.waitingforkey = 0;
1141
1142   if(!(from->options | cl->options | myself->options) & OPTION_INDIRECT)
1143     send_key_changed(from, cl);
1144 cp
1145   return 0;
1146 }
1147
1148 int send_req_key(connection_t *from, connection_t *to)
1149 {
1150 cp
1151   return send_request(to->nexthop, "%d %s %s", REQ_KEY,
1152                       from->name, to->name);
1153 }
1154
1155 int req_key_h(connection_t *cl)
1156 {
1157   char from_id[MAX_STRING_SIZE];
1158   char to_id[MAX_STRING_SIZE];
1159   connection_t *from, *to;
1160   char pktkey[129];
1161 cp
1162   if(sscanf(cl->buffer, "%*d "MAX_STRING" "MAX_STRING, from_id, to_id) != 2)
1163     {
1164        syslog(LOG_ERR, _("Got bad REQ_KEY from %s (%s)"),
1165               cl->name, cl->hostname);
1166        return -1;
1167     }
1168
1169   if(!(from = lookup_id(from_id)))
1170     {
1171       syslog(LOG_ERR, _("Got REQ_KEY from %s (%s) origin %s which does not exist in our connection list"),
1172              cl->name, cl->hostname, from_id);
1173       return -1;
1174     }
1175
1176   /* Check if this key request is for us */
1177
1178   if(!strcmp(to_id, myself->name))      /* Yes, send our own key back */
1179     {
1180       bin2hex(myself->cipher_pktkey, pktkey, myself->cipher_pktkeylength);
1181       pktkey[myself->cipher_pktkeylength*2] = '\0';
1182       send_ans_key(myself, from, pktkey);
1183       mykeyused = 1;
1184     }
1185   else
1186     {
1187       if(!(to = lookup_id(to_id)))
1188         {
1189           syslog(LOG_ERR, _("Got REQ_KEY from %s (%s) destination %s which does not exist in our connection list"),
1190                  cl->name, cl->hostname, to_id);
1191           return -1;
1192         }
1193         
1194       if(to->status.validkey)   /* Proxy keys */
1195         {
1196           bin2hex(to->cipher_pktkey, pktkey, to->cipher_pktkeylength);
1197           pktkey[to->cipher_pktkeylength*2] = '\0';
1198           send_ans_key(to, from, pktkey);
1199         }
1200       else
1201         send_req_key(from, to);
1202     }
1203
1204 cp
1205   return 0;
1206 }
1207
1208 int send_ans_key(connection_t *from, connection_t *to, char *pktkey)
1209 {
1210 cp
1211   return send_request(to->nexthop, "%d %s %s %s", ANS_KEY,
1212                       from->name, to->name, pktkey);
1213 }
1214
1215 int ans_key_h(connection_t *cl)
1216 {
1217   char from_id[MAX_STRING_SIZE];
1218   char to_id[MAX_STRING_SIZE];
1219   char pktkey[MAX_STRING_SIZE];
1220   int keylength;
1221   connection_t *from, *to;
1222 cp
1223   if(sscanf(cl->buffer, "%*d "MAX_STRING" "MAX_STRING" "MAX_STRING, from_id, to_id, pktkey) != 3)
1224     {
1225        syslog(LOG_ERR, _("Got bad ANS_KEY from %s (%s)"),
1226               cl->name, cl->hostname);
1227        return -1;
1228     }
1229
1230   if(!(from = lookup_id(from_id)))
1231     {
1232       syslog(LOG_ERR, _("Got ANS_KEY from %s (%s) origin %s which does not exist in our connection list"),
1233              cl->name, cl->hostname, from_id);
1234       return -1;
1235     }
1236
1237   /* Check correctness of packet key */
1238
1239   keylength = strlen(pktkey);
1240
1241   if(keylength != from->cipher_pktkeylength*2)
1242     {
1243       syslog(LOG_ERR, _("Got bad ANS_KEY from %s (%s) origin %s: invalid key length"),
1244              cl->name, cl->hostname, from->name);
1245       return -1;
1246     }
1247
1248   /* Forward it if necessary */
1249
1250   if(strcmp(to_id, myself->name))
1251     {
1252       if(!(to = lookup_id(to_id)))
1253         {
1254           syslog(LOG_ERR, _("Got ANS_KEY from %s (%s) destination %s which does not exist in our connection list"),
1255                  cl->name, cl->hostname, to_id);
1256           return -1;
1257         }
1258       send_ans_key(from, to, pktkey);
1259     }
1260
1261   /* Update our copy of the origin's packet key */
1262
1263   if(from->cipher_pktkey)
1264     free(from->cipher_pktkey);
1265
1266   from->cipher_pktkey = xstrdup(pktkey);
1267   keylength /= 2;
1268   hex2bin(from->cipher_pktkey, from->cipher_pktkey, keylength);
1269   from->cipher_pktkey[keylength] = '\0';
1270
1271   from->status.validkey = 1;
1272   from->status.waitingforkey = 0;
1273   
1274   flush_queue(from);
1275 cp
1276   return 0;
1277 }
1278
1279 int send_tcppacket(connection_t *cl, vpn_packet_t *packet)
1280 {
1281   int x;
1282 cp  
1283   /* Evil hack. */
1284
1285   x = send_request(cl->nexthop, "%d %hd", PACKET, packet->len);
1286
1287   if(x)
1288     return x;
1289 cp
1290   return send_meta(cl, packet->data, packet->len);
1291 }
1292
1293 int tcppacket_h(connection_t *cl)
1294 {
1295   short int len;
1296 cp  
1297   if(sscanf(cl->buffer, "%*d %hd", &len) != 1)
1298     {
1299       syslog(LOG_ERR, _("Got bad PACKET from %s (%s)"), cl->name, cl->hostname);
1300       return -1;
1301     }
1302
1303   /* Set reqlen to len, this will tell receive_meta() that a tcppacket is coming. */
1304
1305   cl->tcplen = len;
1306 cp
1307   return 0;
1308 }
1309
1310 /* Jumptable for the request handlers */
1311
1312 int (*request_handlers[])(connection_t*) = {
1313   id_h, metakey_h, challenge_h, chal_reply_h,
1314   status_h, error_h, termreq_h,
1315   ping_h, pong_h,
1316   add_host_h, del_host_h,
1317   add_subnet_h, del_subnet_h,
1318   key_changed_h, req_key_h, ans_key_h,
1319   tcppacket_h,
1320 };
1321
1322 /* Request names */
1323
1324 char (*request_name[]) = {
1325   "ID", "METAKEY", "CHALLENGE", "CHAL_REPLY",
1326   "STATUS", "ERROR", "TERMREQ",
1327   "PING", "PONG",
1328   "ADD_HOST", "DEL_HOST",
1329   "ADD_SUBNET", "DEL_SUBNET",
1330   "KEY_CHANGED", "REQ_KEY", "ANS_KEY",
1331   "PACKET",
1332 };
1333
1334 /* Status strings */
1335
1336 char (*status_text[]) = {
1337   "Warning",
1338 };
1339
1340 /* Error strings */
1341
1342 char (*error_text[]) = {
1343   "Error",
1344 };