--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/contrib/chg/chg.c	Sun Jan 03 12:39:27 2016 +0900
@@ -0,0 +1,331 @@
+/*
+ * A fast client for Mercurial command server
+ *
+ * Copyright (c) 2011 Yuya Nishihara <yuya@tcha.org>
+ *
+ * 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;
+
+	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;
+}