contrib/bind-9.5.2/bin/named/unix/os.c

   1 /*
   2  * Copyright (C) 2004-2009  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1999-2002  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  10  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  11  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  13  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  14  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15  * PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 /* $Id: os.c,v 1.79.128.13 2009/03/02 03:07:05 marka Exp $ */
  19
  20 /*! \file */
  21
  22 #include <config.h>
  23 #include <stdarg.h>
  24
  25 #include <sys/types.h>  /* dev_t FreeBSD 2.1 */
  26 #include <sys/stat.h>
  27
  28 #include <ctype.h>
  29 #include <errno.h>
  30 #include <fcntl.h>
  31 #include <grp.h>                /* Required for initgroups() on IRIX. */
  32 #include <pwd.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <signal.h>
  36 #include <syslog.h>
  37 #ifdef HAVE_TZSET
  38 #include <time.h>
  39 #endif
  40 #include <unistd.h>
  41
  42 #include <isc/buffer.h>
  43 #include <isc/file.h>
  44 #include <isc/print.h>
  45 #include <isc/resource.h>
  46 #include <isc/result.h>
  47 #include <isc/strerror.h>
  48 #include <isc/string.h>
  49
  50 #include <named/main.h>
  51 #include <named/os.h>
  52 #ifdef HAVE_LIBSCF
  53 #include <named/ns_smf_globals.h>
  54 #endif
  55
  56 static char *pidfile = NULL;
  57 static int devnullfd = -1;
  58
  59 #ifndef ISC_FACILITY
  60 #define ISC_FACILITY LOG_DAEMON
  61 #endif
  62
  63 /*
  64  * If there's no <linux/capability.h>, we don't care about <sys/prctl.h>
  65  */
  66 #ifndef HAVE_LINUX_CAPABILITY_H
  67 #undef HAVE_SYS_PRCTL_H
  68 #endif
  69
  70 /*
  71  * Linux defines:
  72  *      (T) HAVE_LINUXTHREADS
  73  *      (C) HAVE_SYS_CAPABILITY_H (or HAVE_LINUX_CAPABILITY_H)
  74  *      (P) HAVE_SYS_PRCTL_H
  75  * The possible cases are:
  76  *      none:   setuid() normally
  77  *      T:      no setuid()
  78  *      C:      setuid() normally, drop caps (keep CAP_SETUID)
  79  *      T+C:    no setuid(), drop caps (don't keep CAP_SETUID)
  80  *      T+C+P:  setuid() early, drop caps (keep CAP_SETUID)
  81  *      C+P:    setuid() normally, drop caps (keep CAP_SETUID)
  82  *      P:      not possible
  83  *      T+P:    not possible
  84  *
  85  * if (C)
  86  *      caps = BIND_SERVICE + CHROOT + SETGID
  87  *      if ((T && C && P) || !T)
  88  *              caps += SETUID
  89  *      endif
  90  *      capset(caps)
  91  * endif
  92  * if (T && C && P && -u)
  93  *      setuid()
  94  * else if (T && -u)
  95  *      fail
  96  * --> start threads
  97  * if (!T && -u)
  98  *      setuid()
  99  * if (C && (P || !-u))
 100  *      caps = BIND_SERVICE
 101  *      capset(caps)
 102  * endif
 103  *
 104  * It will be nice when Linux threads work properly with setuid().
 105  */
 106
 107 #ifdef HAVE_LINUXTHREADS
 108 static pid_t mainpid = 0;
 109 #endif
 110
 111 static struct passwd *runas_pw = NULL;
 112 static isc_boolean_t done_setuid = ISC_FALSE;
 113 static int dfd[2] = { -1, -1 };
 114
 115 #ifdef HAVE_LINUX_CAPABILITY_H
 116
 117 static isc_boolean_t non_root = ISC_FALSE;
 118 static isc_boolean_t non_root_caps = ISC_FALSE;
 119
 120 #ifdef HAVE_SYS_CAPABILITY_H
 121 #include <sys/capability.h>
 122 #else
 123 /*%
 124  * We define _LINUX_FS_H to prevent it from being included.  We don't need
 125  * anything from it, and the files it includes cause warnings with 2.2
 126  * kernels, and compilation failures (due to conflicts between <linux/string.h>
 127  * and <string.h>) on 2.3 kernels.
 128  */
 129 #define _LINUX_FS_H
 130 #include <linux/capability.h>
 131 #include <syscall.h>
 132 #ifndef SYS_capset
 133 #ifndef __NR_capset
 134 #include <asm/unistd.h> /* Slackware 4.0 needs this. */
 135 #endif /* __NR_capset */
 136 #define SYS_capset __NR_capset
 137 #endif /* SYS_capset */
 138 #endif /* HAVE_SYS_CAPABILITY_H */
 139
 140 #ifdef HAVE_SYS_PRCTL_H
 141 #include <sys/prctl.h>          /* Required for prctl(). */
 142
 143 /*
 144  * If the value of PR_SET_KEEPCAPS is not in <sys/prctl.h>, define it
 145  * here.  This allows setuid() to work on systems running a new enough
 146  * kernel but with /usr/include/linux pointing to "standard" kernel
 147  * headers.
 148  */
 149 #ifndef PR_SET_KEEPCAPS
 150 #define PR_SET_KEEPCAPS 8
 151 #endif
 152
 153 #endif /* HAVE_SYS_PRCTL_H */
 154
 155 #ifdef HAVE_LIBCAP
 156 #define SETCAPS_FUNC "cap_set_proc "
 157 #else
 158 typedef unsigned int cap_t;
 159 #define SETCAPS_FUNC "syscall(capset) "
 160 #endif /* HAVE_LIBCAP */
 161
 162 static void
 163 linux_setcaps(cap_t caps) {
 164 #ifndef HAVE_LIBCAP
 165         struct __user_cap_header_struct caphead;
 166         struct __user_cap_data_struct cap;
 167 #endif
 168         char strbuf[ISC_STRERRORSIZE];
 169
 170         if ((getuid() != 0 && !non_root_caps) || non_root)
 171                 return;
 172 #ifndef HAVE_LIBCAP
 173         memset(&caphead, 0, sizeof(caphead));
 174         caphead.version = _LINUX_CAPABILITY_VERSION;
 175         caphead.pid = 0;
 176         memset(&cap, 0, sizeof(cap));
 177         cap.effective = caps;
 178         cap.permitted = caps;
 179         cap.inheritable = 0;
 180 #endif
 181 #ifdef HAVE_LIBCAP
 182         if (cap_set_proc(caps) < 0) {
 183 #else
 184         if (syscall(SYS_capset, &caphead, &cap) < 0) {
 185 #endif
 186                 isc__strerror(errno, strbuf, sizeof(strbuf));
 187                 ns_main_earlyfatal(SETCAPS_FUNC "failed: %s:"
 188                                    " please ensure that the capset kernel"
 189                                    " module is loaded.  see insmod(8)",
 190                                    strbuf);
 191         }
 192 }
 193
 194 #ifdef HAVE_LIBCAP
 195 #define SET_CAP(flag) \
 196         do { \
 197                 capval = (flag); \
 198                 cap_flag_value_t curval; \
 199                 err = cap_get_flag(curcaps, capval, CAP_PERMITTED, &curval); \
 200                 if (err != -1 && curval) { \
 201                         err = cap_set_flag(caps, CAP_EFFECTIVE, 1, &capval, CAP_SET); \
 202                         if (err == -1) { \
 203                                 isc__strerror(errno, strbuf, sizeof(strbuf)); \
 204                                 ns_main_earlyfatal("cap_set_proc failed: %s", strbuf); \
 205                         } \
 206                         \
 207                         err = cap_set_flag(caps, CAP_PERMITTED, 1, &capval, CAP_SET); \
 208                         if (err == -1) { \
 209                                 isc__strerror(errno, strbuf, sizeof(strbuf)); \
 210                                 ns_main_earlyfatal("cap_set_proc failed: %s", strbuf); \
 211                         } \
 212                 } \
 213         } while (0)
 214 #define INIT_CAP \
 215         do { \
 216                 caps = cap_init(); \
 217                 if (caps == NULL) { \
 218                         isc__strerror(errno, strbuf, sizeof(strbuf)); \
 219                         ns_main_earlyfatal("cap_init failed: %s", strbuf); \
 220                 } \
 221                 curcaps = cap_get_proc(); \
 222                 if (curcaps == NULL) { \
 223                         isc__strerror(errno, strbuf, sizeof(strbuf)); \
 224                         ns_main_earlyfatal("cap_get_proc failed: %s", strbuf); \
 225                 } \
 226         } while (0)
 227 #define FREE_CAP \
 228         { \
 229                 cap_free(caps); \
 230                 cap_free(curcaps); \
 231         } while (0)
 232 #else
 233 #define SET_CAP(flag) do { caps |= (1 << (flag)); } while (0)
 234 #define INIT_CAP do { caps = 0; } while (0)
 235 #endif /* HAVE_LIBCAP */
 236
 237 static void
 238 linux_initialprivs(void) {
 239         cap_t caps;
 240 #ifdef HAVE_LIBCAP
 241         cap_t curcaps;
 242         cap_value_t capval;
 243         char strbuf[ISC_STRERRORSIZE];
 244         int err;
 245 #endif
 246
 247         /*%
 248          * We don't need most privileges, so we drop them right away.
 249          * Later on linux_minprivs() will be called, which will drop our
 250          * capabilities to the minimum needed to run the server.
 251          */
 252         INIT_CAP;
 253
 254         /*
 255          * We need to be able to bind() to privileged ports, notably port 53!
 256          */
 257         SET_CAP(CAP_NET_BIND_SERVICE);
 258
 259         /*
 260          * We need chroot() initially too.
 261          */
 262         SET_CAP(CAP_SYS_CHROOT);
 263
 264 #if defined(HAVE_SYS_PRCTL_H) || !defined(HAVE_LINUXTHREADS)
 265         /*
 266          * We can setuid() only if either the kernel supports keeping
 267          * capabilities after setuid() (which we don't know until we've
 268          * tried) or we're not using threads.  If either of these is
 269          * true, we want the setuid capability.
 270          */
 271         SET_CAP(CAP_SETUID);
 272 #endif
 273
 274         /*
 275          * Since we call initgroups, we need this.
 276          */
 277         SET_CAP(CAP_SETGID);
 278
 279         /*
 280          * Without this, we run into problems reading a configuration file
 281          * owned by a non-root user and non-world-readable on startup.
 282          */
 283         SET_CAP(CAP_DAC_READ_SEARCH);
 284
 285         /*
 286          * XXX  We might want to add CAP_SYS_RESOURCE, though it's not
 287          *      clear it would work right given the way linuxthreads work.
 288          * XXXDCL But since we need to be able to set the maximum number
 289          * of files, the stack size, data size, and core dump size to
 290          * support named.conf options, this is now being added to test.
 291          */
 292         SET_CAP(CAP_SYS_RESOURCE);
 293
 294         linux_setcaps(caps);
 295
 296 #ifdef HAVE_LIBCAP
 297         FREE_CAP;
 298 #endif
 299 }
 300
 301 static void
 302 linux_minprivs(void) {
 303         cap_t caps;
 304 #ifdef HAVE_LIBCAP
 305         cap_t curcaps;
 306         cap_value_t capval;
 307         char strbuf[ISC_STRERRORSIZE];
 308         int err;
 309 #endif
 310
 311         INIT_CAP;
 312         /*%
 313          * Drop all privileges except the ability to bind() to privileged
 314          * ports.
 315          *
 316          * It's important that we drop CAP_SYS_CHROOT.  If we didn't, it
 317          * chroot() could be used to escape from the chrooted area.
 318          */
 319
 320         SET_CAP(CAP_NET_BIND_SERVICE);
 321
 322         /*
 323          * XXX  We might want to add CAP_SYS_RESOURCE, though it's not
 324          *      clear it would work right given the way linuxthreads work.
 325          * XXXDCL But since we need to be able to set the maximum number
 326          * of files, the stack size, data size, and core dump size to
 327          * support named.conf options, this is now being added to test.
 328          */
 329         SET_CAP(CAP_SYS_RESOURCE);
 330
 331         linux_setcaps(caps);
 332
 333 #ifdef HAVE_LIBCAP
 334         FREE_CAP;
 335 #endif
 336 }
 337
 338 #ifdef HAVE_SYS_PRCTL_H
 339 static void
 340 linux_keepcaps(void) {
 341         char strbuf[ISC_STRERRORSIZE];
 342         /*%
 343          * Ask the kernel to allow us to keep our capabilities after we
 344          * setuid().
 345          */
 346
 347         if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) < 0) {
 348                 if (errno != EINVAL) {
 349                         isc__strerror(errno, strbuf, sizeof(strbuf));
 350                         ns_main_earlyfatal("prctl() failed: %s", strbuf);
 351                 }
 352         } else {
 353                 non_root_caps = ISC_TRUE;
 354                 if (getuid() != 0)
 355                         non_root = ISC_TRUE;
 356         }
 357 }
 358 #endif
 359
 360 #endif  /* HAVE_LINUX_CAPABILITY_H */
 361
 362
 363 static void
 364 setup_syslog(const char *progname) {
 365         int options;
 366
 367         options = LOG_PID;
 368 #ifdef LOG_NDELAY
 369         options |= LOG_NDELAY;
 370 #endif
 371         openlog(isc_file_basename(progname), options, ISC_FACILITY);
 372 }
 373
 374 void
 375 ns_os_init(const char *progname) {
 376         setup_syslog(progname);
 377 #ifdef HAVE_LINUX_CAPABILITY_H
 378         linux_initialprivs();
 379 #endif
 380 #ifdef HAVE_LINUXTHREADS
 381         mainpid = getpid();
 382 #endif
 383 #ifdef SIGXFSZ
 384         signal(SIGXFSZ, SIG_IGN);
 385 #endif
 386 }
 387
 388 void
 389 ns_os_daemonize(void) {
 390         pid_t pid;
 391         char strbuf[ISC_STRERRORSIZE];
 392
 393         if (pipe(dfd) == -1) {
 394                 isc__strerror(errno, strbuf, sizeof(strbuf));
 395                 ns_main_earlyfatal("pipe(): %s", strbuf);
 396         }
 397
 398         pid = fork();
 399         if (pid == -1) {
 400                 isc__strerror(errno, strbuf, sizeof(strbuf));
 401                 ns_main_earlyfatal("fork(): %s", strbuf);
 402         }
 403         if (pid != 0) {
 404                 int n;
 405                 /*
 406                  * Wait for the child to finish loading for the first time.
 407                  * This would be so much simpler if fork() worked once we
 408                  * were multi-threaded.
 409                  */
 410                 (void)close(dfd[1]);
 411                 do {
 412                         char buf;
 413                         n = read(dfd[0], &buf, 1);
 414                         if (n == 1)
 415                                 _exit(0);
 416                 } while (n == -1 && errno == EINTR);
 417                 _exit(1);
 418         }
 419         (void)close(dfd[0]);
 420
 421         /*
 422          * We're the child.
 423          */
 424
 425 #ifdef HAVE_LINUXTHREADS
 426         mainpid = getpid();
 427 #endif
 428
 429         if (setsid() == -1) {
 430                 isc__strerror(errno, strbuf, sizeof(strbuf));
 431                 ns_main_earlyfatal("setsid(): %s", strbuf);
 432         }
 433
 434         /*
 435          * Try to set stdin, stdout, and stderr to /dev/null, but press
 436          * on even if it fails.
 437          *
 438          * XXXMLG The close() calls here are unneeded on all but NetBSD, but
 439          * are harmless to include everywhere.  dup2() is supposed to close
 440          * the FD if it is in use, but unproven-pthreads-0.16 is broken
 441          * and will end up closing the wrong FD.  This will be fixed eventually,
 442          * and these calls will be removed.
 443          */
 444         if (devnullfd != -1) {
 445                 if (devnullfd != STDIN_FILENO) {
 446                         (void)close(STDIN_FILENO);
 447                         (void)dup2(devnullfd, STDIN_FILENO);
 448                 }
 449                 if (devnullfd != STDOUT_FILENO) {
 450                         (void)close(STDOUT_FILENO);
 451                         (void)dup2(devnullfd, STDOUT_FILENO);
 452                 }
 453                 if (devnullfd != STDERR_FILENO) {
 454                         (void)close(STDERR_FILENO);
 455                         (void)dup2(devnullfd, STDERR_FILENO);
 456                 }
 457         }
 458 }
 459
 460 void
 461 ns_os_started(void) {
 462         char buf = 0;
 463
 464         /*
 465          * Signal to the parent that we started successfully.
 466          */
 467         if (dfd[0] != -1 && dfd[1] != -1) {
 468                 if (write(dfd[1], &buf, 1) != 1)
 469                         ns_main_earlyfatal("unable to signal parent that we "
 470                                            "otherwise started successfully.");
 471                 close(dfd[1]);
 472                 dfd[0] = dfd[1] = -1;
 473         }
 474 }
 475
 476 void
 477 ns_os_opendevnull(void) {
 478         devnullfd = open("/dev/null", O_RDWR, 0);
 479 }
 480
 481 void
 482 ns_os_closedevnull(void) {
 483         if (devnullfd != STDIN_FILENO &&
 484             devnullfd != STDOUT_FILENO &&
 485             devnullfd != STDERR_FILENO) {
 486                 close(devnullfd);
 487                 devnullfd = -1;
 488         }
 489 }
 490
 491 static isc_boolean_t
 492 all_digits(const char *s) {
 493         if (*s == '\0')
 494                 return (ISC_FALSE);
 495         while (*s != '\0') {
 496                 if (!isdigit((*s)&0xff))
 497                         return (ISC_FALSE);
 498                 s++;
 499         }
 500         return (ISC_TRUE);
 501 }
 502
 503 void
 504 ns_os_chroot(const char *root) {
 505         char strbuf[ISC_STRERRORSIZE];
 506 #ifdef HAVE_LIBSCF
 507         ns_smf_chroot = 0;
 508 #endif
 509         if (root != NULL) {
 510 #ifdef HAVE_CHROOT
 511                 if (chroot(root) < 0) {
 512                         isc__strerror(errno, strbuf, sizeof(strbuf));
 513                         ns_main_earlyfatal("chroot(): %s", strbuf);
 514                 }
 515 #else
 516                 ns_main_earlyfatal("chroot(): disabled");
 517 #endif
 518                 if (chdir("/") < 0) {
 519                         isc__strerror(errno, strbuf, sizeof(strbuf));
 520                         ns_main_earlyfatal("chdir(/): %s", strbuf);
 521                 }
 522 #ifdef HAVE_LIBSCF
 523                 /* Set ns_smf_chroot flag on successful chroot. */
 524                 ns_smf_chroot = 1;
 525 #endif
 526         }
 527 }
 528
 529 void
 530 ns_os_inituserinfo(const char *username) {
 531         char strbuf[ISC_STRERRORSIZE];
 532         if (username == NULL)
 533                 return;
 534
 535         if (all_digits(username))
 536                 runas_pw = getpwuid((uid_t)atoi(username));
 537         else
 538                 runas_pw = getpwnam(username);
 539         endpwent();
 540
 541         if (runas_pw == NULL)
 542                 ns_main_earlyfatal("user '%s' unknown", username);
 543
 544         if (getuid() == 0) {
 545                 if (initgroups(runas_pw->pw_name, runas_pw->pw_gid) < 0) {
 546                         isc__strerror(errno, strbuf, sizeof(strbuf));
 547                         ns_main_earlyfatal("initgroups(): %s", strbuf);
 548                 }
 549         }
 550
 551 }
 552
 553 void
 554 ns_os_changeuser(void) {
 555         char strbuf[ISC_STRERRORSIZE];
 556         if (runas_pw == NULL || done_setuid)
 557                 return;
 558
 559         done_setuid = ISC_TRUE;
 560
 561 #ifdef HAVE_LINUXTHREADS
 562 #ifdef HAVE_LINUX_CAPABILITY_H
 563         if (!non_root_caps)
 564                 ns_main_earlyfatal("-u with Linux threads not supported: "
 565                                    "requires kernel support for "
 566                                    "prctl(PR_SET_KEEPCAPS)");
 567 #else
 568         ns_main_earlyfatal("-u with Linux threads not supported: "
 569                            "no capabilities support or capabilities "
 570                            "disabled at build time");
 571 #endif
 572 #endif
 573
 574         if (setgid(runas_pw->pw_gid) < 0) {
 575                 isc__strerror(errno, strbuf, sizeof(strbuf));
 576                 ns_main_earlyfatal("setgid(): %s", strbuf);
 577         }
 578
 579         if (setuid(runas_pw->pw_uid) < 0) {
 580                 isc__strerror(errno, strbuf, sizeof(strbuf));
 581                 ns_main_earlyfatal("setuid(): %s", strbuf);
 582         }
 583
 584 #if defined(HAVE_SYS_PRCTL_H) && defined(PR_SET_DUMPABLE)
 585         /*
 586          * Restore the ability of named to drop core after the setuid()
 587          * call has disabled it.
 588          */
 589         if (prctl(PR_SET_DUMPABLE,1,0,0,0) < 0) {
 590                 isc__strerror(errno, strbuf, sizeof(strbuf));
 591                 ns_main_earlywarning("prctl(PR_SET_DUMPABLE) failed: %s",
 592                                      strbuf);
 593         }
 594 #endif
 595 #if defined(HAVE_LINUX_CAPABILITY_H) && !defined(HAVE_LINUXTHREADS)
 596         linux_minprivs();
 597 #endif
 598 }
 599
 600 void
 601 ns_os_adjustnofile() {
 602 #ifdef HAVE_LINUXTHREADS
 603         isc_result_t result;
 604         isc_resourcevalue_t newvalue;
 605
 606         /*
 607          * Linux: max number of open files specified by one thread doesn't seem
 608          * to apply to other threads on Linux.
 609          */
 610         newvalue = ISC_RESOURCE_UNLIMITED;
 611
 612         result = isc_resource_setlimit(isc_resource_openfiles, newvalue);
 613         if (result != ISC_R_SUCCESS)
 614                 ns_main_earlywarning("couldn't adjust limit on open files");
 615 #endif
 616 }
 617
 618 void
 619 ns_os_minprivs(void) {
 620 #ifdef HAVE_SYS_PRCTL_H
 621         linux_keepcaps();
 622 #endif
 623
 624 #ifdef HAVE_LINUXTHREADS
 625         ns_os_changeuser(); /* Call setuid() before threads are started */
 626 #endif
 627
 628 #if defined(HAVE_LINUX_CAPABILITY_H) && defined(HAVE_LINUXTHREADS)
 629         linux_minprivs();
 630 #endif
 631 }
 632
 633 static int
 634 safe_open(const char *filename, isc_boolean_t append) {
 635         int fd;
 636         struct stat sb;
 637
 638         if (stat(filename, &sb) == -1) {
 639                 if (errno != ENOENT)
 640                         return (-1);
 641         } else if ((sb.st_mode & S_IFREG) == 0) {
 642                 errno = EOPNOTSUPP;
 643                 return (-1);
 644         }
 645
 646         if (append)
 647                 fd = open(filename, O_WRONLY|O_CREAT|O_APPEND,
 648                           S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
 649         else {
 650                 if (unlink(filename) < 0 && errno != ENOENT)
 651                         return (-1);
 652                 fd = open(filename, O_WRONLY|O_CREAT|O_EXCL,
 653                           S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
 654         }
 655         return (fd);
 656 }
 657
 658 static void
 659 cleanup_pidfile(void) {
 660         int n;
 661         if (pidfile != NULL) {
 662                 n = unlink(pidfile);
 663                 if (n == -1 && errno != ENOENT)
 664                         ns_main_earlywarning("unlink '%s': failed", pidfile);
 665                 free(pidfile);
 666         }
 667         pidfile = NULL;
 668 }
 669
 670 void
 671 ns_os_writepidfile(const char *filename, isc_boolean_t first_time) {
 672         int fd;
 673         FILE *lockfile;
 674         size_t len;
 675         pid_t pid;
 676         char strbuf[ISC_STRERRORSIZE];
 677         void (*report)(const char *, ...);
 678
 679         /*
 680          * The caller must ensure any required synchronization.
 681          */
 682
 683         report = first_time ? ns_main_earlyfatal : ns_main_earlywarning;
 684
 685         cleanup_pidfile();
 686
 687         if (filename == NULL)
 688                 return;
 689
 690         len = strlen(filename);
 691         pidfile = malloc(len + 1);
 692         if (pidfile == NULL) {
 693                 isc__strerror(errno, strbuf, sizeof(strbuf));
 694                 (*report)("couldn't malloc '%s': %s", filename, strbuf);
 695                 return;
 696         }
 697         /* This is safe. */
 698         strcpy(pidfile, filename);
 699
 700         fd = safe_open(filename, ISC_FALSE);
 701         if (fd < 0) {
 702                 isc__strerror(errno, strbuf, sizeof(strbuf));
 703                 (*report)("couldn't open pid file '%s': %s", filename, strbuf);
 704                 free(pidfile);
 705                 pidfile = NULL;
 706                 return;
 707         }
 708         lockfile = fdopen(fd, "w");
 709         if (lockfile == NULL) {
 710                 isc__strerror(errno, strbuf, sizeof(strbuf));
 711                 (*report)("could not fdopen() pid file '%s': %s",
 712                           filename, strbuf);
 713                 (void)close(fd);
 714                 cleanup_pidfile();
 715                 return;
 716         }
 717 #ifdef HAVE_LINUXTHREADS
 718         pid = mainpid;
 719 #else
 720         pid = getpid();
 721 #endif
 722         if (fprintf(lockfile, "%ld\n", (long)pid) < 0) {
 723                 (*report)("fprintf() to pid file '%s' failed", filename);
 724                 (void)fclose(lockfile);
 725                 cleanup_pidfile();
 726                 return;
 727         }
 728         if (fflush(lockfile) == EOF) {
 729                 (*report)("fflush() to pid file '%s' failed", filename);
 730                 (void)fclose(lockfile);
 731                 cleanup_pidfile();
 732                 return;
 733         }
 734         (void)fclose(lockfile);
 735 }
 736
 737 void
 738 ns_os_shutdown(void) {
 739         closelog();
 740         cleanup_pidfile();
 741 }
 742
 743 isc_result_t
 744 ns_os_gethostname(char *buf, size_t len) {
 745         int n;
 746
 747         n = gethostname(buf, len);
 748         return ((n == 0) ? ISC_R_SUCCESS : ISC_R_FAILURE);
 749 }
 750
 751 static char *
 752 next_token(char **stringp, const char *delim) {
 753         char *res;
 754
 755         do {
 756                 res = strsep(stringp, delim);
 757                 if (res == NULL)
 758                         break;
 759         } while (*res == '\0');
 760         return (res);
 761 }
 762
 763 void
 764 ns_os_shutdownmsg(char *command, isc_buffer_t *text) {
 765         char *input, *ptr;
 766         unsigned int n;
 767         pid_t pid;
 768
 769         input = command;
 770
 771         /* Skip the command name. */
 772         ptr = next_token(&input, " \t");
 773         if (ptr == NULL)
 774                 return;
 775
 776         ptr = next_token(&input, " \t");
 777         if (ptr == NULL)
 778                 return;
 779
 780         if (strcmp(ptr, "-p") != 0)
 781                 return;
 782
 783 #ifdef HAVE_LINUXTHREADS
 784         pid = mainpid;
 785 #else
 786         pid = getpid();
 787 #endif
 788
 789         n = snprintf((char *)isc_buffer_used(text),
 790                      isc_buffer_availablelength(text),
 791                      "pid: %ld", (long)pid);
 792         /* Only send a message if it is complete. */
 793         if (n < isc_buffer_availablelength(text))
 794                 isc_buffer_add(text, n);
 795 }
 796
 797 void
 798 ns_os_tzset(void) {
 799 #ifdef HAVE_TZSET
 800         tzset();
 801 #endif
 802 }