summaryrefslogtreecommitdiffstats
path: root/lib/util/pidfile.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--lib/util/pidfile.c238
1 files changed, 238 insertions, 0 deletions
diff --git a/lib/util/pidfile.c b/lib/util/pidfile.c
new file mode 100644
index 0000000..6ffbbea
--- /dev/null
+++ b/lib/util/pidfile.c
@@ -0,0 +1,238 @@
+/*
+ Unix SMB/CIFS implementation.
+ pidfile handling
+ Copyright (C) Andrew Tridgell 1998
+ Copyright (C) Amitay Isaccs 2016
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "replace.h"
+#include "system/filesys.h"
+
+#include "lib/util/blocking.h"
+#include "lib/util/debug.h"
+#include "lib/util/samba_util.h" /* For process_exists_by_pid() */
+
+#include "lib/util/pidfile.h"
+
+int pidfile_path_create(const char *path, int *pfd, pid_t *existing_pid)
+{
+ struct flock lck;
+ char tmp[64] = { 0 };
+ int fd, ret = 0;
+ int len;
+ ssize_t nwritten;
+ bool retried = false;
+
+ fd = open(path, O_CREAT|O_WRONLY|O_NONBLOCK, 0644);
+ if (fd == -1) {
+ return errno;
+ }
+
+ if (! set_close_on_exec(fd)) {
+ ret = errno;
+ goto fail;
+ }
+
+retry:
+ lck = (struct flock) {
+ .l_type = F_WRLCK,
+ .l_whence = SEEK_SET,
+ };
+
+ do {
+ ret = fcntl(fd, F_SETLK, &lck);
+ } while ((ret == -1) && (errno == EINTR));
+
+ if (ret != 0) {
+ ret = errno;
+
+ if ((ret == EACCES) || (ret == EAGAIN)) {
+ do {
+ ret = fcntl(fd, F_GETLK, &lck);
+ } while ((ret == -1) && (errno == EINTR));
+
+ if (ret == -1) {
+ ret = errno;
+ goto fail;
+ }
+
+ if (lck.l_type == F_UNLCK) {
+ if (!retried) {
+ /* Lock holder died, retry once */
+ retried = true;
+ goto retry;
+ }
+ /* Something badly wrong */
+ ret = EIO;
+ goto fail;
+ }
+
+ if (existing_pid != NULL) {
+ *existing_pid = lck.l_pid;
+ }
+ return EAGAIN;
+ }
+ goto fail;
+ }
+
+ /*
+ * PID file is locked by us so from here on we should unlink
+ * on failure
+ */
+ len = snprintf(tmp, sizeof(tmp), "%u\n", getpid());
+ if (len < 0) {
+ ret = errno;
+ goto fail_unlink;
+ }
+ if ((size_t)len >= sizeof(tmp)) {
+ ret = ENOSPC;
+ goto fail_unlink;
+ }
+
+ do {
+ nwritten = write(fd, tmp, len);
+ } while ((nwritten == -1) && (errno == EINTR));
+
+ if ((nwritten == -1) || (nwritten != len)) {
+ ret = errno;
+ goto fail_unlink;
+ }
+
+ do {
+ ret = ftruncate(fd, len);
+ } while ((ret == -1) && (errno == EINTR));
+
+ if (ret == -1) {
+ ret = errno;
+ goto fail_unlink;
+ }
+
+ *pfd = fd;
+ return 0;
+
+fail_unlink:
+ unlink(path);
+fail:
+ close(fd);
+ return ret;
+}
+
+void pidfile_fd_close(int fd)
+{
+ struct flock lck = {
+ .l_type = F_UNLCK,
+ .l_whence = SEEK_SET,
+ };
+ int ret;
+
+ do {
+ ret = fcntl(fd, F_SETLK, &lck);
+ } while ((ret == -1) && (errno == EINTR));
+
+ do {
+ ret = close(fd);
+ } while ((ret == -1) && (errno == EINTR));
+}
+
+
+/**
+ * return the pid in a pidfile. return 0 if the process (or pidfile)
+ * does not exist
+ */
+pid_t pidfile_pid(const char *piddir, const char *name)
+{
+ size_t len = strlen(piddir) + strlen(name) + 6;
+ char pidFile[len];
+ int fd;
+ char pidstr[20] = { 0, };
+ pid_t ret = -1;
+
+ snprintf(pidFile, sizeof(pidFile), "%s/%s.pid", piddir, name);
+
+ fd = open(pidFile, O_NONBLOCK | O_RDONLY, 0644);
+
+ if (fd == -1) {
+ return 0;
+ }
+
+ if (read(fd, pidstr, sizeof(pidstr)-1) <= 0) {
+ goto noproc;
+ }
+
+ ret = (pid_t)atoi(pidstr);
+ if (ret <= 0) {
+ DEBUG(1, ("Could not parse contents of pidfile %s\n",
+ pidFile));
+ goto noproc;
+ }
+
+ if (!process_exists_by_pid(ret)) {
+ DEBUG(10, ("Process with PID=%d does not exist.\n", (int)ret));
+ goto noproc;
+ }
+
+ if (fcntl_lock(fd,F_SETLK,0,1,F_RDLCK)) {
+ /* we could get the lock - it can't be a Samba process */
+ DEBUG(10, ("Process with PID=%d is not a Samba process.\n",
+ (int)ret));
+ goto noproc;
+ }
+
+ close(fd);
+ DEBUG(10, ("Process with PID=%d is running.\n", (int)ret));
+ return ret;
+
+ noproc:
+ close(fd);
+ return 0;
+}
+
+/**
+ * create a pid file in the pid directory. open it and leave it locked
+ */
+void pidfile_create(const char *piddir, const char *name)
+{
+ size_t len = strlen(piddir) + strlen(name) + 6;
+ char pidFile[len];
+ pid_t pid = (pid_t)-1;
+ int ret, fd;
+
+ snprintf(pidFile, sizeof(pidFile), "%s/%s.pid", piddir, name);
+
+ ret = pidfile_path_create(pidFile, &fd, &pid);
+ if (ret == EAGAIN) {
+ DEBUG(0,("ERROR: %s is already running. File %s exists and process id %d is running.\n",
+ name, pidFile, (int)pid));
+ exit(1);
+ }
+
+ /* Leave pid file open & locked for the duration... */
+}
+
+void pidfile_unlink(const char *piddir, const char *name)
+{
+ size_t len = strlen(piddir) + strlen(name) + 6;
+ char pidFile[len];
+ int ret;
+
+ snprintf(pidFile, sizeof(pidFile), "%s/%s.pid", piddir, name);
+
+ ret = unlink(pidFile);
+ if (ret == -1) {
+ DEBUG(0,("Failed to delete pidfile %s. Error was %s\n",
+ pidFile, strerror(errno)));
+ }
+}