openrc/src/librc/librc-daemon.c

/*
   librc-daemon
   Finds PID for given daemon criteria
   */

/*
 * Copyright 2007-2008 Roy Marples
 * 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 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 "librc.h"

#if defined(__linux__)
static bool pid_is_cmd(pid_t pid, const char *cmd)
{
	char buffer[32];
	FILE *fp;
	int c;

	snprintf(buffer, sizeof(buffer), "/proc/%d/stat", pid);
	if ((fp = fopen(buffer, "r")) == NULL)
		return false;

	while ((c = getc(fp)) != EOF && c != '(')
		;

	if (c != '(') {
		fclose(fp);
		return false;
	}

	while ((c = getc(fp)) != EOF && c == *cmd)
		cmd++;

	fclose(fp);

	return (c == ')' && *cmd == '\0') ? true : false;
}

static bool pid_is_exec(pid_t pid, const char *const *argv)
{
	char cmdline[32];
	char buffer[PATH_MAX];
	char *p;
	int fd = -1;
	int r;

	/* Check it's the right binary */
	snprintf (cmdline, sizeof (cmdline), "/proc/%u/exe", pid);
	memset (buffer, 0, sizeof (buffer));
	if (readlink(cmdline, buffer, sizeof(buffer)) != -1) {
		if (strcmp(*argv, buffer) == 0)
			return true;

		/* We should cater for deleted binaries too */
		if (strlen(buffer) > 10) {
			p = buffer + (strlen(buffer) - 10);
			if (strcmp(p, " (deleted)") == 0) {
				*p = 0;
				if (strcmp(buffer, *argv) == 0)
					return true;
			}
		}
	}

	snprintf(cmdline, sizeof(cmdline), "/proc/%u/cmdline", pid);
	if ((fd = open(cmdline, O_RDONLY)) < 0)
		return false;

	r = read(fd, buffer, sizeof(buffer));
	close(fd);

	if (r == -1)
		return 0;

	buffer[r] = 0;
	p = buffer;
	while (*argv) {
		if (strcmp(*argv, p) != 0)
			return false;
		argv++;
		p += strlen(p) + 1;
		if ((unsigned) (p - buffer) > sizeof (buffer))
			return false;
	}
	return true;
}

RC_PIDLIST *rc_find_pids(const char *const *argv, const char *cmd,
			 uid_t uid, pid_t pid)
{
	DIR *procdir;
	struct dirent *entry;
	pid_t p;
	char buffer[PATH_MAX];
	struct stat sb;
	pid_t runscript_pid = 0;
	char *pp;
	RC_PIDLIST *pids = NULL;
	RC_PID *pi;

	if ((procdir = opendir("/proc")) == NULL)
		return NULL;

	/*
	   We never match RC_RUNSCRIPT_PID if present so we avoid the below
	   scenario

	   /etc/init.d/ntpd stop does
	   start-stop-daemon --stop --name ntpd
	   catching /etc/init.d/ntpd stop

	   nasty
	   */

	if ((pp = getenv("RC_RUNSCRIPT_PID"))) {
		if (sscanf(pp, "%d", &runscript_pid) != 1)
			runscript_pid = 0;
	}

	while ((entry = readdir(procdir)) != NULL) {
		if (sscanf(entry->d_name, "%d", &p) != 1)
			continue;

		if (runscript_pid != 0 && runscript_pid == p)
			continue;

		if (pid != 0 && pid != p)
			continue;

		if (uid) {
			snprintf(buffer, sizeof(buffer), "/proc/%d", p);
			if (stat(buffer, &sb) != 0 || sb.st_uid != uid)
				continue;
		}

		if (cmd && ! pid_is_cmd(p, cmd))
			continue;

		if (argv && ! cmd && !
		    pid_is_exec(p, (const char *const *)argv))
			continue;

		if (! pids) {
			pids = xmalloc(sizeof(*pids));
			LIST_INIT(pids);
		}
		pi = xmalloc(sizeof(*pi));
		pi->pid = p;
		LIST_INSERT_HEAD(pids, pi, entries);
	}
	closedir(procdir);

	return pids;
}
librc_hidden_def(rc_find_pids)

