samba-mirror/lib/util/pidfile.c

/*
   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)));
	}
}