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,st->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
 607     BUF_ASSERT_USED(buf);
 608     if (!netlink_check(st,buf,errmsgbuf,sizeof(errmsgbuf))) {
 609         Message(M_WARNING,"%s: bad IP packet from %s: %s\n",
 610                 st->name,client?client->name:"host",
 611                 errmsgbuf);
 612         BUF_FREE(buf);
 613         return;
 614     }
 615     iph=(struct iphdr *)buf->start;
 616
 617     source=ntohl(iph->saddr);
 618     dest=ntohl(iph->daddr);
 619
 620     /* Check source. If we don't like the source, there's no point
 621        generating ICMP because we won't know how to get it to the
 622        source of the packet. */
 623     if (client) {
 624         /* Check that the packet source is appropriate for the tunnel
 625            it came down */
 626         if (!ipset_contains_addr(client->networks,source)) {
 627             string_t s,d;
 628             s=ipaddr_to_string(source);
 629             d=ipaddr_to_string(dest);
 630             Message(M_WARNING,"%s: packet from tunnel %s with bad "
 631                     "source address (s=%s,d=%s)\n",st->name,client->name,s,d);
 632             free(s); free(d);
 633             BUF_FREE(buf);
 634             return;
 635         }
 636     } else {
 637         /* Check that the packet originates in our configured local
 638            network, and hasn't been forwarded from elsewhere or
 639            generated with the wrong source address */
 640         if (!ipset_contains_addr(st->networks,source)) {
 641             string_t s,d;
 642             s=ipaddr_to_string(source);
 643             d=ipaddr_to_string(dest);
 644             Message(M_WARNING,"%s: outgoing packet with bad source address "
 645                     "(s=%s,d=%s)\n",st->name,s,d);
 646             free(s); free(d);
 647             BUF_FREE(buf);
 648             return;
 649         }
 650     }
 651
 652     /* If this is a point-to-point device we don't examine the
 653        destination address at all; we blindly send it down our
 654        one-and-only registered tunnel, or to the host, depending on
 655        where it came from.  It's up to external software to check
 656        address validity and generate ICMP, etc. */
 657     if (st->ptp) {
 658         if (client) {
 659             st->deliver_to_host(st->dst,buf);
 660         } else {
 661             st->clients->deliver(st->clients->dst,buf);
 662         }
 663         BUF_ASSERT_FREE(buf);
 664         return;
 665     }
 666
 667     /* st->secnet_address needs checking before matching destination
 668        addresses */
 669     if (dest==st->secnet_address) {
 670         netlink_packet_local(st,client,buf);
 671         BUF_ASSERT_FREE(buf);
 672         return;
 673     }
 674     netlink_packet_forward(st,client,buf);
 675     BUF_ASSERT_FREE(buf);
 676 }
 677
 678 static void netlink_inst_incoming(void *sst, struct buffer_if *buf)
 679 {
 680     struct netlink_client *c=sst;
 681     struct netlink *st=c->nst;
 682
 683     netlink_incoming(st,c,buf);
 684 }
 685
 686 static void netlink_dev_incoming(void *sst, struct buffer_if *buf)
 687 {
 688     struct netlink *st=sst;
 689
 690     netlink_incoming(st,NULL,buf);
 691 }
 692
 693 static void netlink_set_quality(void *sst, uint32_t quality)
 694 {
 695     struct netlink_client *c=sst;
 696     struct netlink *st=c->nst;
 697
 698     c->link_quality=quality;
 699     c->up=(c->link_quality==LINK_QUALITY_DOWN)?False:True;
 700     if (c->options&OPT_SOFTROUTE) {
 701         st->set_routes(st->dst,c);
 702     }
 703 }
 704
 705 static void netlink_output_subnets(struct netlink *st, uint32_t loglevel,
 706                                    struct subnet_list *snets)
 707 {
 708     int32_t i;
 709     string_t net;
 710
 711     for (i=0; i<snets->entries; i++) {
 712         net=subnet_to_string(snets->list[i]);
 713         Message(loglevel,"%s ",net);
 714         free(net);
 715     }
 716 }
 717
 718 static void netlink_dump_routes(struct netlink *st, bool_t requested)
 719 {
 720     int i;
 721     string_t net;
 722     uint32_t c=M_INFO;
 723
 724     if (requested) c=M_WARNING;
 725     if (st->ptp) {
 726         net=ipaddr_to_string(st->secnet_address);
 727         Message(c,"%s: point-to-point (remote end is %s); routes:\n",
 728                 st->name, net);
 729         free(net);
 730         netlink_output_subnets(st,c,st->clients->subnets);
 731         Message(c,"\n");
 732     } else {
 733         Message(c,"%s: routing table:\n",st->name);
 734         for (i=0; i<st->n_clients; i++) {
 735             netlink_output_subnets(st,c,st->routes[i]->subnets);
 736             Message(c,"-> tunnel %s (%s,mtu %d,%s routes,%s,"
 737                     "quality %d,use %d,pri %lu)\n",
 738                     st->routes[i]->name,
 739                     st->routes[i]->up?"up":"down",
 740                     st->routes[i]->mtu,
 741                     st->routes[i]->options&OPT_SOFTROUTE?"soft":"hard",
 742                     st->routes[i]->options&OPT_ALLOWROUTE?"free":"restricted",
 743                     st->routes[i]->link_quality,
 744                     st->routes[i]->outcount,
 745                     (unsigned long)st->routes[i]->priority);
 746         }
 747         net=ipaddr_to_string(st->secnet_address);
 748         Message(c,"%s/32 -> netlink \"%s\" (use %d)\n",
 749                 net,st->name,st->localcount);
 750         free(net);
 751         for (i=0; i<st->subnets->entries; i++) {
 752             net=subnet_to_string(st->subnets->list[i]);
 753             Message(c,"%s ",net);
 754             free(net);
 755         }
 756         if (i>0)
 757             Message(c,"-> host (use %d)\n",st->outcount);
 758     }
 759 }
 760
 761 /* ap is a pointer to a member of the routes array */
 762 static int netlink_compare_client_priority(const void *ap, const void *bp)
 763 {
 764     const struct netlink_client *const*a=ap;
 765     const struct netlink_client *const*b=bp;
 766
 767     if ((*a)->priority==(*b)->priority) return 0;
 768     if ((*a)->priority<(*b)->priority) return 1;
 769     return -1;
 770 }
 771
 772 static void netlink_phase_hook(void *sst, uint32_t new_phase)
 773 {
 774     struct netlink *st=sst;
 775     struct netlink_client *c;
 776     int32_t i;
 777
 778     /* All the networks serviced by the various tunnels should now
 779      * have been registered.  We build a routing table by sorting the
 780      * clients by priority.  */
 781     st->routes=safe_malloc_ary(sizeof(*st->routes),st->n_clients,
 782                                "netlink_phase_hook");
 783     /* Fill the table */
 784     i=0;
 785     for (c=st->clients; c; c=c->next) {
 786         assert(i<INT_MAX);
 787         st->routes[i++]=c;
 788     }
 789     /* Sort the table in descending order of priority */
 790     qsort(st->routes,st->n_clients,sizeof(*st->routes),
 791           netlink_compare_client_priority);
 792
 793     netlink_dump_routes(st,False);
 794 }
 795
 796 static void netlink_signal_handler(void *sst, int signum)
 797 {
 798     struct netlink *st=sst;
 799     Message(M_INFO,"%s: route dump requested by SIGUSR1\n",st->name);
 800     netlink_dump_routes(st,True);
 801 }
 802
 803 static void netlink_inst_set_mtu(void *sst, int32_t new_mtu)
 804 {
 805     struct netlink_client *c=sst;
 806
 807     c->mtu=new_mtu;
 808 }
 809
 810 static void netlink_inst_reg(void *sst, netlink_deliver_fn *deliver,
 811                              void *dst, int32_t max_start_pad)
 812 {
 813     struct netlink_client *c=sst;
 814     struct netlink *st=c->nst;
 815
 816     if (max_start_pad > st->max_start_pad) st->max_start_pad=max_start_pad;
 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->max_start_pad=0;
 945     st->clients=NULL;
 946     st->routes=NULL;
 947     st->n_clients=0;
 948     st->set_routes=set_routes;
 949     st->deliver_to_host=to_host;
 950
 951     st->name=dict_read_string(dict,"name",False,description,loc);
 952     if (!st->name) st->name=description;
 953     l=dict_lookup(dict,"networks");
 954     if (l)
 955         st->networks=string_list_to_ipset(l,loc,st->name,"networks");
 956     else {
 957         struct ipset *empty;
 958         empty=ipset_new();
 959         st->networks=ipset_complement(empty);
 960         ipset_free(empty);
 961     }
 962     l=dict_lookup(dict,"remote-networks");
 963     if (l) {
 964         st->remote_networks=string_list_to_ipset(l,loc,st->name,
 965                                                  "remote-networks");
 966     } else {
 967         struct ipset *empty;
 968         empty=ipset_new();
 969         st->remote_networks=ipset_complement(empty);
 970         ipset_free(empty);
 971     }
 972
 973     sa=dict_find_item(dict,"secnet-address",False,"netlink",loc);
 974     ptpa=dict_find_item(dict,"ptp-address",False,"netlink",loc);
 975     if (sa && ptpa) {
 976         cfgfatal(loc,st->name,"you may not specify secnet-address and "
 977                  "ptp-address in the same netlink device\n");
 978     }
 979     if (!(sa || ptpa)) {
 980         cfgfatal(loc,st->name,"you must specify secnet-address or "
 981                  "ptp-address for this netlink device\n");
 982     }
 983     if (sa) {
 984         st->secnet_address=string_item_to_ipaddr(sa,"netlink");
 985         st->ptp=False;
 986     } else {
 987         st->secnet_address=string_item_to_ipaddr(ptpa,"netlink");
 988         st->ptp=True;
 989     }
 990     /* To be strictly correct we could subtract secnet_address from
 991        networks here.  It shouldn't make any practical difference,
 992        though, and will make the route dump look complicated... */
 993     st->subnets=ipset_to_subnet_list(st->networks);
 994     st->mtu=dict_read_number(dict, "mtu", False, "netlink", loc, DEFAULT_MTU);
 995     buffer_new(&st->icmp,ICMP_BUFSIZE);
 996     st->outcount=0;
 997     st->localcount=0;
 998
 999     add_hook(PHASE_SETUP,netlink_phase_hook,st);
1000     request_signal_notification(SIGUSR1, netlink_signal_handler, st);
1001
1002     /* If we're point-to-point then we return a CL_NETLINK directly,
1003        rather than a CL_NETLINK_OLD or pure closure (depending on
1004        compatibility).  This CL_NETLINK is for our one and only
1005        client.  Our cl.apply function is NULL. */
1006     if (st->ptp) {
1007         closure_t *cl;
1008         cl=netlink_inst_create(st,loc,dict);
1009         st->cl=*cl;
1010     }
1011     return netlink_dev_incoming;
1012 }
1013
1014 /* No connection to the kernel at all... */
1015
1016 struct null {
1017     struct netlink nl;
1018 };
1019
1020 static bool_t null_set_route(void *sst, struct netlink_client *routes)
1021 {
1022     struct null *st=sst;
1023
1024     if (routes->up!=routes->kup) {
1025         Message(M_INFO,"%s: setting routes for tunnel %s to state %s\n",
1026                 st->nl.name,routes->name,
1027                 routes->up?"up":"down");
1028         routes->kup=routes->up;
1029         return True;
1030     }
1031     return False;
1032 }
1033
1034 static void null_deliver(void *sst, struct buffer_if *buf)
1035 {
1036     return;
1037 }
1038
1039 static list_t *null_apply(closure_t *self, struct cloc loc, dict_t *context,
1040                           list_t *args)
1041 {
1042     struct null *st;
1043     item_t *item;
1044     dict_t *dict;
1045
1046     st=safe_malloc(sizeof(*st),"null_apply");
1047
1048     item=list_elem(args,0);
1049     if (!item || item->type!=t_dict)
1050         cfgfatal(loc,"null-netlink","parameter must be a dictionary\n");
1051
1052     dict=item->data.dict;
1053
1054     netlink_init(&st->nl,st,loc,dict,"null-netlink",null_set_route,
1055                  null_deliver);
1056
1057     return new_closure(&st->nl.cl);
1058 }
1059
1060 void netlink_module(dict_t *dict)
1061 {
1062     add_closure(dict,"null-netlink",null_apply);
1063 }