slip: Buffer management (max_start_pad) fixes
[secnet] / netlink.c
1 /* User-kernel network link */
2
3 /* See RFCs 791, 792, 1123 and 1812 */
4
5 /* The netlink device is actually a router. Tunnels are unnumbered
6 point-to-point lines (RFC1812 section 2.2.7); the router has a
7 single address (the 'router-id'). */
8
9 /* This is where we currently have the anti-spoofing paranoia - before
10 sending a packet to the kernel we check that the tunnel it came
11 over could reasonably have produced it. */
12
13
14 /* Points to note from RFC1812 (which may require changes in this
15 file):
16
17 3.3.4 Maximum Transmission Unit - MTU
18
19 The MTU of each logical interface MUST be configurable within the
20 range of legal MTUs for the interface.
21
22 Many Link Layer protocols define a maximum frame size that may be
23 sent. In such cases, a router MUST NOT allow an MTU to be set which
24 would allow sending of frames larger than those allowed by the Link
25 Layer protocol. However, a router SHOULD be willing to receive a
26 packet as large as the maximum frame size even if that is larger than
27 the MTU.
28
29 4.2.1 A router SHOULD count datagrams discarded.
30
31 4.2.2.1 Source route options - we probably should implement processing
32 of source routes, even though mostly the security policy will prevent
33 their use.
34
35 5.3.13.4 Source Route Options
36
37 A router MUST implement support for source route options in forwarded
38 packets. A router MAY implement a configuration option that, when
39 enabled, causes all source-routed packets to be discarded. However,
40 such an option MUST NOT be enabled by default.
41
42 5.3.13.5 Record Route Option
43
44 Routers MUST support the Record Route option in forwarded packets.
45
46 A router MAY provide a configuration option that, if enabled, will
47 cause the router to ignore (i.e., pass through unchanged) Record
48 Route options in forwarded packets. If provided, such an option MUST
49 default to enabling the record-route. This option should not affect
50 the processing of Record Route options in datagrams received by the
51 router itself (in particular, Record Route options in ICMP echo
52 requests will still be processed according to Section [4.3.3.6]).
53
54 5.3.13.6 Timestamp Option
55
56 Routers MUST support the timestamp option in forwarded packets. A
57 timestamp value MUST follow the rules given [INTRO:2].
58
59 If the flags field = 3 (timestamp and prespecified address), the
60 router MUST add its timestamp if the next prespecified address
61 matches any of the router's IP addresses. It is not necessary that
62 the prespecified address be either the address of the interface on
63 which the packet arrived or the address of the interface over which
64 it will be sent.
65
66
67 4.2.2.7 Fragmentation: RFC 791 Section 3.2
68
69 Fragmentation, as described in [INTERNET:1], MUST be supported by a
70 router.
71
72 4.2.2.8 Reassembly: RFC 791 Section 3.2
73
74 As specified in the corresponding section of [INTRO:2], a router MUST
75 support reassembly of datagrams that it delivers to itself.
76
77 4.2.2.9 Time to Live: RFC 791 Section 3.2
78
79 Note in particular that a router MUST NOT check the TTL of a packet
80 except when forwarding it.
81
82 A router MUST NOT discard a datagram just because it was received
83 with TTL equal to zero or one; if it is to the router and otherwise
84 valid, the router MUST attempt to receive it.
85
86 On messages the router originates, the IP layer MUST provide a means
87 for the transport layer to set the TTL field of every datagram that
88 is sent. When a fixed TTL value is used, it MUST be configurable.
89
90
91 8.1 The Simple Network Management Protocol - SNMP
92 8.1.1 SNMP Protocol Elements
93
94 Routers MUST be manageable by SNMP [MGT:3]. The SNMP MUST operate
95 using UDP/IP as its transport and network protocols.
96
97
98 */
99
100 #include <string.h>
101 #include <assert.h>
102 #include <limits.h>
103 #include "secnet.h"
104 #include "util.h"
105 #include "ipaddr.h"
106 #include "netlink.h"
107 #include "process.h"
108
109 #define ICMP_TYPE_ECHO_REPLY 0
110
111 #define ICMP_TYPE_UNREACHABLE 3
112 #define ICMP_CODE_NET_UNREACHABLE 0
113 #define ICMP_CODE_PROTOCOL_UNREACHABLE 2
114 #define ICMP_CODE_FRAGMENTATION_REQUIRED 4
115 #define ICMP_CODE_NET_PROHIBITED 13
116
117 #define ICMP_TYPE_ECHO_REQUEST 8
118
119 #define ICMP_TYPE_TIME_EXCEEDED 11
120 #define ICMP_CODE_TTL_EXCEEDED 0
121
122 /* Generic IP checksum routine */
123 static inline uint16_t ip_csum(uint8_t *iph,int32_t count)
124 {
125 register uint32_t sum=0;
126
127 while (count>1) {
128 sum+=ntohs(*(uint16_t *)iph);
129 iph+=2;
130 count-=2;
131 }
132 if(count>0)
133 sum+=*(uint8_t *)iph;
134 while (sum>>16)
135 sum=(sum&0xffff)+(sum>>16);
136 return htons(~sum);
137 }
138
139 #ifdef i386
140 /*
141 * This is a version of ip_compute_csum() optimized for IP headers,
142 * which always checksum on 4 octet boundaries.
143 *
144 * By Jorge Cwik <jorge@laser.satlink.net>, adapted for linux by
145 * Arnt Gulbrandsen.
146 */
147 static inline uint16_t ip_fast_csum(uint8_t *iph, int32_t ihl) {
148 uint32_t sum;
149
150 __asm__ __volatile__(
151 "movl (%1), %0 ;\n"
152 "subl $4, %2 ;\n"
153 "jbe 2f ;\n"
154 "addl 4(%1), %0 ;\n"
155 "adcl 8(%1), %0 ;\n"
156 "adcl 12(%1), %0 ;\n"
157 "1: adcl 16(%1), %0 ;\n"
158 "lea 4(%1), %1 ;\n"
159 "decl %2 ;\n"
160 "jne 1b ;\n"
161 "adcl $0, %0 ;\n"
162 "movl %0, %2 ;\n"
163 "shrl $16, %0 ;\n"
164 "addw %w2, %w0 ;\n"
165 "adcl $0, %0 ;\n"
166 "notl %0 ;\n"
167 "2: ;\n"
168 /* Since the input registers which are loaded with iph and ipl
169 are modified, we must also specify them as outputs, or gcc
170 will assume they contain their original values. */
171 : "=r" (sum), "=r" (iph), "=r" (ihl)
172 : "1" (iph), "2" (ihl)
173 : "memory");
174 return sum;
175 }
176 #else
177 static inline uint16_t ip_fast_csum(uint8_t *iph, int32_t ihl)
178 {
179 assert(ihl < INT_MAX/4);
180 return ip_csum(iph,ihl*4);
181 }
182 #endif
183
184 struct iphdr {
185 #if defined (WORDS_BIGENDIAN)
186 uint8_t version:4,
187 ihl:4;
188 #else
189 uint8_t ihl:4,
190 version:4;
191 #endif
192 uint8_t tos;
193 uint16_t tot_len;
194 uint16_t id;
195 uint16_t frag_off;
196 uint8_t ttl;
197 uint8_t protocol;
198 uint16_t check;
199 uint32_t saddr;
200 uint32_t daddr;
201 /* The options start here. */
202 };
203
204 struct icmphdr {
205 struct iphdr iph;
206 uint8_t type;
207 uint8_t code;
208 uint16_t check;
209 union {
210 uint32_t unused;
211 struct {
212 uint8_t pointer;
213 uint8_t unused1;
214 uint16_t unused2;
215 } pprob;
216 uint32_t gwaddr;
217 struct {
218 uint16_t id;
219 uint16_t seq;
220 } echo;
221 } d;
222 };
223
224 static void netlink_packet_deliver(struct netlink *st,
225 struct netlink_client *client,
226 struct buffer_if *buf);
227
228 /* XXX RFC1812 4.3.2.5:
229 All other ICMP error messages (Destination Unreachable,
230 Redirect, Time Exceeded, and Parameter Problem) SHOULD have their
231 precedence value set to 6 (INTERNETWORK CONTROL) or 7 (NETWORK
232 CONTROL). The IP Precedence value for these error messages MAY be
233 settable.
234 */
235 static struct icmphdr *netlink_icmp_tmpl(struct netlink *st,
236 uint32_t dest,uint16_t len)
237 {
238 struct icmphdr *h;
239
240 BUF_ALLOC(&st->icmp,"netlink_icmp_tmpl");
241 buffer_init(&st->icmp,calculate_max_start_pad());
242 h=buf_append(&st->icmp,sizeof(*h));
243
244 h->iph.version=4;
245 h->iph.ihl=5;
246 h->iph.tos=0;
247 h->iph.tot_len=htons(len+(h->iph.ihl*4)+8);
248 h->iph.id=0;
249 h->iph.frag_off=0;
250 h->iph.ttl=255; /* XXX should be configurable */
251 h->iph.protocol=1;
252 h->iph.saddr=htonl(st->secnet_address);
253 h->iph.daddr=htonl(dest);
254 h->iph.check=0;
255 h->iph.check=ip_fast_csum((uint8_t *)&h->iph,h->iph.ihl);
256 h->check=0;
257 h->d.unused=0;
258
259 return h;
260 }
261
262 /* Fill in the ICMP checksum field correctly */
263 static void netlink_icmp_csum(struct icmphdr *h)
264 {
265 int32_t len;
266
267 len=ntohs(h->iph.tot_len)-(4*h->iph.ihl);
268 h->check=0;
269 h->check=ip_csum(&h->type,len);
270 }
271
272 /* RFC1122:
273 * An ICMP error message MUST NOT be sent as the result of
274 * receiving:
275 *
276 * * an ICMP error message, or
277 *
278 * * a datagram destined to an IP broadcast or IP multicast
279 * address, or
280 *
281 * * a datagram sent as a link-layer broadcast, or
282 *
283 * * a non-initial fragment, or
284 *
285 * * a datagram whose source address does not define a single
286 * host -- e.g., a zero address, a loopback address, a
287 * broadcast address, a multicast address, or a Class E
288 * address.
289 */
290 static bool_t netlink_icmp_may_reply(struct buffer_if *buf)
291 {
292 struct iphdr *iph;
293 struct icmphdr *icmph;
294 uint32_t source;
295
296 iph=(struct iphdr *)buf->start;
297 icmph=(struct icmphdr *)buf->start;
298 if (iph->protocol==1) {
299 switch(icmph->type) {
300 case 3: /* Destination unreachable */
301 case 11: /* Time Exceeded */
302 case 12: /* Parameter Problem */
303 return False;
304 }
305 }
306 /* How do we spot broadcast destination addresses? */
307 if (ntohs(iph->frag_off)&0x1fff) return False; /* Non-initial fragment */
308 source=ntohl(iph->saddr);
309 if (source==0) return False;
310 if ((source&0xff000000)==0x7f000000) return False;
311 /* How do we spot broadcast source addresses? */
312 if ((source&0xf0000000)==0xe0000000) return False; /* Multicast */
313 if ((source&0xf0000000)==0xf0000000) return False; /* Class E */
314 return True;
315 }
316
317 /* How much of the original IP packet do we include in its ICMP
318 response? The header plus up to 64 bits. */
319
320 /* XXX TODO RFC1812:
321 4.3.2.3 Original Message Header
322
323 Historically, every ICMP error message has included the Internet
324 header and at least the first 8 data bytes of the datagram that
325 triggered the error. This is no longer adequate, due to the use of
326 IP-in-IP tunneling and other technologies. Therefore, the ICMP
327 datagram SHOULD contain as much of the original datagram as possible
328 without the length of the ICMP datagram exceeding 576 bytes. The
329 returned IP header (and user data) MUST be identical to that which
330 was received, except that the router is not required to undo any
331 modifications to the IP header that are normally performed in
332 forwarding that were performed before the error was detected (e.g.,
333 decrementing the TTL, or updating options). Note that the
334 requirements of Section [4.3.3.5] supersede this requirement in some
335 cases (i.e., for a Parameter Problem message, if the problem is in a
336 modified field, the router must undo the modification). See Section
337 [4.3.3.5]).
338 */
339 static uint16_t netlink_icmp_reply_len(struct buffer_if *buf)
340 {
341 struct iphdr *iph=(struct iphdr *)buf->start;
342 uint16_t hlen,plen;
343
344 hlen=iph->ihl*4;
345 /* We include the first 8 bytes of the packet data, provided they exist */
346 hlen+=8;
347 plen=ntohs(iph->tot_len);
348 return (hlen>plen?plen:hlen);
349 }
350
351 /* client indicates where the packet we're constructing a response to
352 comes from. NULL indicates the host. */
353 static void netlink_icmp_simple(struct netlink *st, struct buffer_if *buf,
354 struct netlink_client *client,
355 uint8_t type, uint8_t code)
356 {
357 struct iphdr *iph=(struct iphdr *)buf->start;
358 struct icmphdr *h;
359 uint16_t len;
360
361 if (netlink_icmp_may_reply(buf)) {
362 len=netlink_icmp_reply_len(buf);
363 h=netlink_icmp_tmpl(st,ntohl(iph->saddr),len);
364 h->type=type; h->code=code;
365 memcpy(buf_append(&st->icmp,len),buf->start,len);
366 netlink_icmp_csum(h);
367 netlink_packet_deliver(st,NULL,&st->icmp);
368 BUF_ASSERT_FREE(&st->icmp);
369 }
370 }
371
372 /*
373 * RFC1122: 3.1.2.2 MUST silently discard any IP frame that fails the
374 * checksum.
375 * RFC1812: 4.2.2.5 MUST discard messages containing invalid checksums.
376 *
377 * Is the datagram acceptable?
378 *
379 * 1. Length at least the size of an ip header
380 * 2. Version of 4
381 * 3. Checksums correctly.
382 * 4. Doesn't have a bogus length
383 */
384 static bool_t netlink_check(struct netlink *st, struct buffer_if *buf,
385 char *errmsgbuf, int errmsgbuflen)
386 {
387 #define BAD(...) do{ \
388 snprintf(errmsgbuf,errmsgbuflen,__VA_ARGS__); \
389 return False; \
390 }while(0)
391
392 struct iphdr *iph=(struct iphdr *)buf->start;
393 int32_t len;
394
395 if (iph->ihl < 5) BAD("ihl %u",iph->ihl);
396 if (iph->version != 4) BAD("version %u",iph->version);
397 if (buf->size < iph->ihl*4) BAD("size %"PRId32"<%u*4",buf->size,iph->ihl);
398 if (ip_fast_csum((uint8_t *)iph, iph->ihl)!=0) BAD("csum");
399 len=ntohs(iph->tot_len);
400 /* There should be no padding */
401 if (buf->size!=len) BAD("len %"PRId32"!=%"PRId32,buf->size,len);
402 if (len<(iph->ihl<<2)) BAD("len %"PRId32"<(%u<<2)",len,iph->ihl);
403 /* XXX check that there's no source route specified */
404 return True;
405
406 #undef BAD
407 }
408
409 /* Deliver a packet. "client" is the _origin_ of the packet, not its
410 destination, and is NULL for packets from the host and packets
411 generated internally in secnet. */
412 static void netlink_packet_deliver(struct netlink *st,
413 struct netlink_client *client,
414 struct buffer_if *buf)
415 {
416 struct iphdr *iph=(struct iphdr *)buf->start;
417 uint32_t dest=ntohl(iph->daddr);
418 uint32_t source=ntohl(iph->saddr);
419 uint32_t best_quality;
420 bool_t allow_route=False;
421 bool_t found_allowed=False;
422 int best_match;
423 int i;
424
425 BUF_ASSERT_USED(buf);
426
427 if (dest==st->secnet_address) {
428 Message(M_ERR,"%s: trying to deliver a packet to myself!\n",st->name);
429 BUF_FREE(buf);
430 return;
431 }
432
433 /* Packets from the host (client==NULL) may always be routed. Packets
434 from clients with the allow_route option will also be routed. */
435 if (!client || (client && (client->options & OPT_ALLOWROUTE)))
436 allow_route=True;
437
438 /* If !allow_route, we check the routing table anyway, and if
439 there's a suitable route with OPT_ALLOWROUTE set we use it. If
440 there's a suitable route, but none with OPT_ALLOWROUTE set then
441 we generate ICMP 'communication with destination network
442 administratively prohibited'. */
443
444 best_quality=0;
445 best_match=-1;
446 for (i=0; i<st->n_clients; i++) {
447 if (st->routes[i]->up &&
448 ipset_contains_addr(st->routes[i]->networks,dest)) {
449 /* It's an available route to the correct destination. But is
450 it better than the one we already have? */
451
452 /* If we have already found an allowed route then we don't
453 bother looking at routes we're not allowed to use. If
454 we don't yet have an allowed route we'll consider any. */
455 if (!allow_route && found_allowed) {
456 if (!(st->routes[i]->options&OPT_ALLOWROUTE)) continue;
457 }
458
459 if (st->routes[i]->link_quality>best_quality
460 || best_quality==0) {
461 best_quality=st->routes[i]->link_quality;
462 best_match=i;
463 if (st->routes[i]->options&OPT_ALLOWROUTE)
464 found_allowed=True;
465 /* If quality isn't perfect we may wish to
466 consider kicking the tunnel with a 0-length
467 packet to prompt it to perform a key setup.
468 Then it'll eventually decide it's up or
469 down. */
470 /* If quality is perfect and we're allowed to use the
471 route we don't need to search any more. */
472 if (best_quality>=MAXIMUM_LINK_QUALITY &&
473 (allow_route || found_allowed)) break;
474 }
475 }
476 }
477 if (best_match==-1) {
478 /* The packet's not going down a tunnel. It might (ought to)
479 be for the host. */
480 if (ipset_contains_addr(st->networks,dest)) {
481 st->deliver_to_host(st->dst,buf);
482 st->outcount++;
483 BUF_ASSERT_FREE(buf);
484 } else {
485 string_t s,d;
486 s=ipaddr_to_string(source);
487 d=ipaddr_to_string(dest);
488 Message(M_DEBUG,"%s: don't know where to deliver packet "
489 "(s=%s, d=%s)\n", st->name, s, d);
490 free(s); free(d);
491 netlink_icmp_simple(st,buf,client,ICMP_TYPE_UNREACHABLE,
492 ICMP_CODE_NET_UNREACHABLE);
493 BUF_FREE(buf);
494 }
495 } else {
496 if (!allow_route &&
497 !(st->routes[best_match]->options&OPT_ALLOWROUTE)) {
498 string_t s,d;
499 s=ipaddr_to_string(source);
500 d=ipaddr_to_string(dest);
501 /* We have a usable route but aren't allowed to use it.
502 Generate ICMP destination unreachable: communication
503 with destination network administratively prohibited */
504 Message(M_NOTICE,"%s: denied forwarding for packet (s=%s, d=%s)\n",
505 st->name,s,d);
506 free(s); free(d);
507
508 netlink_icmp_simple(st,buf,client,ICMP_TYPE_UNREACHABLE,
509 ICMP_CODE_NET_PROHIBITED);
510 BUF_FREE(buf);
511 } else {
512 if (best_quality>0) {
513 /* XXX Fragment if required */
514 st->routes[best_match]->deliver(
515 st->routes[best_match]->dst, buf);
516 st->routes[best_match]->outcount++;
517 BUF_ASSERT_FREE(buf);
518 } else {
519 /* Generate ICMP destination unreachable */
520 netlink_icmp_simple(st,buf,client,ICMP_TYPE_UNREACHABLE,
521 ICMP_CODE_NET_UNREACHABLE); /* client==NULL */
522 BUF_FREE(buf);
523 }
524 }
525 }
526 BUF_ASSERT_FREE(buf);
527 }
528
529 static void netlink_packet_forward(struct netlink *st,
530 struct netlink_client *client,
531 struct buffer_if *buf)
532 {
533 struct iphdr *iph=(struct iphdr *)buf->start;
534
535 BUF_ASSERT_USED(buf);
536
537 /* Packet has already been checked */
538 if (iph->ttl<=1) {
539 /* Generate ICMP time exceeded */
540 netlink_icmp_simple(st,buf,client,ICMP_TYPE_TIME_EXCEEDED,
541 ICMP_CODE_TTL_EXCEEDED);
542 BUF_FREE(buf);
543 return;
544 }
545 iph->ttl--;
546 iph->check=0;
547 iph->check=ip_fast_csum((uint8_t *)iph,iph->ihl);
548
549 netlink_packet_deliver(st,client,buf);
550 BUF_ASSERT_FREE(buf);
551 }
552
553 /* Deal with packets addressed explicitly to us */
554 static void netlink_packet_local(struct netlink *st,
555 struct netlink_client *client,
556 struct buffer_if *buf)
557 {
558 struct icmphdr *h;
559
560 st->localcount++;
561
562 h=(struct icmphdr *)buf->start;
563
564 if ((ntohs(h->iph.frag_off)&0xbfff)!=0) {
565 Message(M_WARNING,"%s: fragmented packet addressed to secnet; "
566 "ignoring it\n",st->name);
567 BUF_FREE(buf);
568 return;
569 }
570
571 if (h->iph.protocol==1) {
572 /* It's ICMP */
573 if (h->type==ICMP_TYPE_ECHO_REQUEST && h->code==0) {
574 /* ICMP echo-request. Special case: we re-use the buffer
575 to construct the reply. */
576 h->type=ICMP_TYPE_ECHO_REPLY;
577 h->iph.daddr=h->iph.saddr;
578 h->iph.saddr=htonl(st->secnet_address);
579 h->iph.ttl=255;
580 h->iph.check=0;
581 h->iph.check=ip_fast_csum((uint8_t *)h,h->iph.ihl);
582 netlink_icmp_csum(h);
583 netlink_packet_deliver(st,NULL,buf);
584 return;
585 }
586 Message(M_WARNING,"%s: unknown incoming ICMP\n",st->name);
587 } else {
588 /* Send ICMP protocol unreachable */
589 netlink_icmp_simple(st,buf,client,ICMP_TYPE_UNREACHABLE,
590 ICMP_CODE_PROTOCOL_UNREACHABLE);
591 BUF_FREE(buf);
592 return;
593 }
594
595 BUF_FREE(buf);
596 }
597
598 /* If cid==NULL packet is from host, otherwise cid specifies which tunnel
599 it came from. */
600 static void netlink_incoming(struct netlink *st, struct netlink_client *client,
601 struct buffer_if *buf)
602 {
603 uint32_t source,dest;
604 struct iphdr *iph;
605 char errmsgbuf[50];
606 const char *sourcedesc=client?client->name:"host";
607
608 BUF_ASSERT_USED(buf);
609
610 if (!netlink_check(st,buf,errmsgbuf,sizeof(errmsgbuf))) {
611 Message(M_WARNING,"%s: bad IP packet from %s: %s\n",
612 st->name,sourcedesc,
613 errmsgbuf);
614 BUF_FREE(buf);
615 return;
616 }
617 iph=(struct iphdr *)buf->start;
618
619 source=ntohl(iph->saddr);
620 dest=ntohl(iph->daddr);
621
622 /* Check source. If we don't like the source, there's no point
623 generating ICMP because we won't know how to get it to the
624 source of the packet. */
625 if (client) {
626 /* Check that the packet source is appropriate for the tunnel
627 it came down */
628 if (!ipset_contains_addr(client->networks,source)) {
629 string_t s,d;
630 s=ipaddr_to_string(source);
631 d=ipaddr_to_string(dest);
632 Message(M_WARNING,"%s: packet from tunnel %s with bad "
633 "source address (s=%s,d=%s)\n",st->name,client->name,s,d);
634 free(s); free(d);
635 BUF_FREE(buf);
636 return;
637 }
638 } else {
639 /* Check that the packet originates in our configured local
640 network, and hasn't been forwarded from elsewhere or
641 generated with the wrong source address */
642 if (!ipset_contains_addr(st->networks,source)) {
643 string_t s,d;
644 s=ipaddr_to_string(source);
645 d=ipaddr_to_string(dest);
646 Message(M_WARNING,"%s: outgoing packet with bad source address "
647 "(s=%s,d=%s)\n",st->name,s,d);
648 free(s); free(d);
649 BUF_FREE(buf);
650 return;
651 }
652 }
653
654 /* If this is a point-to-point device we don't examine the
655 destination address at all; we blindly send it down our
656 one-and-only registered tunnel, or to the host, depending on
657 where it came from. It's up to external software to check
658 address validity and generate ICMP, etc. */
659 if (st->ptp) {
660 if (client) {
661 st->deliver_to_host(st->dst,buf);
662 } else {
663 st->clients->deliver(st->clients->dst,buf);
664 }
665 BUF_ASSERT_FREE(buf);
666 return;
667 }
668
669 /* st->secnet_address needs checking before matching destination
670 addresses */
671 if (dest==st->secnet_address) {
672 netlink_packet_local(st,client,buf);
673 BUF_ASSERT_FREE(buf);
674 return;
675 }
676 netlink_packet_forward(st,client,buf);
677 BUF_ASSERT_FREE(buf);
678 }
679
680 static void netlink_inst_incoming(void *sst, struct buffer_if *buf)
681 {
682 struct netlink_client *c=sst;
683 struct netlink *st=c->nst;
684
685 netlink_incoming(st,c,buf);
686 }
687
688 static void netlink_dev_incoming(void *sst, struct buffer_if *buf)
689 {
690 struct netlink *st=sst;
691
692 netlink_incoming(st,NULL,buf);
693 }
694
695 static void netlink_set_quality(void *sst, uint32_t quality)
696 {
697 struct netlink_client *c=sst;
698 struct netlink *st=c->nst;
699
700 c->link_quality=quality;
701 c->up=(c->link_quality==LINK_QUALITY_DOWN)?False:True;
702 if (c->options&OPT_SOFTROUTE) {
703 st->set_routes(st->dst,c);
704 }
705 }
706
707 static void netlink_output_subnets(struct netlink *st, uint32_t loglevel,
708 struct subnet_list *snets)
709 {
710 int32_t i;
711 string_t net;
712
713 for (i=0; i<snets->entries; i++) {
714 net=subnet_to_string(snets->list[i]);
715 Message(loglevel,"%s ",net);
716 free(net);
717 }
718 }
719
720 static void netlink_dump_routes(struct netlink *st, bool_t requested)
721 {
722 int i;
723 string_t net;
724 uint32_t c=M_INFO;
725
726 if (requested) c=M_WARNING;
727 if (st->ptp) {
728 net=ipaddr_to_string(st->secnet_address);
729 Message(c,"%s: point-to-point (remote end is %s); routes:\n",
730 st->name, net);
731 free(net);
732 netlink_output_subnets(st,c,st->clients->subnets);
733 Message(c,"\n");
734 } else {
735 Message(c,"%s: routing table:\n",st->name);
736 for (i=0; i<st->n_clients; i++) {
737 netlink_output_subnets(st,c,st->routes[i]->subnets);
738 Message(c,"-> tunnel %s (%s,mtu %d,%s routes,%s,"
739 "quality %d,use %d,pri %lu)\n",
740 st->routes[i]->name,
741 st->routes[i]->up?"up":"down",
742 st->routes[i]->mtu,
743 st->routes[i]->options&OPT_SOFTROUTE?"soft":"hard",
744 st->routes[i]->options&OPT_ALLOWROUTE?"free":"restricted",
745 st->routes[i]->link_quality,
746 st->routes[i]->outcount,
747 (unsigned long)st->routes[i]->priority);
748 }
749 net=ipaddr_to_string(st->secnet_address);
750 Message(c,"%s/32 -> netlink \"%s\" (use %d)\n",
751 net,st->name,st->localcount);
752 free(net);
753 for (i=0; i<st->subnets->entries; i++) {
754 net=subnet_to_string(st->subnets->list[i]);
755 Message(c,"%s ",net);
756 free(net);
757 }
758 if (i>0)
759 Message(c,"-> host (use %d)\n",st->outcount);
760 }
761 }
762
763 /* ap is a pointer to a member of the routes array */
764 static int netlink_compare_client_priority(const void *ap, const void *bp)
765 {
766 const struct netlink_client *const*a=ap;
767 const struct netlink_client *const*b=bp;
768
769 if ((*a)->priority==(*b)->priority) return 0;
770 if ((*a)->priority<(*b)->priority) return 1;
771 return -1;
772 }
773
774 static void netlink_phase_hook(void *sst, uint32_t new_phase)
775 {
776 struct netlink *st=sst;
777 struct netlink_client *c;
778 int32_t i;
779
780 /* All the networks serviced by the various tunnels should now
781 * have been registered. We build a routing table by sorting the
782 * clients by priority. */
783 st->routes=safe_malloc_ary(sizeof(*st->routes),st->n_clients,
784 "netlink_phase_hook");
785 /* Fill the table */
786 i=0;
787 for (c=st->clients; c; c=c->next) {
788 assert(i<INT_MAX);
789 st->routes[i++]=c;
790 }
791 /* Sort the table in descending order of priority */
792 qsort(st->routes,st->n_clients,sizeof(*st->routes),
793 netlink_compare_client_priority);
794
795 netlink_dump_routes(st,False);
796 }
797
798 static void netlink_signal_handler(void *sst, int signum)
799 {
800 struct netlink *st=sst;
801 Message(M_INFO,"%s: route dump requested by SIGUSR1\n",st->name);
802 netlink_dump_routes(st,True);
803 }
804
805 static void netlink_inst_set_mtu(void *sst, int32_t new_mtu)
806 {
807 struct netlink_client *c=sst;
808
809 c->mtu=new_mtu;
810 }
811
812 static void netlink_inst_reg(void *sst, netlink_deliver_fn *deliver,
813 void *dst)
814 {
815 struct netlink_client *c=sst;
816
817 c->deliver=deliver;
818 c->dst=dst;
819 }
820
821 static struct flagstr netlink_option_table[]={
822 { "soft", OPT_SOFTROUTE },
823 { "allow-route", OPT_ALLOWROUTE },
824 { NULL, 0}
825 };
826 /* This is the routine that gets called when the closure that's
827 returned by an invocation of a netlink device closure (eg. tun,
828 userv-ipif) is invoked. It's used to create routes and pass in
829 information about them; the closure it returns is used by site
830 code. */
831 static closure_t *netlink_inst_create(struct netlink *st,
832 struct cloc loc, dict_t *dict)
833 {
834 struct netlink_client *c;
835 string_t name;
836 struct ipset *networks;
837 uint32_t options,priority;
838 int32_t mtu;
839 list_t *l;
840
841 name=dict_read_string(dict, "name", True, st->name, loc);
842
843 l=dict_lookup(dict,"routes");
844 if (!l)
845 cfgfatal(loc,st->name,"required parameter \"routes\" not found\n");
846 networks=string_list_to_ipset(l,loc,st->name,"routes");
847 options=string_list_to_word(dict_lookup(dict,"options"),
848 netlink_option_table,st->name);
849
850 priority=dict_read_number(dict,"priority",False,st->name,loc,0);
851 mtu=dict_read_number(dict,"mtu",False,st->name,loc,0);
852
853 if ((options&OPT_SOFTROUTE) && !st->set_routes) {
854 cfgfatal(loc,st->name,"this netlink device does not support "
855 "soft routes.\n");
856 return NULL;
857 }
858
859 if (options&OPT_SOFTROUTE) {
860 /* XXX for now we assume that soft routes require root privilege;
861 this may not always be true. The device driver can tell us. */
862 require_root_privileges=True;
863 require_root_privileges_explanation="netlink: soft routes";
864 if (st->ptp) {
865 cfgfatal(loc,st->name,"point-to-point netlinks do not support "
866 "soft routes.\n");
867 return NULL;
868 }
869 }
870
871 /* Check that nets are a subset of st->remote_networks;
872 refuse to register if they are not. */
873 if (!ipset_is_subset(st->remote_networks,networks)) {
874 cfgfatal(loc,st->name,"routes are not allowed\n");
875 return NULL;
876 }
877
878 c=safe_malloc(sizeof(*c),"netlink_inst_create");
879 c->cl.description=name;
880 c->cl.type=CL_NETLINK;
881 c->cl.apply=NULL;
882 c->cl.interface=&c->ops;
883 c->ops.st=c;
884 c->ops.reg=netlink_inst_reg;
885 c->ops.deliver=netlink_inst_incoming;
886 c->ops.set_quality=netlink_set_quality;
887 c->ops.set_mtu=netlink_inst_set_mtu;
888 c->nst=st;
889
890 c->networks=networks;
891 c->subnets=ipset_to_subnet_list(networks);
892 c->priority=priority;
893 c->deliver=NULL;
894 c->dst=NULL;
895 c->name=name;
896 c->link_quality=LINK_QUALITY_UNUSED;
897 c->mtu=mtu?mtu:st->mtu;
898 c->options=options;
899 c->outcount=0;
900 c->up=False;
901 c->kup=False;
902 c->next=st->clients;
903 st->clients=c;
904 assert(st->n_clients < INT_MAX);
905 st->n_clients++;
906
907 return &c->cl;
908 }
909
910 static list_t *netlink_inst_apply(closure_t *self, struct cloc loc,
911 dict_t *context, list_t *args)
912 {
913 struct netlink *st=self->interface;
914
915 dict_t *dict;
916 item_t *item;
917 closure_t *cl;
918
919 item=list_elem(args,0);
920 if (!item || item->type!=t_dict) {
921 cfgfatal(loc,st->name,"must have a dictionary argument\n");
922 }
923 dict=item->data.dict;
924
925 cl=netlink_inst_create(st,loc,dict);
926
927 return new_closure(cl);
928 }
929
930 netlink_deliver_fn *netlink_init(struct netlink *st,
931 void *dst, struct cloc loc,
932 dict_t *dict, cstring_t description,
933 netlink_route_fn *set_routes,
934 netlink_deliver_fn *to_host)
935 {
936 item_t *sa, *ptpa;
937 list_t *l;
938
939 st->dst=dst;
940 st->cl.description=description;
941 st->cl.type=CL_PURE;
942 st->cl.apply=netlink_inst_apply;
943 st->cl.interface=st;
944 st->clients=NULL;
945 st->routes=NULL;
946 st->n_clients=0;
947 st->set_routes=set_routes;
948 st->deliver_to_host=to_host;
949
950 st->name=dict_read_string(dict,"name",False,description,loc);
951 if (!st->name) st->name=description;
952 l=dict_lookup(dict,"networks");
953 if (l)
954 st->networks=string_list_to_ipset(l,loc,st->name,"networks");
955 else {
956 struct ipset *empty;
957 empty=ipset_new();
958 st->networks=ipset_complement(empty);
959 ipset_free(empty);
960 }
961 l=dict_lookup(dict,"remote-networks");
962 if (l) {
963 st->remote_networks=string_list_to_ipset(l,loc,st->name,
964 "remote-networks");
965 } else {
966 struct ipset *empty;
967 empty=ipset_new();
968 st->remote_networks=ipset_complement(empty);
969 ipset_free(empty);
970 }
971
972 sa=dict_find_item(dict,"secnet-address",False,"netlink",loc);
973 ptpa=dict_find_item(dict,"ptp-address",False,"netlink",loc);
974 if (sa && ptpa) {
975 cfgfatal(loc,st->name,"you may not specify secnet-address and "
976 "ptp-address in the same netlink device\n");
977 }
978 if (!(sa || ptpa)) {
979 cfgfatal(loc,st->name,"you must specify secnet-address or "
980 "ptp-address for this netlink device\n");
981 }
982 if (sa) {
983 st->secnet_address=string_item_to_ipaddr(sa,"netlink");
984 st->ptp=False;
985 } else {
986 st->secnet_address=string_item_to_ipaddr(ptpa,"netlink");
987 st->ptp=True;
988 }
989 /* To be strictly correct we could subtract secnet_address from
990 networks here. It shouldn't make any practical difference,
991 though, and will make the route dump look complicated... */
992 st->subnets=ipset_to_subnet_list(st->networks);
993 st->mtu=dict_read_number(dict, "mtu", False, "netlink", loc, DEFAULT_MTU);
994 buffer_new(&st->icmp,ICMP_BUFSIZE);
995 st->outcount=0;
996 st->localcount=0;
997
998 add_hook(PHASE_SETUP,netlink_phase_hook,st);
999 request_signal_notification(SIGUSR1, netlink_signal_handler, st);
1000
1001 /* If we're point-to-point then we return a CL_NETLINK directly,
1002 rather than a CL_NETLINK_OLD or pure closure (depending on
1003 compatibility). This CL_NETLINK is for our one and only
1004 client. Our cl.apply function is NULL. */
1005 if (st->ptp) {
1006 closure_t *cl;
1007 cl=netlink_inst_create(st,loc,dict);
1008 st->cl=*cl;
1009 }
1010 return netlink_dev_incoming;
1011 }
1012
1013 /* No connection to the kernel at all... */
1014
1015 struct null {
1016 struct netlink nl;
1017 };
1018
1019 static bool_t null_set_route(void *sst, struct netlink_client *routes)
1020 {
1021 struct null *st=sst;
1022
1023 if (routes->up!=routes->kup) {
1024 Message(M_INFO,"%s: setting routes for tunnel %s to state %s\n",
1025 st->nl.name,routes->name,
1026 routes->up?"up":"down");
1027 routes->kup=routes->up;
1028 return True;
1029 }
1030 return False;
1031 }
1032
1033 static void null_deliver(void *sst, struct buffer_if *buf)
1034 {
1035 return;
1036 }
1037
1038 static list_t *null_apply(closure_t *self, struct cloc loc, dict_t *context,
1039 list_t *args)
1040 {
1041 struct null *st;
1042 item_t *item;
1043 dict_t *dict;
1044
1045 st=safe_malloc(sizeof(*st),"null_apply");
1046
1047 item=list_elem(args,0);
1048 if (!item || item->type!=t_dict)
1049 cfgfatal(loc,"null-netlink","parameter must be a dictionary\n");
1050
1051 dict=item->data.dict;
1052
1053 netlink_init(&st->nl,st,loc,dict,"null-netlink",null_set_route,
1054 null_deliver);
1055
1056 return new_closure(&st->nl.cl);
1057 }
1058
1059 void netlink_module(dict_t *dict)
1060 {
1061 add_closure(dict,"null-netlink",null_apply);
1062 }