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 #define IPHDR_FRAG_OFF  ((uint16_t)0x1fff)
 197 #define IPHDR_FRAG_MORE ((uint16_t)0x2000)
 198 #define IPHDR_FRAG_DONT ((uint16_t)0x4000)
 199 /*                 reserved        0x8000 */
 200     uint8_t    ttl;
 201     uint8_t    protocol;
 202     uint16_t   check;
 203     uint32_t   saddr;
 204     uint32_t   daddr;
 205     /* The options start here. */
 206 };
 207
 208 struct icmphdr {
 209     struct iphdr iph;
 210     uint8_t type;
 211     uint8_t code;
 212     uint16_t check;
 213     union {
 214         uint32_t unused;
 215         struct {
 216             uint8_t pointer;
 217             uint8_t unused1;
 218             uint16_t unused2;
 219         } pprob;
 220         uint32_t gwaddr;
 221         struct {
 222             uint16_t id;
 223             uint16_t seq;
 224         } echo;
 225     } d;
 226 };
 227
 228 static void netlink_packet_deliver(struct netlink *st,
 229                                    struct netlink_client *client,
 230                                    struct buffer_if *buf);
 231
 232 /* XXX RFC1812 4.3.2.5:
 233    All other ICMP error messages (Destination Unreachable,
 234    Redirect, Time Exceeded, and Parameter Problem) SHOULD have their
 235    precedence value set to 6 (INTERNETWORK CONTROL) or 7 (NETWORK
 236    CONTROL).  The IP Precedence value for these error messages MAY be
 237    settable.
 238    */
 239 static struct icmphdr *netlink_icmp_tmpl(struct netlink *st,
 240                                          uint32_t dest,uint16_t len)
 241 {
 242     struct icmphdr *h;
 243
 244     BUF_ALLOC(&st->icmp,"netlink_icmp_tmpl");
 245     buffer_init(&st->icmp,calculate_max_start_pad());
 246     h=buf_append(&st->icmp,sizeof(*h));
 247
 248     h->iph.version=4;
 249     h->iph.ihl=5;
 250     h->iph.tos=0;
 251     h->iph.tot_len=htons(len+(h->iph.ihl*4)+8);
 252     h->iph.id=0;
 253     h->iph.frag_off=0;
 254     h->iph.ttl=255; /* XXX should be configurable */
 255     h->iph.protocol=1;
 256     h->iph.saddr=htonl(st->secnet_address);
 257     h->iph.daddr=htonl(dest);
 258     h->iph.check=0;
 259     h->iph.check=ip_fast_csum((uint8_t *)&h->iph,h->iph.ihl);
 260     h->check=0;
 261     h->d.unused=0;
 262
 263     return h;
 264 }
 265
 266 /* Fill in the ICMP checksum field correctly */
 267 static void netlink_icmp_csum(struct icmphdr *h)
 268 {
 269     int32_t len;
 270
 271     len=ntohs(h->iph.tot_len)-(4*h->iph.ihl);
 272     h->check=0;
 273     h->check=ip_csum(&h->type,len);
 274 }
 275
 276 /* RFC1122:
 277  *       An ICMP error message MUST NOT be sent as the result of
 278  *       receiving:
 279  *
 280  *       *    an ICMP error message, or
 281  *
 282  *       *    a datagram destined to an IP broadcast or IP multicast
 283  *            address, or
 284  *
 285  *       *    a datagram sent as a link-layer broadcast, or
 286  *
 287  *       *    a non-initial fragment, or
 288  *
 289  *       *    a datagram whose source address does not define a single
 290  *            host -- e.g., a zero address, a loopback address, a
 291  *            broadcast address, a multicast address, or a Class E
 292  *            address.
 293  */
 294 static bool_t netlink_icmp_may_reply(struct buffer_if *buf)
 295 {
 296     struct iphdr *iph;
 297     struct icmphdr *icmph;
 298     uint32_t source;
 299
 300     if (buf->size < (int)sizeof(struct icmphdr)) return False;
 301     iph=(struct iphdr *)buf->start;
 302     icmph=(struct icmphdr *)buf->start;
 303     if (iph->protocol==1) {
 304         switch(icmph->type) {
 305         case 3: /* Destination unreachable */
 306         case 11: /* Time Exceeded */
 307         case 12: /* Parameter Problem */
 308             return False;
 309         }
 310     }
 311     /* How do we spot broadcast destination addresses? */
 312     if (ntohs(iph->frag_off)&IPHDR_FRAG_OFF) return False;
 313     source=ntohl(iph->saddr);
 314     if (source==0) return False;
 315     if ((source&0xff000000)==0x7f000000) return False;
 316     /* How do we spot broadcast source addresses? */
 317     if ((source&0xf0000000)==0xe0000000) return False; /* Multicast */
 318     if ((source&0xf0000000)==0xf0000000) return False; /* Class E */
 319     return True;
 320 }
 321
 322 /* How much of the original IP packet do we include in its ICMP
 323    response? The header plus up to 64 bits. */
 324
 325 /* XXX TODO RFC1812:
 326 4.3.2.3 Original Message Header
 327
 328    Historically, every ICMP error message has included the Internet
 329    header and at least the first 8 data bytes of the datagram that
 330    triggered the error.  This is no longer adequate, due to the use of
 331    IP-in-IP tunneling and other technologies.  Therefore, the ICMP
 332    datagram SHOULD contain as much of the original datagram as possible
 333    without the length of the ICMP datagram exceeding 576 bytes.  The
 334    returned IP header (and user data) MUST be identical to that which
 335    was received, except that the router is not required to undo any
 336    modifications to the IP header that are normally performed in
 337    forwarding that were performed before the error was detected (e.g.,
 338    decrementing the TTL, or updating options).  Note that the
 339    requirements of Section [4.3.3.5] supersede this requirement in some
 340    cases (i.e., for a Parameter Problem message, if the problem is in a
 341    modified field, the router must undo the modification).  See Section
 342    [4.3.3.5]).
 343    */
 344 static uint16_t netlink_icmp_reply_len(struct buffer_if *buf)
 345 {
 346     if (buf->size < (int)sizeof(struct iphdr)) return 0;
 347     struct iphdr *iph=(struct iphdr *)buf->start;
 348     uint16_t hlen,plen;
 349
 350     hlen=iph->ihl*4;
 351     /* We include the first 8 bytes of the packet data, provided they exist */
 352     hlen+=8;
 353     plen=ntohs(iph->tot_len);
 354     return (hlen>plen?plen:hlen);
 355 }
 356
 357 /* client indicates where the packet we're constructing a response to
 358    comes from. NULL indicates the host. */
 359 static void netlink_icmp_simple(struct netlink *st, struct buffer_if *buf,
 360                                 struct netlink_client *client,
 361                                 uint8_t type, uint8_t code)
 362 {
 363     struct icmphdr *h;
 364     uint16_t len;
 365
 366     if (netlink_icmp_may_reply(buf)) {
 367         struct iphdr *iph=(struct iphdr *)buf->start;
 368         len=netlink_icmp_reply_len(buf);
 369         h=netlink_icmp_tmpl(st,ntohl(iph->saddr),len);
 370         h->type=type; h->code=code;
 371         memcpy(buf_append(&st->icmp,len),buf->start,len);
 372         netlink_icmp_csum(h);
 373         netlink_packet_deliver(st,NULL,&st->icmp);
 374         BUF_ASSERT_FREE(&st->icmp);
 375     }
 376 }
 377
 378 /*
 379  * RFC1122: 3.1.2.2 MUST silently discard any IP frame that fails the
 380  * checksum.
 381  * RFC1812: 4.2.2.5 MUST discard messages containing invalid checksums.
 382  *
 383  * Is the datagram acceptable?
 384  *
 385  * 1. Length at least the size of an ip header
 386  * 2. Version of 4
 387  * 3. Checksums correctly.
 388  * 4. Doesn't have a bogus length
 389  */
 390 static bool_t netlink_check(struct netlink *st, struct buffer_if *buf,
 391                             char *errmsgbuf, int errmsgbuflen)
 392 {
 393 #define BAD(...) do{                                    \
 394         snprintf(errmsgbuf,errmsgbuflen,__VA_ARGS__);   \
 395         return False;                                   \
 396     }while(0)
 397
 398     if (buf->size < (int)sizeof(struct iphdr)) BAD("len %"PRIu32"",buf->size);
 399     struct iphdr *iph=(struct iphdr *)buf->start;
 400     int32_t len;
 401
 402     if (iph->ihl < 5) BAD("ihl %u",iph->ihl);
 403     if (iph->version != 4) BAD("version %u",iph->version);
 404     if (buf->size < iph->ihl*4) BAD("size %"PRId32"<%u*4",buf->size,iph->ihl);
 405     if (ip_fast_csum((uint8_t *)iph, iph->ihl)!=0) BAD("csum");
 406     len=ntohs(iph->tot_len);
 407     /* There should be no padding */
 408     if (buf->size!=len) BAD("len %"PRId32"!=%"PRId32,buf->size,len);
 409     if (len<(iph->ihl<<2)) BAD("len %"PRId32"<(%u<<2)",len,iph->ihl);
 410     /* XXX check that there's no source route specified */
 411     return True;
 412
 413 #undef BAD
 414 }
 415
 416 /* Deliver a packet _to_ client; used after we have decided
 417  * what to do with it (and just to check that the client has
 418  * actually registered a delivery function with us). */
 419 static void netlink_client_deliver(struct netlink *st,
 420                                    struct netlink_client *client,
 421                                    uint32_t source, uint32_t dest,
 422                                    struct buffer_if *buf)
 423 {
 424     if (!client->deliver) {
 425         string_t s,d;
 426         s=ipaddr_to_string(source);
 427         d=ipaddr_to_string(dest);
 428         Message(M_ERR,"%s: dropping %s->%s, client not registered\n",
 429                 st->name,s,d);
 430         free(s); free(d);
 431         BUF_FREE(buf);
 432         return;
 433     }
 434     client->deliver(client->dst, buf);
 435     client->outcount++;
 436 }
 437
 438 /* Deliver a packet. "client" is the _origin_ of the packet, not its
 439    destination, and is NULL for packets from the host and packets
 440    generated internally in secnet.  */
 441 static void netlink_packet_deliver(struct netlink *st,
 442                                    struct netlink_client *client,
 443                                    struct buffer_if *buf)
 444 {
 445     if (buf->size < (int)sizeof(struct iphdr)) {
 446         Message(M_ERR,"%s: trying to deliver a too-short packet"
 447                 " from %s!\n",st->name, client?client->name:"(local)");
 448         BUF_FREE(buf);
 449         return;
 450     }
 451
 452     struct iphdr *iph=(struct iphdr *)buf->start;
 453     uint32_t dest=ntohl(iph->daddr);
 454     uint32_t source=ntohl(iph->saddr);
 455     uint32_t best_quality;
 456     bool_t allow_route=False;
 457     bool_t found_allowed=False;
 458     int best_match;
 459     int i;
 460
 461     BUF_ASSERT_USED(buf);
 462
 463     if (dest==st->secnet_address) {
 464         Message(M_ERR,"%s: trying to deliver a packet to myself!\n",st->name);
 465         BUF_FREE(buf);
 466         return;
 467     }
 468
 469     /* Packets from the host (client==NULL) may always be routed.  Packets
 470        from clients with the allow_route option will also be routed. */
 471     if (!client || (client && (client->options & OPT_ALLOWROUTE)))
 472         allow_route=True;
 473
 474     /* If !allow_route, we check the routing table anyway, and if
 475        there's a suitable route with OPT_ALLOWROUTE set we use it.  If
 476        there's a suitable route, but none with OPT_ALLOWROUTE set then
 477        we generate ICMP 'communication with destination network
 478        administratively prohibited'. */
 479
 480     best_quality=0;
 481     best_match=-1;
 482     for (i=0; i<st->n_clients; i++) {
 483         if (st->routes[i]->up &&
 484             ipset_contains_addr(st->routes[i]->networks,dest)) {
 485             /* It's an available route to the correct destination. But is
 486                it better than the one we already have? */
 487
 488             /* If we have already found an allowed route then we don't
 489                bother looking at routes we're not allowed to use.  If
 490                we don't yet have an allowed route we'll consider any.  */
 491             if (!allow_route && found_allowed) {
 492                 if (!(st->routes[i]->options&OPT_ALLOWROUTE)) continue;
 493             }
 494
 495             if (st->routes[i]->link_quality>best_quality
 496                 || best_quality==0) {
 497                 best_quality=st->routes[i]->link_quality;
 498                 best_match=i;
 499                 if (st->routes[i]->options&OPT_ALLOWROUTE)
 500                     found_allowed=True;
 501                 /* If quality isn't perfect we may wish to
 502                    consider kicking the tunnel with a 0-length
 503                    packet to prompt it to perform a key setup.
 504                    Then it'll eventually decide it's up or
 505                    down. */
 506                 /* If quality is perfect and we're allowed to use the
 507                    route we don't need to search any more. */
 508                 if (best_quality>=MAXIMUM_LINK_QUALITY &&
 509                     (allow_route || found_allowed)) break;
 510             }
 511         }
 512     }
 513     if (best_match==-1) {
 514         /* The packet's not going down a tunnel.  It might (ought to)
 515            be for the host.   */
 516         if (ipset_contains_addr(st->networks,dest)) {
 517             st->deliver_to_host(st->dst,buf);
 518             st->outcount++;
 519             BUF_ASSERT_FREE(buf);
 520         } else {
 521             string_t s,d;
 522             s=ipaddr_to_string(source);
 523             d=ipaddr_to_string(dest);
 524             Message(M_DEBUG,"%s: don't know where to deliver packet "
 525                     "(s=%s, d=%s)\n", st->name, s, d);
 526             free(s); free(d);
 527             netlink_icmp_simple(st,buf,client,ICMP_TYPE_UNREACHABLE,
 528                                 ICMP_CODE_NET_UNREACHABLE);
 529             BUF_FREE(buf);
 530         }
 531     } else {
 532         if (!allow_route &&
 533             !(st->routes[best_match]->options&OPT_ALLOWROUTE)) {
 534             string_t s,d;
 535             s=ipaddr_to_string(source);
 536             d=ipaddr_to_string(dest);
 537             /* We have a usable route but aren't allowed to use it.
 538                Generate ICMP destination unreachable: communication
 539                with destination network administratively prohibited */
 540             Message(M_NOTICE,"%s: denied forwarding for packet (s=%s, d=%s)\n",
 541                     st->name,s,d);
 542             free(s); free(d);
 543
 544             netlink_icmp_simple(st,buf,client,ICMP_TYPE_UNREACHABLE,
 545                                 ICMP_CODE_NET_PROHIBITED);
 546             BUF_FREE(buf);
 547         } else {
 548             if (best_quality>0) {
 549                 /* XXX Fragment if required */
 550                 netlink_client_deliver(st,st->routes[best_match],
 551                                        source,dest,buf);
 552                 BUF_ASSERT_FREE(buf);
 553             } else {
 554                 /* Generate ICMP destination unreachable */
 555                 netlink_icmp_simple(st,buf,client,ICMP_TYPE_UNREACHABLE,
 556                                     ICMP_CODE_NET_UNREACHABLE); /* client==NULL */
 557                 BUF_FREE(buf);
 558             }
 559         }
 560     }
 561     BUF_ASSERT_FREE(buf);
 562 }
 563
 564 static void netlink_packet_forward(struct netlink *st,
 565                                    struct netlink_client *client,
 566                                    struct buffer_if *buf)
 567 {
 568     if (buf->size < (int)sizeof(struct iphdr)) return;
 569     struct iphdr *iph=(struct iphdr *)buf->start;
 570
 571     BUF_ASSERT_USED(buf);
 572
 573     /* Packet has already been checked */
 574     if (iph->ttl<=1) {
 575         /* Generate ICMP time exceeded */
 576         netlink_icmp_simple(st,buf,client,ICMP_TYPE_TIME_EXCEEDED,
 577                             ICMP_CODE_TTL_EXCEEDED);
 578         BUF_FREE(buf);
 579         return;
 580     }
 581     iph->ttl--;
 582     iph->check=0;
 583     iph->check=ip_fast_csum((uint8_t *)iph,iph->ihl);
 584
 585     netlink_packet_deliver(st,client,buf);
 586     BUF_ASSERT_FREE(buf);
 587 }
 588
 589 /* Deal with packets addressed explicitly to us */
 590 static void netlink_packet_local(struct netlink *st,
 591                                  struct netlink_client *client,
 592                                  struct buffer_if *buf)
 593 {
 594     struct icmphdr *h;
 595
 596     st->localcount++;
 597
 598     if (buf->size < (int)sizeof(struct icmphdr)) {
 599         Message(M_WARNING,"%s: short packet addressed to secnet; "
 600                 "ignoring it\n",st->name);
 601         BUF_FREE(buf);
 602         return;
 603     }
 604     h=(struct icmphdr *)buf->start;
 605
 606     if ((ntohs(h->iph.frag_off)&(IPHDR_FRAG_OFF|IPHDR_FRAG_MORE))!=0) {
 607         Message(M_WARNING,"%s: fragmented packet addressed to secnet; "
 608                 "ignoring it\n",st->name);
 609         BUF_FREE(buf);
 610         return;
 611     }
 612
 613     if (h->iph.protocol==1) {
 614         /* It's ICMP */
 615         if (h->type==ICMP_TYPE_ECHO_REQUEST && h->code==0) {
 616             /* ICMP echo-request. Special case: we re-use the buffer
 617                to construct the reply. */
 618             h->type=ICMP_TYPE_ECHO_REPLY;
 619             h->iph.daddr=h->iph.saddr;
 620             h->iph.saddr=htonl(st->secnet_address);
 621             h->iph.ttl=255;
 622             h->iph.check=0;
 623             h->iph.check=ip_fast_csum((uint8_t *)h,h->iph.ihl);
 624             netlink_icmp_csum(h);
 625             netlink_packet_deliver(st,NULL,buf);
 626             return;
 627         }
 628         Message(M_WARNING,"%s: unknown incoming ICMP\n",st->name);
 629     } else {
 630         /* Send ICMP protocol unreachable */
 631         netlink_icmp_simple(st,buf,client,ICMP_TYPE_UNREACHABLE,
 632                             ICMP_CODE_PROTOCOL_UNREACHABLE);
 633         BUF_FREE(buf);
 634         return;
 635     }
 636
 637     BUF_FREE(buf);
 638 }
 639
 640 /* If cid==NULL packet is from host, otherwise cid specifies which tunnel
 641    it came from. */
 642 static void netlink_incoming(struct netlink *st, struct netlink_client *client,
 643                              struct buffer_if *buf)
 644 {
 645     uint32_t source,dest;
 646     struct iphdr *iph;
 647     char errmsgbuf[50];
 648     const char *sourcedesc=client?client->name:"host";
 649
 650     BUF_ASSERT_USED(buf);
 651
 652     if (!netlink_check(st,buf,errmsgbuf,sizeof(errmsgbuf))) {
 653         Message(M_WARNING,"%s: bad IP packet from %s: %s\n",
 654                 st->name,sourcedesc,
 655                 errmsgbuf);
 656         BUF_FREE(buf);
 657         return;
 658     }
 659     assert(buf->size >= (int)sizeof(struct icmphdr));
 660     iph=(struct iphdr *)buf->start;
 661
 662     source=ntohl(iph->saddr);
 663     dest=ntohl(iph->daddr);
 664
 665     /* Check source. If we don't like the source, there's no point
 666        generating ICMP because we won't know how to get it to the
 667        source of the packet. */
 668     if (client) {
 669         /* Check that the packet source is appropriate for the tunnel
 670            it came down */
 671         if (!ipset_contains_addr(client->networks,source)) {
 672             string_t s,d;
 673             s=ipaddr_to_string(source);
 674             d=ipaddr_to_string(dest);
 675             Message(M_WARNING,"%s: packet from tunnel %s with bad "
 676                     "source address (s=%s,d=%s)\n",st->name,client->name,s,d);
 677             free(s); free(d);
 678             BUF_FREE(buf);
 679             return;
 680         }
 681     } else {
 682         /* Check that the packet originates in our configured local
 683            network, and hasn't been forwarded from elsewhere or
 684            generated with the wrong source address */
 685         if (!ipset_contains_addr(st->networks,source)) {
 686             string_t s,d;
 687             s=ipaddr_to_string(source);
 688             d=ipaddr_to_string(dest);
 689             Message(M_WARNING,"%s: outgoing packet with bad source address "
 690                     "(s=%s,d=%s)\n",st->name,s,d);
 691             free(s); free(d);
 692             BUF_FREE(buf);
 693             return;
 694         }
 695     }
 696
 697     /* If this is a point-to-point device we don't examine the
 698        destination address at all; we blindly send it down our
 699        one-and-only registered tunnel, or to the host, depending on
 700        where it came from.  It's up to external software to check
 701        address validity and generate ICMP, etc. */
 702     if (st->ptp) {
 703         if (client) {
 704             st->deliver_to_host(st->dst,buf);
 705         } else {
 706             netlink_client_deliver(st,st->clients,source,dest,buf);
 707         }
 708         BUF_ASSERT_FREE(buf);
 709         return;
 710     }
 711
 712     /* st->secnet_address needs checking before matching destination
 713        addresses */
 714     if (dest==st->secnet_address) {
 715         netlink_packet_local(st,client,buf);
 716         BUF_ASSERT_FREE(buf);
 717         return;
 718     }
 719     netlink_packet_forward(st,client,buf);
 720     BUF_ASSERT_FREE(buf);
 721 }
 722
 723 static void netlink_inst_incoming(void *sst, struct buffer_if *buf)
 724 {
 725     struct netlink_client *c=sst;
 726     struct netlink *st=c->nst;
 727
 728     netlink_incoming(st,c,buf);
 729 }
 730
 731 static void netlink_dev_incoming(void *sst, struct buffer_if *buf)
 732 {
 733     struct netlink *st=sst;
 734
 735     netlink_incoming(st,NULL,buf);
 736 }
 737
 738 static void netlink_set_quality(void *sst, uint32_t quality)
 739 {
 740     struct netlink_client *c=sst;
 741     struct netlink *st=c->nst;
 742
 743     c->link_quality=quality;
 744     c->up=(c->link_quality==LINK_QUALITY_DOWN)?False:True;
 745     if (c->options&OPT_SOFTROUTE) {
 746         st->set_routes(st->dst,c);
 747     }
 748 }
 749
 750 static void netlink_output_subnets(struct netlink *st, uint32_t loglevel,
 751                                    struct subnet_list *snets)
 752 {
 753     int32_t i;
 754     string_t net;
 755
 756     for (i=0; i<snets->entries; i++) {
 757         net=subnet_to_string(snets->list[i]);
 758         Message(loglevel,"%s ",net);
 759         free(net);
 760     }
 761 }
 762
 763 static void netlink_dump_routes(struct netlink *st, bool_t requested)
 764 {
 765     int i;
 766     string_t net;
 767     uint32_t c=M_INFO;
 768
 769     if (requested) c=M_WARNING;
 770     if (st->ptp) {
 771         net=ipaddr_to_string(st->secnet_address);
 772         Message(c,"%s: point-to-point (remote end is %s); routes: ",
 773                 st->name, net);
 774         free(net);
 775         netlink_output_subnets(st,c,st->clients->subnets);
 776         Message(c,"\n");
 777     } else {
 778         Message(c,"%s: routing table:\n",st->name);
 779         for (i=0; i<st->n_clients; i++) {
 780             netlink_output_subnets(st,c,st->routes[i]->subnets);
 781             Message(c,"-> tunnel %s (%s,mtu %d,%s routes,%s,"
 782                     "quality %d,use %d,pri %lu)\n",
 783                     st->routes[i]->name,
 784                     st->routes[i]->up?"up":"down",
 785                     st->routes[i]->mtu,
 786                     st->routes[i]->options&OPT_SOFTROUTE?"soft":"hard",
 787                     st->routes[i]->options&OPT_ALLOWROUTE?"free":"restricted",
 788                     st->routes[i]->link_quality,
 789                     st->routes[i]->outcount,
 790                     (unsigned long)st->routes[i]->priority);
 791         }
 792         net=ipaddr_to_string(st->secnet_address);
 793         Message(c,"%s/32 -> netlink \"%s\" (use %d)\n",
 794                 net,st->name,st->localcount);
 795         free(net);
 796         for (i=0; i<st->subnets->entries; i++) {
 797             net=subnet_to_string(st->subnets->list[i]);
 798             Message(c,"%s ",net);
 799             free(net);
 800         }
 801         if (i>0)
 802             Message(c,"-> host (use %d)\n",st->outcount);
 803     }
 804 }
 805
 806 /* ap is a pointer to a member of the routes array */
 807 static int netlink_compare_client_priority(const void *ap, const void *bp)
 808 {
 809     const struct netlink_client *const*a=ap;
 810     const struct netlink_client *const*b=bp;
 811
 812     if ((*a)->priority==(*b)->priority) return 0;
 813     if ((*a)->priority<(*b)->priority) return 1;
 814     return -1;
 815 }
 816
 817 static void netlink_phase_hook(void *sst, uint32_t new_phase)
 818 {
 819     struct netlink *st=sst;
 820     struct netlink_client *c;
 821     int32_t i;
 822
 823     /* All the networks serviced by the various tunnels should now
 824      * have been registered.  We build a routing table by sorting the
 825      * clients by priority.  */
 826     st->routes=safe_malloc_ary(sizeof(*st->routes),st->n_clients,
 827                                "netlink_phase_hook");
 828     /* Fill the table */
 829     i=0;
 830     for (c=st->clients; c; c=c->next) {
 831         assert(i<INT_MAX);
 832         st->routes[i++]=c;
 833     }
 834     /* Sort the table in descending order of priority */
 835     qsort(st->routes,st->n_clients,sizeof(*st->routes),
 836           netlink_compare_client_priority);
 837
 838     netlink_dump_routes(st,False);
 839 }
 840
 841 static void netlink_signal_handler(void *sst, int signum)
 842 {
 843     struct netlink *st=sst;
 844     Message(M_INFO,"%s: route dump requested by SIGUSR1\n",st->name);
 845     netlink_dump_routes(st,True);
 846 }
 847
 848 static void netlink_inst_set_mtu(void *sst, int32_t new_mtu)
 849 {
 850     struct netlink_client *c=sst;
 851
 852     c->mtu=new_mtu;
 853 }
 854
 855 static void netlink_inst_reg(void *sst, netlink_deliver_fn *deliver,
 856                              void *dst)
 857 {
 858     struct netlink_client *c=sst;
 859
 860     c->deliver=deliver;
 861     c->dst=dst;
 862 }
 863
 864 static struct flagstr netlink_option_table[]={
 865     { "soft", OPT_SOFTROUTE },
 866     { "allow-route", OPT_ALLOWROUTE },
 867     { NULL, 0}
 868 };
 869 /* This is the routine that gets called when the closure that's
 870    returned by an invocation of a netlink device closure (eg. tun,
 871    userv-ipif) is invoked.  It's used to create routes and pass in
 872    information about them; the closure it returns is used by site
 873    code.  */
 874 static closure_t *netlink_inst_create(struct netlink *st,
 875                                       struct cloc loc, dict_t *dict)
 876 {
 877     struct netlink_client *c;
 878     string_t name;
 879     struct ipset *networks;
 880     uint32_t options,priority;
 881     int32_t mtu;
 882     list_t *l;
 883
 884     name=dict_read_string(dict, "name", True, st->name, loc);
 885
 886     l=dict_lookup(dict,"routes");
 887     if (!l)
 888         cfgfatal(loc,st->name,"required parameter \"routes\" not found\n");
 889     networks=string_list_to_ipset(l,loc,st->name,"routes");
 890     options=string_list_to_word(dict_lookup(dict,"options"),
 891                                 netlink_option_table,st->name);
 892
 893     priority=dict_read_number(dict,"priority",False,st->name,loc,0);
 894     mtu=dict_read_number(dict,"mtu",False,st->name,loc,0);
 895
 896     if ((options&OPT_SOFTROUTE) && !st->set_routes) {
 897         cfgfatal(loc,st->name,"this netlink device does not support "
 898                  "soft routes.\n");
 899         return NULL;
 900     }
 901
 902     if (options&OPT_SOFTROUTE) {
 903         /* XXX for now we assume that soft routes require root privilege;
 904            this may not always be true. The device driver can tell us. */
 905         require_root_privileges=True;
 906         require_root_privileges_explanation="netlink: soft routes";
 907         if (st->ptp) {
 908             cfgfatal(loc,st->name,"point-to-point netlinks do not support "
 909                      "soft routes.\n");
 910             return NULL;
 911         }
 912     }
 913
 914     /* Check that nets are a subset of st->remote_networks;
 915        refuse to register if they are not. */
 916     if (!ipset_is_subset(st->remote_networks,networks)) {
 917         cfgfatal(loc,st->name,"routes are not allowed\n");
 918         return NULL;
 919     }
 920
 921     c=safe_malloc(sizeof(*c),"netlink_inst_create");
 922     c->cl.description=name;
 923     c->cl.type=CL_NETLINK;
 924     c->cl.apply=NULL;
 925     c->cl.interface=&c->ops;
 926     c->ops.st=c;
 927     c->ops.reg=netlink_inst_reg;
 928     c->ops.deliver=netlink_inst_incoming;
 929     c->ops.set_quality=netlink_set_quality;
 930     c->ops.set_mtu=netlink_inst_set_mtu;
 931     c->nst=st;
 932
 933     c->networks=networks;
 934     c->subnets=ipset_to_subnet_list(networks);
 935     c->priority=priority;
 936     c->deliver=NULL;
 937     c->dst=NULL;
 938     c->name=name;
 939     c->link_quality=LINK_QUALITY_UNUSED;
 940     c->mtu=mtu?mtu:st->mtu;
 941     c->options=options;
 942     c->outcount=0;
 943     c->up=False;
 944     c->kup=False;
 945     c->next=st->clients;
 946     st->clients=c;
 947     assert(st->n_clients < INT_MAX);
 948     st->n_clients++;
 949
 950     return &c->cl;
 951 }
 952
 953 static list_t *netlink_inst_apply(closure_t *self, struct cloc loc,
 954                                   dict_t *context, list_t *args)
 955 {
 956     struct netlink *st=self->interface;
 957
 958     dict_t *dict;
 959     item_t *item;
 960     closure_t *cl;
 961
 962     item=list_elem(args,0);
 963     if (!item || item->type!=t_dict) {
 964         cfgfatal(loc,st->name,"must have a dictionary argument\n");
 965     }
 966     dict=item->data.dict;
 967
 968     cl=netlink_inst_create(st,loc,dict);
 969
 970     return new_closure(cl);
 971 }
 972
 973 netlink_deliver_fn *netlink_init(struct netlink *st,
 974                                  void *dst, struct cloc loc,
 975                                  dict_t *dict, cstring_t description,
 976                                  netlink_route_fn *set_routes,
 977                                  netlink_deliver_fn *to_host)
 978 {
 979     item_t *sa, *ptpa;
 980     list_t *l;
 981
 982     st->dst=dst;
 983     st->cl.description=description;
 984     st->cl.type=CL_PURE;
 985     st->cl.apply=netlink_inst_apply;
 986     st->cl.interface=st;
 987     st->clients=NULL;
 988     st->routes=NULL;
 989     st->n_clients=0;
 990     st->set_routes=set_routes;
 991     st->deliver_to_host=to_host;
 992
 993     st->name=dict_read_string(dict,"name",False,description,loc);
 994     if (!st->name) st->name=description;
 995     l=dict_lookup(dict,"networks");
 996     if (l)
 997         st->networks=string_list_to_ipset(l,loc,st->name,"networks");
 998     else {
 999         struct ipset *empty;
1000         empty=ipset_new();
1001         st->networks=ipset_complement(empty);
1002         ipset_free(empty);
1003     }
1004     l=dict_lookup(dict,"remote-networks");
1005     if (l) {
1006         st->remote_networks=string_list_to_ipset(l,loc,st->name,
1007                                                  "remote-networks");
1008     } else {
1009         struct ipset *empty;
1010         empty=ipset_new();
1011         st->remote_networks=ipset_complement(empty);
1012         ipset_free(empty);
1013     }
1014
1015     sa=dict_find_item(dict,"secnet-address",False,"netlink",loc);
1016     ptpa=dict_find_item(dict,"ptp-address",False,"netlink",loc);
1017     if (sa && ptpa) {
1018         cfgfatal(loc,st->name,"you may not specify secnet-address and "
1019                  "ptp-address in the same netlink device\n");
1020     }
1021     if (!(sa || ptpa)) {
1022         cfgfatal(loc,st->name,"you must specify secnet-address or "
1023                  "ptp-address for this netlink device\n");
1024     }
1025     if (sa) {
1026         st->secnet_address=string_item_to_ipaddr(sa,"netlink");
1027         st->ptp=False;
1028     } else {
1029         st->secnet_address=string_item_to_ipaddr(ptpa,"netlink");
1030         st->ptp=True;
1031     }
1032     /* To be strictly correct we could subtract secnet_address from
1033        networks here.  It shouldn't make any practical difference,
1034        though, and will make the route dump look complicated... */
1035     st->subnets=ipset_to_subnet_list(st->networks);
1036     st->mtu=dict_read_number(dict, "mtu", False, "netlink", loc, DEFAULT_MTU);
1037     buffer_new(&st->icmp,ICMP_BUFSIZE);
1038     st->outcount=0;
1039     st->localcount=0;
1040
1041     add_hook(PHASE_SETUP,netlink_phase_hook,st);
1042     request_signal_notification(SIGUSR1, netlink_signal_handler, st);
1043
1044     /* If we're point-to-point then we return a CL_NETLINK directly,
1045        rather than a CL_NETLINK_OLD or pure closure (depending on
1046        compatibility).  This CL_NETLINK is for our one and only
1047        client.  Our cl.apply function is NULL. */
1048     if (st->ptp) {
1049         closure_t *cl;
1050         cl=netlink_inst_create(st,loc,dict);
1051         st->cl=*cl;
1052     }
1053     return netlink_dev_incoming;
1054 }
1055
1056 /* No connection to the kernel at all... */
1057
1058 struct null {
1059     struct netlink nl;
1060 };
1061
1062 static bool_t null_set_route(void *sst, struct netlink_client *routes)
1063 {
1064     struct null *st=sst;
1065
1066     if (routes->up!=routes->kup) {
1067         Message(M_INFO,"%s: setting routes for tunnel %s to state %s\n",
1068                 st->nl.name,routes->name,
1069                 routes->up?"up":"down");
1070         routes->kup=routes->up;
1071         return True;
1072     }
1073     return False;
1074 }
1075
1076 static void null_deliver(void *sst, struct buffer_if *buf)
1077 {
1078     return;
1079 }
1080
1081 static list_t *null_apply(closure_t *self, struct cloc loc, dict_t *context,
1082                           list_t *args)
1083 {
1084     struct null *st;
1085     item_t *item;
1086     dict_t *dict;
1087
1088     st=safe_malloc(sizeof(*st),"null_apply");
1089
1090     item=list_elem(args,0);
1091     if (!item || item->type!=t_dict)
1092         cfgfatal(loc,"null-netlink","parameter must be a dictionary\n");
1093
1094     dict=item->data.dict;
1095
1096     netlink_init(&st->nl,st,loc,dict,"null-netlink",null_set_route,
1097                  null_deliver);
1098
1099     return new_closure(&st->nl.cl);
1100 }
1101
1102 void netlink_module(dict_t *dict)
1103 {
1104     add_closure(dict,"null-netlink",null_apply);
1105 }