release/src/router/dnsmasq/src/lease.c

   1 /* dnsmasq is Copyright (c) 2000-2010 Simon Kelley
   2
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; version 2 dated June, 1991, or
   6    (at your option) version 3 dated 29 June, 2007.
   7
   8    This program is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11    GNU General Public License for more details.
  12
  13    You should have received a copy of the GNU General Public License
  14    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15 */
  16
  17 #include "dnsmasq.h"
  18
  19 #ifdef HAVE_DHCP
  20
  21 static struct dhcp_lease *leases = NULL, *old_leases = NULL;
  22 static int dns_dirty, file_dirty, leases_left;
  23
  24 void lease_init(time_t now)
  25 {
  26   unsigned long ei;
  27   struct in_addr addr;
  28   struct dhcp_lease *lease;
  29   int clid_len, hw_len, hw_type;
  30   FILE *leasestream;
  31
  32   /* These each hold a DHCP option max size 255
  33      and get a terminating zero added */
  34   daemon->dhcp_buff = safe_malloc(256);
  35   daemon->dhcp_buff2 = safe_malloc(256);
  36   daemon->dhcp_buff3 = safe_malloc(256);
  37
  38   leases_left = daemon->dhcp_max;
  39
  40   if (daemon->options & OPT_LEASE_RO)
  41     {
  42       /* run "<lease_change_script> init" once to get the
  43          initial state of the database. If leasefile-ro is
  44          set without a script, we just do without any
  45          lease database. */
  46 #ifdef HAVE_SCRIPT
  47       if (daemon->lease_change_command)
  48         {
  49           strcpy(daemon->dhcp_buff, daemon->lease_change_command);
  50           strcat(daemon->dhcp_buff, " init");
  51           leasestream = popen(daemon->dhcp_buff, "r");
  52         }
  53       else
  54 #endif
  55         {
  56           file_dirty = dns_dirty = 0;
  57           return;
  58         }
  59
  60     }
  61   else
  62     {
  63       /* NOTE: need a+ mode to create file if it doesn't exist */
  64       leasestream = daemon->lease_stream = fopen(daemon->lease_file, "a+");
  65
  66       if (!leasestream)
  67         die(_("cannot open or create lease file %s: %s"), daemon->lease_file, EC_FILE);
  68
  69       /* a+ mode leaves pointer at end. */
  70       rewind(leasestream);
  71     }
  72
  73   /* client-id max length is 255 which is 255*2 digits + 254 colons
  74      borrow DNS packet buffer which is always larger than 1000 bytes */
  75   if (leasestream)
  76     while (fscanf(leasestream, "%lu %255s %16s %255s %764s",
  77                   &ei, daemon->dhcp_buff2, daemon->namebuff,
  78                   daemon->dhcp_buff, daemon->packet) == 5)
  79       {
  80         hw_len = parse_hex(daemon->dhcp_buff2, (unsigned char *)daemon->dhcp_buff2, DHCP_CHADDR_MAX, NULL, &hw_type);
  81         /* For backwards compatibility, no explict MAC address type means ether. */
  82         if (hw_type == 0 && hw_len != 0)
  83           hw_type = ARPHRD_ETHER;
  84
  85         addr.s_addr = inet_addr(daemon->namebuff);
  86
  87         /* decode hex in place */
  88         clid_len = 0;
  89         if (strcmp(daemon->packet, "*") != 0)
  90           clid_len = parse_hex(daemon->packet, (unsigned char *)daemon->packet, 255, NULL, NULL);
  91
  92         if (!(lease = lease_allocate(addr)))
  93           die (_("too many stored leases"), NULL, EC_MISC);
  94
  95 #ifdef HAVE_BROKEN_RTC
  96         if (ei != 0)
  97           lease->expires = (time_t)ei + now;
  98         else
  99           lease->expires = (time_t)0;
 100         lease->length = ei;
 101 #else
 102         /* strictly time_t is opaque, but this hack should work on all sane systems,
 103            even when sizeof(time_t) == 8 */
 104         lease->expires = (time_t)ei;
 105 #endif
 106
 107         lease_set_hwaddr(lease, (unsigned char *)daemon->dhcp_buff2, (unsigned char *)daemon->packet, hw_len, hw_type, clid_len);
 108
 109         if (strcmp(daemon->dhcp_buff, "*") !=  0)
 110           lease_set_hostname(lease, daemon->dhcp_buff, 0);
 111
 112         /* set these correctly: the "old" events are generated later from
 113            the startup synthesised SIGHUP. */
 114         lease->new = lease->changed = 0;
 115       }
 116
 117 #ifdef HAVE_SCRIPT
 118   if (!daemon->lease_stream)
 119     {
 120       int rc = 0;
 121
 122       /* shell returns 127 for "command not found", 126 for bad permissions. */
 123       if (!leasestream || (rc = pclose(leasestream)) == -1 || WEXITSTATUS(rc) == 127 || WEXITSTATUS(rc) == 126)
 124         {
 125           if (WEXITSTATUS(rc) == 127)
 126             errno = ENOENT;
 127           else if (WEXITSTATUS(rc) == 126)
 128             errno = EACCES;
 129           die(_("cannot run lease-init script %s: %s"), daemon->lease_change_command, EC_FILE);
 130         }
 131
 132       if (WEXITSTATUS(rc) != 0)
 133         {
 134           sprintf(daemon->dhcp_buff, "%d", WEXITSTATUS(rc));
 135           die(_("lease-init script returned exit code %s"), daemon->dhcp_buff, WEXITSTATUS(rc) + EC_INIT_OFFSET);
 136         }
 137     }
 138 #endif
 139
 140   /* Some leases may have expired */
 141   file_dirty = 0;
 142   lease_prune(NULL, now);
 143   dns_dirty = 1;
 144 }
 145
 146 void lease_update_from_configs(void)
 147 {
 148   /* changes to the config may change current leases. */
 149
 150   struct dhcp_lease *lease;
 151   struct dhcp_config *config;
 152   char *name;
 153
 154   for (lease = leases; lease; lease = lease->next)
 155     if ((config = find_config(daemon->dhcp_conf, NULL, lease->clid, lease->clid_len,
 156                               lease->hwaddr, lease->hwaddr_len, lease->hwaddr_type, NULL)) &&
 157         (config->flags & CONFIG_NAME) &&
 158         (!(config->flags & CONFIG_ADDR) || config->addr.s_addr == lease->addr.s_addr))
 159       lease_set_hostname(lease, config->hostname, 1);
 160     else if ((name = host_from_dns(lease->addr)))
 161       lease_set_hostname(lease, name, 1); /* updates auth flag only */
 162 }
 163
 164 static void ourprintf(int *errp, char *format, ...)
 165 {
 166   va_list ap;
 167
 168   va_start(ap, format);
 169   if (!(*errp) && vfprintf(daemon->lease_stream, format, ap) < 0)
 170     *errp = errno;
 171   va_end(ap);
 172 }
 173
 174 void lease_update_file(time_t now)
 175 {
 176   struct dhcp_lease *lease;
 177   time_t next_event;
 178   int i, err = 0;
 179
 180   if (file_dirty != 0 && daemon->lease_stream)
 181     {
 182       errno = 0;
 183       rewind(daemon->lease_stream);
 184       if (errno != 0 || ftruncate(fileno(daemon->lease_stream), 0) != 0)
 185         err = errno;
 186
 187       for (lease = leases; lease; lease = lease->next)
 188         {
 189 #if 1   // zzz
 190           ourprintf(&err, "%lu ", (unsigned long)lease->expires - now);
 191 #else
 192 #ifdef HAVE_BROKEN_RTC
 193           ourprintf(&err, "%u ", lease->length);
 194 #else
 195           ourprintf(&err, "%lu ", (unsigned long)lease->expires);
 196 #endif
 197 #endif
 198           if (lease->hwaddr_type != ARPHRD_ETHER || lease->hwaddr_len == 0)
 199             ourprintf(&err, "%.2x-", lease->hwaddr_type);
 200           for (i = 0; i < lease->hwaddr_len; i++)
 201             {
 202               ourprintf(&err, "%.2x", lease->hwaddr[i]);
 203               if (i != lease->hwaddr_len - 1)
 204                 ourprintf(&err, ":");
 205             }
 206
 207           ourprintf(&err, " %s ", inet_ntoa(lease->addr));
 208           ourprintf(&err, "%s ", lease->hostname ? lease->hostname : "*");
 209
 210           if (lease->clid && lease->clid_len != 0)
 211             {
 212               for (i = 0; i < lease->clid_len - 1; i++)
 213                 ourprintf(&err, "%.2x:", lease->clid[i]);
 214               ourprintf(&err, "%.2x\n", lease->clid[i]);
 215             }
 216           else
 217             ourprintf(&err, "*\n");
 218         }
 219
 220       if (fflush(daemon->lease_stream) != 0 ||
 221           fsync(fileno(daemon->lease_stream)) < 0)
 222         err = errno;
 223
 224       if (!err)
 225         file_dirty = 0;
 226     }
 227
 228   /* Set alarm for when the first lease expires + slop. */
 229   for (next_event = 0, lease = leases; lease; lease = lease->next)
 230     if (lease->expires != 0 &&
 231         (next_event == 0 || difftime(next_event, lease->expires + 10) > 0.0))
 232       next_event = lease->expires + 10;
 233
 234   if (err)
 235     {
 236       if (next_event == 0 || difftime(next_event, LEASE_RETRY + now) > 0.0)
 237         next_event = LEASE_RETRY + now;
 238
 239       my_syslog(MS_DHCP | LOG_ERR, _("failed to write %s: %s (retry in %us)"),
 240                 daemon->lease_file, strerror(err),
 241                 (unsigned int)difftime(next_event, now));
 242     }
 243
 244   if (next_event != 0)
 245     alarm((unsigned)difftime(next_event, now));
 246 }
 247
 248 void lease_update_dns(void)
 249 {
 250   struct dhcp_lease *lease;
 251
 252   if (daemon->port != 0 && dns_dirty)
 253     {
 254       cache_unhash_dhcp();
 255
 256       for (lease = leases; lease; lease = lease->next)
 257         {
 258           if (lease->fqdn)
 259             cache_add_dhcp_entry(lease->fqdn, &lease->addr, lease->expires);
 260
 261           if (!(daemon->options & OPT_DHCP_FQDN) && lease->hostname)
 262             cache_add_dhcp_entry(lease->hostname, &lease->addr, lease->expires);
 263         }
 264
 265       dns_dirty = 0;
 266     }
 267 }
 268
 269 void lease_prune(struct dhcp_lease *target, time_t now)
 270 {
 271   struct dhcp_lease *lease, *tmp, **up;
 272
 273   for (lease = leases, up = &leases; lease; lease = tmp)
 274     {
 275       tmp = lease->next;
 276       if ((lease->expires != 0 && difftime(now, lease->expires) > 0) || lease == target)
 277         {
 278           file_dirty = 1;
 279           if (lease->hostname)
 280             dns_dirty = 1;
 281
 282           *up = lease->next; /* unlink */
 283
 284           /* Put on old_leases list 'till we
 285              can run the script */
 286           lease->next = old_leases;
 287           old_leases = lease;
 288
 289           leases_left++;
 290         }
 291       else
 292         up = &lease->next;
 293     }
 294 }
 295
 296
 297 struct dhcp_lease *lease_find_by_client(unsigned char *hwaddr, int hw_len, int hw_type,
 298                                         unsigned char *clid, int clid_len)
 299 {
 300   struct dhcp_lease *lease;
 301
 302   if (clid)
 303     for (lease = leases; lease; lease = lease->next)
 304       if (lease->clid && clid_len == lease->clid_len &&
 305           memcmp(clid, lease->clid, clid_len) == 0)
 306         return lease;
 307
 308   for (lease = leases; lease; lease = lease->next)
 309     if ((!lease->clid || !clid) &&
 310         hw_len != 0 &&
 311         lease->hwaddr_len == hw_len &&
 312         lease->hwaddr_type == hw_type &&
 313         memcmp(hwaddr, lease->hwaddr, hw_len) == 0)
 314       return lease;
 315
 316   return NULL;
 317 }
 318
 319 struct dhcp_lease *lease_find_by_addr(struct in_addr addr)
 320 {
 321   struct dhcp_lease *lease;
 322
 323   for (lease = leases; lease; lease = lease->next)
 324     if (lease->addr.s_addr == addr.s_addr)
 325       return lease;
 326
 327   return NULL;
 328 }
 329
 330
 331 struct dhcp_lease *lease_allocate(struct in_addr addr)
 332 {
 333   struct dhcp_lease *lease;
 334   if (!leases_left || !(lease = whine_malloc(sizeof(struct dhcp_lease))))
 335     return NULL;
 336
 337   memset(lease, 0, sizeof(struct dhcp_lease));
 338   lease->new = 1;
 339   lease->addr = addr;
 340   lease->hwaddr_len = 256; /* illegal value */
 341   lease->expires = 1;
 342 #ifdef HAVE_BROKEN_RTC
 343   lease->length = 0xffffffff; /* illegal value */
 344 #endif
 345   lease->next = leases;
 346   leases = lease;
 347
 348   file_dirty = 1;
 349   leases_left--;
 350
 351   return lease;
 352 }
 353
 354 void lease_set_expires(struct dhcp_lease *lease, unsigned int len, time_t now)
 355 {
 356   time_t exp = now + (time_t)len;
 357
 358   if (len == 0xffffffff)
 359     {
 360       exp = 0;
 361       len = 0;
 362     }
 363
 364   if (exp != lease->expires)
 365     {
 366       dns_dirty = 1;
 367       lease->expires = exp;
 368 #ifndef HAVE_BROKEN_RTC
 369       lease->aux_changed = file_dirty = 1;
 370 #endif
 371     }
 372
 373 #ifdef HAVE_BROKEN_RTC
 374   if (len != lease->length)
 375     {
 376       lease->length = len;
 377       lease->aux_changed = file_dirty = 1;
 378     }
 379 #endif
 380 }
 381
 382 void lease_set_hwaddr(struct dhcp_lease *lease, unsigned char *hwaddr,
 383                       unsigned char *clid, int hw_len, int hw_type, int clid_len)
 384 {
 385   if (hw_len != lease->hwaddr_len ||
 386       hw_type != lease->hwaddr_type ||
 387       (hw_len != 0 && memcmp(lease->hwaddr, hwaddr, hw_len) != 0))
 388     {
 389       memcpy(lease->hwaddr, hwaddr, hw_len);
 390       lease->hwaddr_len = hw_len;
 391       lease->hwaddr_type = hw_type;
 392       lease->changed = file_dirty = 1; /* run script on change */
 393     }
 394
 395   /* only update clid when one is available, stops packets
 396      without a clid removing the record. Lease init uses
 397      clid_len == 0 for no clid. */
 398   if (clid_len != 0 && clid)
 399     {
 400       if (!lease->clid)
 401         lease->clid_len = 0;
 402
 403       if (lease->clid_len != clid_len)
 404         {
 405           lease->aux_changed = file_dirty = 1;
 406           free(lease->clid);
 407           if (!(lease->clid = whine_malloc(clid_len)))
 408             return;
 409         }
 410       else if (memcmp(lease->clid, clid, clid_len) != 0)
 411         lease->aux_changed = file_dirty = 1;
 412
 413       lease->clid_len = clid_len;
 414       memcpy(lease->clid, clid, clid_len);
 415     }
 416
 417 }
 418
 419 static void kill_name(struct dhcp_lease *lease)
 420 {
 421   /* run script to say we lost our old name */
 422
 423   /* this shouldn't happen unless updates are very quick and the
 424      script very slow, we just avoid a memory leak if it does. */
 425   free(lease->old_hostname);
 426
 427   /* If we know the fqdn, pass that. The helper will derive the
 428      unqualified name from it, free the unqulaified name here. */
 429
 430   if (lease->fqdn)
 431     {
 432       lease->old_hostname = lease->fqdn;
 433       free(lease->hostname);
 434     }
 435   else
 436     lease->old_hostname = lease->hostname;
 437
 438   lease->hostname = lease->fqdn = NULL;
 439 }
 440
 441 void lease_set_hostname(struct dhcp_lease *lease, char *name, int auth)
 442 {
 443   struct dhcp_lease *lease_tmp;
 444   char *new_name = NULL, *new_fqdn = NULL;
 445
 446   if (lease->hostname && name && hostname_isequal(lease->hostname, name))
 447     {
 448       lease->auth_name = auth;
 449       return;
 450     }
 451
 452   if (!name && !lease->hostname)
 453     return;
 454
 455   /* If a machine turns up on a new net without dropping the old lease,
 456      or two machines claim the same name, then we end up with two interfaces with
 457      the same name. Check for that here and remove the name from the old lease.
 458      Don't allow a name from the client to override a name from dnsmasq config. */
 459
 460   if (name)
 461     {
 462       if ((new_name = whine_malloc(strlen(name) + 1)))
 463         {
 464           char *suffix = get_domain(lease->addr);
 465           strcpy(new_name, name);
 466           if (suffix && (new_fqdn = whine_malloc(strlen(new_name) + strlen(suffix) + 2)))
 467             {
 468               strcpy(new_fqdn, name);
 469               strcat(new_fqdn, ".");
 470               strcat(new_fqdn, suffix);
 471             }
 472         }
 473
 474       /* Depending on mode, we check either unqualified name or FQDN. */
 475       for (lease_tmp = leases; lease_tmp; lease_tmp = lease_tmp->next)
 476         {
 477           if (daemon->options & OPT_DHCP_FQDN)
 478             {
 479               if (!new_fqdn || !lease_tmp->fqdn || !hostname_isequal(lease_tmp->fqdn, new_fqdn) )
 480                 continue;
 481             }
 482           else
 483             {
 484               if (!new_name || !lease_tmp->hostname || !hostname_isequal(lease_tmp->hostname, new_name) )
 485                 continue;
 486             }
 487
 488           if (lease_tmp->auth_name && !auth)
 489             {
 490               free(new_name);
 491               free(new_fqdn);
 492               return;
 493             }
 494
 495           kill_name(lease_tmp);
 496           break;
 497         }
 498     }
 499
 500   if (lease->hostname)
 501     kill_name(lease);
 502
 503   lease->hostname = new_name;
 504   lease->fqdn = new_fqdn;
 505   lease->auth_name = auth;
 506
 507   file_dirty = 1;
 508   dns_dirty = 1;
 509   lease->changed = 1; /* run script on change */
 510 }
 511
 512 void lease_set_interface(struct dhcp_lease *lease, int interface)
 513 {
 514   if (lease->last_interface == interface)
 515     return;
 516
 517   lease->last_interface = interface;
 518   lease->changed = 1;
 519 }
 520
 521 void rerun_scripts(void)
 522 {
 523   struct dhcp_lease *lease;
 524
 525   for (lease = leases; lease; lease = lease->next)
 526     lease->changed = 1;
 527 }
 528
 529 /* deleted leases get transferred to the old_leases list.
 530    remove them here, after calling the lease change
 531    script. Also run the lease change script on new/modified leases.
 532
 533    Return zero if nothing to do. */
 534 int do_script_run(time_t now)
 535 {
 536   struct dhcp_lease *lease;
 537
 538 #ifdef HAVE_DBUS
 539   /* If we're going to be sending DBus signals, but the connection is not yet up,
 540      delay everything until it is. */
 541   if ((daemon->options & OPT_DBUS) && !daemon->dbus)
 542     return 0;
 543 #endif
 544
 545   if (old_leases)
 546     {
 547       lease = old_leases;
 548
 549       /* If the lease still has an old_hostname, do the "old" action on that first */
 550       if (lease->old_hostname)
 551         {
 552 #ifdef HAVE_SCRIPT
 553           queue_script(ACTION_OLD_HOSTNAME, lease, lease->old_hostname, now);
 554 #endif
 555           free(lease->old_hostname);
 556           lease->old_hostname = NULL;
 557           return 1;
 558         }
 559       else
 560         {
 561           kill_name(lease);
 562 #ifdef HAVE_SCRIPT
 563           queue_script(ACTION_DEL, lease, lease->old_hostname, now);
 564 #endif
 565 #ifdef HAVE_DBUS
 566           emit_dbus_signal(ACTION_DEL, lease, lease->old_hostname);
 567 #endif
 568           old_leases = lease->next;
 569
 570           free(lease->old_hostname);
 571           free(lease->clid);
 572           free(lease->extradata);
 573           free(lease);
 574
 575           return 1;
 576         }
 577     }
 578
 579   /* make sure we announce the loss of a hostname before its new location. */
 580   for (lease = leases; lease; lease = lease->next)
 581     if (lease->old_hostname)
 582       {
 583 #ifdef HAVE_SCRIPT
 584         queue_script(ACTION_OLD_HOSTNAME, lease, lease->old_hostname, now);
 585 #endif
 586         free(lease->old_hostname);
 587         lease->old_hostname = NULL;
 588         return 1;
 589       }
 590
 591   for (lease = leases; lease; lease = lease->next)
 592     if (lease->new || lease->changed ||
 593         (lease->aux_changed && (daemon->options & OPT_LEASE_RO)))
 594       {
 595 #ifdef HAVE_SCRIPT
 596         queue_script(lease->new ? ACTION_ADD : ACTION_OLD, lease,
 597                      lease->fqdn ? lease->fqdn : lease->hostname, now);
 598 #endif
 599 #ifdef HAVE_DBUS
 600         emit_dbus_signal(lease->new ? ACTION_ADD : ACTION_OLD, lease,
 601                          lease->fqdn ? lease->fqdn : lease->hostname);
 602 #endif
 603         lease->new = lease->changed = lease->aux_changed = 0;
 604
 605         /* this is used for the "add" call, then junked, since they're not in the database */
 606         free(lease->extradata);
 607         lease->extradata = NULL;
 608
 609         return 1;
 610       }
 611
 612   return 0; /* nothing to do */
 613 }
 614
 615
 616
 617
 618 void tomato_helper(time_t now)
 619 {
 620         FILE *f;
 621         struct in_addr ia;
 622         char buf[64];
 623         struct dhcp_lease *lease;
 624
 625         // if delete exists...
 626         if ((f = fopen("/var/tmp/dhcp/delete", "r")) != NULL) {
 627                 while (fgets(buf, sizeof(buf), f)) {
 628                         ia.s_addr = inet_addr(buf);
 629                         lease = lease_find_by_addr(ia);
 630                         if (lease) {
 631                                 lease_prune(lease, 0);
 632                                 lease_update_file(now);
 633                         }
 634                 }
 635                 fclose(f);
 636                 unlink("/var/tmp/dhcp/delete");
 637         }
 638
 639         // dump the leases file
 640         if ((f = fopen("/var/tmp/dhcp/leases.!", "w")) != NULL) {
 641                 for (lease = leases; lease; lease = lease->next) {
 642                         if (lease->hwaddr_type == ARPHRD_ETHER) {
 643                                 fprintf(f, "%lu %02X:%02X:%02X:%02X:%02X:%02X %s %s\n",
 644                                         lease->expires - now,
 645                                         lease->hwaddr[0], lease->hwaddr[1], lease->hwaddr[2], lease->hwaddr[3], lease->hwaddr[4], lease->hwaddr[5],
 646                                         inet_ntoa(lease->addr),
 647                                         ((lease->hostname) && (strlen(lease->hostname) > 0)) ? lease->hostname : "*");
 648                         }
 649                 }
 650                 fclose(f);
 651                 rename("/var/tmp/dhcp/leases.!", "/var/tmp/dhcp/leases");
 652         }
 653 }
 654
 655 void flush_lease_file(time_t now)
 656 {
 657         file_dirty = 1;
 658         lease_update_file(now);
 659 }
 660
 661 #endif