#elif BSD

# if defined(__NetBSD__) || defined(__OpenBSD__)
#  define _KVM_GETPROC2
#  define _KINFO_PROC kinfo_proc2
#  define _KVM_GETARGV kvm_getargv2
#  define _GET_KINFO_UID(kp) (kp.p_ruid)
#  define _GET_KINFO_COMM(kp) (kp.p_comm)
#  define _GET_KINFO_PID(kp) (kp.p_pid)
#  define _KVM_PATH NULL
#  define _KVM_FLAGS KVM_NO_FILES
# else
#  ifndef KERN_PROC_PROC
#    define KERN_PROC_PROC KERN_PROC_ALL
#  endif
#  define _KINFO_PROC kinfo_proc
#  define _KVM_GETARGV kvm_getargv
#  define _GET_KINFO_UID(kp) (kp.ki_ruid)
#  define _GET_KINFO_COMM(kp) (kp.ki_comm)
#  define _GET_KINFO_PID(kp) (kp.ki_pid)
#  define _KVM_PATH _PATH_DEVNULL
#  define _KVM_FLAGS O_RDONLY
# endif

RC_PIDLIST *rc_find_pids(const char *const *argv, const char *cmd,
			 uid_t uid, pid_t pid)
{
	static kvm_t *kd = NULL;
	char errbuf[_POSIX2_LINE_MAX];
	struct _KINFO_PROC *kp;
	int i;
	int processes = 0;
	int pargc = 0;
	char **pargv;
	RC_PIDLIST *pids = NULL;
	RC_PID *pi;
	pid_t p;
	const char *const *arg;
	int npids = 0;
	int match;

	if ((kd = kvm_openfiles(_KVM_PATH, _KVM_PATH,
			        NULL, _KVM_FLAGS, errbuf)) == NULL)
	{
		fprintf(stderr, "kvm_open: %s\n", errbuf);
		return NULL;
	}

#ifdef _KVM_GETPROC2
	kp = kvm_getproc2(kd, KERN_PROC_ALL, 0, sizeof(*kp), &processes);
#else
	kp = kvm_getprocs(kd, KERN_PROC_PROC, 0, &processes);
#endif
	if ((kp == NULL && processes > 0) || (kp != NULL && processes < 0)) {
		fprintf(stderr, "kvm_getprocs: %s\n", kvm_geterr(kd));
		kvm_close(kd);
		return NULL;
	}

	for (i = 0; i < processes; i++) {
		p = _GET_KINFO_PID(kp[i]);
		if (pid != 0 && pid != p)
			continue;

		if (uid != 0 && uid != _GET_KINFO_UID(kp[i]))
			continue;

		if (cmd) {
			if (! _GET_KINFO_COMM(kp[i]) ||
			    strcmp(cmd, _GET_KINFO_COMM(kp[i])) != 0)
				continue;
		}

		if (argv && *argv && ! cmd) {
			pargv = _KVM_GETARGV(kd, &kp[i], pargc);
			if (! pargv || ! *pargv)
				continue;

			arg = argv;
			match = 1;

			while (*arg && *pargv)
				if (strcmp(*arg++, *pargv++) != 0) {
					match = 0;
					break;
				}

			if (! match)
				continue;
		}

		if (! pids) {
			pids = xmalloc(sizeof(*pids));
			LIST_INIT(pids);
		}
		pi = xmalloc(sizeof(*pi));
		pi->pid = p;
		LIST_INSERT_HEAD(pids, pi, entries);
	}
	kvm_close(kd);

	return pids;
}
librc_hidden_def(rc_find_pids)

#else
#  error "Platform not supported!"
#endif

static bool _match_daemon(const char *path, const char *file,
			  RC_STRINGLIST *match)
{
	char *line;
	char *ffile = rc_strcatpaths(path, file, (char *) NULL);
	FILE *fp;
	RC_STRING *m;

	fp = fopen(ffile, "r");
	free(ffile);

	if (! fp)
		return false;

	while ((line = rc_getline(fp))) {
		TAILQ_FOREACH(m, match, entries)
			if (strcmp(line, m->value) == 0) {
				TAILQ_REMOVE(match, m, entries);
				break;
			}
		if (! TAILQ_FIRST(match))
			break;
	}
	fclose(fp);
	if (TAILQ_FIRST(match))
		return false;
	return true;
}

