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