This is an archive of the discontinued Mercurial Phabricator instance.

			Path	Packages
M			contrib/chg/chg.c (80 lines)
M			contrib/chg/hgclient.h (4 lines)
M			contrib/chg/hgclient.c (71 lines)
M			contrib/chg/procutil.c (6 lines)
M			contrib/chg/util.h (2 lines)
M			contrib/chg/util.c (3 lines)
M			contrib/clang-format-blacklist (7 lines)

	Status	Author	Revision
	Closed	durin42	D2059 hgsh: enable clang-format
	Closed	durin42	D2058 chg: enable clang-format on all .c and .h files

Diff 5295

contrib/chg/chg.c

	struct cmdserveropts {			struct cmdserveropts {
	char sockname[PATH_MAX];			char sockname[PATH_MAX];
	char initsockname[PATH_MAX];			char initsockname[PATH_MAX];
	char redirectsockname[PATH_MAX];			char redirectsockname[PATH_MAX];
	size_t argsize;			size_t argsize;
	const char **args;			const char **args;
	};			};

	static void initcmdserveropts(struct cmdserveropts *opts) {			static void initcmdserveropts(struct cmdserveropts *opts)
				{
	memset(opts, 0, sizeof(struct cmdserveropts));			memset(opts, 0, sizeof(struct cmdserveropts));
	}			}

	static void freecmdserveropts(struct cmdserveropts *opts) {			static void freecmdserveropts(struct cmdserveropts *opts)
				{
	free(opts->args);			free(opts->args);
	opts->args = NULL;			opts->args = NULL;
	opts->argsize = 0;			opts->argsize = 0;
	}			}

	/*			/*
	* Test if an argument is a sensitive flag that should be passed to the server.			* Test if an argument is a sensitive flag that should be passed to the server.
	* Return 0 if not, otherwise the number of arguments starting from the current			* Return 0 if not, otherwise the number of arguments starting from the current
	* one that should be passed to the server.			* one that should be passed to the server.
	*/			*/
	static size_t testsensitiveflag(const char *arg)			static size_t testsensitiveflag(const char *arg)
	{			{
	static const struct {			static const struct {
	const char *name;			const char *name;
	size_t narg;			size_t narg;
	} flags[] = {			} flags[] = {
	{"--config", 1},			{"--config", 1}, {"--cwd", 1}, {"--repo", 1},
	{"--cwd", 1},			{"--repository", 1}, {"--traceback", 0}, {"-R", 1},
	{"--repo", 1},
	{"--repository", 1},
	{"--traceback", 0},
	{"-R", 1},
	};			};
	size_t i;			size_t i;
	for (i = 0; i < sizeof(flags) / sizeof(flags[0]); ++i) {			for (i = 0; i < sizeof(flags) / sizeof(flags[0]); ++i) {
	size_t len = strlen(flags[i].name);			size_t len = strlen(flags[i].name);
	size_t narg = flags[i].narg;			size_t narg = flags[i].narg;
	if (memcmp(arg, flags[i].name, len) == 0) {			if (memcmp(arg, flags[i].name, len) == 0) {
	if (arg[len] == '\0') {			if (arg[len] == '\0') {
	/* --flag (value) */			/* --flag (value) */
	return narg + 1;			return narg + 1;
	} else if (arg[len] == '=' && narg > 0) {			} else if (arg[len] == '=' && narg > 0) {
	/* --flag=value */			/* --flag=value */
	return 1;			return 1;
	} else if (flags[i].name[1] != '-') {			} else if (flags[i].name[1] != '-') {
	/* short flag */			/* short flag */
	return 1;			return 1;
	}			}
	}			}
	}			}
	return 0;			return 0;
	}			}

	/*			/*
	* Parse argv[] and put sensitive flags to opts->args			* Parse argv[] and put sensitive flags to opts->args
	*/			*/
	static void setcmdserverargs(struct cmdserveropts *opts,			static void setcmdserverargs(struct cmdserveropts *opts, int argc,
	int argc, const char *argv[])			const char *argv[])
	{			{
	size_t i, step;			size_t i, step;
	opts->argsize = 0;			opts->argsize = 0;
	for (i = 0, step = 1; i < (size_t)argc; i += step, step = 1) {			for (i = 0, step = 1; i < (size_t)argc; i += step, step = 1) {
	if (!argv[i])			if (!argv[i])
	continue; /* pass clang-analyse */			continue; /* pass clang-analyse */
	if (strcmp(argv[i], "--") == 0)			if (strcmp(argv[i], "--") == 0)
	break;			break;
	size_t n = testsensitiveflag(argv[i]);			size_t n = testsensitiveflag(argv[i]);
	if (n == 0 \|\| i + n > (size_t)argc)			if (n == 0 \|\| i + n > (size_t)argc)
	continue;			continue;
	opts->args = reallocx(opts->args,			opts->args =
	(n + opts->argsize) * sizeof(char *));			reallocx(opts->args, (n + opts->argsize) * sizeof(char *));
	memcpy(opts->args + opts->argsize, argv + i,			memcpy(opts->args + opts->argsize, argv + i,
	sizeof(char ) n);			sizeof(char ) n);
	opts->argsize += n;			opts->argsize += n;
	step = n;			step = n;
	}			}
	}			}

	static void preparesockdir(const char *sockdir)			static void preparesockdir(const char *sockdir)
	preparesockdir(sockdir);			preparesockdir(sockdir);
	}			}

	const char *basename = (envsockname) ? envsockname : sockdir;			const char *basename = (envsockname) ? envsockname : sockdir;
	const char *sockfmt = (envsockname) ? "%s" : "%s/server";			const char *sockfmt = (envsockname) ? "%s" : "%s/server";
	r = snprintf(opts->sockname, sizeof(opts->sockname), sockfmt, basename);			r = snprintf(opts->sockname, sizeof(opts->sockname), sockfmt, basename);
	if (r < 0 \|\| (size_t)r >= sizeof(opts->sockname))			if (r < 0 \|\| (size_t)r >= sizeof(opts->sockname))
	abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);			abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);
	r = snprintf(opts->initsockname, sizeof(opts->initsockname),			r = snprintf(opts->initsockname, sizeof(opts->initsockname), "%s.%u",
	"%s.%u", opts->sockname, (unsigned)getpid());			opts->sockname, (unsigned)getpid());
	if (r < 0 \|\| (size_t)r >= sizeof(opts->initsockname))			if (r < 0 \|\| (size_t)r >= sizeof(opts->initsockname))
	abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);			abortmsg("too long TMPDIR or CHGSOCKNAME (r = %d)", r);
	}			}

	static const char *gethgcmd(void)			static const char *gethgcmd(void)
	{			{
	static const char *hgcmd = NULL;			static const char *hgcmd = NULL;
	if (!hgcmd) {			if (!hgcmd) {
	return hgcmd;			return hgcmd;
	}			}

	static void execcmdserver(const struct cmdserveropts *opts)			static void execcmdserver(const struct cmdserveropts *opts)
	{			{
	const char *hgcmd = gethgcmd();			const char *hgcmd = gethgcmd();

	const char *baseargv[] = {			const char *baseargv[] = {
	hgcmd,			hgcmd,
	"serve",			"serve",
	"--cmdserver", "chgunix",			"--cmdserver",
	"--address", opts->initsockname,			"chgunix",
	"--daemon-postexec", "chdir:/",			"--address",
				opts->initsockname,
				"--daemon-postexec",
				"chdir:/",
	};			};
	size_t baseargvsize = sizeof(baseargv) / sizeof(baseargv[0]);			size_t baseargvsize = sizeof(baseargv) / sizeof(baseargv[0]);
	size_t argsize = baseargvsize + opts->argsize + 1;			size_t argsize = baseargvsize + opts->argsize + 1;

	const char *argv = mallocx(sizeof(char ) * argsize);			const char *argv = mallocx(sizeof(char ) * argsize);
	memcpy(argv, baseargv, sizeof(baseargv));			memcpy(argv, baseargv, sizeof(baseargv));
	memcpy(argv + baseargvsize, opts->args, sizeof(char ) opts->argsize);			memcpy(argv + baseargvsize, opts->args, sizeof(char ) opts->argsize);
	argv[argsize - 1] = NULL;			argv[argsize - 1] = NULL;

	if (putenv("CHGINTERNALMARK=") != 0)			if (putenv("CHGINTERNALMARK=") != 0)
	abortmsgerrno("failed to putenv");			abortmsgerrno("failed to putenv");
	if (execvp(hgcmd, (char **)argv) < 0)			if (execvp(hgcmd, (char **)argv) < 0)
	abortmsgerrno("failed to exec cmdserver");			abortmsgerrno("failed to exec cmdserver");
	free(argv);			free(argv);
	}			}

	/* Retry until we can connect to the server. Give up after some time. */			/* Retry until we can connect to the server. Give up after some time. */
	static hgclient_t retryconnectcmdserver(struct cmdserveropts opts, pid_t pid)			static hgclient_t retryconnectcmdserver(struct cmdserveropts opts, pid_t pid)
	{			{
	static const struct timespec sleepreq = {0, 10 * 1000000};			static const struct timespec sleepreq = {0, 10 * 1000000};
	int pst = 0;			int pst = 0;

	debugmsg("try connect to %s repeatedly", opts->initsockname);			debugmsg("try connect to %s repeatedly", opts->initsockname);

	unsigned int timeoutsec = 60; /* default: 60 seconds */			unsigned int timeoutsec = 60; /* default: 60 seconds */
	const char *timeoutenv = getenv("CHGTIMEOUT");			const char *timeoutenv = getenv("CHGTIMEOUT");
	if (timeoutenv)			if (timeoutenv)
	sscanf(timeoutenv, "%u", &timeoutsec);			sscanf(timeoutenv, "%u", &timeoutsec);

	for (unsigned int i = 0; !timeoutsec \|\| i < timeoutsec * 100; i++) {			for (unsigned int i = 0; !timeoutsec \|\| i < timeoutsec * 100; i++) {
	hgclient_t *hgc = hgc_open(opts->initsockname);			hgclient_t *hgc = hgc_open(opts->initsockname);
	if (hgc) {			if (hgc) {
	debugmsg("rename %s to %s", opts->initsockname,			debugmsg("rename %s to %s", opts->initsockname,
	opts->sockname);			opts->sockname);
	int r = rename(opts->initsockname, opts->sockname);			int r = rename(opts->initsockname, opts->sockname);
	if (r != 0)			if (r != 0)
	abortmsgerrno("cannot rename");			abortmsgerrno("cannot rename");
	return hgc;			return hgc;
	}			}

	if (pid > 0) {			if (pid > 0) {
	/* collect zombie if child process fails to start */			/* collect zombie if child process fails to start */
	int r = waitpid(pid, &pst, WNOHANG);			int r = waitpid(pid, &pst, WNOHANG);
	if (r != 0)			if (r != 0)
	goto cleanup;			goto cleanup;
	}			}

	nanosleep(&sleepreq, NULL);			nanosleep(&sleepreq, NULL);
	}			}

	abortmsg("timed out waiting for cmdserver %s", opts->initsockname);			abortmsg("timed out waiting for cmdserver %s", opts->initsockname);
	return NULL;			return NULL;

	cleanup:			cleanup:
	if (WIFEXITED(pst)) {			if (WIFEXITED(pst)) {
	if (WEXITSTATUS(pst) == 0)			if (WEXITSTATUS(pst) == 0)
	abortmsg("could not connect to cmdserver "			abortmsg("could not connect to cmdserver "
	"(exited with status 0)");			"(exited with status 0)");
	debugmsg("cmdserver exited with status %d", WEXITSTATUS(pst));			debugmsg("cmdserver exited with status %d", WEXITSTATUS(pst));
	exit(WEXITSTATUS(pst));			exit(WEXITSTATUS(pst));
	} else if (WIFSIGNALED(pst)) {			} else if (WIFSIGNALED(pst)) {
	abortmsg("cmdserver killed by signal %d", WTERMSIG(pst));			abortmsg("cmdserver killed by signal %d", WTERMSIG(pst));
	} else {			} else {
	abortmsg("error while waiting for cmdserver");			abortmsg("error while waiting for cmdserver");
	}			}
	return NULL;			return NULL;
	}			}

	/* Connect to a cmdserver. Will start a new server on demand. */			/* Connect to a cmdserver. Will start a new server on demand. */
	static hgclient_t connectcmdserver(struct cmdserveropts opts)			static hgclient_t connectcmdserver(struct cmdserveropts opts)
	{			{
	const char *sockname = opts->redirectsockname[0] ?			const char *sockname =
	opts->redirectsockname : opts->sockname;			opts->redirectsockname[0] ? opts->redirectsockname : opts->sockname;
	debugmsg("try connect to %s", sockname);			debugmsg("try connect to %s", sockname);
	hgclient_t *hgc = hgc_open(sockname);			hgclient_t *hgc = hgc_open(sockname);
	if (hgc)			if (hgc)
	return hgc;			return hgc;

	/* prevent us from being connected to an outdated server: we were			/* prevent us from being connected to an outdated server: we were
	* told by a server to redirect to opts->redirectsockname and that			* told by a server to redirect to opts->redirectsockname and that
	* address does not work. we do not want to connect to the server			* address does not work. we do not want to connect to the server
	opts->redirectsockname[0] = '\0';			opts->redirectsockname[0] = '\0';
	const char **pinst;			const char **pinst;
	for (pinst = insts; *pinst; pinst++) {			for (pinst = insts; *pinst; pinst++) {
	debugmsg("instruction: %s", *pinst);			debugmsg("instruction: %s", *pinst);
	if (strncmp(*pinst, "unlink ", 7) == 0) {			if (strncmp(*pinst, "unlink ", 7) == 0) {
	unlink(*pinst + 7);			unlink(*pinst + 7);
	} else if (strncmp(*pinst, "redirect ", 9) == 0) {			} else if (strncmp(*pinst, "redirect ", 9) == 0) {
	int r = snprintf(opts->redirectsockname,			int r = snprintf(opts->redirectsockname,
	sizeof(opts->redirectsockname),			sizeof(opts->redirectsockname), "%s",
	"%s", *pinst + 9);			*pinst + 9);
	if (r < 0 \|\| r >= (int)sizeof(opts->redirectsockname))			if (r < 0 \|\| r >= (int)sizeof(opts->redirectsockname))
	abortmsg("redirect path is too long (%d)", r);			abortmsg("redirect path is too long (%d)", r);
	needreconnect = 1;			needreconnect = 1;
	} else if (strncmp(*pinst, "exit ", 5) == 0) {			} else if (strncmp(*pinst, "exit ", 5) == 0) {
	int n = 0;			int n = 0;
	if (sscanf(*pinst + 5, "%d", &n) != 1)			if (sscanf(*pinst + 5, "%d", &n) != 1)
	abortmsg("cannot read the exit code");			abortmsg("cannot read the exit code");
	exit(n);			exit(n);
	} else if (strcmp(*pinst, "reconnect") == 0) {			} else if (strcmp(*pinst, "reconnect") == 0) {
	needreconnect = 1;			needreconnect = 1;
	} else {			} else {
	abortmsg("unknown instruction: %s", *pinst);			abortmsg("unknown instruction: %s", *pinst);
	}			}
	}			}
	return needreconnect;			return needreconnect;
	}			}

	/*			/*
	* Test whether the command is unsupported or not. This is not designed to			* Test whether the command is unsupported or not. This is not designed to
	* cover all cases. But it's fast, does not depend on the server and does			* cover all cases. But it's fast, does not depend on the server and does
	* not return false positives.			* not return false positives.
	*/			*/
	static int isunsupported(int argc, const char *argv[])			static int isunsupported(int argc, const char *argv[])
	{			{
	enum {			enum { SERVE = 1,
	SERVE = 1,
	DAEMON = 2,			DAEMON = 2,
	SERVEDAEMON = SERVE \| DAEMON,			SERVEDAEMON = SERVE \| DAEMON,
	};			};
	unsigned int state = 0;			unsigned int state = 0;
	int i;			int i;
	for (i = 0; i < argc; ++i) {			for (i = 0; i < argc; ++i) {
	if (strcmp(argv[i], "--") == 0)			if (strcmp(argv[i], "--") == 0)
	break;			break;
	if (i == 0 && strcmp("serve", argv[i]) == 0)			if (i == 0 && strcmp("serve", argv[i]) == 0)
	state \|= SERVE;			state \|= SERVE;
	else if (strcmp("-d", argv[i]) == 0 \|\|			else if (strcmp("-d", argv[i]) == 0 \|\|
	strcmp("--daemon", argv[i]) == 0)			strcmp("--daemon", argv[i]) == 0)
	state \|= DAEMON;			state \|= DAEMON;
	}			}
	return (state & SERVEDAEMON) == SERVEDAEMON;			return (state & SERVEDAEMON) == SERVEDAEMON;
	}			}

	static void execoriginalhg(const char *argv[])			static void execoriginalhg(const char *argv[])
	{			{
	debugmsg("execute original hg");			debugmsg("execute original hg");
	if (execvp(gethgcmd(), (char **)argv) < 0)			if (execvp(gethgcmd(), (char **)argv) < 0)
	abortmsgerrno("failed to exec original hg");			abortmsgerrno("failed to exec original hg");
	}			}

	int main(int argc, const char argv[], const char envp[])			int main(int argc, const char argv[], const char envp[])
	{			{
	if (getenv("CHGDEBUG"))			if (getenv("CHGDEBUG"))
	enabledebugmsg();			enabledebugmsg();

	if (!getenv("HGPLAIN") && isatty(fileno(stderr)))			if (!getenv("HGPLAIN") && isatty(fileno(stderr)))
	enablecolor();			enablecolor();

	if (getenv("CHGINTERNALMARK"))			if (getenv("CHGINTERNALMARK"))
	abortmsg("chg started by chg detected.\n"			abortmsg("chg started by chg detected.\n"
	"Please make sure ${HG:-hg} is not a symlink or "			"Please make sure ${HG:-hg} is not a symlink or "
	"wrapper to chg. Alternatively, set $CHGHG to the "			"wrapper to chg. Alternatively, set $CHGHG to the "
	"path of real hg.");			"path of real hg.");

	if (isunsupported(argc - 1, argv + 1))			if (isunsupported(argc - 1, argv + 1))
	execoriginalhg(argv);			execoriginalhg(argv);

	struct cmdserveropts opts;			struct cmdserveropts opts;
	initcmdserveropts(&opts);			initcmdserveropts(&opts);
	setcmdserveropts(&opts);			setcmdserveropts(&opts);
	setcmdserverargs(&opts, argc, argv);			setcmdserverargs(&opts, argc, argv);
	const char **insts = hgc_validate(hgc, argv + 1, argc - 1);			const char **insts = hgc_validate(hgc, argv + 1, argc - 1);
	int needreconnect = runinstructions(&opts, insts);			int needreconnect = runinstructions(&opts, insts);
	free(insts);			free(insts);
	if (!needreconnect)			if (!needreconnect)
	break;			break;
	hgc_close(hgc);			hgc_close(hgc);
	if (++retry > 10)			if (++retry > 10)
	abortmsg("too many redirections.\n"			abortmsg("too many redirections.\n"
	"Please make sure %s is not a wrapper which "			"Please make sure %s is not a wrapper which "
	"changes sensitive environment variables "			"changes sensitive environment variables "
	"before executing hg. If you have to use a "			"before executing hg. If you have to use a "
	"wrapper, wrap chg instead of hg.",			"wrapper, wrap chg instead of hg.",
	gethgcmd());			gethgcmd());
	}			}

	setupsignalhandler(hgc_peerpid(hgc), hgc_peerpgid(hgc));			setupsignalhandler(hgc_peerpid(hgc), hgc_peerpgid(hgc));
	atexit(waitpager);			atexit(waitpager);
	int exitcode = hgc_runcommand(hgc, argv + 1, argc - 1);			int exitcode = hgc_runcommand(hgc, argv + 1, argc - 1);
	restoresignalhandler();			restoresignalhandler();
	hgc_close(hgc);			hgc_close(hgc);
	freecmdserveropts(&opts);			freecmdserveropts(&opts);

	return exitcode;			return exitcode;
	}			}

contrib/chg/hgclient.h


	hgclient_t hgc_open(const char sockname);			hgclient_t hgc_open(const char sockname);
	void hgc_close(hgclient_t *hgc);			void hgc_close(hgclient_t *hgc);

	pid_t hgc_peerpgid(const hgclient_t *hgc);			pid_t hgc_peerpgid(const hgclient_t *hgc);
	pid_t hgc_peerpid(const hgclient_t *hgc);			pid_t hgc_peerpid(const hgclient_t *hgc);

	const char *hgc_validate(hgclient_t hgc, const char *const args[],			const char *hgc_validate(hgclient_t hgc, const char *const args[],
	size_t argsize);			size_t argsize);
	int hgc_runcommand(hgclient_t hgc, const char const args[], size_t argsize);			int hgc_runcommand(hgclient_t hgc, const char const args[], size_t argsize);
	void hgc_attachio(hgclient_t *hgc);			void hgc_attachio(hgclient_t *hgc);
	void hgc_setenv(hgclient_t hgc, const char const envp[]);			void hgc_setenv(hgclient_t hgc, const char const envp[]);

	#endif /* HGCLIENT_H_ */			#endif /* HGCLIENT_H_ */

contrib/chg/hgclient.c

	/*			/*
	* A command server client that uses Unix domain socket			* A command server client that uses Unix domain socket
	*			*
	* Copyright (c) 2011 Yuya Nishihara <yuya@tcha.org>			* Copyright (c) 2011 Yuya Nishihara <yuya@tcha.org>
	*			*
	* This software may be used and distributed according to the terms of the			* This software may be used and distributed according to the terms of the
	* GNU General Public License version 2 or any later version.			* GNU General Public License version 2 or any later version.
	*/			*/

	#include <arpa/inet.h> /* for ntohl(), htonl() */			#include <arpa/inet.h> /* for ntohl(), htonl() */
	#include <assert.h>			#include <assert.h>
	#include <ctype.h>			#include <ctype.h>
	#include <errno.h>			#include <errno.h>
	#include <fcntl.h>			#include <fcntl.h>
	#include <signal.h>			#include <signal.h>
	#include <stdint.h>			#include <stdint.h>
	#include <stdio.h>			#include <stdio.h>
	#include <stdlib.h>			#include <stdlib.h>
	#include <string.h>			#include <string.h>
	#include <sys/socket.h>			#include <sys/socket.h>
	#include <sys/stat.h>			#include <sys/stat.h>
	#include <sys/un.h>			#include <sys/un.h>
	#include <unistd.h>			#include <unistd.h>

	#include "hgclient.h"			#include "hgclient.h"
	#include "procutil.h"			#include "procutil.h"
	#include "util.h"			#include "util.h"

	enum {			enum { CAP_GETENCODING = 0x0001,
	CAP_GETENCODING = 0x0001,
	CAP_RUNCOMMAND = 0x0002,			CAP_RUNCOMMAND = 0x0002,
	/* cHg extension: */			/* cHg extension: */
	CAP_ATTACHIO = 0x0100,			CAP_ATTACHIO = 0x0100,
	CAP_CHDIR = 0x0200,			CAP_CHDIR = 0x0200,
	CAP_SETENV = 0x0800,			CAP_SETENV = 0x0800,
	CAP_SETUMASK = 0x1000,			CAP_SETUMASK = 0x1000,
	CAP_VALIDATE = 0x2000,			CAP_VALIDATE = 0x2000,
	CAP_SETPROCNAME = 0x4000,			CAP_SETPROCNAME = 0x4000,
	};			};

	typedef struct {			typedef struct {
	const char *name;			const char *name;
	unsigned int flag;			unsigned int flag;
	} cappair_t;			} cappair_t;

	static const cappair_t captable[] = {			static const cappair_t captable[] = {
	{"getencoding", CAP_GETENCODING},			{"getencoding", CAP_GETENCODING},
	{"runcommand", CAP_RUNCOMMAND},			{"runcommand", CAP_RUNCOMMAND},
	{"attachio", CAP_ATTACHIO},			{"attachio", CAP_ATTACHIO},
	{"chdir", CAP_CHDIR},			{"chdir", CAP_CHDIR},
	{"setenv", CAP_SETENV},			{"setenv", CAP_SETENV},
	{"setumask", CAP_SETUMASK},			{"setumask", CAP_SETUMASK},
	{"validate", CAP_VALIDATE},			{"validate", CAP_VALIDATE},
	{"setprocname", CAP_SETPROCNAME},			{"setprocname", CAP_SETPROCNAME},
	{NULL, 0}, /* terminator */			{NULL, 0}, /* terminator */
	};			};

	typedef struct {			typedef struct {
	char ch;			char ch;
	char *data;			char *data;
	size_t maxdatasize;			size_t maxdatasize;
	size_t datasize;			size_t datasize;
	} context_t;			} context_t;
	debugmsg("initialize context buffer with size %zu", ctx->maxdatasize);			debugmsg("initialize context buffer with size %zu", ctx->maxdatasize);
	}			}

	static void enlargecontext(context_t *ctx, size_t newsize)			static void enlargecontext(context_t *ctx, size_t newsize)
	{			{
	if (newsize <= ctx->maxdatasize)			if (newsize <= ctx->maxdatasize)
	return;			return;

	newsize = defaultdatasize			newsize = defaultdatasize *
	* ((newsize + defaultdatasize - 1) / defaultdatasize);			((newsize + defaultdatasize - 1) / defaultdatasize);
	ctx->data = reallocx(ctx->data, newsize);			ctx->data = reallocx(ctx->data, newsize);
	ctx->maxdatasize = newsize;			ctx->maxdatasize = newsize;
	debugmsg("enlarge context buffer to %zu", ctx->maxdatasize);			debugmsg("enlarge context buffer to %zu", ctx->maxdatasize);
	}			}

	static void freecontext(context_t *ctx)			static void freecontext(context_t *ctx)
	{			{
	debugmsg("free context buffer");			debugmsg("free context buffer");
	if (rsize != sizeof(datasize_n))			if (rsize != sizeof(datasize_n))
	abortmsg("failed to read data size");			abortmsg("failed to read data size");

	/* datasize denotes the maximum size to write if input request */			/* datasize denotes the maximum size to write if input request */
	hgc->ctx.datasize = ntohl(datasize_n);			hgc->ctx.datasize = ntohl(datasize_n);
	enlargecontext(&hgc->ctx, hgc->ctx.datasize);			enlargecontext(&hgc->ctx, hgc->ctx.datasize);

	if (isupper(hgc->ctx.ch) && hgc->ctx.ch != 'S')			if (isupper(hgc->ctx.ch) && hgc->ctx.ch != 'S')
	return; /* assumes input request */			return; /* assumes input request */

	size_t cursize = 0;			size_t cursize = 0;
	while (cursize < hgc->ctx.datasize) {			while (cursize < hgc->ctx.datasize) {
	rsize = recv(hgc->sockfd, hgc->ctx.data + cursize,			rsize = recv(hgc->sockfd, hgc->ctx.data + cursize,
	hgc->ctx.datasize - cursize, 0);			hgc->ctx.datasize - cursize, 0);
	if (rsize < 1)			if (rsize < 1)
	abortmsg("failed to read data block");			abortmsg("failed to read data block");
	cursize += rsize;			cursize += rsize;
	}			}
	}			}

	static void sendall(int sockfd, const void *data, size_t datasize)			static void sendall(int sockfd, const void *data, size_t datasize)
	{			{
	sendall(hgc->sockfd, buf, sizeof(buf));			sendall(hgc->sockfd, buf, sizeof(buf));

	writeblock(hgc);			writeblock(hgc);
	}			}

	/* Build '\0'-separated list of args. argsize < 0 denotes that args are			/* Build '\0'-separated list of args. argsize < 0 denotes that args are
	* terminated by NULL. */			* terminated by NULL. */
	static void packcmdargs(context_t ctx, const char const args[],			static void packcmdargs(context_t ctx, const char const args[],
	ssize_t argsize)			ssize_t argsize)
	{			{
	ctx->datasize = 0;			ctx->datasize = 0;
	const char const const end = (argsize >= 0) ? args + argsize : NULL;			const char const const end = (argsize >= 0) ? args + argsize : NULL;
	for (const char const it = args; it != end && *it; ++it) {			for (const char const it = args; it != end && *it; ++it) {
	const size_t n = strlen(it) + 1; / include '\0' */			const size_t n = strlen(it) + 1; / include '\0' */
	enlargecontext(ctx, ctx->datasize + n);			enlargecontext(ctx, ctx->datasize + n);
	memcpy(ctx->data + ctx->datasize, *it, n);			memcpy(ctx->data + ctx->datasize, *it, n);
	ctx->datasize += n;			ctx->datasize += n;
	}			}

	if (ctx->datasize > 0)			if (ctx->datasize > 0)
	--ctx->datasize; /* strip last '\0' */			--ctx->datasize; /* strip last '\0' */
	}			}

	/* Extract '\0'-separated list of args to new buffer, terminated by NULL */			/* Extract '\0'-separated list of args to new buffer, terminated by NULL */
	static const char *unpackcmdargsnul(const context_t ctx)			static const char *unpackcmdargsnul(const context_t ctx)
	{			{
	const char **args = NULL;			const char **args = NULL;
	size_t nargs = 0, maxnargs = 0;			size_t nargs = 0, maxnargs = 0;
	const char *s = ctx->data;			const char *s = ctx->data;
	const char *e = ctx->data + ctx->datasize;			const char *e = ctx->data + ctx->datasize;
	for (;;) {			for (;;) {
	if (nargs + 1 >= maxnargs) { /* including last NULL */			if (nargs + 1 >= maxnargs) { /* including last NULL */
	maxnargs += 256;			maxnargs += 256;
	args = reallocx(args, maxnargs * sizeof(args[0]));			args = reallocx(args, maxnargs * sizeof(args[0]));
	}			}
	args[nargs] = s;			args[nargs] = s;
	nargs++;			nargs++;
	s = memchr(s, '\0', e - s);			s = memchr(s, '\0', e - s);
	if (!s)			if (!s)
	break;			break;
	writeblock(hgc);			writeblock(hgc);
	}			}

	/* Execute the requested command and write exit code */			/* Execute the requested command and write exit code */
	static void handlesystemrequest(hgclient_t *hgc)			static void handlesystemrequest(hgclient_t *hgc)
	{			{
	context_t *ctx = &hgc->ctx;			context_t *ctx = &hgc->ctx;
	enlargecontext(ctx, ctx->datasize + 1);			enlargecontext(ctx, ctx->datasize + 1);
	ctx->data[ctx->datasize] = '\0'; /* terminate last string */			ctx->data[ctx->datasize] = '\0'; /* terminate last string */

	const char **args = unpackcmdargsnul(ctx);			const char **args = unpackcmdargsnul(ctx);
	if (!args[0] \|\| !args[1] \|\| !args[2])			if (!args[0] \|\| !args[1] \|\| !args[2])
	abortmsg("missing type or command or cwd in system request");			abortmsg("missing type or command or cwd in system request");
	if (strcmp(args[0], "system") == 0) {			if (strcmp(args[0], "system") == 0) {
	debugmsg("run '%s' at '%s'", args[1], args[2]);			debugmsg("run '%s' at '%s'", args[1], args[2]);
	int32_t r = runshellcmd(args[1], args + 3, args[2]);			int32_t r = runshellcmd(args[1], args + 3, args[2]);
	free(args);			free(args);
	}			}

	/* Read response of command execution until receiving 'r'-esult */			/* Read response of command execution until receiving 'r'-esult */
	static void handleresponse(hgclient_t *hgc)			static void handleresponse(hgclient_t *hgc)
	{			{
	for (;;) {			for (;;) {
	readchannel(hgc);			readchannel(hgc);
	context_t *ctx = &hgc->ctx;			context_t *ctx = &hgc->ctx;
	debugmsg("response read from channel %c, size %zu",			debugmsg("response read from channel %c, size %zu", ctx->ch,
	ctx->ch, ctx->datasize);			ctx->datasize);
	switch (ctx->ch) {			switch (ctx->ch) {
	case 'o':			case 'o':
	fwrite(ctx->data, sizeof(ctx->data[0]), ctx->datasize,			fwrite(ctx->data, sizeof(ctx->data[0]), ctx->datasize,
	stdout);			stdout);
	break;			break;
	case 'e':			case 'e':
	fwrite(ctx->data, sizeof(ctx->data[0]), ctx->datasize,			fwrite(ctx->data, sizeof(ctx->data[0]), ctx->datasize,
	stderr);			stderr);
	handlereadlinerequest(hgc);			handlereadlinerequest(hgc);
	break;			break;
	case 'S':			case 'S':
	handlesystemrequest(hgc);			handlesystemrequest(hgc);
	break;			break;
	default:			default:
	if (isupper(ctx->ch))			if (isupper(ctx->ch))
	abortmsg("cannot handle response (ch = %c)",			abortmsg("cannot handle response (ch = %c)",
	ctx->ch);			ctx->ch);
	}			}
	}			}
	}			}

	static unsigned int parsecapabilities(const char s, const char e)			static unsigned int parsecapabilities(const char s, const char e)
	{			{
	unsigned int flags = 0;			unsigned int flags = 0;
	while (s < e) {			while (s < e) {
	}			}
	s = u + 1;			s = u + 1;
	}			}
	debugmsg("capflags=0x%04x, pid=%d", hgc->capflags, hgc->pid);			debugmsg("capflags=0x%04x, pid=%d", hgc->capflags, hgc->pid);
	}			}

	static void updateprocname(hgclient_t *hgc)			static void updateprocname(hgclient_t *hgc)
	{			{
	int r = snprintf(hgc->ctx.data, hgc->ctx.maxdatasize,			int r = snprintf(hgc->ctx.data, hgc->ctx.maxdatasize, "chg[worker/%d]",
	"chg[worker/%d]", (int)getpid());			(int)getpid());
	if (r < 0 \|\| (size_t)r >= hgc->ctx.maxdatasize)			if (r < 0 \|\| (size_t)r >= hgc->ctx.maxdatasize)
	abortmsg("insufficient buffer to write procname (r = %d)", r);			abortmsg("insufficient buffer to write procname (r = %d)", r);
	hgc->ctx.datasize = (size_t)r;			hgc->ctx.datasize = (size_t)r;
	writeblockrequest(hgc, "setprocname");			writeblockrequest(hgc, "setprocname");
	}			}

	static void attachio(hgclient_t *hgc)			static void attachio(hgclient_t *hgc)
	{			{
	debugmsg("request attachio");			debugmsg("request attachio");
	static const char chcmd[] = "attachio\n";			static const char chcmd[] = "attachio\n";
	sendall(hgc->sockfd, chcmd, sizeof(chcmd) - 1);			sendall(hgc->sockfd, chcmd, sizeof(chcmd) - 1);
	readchannel(hgc);			readchannel(hgc);
	context_t *ctx = &hgc->ctx;			context_t *ctx = &hgc->ctx;
	if (ctx->ch != 'I')			if (ctx->ch != 'I')
	abortmsg("unexpected response for attachio (ch = %c)", ctx->ch);			abortmsg("unexpected response for attachio (ch = %c)", ctx->ch);

	static const int fds[3] = {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO};			static const int fds[3] = {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO};
	struct msghdr msgh;			struct msghdr msgh;
	memset(&msgh, 0, sizeof(msgh));			memset(&msgh, 0, sizeof(msgh));
	struct iovec iov = {ctx->data, ctx->datasize}; /* dummy payload */			struct iovec iov = {ctx->data, ctx->datasize}; /* dummy payload */
	msgh.msg_iov = &iov;			msgh.msg_iov = &iov;
	msgh.msg_iovlen = 1;			msgh.msg_iovlen = 1;
	char fdbuf[CMSG_SPACE(sizeof(fds))];			char fdbuf[CMSG_SPACE(sizeof(fds))];
	msgh.msg_control = fdbuf;			msgh.msg_control = fdbuf;
	msgh.msg_controllen = sizeof(fdbuf);			msgh.msg_controllen = sizeof(fdbuf);
	struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msgh);			struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msgh);
	cmsg->cmsg_level = SOL_SOCKET;			cmsg->cmsg_level = SOL_SOCKET;
	cmsg->cmsg_type = SCM_RIGHTS;			cmsg->cmsg_type = SCM_RIGHTS;
	* support "validate" command.			* support "validate" command.
	* - a list of strings, the server probably cannot handle our request			* - a list of strings, the server probably cannot handle our request
	* and it sent instructions telling us what to do next. See			* and it sent instructions telling us what to do next. See
	* chgserver.py for possible instruction formats.			* chgserver.py for possible instruction formats.
	* the list should be freed by the caller.			* the list should be freed by the caller.
	* the last string is guaranteed to be NULL.			* the last string is guaranteed to be NULL.
	*/			*/
	const char *hgc_validate(hgclient_t hgc, const char *const args[],			const char *hgc_validate(hgclient_t hgc, const char *const args[],
	size_t argsize)			size_t argsize)
	{			{
	assert(hgc);			assert(hgc);
	if (!(hgc->capflags & CAP_VALIDATE))			if (!(hgc->capflags & CAP_VALIDATE))
	return NULL;			return NULL;

	packcmdargs(&hgc->ctx, args, argsize);			packcmdargs(&hgc->ctx, args, argsize);
	writeblockrequest(hgc, "validate");			writeblockrequest(hgc, "validate");
	handleresponse(hgc);			handleresponse(hgc);

contrib/chg/procutil.c

	goto error;			goto error;
	memset(&sa, 0, sizeof(sa));			memset(&sa, 0, sizeof(sa));
	sa.sa_handler = SIG_DFL;			sa.sa_handler = SIG_DFL;
	sa.sa_flags = SA_RESTART;			sa.sa_flags = SA_RESTART;
	if (sigemptyset(&sa.sa_mask) < 0)			if (sigemptyset(&sa.sa_mask) < 0)
	goto error;			goto error;

	forwardsignal(sig);			forwardsignal(sig);
	if (raise(sig) < 0) /* resend to self */			if (raise(sig) < 0) /* resend to self */
	goto error;			goto error;
	if (sigaction(sig, &sa, &oldsa) < 0)			if (sigaction(sig, &sa, &oldsa) < 0)
	goto error;			goto error;
	if (sigprocmask(SIG_UNBLOCK, &unblockset, &oldset) < 0)			if (sigprocmask(SIG_UNBLOCK, &unblockset, &oldset) < 0)
	goto error;			goto error;
	/* resent signal will be handled before sigprocmask() returns */			/* resent signal will be handled before sigprocmask() returns */
	if (sigprocmask(SIG_SETMASK, &oldset, NULL) < 0)			if (sigprocmask(SIG_SETMASK, &oldset, NULL) < 0)
	goto error;			goto error;
	close(pipefds[1]);			close(pipefds[1]);
	pagerpid = pid;			pagerpid = pid;
	return pid;			return pid;
	} else {			} else {
	dup2(pipefds[0], fileno(stdin));			dup2(pipefds[0], fileno(stdin));
	close(pipefds[0]);			close(pipefds[0]);
	close(pipefds[1]);			close(pipefds[1]);

	int r = execle("/bin/sh", "/bin/sh", "-c", pagercmd, NULL,			int r =
	envp);			execle("/bin/sh", "/bin/sh", "-c", pagercmd, NULL, envp);
	if (r < 0) {			if (r < 0) {
	abortmsgerrno("cannot start pager '%s'", pagercmd);			abortmsgerrno("cannot start pager '%s'", pagercmd);
	}			}
	return 0;			return 0;
	}			}

	error:			error:
	close(pipefds[0]);			close(pipefds[0]);

contrib/chg/util.h


	void fchdirx(int dirfd);			void fchdirx(int dirfd);
	void fsetcloexec(int fd);			void fsetcloexec(int fd);
	void *mallocx(size_t size);			void *mallocx(size_t size);
	void reallocx(void ptr, size_t size);			void reallocx(void ptr, size_t size);

	int runshellcmd(const char cmd, const char envp[], const char *cwd);			int runshellcmd(const char cmd, const char envp[], const char *cwd);

	#endif /* UTIL_H_ */			#endif /* UTIL_H_ */

contrib/chg/util.c

	va_start(args, fmt);			va_start(args, fmt);
	vabortmsgerrno(no, fmt, args);			vabortmsgerrno(no, fmt, args);
	va_end(args);			va_end(args);
	}			}

	static int debugmsgenabled = 0;			static int debugmsgenabled = 0;
	static double debugstart = 0;			static double debugstart = 0;

	static double now() {			static double now()
				{
	struct timeval t;			struct timeval t;
	gettimeofday(&t, NULL);			gettimeofday(&t, NULL);
	return t.tv_usec / 1e6 + t.tv_sec;			return t.tv_usec / 1e6 + t.tv_sec;
	}			}

	void enablecolor(void)			void enablecolor(void)
	{			{
	colorenabled = 1;			colorenabled = 1;

contrib/clang-format-blacklist

	# Files that just need to be migrated to the formatter.			# Files that just need to be migrated to the formatter.
	# Do not add new files here!			# Do not add new files here!
	contrib/chg/chg.c
	contrib/chg/hgclient.c
	contrib/chg/hgclient.h
	contrib/chg/procutil.c
	contrib/chg/procutil.h
	contrib/chg/util.c
	contrib/chg/util.h
	contrib/hgsh/hgsh.c			contrib/hgsh/hgsh.c
	mercurial/cext/base85.c			mercurial/cext/base85.c
	mercurial/cext/bdiff.c			mercurial/cext/bdiff.c
	mercurial/cext/charencode.c			mercurial/cext/charencode.c
	mercurial/cext/charencode.h			mercurial/cext/charencode.h
	mercurial/cext/diffhelpers.c			mercurial/cext/diffhelpers.c
	mercurial/cext/dirs.c			mercurial/cext/dirs.c
	mercurial/cext/manifest.c			mercurial/cext/manifest.c

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	5239		Feb 6 2018, 5:24 AM	★	★
Diff 2	5295	rHG9724f54923ec2cc5df4494d64c1833a33e5b458f	Feb 6 2018, 5:24 AM	★	★

This is an archive of the discontinued Mercurial Phabricator instance.

chg: enable clang-format on all .c and .h filesClosedPublic

Details

Diff Detail

Event Timeline

Revision ContentsChangeset List

Diff 5295

contrib/chg/chg.c

contrib/chg/hgclient.h

contrib/chg/hgclient.c

contrib/chg/procutil.c

contrib/chg/util.h

contrib/chg/util.c

contrib/clang-format-blacklist

chg: enable clang-format on all .c and .h files
ClosedPublic

Revision Contents
Changeset List