static RC_STRINGLIST *_match_list(const char* const* argv,
				  const char *name, const char *pidfile)
{
	RC_STRINGLIST *match = rc_stringlist_new();
	int i = 0;
	size_t l;
	char *m;

	while (argv && argv[i]) {
		l = strlen(*argv) + strlen("argv_=") + 16;
		m = xmalloc(sizeof(char) * l);
		snprintf(m, l, "argv_0=%s", argv[i++]);
		rc_stringlist_add(match, m);
		free(m);
	}

	if (name) {
		l = strlen(name) + 6;
		m = xmalloc(sizeof (char) * l);
		snprintf(m, l, "name=%s", name);
		rc_stringlist_add(match, m);
		free(m);
	}

	if (pidfile) {
		l = strlen(pidfile) + 9;
		m = xmalloc(sizeof (char) * l);
		snprintf(m, l, "pidfile=%s", pidfile);
		rc_stringlist_add(match, m);
		free (m);
	}

	return match;
}

bool rc_service_daemon_set(const char *service, const char *const *argv,
			   const char *name, const char *pidfile, bool started)
{
	char *dirpath;
	char *file = NULL;
	int nfiles = 0;
	char *oldfile = NULL;
	bool retval = false;
	DIR *dp;
	struct dirent *d;
	RC_STRINGLIST *match;
	int i = 0;
	char buffer[10];
	FILE *fp;

	if (!(argv && *argv) && ! name && ! pidfile) {
		errno = EINVAL;
		return false;
	}

	dirpath = rc_strcatpaths(RC_SVCDIR, "daemons",
				 basename_c(service), (char *) NULL);

	match = _match_list(argv, name, pidfile);

	/* Regardless, erase any existing daemon info */
	if ((dp = opendir(dirpath))) {
		while ((d = readdir(dp))) {
			if (d->d_name[0] == '.')
				continue;
			file = rc_strcatpaths(dirpath, d->d_name, (char *) NULL);
			nfiles++;

			if (! oldfile) {
				if (_match_daemon(dirpath, d->d_name, match)) {
					unlink (file);
					oldfile = file;
					nfiles--;
				}
			} else {
				rename(file, oldfile);
				free(oldfile);
				oldfile = file;
			}
		}
		free(file);
		closedir(dp);
	}

	/* Now store our daemon info */
	if (started) {
		if (mkdir(dirpath, 0755) == 0 || errno == EEXIST) {
			snprintf(buffer, sizeof(buffer), "%03d", nfiles + 1);
			file = rc_strcatpaths(dirpath, buffer, (char *) NULL);
			if ((fp = fopen(file, "w"))) {
				while (argv && argv[i]) {
					fprintf(fp, "argv_%d=%s\n", i, argv[i]);
					i++;
				}
				fprintf(fp, "name=");
				if (name)
					fprintf(fp, "%s", name);
				fprintf(fp, "\npidfile=");
				if (pidfile)
					fprintf(fp, "%s", pidfile);
				fprintf(fp, "\n");
				fclose(fp);
				retval = true;
			}
			free(file);
		}
	} else
		retval = true;

	rc_stringlist_free(match);
	free(dirpath);

	return retval;
}
librc_hidden_def(rc_service_daemon_set)

