src/modules/proto_dhcp/dhcp.c

   1 /*
   2  * dhcp.c       Functions to send/receive dhcp packets.
   3  *
   4  * Version:     $Id$
   5  *
   6  *   This library is free software; you can redistribute it and/or
   7  *   modify it under the terms of the GNU Lesser General Public
   8  *   License as published by the Free Software Foundation; either
   9  *   version 2.1 of the License, or (at your option) any later version.
  10  *
  11  *   This library is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  *   Lesser General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU Lesser General Public
  17  *   License along with this library; if not, write to the Free Software
  18  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * Copyright 2008 The FreeRADIUS server project
  21  * Copyright 2008 Alan DeKok <aland@deployingradius.com>
  22  */
  23
  24 RCSID("$Id$")
  25
  26 #include <freeradius-devel/libradius.h>
  27 #include <freeradius-devel/udpfromto.h>
  28 #include <freeradius-devel/dhcp.h>
  29 #include <freeradius-devel/net.h>
  30
  31 #ifndef __MINGW32__
  32 #include <sys/ioctl.h>
  33 #endif
  34
  35 #ifdef HAVE_SYS_SOCKET_H
  36 #include <sys/socket.h>
  37 #endif
  38 #ifdef HAVE_SYS_TYPES_H
  39 #include <sys/types.h>
  40 #endif
  41
  42 #ifndef __MINGW32__
  43 #include <net/if_arp.h>
  44 #endif
  45
  46 #define DHCP_CHADDR_LEN (16)
  47 #define DHCP_SNAME_LEN  (64)
  48 #define DHCP_FILE_LEN   (128)
  49 #define DHCP_VEND_LEN   (308)
  50 #define DHCP_OPTION_MAGIC_NUMBER (0x63825363)
  51
  52 #ifndef INADDR_BROADCAST
  53 #define INADDR_BROADCAST INADDR_NONE
  54 #endif
  55
  56 /* @todo: this is a hack */
  57 #  define DEBUG                 if (fr_debug_lvl && fr_log_fp) fr_printf_log
  58 #  define debug_pair(vp)        do { if (fr_debug_lvl && fr_log_fp) { \
  59                                         vp_print(fr_log_fp, vp); \
  60                                      } \
  61                                 } while(0)
  62
  63 #ifdef HAVE_LINUX_IF_PACKET_H
  64 #define ETH_HDR_SIZE   14
  65 #define IP_HDR_SIZE    20
  66 #define UDP_HDR_SIZE   8
  67 #define ETH_ADDR_LEN   6
  68 #define ETH_TYPE_IP    0x0800
  69 #define ETH_P_ALL      0x0003
  70
  71 static uint8_t eth_bcast[ETH_ADDR_LEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
  72
  73 /* Discard raw packets which we are not interested in. Allow to trace why we discard. */
  74 #define DISCARD_RP(...) { \
  75         if (fr_debug_lvl > 2) { \
  76                 fprintf(stdout, "dhcpclient: discarding received packet: "); \
  77                 fprintf(stdout, ## __VA_ARGS__); \
  78                 fprintf(stdout, "\n"); \
  79         } \
  80         rad_free(&packet); \
  81         return NULL; \
  82 }
  83 #endif
  84
  85 typedef struct dhcp_packet_t {
  86         uint8_t         opcode;
  87         uint8_t         htype;
  88         uint8_t         hlen;
  89         uint8_t         hops;
  90         uint32_t        xid;    /* 4 */
  91         uint16_t        secs;   /* 8 */
  92         uint16_t        flags;
  93         uint32_t        ciaddr; /* 12 */
  94         uint32_t        yiaddr; /* 16 */
  95         uint32_t        siaddr; /* 20 */
  96         uint32_t        giaddr; /* 24 */
  97         uint8_t         chaddr[DHCP_CHADDR_LEN]; /* 28 */
  98         uint8_t         sname[DHCP_SNAME_LEN]; /* 44 */
  99         uint8_t         file[DHCP_FILE_LEN]; /* 108 */
 100         uint32_t        option_format; /* 236 */
 101         uint8_t         options[DHCP_VEND_LEN];
 102 } dhcp_packet_t;
 103
 104 typedef struct dhcp_option_t {
 105         uint8_t         code;
 106         uint8_t         length;
 107 } dhcp_option_t;
 108
 109 /*
 110  *      INADDR_ANY : 68 -> INADDR_BROADCAST : 67        DISCOVER
 111  *      INADDR_BROADCAST : 68 <- SERVER_IP : 67         OFFER
 112  *      INADDR_ANY : 68 -> INADDR_BROADCAST : 67        REQUEST
 113  *      INADDR_BROADCAST : 68 <- SERVER_IP : 67         ACK
 114  */
 115 static char const *dhcp_header_names[] = {
 116         "DHCP-Opcode",
 117         "DHCP-Hardware-Type",
 118         "DHCP-Hardware-Address-Length",
 119         "DHCP-Hop-Count",
 120         "DHCP-Transaction-Id",
 121         "DHCP-Number-of-Seconds",
 122         "DHCP-Flags",
 123         "DHCP-Client-IP-Address",
 124         "DHCP-Your-IP-Address",
 125         "DHCP-Server-IP-Address",
 126         "DHCP-Gateway-IP-Address",
 127         "DHCP-Client-Hardware-Address",
 128         "DHCP-Server-Host-Name",
 129         "DHCP-Boot-Filename",
 130
 131         NULL
 132 };
 133
 134 static char const *dhcp_message_types[] = {
 135         "invalid",
 136         "DHCP-Discover",
 137         "DHCP-Offer",
 138         "DHCP-Request",
 139         "DHCP-Decline",
 140         "DHCP-Ack",
 141         "DHCP-NAK",
 142         "DHCP-Release",
 143         "DHCP-Inform",
 144         "DHCP-Force-Renew",
 145         "DHCP-Lease-Query",
 146         "DHCP-Lease-Unassigned",
 147         "DHCP-Lease-Unknown",
 148         "DHCP-Lease-Active",
 149         "DHCP-Bulk-Lease-Query",
 150         "DHCP-Lease-Query-Done"
 151 };
 152
 153 #define DHCP_MAX_MESSAGE_TYPE (sizeof(dhcp_message_types) / sizeof(dhcp_message_types[0]))
 154
 155 static int dhcp_header_sizes[] = {
 156         1, 1, 1, 1,
 157         4, 2, 2, 4,
 158         4, 4, 4,
 159         DHCP_CHADDR_LEN,
 160         DHCP_SNAME_LEN,
 161         DHCP_FILE_LEN
 162 };
 163
 164
 165 /*
 166  *      Some clients silently ignore responses less than 300 bytes.
 167  */
 168 #define MIN_PACKET_SIZE (244)
 169 #define DEFAULT_PACKET_SIZE (300)
 170 #define MAX_PACKET_SIZE (1500 - 40)
 171
 172 #define DHCP_OPTION_FIELD (0)
 173 #define DHCP_FILE_FIELD   (1)
 174 #define DHCP_SNAME_FIELD  (2)
 175
 176 static uint8_t *dhcp_get_option(dhcp_packet_t *packet, size_t packet_size,
 177                                 unsigned int option)
 178 {
 179         int overload = 0;
 180         int field = DHCP_OPTION_FIELD;
 181         size_t where, size;
 182         uint8_t *data;
 183
 184         where = 0;
 185         size = packet_size - offsetof(dhcp_packet_t, options);
 186         data = &packet->options[where];
 187
 188         while (where < size) {
 189                 if (data[0] == 0) { /* padding */
 190                         where++;
 191                         continue;
 192                 }
 193
 194                 if (data[0] == 255) { /* end of options */
 195                         if ((field == DHCP_OPTION_FIELD) &&
 196                             (overload & DHCP_FILE_FIELD)) {
 197                                 data = packet->file;
 198                                 where = 0;
 199                                 size = sizeof(packet->file);
 200                                 field = DHCP_FILE_FIELD;
 201                                 continue;
 202
 203                         } else if ((field == DHCP_FILE_FIELD) &&
 204                                    (overload & DHCP_SNAME_FIELD)) {
 205                                 data = packet->sname;
 206                                 where = 0;
 207                                 size = sizeof(packet->sname);
 208                                 field = DHCP_SNAME_FIELD;
 209                                 continue;
 210                         }
 211
 212                         return NULL;
 213                 }
 214
 215                 /*
 216                  *      We MUST have a real option here.
 217                  */
 218                 if ((where + 2) > size) {
 219                         fr_strerror_printf("Options overflow field at %u",
 220                                            (unsigned int) (data - (uint8_t *) packet));
 221                         return NULL;
 222                 }
 223
 224                 if ((where + 2 + data[1]) > size) {
 225                         fr_strerror_printf("Option length overflows field at %u",
 226                                            (unsigned int) (data - (uint8_t *) packet));
 227                         return NULL;
 228                 }
 229
 230                 if (data[0] == option) return data;
 231
 232                 if (data[0] == 52) { /* overload sname and/or file */
 233                         overload = data[3];
 234                 }
 235
 236                 where += data[1] + 2;
 237                 data += data[1] + 2;
 238         }
 239
 240         return NULL;
 241 }
 242
 243 /*
 244  *      DHCPv4 is only for IPv4.  Broadcast only works if udpfromto is
 245  *      defined.
 246  */
 247 RADIUS_PACKET *fr_dhcp_recv(int sockfd)
 248 {
 249         uint32_t                magic;
 250         struct sockaddr_storage src;
 251         struct sockaddr_storage dst;
 252         socklen_t               sizeof_src;
 253         socklen_t               sizeof_dst;
 254         RADIUS_PACKET           *packet;
 255         uint16_t                port;
 256         uint8_t                 *code;
 257         ssize_t                 data_len;
 258
 259         packet = rad_alloc(NULL, false);
 260         if (!packet) {
 261                 fr_strerror_printf("Failed allocating packet");
 262                 return NULL;
 263         }
 264
 265         packet->data = talloc_zero_array(packet, uint8_t, MAX_PACKET_SIZE);
 266         if (!packet->data) {
 267                 fr_strerror_printf("Out of memory");
 268                 rad_free(&packet);
 269                 return NULL;
 270         }
 271
 272         packet->sockfd = sockfd;
 273         sizeof_src = sizeof(src);
 274 #ifdef WITH_UDPFROMTO
 275         sizeof_dst = sizeof(dst);
 276         data_len = recvfromto(sockfd, packet->data, MAX_PACKET_SIZE, 0,
 277                               (struct sockaddr *)&src, &sizeof_src,
 278                               (struct sockaddr *)&dst, &sizeof_dst);
 279 #else
 280         data_len = recvfrom(sockfd, packet->data, MAX_PACKET_SIZE, 0,
 281                             (struct sockaddr *)&src, &sizeof_src);
 282 #endif
 283
 284         if (data_len <= 0) {
 285                 fr_strerror_printf("Failed reading DHCP socket: %s", fr_syserror(errno));
 286                 rad_free(&packet);
 287                 return NULL;
 288         }
 289
 290         packet->data_len = data_len;
 291         if (packet->data_len < MIN_PACKET_SIZE) {
 292                 fr_strerror_printf("DHCP packet is too small (%zu < %d)",
 293                                    packet->data_len, MIN_PACKET_SIZE);
 294                 rad_free(&packet);
 295                 return NULL;
 296         }
 297
 298         if (packet->data_len > MAX_PACKET_SIZE) {
 299                 fr_strerror_printf("DHCP packet is too large (%zx > %d)",
 300                                    packet->data_len, MAX_PACKET_SIZE);
 301                 rad_free(&packet);
 302                 return NULL;
 303         }
 304
 305         if (packet->data[1] > 1) {
 306                 fr_strerror_printf("DHCP can only receive ethernet requests, not type %02x",
 307                       packet->data[1]);
 308                 rad_free(&packet);
 309                 return NULL;
 310         }
 311
 312         if ((packet->data[2] != 0) && (packet->data[2] != 6)) {
 313                 fr_strerror_printf("Ethernet HW length is wrong length %d",
 314                         packet->data[2]);
 315                 rad_free(&packet);
 316                 return NULL;
 317         }
 318
 319         memcpy(&magic, packet->data + 236, 4);
 320         magic = ntohl(magic);
 321         if (magic != DHCP_OPTION_MAGIC_NUMBER) {
 322                 fr_strerror_printf("Cannot do BOOTP");
 323                 rad_free(&packet);
 324                 return NULL;
 325         }
 326
 327         /*
 328          *      Create unique keys for the packet.
 329          */
 330         memcpy(&magic, packet->data + 4, 4);
 331         packet->id = ntohl(magic);
 332
 333         code = dhcp_get_option((dhcp_packet_t *) packet->data,
 334                                packet->data_len, 53);
 335         if (!code) {
 336                 fr_strerror_printf("No message-type option was found in the packet");
 337                 rad_free(&packet);
 338                 return NULL;
 339         }
 340
 341         if ((code[1] < 1) || (code[2] == 0) || (code[2] >= DHCP_MAX_MESSAGE_TYPE)) {
 342                 fr_strerror_printf("Unknown value %d for message-type option", code[2]);
 343                 rad_free(&packet);
 344                 return NULL;
 345         }
 346
 347         packet->code = code[2] | PW_DHCP_OFFSET;
 348
 349         /*
 350          *      Create a unique vector from the MAC address and the
 351          *      DHCP opcode.  This is a hack for the RADIUS
 352          *      infrastructure in the rest of the server.
 353          *
 354          *      Note: packet->data[2] == 6, which is smaller than
 355          *      sizeof(packet->vector)
 356          *
 357          *      FIXME:  Look for client-identifier in packet,
 358          *      and use that, too?
 359          */
 360         memset(packet->vector, 0, sizeof(packet->vector));
 361         memcpy(packet->vector, packet->data + 28, packet->data[2]);
 362         packet->vector[packet->data[2]] = packet->code & 0xff;
 363
 364         /*
 365          *      FIXME: for DISCOVER / REQUEST: src_port == dst_port + 1
 366          *      FIXME: for OFFER / ACK       : src_port = dst_port - 1
 367          */
 368
 369         /*
 370          *      Unique keys are xid, client mac, and client ID?
 371          */
 372
 373         /*
 374          *      FIXME: More checks, like DHCP packet type?
 375          */
 376
 377         sizeof_dst = sizeof(dst);
 378
 379 #ifndef WITH_UDPFROMTO
 380         /*
 381          *      This should never fail...
 382          */
 383         if (getsockname(sockfd, (struct sockaddr *) &dst, &sizeof_dst) < 0) {
 384                 fr_strerror_printf("getsockname failed: %s", fr_syserror(errno));
 385                 rad_free(&packet);
 386                 return NULL;
 387         }
 388 #endif
 389
 390         fr_sockaddr2ipaddr(&dst, sizeof_dst, &packet->dst_ipaddr, &port);
 391         packet->dst_port = port;
 392
 393         fr_sockaddr2ipaddr(&src, sizeof_src, &packet->src_ipaddr, &port);
 394         packet->src_port = port;
 395
 396         if (fr_debug_lvl > 1) {
 397                 char type_buf[64];
 398                 char const *name = type_buf;
 399                 char src_ip_buf[256], dst_ip_buf[256];
 400
 401                 if ((packet->code >= PW_DHCP_DISCOVER) &&
 402                     (packet->code < (1024 + DHCP_MAX_MESSAGE_TYPE))) {
 403                         name = dhcp_message_types[packet->code - PW_DHCP_OFFSET];
 404                 } else {
 405                         snprintf(type_buf, sizeof(type_buf), "%d",
 406                                  packet->code - PW_DHCP_OFFSET);
 407                 }
 408
 409                 DEBUG("Received %s of Id %08x from %s:%d to %s:%d\n",
 410                        name, (unsigned int) packet->id,
 411                        inet_ntop(packet->src_ipaddr.af,
 412                                  &packet->src_ipaddr.ipaddr,
 413                                  src_ip_buf, sizeof(src_ip_buf)),
 414                        packet->src_port,
 415                        inet_ntop(packet->dst_ipaddr.af,
 416                                  &packet->dst_ipaddr.ipaddr,
 417                                  dst_ip_buf, sizeof(dst_ip_buf)),
 418                        packet->dst_port);
 419         }
 420
 421         return packet;
 422 }
 423
 424
 425 /*
 426  *      Send a DHCP packet.
 427  */
 428 int fr_dhcp_send(RADIUS_PACKET *packet)
 429 {
 430         struct sockaddr_storage dst;
 431         socklen_t               sizeof_dst;
 432 #ifdef WITH_UDPFROMTO
 433         struct sockaddr_storage src;
 434         socklen_t               sizeof_src;
 435
 436         fr_ipaddr2sockaddr(&packet->src_ipaddr, packet->src_port,
 437             &src, &sizeof_src);
 438 #endif
 439
 440         fr_ipaddr2sockaddr(&packet->dst_ipaddr, packet->dst_port,
 441                            &dst, &sizeof_dst);
 442
 443         if (packet->data_len == 0) {
 444                 fr_strerror_printf("No data to send");
 445                 return -1;
 446         }
 447
 448         if (fr_debug_lvl > 1) {
 449                 char type_buf[64];
 450                 char const *name = type_buf;
 451 #ifdef WITH_UDPFROMTO
 452                 char src_ip_buf[INET6_ADDRSTRLEN];
 453 #endif
 454                 char dst_ip_buf[INET6_ADDRSTRLEN];
 455
 456                 if ((packet->code >= PW_DHCP_DISCOVER) &&
 457                     (packet->code < (1024 + DHCP_MAX_MESSAGE_TYPE))) {
 458                         name = dhcp_message_types[packet->code - PW_DHCP_OFFSET];
 459                 } else {
 460                         snprintf(type_buf, sizeof(type_buf), "%d",
 461                             packet->code - PW_DHCP_OFFSET);
 462                 }
 463
 464                 DEBUG(
 465 #ifdef WITH_UDPFROMTO
 466                 "Sending %s Id %08x from %s:%d to %s:%d\n",
 467 #else
 468                 "Sending %s Id %08x to %s:%d\n",
 469 #endif
 470                    name, (unsigned int) packet->id,
 471 #ifdef WITH_UDPFROMTO
 472                    inet_ntop(packet->src_ipaddr.af, &packet->src_ipaddr.ipaddr, src_ip_buf, sizeof(src_ip_buf)),
 473                    packet->src_port,
 474 #endif
 475                    inet_ntop(packet->dst_ipaddr.af, &packet->dst_ipaddr.ipaddr, dst_ip_buf, sizeof(dst_ip_buf)),
 476                    packet->dst_port);
 477         }
 478
 479 #ifndef WITH_UDPFROMTO
 480         /*
 481          *      Assume that the packet is encoded before sending it.
 482          */
 483         return sendto(packet->sockfd, packet->data, packet->data_len, 0,
 484                       (struct sockaddr *)&dst, sizeof_dst);
 485 #else
 486
 487         return sendfromto(packet->sockfd, packet->data, packet->data_len, 0,
 488                           (struct sockaddr *)&src, sizeof_src,
 489                           (struct sockaddr *)&dst, sizeof_dst);
 490 #endif
 491 }
 492
 493 static int fr_dhcp_attr2vp(TALLOC_CTX *ctx, VALUE_PAIR **vp_p, uint8_t const *p, size_t alen);
 494
 495 /** Returns the number of array members for arrays with fixed element sizes
 496  *
 497  */
 498 static int fr_dhcp_array_members(size_t *len, DICT_ATTR const *da)
 499 {
 500         int num_entries = 1;
 501
 502         /*
 503          *      Could be an array of bytes, integers, etc.
 504          */
 505         if (da->flags.array) switch (da->type) {
 506         case PW_TYPE_BYTE:
 507                 num_entries = *len;
 508                 *len = 1;
 509                 break;
 510
 511         case PW_TYPE_SHORT: /* ignore any trailing data */
 512                 num_entries = *len >> 1;
 513                 *len = 2;
 514                 break;
 515
 516         case PW_TYPE_IPV4_ADDR:
 517         case PW_TYPE_INTEGER:
 518         case PW_TYPE_DATE: /* ignore any trailing data */
 519                 num_entries = *len >> 2;
 520                 *len = 4;
 521                 break;
 522
 523         case PW_TYPE_IPV6_ADDR:
 524                 num_entries = *len >> 4;
 525                 *len = 16;
 526                 break;
 527
 528         default:
 529                 break;
 530         }
 531
 532         return num_entries;
 533 }
 534
 535 /** RFC 4243 Vendor Specific Suboptions
 536  *
 537  * Vendor specific suboptions are in the format.
 538  @verbatim
 539       0                   1                   2                   3
 540       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 541      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 542      |                     Enterprise Number 0                       |
 543      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 544      |    Len 0      |                                               /
 545      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 546      /                      Suboption Data 0                         /
 547      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 548      |                     Enterprise Number n                       |
 549      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 550      |    Len n      |                                               /
 551      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 552      /                      Suboption Data n                         /
 553      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 554  @endverbatim
 555  *
 556  * So although the vendor is identified, the format of the data isn't
 557  * specified so we can't actually resolve the suboption to an
 558  * attribute.  For now, we just convert it to an attribute of
 559  * DHCP-Vendor-Specific-Information with raw octets contents.
 560  */
 561
 562
 563 /** Decode DHCP suboptions
 564  *
 565  * @param[in,out] tlv to decode. *tlv will be set to the head of the list of suboptions and original will be freed.
 566  * @param[in] ctx context to alloc new attributes in.
 567  * @param[in] data to parse.
 568  * @param[in] len length of data to parse.
 569  */
 570 static int fr_dhcp_decode_suboption(TALLOC_CTX *ctx, VALUE_PAIR **tlv, uint8_t const *data, size_t len)
 571 {
 572         uint8_t const *p, *q;
 573         VALUE_PAIR *head, *vp;
 574         vp_cursor_t cursor;
 575
 576         /*
 577          *      TLV must already point to a VALUE_PAIR.
 578          */
 579         VERIFY_VP(*tlv);
 580
 581         /*
 582          *      Take a pass at parsing it.
 583          */
 584         p = data;
 585         q = data + len;
 586         while (p < q) {
 587                 /*
 588                  *      RFC 3046 is very specific about not allowing termination
 589                  *      with a 255 sub-option. But it's required for decoding
 590                  *      option 43, and vendors will probably screw it up
 591                  *      anyway.
 592                  */
 593                 if (*p == 0) {
 594                         p++;
 595                         continue;
 596                 }
 597                 if (*p == 255) {
 598                         q--;
 599                         break;
 600                 }
 601
 602                 /*
 603                  *      Check if reading length would take us past the end of the buffer
 604                  */
 605                 if (++p >= q) goto malformed;
 606                 p += p[0];
 607
 608                 /*
 609                  *      Check if length > the length of the buffer we have left
 610                  */
 611                 if (p >= q) goto malformed;
 612                 p++;
 613         }
 614
 615         /*
 616          *      Got here... must be well formed.
 617          */
 618         head = NULL;
 619         fr_cursor_init(&cursor, &head);
 620
 621         p = data;
 622         while (p < q) {
 623                 uint8_t const   *a_p;
 624                 size_t          a_len;
 625                 int             num_entries, i;
 626
 627                 DICT_ATTR const *da;
 628                 uint32_t        attr;
 629
 630                 /*
 631                  *      The initial OID string looks like:
 632                  *      <iana>.0
 633                  *
 634                  *      If <iana>.0 is type TLV then we attempt to decode its contents as more
 635                  *      DHCP suboptions, which gives us:
 636                  *      <iana>.<attr>
 637                  *
 638                  *      If <iana>.0 is not defined in the dictionary or is type octets, we leave
 639                  *      the attribute as is.
 640                  */
 641                 attr = (*tlv)->da->attr ? ((*tlv)->da->attr | (p[0] << 8)) : p[0];
 642
 643                 /*
 644                  *      Use the vendor of the parent TLV which is not necessarily
 645                  *      DHCP_MAGIC_VENDOR.
 646                  *
 647                  *      Note: This does not deal with dictionary numbering clashes. If
 648                  *      the vendor uses different numbers for DHCP suboptions and RADIUS
 649                  *      attributes then it's time to break out %{hex:} and regular
 650                  *      expressions.
 651                  */
 652                 da = dict_attrbyvalue(attr, (*tlv)->da->vendor);
 653                 if (!da) {
 654                         da = dict_unknown_afrom_fields(ctx, attr, (*tlv)->da->vendor);
 655                         if (!da) {
 656                                 fr_pair_list_free(&head);
 657                                 return -1;
 658                         }
 659                 }
 660
 661                 a_len = p[1];
 662                 a_p = p + 2;
 663                 num_entries = fr_dhcp_array_members(&a_len, da);
 664                 for (i = 0; i < num_entries; i++) {
 665                         vp = fr_pair_afrom_da(ctx, da);
 666                         if (!vp) {
 667                                 fr_pair_list_free(&head);
 668                                 return -1;
 669                         }
 670                         vp->op = T_OP_EQ;
 671                         fr_pair_steal(ctx, vp); /* for unknown attributes hack */
 672
 673                         if (fr_dhcp_attr2vp(ctx, &vp, a_p, a_len) < 0) {
 674                                 dict_attr_free(&da);
 675                                 fr_pair_list_free(&head);
 676                                 goto malformed;
 677                         }
 678                         fr_cursor_merge(&cursor, vp);
 679
 680                         a_p += a_len;
 681                 }
 682
 683                 dict_attr_free(&da); /* for unknown attributes hack */
 684
 685                 p += 2 + p[1];  /* code (1) + len (1) + suboption len (n)*/
 686         }
 687
 688         /*
 689          *      The caller allocated a TLV, if decoding it generated
 690          *      additional attributes, we now need to free it, and write
 691          *      the HEAD of our new list of attributes in its place.
 692          */
 693         if (head) {
 694                 vp_cursor_t tlv_cursor;
 695
 696                 /*
 697                  *      Free the old TLV attribute
 698                  */
 699                 TALLOC_FREE(*tlv);
 700
 701                 /*
 702                  *      Cursor not necessary but means we don't have to set
 703                  *      ->next directly.
 704                  */
 705                 fr_cursor_init(&tlv_cursor, tlv);
 706                 fr_cursor_merge(&tlv_cursor, head);
 707         }
 708
 709         return 0;
 710
 711 malformed:
 712         fr_pair_to_unknown(*tlv);
 713         fr_pair_value_memcpy(*tlv, data, len);
 714
 715         return 0;
 716 }
 717
 718 /*
 719  *      Decode ONE value into a VP
 720  */
 721 static int fr_dhcp_attr2vp(TALLOC_CTX *ctx, VALUE_PAIR **vp_p, uint8_t const *data, size_t len)
 722 {
 723         VALUE_PAIR *vp = *vp_p;
 724         VERIFY_VP(vp);
 725
 726         switch (vp->da->type) {
 727         case PW_TYPE_BYTE:
 728                 if (len != 1) goto raw;
 729                 vp->vp_byte = data[0];
 730                 break;
 731
 732         case PW_TYPE_SHORT:
 733                 if (len != 2) goto raw;
 734                 memcpy(&vp->vp_short, data, 2);
 735                 vp->vp_short = ntohs(vp->vp_short);
 736                 break;
 737
 738         case PW_TYPE_INTEGER:
 739                 if (len != 4) goto raw;
 740                 memcpy(&vp->vp_integer, data, 4);
 741                 vp->vp_integer = ntohl(vp->vp_integer);
 742                 break;
 743
 744         case PW_TYPE_IPV4_ADDR:
 745                 if (len != 4) goto raw;
 746                 /*
 747                  *      Keep value in Network Order!
 748                  */
 749                 memcpy(&vp->vp_ipaddr, data, 4);
 750                 vp->vp_length = 4;
 751                 break;
 752
 753         /*
 754          *      In DHCPv4, string options which can also be arrays,
 755          *      have their values '\0' delimited.
 756          */
 757         case PW_TYPE_STRING:
 758         {
 759                 uint8_t const *p;
 760                 uint8_t const *q, *end;
 761                 vp_cursor_t cursor;
 762
 763                 p = data;
 764                 q = end = data + len;
 765
 766                 if (!vp->da->flags.array) {
 767                         fr_pair_value_bstrncpy(vp, (char const *)p, q - p);
 768                         break;
 769                 }
 770
 771                 /*
 772                  *      Initialise the cursor as we may be inserting
 773                  *      multiple additional VPs
 774                  */
 775                 fr_cursor_init(&cursor, vp_p);
 776                 for (;;) {
 777                         q = memchr(p, '\0', q - p);
 778                         /* Malformed but recoverable */
 779                         if (!q) q = end;
 780
 781                         fr_pair_value_bstrncpy(vp, (char const *)p, q - p);
 782                         p = q + 1;
 783
 784                         /* Need another VP for the next round */
 785                         if (p < end) {
 786                                 vp = fr_pair_afrom_da(ctx, vp->da);
 787                                 if (!vp) {
 788                                         fr_pair_list_free(vp_p);
 789                                         return -1;
 790                                 }
 791                                 fr_cursor_insert(&cursor, vp);
 792                                 continue;
 793                         }
 794                         break;
 795                 }
 796         }
 797                 break;
 798
 799         case PW_TYPE_ETHERNET:
 800                 memcpy(vp->vp_ether, data, sizeof(vp->vp_ether));
 801                 vp->vp_length = sizeof(vp->vp_ether);
 802                 break;
 803
 804         /*
 805          *      Value doesn't match up with attribute type, overwrite the
 806          *      vp's original DICT_ATTR with an unknown one.
 807          */
 808         raw:
 809                 if (fr_pair_to_unknown(vp) < 0) return -1;
 810
 811         case PW_TYPE_OCTETS:
 812                 if (len > 255) return -1;
 813                 fr_pair_value_memcpy(vp, data, len);
 814                 break;
 815
 816         /*
 817          *      For option 82 et al...
 818          */
 819         case PW_TYPE_TLV:
 820                 return fr_dhcp_decode_suboption(ctx, vp_p, data, len);
 821
 822         default:
 823                 fr_strerror_printf("Internal sanity check %d %d", vp->da->type, __LINE__);
 824                 return -1;
 825         } /* switch over type */
 826
 827         vp->vp_length = len;
 828         return 0;
 829 }
 830
 831 /** Decode DHCP options
 832  *
 833  * @param[in,out] out Where to write the decoded options.
 834  * @param[in] ctx context to alloc new attributes in.
 835  * @param[in] data to parse.
 836  * @param[in] len of data to parse.
 837  */
 838 ssize_t fr_dhcp_decode_options(TALLOC_CTX *ctx, VALUE_PAIR **out, uint8_t const *data, size_t len)
 839 {
 840         VALUE_PAIR *vp;
 841         vp_cursor_t cursor;
 842         uint8_t const *p, *q;
 843
 844         *out = NULL;
 845         fr_cursor_init(&cursor, out);
 846
 847         /*
 848          *      FIXME: This should also check sname && file fields.
 849          *      See the dhcp_get_option() function above.
 850          */
 851         p = data;
 852         q = data + len;
 853         while (p < q) {
 854                 uint8_t const   *a_p;
 855                 size_t          a_len;
 856                 int             num_entries, i;
 857
 858                 DICT_ATTR const *da;
 859
 860                 if (*p == 0) {          /* 0x00 - Padding option */
 861                         p++;
 862                         continue;
 863                 }
 864
 865                 if (*p == 255) {        /* 0xff - End of options signifier */
 866                         break;
 867                 }
 868
 869                 if ((p + 2) > q) break;
 870
 871                 a_len = p[1];
 872                 a_p = p + 2;
 873
 874                 /*
 875                  *      Unknown attribute, create an octets type
 876                  *      attribute with the contents of the sub-option.
 877                  */
 878                 da = dict_attrbyvalue(p[0], DHCP_MAGIC_VENDOR);
 879                 if (!da) {
 880                         da = dict_unknown_afrom_fields(ctx, p[0], DHCP_MAGIC_VENDOR);
 881                         if (!da) {
 882                                 fr_pair_list_free(out);
 883                                 return -1;
 884                         }
 885                         vp = fr_pair_afrom_da(ctx, da);
 886                         if (!vp) {
 887                                 fr_pair_list_free(out);
 888                                 return -1;
 889                         }
 890                         fr_pair_value_memcpy(vp, a_p, a_len);
 891                         fr_cursor_insert(&cursor, vp);
 892
 893                         goto next;
 894                 }
 895
 896                 /*
 897                  *      Array type sub-option create a new VALUE_PAIR
 898                  *      for each array element.
 899                  */
 900                 num_entries = fr_dhcp_array_members(&a_len, da);
 901                 for (i = 0; i < num_entries; i++) {
 902                         vp = fr_pair_afrom_da(ctx, da);
 903                         if (!vp) {
 904                                 fr_pair_list_free(out);
 905                                 return -1;
 906                         }
 907                         vp->op = T_OP_EQ;
 908
 909                         if (fr_dhcp_attr2vp(ctx, &vp, a_p, a_len) < 0) {
 910                                 fr_pair_list_free(&vp);
 911                                 fr_pair_list_free(out);
 912                                 return -1;
 913                         }
 914                         fr_cursor_merge(&cursor, vp);
 915                         a_p += a_len;
 916                 } /* loop over array entries */
 917         next:
 918                 p += 2 + p[1];  /* code (1) + len (1) + option len (n)*/
 919         } /* loop over the entire packet */
 920
 921         return p - data;
 922 }
 923
 924 int fr_dhcp_decode(RADIUS_PACKET *packet)
 925 {
 926         size_t i;
 927         uint8_t *p;
 928         uint32_t giaddr;
 929         vp_cursor_t cursor;
 930         VALUE_PAIR *head = NULL, *vp;
 931         VALUE_PAIR *maxms, *mtu;
 932
 933         fr_cursor_init(&cursor, &head);
 934         p = packet->data;
 935
 936         if ((fr_debug_lvl > 2) && fr_log_fp) {
 937                 for (i = 0; i < packet->data_len; i++) {
 938                         if ((i & 0x0f) == 0x00) fprintf(fr_log_fp, "%d: ", (int) i);
 939                         fprintf(fr_log_fp, "%02x ", packet->data[i]);
 940                         if ((i & 0x0f) == 0x0f) fprintf(fr_log_fp, "\n");
 941                 }
 942                 fprintf(fr_log_fp, "\n");
 943         }
 944
 945         if (packet->data[1] > 1) {
 946                 fr_strerror_printf("Packet is not Ethernet: %u",
 947                       packet->data[1]);
 948                 return -1;
 949         }
 950
 951         /*
 952          *      Decode the header.
 953          */
 954         for (i = 0; i < 14; i++) {
 955                 char *q;
 956
 957                 vp = fr_pair_make(packet, NULL, dhcp_header_names[i], NULL, T_OP_EQ);
 958                 if (!vp) {
 959                         char buffer[256];
 960                         strlcpy(buffer, fr_strerror(), sizeof(buffer));
 961                         fr_strerror_printf("Cannot decode packet due to internal error: %s", buffer);
 962                         fr_pair_list_free(&head);
 963                         return -1;
 964                 }
 965
 966                 /*
 967                  *      If chaddr != 6 bytes it's probably not ethernet, and we should store
 968                  *      it as an opaque type (octets).
 969                  */
 970                 if (i == 11) {
 971                         /*
 972                          *      Skip chaddr if it doesn't exist.
 973                          */
 974                         if ((packet->data[1] == 0) || (packet->data[2] == 0)) continue;
 975
 976                         if ((packet->data[1] == 1) && (packet->data[2] != sizeof(vp->vp_ether))) {
 977                                 DICT_ATTR const *da = dict_unknown_afrom_fields(packet, vp->da->attr, vp->da->vendor);
 978                                 if (!da) {
 979                                         return -1;
 980                                 }
 981                                 vp->da = da;
 982                         }
 983                 }
 984
 985                 switch (vp->da->type) {
 986                 case PW_TYPE_BYTE:
 987                         vp->vp_byte = p[0];
 988                         vp->vp_length = 1;
 989                         break;
 990
 991                 case PW_TYPE_SHORT:
 992                         vp->vp_short = (p[0] << 8) | p[1];
 993                         vp->vp_length = 2;
 994                         break;
 995
 996                 case PW_TYPE_INTEGER:
 997                         memcpy(&vp->vp_integer, p, 4);
 998                         vp->vp_integer = ntohl(vp->vp_integer);
 999                         vp->vp_length = 4;
1000                         break;
1001
1002                 case PW_TYPE_IPV4_ADDR:
1003                         memcpy(&vp->vp_ipaddr, p, 4);
1004                         vp->vp_length = 4;
1005                         break;
1006
1007                 case PW_TYPE_STRING:
1008                         vp->vp_strvalue = q = talloc_array(vp, char, dhcp_header_sizes[i] + 1);
1009                         vp->type = VT_DATA;
1010                         memcpy(q, p, dhcp_header_sizes[i]);
1011                         q[dhcp_header_sizes[i]] = '\0';
1012                         vp->vp_length = strlen(vp->vp_strvalue);
1013                         if (vp->vp_length == 0) {
1014                                 fr_pair_list_free(&vp);
1015                         }
1016                         break;
1017
1018                 case PW_TYPE_OCTETS:
1019                         if (packet->data[2] == 0) break;
1020
1021                         fr_pair_value_memcpy(vp, p, packet->data[2]);
1022                         break;
1023
1024                 case PW_TYPE_ETHERNET:
1025                         memcpy(vp->vp_ether, p, sizeof(vp->vp_ether));
1026                         vp->vp_length = sizeof(vp->vp_ether);
1027                         break;
1028
1029                 default:
1030                         fr_strerror_printf("BAD TYPE %d", vp->da->type);
1031                         fr_pair_list_free(&vp);
1032                         break;
1033                 }
1034                 p += dhcp_header_sizes[i];
1035
1036                 if (!vp) continue;
1037
1038                 debug_pair(vp);
1039                 fr_cursor_insert(&cursor, vp);
1040         }
1041
1042         /*
1043          *      Loop over the options.
1044          */
1045
1046         /*
1047          *      Nothing uses tail after this call, if it does in the future
1048          *      it'll need to find the new tail...
1049          */
1050         {
1051                 VALUE_PAIR *options = NULL;
1052                 vp_cursor_t options_cursor;
1053
1054                 if (fr_dhcp_decode_options(packet, &options, packet->data + 240, packet->data_len - 240) < 0) {
1055                         return -1;
1056                 }
1057
1058                 if (options) {
1059                         for (vp = fr_cursor_init(&options_cursor, &options);
1060                              vp;
1061                              vp = fr_cursor_next(&options_cursor)) {
1062                                 debug_pair(vp);
1063                         }
1064                         fr_cursor_merge(&cursor, options);
1065                 }
1066         }
1067
1068         /*
1069          *      If DHCP request, set ciaddr to zero.
1070          */
1071
1072         /*
1073          *      Set broadcast flag for broken vendors, but only if
1074          *      giaddr isn't set.
1075          */
1076         memcpy(&giaddr, packet->data + 24, sizeof(giaddr));
1077         if (giaddr == htonl(INADDR_ANY)) {
1078                 /*
1079                  *      DHCP Opcode is request
1080                  */
1081                 vp = fr_pair_find_by_num(head, 256, DHCP_MAGIC_VENDOR, TAG_ANY);
1082                 if (vp && vp->vp_integer == 3) {
1083                         /*
1084                          *      Vendor is "MSFT 98"
1085                          */
1086                         vp = fr_pair_find_by_num(head, 63, DHCP_MAGIC_VENDOR, TAG_ANY);
1087                         if (vp && (strcmp(vp->vp_strvalue, "MSFT 98") == 0)) {
1088                                 vp = fr_pair_find_by_num(head, 262, DHCP_MAGIC_VENDOR, TAG_ANY);
1089
1090                                 /*
1091                                  *      Reply should be broadcast.
1092                                  */
1093                                 if (vp) vp->vp_short |= 0x8000;
1094                                 packet->data[10] |= 0x80;
1095                         }
1096                 }
1097         }
1098
1099         /*
1100          *      FIXME: Nuke attributes that aren't used in the normal
1101          *      header for discover/requests.
1102          */
1103         packet->vps = head;
1104
1105         /*
1106          *      Client can request a LARGER size, but not a smaller
1107          *      one.  They also cannot request a size larger than MTU.
1108          */
1109         maxms = fr_pair_find_by_num(packet->vps, 57, DHCP_MAGIC_VENDOR, TAG_ANY);
1110         mtu = fr_pair_find_by_num(packet->vps, 26, DHCP_MAGIC_VENDOR, TAG_ANY);
1111
1112         if (mtu && (mtu->vp_integer < DEFAULT_PACKET_SIZE)) {
1113                 fr_strerror_printf("DHCP Fatal: Client says MTU is smaller than minimum permitted by the specification");
1114                 return -1;
1115         }
1116
1117         if (maxms && (maxms->vp_integer < DEFAULT_PACKET_SIZE)) {
1118                 fr_strerror_printf("DHCP WARNING: Client says maximum message size is smaller than minimum permitted by the specification: fixing it");
1119                 maxms->vp_integer = DEFAULT_PACKET_SIZE;
1120         }
1121
1122         if (maxms && mtu && (maxms->vp_integer > mtu->vp_integer)) {
1123                 fr_strerror_printf("DHCP WARNING: Client says MTU is smaller than maximum message size: fixing it");
1124                 maxms->vp_integer = mtu->vp_integer;
1125         }
1126
1127         if (fr_debug_lvl) fflush(stdout);
1128
1129         return 0;
1130 }
1131
1132
1133 int8_t fr_dhcp_attr_cmp(void const *a, void const *b)
1134 {
1135         VALUE_PAIR const *my_a = a;
1136         VALUE_PAIR const *my_b = b;
1137
1138         VERIFY_VP(my_a);
1139         VERIFY_VP(my_b);
1140
1141         /*
1142          *      DHCP-Message-Type is first, for simplicity.
1143          */
1144         if ((my_a->da->attr == 53) && (my_b->da->attr != 53)) return -1;
1145
1146         /*
1147          *      Relay-Agent is last
1148          */
1149         if ((my_a->da->attr == 82) && (my_b->da->attr != 82)) return 1;
1150
1151         if (my_a->da->attr < my_b->da->attr) return -1;
1152         if (my_a->da->attr > my_b->da->attr) return 1;
1153
1154         return 0;
1155 }
1156
1157 /** Write DHCP option value into buffer
1158  *
1159  * Does not include DHCP option length or number.
1160  *
1161  * @param out where to write the DHCP option.
1162  * @param outlen length of output buffer.
1163  * @param vp option to encode.
1164  * @return the length of data writen, -1 if out of buffer, -2 if unsupported type.
1165  */
1166 static ssize_t fr_dhcp_vp2data(uint8_t *out, size_t outlen, VALUE_PAIR *vp)
1167 {
1168         uint32_t lvalue;
1169         uint8_t *p = out;
1170
1171         if (outlen < vp->vp_length) {
1172                 return -1;
1173         }
1174
1175         switch (vp->da->type) {
1176         case PW_TYPE_BYTE:
1177                 *p = vp->vp_byte;
1178                 break;
1179
1180         case PW_TYPE_SHORT:
1181                 p[0] = (vp->vp_short >> 8) & 0xff;
1182                 p[1] = vp->vp_short & 0xff;
1183                 break;
1184
1185         case PW_TYPE_INTEGER:
1186                 lvalue = htonl(vp->vp_integer);
1187                 memcpy(p, &lvalue, 4);
1188                 break;
1189
1190         case PW_TYPE_IPV4_ADDR:
1191                 memcpy(p, &vp->vp_ipaddr, 4);
1192                 break;
1193
1194         case PW_TYPE_ETHERNET:
1195                 memcpy(p, vp->vp_ether, 6);
1196                 break;
1197
1198         case PW_TYPE_STRING:
1199                 memcpy(p, vp->vp_strvalue, vp->vp_length);
1200                 break;
1201
1202         case PW_TYPE_OCTETS:
1203                 memcpy(p, vp->vp_octets, vp->vp_length);
1204                 break;
1205
1206         default:
1207                 fr_strerror_printf("Unsupported option type %d", vp->da->type);
1208                 return -2;
1209         }
1210
1211         return vp->vp_length;
1212 }
1213
1214 /** Create a new TLV attribute from multiple sub options
1215  *
1216  * @param[in,out] out buffer to write the data
1217  * @param[out] outlen length of the output buffer
1218  * @param[in,out] cursor should be set to the start of the list of TLV attributes.
1219  *   Will be advanced to the first non-TLV attribute.
1220  * @return length of data encoded, or -1 on error
1221  */
1222 static ssize_t fr_dhcp_vp2data_tlv(uint8_t *out, ssize_t outlen, vp_cursor_t *cursor)
1223 {
1224         ssize_t len;
1225         unsigned int parent;    /* Parent attribute of suboption */
1226         uint8_t attr = 0;
1227         uint8_t *p, *opt_len;
1228         vp_cursor_t tlv_cursor;
1229         VALUE_PAIR *vp;
1230
1231 #define SUBOPTION_PARENT(_x) (_x & 0xffff00ff)
1232 #define SUBOPTION_ATTR(_x) ((_x & 0xff00) >> 8)
1233
1234         vp = fr_cursor_current(cursor);
1235         if (!vp) return -1;
1236
1237         parent = SUBOPTION_PARENT(vp->da->attr);
1238
1239         /*
1240          *      Remember where we started off.
1241          */
1242         fr_cursor_copy(&tlv_cursor, cursor);
1243
1244         /*
1245          *      Loop over TLVs to determine how much memory we need to allocate
1246          *
1247          *      We advanced the tlv_cursor we were passed, so if we
1248          *      fail encoding, the tlv_cursor is at the right position
1249          *      for the next potentially encodable attr.
1250          */
1251         len = 0;
1252         for (vp = fr_cursor_current(&tlv_cursor);
1253              vp && vp->da->flags.is_tlv && (SUBOPTION_PARENT(vp->da->attr) == parent);
1254              vp = fr_cursor_next(&tlv_cursor)) {
1255                 if (SUBOPTION_ATTR(vp->da->attr) == 0) {
1256                         fr_strerror_printf("Invalid attribute number 0");
1257                         return -1;
1258                 }
1259
1260                 /*
1261                  *      If it's not an array type or is an array type,
1262                  *      but is not the same as the previous attribute,
1263                  *      we add 2 for the additional sub-option header
1264                  *      bytes.
1265                  */
1266                 if (!vp->da->flags.array || (SUBOPTION_ATTR(vp->da->attr) != attr)) {
1267                         attr = SUBOPTION_ATTR(vp->da->attr);
1268                         len += 2;
1269                 }
1270                 len += vp->vp_length;
1271         }
1272
1273         if (len > outlen) {
1274                 fr_strerror_printf("Insufficient room for suboption");
1275                 return -1;
1276         }
1277
1278         attr = 0;
1279         opt_len = NULL;
1280         p = out;
1281
1282         for (vp = fr_cursor_current(cursor);
1283              vp && vp->da->flags.is_tlv && (SUBOPTION_PARENT(vp->da->attr) == parent);
1284              vp = fr_cursor_next(cursor)) {
1285                 /* Don't write out the header, were packing array options */
1286                 if (!opt_len || !vp->da->flags.array || (attr != SUBOPTION_ATTR(vp->da->attr))) {
1287                         attr = SUBOPTION_ATTR(vp->da->attr);
1288                         *p++ = attr;
1289                         opt_len = p++;
1290                         *opt_len = 0;
1291                 }
1292
1293                 len = fr_dhcp_vp2data(p, out + outlen - p, vp);
1294                 if ((len < 0) || (len > 255)) {
1295                         return -1;
1296                 }
1297
1298                 debug_pair(vp);
1299                 *opt_len += len;
1300                 p += len;
1301         };
1302
1303         return p - out;
1304 }
1305
1306 /** Encode a DHCP option and any sub-options.
1307  *
1308  * @param out Where to write encoded DHCP attributes.
1309  * @param outlen Length of out buffer.
1310  * @param ctx to use for any allocated memory.
1311  * @param cursor with current VP set to the option to be encoded. Will be advanced to the next option to encode.
1312  * @return > 0 length of data written, < 0 error, 0 not valid option (skipping).
1313  */
1314 ssize_t fr_dhcp_encode_option(UNUSED TALLOC_CTX *ctx, uint8_t *out, size_t outlen, vp_cursor_t *cursor)
1315 {
1316         VALUE_PAIR *vp;
1317         DICT_ATTR const *previous;
1318         uint8_t *opt_len, *p = out;
1319         size_t freespace = outlen;
1320         ssize_t len;
1321
1322         vp = fr_cursor_current(cursor);
1323         if (!vp) return -1;
1324
1325         if (vp->da->vendor != DHCP_MAGIC_VENDOR) goto next; /* not a DHCP option */
1326         if (vp->da->attr == 53) goto next; /* already done */
1327         if ((vp->da->attr > 255) && (DHCP_BASE_ATTR(vp->da->attr) != PW_DHCP_OPTION_82)) goto next;
1328
1329         if (vp->da->flags.extended) {
1330         next:
1331                 fr_strerror_printf("Attribute \"%s\" is not a DHCP option", vp->da->name);
1332                 fr_cursor_next(cursor);
1333                 return 0;
1334         }
1335
1336         /* Write out the option number */
1337         *(p++) = vp->da->attr & 0xff;
1338
1339         /* Pointer to the length field of the option */
1340         opt_len = p++;
1341
1342         /* Zero out the option's length field */
1343         *opt_len = 0;
1344
1345         /* We just consumed two bytes for the header */
1346         freespace -= 2;
1347
1348         /* DHCP options with the same number get coalesced into a single option */
1349         do {
1350                 /*
1351                  *      Sub-option encoder will encode the data and
1352                  *      advance the cursor.
1353                  */
1354                 if (vp->da->flags.is_tlv) {
1355                         len = fr_dhcp_vp2data_tlv(p, freespace, cursor);
1356                         previous = NULL;
1357
1358                 } else {
1359                         len = fr_dhcp_vp2data(p, freespace, vp);
1360                         if (len >= 0) debug_pair(vp);
1361                         fr_cursor_next(cursor);
1362                         previous = vp->da;
1363                 }
1364
1365                 if (len < 0) return len;
1366
1367                 if ((*opt_len + len) > 255) {
1368                         fr_strerror_printf("Skipping \"%s\": Option splitting not supported "
1369                                            "(option > 255 bytes)", vp->da->name);
1370                         return 0;
1371                 }
1372
1373                 p += len;
1374                 *opt_len += len;
1375                 freespace -= len;
1376
1377         } while ((vp = fr_cursor_current(cursor)) && previous && (previous == vp->da) && vp->da->flags.array);
1378
1379         return p - out;
1380 }
1381
1382 int fr_dhcp_encode(RADIUS_PACKET *packet)
1383 {
1384         unsigned int i;
1385         uint8_t *p;
1386         vp_cursor_t cursor;
1387         VALUE_PAIR *vp;
1388         uint32_t lvalue;
1389         uint16_t        svalue;
1390         size_t dhcp_size;
1391         ssize_t len;
1392 #ifndef NDEBUG
1393         char const *name;
1394 #  ifdef WITH_UDPFROMTO
1395         char src_ip_buf[256];
1396 #  endif
1397         char dst_ip_buf[256];
1398 #endif
1399
1400         if (packet->data) return 0;
1401
1402         packet->data_len = MAX_PACKET_SIZE;
1403         packet->data = talloc_zero_array(packet, uint8_t, packet->data_len);
1404
1405         /* XXX Ugly ... should be set by the caller */
1406         if (packet->code == 0) packet->code = PW_DHCP_NAK;
1407
1408         /* store xid */
1409         if ((vp = fr_pair_find_by_num(packet->vps, 260, DHCP_MAGIC_VENDOR, TAG_ANY))) {
1410                 packet->id = vp->vp_integer;
1411         } else {
1412                 packet->id = fr_rand();
1413         }
1414
1415 #ifndef NDEBUG
1416         if ((packet->code >= PW_DHCP_DISCOVER) &&
1417             (packet->code < (1024 + DHCP_MAX_MESSAGE_TYPE))) {
1418                 name = dhcp_message_types[packet->code - PW_DHCP_OFFSET];
1419         } else {
1420                 name = "?Unknown?";
1421         }
1422
1423         DEBUG(
1424 #  ifdef WITH_UDPFROMTO
1425               "Encoding %s of id %08x from %s:%d to %s:%d\n",
1426 #  else
1427               "Encoding %s of id %08x to %s:%d\n",
1428 #  endif
1429               name, (unsigned int) packet->id,
1430 #  ifdef WITH_UDPFROMTO
1431               inet_ntop(packet->src_ipaddr.af,
1432                         &packet->src_ipaddr.ipaddr,
1433                         src_ip_buf, sizeof(src_ip_buf)),
1434               packet->src_port,
1435 #  endif
1436               inet_ntop(packet->dst_ipaddr.af,
1437                         &packet->dst_ipaddr.ipaddr,
1438                      dst_ip_buf, sizeof(dst_ip_buf)),
1439               packet->dst_port);
1440 #endif
1441
1442         p = packet->data;
1443
1444         /*
1445          *      @todo: Make this work again.
1446          */
1447 #if 0
1448         mms = DEFAULT_PACKET_SIZE; /* maximum message size */
1449
1450         /*
1451          *      Clients can request a LARGER size, but not a
1452          *      smaller one.  They also cannot request a size
1453          *      larger than MTU.
1454          */
1455
1456         /* DHCP-DHCP-Maximum-Msg-Size */
1457         vp = fr_pair_find_by_num(packet->vps, 57, DHCP_MAGIC_VENDOR, TAG_ANY);
1458         if (vp && (vp->vp_integer > mms)) {
1459                 mms = vp->vp_integer;
1460
1461                 if (mms > MAX_PACKET_SIZE) mms = MAX_PACKET_SIZE;
1462         }
1463 #endif
1464
1465         vp = fr_pair_find_by_num(packet->vps, 256, DHCP_MAGIC_VENDOR, TAG_ANY);
1466         if (vp) {
1467                 *p++ = vp->vp_integer & 0xff;
1468         } else {
1469                 *p++ = 1;       /* client message */
1470         }
1471
1472         /* DHCP-Hardware-Type */
1473         if ((vp = fr_pair_find_by_num(packet->vps, 257, DHCP_MAGIC_VENDOR, TAG_ANY))) {
1474                 *p++ = vp->vp_byte;
1475         } else {
1476                 *p++ = 1;               /* hardware type = ethernet */
1477         }
1478
1479         /* DHCP-Hardware-Address-Length */
1480         if ((vp = fr_pair_find_by_num(packet->vps, 258, DHCP_MAGIC_VENDOR, TAG_ANY))) {
1481                 *p++ = vp->vp_byte;
1482         } else {
1483                 *p++ = 6;               /* 6 bytes of ethernet */
1484         }
1485
1486         /* DHCP-Hop-Count */
1487         if ((vp = fr_pair_find_by_num(packet->vps, 259, DHCP_MAGIC_VENDOR, TAG_ANY))) {
1488                 *p = vp->vp_byte;
1489         }
1490         p++;
1491
1492         /* DHCP-Transaction-Id */
1493         lvalue = htonl(packet->id);
1494         memcpy(p, &lvalue, 4);
1495         p += 4;
1496
1497         /* DHCP-Number-of-Seconds */
1498         if ((vp = fr_pair_find_by_num(packet->vps, 261, DHCP_MAGIC_VENDOR, TAG_ANY))) {
1499                 svalue = htons(vp->vp_short);
1500                 memcpy(p, &svalue, 2);
1501         }
1502         p += 2;
1503
1504         /* DHCP-Flags */
1505         if ((vp = fr_pair_find_by_num(packet->vps, 262, DHCP_MAGIC_VENDOR, TAG_ANY))) {
1506                 svalue = htons(vp->vp_short);
1507                 memcpy(p, &svalue, 2);
1508         }
1509         p += 2;
1510
1511         /* DHCP-Client-IP-Address */
1512         if ((vp = fr_pair_find_by_num(packet->vps, 263, DHCP_MAGIC_VENDOR, TAG_ANY))) {
1513                 memcpy(p, &vp->vp_ipaddr, 4);
1514         }
1515         p += 4;
1516
1517         /* DHCP-Your-IP-address */
1518         if ((vp = fr_pair_find_by_num(packet->vps, 264, DHCP_MAGIC_VENDOR, TAG_ANY))) {
1519                 lvalue = vp->vp_ipaddr;
1520         } else {
1521                 lvalue = htonl(INADDR_ANY);
1522         }
1523         memcpy(p, &lvalue, 4);
1524         p += 4;
1525
1526         /* DHCP-Server-IP-Address */
1527         vp = fr_pair_find_by_num(packet->vps, 265, DHCP_MAGIC_VENDOR, TAG_ANY);
1528         if (vp) {
1529                 lvalue = vp->vp_ipaddr;
1530         } else {
1531                 lvalue = htonl(INADDR_ANY);
1532         }
1533         memcpy(p, &lvalue, 4);
1534         p += 4;
1535
1536         /*
1537          *      DHCP-Gateway-IP-Address
1538          */
1539         if ((vp = fr_pair_find_by_num(packet->vps, 266, DHCP_MAGIC_VENDOR, TAG_ANY))) {
1540                 lvalue = vp->vp_ipaddr;
1541         } else {
1542                 lvalue = htonl(INADDR_ANY);
1543         }
1544         memcpy(p, &lvalue, 4);
1545         p += 4;
1546
1547         /* DHCP-Client-Hardware-Address */
1548         if ((vp = fr_pair_find_by_num(packet->vps, 267, DHCP_MAGIC_VENDOR, TAG_ANY))) {
1549                 if (vp->vp_length == sizeof(vp->vp_ether)) {
1550                         /*
1551                          *      Ensure that we mark the packet as being Ethernet.
1552                          *      This is mainly for DHCP-Lease-Query responses.
1553                          */
1554                         packet->data[1] = 1;
1555                         packet->data[2] = 6;
1556
1557                         memcpy(p, vp->vp_ether, vp->vp_length);
1558                 } /* else ignore it */
1559         }
1560         p += DHCP_CHADDR_LEN;
1561
1562         /* DHCP-Server-Host-Name */
1563         if ((vp = fr_pair_find_by_num(packet->vps, 268, DHCP_MAGIC_VENDOR, TAG_ANY))) {
1564                 if (vp->vp_length > DHCP_SNAME_LEN) {
1565                         memcpy(p, vp->vp_strvalue, DHCP_SNAME_LEN);
1566                 } else {
1567                         memcpy(p, vp->vp_strvalue, vp->vp_length);
1568                 }
1569         }
1570         p += DHCP_SNAME_LEN;
1571
1572         /*
1573          *      Copy over DHCP-Boot-Filename.
1574          *
1575          *      FIXME: This copy should be delayed until AFTER the options
1576          *      have been processed.  If there are too many options for
1577          *      the packet, then they go into the sname && filename fields.
1578          *      When that happens, the boot filename is passed as an option,
1579          *      instead of being placed verbatim in the filename field.
1580          */
1581
1582         /* DHCP-Boot-Filename */
1583         vp = fr_pair_find_by_num(packet->vps, 269, DHCP_MAGIC_VENDOR, TAG_ANY);
1584         if (vp) {
1585                 if (vp->vp_length > DHCP_FILE_LEN) {
1586                         memcpy(p, vp->vp_strvalue, DHCP_FILE_LEN);
1587                 } else {
1588                         memcpy(p, vp->vp_strvalue, vp->vp_length);
1589                 }
1590         }
1591         p += DHCP_FILE_LEN;
1592
1593         /* DHCP magic number */
1594         lvalue = htonl(DHCP_OPTION_MAGIC_NUMBER);
1595         memcpy(p, &lvalue, 4);
1596         p += 4;
1597
1598         /*
1599          *      Print the header.
1600          */
1601         if (fr_debug_lvl > 1) {
1602                 uint8_t *pp = p;
1603
1604                 p = packet->data;
1605
1606                 for (i = 0; i < 14; i++) {
1607                         char *q;
1608
1609                         vp = fr_pair_make(packet, NULL,
1610                                       dhcp_header_names[i], NULL, T_OP_EQ);
1611                         if (!vp) {
1612                                 char buffer[256];
1613                                 strlcpy(buffer, fr_strerror(), sizeof(buffer));
1614                                 fr_strerror_printf("Cannot decode packet due to internal error: %s", buffer);
1615                                 return -1;
1616                         }
1617
1618                         switch (vp->da->type) {
1619                         case PW_TYPE_BYTE:
1620                                 vp->vp_byte = p[0];
1621                                 break;
1622
1623                         case PW_TYPE_SHORT:
1624                                 vp->vp_short = (p[0] << 8) | p[1];
1625                                 break;
1626
1627                         case PW_TYPE_INTEGER:
1628                                 memcpy(&vp->vp_integer, p, 4);
1629                                 vp->vp_integer = ntohl(vp->vp_integer);
1630                                 break;
1631
1632                         case PW_TYPE_IPV4_ADDR:
1633                                 memcpy(&vp->vp_ipaddr, p, 4);
1634                                 break;
1635
1636                         case PW_TYPE_STRING:
1637                                 vp->vp_strvalue = q = talloc_array(vp, char, dhcp_header_sizes[i] + 1);
1638                                 vp->type = VT_DATA;
1639                                 memcpy(q, p, dhcp_header_sizes[i]);
1640                                 q[dhcp_header_sizes[i]] = '\0';
1641                                 vp->vp_length = strlen(vp->vp_strvalue);
1642                                 break;
1643
1644                         case PW_TYPE_OCTETS: /* only for Client HW Address */
1645                                 fr_pair_value_memcpy(vp, p, packet->data[2]);
1646                                 break;
1647
1648                         case PW_TYPE_ETHERNET: /* only for Client HW Address */
1649                                 memcpy(vp->vp_ether, p, sizeof(vp->vp_ether));
1650                                 break;
1651
1652                         default:
1653                                 fr_strerror_printf("Internal sanity check failed %d %d", vp->da->type, __LINE__);
1654                                 fr_pair_list_free(&vp);
1655                                 break;
1656                         }
1657
1658                         p += dhcp_header_sizes[i];
1659
1660                         debug_pair(vp);
1661                         fr_pair_list_free(&vp);
1662                 }
1663
1664                 /*
1665                  *      Jump over DHCP magic number, response, etc.
1666                  */
1667                 p = pp;
1668         }
1669
1670         p[0] = 0x35;            /* DHCP-Message-Type */
1671         p[1] = 1;
1672         p[2] = packet->code - PW_DHCP_OFFSET;
1673         p += 3;
1674
1675         /*
1676          *  Pre-sort attributes into contiguous blocks so that fr_dhcp_encode_option
1677          *  operates correctly. This changes the order of the list, but never mind...
1678          */
1679         fr_pair_list_sort(&packet->vps, fr_dhcp_attr_cmp);
1680         fr_cursor_init(&cursor, &packet->vps);
1681
1682         /*
1683          *  Each call to fr_dhcp_encode_option will encode one complete DHCP option,
1684          *  and sub options.
1685          */
1686         while ((vp = fr_cursor_current(&cursor))) {
1687                 len = fr_dhcp_encode_option(packet, p, packet->data_len - (p - packet->data), &cursor);
1688                 if (len < 0) break;
1689                 p += len;
1690         };
1691
1692         p[0] = 0xff;            /* end of option option */
1693         p[1] = 0x00;
1694         p += 2;
1695         dhcp_size = p - packet->data;
1696
1697         /*
1698          *      FIXME: if (dhcp_size > mms),
1699          *        then we put the extra options into the "sname" and "file"
1700          *        fields, AND set the "end option option" in the "options"
1701          *        field.  We also set the "overload option",
1702          *        and put options into the "file" field, followed by
1703          *        the "sname" field.  Where each option is completely
1704          *        enclosed in the "file" and/or "sname" field, AND
1705          *        followed by the "end of option", and MUST be followed
1706          *        by padding option.
1707          *
1708          *      Yuck.  That sucks...
1709          */
1710         packet->data_len = dhcp_size;
1711
1712         if (packet->data_len < DEFAULT_PACKET_SIZE) {
1713                 memset(packet->data + packet->data_len, 0,
1714                        DEFAULT_PACKET_SIZE - packet->data_len);
1715                 packet->data_len = DEFAULT_PACKET_SIZE;
1716         }
1717
1718         if ((fr_debug_lvl > 2) && fr_log_fp) {
1719                 fprintf(fr_log_fp, "DHCP Sending %zu bytes\n", packet->data_len);
1720                 for (i = 0; i < packet->data_len; i++) {
1721                         if ((i & 0x0f) == 0x00) fprintf(fr_log_fp, "%d: ", (int) i);
1722                         fprintf(fr_log_fp, "%02x ", packet->data[i]);
1723                         if ((i & 0x0f) == 0x0f) fprintf(fr_log_fp, "\n");
1724                 }
1725                 fprintf(fr_log_fp, "\n");
1726         }
1727
1728         return 0;
1729 }
1730
1731 #ifdef SIOCSARP
1732 int fr_dhcp_add_arp_entry(int fd, char const *interface,
1733                           VALUE_PAIR *macaddr, VALUE_PAIR *ip)
1734 {
1735         struct sockaddr_in *sin;
1736         struct arpreq req;
1737
1738         if (!interface) {
1739                 fr_strerror_printf("No interface specified.  Cannot update ARP table");
1740                 return -1;
1741         }
1742
1743         if (!fr_assert(macaddr) ||
1744             !fr_assert((macaddr->da->type == PW_TYPE_ETHERNET) || (macaddr->da->type == PW_TYPE_OCTETS))) {
1745                 fr_strerror_printf("Wrong VP type (%s) for chaddr",
1746                                    fr_int2str(dict_attr_types, macaddr->da->type, "<invalid>"));
1747                 return -1;
1748         }
1749
1750         if (macaddr->vp_length > sizeof(req.arp_ha.sa_data)) {
1751                 fr_strerror_printf("arp sa_data field too small (%zu octets) to contain chaddr (%zu octets)",
1752                                    sizeof(req.arp_ha.sa_data), macaddr->vp_length);
1753                 return -1;
1754         }
1755
1756         memset(&req, 0, sizeof(req));
1757         sin = (struct sockaddr_in *) &req.arp_pa;
1758         sin->sin_family = AF_INET;
1759         sin->sin_addr.s_addr = ip->vp_ipaddr;
1760
1761         strlcpy(req.arp_dev, interface, sizeof(req.arp_dev));
1762
1763         if (macaddr->da->type == PW_TYPE_ETHERNET) {
1764                 memcpy(&req.arp_ha.sa_data, macaddr->vp_ether, sizeof(macaddr->vp_ether));
1765         } else {
1766                 memcpy(&req.arp_ha.sa_data, macaddr->vp_octets, macaddr->vp_length);
1767         }
1768
1769         req.arp_flags = ATF_COM;
1770         if (ioctl(fd, SIOCSARP, &req) < 0) {
1771                 fr_strerror_printf("Failed to add entry in ARP cache: %s (%d)", fr_syserror(errno), errno);
1772                 return -1;
1773         }
1774
1775         return 0;
1776 }
1777 #else
1778 int fr_dhcp_add_arp_entry(UNUSED int fd, UNUSED char const *interface,
1779                           UNUSED VALUE_PAIR *macaddr, UNUSED VALUE_PAIR *ip)
1780 {
1781         fr_strerror_printf("Adding ARP entry is unsupported on this system");
1782         return -1;
1783 }
1784 #endif
1785
1786
1787 #ifdef HAVE_LINUX_IF_PACKET_H
1788 /*
1789  *      Open a packet interface raw socket.
1790  *      Bind it to the specified interface using a device independent physical layer address.
1791  */
1792 int fr_socket_packet(int iface_index, struct sockaddr_ll *p_ll)
1793 {
1794         int lsockfd;
1795
1796         /* PF_PACKET - packet interface on device level.
1797            using a raw socket allows packet data to be unchanged by the device driver.
1798          */
1799         lsockfd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
1800         if (lsockfd < 0) {
1801                 fr_strerror_printf("cannot open socket: %s", fr_syserror(errno));
1802                 return lsockfd;
1803         }
1804
1805         /* Set link layer parameters */
1806         memset(p_ll, 0, sizeof(struct sockaddr_ll));
1807
1808         p_ll->sll_family = AF_PACKET;
1809         p_ll->sll_protocol = htons(ETH_P_ALL);
1810         p_ll->sll_ifindex = iface_index;
1811         p_ll->sll_hatype = ARPHRD_ETHER;
1812         p_ll->sll_pkttype = PACKET_OTHERHOST;
1813         p_ll->sll_halen = 6;
1814
1815         if (bind(lsockfd, (struct sockaddr *)p_ll, sizeof(struct sockaddr_ll)) < 0) {
1816                 close(lsockfd);
1817                 fr_strerror_printf("cannot bind raw socket: %s", fr_syserror(errno));
1818                 return -1;
1819         }
1820
1821         return lsockfd;
1822 }
1823
1824 /*
1825  *      Encode and send a DHCP packet on a raw packet socket.
1826  */
1827 int fr_dhcp_send_raw_packet(int sockfd, struct sockaddr_ll *p_ll, RADIUS_PACKET *packet)
1828 {
1829         VALUE_PAIR *vp;
1830         u_char dhcp_packet[1518] = { 0 };
1831
1832         /* set ethernet source address to our MAC address (DHCP-Client-Hardware-Address). */
1833         u_char dhmac[ETH_ADDR_LEN] = { 0 };
1834         if ((vp = fr_pair_find_by_num(packet->vps, 267, DHCP_MAGIC_VENDOR, TAG_ANY))) {
1835                 if (vp->length == sizeof(vp->vp_ether)) {
1836                         memcpy(dhmac, vp->vp_ether, vp->length);
1837                 }
1838         }
1839
1840         /* fill in Ethernet layer (L2) */
1841         struct ethernet_header *ethhdr = (struct ethernet_header *)dhcp_packet;
1842         memcpy(ethhdr->ether_dst, eth_bcast, ETH_ADDR_LEN);
1843         memcpy(ethhdr->ether_src, dhmac, ETH_ADDR_LEN);
1844         ethhdr->ether_type = htons(ETH_TYPE_IP);
1845
1846         /* fill in IP layer (L3) */
1847         struct ip_header *iph = (struct ip_header *)(dhcp_packet + ETH_HDR_SIZE);
1848         iph->ip_vhl = IP_VHL(4, 5);
1849         iph->ip_tos = 0;
1850         iph->ip_len = htons(IP_HDR_SIZE +  UDP_HDR_SIZE + packet->data_len);
1851         iph->ip_id = 0;
1852         iph->ip_off = 0;
1853         iph->ip_ttl = 64;
1854         iph->ip_p = 17;
1855         iph->ip_sum = 0; /* Filled later */
1856
1857         /* saddr: Packet-Src-IP-Address (default: 0.0.0.0). */
1858         iph->ip_src.s_addr = packet->src_ipaddr.ipaddr.ip4addr.s_addr;
1859
1860         /* daddr: packet destination IP addr (should be 255.255.255.255 for broadcast). */
1861         iph->ip_dst.s_addr = packet->dst_ipaddr.ipaddr.ip4addr.s_addr;
1862
1863         /* IP header checksum */
1864         iph->ip_sum = fr_iph_checksum((uint8_t const *)iph, 5);
1865
1866         /* fill in UDP layer (L4) */
1867         udp_header_t *uh = (udp_header_t *) (dhcp_packet + ETH_HDR_SIZE + IP_HDR_SIZE);
1868
1869         uh->src = htons(68);
1870         uh->dst = htons(67);
1871         u_int16_t l4_len = (UDP_HDR_SIZE + packet->data_len);
1872         uh->len = htons(l4_len);
1873         uh->checksum = 0; /* UDP checksum will be done after dhcp header */
1874
1875         /* DHCP layer (L7) */
1876         dhcp_packet_t *dhpointer = (dhcp_packet_t *)(dhcp_packet + ETH_HDR_SIZE + IP_HDR_SIZE + UDP_HDR_SIZE);
1877         /* just copy what FreeRADIUS has encoded for us. */
1878         memcpy(dhpointer, packet->data, packet->data_len);
1879
1880         /* UDP checksum is done here */
1881         uh->checksum = fr_udp_checksum((uint8_t const *)(dhcp_packet + ETH_HDR_SIZE + IP_HDR_SIZE), ntohs(uh->len), uh->checksum,
1882                                         packet->src_ipaddr.ipaddr.ip4addr, packet->dst_ipaddr.ipaddr.ip4addr);
1883
1884         if (fr_debug_lvl > 1) {
1885                 char type_buf[64];
1886                 char const *name = type_buf;
1887                 char src_ip_buf[INET6_ADDRSTRLEN];
1888                 char dst_ip_buf[INET6_ADDRSTRLEN];
1889
1890                 if ((packet->code >= PW_DHCP_DISCOVER) &&
1891                     (packet->code < (1024 + DHCP_MAX_MESSAGE_TYPE))) {
1892                         name = dhcp_message_types[packet->code - PW_DHCP_OFFSET];
1893                 } else {
1894                         snprintf(type_buf, sizeof(type_buf), "%d",
1895                             packet->code - PW_DHCP_OFFSET);
1896                 }
1897
1898                 DEBUG(
1899                 "Sending %s Id %08x from %s:%d to %s:%d\n",
1900                    name, (unsigned int) packet->id,
1901                    inet_ntop(packet->src_ipaddr.af, &packet->src_ipaddr.ipaddr, src_ip_buf, sizeof(src_ip_buf)), packet->src_port,
1902                    inet_ntop(packet->dst_ipaddr.af, &packet->dst_ipaddr.ipaddr, dst_ip_buf, sizeof(dst_ip_buf)), packet->dst_port);
1903         }
1904
1905         return sendto(sockfd, dhcp_packet,
1906                 (ETH_HDR_SIZE + IP_HDR_SIZE + UDP_HDR_SIZE + packet->data_len),
1907                 0, (struct sockaddr *) p_ll, sizeof(struct sockaddr_ll));
1908 }
1909
1910 /*
1911  *      print an ethernet address in a buffer
1912  */
1913 char * ether_addr_print(const uint8_t *addr, char *buf)
1914 {
1915         sprintf (buf, "%02x:%02x:%02x:%02x:%02x:%02x",
1916                 addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
1917         return buf;
1918 }
1919
1920 /*
1921  *      For a client, receive a DHCP packet from a raw packet
1922  *      socket. Make sure it matches the ongoing request.
1923  *
1924  *      FIXME: split this into two, recv_raw_packet, and verify(packet, original)
1925  */
1926 RADIUS_PACKET *fr_dhcp_recv_raw_packet(int sockfd, struct sockaddr_ll *p_ll, RADIUS_PACKET *request)
1927 {
1928         VALUE_PAIR              *vp;
1929         RADIUS_PACKET           *packet;
1930         uint8_t                 *code;
1931         uint32_t                magic, xid;
1932         ssize_t                 data_len;
1933
1934         uint8_t                 *raw_packet;
1935         ethernet_header_t       *eth_hdr;
1936         struct ip_header        *ip_hdr;
1937         udp_header_t            *udp_hdr;
1938         dhcp_packet_t           *dhcp_hdr;
1939         uint16_t                udp_src_port;
1940         uint16_t                udp_dst_port;
1941         size_t                  dhcp_data_len;
1942         int                     retval;
1943         socklen_t               sock_len;
1944         fd_set                  read_fd;
1945
1946         packet = rad_alloc(NULL, false);
1947         if (!packet) {
1948                 fr_strerror_printf("Failed allocating packet");
1949                 return NULL;
1950         }
1951
1952         raw_packet = talloc_zero_array(packet, uint8_t, MAX_PACKET_SIZE);
1953         if (!raw_packet) {
1954                 fr_strerror_printf("Out of memory");
1955                 rad_free(&packet);
1956                 return NULL;
1957         }
1958
1959         packet->sockfd = sockfd;
1960
1961         /* a packet was received (but maybe it is not for us) */
1962         sock_len = sizeof(struct sockaddr_ll);
1963         data_len = recvfrom(sockfd, raw_packet, MAX_PACKET_SIZE, 0,
1964                             (struct sockaddr *)p_ll, &sock_len);
1965
1966         uint8_t data_offset = ETH_HDR_SIZE + IP_HDR_SIZE + UDP_HDR_SIZE; // DHCP data starts after Ethernet, IP, UDP.
1967
1968         if (data_len <= data_offset) DISCARD_RP("Payload (%d) smaller than required for layers 2+3+4", (int)data_len);
1969
1970         /* map raw packet to packet header of the different layers (Ethernet, IP, UDP) */
1971         eth_hdr = (ethernet_header_t *)raw_packet;
1972
1973         /* a. Check Ethernet layer data (L2) */
1974         if (ntohs(eth_hdr->ether_type) != ETH_TYPE_IP) DISCARD_RP("Ethernet type (%d) != IP", ntohs(eth_hdr->ether_type));
1975
1976         /* If Ethernet destination is not broadcast (ff:ff:ff:ff:ff:ff)
1977          * Check if it matches the source HW address used (DHCP-Client-Hardware-Address = 267)
1978          */
1979         if ( (memcmp(&eth_bcast, &eth_hdr->ether_dst, ETH_ADDR_LEN) != 0) &&
1980                         (vp = fr_pair_find_by_num(request->vps, 267, DHCP_MAGIC_VENDOR, TAG_ANY)) &&
1981                         (vp->length == sizeof(vp->vp_ether)) &&
1982                         (memcmp(vp->vp_ether, &eth_hdr->ether_dst, ETH_ADDR_LEN) != 0) ) {
1983                 /* No match. */
1984                 char eth_dest[17+1];
1985                 char eth_req_src[17+1];
1986                 DISCARD_RP("Ethernet destination (%s) is not broadcast and doesn't match request source (%s)",
1987                         ether_addr_print(eth_hdr->ether_dst, eth_dest),
1988                         ether_addr_print(vp->vp_ether, eth_req_src));
1989         }
1990
1991         /*
1992          *      Ethernet is OK.  Now look at IP.
1993          */
1994         ip_hdr = (struct ip_header *)(raw_packet + ETH_HDR_SIZE);
1995
1996         /* b. Check IPv4 layer data (L3) */
1997         if (ip_hdr->ip_p != IPPROTO_UDP) DISCARD_RP("IP protocol (%d) != UDP", ip_hdr->ip_p);
1998
1999         /*
2000          *      note: checking the destination IP address is not
2001          *      useful (it would be the offered IP address - which we
2002          *      don't know beforehand, or the broadcast address).
2003          */
2004
2005         /*
2006          *      Now check UDP.
2007          */
2008         udp_hdr = (udp_header_t *)(raw_packet + ETH_HDR_SIZE + IP_HDR_SIZE);
2009
2010         /* c. Check UDP layer data (L4) */
2011         udp_src_port = ntohs(udp_hdr->src);
2012         udp_dst_port = ntohs(udp_hdr->dst);
2013
2014         /*
2015          *      A DHCP server will always respond to port 68 (to a
2016          *      client) or 67 (to a relay).  Just check that both
2017          *      ports are 67 or 68.
2018          */
2019         if (udp_src_port != 67 && udp_src_port != 68) DISCARD_RP("UDP src port (%d) != DHCP (67 or 68)", udp_src_port);
2020         if (udp_dst_port != 67 && udp_dst_port != 68) DISCARD_RP("UDP dst port (%d) != DHCP (67 or 68)", udp_dst_port);
2021
2022         /* d. Check DHCP layer data */
2023         dhcp_data_len = data_len - data_offset;
2024
2025         if (dhcp_data_len < MIN_PACKET_SIZE) DISCARD_RP("DHCP packet is too small (%d < %d)", dhcp_data_len, MIN_PACKET_SIZE);
2026         if (dhcp_data_len > MAX_PACKET_SIZE) DISCARD_RP("DHCP packet is too large (%d > %d)", dhcp_data_len, MAX_PACKET_SIZE);
2027
2028         dhcp_hdr = (dhcp_packet_t *)(raw_packet + ETH_HDR_SIZE + IP_HDR_SIZE + UDP_HDR_SIZE);
2029
2030         if (dhcp_hdr->htype != 1) DISCARD_RP("DHCP hardware type (%d) != Ethernet (1)", dhcp_hdr->htype);
2031         if (dhcp_hdr->hlen != 6) DISCARD_RP("DHCP hardware address length (%d) != 6", dhcp_hdr->hlen);
2032
2033         magic = ntohl(dhcp_hdr->option_format);
2034
2035         if (magic != DHCP_OPTION_MAGIC_NUMBER) DISCARD_RP("DHCP magic cookie (0x%04x) != DHCP (0x%04x)", magic, DHCP_OPTION_MAGIC_NUMBER);
2036
2037         /*
2038          *      Reply transaction id must match value from request.
2039          */
2040         xid = ntohl(dhcp_hdr->xid);
2041         if (xid != (uint32_t)request->id) DISCARD_RP("DHCP transaction ID (0x%04x) != xid from request (0x%04x)", xid, request->id)
2042
2043         /* all checks ok! this is a DHCP reply we're interested in. */
2044         packet->data_len = dhcp_data_len;
2045         packet->data = talloc_memdup(packet, raw_packet + data_offset, dhcp_data_len);
2046         TALLOC_FREE(raw_packet);
2047         packet->id = xid;
2048
2049         code = dhcp_get_option((dhcp_packet_t *) packet->data,
2050                                packet->data_len, 53);
2051         if (!code) {
2052                 fr_strerror_printf("No message-type option was found in the packet");
2053                 rad_free(&packet);
2054                 return NULL;
2055         }
2056
2057         if ((code[1] < 1) || (code[2] == 0) || (code[2] > 8)) {
2058                 fr_strerror_printf("Unknown value for message-type option");
2059                 rad_free(&packet);
2060                 return NULL;
2061         }
2062
2063         packet->code = code[2] | PW_DHCP_OFFSET;
2064
2065         /*
2066          *      Create a unique vector from the MAC address and the
2067          *      DHCP opcode.  This is a hack for the RADIUS
2068          *      infrastructure in the rest of the server.
2069          *
2070          *      Note: packet->data[2] == 6, which is smaller than
2071          *      sizeof(packet->vector)
2072          *
2073          *      FIXME:  Look for client-identifier in packet,
2074          *      and use that, too?
2075          */
2076         memset(packet->vector, 0, sizeof(packet->vector));
2077         memcpy(packet->vector, packet->data + 28, packet->data[2]);
2078         packet->vector[packet->data[2]] = packet->code & 0xff;
2079
2080         packet->src_port = udp_src_port;
2081         packet->dst_port = udp_dst_port;
2082
2083         packet->src_ipaddr.af = AF_INET;
2084         packet->src_ipaddr.ipaddr.ip4addr.s_addr = ip_hdr->ip_src.s_addr;
2085         packet->dst_ipaddr.af = AF_INET;
2086         packet->dst_ipaddr.ipaddr.ip4addr.s_addr = ip_hdr->ip_dst.s_addr;
2087
2088         if (fr_debug_lvl > 1) {
2089                 char type_buf[64];
2090                 char const *name = type_buf;
2091                 char src_ip_buf[256], dst_ip_buf[256];
2092
2093                 if ((packet->code >= PW_DHCP_DISCOVER) &&
2094                     (packet->code < (1024 + DHCP_MAX_MESSAGE_TYPE))) {
2095                         name = dhcp_message_types[packet->code - PW_DHCP_OFFSET];
2096                 } else {
2097                         snprintf(type_buf, sizeof(type_buf), "%d", packet->code - PW_DHCP_OFFSET);
2098                 }
2099
2100                 DEBUG("Received %s of Id %08x from %s:%d to %s:%d\n",
2101                        name, (unsigned int) packet->id,
2102                        inet_ntop(packet->src_ipaddr.af, &packet->src_ipaddr.ipaddr, src_ip_buf, sizeof(src_ip_buf)),
2103                        packet->src_port,
2104                        inet_ntop(packet->dst_ipaddr.af, &packet->dst_ipaddr.ipaddr, dst_ip_buf, sizeof(dst_ip_buf)),
2105                        packet->dst_port);
2106         }
2107
2108         return packet;
2109 }
2110 #endif