chg: initialize sigaction fields more reliably

It seems calling memset() and sigemptyset() is common pattern to initialize
sigaction. And strictly speaking, sigset_t must be initialized by sigemptyset()
or sigfillset(). I saw git and uwsgi do that way, so let's follow them.

contrib/chg/chg.c

@@ -1,331 +1,332 b''
 /*
  * A fast client for Mercurial command server
  *
  * Copyright (c) 2011 Yuya Nishihara <[e-mail]>
  *
  * This software may be used and distributed according to the terms of the
  * GNU General Public License version 2 or any later version.
  */
 
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/un.h>
 #include <sys/wait.h>
 #include <time.h>
 #include <unistd.h>
 
 #include "hgclient.h"
 #include "util.h"
 
 #ifndef UNIX_PATH_MAX
 #define UNIX_PATH_MAX (sizeof(((struct sockaddr_un *)NULL)->sun_path))
 #endif
 
 struct cmdserveropts {
 	char sockname[UNIX_PATH_MAX];
 	char lockfile[UNIX_PATH_MAX];
 	char pidfile[UNIX_PATH_MAX];
 };
 
 static void preparesockdir(const char *sockdir)
 {
 	int r;
 	r = mkdir(sockdir, 0700);
 	if (r < 0 && errno != EEXIST)
 		abortmsg("cannot create sockdir %s (errno = %d)",
 			 sockdir, errno);
 
 	struct stat st;
 	r = lstat(sockdir, &st);
 	if (r < 0)
 		abortmsg("cannot stat %s (errno = %d)", sockdir, errno);
 	if (!S_ISDIR(st.st_mode))
 		abortmsg("cannot create sockdir %s (file exists)", sockdir);
 	if (st.st_uid != geteuid() || st.st_mode & 0077)
 		abortmsg("insecure sockdir %s", sockdir);
 }
 
 static void setcmdserveropts(struct cmdserveropts *opts)
 {
 	int r;
 	char sockdir[UNIX_PATH_MAX];
 	const char *envsockname = getenv("CHGSOCKNAME");
 	if (!envsockname) {
 		/* by default, put socket file in secure directory
 		 * (permission of socket file may be ignored on some Unices) */
 		const char *tmpdir = getenv("TMPDIR");
 		if (!tmpdir)
 			tmpdir = "/tmp";
 		r = snprintf(sockdir, sizeof(sockdir), "%s/chg%d",
 			     tmpdir, geteuid());
 		if (r < 0 || (size_t)r >= sizeof(sockdir))
 			abortmsg("too long TMPDIR (r = %d)", r);
 		preparesockdir(sockdir);
 	}
 
 	const char *basename = (envsockname) ? envsockname : sockdir;
 	const char *sockfmt = (envsockname) ? "%s" : "%s/server";
 	const char *lockfmt = (envsockname) ? "%s.lock" : "%s/lock";
 	const char *pidfmt = (envsockname) ? "%s.pid" : "%s/pid";
 	r = snprintf(opts->sockname, sizeof(opts->sockname), sockfmt, basename);
 	if (r < 0 || (size_t)r >= sizeof(opts->sockname))
 		abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);
 	r = snprintf(opts->lockfile, sizeof(opts->lockfile), lockfmt, basename);
 	if (r < 0 || (size_t)r >= sizeof(opts->lockfile))
 		abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);
 	r = snprintf(opts->pidfile, sizeof(opts->pidfile), pidfmt, basename);
 	if (r < 0 || (size_t)r >= sizeof(opts->pidfile))
 		abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);
 }
 
 /*
  * Make lock file that indicates cmdserver process is about to start. Created
  * lock file will be deleted by server. (0: success, -1: lock exists)
  */
 static int lockcmdserver(const struct cmdserveropts *opts)
 {
 	int r;
 	char info[32];
 	r = snprintf(info, sizeof(info), "%d", getpid());
 	if (r < 0 || (size_t)r >= sizeof(info))
 		abortmsg("failed to format lock info");
 	r = symlink(info, opts->lockfile);
 	if (r < 0 && errno != EEXIST)
 		abortmsg("failed to make lock %s (errno = %d)",
 			 opts->lockfile, errno);
 	return r;
 }
 
 static void execcmdserver(const struct cmdserveropts *opts)
 {
 	const char *hgcmd = getenv("CHGHG");
 	if (!hgcmd || hgcmd[0] == '\0')
 		hgcmd = getenv("HG");
 	if (!hgcmd || hgcmd[0] == '\0')
 		hgcmd = "hg";
 
 	const char *argv[] = {
 		hgcmd,
 		"serve",
 		"--cwd", "/",
 		"--cmdserver", "chgunix",
 		"--address", opts->sockname,
 		"--daemon-pipefds", opts->lockfile,
 		"--pid-file", opts->pidfile,
 		"--config", "extensions.chgserver=",
 		/* wrap root ui so that it can be disabled/enabled by config */
 		"--config", "progress.assume-tty=1",
 		NULL,
 	};
 	if (execvp(hgcmd, (char **)argv) < 0)
 		abortmsg("failed to exec cmdserver (errno = %d)", errno);
 }
 
 /*
  * Sleep until lock file is deleted, i.e. cmdserver process starts listening.
  * If pid is given, it also checks if the child process fails to start.
  */
 static void waitcmdserver(const struct cmdserveropts *opts, pid_t pid)
 {
 	static const struct timespec sleepreq = {0, 10 * 1000000};
 	int pst = 0;
 
 	for (unsigned int i = 0; i < 10 * 100; i++) {
 		int r;
 		struct stat lst;
 
 		r = lstat(opts->lockfile, &lst);
 		if (r < 0 && errno == ENOENT)
 			return;  /* lock file deleted by server */
 		if (r < 0)
 			goto cleanup;
 
 		if (pid > 0) {
 			/* collect zombie if child process fails to start */
 			r = waitpid(pid, &pst, WNOHANG);
 			if (r != 0)
 				goto cleanup;
 		}
 
 		nanosleep(&sleepreq, NULL);
 	}
 
 	abortmsg("timed out waiting for cmdserver %s", opts->lockfile);
 	return;
 
 cleanup:
 	if (pid > 0)
 		/* lockfile should be made by this process */
 		unlink(opts->lockfile);
 	if (WIFEXITED(pst)) {
 		abortmsg("cmdserver exited with status %d", WEXITSTATUS(pst));
 	} else if (WIFSIGNALED(pst)) {
 		abortmsg("cmdserver killed by signal %d", WTERMSIG(pst));
 	} else {
 		abortmsg("error white waiting cmdserver");
 	}
 }
 
 /* Spawn new background cmdserver */
 static void startcmdserver(const struct cmdserveropts *opts)
 {
 	debugmsg("start cmdserver at %s", opts->sockname);
 
 	if (lockcmdserver(opts) < 0) {
 		debugmsg("lock file exists, waiting...");
 		waitcmdserver(opts, 0);
 		return;
 	}
 
 	/* remove dead cmdserver socket if any */
 	unlink(opts->sockname);
 
 	pid_t pid = fork();
 	if (pid < 0)
 		abortmsg("failed to fork cmdserver process");
 	if (pid == 0) {
 		/* bypass uisetup() of pager extension */
 		int nullfd = open("/dev/null", O_WRONLY);
 		if (nullfd >= 0) {
 			dup2(nullfd, fileno(stdout));
 			close(nullfd);
 		}
 		execcmdserver(opts);
 	} else {
 		waitcmdserver(opts, pid);
 	}
 }
 
 static void killcmdserver(const struct cmdserveropts *opts, int sig)
 {
 	FILE *fp = fopen(opts->pidfile, "r");
 	if (!fp)
 		abortmsg("cannot open %s (errno = %d)", opts->pidfile, errno);
 	int pid = 0;
 	int n = fscanf(fp, "%d", &pid);
 	fclose(fp);
 	if (n != 1 || pid <= 0)
 		abortmsg("cannot read pid from %s", opts->pidfile);
 
 	if (kill((pid_t)pid, sig) < 0) {
 		if (errno == ESRCH)
 			return;
 		abortmsg("cannot kill %d (errno = %d)", pid, errno);
 	}
 }
 
 static pid_t peerpid = 0;
 
 static void forwardsignal(int sig)
 {
 	assert(peerpid > 0);
 	if (kill(peerpid, sig) < 0)
 		abortmsg("cannot kill %d (errno = %d)", peerpid, errno);
 	debugmsg("forward signal %d", sig);
 }
 
 static void setupsignalhandler(pid_t pid)
 {
 	if (pid <= 0)
 		return;
 	peerpid = pid;
 
 	struct sigaction sa;
 	memset(&sa, 0, sizeof(sa));
 	sa.sa_handler = forwardsignal;
 	sa.sa_flags = SA_RESTART;
+	sigemptyset(&sa.sa_mask);
 
 	sigaction(SIGHUP, &sa, NULL);
 	sigaction(SIGINT, &sa, NULL);
 
 	/* terminate frontend by double SIGTERM in case of server freeze */
 	sa.sa_flags |= SA_RESETHAND;
 	sigaction(SIGTERM, &sa, NULL);
 }
 
 /* This implementation is based on hgext/pager.py (pre 369741ef7253) */
 static void setuppager(hgclient_t *hgc, const char *const args[],
 		       size_t argsize)
 {
 	const char *pagercmd = hgc_getpager(hgc, args, argsize);
 	if (!pagercmd)
 		return;
 
 	int pipefds[2];
 	if (pipe(pipefds) < 0)
 		return;
 	pid_t pid = fork();
 	if (pid < 0)
 		goto error;
 	if (pid == 0) {
 		close(pipefds[0]);
 		if (dup2(pipefds[1], fileno(stdout)) < 0)
 			goto error;
 		if (isatty(fileno(stderr))) {
 			if (dup2(pipefds[1], fileno(stderr)) < 0)
 				goto error;
 		}
 		close(pipefds[1]);
 		hgc_attachio(hgc);  /* reattach to pager */
 		return;
 	} else {
 		dup2(pipefds[0], fileno(stdin));
 		close(pipefds[0]);
 		close(pipefds[1]);
 
 		int r = execlp("/bin/sh", "/bin/sh", "-c", pagercmd, NULL);
 		if (r < 0) {
 			abortmsg("cannot start pager '%s' (errno = %d)",
 				 pagercmd, errno);
 		}
 		return;
 	}
 
 error:
 	close(pipefds[0]);
 	close(pipefds[1]);
 	abortmsg("failed to prepare pager (errno = %d)", errno);
 }
 
 int main(int argc, const char *argv[], const char *envp[])
 {
 	if (getenv("CHGDEBUG"))
 		enabledebugmsg();
 
 	struct cmdserveropts opts;
 	setcmdserveropts(&opts);
 
 	if (argc == 2) {
 		int sig = 0;
 		if (strcmp(argv[1], "--kill-chg-daemon") == 0)
 			sig = SIGTERM;
 		if (strcmp(argv[1], "--reload-chg-daemon") == 0)
 			sig = SIGHUP;
 		if (sig > 0) {
 			killcmdserver(&opts, sig);
 			return 0;
 		}
 	}
 
 	hgclient_t *hgc = hgc_open(opts.sockname);
 	if (!hgc) {
 		startcmdserver(&opts);
 		hgc = hgc_open(opts.sockname);
 	}
 	if (!hgc)
 		abortmsg("cannot open hg client");
 
 	setupsignalhandler(hgc_peerpid(hgc));
 	hgc_setenv(hgc, envp);
 	setuppager(hgc, argv + 1, argc - 1);
 	int exitcode = hgc_runcommand(hgc, argv + 1, argc - 1);
 	hgc_close(hgc);
 	return exitcode;
 }

