support/nsm/file.c

   1 /*
   2  * Copyright 2009 Oracle.  All rights reserved.
   3  *
   4  * This file is part of nfs-utils.
   5  *
   6  * nfs-utils is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * nfs-utils 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
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with nfs-utils.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /*
  21  * NSM for Linux.
  22  *
  23  * Callback information and NSM state is stored in files, usually
  24  * under /var/lib/nfs.  A database of information contained in local
  25  * files stores NLM callback data and what remote peers to notify of
  26  * reboots.
  27  *
  28  * For each monitored remote peer, a text file is created under the
  29  * directory specified by NSM_MONITOR_DIR.  The name of the file
  30  * is a valid DNS hostname.  The hostname string must be a valid
  31  * ASCII DNS name, and must not contain slash characters, white space,
  32  * or '\0' (ie. anything that might have some special meaning in a
  33  * path name).
  34  *
  35  * The contents of each file include seven blank-separated fields of
  36  * text, finished with '\n'.  The first field contains the network
  37  * address of the NLM service to call back.  The current implementation
  38  * supports using only IPv4 addresses, so the only contents of this
  39  * field are a network order IPv4 address expressed in 8 hexadecimal
  40  * characters.
  41  *
  42  * The next four fields are text strings of hexadecimal characters,
  43  * representing:
  44  *
  45  * 2. A 4 byte RPC program number of the NLM service to call back
  46  * 3. A 4 byte RPC version number of the NLM service to call back
  47  * 4. A 4 byte RPC procedure number of the NLM service to call back
  48  * 5. A 16 byte opaque cookie that the NLM service uses to identify
  49  *    the monitored host
  50  *
  51  * The sixth field is the monitored host's mon_name, passed to statd
  52  * via an SM_MON request.
  53  *
  54  * The seventh field is the my_name for this peer, which is the
  55  * hostname of the local NLM (currently on Linux, the result of
  56  * `uname -n`).  This can be used as the source address/hostname
  57  * when sending SM_NOTIFY requests.
  58  *
  59  * The NSM protocol does not limit the contents of these strings
  60  * in any way except that they must fit into 1024 bytes.  Our
  61  * implementation requires that these strings not contain
  62  * white space or '\0'.
  63  */
  64
  65 #ifdef HAVE_CONFIG_H
  66 #include <config.h>
  67 #endif
  68
  69 #include <sys/types.h>
  70 #include <sys/stat.h>
  71
  72 #include <ctype.h>
  73 #include <string.h>
  74 #include <stdint.h>
  75 #ifndef S_SPLINT_S
  76 #include <unistd.h>
  77 #endif
  78 #include <libgen.h>
  79 #include <stdio.h>
  80 #include <errno.h>
  81 #include <fcntl.h>
  82 #include <dirent.h>
  83 #include <grp.h>
  84
  85 #include "xlog.h"
  86 #include "nsm.h"
  87
  88 #define RPCARGSLEN      (4 * (8 + 1))
  89 #define LINELEN         (RPCARGSLEN + SM_PRIV_SIZE * 2 + 1)
  90
  91 #define NSM_KERNEL_STATE_FILE   "/proc/sys/fs/nfs/nsm_local_state"
  92
  93 /*
  94  * Some distributions place statd's files in a subdirectory
  95  */
  96 #define NSM_PATH_EXTENSION
  97 /* #define NSM_PATH_EXTENSION   "/statd" */
  98
  99 #define NSM_DEFAULT_STATEDIR            NFS_STATEDIR NSM_PATH_EXTENSION
 100
 101 static char nsm_base_dirname[PATH_MAX] = NSM_DEFAULT_STATEDIR;
 102
 103 #define NSM_MONITOR_DIR "sm"
 104 #define NSM_NOTIFY_DIR  "sm.bak"
 105 #define NSM_STATE_FILE  "state"
 106
 107
 108 static _Bool
 109 error_check(const int len, const size_t buflen)
 110 {
 111         return (len < 0) || ((size_t)len >= buflen);
 112 }
 113
 114 static _Bool
 115 exact_error_check(const ssize_t len, const size_t buflen)
 116 {
 117         return (len < 0) || ((size_t)len != buflen);
 118 }
 119
 120 /*
 121  * Returns a dynamically allocated, '\0'-terminated buffer
 122  * containing an appropriate pathname, or NULL if an error
 123  * occurs.  Caller must free the returned result with free(3).
 124  */
 125 __attribute_malloc__
 126 static char *
 127 nsm_make_record_pathname(const char *directory, const char *hostname)
 128 {
 129         const char *c;
 130         size_t size;
 131         char *path;
 132         int len;
 133
 134         /*
 135          * Block hostnames that contain characters that have
 136          * meaning to the file system (like '/'), or that can
 137          * be confusing on visual inspection (like ' ').
 138          */
 139         for (c = hostname; *c != '\0'; c++)
 140                 if (*c == '/' || isspace((int)*c) != 0) {
 141                         xlog(D_GENERAL, "Hostname contains invalid characters");
 142                         return NULL;
 143                 }
 144
 145         size = strlen(nsm_base_dirname) + strlen(directory) + strlen(hostname) + 3;
 146         if (size > PATH_MAX) {
 147                 xlog(D_GENERAL, "Hostname results in pathname that is too long");
 148                 return NULL;
 149         }
 150
 151         path = malloc(size);
 152         if (path == NULL) {
 153                 xlog(D_GENERAL, "Failed to allocate memory for pathname");
 154                 return NULL;
 155         }
 156
 157         len = snprintf(path, size, "%s/%s/%s",
 158                         nsm_base_dirname, directory, hostname);
 159         if (error_check(len, size)) {
 160                 xlog(D_GENERAL, "Pathname did not fit in specified buffer");
 161                 free(path);
 162                 return NULL;
 163         }
 164
 165         return path;
 166 }
 167
 168 /*
 169  * Returns a dynamically allocated, '\0'-terminated buffer
 170  * containing an appropriate pathname, or NULL if an error
 171  * occurs.  Caller must free the returned result with free(3).
 172  */
 173 __attribute_malloc__
 174 static char *
 175 nsm_make_pathname(const char *directory)
 176 {
 177         size_t size;
 178         char *path;
 179         int len;
 180
 181         size = strlen(nsm_base_dirname) + strlen(directory) + 2;
 182         if (size > PATH_MAX)
 183                 return NULL;
 184
 185         path = malloc(size);
 186         if (path == NULL)
 187                 return NULL;
 188
 189         len = snprintf(path, size, "%s/%s", nsm_base_dirname, directory);
 190         if (error_check(len, size)) {
 191                 free(path);
 192                 return NULL;
 193         }
 194
 195         return path;
 196 }
 197
 198 /**
 199  * nsm_setup_pathnames - set up pathname
 200  * @progname: C string containing name of program, for error messages
 201  * @parentdir: C string containing pathname to on-disk state, or NULL
 202  *
 203  * This runs before logging is set up, so error messages are directed
 204  * to stderr.
 205  *
 206  * Returns true and sets up our pathnames, if @parentdir was valid
 207  * and usable; otherwise false is returned.
 208  */
 209 _Bool
 210 nsm_setup_pathnames(const char *progname, const char *parentdir)
 211 {
 212         static char buf[PATH_MAX];
 213         struct stat st;
 214         char *path;
 215
 216         /* First: test length of name and whether it exists */
 217         if (lstat(parentdir, &st) == -1) {
 218                 (void)fprintf(stderr, "%s: Failed to stat %s: %s",
 219                                 progname, parentdir, strerror(errno));
 220                 return false;
 221         }
 222
 223         /* Ensure we have a clean directory pathname */
 224         strncpy(buf, parentdir, sizeof(buf));
 225         path = dirname(buf);
 226         if (*path == '.') {
 227                 (void)fprintf(stderr, "%s: Unusable directory %s",
 228                                 progname, parentdir);
 229                 return false;
 230         }
 231
 232         xlog(D_CALL, "Using %s as the state directory", parentdir);
 233         strncpy(nsm_base_dirname, parentdir, sizeof(nsm_base_dirname));
 234         return true;
 235 }
 236
 237 /**
 238  * nsm_is_default_parentdir - check if parent directory is default
 239  *
 240  * Returns true if the active statd parent directory, set by
 241  * nsm_change_pathname(), is the same as the built-in default
 242  * parent directory; otherwise false is returned.
 243  */
 244 _Bool
 245 nsm_is_default_parentdir(void)
 246 {
 247         return strcmp(nsm_base_dirname, NSM_DEFAULT_STATEDIR) == 0;
 248 }
 249
 250 /**
 251  * nsm_drop_privileges - drop root privileges
 252  * @pidfd: file descriptor of a pid file
 253  *
 254  * Returns true if successful, or false if some error occurred.
 255  *
 256  * Set our effective UID and GID to that of our on-disk database.
 257  */
 258 _Bool
 259 nsm_drop_privileges(const int pidfd)
 260 {
 261         struct stat st;
 262
 263         (void)umask(S_IRWXO);
 264
 265         /*
 266          * XXX: If we can't stat dirname, or if dirname is owned by
 267          *      root, we should use "statduser" instead, which is set up
 268          *      by configure.ac.  Nothing in nfs-utils seems to use
 269          *      "statduser," though.
 270          */
 271         if (lstat(nsm_base_dirname, &st) == -1) {
 272                 xlog(L_ERROR, "Failed to stat %s: %m", nsm_base_dirname);
 273                 return false;
 274         }
 275
 276         if (st.st_uid == 0) {
 277                 xlog_warn("Running as root.  "
 278                         "chown %s to choose different user", nsm_base_dirname);
 279                 return true;
 280         }
 281
 282         if (chdir(nsm_base_dirname) == -1) {
 283                 xlog(L_ERROR, "Failed to change working directory to %s: %m",
 284                                 nsm_base_dirname);
 285                 return false;
 286         }
 287
 288         /*
 289          * If the pidfile happens to reside on NFS, dropping privileges
 290          * will probably cause us to lose access, even though we are
 291          * holding it open.  Chown it to prevent this.
 292          */
 293         if (pidfd >= 0)
 294                 if (fchown(pidfd, st.st_uid, st.st_gid) == -1)
 295                         xlog_warn("Failed to change owner of pidfile: %m");
 296
 297         if (setgroups(0, NULL) == -1) {
 298                 xlog(L_ERROR, "Failed to drop supplementary groups: %m");
 299                 return false;
 300         }
 301
 302         /*
 303          * ORDER
 304          *
 305          * setgid(2) first, as setuid(2) may remove privileges needed
 306          * to set the group id.
 307          */
 308         if (setgid(st.st_gid) == -1 || setuid(st.st_uid) == -1) {
 309                 xlog(L_ERROR, "Failed to drop privileges: %m");
 310                 return false;
 311         }
 312
 313         xlog(D_CALL, "Effective UID, GID: %u, %u", st.st_uid, st.st_gid);
 314         return true;
 315 }
 316
 317 /**
 318  * nsm_get_state - retrieve on-disk NSM state number
 319  *
 320  * Returns an odd NSM state number read from disk, or an initial
 321  * state number.  Zero is returned if some error occurs.
 322  */
 323 int
 324 nsm_get_state(_Bool update)
 325 {
 326         int fd, state = 0;
 327         ssize_t result;
 328         char *path = NULL;
 329         char *newpath = NULL;
 330
 331         path = nsm_make_pathname(NSM_STATE_FILE);
 332         if (path == NULL) {
 333                 xlog(L_ERROR, "Failed to allocate path for " NSM_STATE_FILE);
 334                 goto out;
 335         }
 336
 337         fd = open(path, O_RDONLY);
 338         if (fd == -1) {
 339                 if (errno != ENOENT) {
 340                         xlog(L_ERROR, "Failed to open %s: %m", path);
 341                         goto out;
 342                 }
 343
 344                 xlog(L_NOTICE, "Initializing NSM state");
 345                 state = 1;
 346                 update = true;
 347                 goto update;
 348         }
 349
 350         result = read(fd, &state, sizeof(state));
 351         if (exact_error_check(result, sizeof(state))) {
 352                 xlog_warn("Failed to read %s: %m", path);
 353
 354                 xlog(L_NOTICE, "Initializing NSM state");
 355                 state = 1;
 356                 update = true;
 357                 goto update;
 358         }
 359
 360         if ((state & 1) == 0)
 361                 state++;
 362
 363 update:
 364         (void)close(fd);
 365
 366         if (update) {
 367                 state += 2;
 368
 369                 newpath = nsm_make_pathname(NSM_STATE_FILE ".new");
 370                 if (newpath == NULL) {
 371                         xlog(L_ERROR,
 372                           "Failed to create path for " NSM_STATE_FILE ".new");
 373                         state = 0;
 374                         goto out;
 375                 }
 376
 377                 fd = open(newpath, O_CREAT | O_SYNC | O_WRONLY, 0644);
 378                 if (fd == -1) {
 379                         xlog(L_ERROR, "Failed to create %s: %m", newpath);
 380                         state = 0;
 381                         goto out;
 382                 }
 383
 384                 result = write(fd, &state, sizeof(state));
 385                 if (exact_error_check(result, sizeof(state))) {
 386                         xlog(L_ERROR, "Failed to write %s: %m", newpath);
 387                         (void)close(fd);
 388                         (void)unlink(newpath);
 389                         state = 0;
 390                         goto out;
 391                 }
 392
 393                 if (close(fd) == -1) {
 394                         xlog(L_ERROR, "Failed to close %s: %m", newpath);
 395                         (void)unlink(newpath);
 396                         state = 0;
 397                         goto out;
 398                 }
 399
 400                 if (rename(newpath, path) == -1) {
 401                         xlog(L_ERROR, "Failed to rename %s -> %s: %m",
 402                                         newpath, path);
 403                         (void)unlink(newpath);
 404                         state = 0;
 405                         goto out;
 406                 }
 407
 408                 /* Ostensibly, a sync(2) is not needed here because
 409                  * open(O_CREAT), write(O_SYNC), and rename(2) are
 410                  * already synchronous with persistent storage, for
 411                  * any file system we care about. */
 412         }
 413
 414 out:
 415         free(newpath);
 416         free(path);
 417         return state;
 418 }
 419
 420 /**
 421  * nsm_update_kernel_state - attempt to post new NSM state to kernel
 422  * @state: NSM state number
 423  *
 424  */
 425 void
 426 nsm_update_kernel_state(const int state)
 427 {
 428         ssize_t result;
 429         char buf[20];
 430         int fd, len;
 431
 432         fd = open(NSM_KERNEL_STATE_FILE, O_WRONLY);
 433         if (fd == -1) {
 434                 xlog(D_GENERAL, "Failed to open " NSM_KERNEL_STATE_FILE ": %m");
 435                 return;
 436         }
 437
 438         len = snprintf(buf, sizeof(buf), "%d", state);
 439         if (error_check(len, sizeof(buf))) {
 440                 xlog_warn("Failed to form NSM state number string");
 441                 return;
 442         }
 443
 444         result = write(fd, buf, strlen(buf));
 445         if (exact_error_check(result, strlen(buf)))
 446                 xlog_warn("Failed to write NSM state number: %m");
 447
 448         if (close(fd) == -1)
 449                 xlog(L_ERROR, "Failed to close NSM state file "
 450                                 NSM_KERNEL_STATE_FILE ": %m");
 451 }
 452
 453 /**
 454  * nsm_retire_monitored_hosts - back up all hosts from "sm/" to "sm.bak/"
 455  *
 456  * Returns the count of host records that were moved.
 457  *
 458  * Note that if any error occurs during this process, some monitor
 459  * records may be left in the "sm" directory.
 460  */
 461 unsigned int
 462 nsm_retire_monitored_hosts(void)
 463 {
 464         unsigned int count = 0;
 465         struct dirent *de;
 466         char *path;
 467         DIR *dir;
 468
 469         path = nsm_make_pathname(NSM_MONITOR_DIR);
 470         if (path == NULL) {
 471                 xlog(L_ERROR, "Failed to allocate path for " NSM_MONITOR_DIR);
 472                 return count;
 473         }
 474
 475         dir = opendir(path);
 476         free(path);
 477         if (dir == NULL) {
 478                 xlog_warn("Failed to open " NSM_MONITOR_DIR ": %m");
 479                 return count;
 480         }
 481
 482         while ((de = readdir(dir)) != NULL) {
 483                 char *src, *dst;
 484
 485                 if (de->d_type != (unsigned char)DT_REG)
 486                         continue;
 487                 if (de->d_name[0] == '.')
 488                         continue;
 489
 490                 src = nsm_make_record_pathname(NSM_MONITOR_DIR, de->d_name);
 491                 if (src == NULL) {
 492                         xlog_warn("Bad monitor file name, skipping");
 493                         continue;
 494                 }
 495
 496                 dst = nsm_make_record_pathname(NSM_NOTIFY_DIR, de->d_name);
 497                 if (dst == NULL) {
 498                         free(src);
 499                         xlog_warn("Bad notify file name, skipping");
 500                         continue;
 501                 }
 502
 503                 if (rename(src, dst) == -1)
 504                         xlog_warn("Failed to rename %s -> %s: %m",
 505                                 src, dst);
 506                 else {
 507                         xlog(D_GENERAL, "Retired record for mon_name %s",
 508                                         de->d_name);
 509                         count++;
 510                 }
 511
 512                 free(dst);
 513                 free(src);
 514         }
 515
 516         (void)closedir(dir);
 517         return count;
 518 }
 519
 520 /*
 521  * Returns the length in bytes of the created record.
 522  */
 523 __attribute_noinline__
 524 static size_t
 525 nsm_create_monitor_record(char *buf, const size_t buflen,
 526                 const struct sockaddr *sap, const struct mon *m)
 527 {
 528         const struct sockaddr_in *sin = (const struct sockaddr_in *)sap;
 529         size_t remaining = buflen;
 530         int i, len;
 531
 532         len = snprintf(buf, remaining, "%08x %08x %08x %08x ",
 533                         (unsigned int)sin->sin_addr.s_addr,
 534                         (unsigned int)m->mon_id.my_id.my_prog,
 535                         (unsigned int)m->mon_id.my_id.my_vers,
 536                         (unsigned int)m->mon_id.my_id.my_proc);
 537         if (error_check(len, remaining))
 538                 return 0;
 539         buf += len;
 540         remaining -= (size_t)len;
 541
 542         for (i = 0; i < SM_PRIV_SIZE; i++) {
 543                 len = snprintf(buf, remaining, "%02x",
 544                                 (unsigned int)(0xff & m->priv[i]));
 545                 if (error_check(len, remaining))
 546                         return 0;
 547                 buf += len;
 548                 remaining -= (size_t)len;
 549         }
 550
 551         len = snprintf(buf, remaining, " %s %s\n",
 552                         m->mon_id.mon_name, m->mon_id.my_id.my_name);
 553         if (error_check(len, remaining))
 554                 return 0;
 555         remaining -= (size_t)len;
 556
 557         return buflen - remaining;
 558 }
 559
 560 /**
 561  * nsm_insert_monitored_host - write callback data for one host to disk
 562  * @hostname: C string containing a hostname
 563  * @sap: sockaddr containing NLM callback address
 564  * @mon: SM_MON arguments to save
 565  *
 566  * Returns true if successful, otherwise false if some error occurs.
 567  */
 568 _Bool
 569 nsm_insert_monitored_host(const char *hostname, const struct sockaddr *sap,
 570                 const struct mon *m)
 571 {
 572         static char buf[LINELEN + 1 + SM_MAXSTRLEN + 2];
 573         char *path;
 574         _Bool result = false;
 575         ssize_t len;
 576         size_t size;
 577         int fd;
 578
 579         path = nsm_make_record_pathname(NSM_MONITOR_DIR, hostname);
 580         if (path == NULL) {
 581                 xlog(L_ERROR, "Failed to insert: bad monitor hostname '%s'",
 582                                 hostname);
 583                 return false;
 584         }
 585
 586         size = nsm_create_monitor_record(buf, sizeof(buf), sap, m);
 587         if (size == 0) {
 588                 xlog(L_ERROR, "Failed to insert: record too long");
 589                 goto out;
 590         }
 591
 592         fd = open(path, O_WRONLY | O_CREAT | O_SYNC, S_IRUSR | S_IWUSR);
 593         if (fd == -1) {
 594                 xlog(L_ERROR, "Failed to insert: creating %s: %m", path);
 595                 goto out;
 596         }
 597         result = true;
 598
 599         len = write(fd, buf, size);
 600         if (exact_error_check(len, size)) {
 601                 xlog_warn("Failed to insert: writing %s: %m", path);
 602                 (void)unlink(path);
 603                 result = false;
 604         }
 605
 606         if (close(fd) == -1) {
 607                 xlog(L_ERROR, "Failed to insert: closing %s: %m", path);
 608                 (void)unlink(path);
 609                 result = false;
 610         }
 611
 612 out:
 613         free(path);
 614         return result;
 615 }
 616
 617 __attribute_noinline__
 618 static _Bool
 619 nsm_parse_line(char *line, struct sockaddr_in *sin, struct mon *m)
 620 {
 621         unsigned int i, tmp;
 622         int count;
 623         char *c;
 624
 625         c = strchr(line, '\n');
 626         if (c != NULL)
 627                 *c = '\0';
 628
 629         count = sscanf(line, "%8x %8x %8x %8x ",
 630                         (unsigned int *)&sin->sin_addr.s_addr,
 631                         (unsigned int *)&m->mon_id.my_id.my_prog,
 632                         (unsigned int *)&m->mon_id.my_id.my_vers,
 633                         (unsigned int *)&m->mon_id.my_id.my_proc);
 634         if (count != 4)
 635                 return false;
 636
 637         c = line + RPCARGSLEN;
 638         for (i = 0; i < SM_PRIV_SIZE; i++) {
 639                 if (sscanf(c, "%2x", &tmp) != 1)
 640                         return false;
 641                 m->priv[i] = (char)tmp;
 642                 c += 2;
 643         }
 644
 645         c++;
 646         m->mon_id.mon_name = c;
 647         while (*c != '\0' && *c != ' ')
 648                 c++;
 649         if (*c != '\0')
 650                 *c++ = '\0';
 651         while (*c == ' ')
 652                 c++;
 653         m->mon_id.my_id.my_name = c;
 654
 655         return true;
 656 }
 657
 658 /*
 659  * Stuff a 'struct mon' with callback data, and call @func.
 660  *
 661  * Returns the count of in-core records created.
 662  */
 663 static unsigned int
 664 nsm_read_line(const char *hostname, const time_t timestamp, char *line,
 665                 nsm_populate_t func)
 666 {
 667         struct sockaddr_in sin = {
 668                 .sin_family             = AF_INET,
 669         };
 670         struct mon m;
 671
 672         if (!nsm_parse_line(line, &sin, &m))
 673                 return 0;
 674
 675         return func(hostname, (struct sockaddr *)(char *)&sin, &m, timestamp);
 676 }
 677
 678 /*
 679  * Given a filename, reads data from a file under NSM_MONITOR_DIR
 680  * and invokes @func so caller can populate their in-core
 681  * database with this data.
 682  */
 683 static unsigned int
 684 nsm_load_host(const char *directory, const char *filename, nsm_populate_t func)
 685 {
 686         char buf[LINELEN + 1 + SM_MAXSTRLEN + 2];
 687         unsigned int result = 0;
 688         struct stat stb;
 689         char *path;
 690         FILE *f;
 691
 692         path = nsm_make_record_pathname(directory, filename);
 693         if (path == NULL)
 694                 goto out_err;
 695
 696         if (stat(path, &stb) == -1) {
 697                 xlog(L_ERROR, "Failed to stat %s: %m", path);
 698                 goto out_freepath;
 699         }
 700
 701         f = fopen(path, "r");
 702         if (f == NULL) {
 703                 xlog(L_ERROR, "Failed to open %s: %m", path);
 704                 goto out_freepath;
 705         }
 706
 707         while (fgets(buf, (int)sizeof(buf), f) != NULL) {
 708                 buf[sizeof(buf) - 1] = '\0';
 709                 result += nsm_read_line(filename, stb.st_mtime, buf, func);
 710         }
 711         if (result == 0)
 712                 xlog(L_ERROR, "Failed to read monitor data from %s", path);
 713
 714         (void)fclose(f);
 715
 716 out_freepath:
 717         free(path);
 718 out_err:
 719         return result;
 720 }
 721
 722 static unsigned int
 723 nsm_load_dir(const char *directory, nsm_populate_t func)
 724 {
 725         unsigned int count = 0;
 726         struct dirent *de;
 727         char *path;
 728         DIR *dir;
 729
 730         path = nsm_make_pathname(directory);
 731         if (path == NULL) {
 732                 xlog(L_ERROR, "Failed to allocate path for directory %s",
 733                                 directory);
 734                 return 0;
 735         }
 736
 737         dir = opendir(path);
 738         free(path);
 739         if (dir == NULL) {
 740                 xlog(L_ERROR, "Failed to open directory %s: %m",
 741                                 directory);
 742                 return 0;
 743         }
 744
 745         while ((de = readdir(dir)) != NULL) {
 746                 if (de->d_type != (unsigned char)DT_REG)
 747                         continue;
 748                 if (de->d_name[0] == '.')
 749                         continue;
 750
 751                 count += nsm_load_host(directory, de->d_name, func);
 752         }
 753
 754         (void)closedir(dir);
 755         return count;
 756 }
 757
 758 /**
 759  * nsm_load_monitor_list - load list of hosts to monitor
 760  * @func: callback function to create entry for one host
 761  *
 762  * Returns the count of hosts that were found in the directory.
 763  */
 764 unsigned int
 765 nsm_load_monitor_list(nsm_populate_t func)
 766 {
 767         return nsm_load_dir(NSM_MONITOR_DIR, func);
 768 }
 769
 770 /**
 771  * nsm_load_notify_list - load list of hosts to notify
 772  * @func: callback function to create entry for one host
 773  *
 774  * Returns the count of hosts that were found in the directory.
 775  */
 776 unsigned int
 777 nsm_load_notify_list(nsm_populate_t func)
 778 {
 779         return nsm_load_dir(NSM_NOTIFY_DIR, func);
 780 }
 781
 782 static void
 783 nsm_delete_host(const char *directory, const char *hostname)
 784 {
 785         char *path;
 786
 787         path = nsm_make_record_pathname(directory, hostname);
 788         if (path == NULL) {
 789                 xlog(L_ERROR, "Bad filename, not deleting");
 790                 return;
 791         }
 792
 793         if (unlink(path) == -1)
 794                 xlog(L_ERROR, "Failed to unlink %s: %m", path);
 795
 796         free(path);
 797 }
 798
 799 /**
 800  * nsm_delete_monitored_host - delete on-disk record for monitored host
 801  * @hostname: '\0'-terminated C string containing hostname of record to delete
 802  *
 803  */
 804 void
 805 nsm_delete_monitored_host(const char *hostname)
 806 {
 807         nsm_delete_host(NSM_MONITOR_DIR, hostname);
 808 }
 809
 810 /**
 811  * nsm_delete_notified_host - delete on-disk host record after notification
 812  * @hostname: '\0'-terminated C string containing hostname of record to delete
 813  *
 814  */
 815 void
 816 nsm_delete_notified_host(const char *hostname)
 817 {
 818         nsm_delete_host(NSM_NOTIFY_DIR, hostname);
 819 }