2009-12-16 Werner Koch * debian/control (Description): Update. * Makefile (LIB_SRCS): Add pidfile.c * Versions (LIBBSD_0.2): New. * include/libutil.h (struct pidfh): New. (pidfile_open, pidfile_write, pidfile_close, pidfile_remove): New. * src/pidfile.c: New. Taken from http://svn.freebsd.org/base/head/lib/libutil, rev 200601. (flopen): Merge using flopen.c from the same repo. diff -urpN libbsd-0.1.6/Makefile libbsd.new/Makefile --- libbsd-0.1.6/Makefile 2009-08-30 12:17:25.000000000 +0200 +++ libbsd.new/Makefile 2009-12-16 12:13:57.000000000 +0100 @@ -35,7 +35,8 @@ LIB_SRCS := \ fmtcheck.c \ nlist.c \ progname.c \ - vis.c unvis.c + vis.c unvis.c \ + pidfile.c LIB_SRCS := $(patsubst %,src/%,$(LIB_SRCS)) LIB_GEN_SRCS := \ diff -urpN libbsd-0.1.6/Versions libbsd.new/Versions --- libbsd-0.1.6/Versions 2009-05-20 04:14:18.000000000 +0200 +++ libbsd.new/Versions 2009-12-16 12:07:20.000000000 +0100 @@ -42,3 +42,12 @@ LIBBSD_0.1 { nlist; } LIBBSD_0.0; + +LIBBSD_0.2 { + pidfile_open; + pidfile_write; + pidfile_close; + pidfile_remove; +} LIBBSD_0.1; + + diff -urpN libbsd-0.1.6/debian/control libbsd.new/debian/control --- libbsd-0.1.6/debian/control 2009-12-16 17:35:18.000000000 +0100 +++ libbsd.new/debian/control 2009-12-16 12:11:42.000000000 +0100 @@ -27,7 +27,8 @@ Description: utility functions from BSD humanize_number, inet_net_pton, getprogname, setprogname, nlist, strlcpy, strlcat, setmode, getmode, strmode, vis, strvis, strvisx, unvis, strunvis, strunvisx, MD5Init, MD5Update, MD5Pad, MD5Final, - MD5Transform, MD5End, MD5File, MD5FileChunk, MD5Data. + MD5Transform, MD5End, MD5File, MD5FileChunk, MD5Data, pidfile_open, + pidfile_write, pidfile_close, pidfile_remove. . Also included are some queue macro definitions not present on includes from glibc. diff -urpN libbsd-0.1.6/debian/libbsd0.symbols libbsd.new/debian/libbsd0.symbols --- libbsd-0.1.6/debian/libbsd0.symbols 2009-12-16 17:35:18.000000000 +0100 +++ libbsd.new/debian/libbsd0.symbols 2009-12-16 12:08:15.000000000 +0100 @@ -1,3 +1,4 @@ libbsd.so.0 libbsd0 #MINVER# *@LIBBSD_0.0 0.0 *@LIBBSD_0.1 0.1.0 + *@LIBBSD_0.2 0.2.0 diff -urpN libbsd-0.1.6/include/libutil.h libbsd.new/include/libutil.h --- libbsd-0.1.6/include/libutil.h 2008-08-07 05:17:03.000000000 +0200 +++ libbsd.new/include/libutil.h 2009-12-16 17:37:06.000000000 +0100 @@ -42,10 +42,27 @@ #include #include +#ifdef _SYS_PARAM_H +/* for pidfile.c */ +struct pidfh { + int pf_fd; + char pf_path[MAXPATHLEN + 1]; + __dev_t pf_dev; + ino_t pf_ino; +}; +#endif + __BEGIN_DECLS int humanize_number(char *buf, size_t len, int64_t bytes, const char *suffix, int scale, int flags); + +#ifdef _SYS_PARAM_H +struct pidfh *pidfile_open(const char *path, mode_t mode, pid_t *pidptr); +int pidfile_write(struct pidfh *pfh); +int pidfile_close(struct pidfh *pfh); +int pidfile_remove(struct pidfh *pfh); +#endif __END_DECLS /* humanize_number(3) */ diff -urpN libbsd-0.1.6/src/pidfile.c libbsd.new/src/pidfile.c --- libbsd-0.1.6/src/pidfile.c 1970-01-01 01:00:00.000000000 +0100 +++ libbsd.new/src/pidfile.c 2009-12-16 12:35:20.000000000 +0100 @@ -0,0 +1,329 @@ +/*- + * Copyright (c) 2005 Pawel Jakub Dawidek + * Copyright (c) 2007 Dag-Erling Coïdan Smørgrav + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +/* We don't have flopen in the lib but it is required here. Thus for + now we define it only here. In case flopen is later added a + warning will be printed about symbol redefinition to remind that + flopen needs to be removed here ;-). */ +static int +flopen(const char *path, int flags, ...) +{ + int fd, operation, serrno, trunc; + struct stat sb, fsb; + mode_t mode; + +#ifdef O_EXLOCK + flags &= ~O_EXLOCK; +#endif + + mode = 0; + if (flags & O_CREAT) { + va_list ap; + + va_start(ap, flags); + mode = (mode_t)va_arg(ap, int); /* mode_t promoted to int */ + va_end(ap); + } + + operation = LOCK_EX; + if (flags & O_NONBLOCK) + operation |= LOCK_NB; + + trunc = (flags & O_TRUNC); + flags &= ~O_TRUNC; + + for (;;) { + if ((fd = open(path, flags, mode)) == -1) + /* non-existent or no access */ + return (-1); + if (flock(fd, operation) == -1) { + /* unsupported or interrupted */ + serrno = errno; + (void)close(fd); + errno = serrno; + return (-1); + } + if (stat(path, &sb) == -1) { + /* disappeared from under our feet */ + (void)close(fd); + continue; + } + if (fstat(fd, &fsb) == -1) { + /* can't happen [tm] */ + serrno = errno; + (void)close(fd); + errno = serrno; + return (-1); + } + if (sb.st_dev != fsb.st_dev || + sb.st_ino != fsb.st_ino) { + /* changed under our feet */ + (void)close(fd); + continue; + } + if (trunc && ftruncate(fd, 0) != 0) { + /* can't happen [tm] */ + serrno = errno; + (void)close(fd); + errno = serrno; + return (-1); + } + return (fd); + } +} + + +static int _pidfile_remove(struct pidfh *pfh, int freeit); + +static int +pidfile_verify(struct pidfh *pfh) +{ + struct stat sb; + + if (pfh == NULL || pfh->pf_fd == -1) + return (EDOOFUS); + /* + * Check remembered descriptor. + */ + if (fstat(pfh->pf_fd, &sb) == -1) + return (errno); + if (sb.st_dev != pfh->pf_dev || sb.st_ino != pfh->pf_ino) + return (EDOOFUS); + return (0); +} + +static int +pidfile_read(const char *path, pid_t *pidptr) +{ + char buf[16], *endptr; + int error, fd, i; + + fd = open(path, O_RDONLY); + if (fd == -1) + return (errno); + + i = read(fd, buf, sizeof(buf) - 1); + error = errno; /* Remember errno in case close() wants to change it. */ + close(fd); + if (i == -1) + return (error); + else if (i == 0) + return (EAGAIN); + buf[i] = '\0'; + + *pidptr = strtol(buf, &endptr, 10); + if (endptr != &buf[i]) + return (EINVAL); + + return (0); +} + +struct pidfh * +pidfile_open(const char *path, mode_t mode, pid_t *pidptr) +{ + struct pidfh *pfh; + struct stat sb; + int error, fd, len, count; + struct timespec rqtp; + + pfh = malloc(sizeof(*pfh)); + if (pfh == NULL) + return (NULL); + + if (path == NULL) + len = snprintf(pfh->pf_path, sizeof(pfh->pf_path), + "/var/run/%s.pid", getprogname()); + else + len = snprintf(pfh->pf_path, sizeof(pfh->pf_path), + "%s", path); + if (len >= (int)sizeof(pfh->pf_path)) { + free(pfh); + errno = ENAMETOOLONG; + return (NULL); + } + + /* + * Open the PID file and obtain exclusive lock. + * We truncate PID file here only to remove old PID immediatelly, + * PID file will be truncated again in pidfile_write(), so + * pidfile_write() can be called multiple times. + */ + fd = flopen(pfh->pf_path, + O_WRONLY | O_CREAT | O_TRUNC | O_NONBLOCK, mode); + if (fd == -1) { + count = 0; + rqtp.tv_sec = 0; + rqtp.tv_nsec = 5000000; + if (errno == EWOULDBLOCK && pidptr != NULL) { + again: + errno = pidfile_read(pfh->pf_path, pidptr); + if (errno == 0) + errno = EEXIST; + else if (errno == EAGAIN) { + if (++count <= 3) { + nanosleep(&rqtp, 0); + goto again; + } + } + } + free(pfh); + return (NULL); + } + /* + * Remember file information, so in pidfile_write() we are sure we write + * to the proper descriptor. + */ + if (fstat(fd, &sb) == -1) { + error = errno; + unlink(pfh->pf_path); + close(fd); + free(pfh); + errno = error; + return (NULL); + } + + pfh->pf_fd = fd; + pfh->pf_dev = sb.st_dev; + pfh->pf_ino = sb.st_ino; + + return (pfh); +} + +int +pidfile_write(struct pidfh *pfh) +{ + char pidstr[16]; + int error, fd; + + /* + * Check remembered descriptor, so we don't overwrite some other + * file if pidfile was closed and descriptor reused. + */ + errno = pidfile_verify(pfh); + if (errno != 0) { + /* + * Don't close descriptor, because we are not sure if it's ours. + */ + return (-1); + } + fd = pfh->pf_fd; + + /* + * Truncate PID file, so multiple calls of pidfile_write() are allowed. + */ + if (ftruncate(fd, 0) == -1) { + error = errno; + _pidfile_remove(pfh, 0); + errno = error; + return (-1); + } + + snprintf(pidstr, sizeof(pidstr), "%u", getpid()); + if (pwrite(fd, pidstr, strlen(pidstr), 0) != (ssize_t)strlen(pidstr)) { + error = errno; + _pidfile_remove(pfh, 0); + errno = error; + return (-1); + } + + return (0); +} + +int +pidfile_close(struct pidfh *pfh) +{ + int error; + + error = pidfile_verify(pfh); + if (error != 0) { + errno = error; + return (-1); + } + + if (close(pfh->pf_fd) == -1) + error = errno; + free(pfh); + if (error != 0) { + errno = error; + return (-1); + } + return (0); +} + +static int +_pidfile_remove(struct pidfh *pfh, int freeit) +{ + int error; + + error = pidfile_verify(pfh); + if (error != 0) { + errno = error; + return (-1); + } + + if (unlink(pfh->pf_path) == -1) + error = errno; + if (close(pfh->pf_fd) == -1) { + if (error == 0) + error = errno; + } + if (freeit) + free(pfh); + else + pfh->pf_fd = -1; + if (error != 0) { + errno = error; + return (-1); + } + return (0); +} + +int +pidfile_remove(struct pidfh *pfh) +{ + + return (_pidfile_remove(pfh, 1)); +}