lib/libutil/pidfile.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2005 Pawel Jakub Dawidek <pjd@FreeBSD.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/types.h>
  34 #include <sys/capsicum.h>
  35 #include <sys/file.h>
  36 #include <sys/stat.h>
  37
  38 #include <err.h>
  39 #include <errno.h>
  40 #include <fcntl.h>
  41 #include <libgen.h>
  42 #include <libutil.h>
  43 #include <signal.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <time.h>
  48 #include <unistd.h>
  49
  50 struct pidfh {
  51         int     pf_dirfd;
  52         int     pf_fd;
  53         char    pf_dir[MAXPATHLEN + 1];
  54         char    pf_filename[MAXPATHLEN + 1];
  55         dev_t   pf_dev;
  56         ino_t   pf_ino;
  57 };
  58
  59 static int _pidfile_remove(struct pidfh *pfh, int freeit);
  60
  61 static int
  62 pidfile_verify(const struct pidfh *pfh)
  63 {
  64         struct stat sb;
  65
  66         if (pfh == NULL || pfh->pf_fd == -1)
  67                 return (EDOOFUS);
  68         /*
  69          * Check remembered descriptor.
  70          */
  71         if (fstat(pfh->pf_fd, &sb) == -1)
  72                 return (errno);
  73         if (sb.st_dev != pfh->pf_dev || sb.st_ino != pfh->pf_ino)
  74                 return (EDOOFUS);
  75         return (0);
  76 }
  77
  78 static int
  79 pidfile_read_impl(int dirfd, const char *filename, pid_t *pidptr)
  80 {
  81         char buf[16], *endptr;
  82         int error, fd, i;
  83
  84         fd = openat(dirfd, filename, O_RDONLY | O_CLOEXEC);
  85         if (fd == -1)
  86                 return (errno);
  87
  88         i = read(fd, buf, sizeof(buf) - 1);
  89         error = errno;  /* Remember errno in case close() wants to change it. */
  90         close(fd);
  91         if (i == -1)
  92                 return (error);
  93         else if (i == 0)
  94                 return (EAGAIN);
  95         buf[i] = '\0';
  96
  97         *pidptr = strtol(buf, &endptr, 10);
  98         if (endptr != &buf[i])
  99                 return (EINVAL);
 100
 101         return (0);
 102 }
 103
 104 static int
 105 pidfile_read(int dirfd, const char *filename, pid_t *pidptr)
 106 {
 107         struct timespec rqtp;
 108         int count;
 109
 110         count = 20;
 111         rqtp.tv_sec = 0;
 112         rqtp.tv_nsec = 5000000;
 113         for (;;) {
 114                 errno = pidfile_read_impl(dirfd, filename, pidptr);
 115                 if (errno != EAGAIN || --count == 0)
 116                         break;
 117                 nanosleep(&rqtp, 0);
 118         }
 119         if (errno == EAGAIN)
 120                 *pidptr = -1;
 121         return (errno);
 122 }
 123
 124 struct pidfh *
 125 pidfile_open(const char *pathp, mode_t mode, pid_t *pidptr)
 126 {
 127         char path[MAXPATHLEN];
 128         struct pidfh *pfh;
 129         struct stat sb;
 130         int error, fd, dirfd, dirlen, filenamelen;
 131         cap_rights_t caprights;
 132
 133         pfh = malloc(sizeof(*pfh));
 134         if (pfh == NULL)
 135                 return (NULL);
 136
 137         if (pathp == NULL) {
 138                 dirlen = snprintf(pfh->pf_dir, sizeof(pfh->pf_dir),
 139                     "/var/run/");
 140                 filenamelen = snprintf(pfh->pf_filename,
 141                     sizeof(pfh->pf_filename), "%s.pid", getprogname());
 142         } else {
 143                 if (strlcpy(path, pathp, sizeof(path)) >= sizeof(path)) {
 144                         free(pfh);
 145                         errno = ENAMETOOLONG;
 146                         return (NULL);
 147                 }
 148                 dirlen = strlcpy(pfh->pf_dir, dirname(path),
 149                     sizeof(pfh->pf_dir));
 150                 (void)strlcpy(path, pathp, sizeof(path));
 151                 filenamelen = strlcpy(pfh->pf_filename, basename(path),
 152                     sizeof(pfh->pf_filename));
 153         }
 154
 155         if (dirlen >= (int)sizeof(pfh->pf_dir) ||
 156             filenamelen >= (int)sizeof(pfh->pf_filename)) {
 157                 free(pfh);
 158                 errno = ENAMETOOLONG;
 159                 return (NULL);
 160         }
 161
 162         dirfd = open(pfh->pf_dir, O_CLOEXEC | O_DIRECTORY | O_NONBLOCK);
 163         if (dirfd == -1) {
 164                 error = errno;
 165                 free(pfh);
 166                 errno = error;
 167                 return (NULL);
 168         }
 169
 170         /*
 171          * Open the PID file and obtain exclusive lock.
 172          * We truncate PID file here only to remove old PID immediately,
 173          * PID file will be truncated again in pidfile_write(), so
 174          * pidfile_write() can be called multiple times.
 175          */
 176         fd = flopenat(dirfd, pfh->pf_filename,
 177             O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NONBLOCK, mode);
 178         if (fd == -1) {
 179                 if (errno == EWOULDBLOCK) {
 180                         if (pidptr == NULL) {
 181                                 errno = EEXIST;
 182                         } else {
 183                                 errno = pidfile_read(dirfd,
 184                                     pfh->pf_filename, pidptr);
 185                                 if (errno == 0 || errno == EAGAIN)
 186                                         errno = EEXIST;
 187                         }
 188                 }
 189                 error = errno;
 190                 close(dirfd);
 191                 free(pfh);
 192                 errno = error;
 193                 return (NULL);
 194         }
 195
 196         /*
 197          * Remember file information, so in pidfile_write() we are sure we write
 198          * to the proper descriptor.
 199          */
 200         if (fstat(fd, &sb) == -1) {
 201                 goto failed;
 202         }
 203
 204         if (cap_rights_limit(dirfd,
 205             cap_rights_init(&caprights, CAP_UNLINKAT)) < 0 && errno != ENOSYS) {
 206                 goto failed;
 207         }
 208
 209         if (cap_rights_limit(fd, cap_rights_init(&caprights, CAP_PWRITE,
 210             CAP_FSTAT, CAP_FTRUNCATE, CAP_EVENT)) < 0 &&
 211             errno != ENOSYS) {
 212                 goto failed;
 213         }
 214
 215         pfh->pf_dirfd = dirfd;
 216         pfh->pf_fd = fd;
 217         pfh->pf_dev = sb.st_dev;
 218         pfh->pf_ino = sb.st_ino;
 219
 220         return (pfh);
 221
 222 failed:
 223         error = errno;
 224         unlinkat(dirfd, pfh->pf_filename, 0);
 225         close(dirfd);
 226         close(fd);
 227         free(pfh);
 228         errno = error;
 229         return (NULL);
 230 }
 231
 232 int
 233 pidfile_write(struct pidfh *pfh)
 234 {
 235         char pidstr[16];
 236         int error, fd;
 237
 238         /*
 239          * Check remembered descriptor, so we don't overwrite some other
 240          * file if pidfile was closed and descriptor reused.
 241          */
 242         errno = pidfile_verify(pfh);
 243         if (errno != 0) {
 244                 /*
 245                  * Don't close descriptor, because we are not sure if it's ours.
 246                  */
 247                 return (-1);
 248         }
 249         fd = pfh->pf_fd;
 250
 251         /*
 252          * Truncate PID file, so multiple calls of pidfile_write() are allowed.
 253          */
 254         if (ftruncate(fd, 0) == -1) {
 255                 error = errno;
 256                 _pidfile_remove(pfh, 0);
 257                 errno = error;
 258                 return (-1);
 259         }
 260
 261         snprintf(pidstr, sizeof(pidstr), "%u", getpid());
 262         if (pwrite(fd, pidstr, strlen(pidstr), 0) != (ssize_t)strlen(pidstr)) {
 263                 error = errno;
 264                 _pidfile_remove(pfh, 0);
 265                 errno = error;
 266                 return (-1);
 267         }
 268
 269         return (0);
 270 }
 271
 272 int
 273 pidfile_close(struct pidfh *pfh)
 274 {
 275         int error;
 276
 277         error = pidfile_verify(pfh);
 278         if (error != 0) {
 279                 errno = error;
 280                 return (-1);
 281         }
 282
 283         if (close(pfh->pf_fd) == -1)
 284                 error = errno;
 285         if (close(pfh->pf_dirfd) == -1 && error == 0)
 286                 error = errno;
 287
 288         free(pfh);
 289         if (error != 0) {
 290                 errno = error;
 291                 return (-1);
 292         }
 293         return (0);
 294 }
 295
 296 static int
 297 _pidfile_remove(struct pidfh *pfh, int freeit)
 298 {
 299         int error;
 300
 301         error = pidfile_verify(pfh);
 302         if (error != 0) {
 303                 errno = error;
 304                 return (-1);
 305         }
 306
 307         if (funlinkat(pfh->pf_dirfd, pfh->pf_filename, pfh->pf_fd, 0) == -1) {
 308                 if (errno == EDEADLK)
 309                         return (-1);
 310                 error = errno;
 311         }
 312         if (close(pfh->pf_fd) == -1 && error == 0)
 313                 error = errno;
 314         if (close(pfh->pf_dirfd) == -1 && error == 0)
 315                 error = errno;
 316         if (freeit)
 317                 free(pfh);
 318         else
 319                 pfh->pf_fd = -1;
 320         if (error != 0) {
 321                 errno = error;
 322                 return (-1);
 323         }
 324         return (0);
 325 }
 326
 327 int
 328 pidfile_remove(struct pidfh *pfh)
 329 {
 330
 331         return (_pidfile_remove(pfh, 1));
 332 }
 333
 334 int
 335 pidfile_fileno(const struct pidfh *pfh)
 336 {
 337
 338         if (pfh == NULL || pfh->pf_fd == -1) {
 339                 errno = EDOOFUS;
 340                 return (-1);
 341         }
 342         return (pfh->pf_fd);
 343 }
 344
 345 int
 346 pidfile_signal(const char *pathp, int sig, pid_t *pidptr)
 347 {
 348         pid_t pid;
 349         int fd;
 350
 351         fd = flopenat(AT_FDCWD, pathp,
 352             O_RDONLY | O_CLOEXEC | O_NONBLOCK);
 353         if (fd >= 0) {
 354                 /*
 355                  * The file exists but is not locked,
 356                  * so the daemon is dead. Nothing to do.
 357                  */
 358                 close(fd);
 359                 errno = ENOENT;
 360                 return (errno);
 361         }
 362         if (errno != EWOULDBLOCK) {
 363                 return (errno);
 364         }
 365         errno = pidfile_read(AT_FDCWD, pathp, &pid);
 366         if (errno != 0)
 367                 return (errno);
 368         /*
 369          * Refuse to send broadcast or group signals, this has
 370          * happened due to the bugs in pidfile(3).
 371          */
 372         if (pid <= 0)
 373                 return (EDOM);
 374         kill(pid, sig);
 375         if (pidptr != NULL)
 376                 *pidptr = pid;
 377         return (errno);
 378 }