xref: /freebsd/lib/libutil/pidfile.c (revision 1e413cf93298b5b97441a21d9a50fdcd0ee9945e)
1 /*-
2  * Copyright (c) 2005 Pawel Jakub Dawidek <pjd@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26 
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 
30 #include <sys/param.h>
31 #include <sys/file.h>
32 #include <sys/stat.h>
33 
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37 #include <fcntl.h>
38 #include <string.h>
39 #include <time.h>
40 #include <err.h>
41 #include <errno.h>
42 #include <libutil.h>
43 
44 static int _pidfile_remove(struct pidfh *pfh, int freeit);
45 
46 static int
47 pidfile_verify(struct pidfh *pfh)
48 {
49 	struct stat sb;
50 
51 	if (pfh == NULL || pfh->pf_fd == -1)
52 		return (EDOOFUS);
53 	/*
54 	 * Check remembered descriptor.
55 	 */
56 	if (fstat(pfh->pf_fd, &sb) == -1)
57 		return (errno);
58 	if (sb.st_dev != pfh->pf_dev || sb.st_ino != pfh->pf_ino)
59 		return (EDOOFUS);
60 	return (0);
61 }
62 
63 static int
64 pidfile_read(const char *path, pid_t *pidptr)
65 {
66 	char buf[16], *endptr;
67 	int error, fd, i;
68 
69 	fd = open(path, O_RDONLY);
70 	if (fd == -1)
71 		return (errno);
72 
73 	i = read(fd, buf, sizeof(buf) - 1);
74 	error = errno;	/* Remember errno in case close() wants to change it. */
75 	close(fd);
76 	if (i == -1)
77 		return (error);
78 	else if (i == 0)
79 		return (EAGAIN);
80 	buf[i] = '\0';
81 
82 	*pidptr = strtol(buf, &endptr, 10);
83 	if (endptr != &buf[i])
84 		return (EINVAL);
85 
86 	return (0);
87 }
88 
89 struct pidfh *
90 pidfile_open(const char *path, mode_t mode, pid_t *pidptr)
91 {
92 	struct pidfh *pfh;
93 	struct stat sb;
94 	int error, fd, len, count;
95 	struct timespec rqtp;
96 
97 	pfh = malloc(sizeof(*pfh));
98 	if (pfh == NULL)
99 		return (NULL);
100 
101 	if (path == NULL)
102 		len = snprintf(pfh->pf_path, sizeof(pfh->pf_path),
103 		    "/var/run/%s.pid", getprogname());
104 	else
105 		len = snprintf(pfh->pf_path, sizeof(pfh->pf_path),
106 		    "%s", path);
107 	if (len >= (int)sizeof(pfh->pf_path)) {
108 		free(pfh);
109 		errno = ENAMETOOLONG;
110 		return (NULL);
111 	}
112 
113 	/*
114 	 * Open the PID file and obtain exclusive lock.
115 	 * We truncate PID file here only to remove old PID immediatelly,
116 	 * PID file will be truncated again in pidfile_write(), so
117 	 * pidfile_write() can be called multiple times.
118 	 */
119 	fd = flopen(pfh->pf_path,
120 	    O_WRONLY | O_CREAT | O_TRUNC | O_NONBLOCK, mode);
121 	if (fd == -1) {
122 		count = 0;
123 		rqtp.tv_sec = 0;
124 		rqtp.tv_nsec = 5000000;
125 		if (errno == EWOULDBLOCK && pidptr != NULL) {
126 		again:
127 			errno = pidfile_read(pfh->pf_path, pidptr);
128 			if (errno == 0)
129 				errno = EEXIST;
130 			else if (errno == EAGAIN) {
131 				if (++count <= 3) {
132 					nanosleep(&rqtp, 0);
133 					goto again;
134 				}
135 			}
136 		}
137 		free(pfh);
138 		return (NULL);
139 	}
140 	/*
141 	 * Remember file information, so in pidfile_write() we are sure we write
142 	 * to the proper descriptor.
143 	 */
144 	if (fstat(fd, &sb) == -1) {
145 		error = errno;
146 		unlink(pfh->pf_path);
147 		close(fd);
148 		free(pfh);
149 		errno = error;
150 		return (NULL);
151 	}
152 
153 	pfh->pf_fd = fd;
154 	pfh->pf_dev = sb.st_dev;
155 	pfh->pf_ino = sb.st_ino;
156 
157 	return (pfh);
158 }
159 
160 int
161 pidfile_write(struct pidfh *pfh)
162 {
163 	char pidstr[16];
164 	int error, fd;
165 
166 	/*
167 	 * Check remembered descriptor, so we don't overwrite some other
168 	 * file if pidfile was closed and descriptor reused.
169 	 */
170 	errno = pidfile_verify(pfh);
171 	if (errno != 0) {
172 		/*
173 		 * Don't close descriptor, because we are not sure if it's ours.
174 		 */
175 		return (-1);
176 	}
177 	fd = pfh->pf_fd;
178 
179 	/*
180 	 * Truncate PID file, so multiple calls of pidfile_write() are allowed.
181 	 */
182 	if (ftruncate(fd, 0) == -1) {
183 		error = errno;
184 		_pidfile_remove(pfh, 0);
185 		errno = error;
186 		return (-1);
187 	}
188 
189 	snprintf(pidstr, sizeof(pidstr), "%u", getpid());
190 	if (pwrite(fd, pidstr, strlen(pidstr), 0) != (ssize_t)strlen(pidstr)) {
191 		error = errno;
192 		_pidfile_remove(pfh, 0);
193 		errno = error;
194 		return (-1);
195 	}
196 
197 	return (0);
198 }
199 
200 int
201 pidfile_close(struct pidfh *pfh)
202 {
203 	int error;
204 
205 	error = pidfile_verify(pfh);
206 	if (error != 0) {
207 		errno = error;
208 		return (-1);
209 	}
210 
211 	if (close(pfh->pf_fd) == -1)
212 		error = errno;
213 	free(pfh);
214 	if (error != 0) {
215 		errno = error;
216 		return (-1);
217 	}
218 	return (0);
219 }
220 
221 static int
222 _pidfile_remove(struct pidfh *pfh, int freeit)
223 {
224 	int error;
225 
226 	error = pidfile_verify(pfh);
227 	if (error != 0) {
228 		errno = error;
229 		return (-1);
230 	}
231 
232 	if (unlink(pfh->pf_path) == -1)
233 		error = errno;
234 	if (flock(pfh->pf_fd, LOCK_UN) == -1) {
235 		if (error == 0)
236 			error = errno;
237 	}
238 	if (close(pfh->pf_fd) == -1) {
239 		if (error == 0)
240 			error = errno;
241 	}
242 	if (freeit)
243 		free(pfh);
244 	else
245 		pfh->pf_fd = -1;
246 	if (error != 0) {
247 		errno = error;
248 		return (-1);
249 	}
250 	return (0);
251 }
252 
253 int
254 pidfile_remove(struct pidfh *pfh)
255 {
256 
257 	return (_pidfile_remove(pfh, 1));
258 }
259