release/src/router/openvpn/tap-win32/dhcp.c

   1 /*
   2  *  TAP-Win32/TAP-Win64 -- A kernel driver to provide virtual tap
   3  *                         device functionality on Windows.
   4  *
   5  *  This code was inspired by the CIPE-Win32 driver by Damion K. Wilson.
   6  *
   7  *  This source code is Copyright (C) 2002-2009 OpenVPN Technologies, Inc.,
   8  *  and is released under the GPL version 2 (see below).
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License version 2
  12  *  as published by the Free Software Foundation.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program (see the file COPYING included with this
  21  *  distribution); if not, write to the Free Software Foundation, Inc.,
  22  *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 //=========================
  26 // Code to set DHCP options
  27 //=========================
  28
  29 VOID
  30 SetDHCPOpt (DHCPMsg *m, void *data, unsigned int len)
  31 {
  32   if (!m->overflow)
  33     {
  34       if (m->optlen + len <= DHCP_OPTIONS_BUFFER_SIZE)
  35         {
  36           if (len)
  37             {
  38               NdisMoveMemory (m->msg.options + m->optlen, data, len);
  39               m->optlen += len;
  40             }
  41         }
  42       else
  43         {
  44           m->overflow = TRUE;
  45         }
  46     }
  47 }
  48
  49 VOID
  50 SetDHCPOpt0 (DHCPMsg *msg, int type)
  51 {
  52   DHCPOPT0 opt;
  53   opt.type = (UCHAR) type;
  54   SetDHCPOpt (msg, &opt, sizeof (opt));
  55 }
  56
  57 VOID
  58 SetDHCPOpt8 (DHCPMsg *msg, int type, ULONG data)
  59 {
  60   DHCPOPT8 opt;
  61   opt.type = (UCHAR) type;
  62   opt.len = sizeof (opt.data);
  63   opt.data = (UCHAR) data;
  64   SetDHCPOpt (msg, &opt, sizeof (opt));
  65 }
  66
  67 VOID
  68 SetDHCPOpt32 (DHCPMsg *msg, int type, ULONG data)
  69 {
  70   DHCPOPT32 opt;
  71   opt.type = (UCHAR) type;
  72   opt.len = sizeof (opt.data);
  73   opt.data = data;
  74   SetDHCPOpt (msg, &opt, sizeof (opt));
  75 }
  76
  77 //==============
  78 // Checksum code
  79 //==============
  80
  81 USHORT
  82 ip_checksum (const UCHAR *buf, const int len_ip_header)
  83 {
  84   USHORT word16;
  85   ULONG sum = 0;
  86   int i;
  87
  88   // make 16 bit words out of every two adjacent 8 bit words in the packet
  89   // and add them up
  90   for (i = 0; i < len_ip_header - 1; i += 2) {
  91     word16 = ((buf[i] << 8) & 0xFF00) + (buf[i+1] & 0xFF);
  92     sum += (ULONG) word16;
  93   }
  94
  95   // take only 16 bits out of the 32 bit sum and add up the carries
  96   while (sum >> 16)
  97     sum = (sum & 0xFFFF) + (sum >> 16);
  98
  99   // one's complement the result
 100   return ((USHORT) ~sum);
 101 }
 102
 103 USHORT
 104 udp_checksum (const UCHAR *buf,
 105               const int len_udp,
 106               const UCHAR *src_addr,
 107               const UCHAR *dest_addr)
 108 {
 109   USHORT word16;
 110   ULONG sum = 0;
 111   int i;
 112
 113   // make 16 bit words out of every two adjacent 8 bit words and
 114   // calculate the sum of all 16 bit words
 115   for (i = 0; i < len_udp; i += 2){
 116     word16 = ((buf[i] << 8) & 0xFF00) + ((i + 1 < len_udp) ? (buf[i+1] & 0xFF) : 0);
 117     sum += word16;
 118   }
 119
 120   // add the UDP pseudo header which contains the IP source and destination addresses
 121   for (i = 0; i < 4; i += 2){
 122     word16 =((src_addr[i] << 8) & 0xFF00) + (src_addr[i+1] & 0xFF);
 123     sum += word16;
 124   }
 125   for (i = 0; i < 4; i += 2){
 126     word16 =((dest_addr[i] << 8) & 0xFF00) + (dest_addr[i+1] & 0xFF);
 127     sum += word16;
 128   }
 129
 130   // the protocol number and the length of the UDP packet
 131   sum += (USHORT) IPPROTO_UDP + (USHORT) len_udp;
 132
 133   // keep only the last 16 bits of the 32 bit calculated sum and add the carries
 134   while (sum >> 16)
 135     sum = (sum & 0xFFFF) + (sum >> 16);
 136
 137   // Take the one's complement of sum
 138   return ((USHORT) ~sum);
 139 }
 140
 141 //================================
 142 // Set IP and UDP packet checksums
 143 //================================
 144
 145 VOID
 146 SetChecksumDHCPMsg (DHCPMsg *m)
 147 {
 148   // Set IP checksum
 149   m->msg.pre.ip.check = htons (ip_checksum ((UCHAR *) &m->msg.pre.ip, sizeof (IPHDR)));
 150
 151   // Set UDP Checksum
 152   m->msg.pre.udp.check = htons (udp_checksum ((UCHAR *) &m->msg.pre.udp,
 153                                               sizeof (UDPHDR) + sizeof (DHCP) + m->optlen,
 154                                               (UCHAR *)&m->msg.pre.ip.saddr,
 155                                               (UCHAR *)&m->msg.pre.ip.daddr));
 156 }
 157
 158 //===================
 159 // DHCP message tests
 160 //===================
 161
 162 int
 163 GetDHCPMessageType (const DHCP *dhcp, const int optlen)
 164 {
 165   const UCHAR *p = (UCHAR *) (dhcp + 1);
 166   int i;
 167
 168   for (i = 0; i < optlen; ++i)
 169     {
 170       const UCHAR type = p[i];
 171       const int room = optlen - i - 1;
 172       if (type == DHCP_END)           // didn't find what we were looking for
 173         return -1;
 174       else if (type == DHCP_PAD)      // no-operation
 175         ;
 176       else if (type == DHCP_MSG_TYPE) // what we are looking for
 177         {
 178           if (room >= 2)
 179             {
 180               if (p[i+1] == 1)        // message length should be 1
 181                 return p[i+2];        // return message type
 182             }
 183           return -1;
 184         }
 185       else                            // some other message
 186         {
 187           if (room >= 1)
 188             {
 189               const int len = p[i+1]; // get message length
 190               i += (len + 1);         // advance to next message
 191             }
 192         }
 193     }
 194   return -1;
 195 }
 196
 197 BOOLEAN
 198 DHCPMessageOurs (const TapAdapterPointer p_Adapter,
 199                  const ETH_HEADER *eth,
 200                  const IPHDR *ip,
 201                  const UDPHDR *udp,
 202                  const DHCP *dhcp)
 203 {
 204   // Must be UDPv4 protocol
 205   if (!(eth->proto == htons (ETH_P_IP) && ip->protocol == IPPROTO_UDP))
 206     return FALSE;
 207
 208   // Source MAC must be our adapter
 209   if (!MAC_EQUAL (eth->src, p_Adapter->m_MAC))
 210     return FALSE;
 211
 212   // Dest MAC must be either broadcast or our virtual DHCP server
 213   if (!(MAC_EQUAL (eth->dest, p_Adapter->m_MAC_Broadcast)
 214         || MAC_EQUAL (eth->dest, p_Adapter->m_dhcp_server_mac)))
 215     return FALSE;
 216
 217   // Port numbers must be correct
 218   if (!(udp->dest == htons (BOOTPS_PORT)
 219         && udp->source == htons (BOOTPC_PORT)))
 220     return FALSE;
 221
 222   // Hardware address must be MAC addr sized
 223   if (!(dhcp->hlen == sizeof (MACADDR)))
 224     return FALSE;
 225
 226   // Hardware address must match our adapter
 227   if (!MAC_EQUAL (eth->src, dhcp->chaddr))
 228     return FALSE;
 229
 230   return TRUE;
 231 }
 232
 233
 234 //=====================================================
 235 // Build all of DHCP packet except for DHCP options.
 236 // Assume that *p has been zeroed before we are called.
 237 //=====================================================
 238
 239 VOID
 240 BuildDHCPPre (const TapAdapterPointer a,
 241               DHCPPre *p,
 242               const ETH_HEADER *eth,
 243               const IPHDR *ip,
 244               const UDPHDR *udp,
 245               const DHCP *dhcp,
 246               const int optlen,
 247               const int type)
 248 {
 249   // Should we broadcast or direct to a specific MAC / IP address?
 250   const BOOLEAN broadcast = (type == DHCPNAK
 251                              || MAC_EQUAL (eth->dest, a->m_MAC_Broadcast));
 252   // Build ethernet header
 253
 254   COPY_MAC (p->eth.src, a->m_dhcp_server_mac);
 255
 256   if (broadcast)
 257     COPY_MAC (p->eth.dest, a->m_MAC_Broadcast);
 258   else
 259     COPY_MAC (p->eth.dest, eth->src);
 260
 261   p->eth.proto = htons (ETH_P_IP);
 262
 263   // Build IP header
 264
 265   p->ip.version_len = (4 << 4) | (sizeof (IPHDR) >> 2);
 266   p->ip.tos = 0;
 267   p->ip.tot_len = htons (sizeof (IPHDR) + sizeof (UDPHDR) + sizeof (DHCP) + optlen);
 268   p->ip.id = 0;
 269   p->ip.frag_off = 0;
 270   p->ip.ttl = 16;
 271   p->ip.protocol = IPPROTO_UDP;
 272   p->ip.check = 0;
 273   p->ip.saddr = a->m_dhcp_server_ip;
 274
 275   if (broadcast)
 276     p->ip.daddr = ~0;
 277   else
 278     p->ip.daddr = a->m_dhcp_addr;
 279
 280   // Build UDP header
 281
 282   p->udp.source = htons (BOOTPS_PORT);
 283   p->udp.dest = htons (BOOTPC_PORT);
 284   p->udp.len = htons (sizeof (UDPHDR) + sizeof (DHCP) + optlen);
 285   p->udp.check = 0;
 286
 287   // Build DHCP response
 288
 289   p->dhcp.op = BOOTREPLY;
 290   p->dhcp.htype = 1;
 291   p->dhcp.hlen = sizeof (MACADDR);
 292   p->dhcp.hops = 0;
 293   p->dhcp.xid = dhcp->xid;
 294   p->dhcp.secs = 0;
 295   p->dhcp.flags = 0;
 296   p->dhcp.ciaddr = 0;
 297
 298   if (type == DHCPNAK)
 299     p->dhcp.yiaddr = 0;
 300   else
 301     p->dhcp.yiaddr = a->m_dhcp_addr;
 302
 303   p->dhcp.siaddr = a->m_dhcp_server_ip;
 304   p->dhcp.giaddr = 0;
 305   COPY_MAC (p->dhcp.chaddr, eth->src);
 306   p->dhcp.magic = htonl (0x63825363);
 307 }
 308 //=============================
 309 // Build specific DHCP messages
 310 //=============================
 311
 312 VOID
 313 SendDHCPMsg (const TapAdapterPointer a,
 314              const int type,
 315              const ETH_HEADER *eth,
 316              const IPHDR *ip,
 317              const UDPHDR *udp,
 318              const DHCP *dhcp)
 319 {
 320   DHCPMsg *pkt;
 321
 322   if (!(type == DHCPOFFER || type == DHCPACK || type == DHCPNAK))
 323     {
 324       DEBUGP (("[TAP] SendDHCPMsg: Bad DHCP type: %d\n", type));
 325       return;
 326     }
 327
 328   pkt = (DHCPMsg *) MemAlloc (sizeof (DHCPMsg), TRUE);
 329
 330   if (pkt)
 331     {
 332       //-----------------------
 333       // Build DHCP options
 334       //-----------------------
 335
 336       // Message Type
 337       SetDHCPOpt8 (pkt, DHCP_MSG_TYPE, type);
 338
 339       // Server ID
 340       SetDHCPOpt32 (pkt, DHCP_SERVER_ID, a->m_dhcp_server_ip);
 341
 342       if (type == DHCPOFFER || type == DHCPACK)
 343         {
 344           // Lease Time
 345           SetDHCPOpt32 (pkt, DHCP_LEASE_TIME, htonl (a->m_dhcp_lease_time));
 346
 347           // Netmask
 348           SetDHCPOpt32 (pkt, DHCP_NETMASK, a->m_dhcp_netmask);
 349
 350           // Other user-defined options
 351           SetDHCPOpt (pkt,
 352                       a->m_dhcp_user_supplied_options_buffer,
 353                       a->m_dhcp_user_supplied_options_buffer_len);
 354         }
 355
 356       // End
 357       SetDHCPOpt0 (pkt, DHCP_END);
 358
 359       if (!DHCPMSG_OVERFLOW (pkt))
 360         {
 361           // The initial part of the DHCP message (not including options) gets built here
 362           BuildDHCPPre (a,
 363                         &pkt->msg.pre,
 364                         eth,
 365                         ip,
 366                         udp,
 367                         dhcp,
 368                         DHCPMSG_LEN_OPT (pkt),
 369                         type);
 370
 371           SetChecksumDHCPMsg (pkt);
 372
 373           DUMP_PACKET ("DHCPMsg",
 374                        DHCPMSG_BUF (pkt),
 375                        DHCPMSG_LEN_FULL (pkt));
 376
 377           // Return DHCP response to kernel
 378           InjectPacketDeferred (a,
 379                                 DHCPMSG_BUF (pkt),
 380                                 DHCPMSG_LEN_FULL (pkt));
 381         }
 382       else
 383         {
 384           DEBUGP (("[TAP] SendDHCPMsg: DHCP buffer overflow\n"));
 385         }
 386
 387       MemFree (pkt, sizeof (DHCPMsg));
 388     }
 389 }
 390
 391 //===================================================================
 392 // Handle a BOOTPS packet produced by the local system to
 393 // resolve the address/netmask of this adapter.
 394 // If we are in TAP_IOCTL_CONFIG_DHCP_MASQ mode, reply
 395 // to the message.  Return TRUE if we processed the passed
 396 // message, so that downstream stages can ignore it.
 397 //===================================================================
 398
 399 BOOLEAN
 400 ProcessDHCP (TapAdapterPointer p_Adapter,
 401              const ETH_HEADER *eth,
 402              const IPHDR *ip,
 403              const UDPHDR *udp,
 404              const DHCP *dhcp,
 405              int optlen)
 406 {
 407   int msg_type;
 408
 409   // Sanity check IP header
 410   if (!(ntohs (ip->tot_len) == sizeof (IPHDR) + sizeof (UDPHDR) + sizeof (DHCP) + optlen
 411         && (ntohs (ip->frag_off) & IP_OFFMASK) == 0))
 412     return TRUE;
 413
 414   // Does this message belong to us?
 415   if (!DHCPMessageOurs (p_Adapter, eth, ip, udp, dhcp))
 416     return FALSE;
 417
 418   msg_type = GetDHCPMessageType (dhcp, optlen);
 419
 420   // Drop non-BOOTREQUEST messages
 421   if (dhcp->op != BOOTREQUEST)
 422     return TRUE;
 423
 424   // Drop any messages except DHCPDISCOVER or DHCPREQUEST
 425   if (!(msg_type == DHCPDISCOVER || msg_type == DHCPREQUEST))
 426     return TRUE;
 427
 428   // Should we reply with DHCPOFFER, DHCPACK, or DHCPNAK?
 429   if (msg_type == DHCPREQUEST
 430       && ((dhcp->ciaddr && dhcp->ciaddr != p_Adapter->m_dhcp_addr)
 431           || !p_Adapter->m_dhcp_received_discover
 432           || p_Adapter->m_dhcp_bad_requests >= BAD_DHCPREQUEST_NAK_THRESHOLD))
 433     SendDHCPMsg (p_Adapter,
 434                  DHCPNAK,
 435                  eth, ip, udp, dhcp);
 436   else
 437     SendDHCPMsg (p_Adapter,
 438                  (msg_type == DHCPDISCOVER ? DHCPOFFER : DHCPACK),
 439                  eth, ip, udp, dhcp);
 440
 441   // Remember if we received a DHCPDISCOVER
 442   if (msg_type == DHCPDISCOVER)
 443     p_Adapter->m_dhcp_received_discover = TRUE;
 444
 445   // Is this a bad DHCPREQUEST?
 446   if (msg_type == DHCPREQUEST && dhcp->ciaddr != p_Adapter->m_dhcp_addr)
 447     ++p_Adapter->m_dhcp_bad_requests;
 448
 449   return TRUE;
 450 }
 451
 452 #if DBG
 453
 454 const char *
 455 message_op_text (int op)
 456 {
 457   switch (op)
 458     {
 459     case BOOTREQUEST:
 460       return "BOOTREQUEST";
 461     case BOOTREPLY:
 462       return "BOOTREPLY";
 463     default:
 464       return "???";
 465     }
 466 }
 467
 468 const char *
 469 message_type_text (int type)
 470 {
 471   switch (type)
 472     {
 473     case DHCPDISCOVER:
 474       return "DHCPDISCOVER";
 475     case DHCPOFFER:
 476       return "DHCPOFFER";
 477     case DHCPREQUEST:
 478       return "DHCPREQUEST";
 479     case DHCPDECLINE:
 480       return "DHCPDECLINE";
 481     case DHCPACK:
 482       return "DHCPACK";
 483     case DHCPNAK:
 484       return "DHCPNAK";
 485     case DHCPRELEASE:
 486       return "DHCPRELEASE";
 487     case DHCPINFORM:
 488       return "DHCPINFORM";
 489     default:
 490       return "???";
 491     }
 492 }
 493
 494 const char *
 495 port_name (int port)
 496 {
 497   switch (port)
 498     {
 499     case BOOTPS_PORT:
 500       return "BOOTPS";
 501     case BOOTPC_PORT:
 502       return "BOOTPC";
 503     default:
 504       return "unknown";
 505     }
 506 }
 507
 508 VOID
 509 DumpDHCP (const ETH_HEADER *eth,
 510           const IPHDR *ip,
 511           const UDPHDR *udp,
 512           const DHCP *dhcp,
 513           const int optlen)
 514 {
 515   DEBUGP ((" %s", message_op_text (dhcp->op)));
 516   DEBUGP ((" %s ", message_type_text (GetDHCPMessageType (dhcp, optlen))));
 517   PrIP (ip->saddr);
 518   DEBUGP ((":%s[", port_name (ntohs (udp->source))));
 519   PrMac (eth->src);
 520   DEBUGP (("] -> "));
 521   PrIP (ip->daddr);
 522   DEBUGP ((":%s[", port_name (ntohs (udp->dest))));
 523   PrMac (eth->dest);
 524   DEBUGP (("]"));
 525   if (dhcp->ciaddr)
 526     {
 527       DEBUGP ((" ci="));
 528       PrIP (dhcp->ciaddr);
 529     }
 530   if (dhcp->yiaddr)
 531     {
 532       DEBUGP ((" yi="));
 533       PrIP (dhcp->yiaddr);
 534     }
 535   if (dhcp->siaddr)
 536     {
 537       DEBUGP ((" si="));
 538       PrIP (dhcp->siaddr);
 539     }
 540   if (dhcp->hlen == sizeof (MACADDR))
 541     {
 542       DEBUGP ((" ch="));
 543       PrMac (dhcp->chaddr);
 544     }
 545
 546   DEBUGP ((" xid=0x%08x", ntohl (dhcp->xid)));
 547
 548   if (ntohl (dhcp->magic) != 0x63825363)
 549     DEBUGP ((" ma=0x%08x", ntohl (dhcp->magic)));
 550   if (dhcp->htype != 1)
 551     DEBUGP ((" htype=%d", dhcp->htype));
 552   if (dhcp->hops)
 553     DEBUGP ((" hops=%d", dhcp->hops));
 554   if (ntohs (dhcp->secs))
 555     DEBUGP ((" secs=%d", ntohs (dhcp->secs)));
 556   if (ntohs (dhcp->flags))
 557     DEBUGP ((" flags=0x%04x", ntohs (dhcp->flags)));
 558
 559   // extra stuff
 560
 561   if (ip->version_len != 0x45)
 562     DEBUGP ((" vl=0x%02x", ip->version_len));
 563   if (ntohs (ip->tot_len) != sizeof (IPHDR) + sizeof (UDPHDR) + sizeof (DHCP) + optlen)
 564     DEBUGP ((" tl=%d", ntohs (ip->tot_len)));
 565   if (ntohs (udp->len) != sizeof (UDPHDR) + sizeof (DHCP) + optlen)
 566     DEBUGP ((" ul=%d", ntohs (udp->len)));
 567
 568   if (ip->tos)
 569     DEBUGP ((" tos=0x%02x", ip->tos));
 570   if (ntohs (ip->id))
 571     DEBUGP ((" id=0x%04x", ntohs (ip->id)));
 572   if (ntohs (ip->frag_off))
 573     DEBUGP ((" frag_off=0x%04x", ntohs (ip->frag_off)));
 574
 575   DEBUGP ((" ttl=%d", ip->ttl));
 576   DEBUGP ((" ic=0x%04x [0x%04x]", ntohs (ip->check),
 577             ip_checksum ((UCHAR*)ip, sizeof (IPHDR))));
 578   DEBUGP ((" uc=0x%04x [0x%04x/%d]", ntohs (udp->check),
 579             udp_checksum ((UCHAR *) udp,
 580                           sizeof (UDPHDR) + sizeof (DHCP) + optlen,
 581                           (UCHAR *) &ip->saddr,
 582                           (UCHAR *) &ip->daddr),
 583             optlen));
 584
 585   // Options
 586   {
 587     const UCHAR *opt = (UCHAR *) (dhcp + 1);
 588     int i;
 589
 590     DEBUGP ((" OPT"));
 591     for (i = 0; i < optlen; ++i)
 592       {
 593         const UCHAR data = opt[i];
 594         DEBUGP ((".%d", data));
 595       }
 596   }
 597 }
 598
 599 #endif /* DBG */