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