From 7162d53967117a8eda4257244327d63f95633783 Mon Sep 17 00:00:00 2001 From: PHO Date: Sat, 27 Dec 2008 16:33:26 +0900 Subject: [PATCH] Done! --- .gitignore | 17 ++++ Makefile | 11 --- Makefile.am | 14 +++ configure.ac | 34 +++++++ daemon.c | 10 +- flopen.c | 105 +++++++++++++++++++++ flopen.h | 6 ++ pidfile.c | 256 +++++++++++++++++++++++++++++++++++++++++++++++++++ pidfile.h | 20 ++++ 9 files changed, 456 insertions(+), 17 deletions(-) create mode 100644 .gitignore delete mode 100644 Makefile create mode 100644 Makefile.am create mode 100644 configure.ac create mode 100644 flopen.c create mode 100644 flopen.h create mode 100644 pidfile.c create mode 100644 pidfile.h diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6680db1 --- /dev/null +++ b/.gitignore @@ -0,0 +1,17 @@ +*~ +*.[oa] +stamp-* +missing +install-sh +depcomp +daemon +configure.scan +configure +config.* +*.log +*.cache +aclocal.m4 +Makefile.in +Makefile +.deps +daemon-*.tar.gz diff --git a/Makefile b/Makefile deleted file mode 100644 index 0b3d8db..0000000 --- a/Makefile +++ /dev/null @@ -1,11 +0,0 @@ -# $FreeBSD: src/usr.sbin/daemon/Makefile,v 1.3 2005/08/24 17:24:39 pjd Exp $ - -PROG= daemon -MAN= daemon.8 - -DPADD= ${LIBUTIL} -LDADD= -lutil - -WARNS?= 2 - -.include diff --git a/Makefile.am b/Makefile.am new file mode 100644 index 0000000..4ccbe69 --- /dev/null +++ b/Makefile.am @@ -0,0 +1,14 @@ +AUTOMAKE_OPTIONS = foreign + +sbin_PROGRAMS = daemon + +daemon_SOURCES = \ + daemon.c \ + pidfile.c pidfile.h \ + flopen.c flopen.h \ + $(NULL) + +man8_MANS = daemon.8 +EXTRA_DIST = $(man8_MANS) + +AM_CFLAGS = -Wall diff --git a/configure.ac b/configure.ac new file mode 100644 index 0000000..a48bcd1 --- /dev/null +++ b/configure.ac @@ -0,0 +1,34 @@ +# -*- Autoconf -*- +# Process this file with autoconf to produce a configure script. + +AC_PREREQ([2.63]) +AC_INIT([daemon], [1.8], [pho@cielonegro.org]) + +AM_INIT_AUTOMAKE +AC_CONFIG_SRCDIR([daemon.c]) +AC_CONFIG_HEADERS([config.h]) + +# Checks for programs. +AC_PROG_CC + +# Checks for libraries. + +# Checks for header files. +AC_CHECK_HEADERS([stdlib.h sys/param.h unistd.h]) +AC_CHECK_HEADERS([fcntl.h]) +AC_CHECK_HEADERS([sys/file.h]) + +# Checks for typedefs, structures, and compiler characteristics. +AC_TYPE_PID_T +AC_TYPE_MODE_T +AC_TYPE_SSIZE_T + +# Checks for library functions. +AC_CHECK_FUNCS([ftruncate]) +AC_CHECK_FUNCS([strtol]) +AC_FUNC_MALLOC + +AC_CONFIG_FILES([ + Makefile +]) +AC_OUTPUT diff --git a/daemon.c b/daemon.c index 7fccad0..82b19a1 100644 --- a/daemon.c +++ b/daemon.c @@ -28,16 +28,14 @@ * From BSDI: daemon.c,v 1.2 1996/08/15 01:11:09 jch Exp */ -#include -__FBSDID("$FreeBSD: src/usr.sbin/daemon/daemon.c,v 1.8 2007/04/19 16:43:30 peter Exp $"); +#include "config.h" +#include "pidfile.h" #include #include #include #include -#include -#include #include #include #include @@ -127,8 +125,8 @@ restrict_process(const char *user) if (pw == NULL) errx(1, "unknown user: %s", user); - if (setusercontext(NULL, pw, pw->pw_uid, LOGIN_SETALL) != 0) - errx(1, "failed to set user environment"); + if (setuid(pw->pw_uid) != 0) + errx(1, "failed to setuid to %s", user); } static void diff --git a/flopen.c b/flopen.c new file mode 100644 index 0000000..d6c27fb --- /dev/null +++ b/flopen.c @@ -0,0 +1,105 @@ +/*- + * 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 + * in this position and unchanged. + * 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 AUTHOR 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 AUTHOR 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 "flopen.h" + +#include + +#include +#include + +#include +#include +#include +#include + +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 = 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; + close(fd); + errno = serrno; + return (-1); + } + if (stat(path, &sb) == -1) { + /* disappeared from under our feet */ + close(fd); + continue; + } + if (fstat(fd, &fsb) == -1) { + /* can't happen [tm] */ + serrno = errno; + close(fd); + errno = serrno; + return (-1); + } + if (sb.st_dev != fsb.st_dev || + sb.st_ino != fsb.st_ino) { + /* changed under our feet */ + close(fd); + continue; + } + if (trunc && ftruncate(fd, 0) != 0) { + /* can't happen [tm] */ + serrno = errno; + close(fd); + errno = serrno; + return (-1); + } + return (fd); + } +} diff --git a/flopen.h b/flopen.h new file mode 100644 index 0000000..3e7fcf8 --- /dev/null +++ b/flopen.h @@ -0,0 +1,6 @@ +#ifndef FLOPEN_H_INCLUDED +#define FLOPEN_H_INCLUDED + +int flopen(const char *path, int flags, ...); + +#endif diff --git a/pidfile.c b/pidfile.c new file mode 100644 index 0000000..8fc42c9 --- /dev/null +++ b/pidfile.c @@ -0,0 +1,256 @@ +/*- + * Copyright (c) 2005 Pawel Jakub Dawidek + * 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 "pidfile.h" +#include "flopen.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +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 (EINVAL); + /* + * 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 (EINVAL); + 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 (flock(pfh->pf_fd, LOCK_UN) == -1) { + if (error == 0) + 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)); +} diff --git a/pidfile.h b/pidfile.h new file mode 100644 index 0000000..3e5a5a0 --- /dev/null +++ b/pidfile.h @@ -0,0 +1,20 @@ +#ifndef PIDFILE_H_INCLUDED +#define PIDFILE_H_INCLUDED + +#include +#include +#include + +struct pidfh { + int pf_fd; + char pf_path[MAXPATHLEN + 1]; + dev_t pf_dev; + ino_t pf_ino; +}; + +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 -- 2.40.0