bool
rc_service_started_daemon (const char *service, const char *const *argv,
			   int indx)
{
	char *dirpath;
	char *file;
	size_t l;
	RC_STRINGLIST *match;
	bool retval = false;
	DIR *dp;
	struct dirent *d;

	if (!service || !(argv && *argv))
		return false;

	dirpath = rc_strcatpaths(RC_SVCDIR, "daemons", basename_c(service),
				 (char *) NULL);

	match = _match_list(argv, NULL, NULL);

	if (indx > 0) {
		l = sizeof (char) * 10;
		file = xmalloc(l);
		snprintf(file, l, "%03d", indx);
		retval = _match_daemon(dirpath, file, match);
		free(file);
	} else {
		if ((dp = opendir(dirpath))) {
			while ((d = readdir(dp))) {
				if (d->d_name[0] == '.')
					continue;
				retval = _match_daemon(dirpath, d->d_name, match);
				if (retval)
					break;
			}
			closedir(dp);
		}
	}

	free(dirpath);
	rc_stringlist_free(match);
	return retval;
}
librc_hidden_def(rc_service_started_daemon)

bool rc_service_daemons_crashed(const char *service)
{
	char *dirpath;
	DIR *dp;
	struct dirent *d;
	char *path;
	FILE *fp;
	char *line;
	char **argv = NULL;
	char *exec = NULL;
	char *name = NULL;
	char *pidfile = NULL;
	pid_t pid = 0;
	RC_PIDLIST *pids;
	RC_PID *p1;
	RC_PID *p2;
	char *p;
	char *token;
	bool retval = false;
	RC_STRINGLIST *list;
	RC_STRING *s;
	size_t i;

	dirpath = rc_strcatpaths(RC_SVCDIR, "daemons", basename_c(service),
				 (char *) NULL);

	if (! (dp = opendir(dirpath))) {
		free(dirpath);
		return false;
	}

	while ((d = readdir(dp))) {
		if (d->d_name[0] == '.')
			continue;

		path = rc_strcatpaths(dirpath, d->d_name, (char *) NULL);
		fp = fopen(path, "r");
		free(path);
		if (! fp)
			break;

		list = rc_stringlist_new();

		while ((line = rc_getline(fp))) {
			p = line;
			if ((token = strsep(&p, "=")) == NULL || ! p) {
				free(line);
				continue;
			}

			if (! *p) {
				free(line);
				continue;
			}

			if (strncmp(token, "argv_", 5) == 0) {
				rc_stringlist_add(list, p);
			} else if (strcmp(token, "exec") == 0) {
				if (exec)
					free(exec);
				exec = xstrdup(p);
			} else if (strcmp(token, "name") == 0) {
				if (name)
					free(name);
				name = xstrdup(p);
			} else if (strcmp(token, "pidfile") == 0) {
				if (pidfile)
					free(pidfile);
				pidfile = xstrdup(p);
			}
			free(line);
		}
		fclose(fp);

		pid = 0;
		if (pidfile) {
			if (! exists(pidfile)) {
				retval = true;
				break;
			}

			if ((fp = fopen(pidfile, "r")) == NULL) {
				retval = true;
				break;
			}

			if (fscanf(fp, "%d", &pid) != 1) {
				fclose (fp);
				retval = true;
				break;
			}

			fclose(fp);
			free(pidfile);
			pidfile = NULL;

			/* We have the pid, so no need to match on name */
			rc_stringlist_free(list);
			list = NULL;
			free (exec);
			exec = NULL;
			free (name);
			name = NULL;
		} else {
			if (exec && ! TAILQ_FIRST(list)) {
				rc_stringlist_add(list, exec);
			}
			free(exec);
			exec = NULL;

			/* We need to flatten our linked list into an array */
			i = 0;
			TAILQ_FOREACH(s, list, entries)
				i++;
			argv = xmalloc(sizeof(char *) * (i + 1));
			i = 0;
			TAILQ_FOREACH(s, list, entries)
				argv[i++] = s->value;
			argv[i] = '\0';
		}

		if ((pids = rc_find_pids((const char *const *)argv,
					 name, 0, pid)) == NULL)
		{
			p1 = LIST_FIRST(pids);
			while (p1) {
				p2 = LIST_NEXT(p1, entries);
				free(p1);
				p1 = p2;
			}
			free(pids);
			retval = true;
		}
		free(argv);
		argv = NULL;
		rc_stringlist_free(list);
		free(name);
		name = NULL;
		if (retval)
			break;
	}

	free(dirpath);
	closedir(dp);

	return retval;
}
librc_hidden_def(rc_service_daemons_crashed)