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