contrib/chg/util.c

@@ -1,121 +1,123 b''
 /*
  * Utility functions
  *
  * Copyright (c) 2011 Yuya Nishihara <[e-mail]>
  *
  * This software may be used and distributed according to the terms of the
  * GNU General Public License version 2 or any later version.
  */
 
 #include <signal.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include "util.h"
 
 void abortmsg(const char *fmt, ...)
 {
 	va_list args;
 	va_start(args, fmt);
 	fputs("\033[1;31mchg: abort: ", stderr);
 	vfprintf(stderr, fmt, args);
 	fputs("\033[m\n", stderr);
 	va_end(args);
 
 	exit(255);
 }
 
 static int debugmsgenabled = 0;
 
 void enabledebugmsg(void)
 {
 	debugmsgenabled = 1;
 }
 
 void debugmsg(const char *fmt, ...)
 {
 	if (!debugmsgenabled)
 		return;
 
 	va_list args;
 	va_start(args, fmt);
 	fputs("\033[1;30mchg: debug: ", stderr);
 	vfprintf(stderr, fmt, args);
 	fputs("\033[m\n", stderr);
 	va_end(args);
 }
 
 /*
  * Execute a shell command in mostly the same manner as system(), with the
  * give environment variables, after chdir to the given cwd. Returns a status
  * code compatible with the Python subprocess module.
  */
 int runshellcmd(const char *cmd, const char *envp[], const char *cwd)
 {
 	enum { F_SIGINT = 1, F_SIGQUIT = 2, F_SIGMASK = 4, F_WAITPID = 8 };
 	unsigned int doneflags = 0;
 	int status = 0;
 	struct sigaction newsa, oldsaint, oldsaquit;
 	sigset_t oldmask;
 
 	/* block or mask signals just as system() does */
+	memset(&newsa, 0, sizeof(newsa));
 	newsa.sa_handler = SIG_IGN;
 	newsa.sa_flags = 0;
 	if (sigemptyset(&newsa.sa_mask) < 0)
 		goto done;
 	if (sigaction(SIGINT, &newsa, &oldsaint) < 0)
 		goto done;
 	doneflags |= F_SIGINT;
 	if (sigaction(SIGQUIT, &newsa, &oldsaquit) < 0)
 		goto done;
 	doneflags |= F_SIGQUIT;
 
 	if (sigaddset(&newsa.sa_mask, SIGCHLD) < 0)
 		goto done;
 	if (sigprocmask(SIG_BLOCK, &newsa.sa_mask, &oldmask) < 0)
 		goto done;
 	doneflags |= F_SIGMASK;
 
 	pid_t pid = fork();
 	if (pid < 0)
 		goto done;
 	if (pid == 0) {
 		sigaction(SIGINT, &oldsaint, NULL);
 		sigaction(SIGQUIT, &oldsaquit, NULL);
 		sigprocmask(SIG_SETMASK, &oldmask, NULL);
 		if (cwd && chdir(cwd) < 0)
 			_exit(127);
 		const char *argv[] = {"sh", "-c", cmd, NULL};
 		if (envp) {
 			execve("/bin/sh", (char **)argv, (char **)envp);
 		} else {
 			execv("/bin/sh", (char **)argv);
 		}
 		_exit(127);
 	} else {
 		if (waitpid(pid, &status, 0) < 0)
 			goto done;
 		doneflags |= F_WAITPID;
 	}
 
 done:
 	if (doneflags & F_SIGINT)
 		sigaction(SIGINT, &oldsaint, NULL);
 	if (doneflags & F_SIGQUIT)
 		sigaction(SIGQUIT, &oldsaquit, NULL);
 	if (doneflags & F_SIGMASK)
 		sigprocmask(SIG_SETMASK, &oldmask, NULL);
 
 	/* no way to report other errors, use 127 (= shell termination) */
 	if (!(doneflags & F_WAITPID))
 		return 127;
 	if (WIFEXITED(status))
 		return WEXITSTATUS(status);
 	if (WIFSIGNALED(status))
 		return -WTERMSIG(status);
 	return 127;
 }