lib/libutil/pidfile.c

   1 /*      $NetBSD: pidfile.c,v 1.9 2011/03/29 13:55:37 jmmv Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1999 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe, Matthias Scheler and Julio Merino.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #if defined(LIBC_SCCS) && !defined(lint)
  34 __RCSID("$NetBSD: pidfile.c,v 1.9 2011/03/29 13:55:37 jmmv Exp $");
  35 #endif
  36
  37 #include <sys/param.h>
  38
  39 #include <paths.h>
  40 #include <stdbool.h>
  41 #include <stdlib.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44 #include <unistd.h>
  45 #include <util.h>
  46
  47 static pid_t pidfile_pid;
  48 static char *pidfile_path;
  49
  50 /* Deletes an existent pidfile iff it was created by this process. */
  51 static void
  52 pidfile_cleanup(void)
  53 {
  54
  55         if ((pidfile_path != NULL) && (pidfile_pid == getpid()))
  56                 (void) unlink(pidfile_path);
  57 }
  58
  59 /* Registers an atexit(3) handler to delete the pidfile we have generated.
  60  * We only register the handler when we create a pidfile, so we can assume
  61  * that the pidfile exists.
  62  *
  63  * Returns 0 on success or -1 if the handler could not be registered. */
  64 static int
  65 register_atexit_handler(void)
  66 {
  67         static bool done = false;
  68
  69         if (!done) {
  70                 if (atexit(pidfile_cleanup) < 0)
  71                         return -1;
  72                 done = true;
  73         }
  74
  75         return 0;
  76 }
  77
  78 /* Given a new pidfile name in 'path', deletes any previously-created pidfile
  79  * if the previous file differs to the new one.
  80  *
  81  * If a previous file is deleted, returns 1, which means that a new pidfile
  82  * must be created.  Otherwise, this returns 0, which means that the existing
  83  * file does not need to be touched. */
  84 static int
  85 cleanup_old_pidfile(const char* path)
  86 {
  87         if (pidfile_path != NULL) {
  88                 if (strcmp(pidfile_path, path) != 0) {
  89                         pidfile_cleanup();
  90
  91                         free(pidfile_path);
  92                         pidfile_path = NULL;
  93
  94                         return 1;
  95                 } else
  96                         return 0;
  97         } else
  98                 return 1;
  99 }
 100
 101 /* Constructs a name for a pidfile in the default location (/var/run).  If
 102  * 'basename' is NULL, uses the name of the current program for the name of
 103  * the pidfile.
 104  *
 105  * Returns a pointer to a dynamically-allocatd string containing the absolute
 106  * path to the pidfile; NULL on failure. */
 107 static char *
 108 generate_varrun_path(const char *basename)
 109 {
 110         char *path;
 111
 112         if (basename == NULL)
 113                 basename = getprogname();
 114
 115         /* _PATH_VARRUN includes trailing / */
 116         (void) asprintf(&path, "%s%s.pid", _PATH_VARRUN, basename);
 117         return path;
 118 }
 119
 120 /* Creates a pidfile with the provided name.  The new pidfile is "registered"
 121  * in the global variables pidfile_path and pidfile_pid so that any further
 122  * call to pidfile(3) can check if we are recreating the same file or a new
 123  * one.
 124  *
 125  * Returns 0 on success or -1 if there is any error. */
 126 static int
 127 create_pidfile(const char* path)
 128 {
 129         FILE *f;
 130
 131         if (register_atexit_handler() == -1)
 132                 return -1;
 133
 134         if (cleanup_old_pidfile(path) == 0)
 135                 return 0;
 136
 137         pidfile_path = strdup(path);
 138         if (pidfile_path == NULL)
 139                 return -1;
 140
 141         if ((f = fopen(path, "w")) == NULL) {
 142                 free(pidfile_path);
 143                 pidfile_path = NULL;
 144                 return -1;
 145         }
 146
 147         pidfile_pid = getpid();
 148
 149         (void) fprintf(f, "%d\n", pidfile_pid);
 150         (void) fclose(f);
 151
 152         return 0;
 153 }
 154
 155 int
 156 pidfile(const char *path)
 157 {
 158
 159         if (path == NULL || strchr(path, '/') == NULL) {
 160                 char *default_path;
 161
 162                 if ((default_path = generate_varrun_path(path)) == NULL)
 163                         return -1;
 164
 165                 if (create_pidfile(default_path) == -1) {
 166                         free(default_path);
 167                         return -1;
 168                 }
 169
 170                 free(default_path);
 171                 return 0;
 172         } else
 173                 return create_pidfile(path);
 174 }