Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/cvs/server.c	Lines:	0	353	0.0 %
Date:	2017-11-07	Branches:	0	162	0.0 %


/*	$OpenBSD: server.c,v 1.105 2017/08/28 19:33:20 otto Exp $	*/
/*
 * Copyright (c) 2006 Joris Vink <joris@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/stat.h>

#include <errno.h>
#include <fcntl.h>
#include <libgen.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "cvs.h"
#include "remote.h"

struct cvs_resp cvs_responses[] = {
	/* this is what our server uses, the client should support it */
	{ "Valid-requests",	1,	cvs_client_validreq, RESP_NEEDED },
	{ "ok",			0,	cvs_client_ok, RESP_NEEDED},
	{ "error",		0,	cvs_client_error, RESP_NEEDED },
	{ "E",			0,	cvs_client_e, RESP_NEEDED },
	{ "M",			0,	cvs_client_m, RESP_NEEDED },
	{ "Checked-in",		0,	cvs_client_checkedin, RESP_NEEDED },
	{ "Updated",		0,	cvs_client_updated, RESP_NEEDED },
	{ "Merged",		0,	cvs_client_merged, RESP_NEEDED },
	{ "Removed",		0,	cvs_client_removed, RESP_NEEDED },
	{ "Remove-entry",	0,	cvs_client_remove_entry, 0 },
	{ "Set-static-directory",	0,
	    cvs_client_set_static_directory, 0 },
	{ "Clear-static-directory",	0,
	    cvs_client_clear_static_directory, 0 },
	{ "Set-sticky",		0,	cvs_client_set_sticky, 0 },
	{ "Clear-sticky",	0,	cvs_client_clear_sticky, 0 },

	/* unsupported responses until told otherwise */
	{ "New-entry",			0,	NULL, 0 },
	{ "Created",			0,	NULL, 0 },
	{ "Update-existing",		0,	NULL, 0 },
	{ "Rcs-diff",			0,	NULL, 0 },
	{ "Patched",			0,	NULL, 0 },
	{ "Mode",			0,	NULL, 0 },
	{ "Mod-time",			0,	NULL, 0 },
	{ "Checksum",			0,	NULL, 0 },
	{ "Copy-file",			0,	NULL, 0 },
	{ "Template",			0,	NULL, 0 },
	{ "Set-checkin-prog",		0,	NULL, 0 },
	{ "Set-update-prog",		0,	NULL, 0 },
	{ "Notified",			0,	NULL, 0 },
	{ "Module-expansion",		0,	NULL, 0 },
	{ "Wrapper-rcsOption",		0,	NULL, 0 },
	{ "Mbinary",			0,	NULL, 0 },
	{ "F",				0,	NULL, 0 },
	{ "MT",				0,	NULL, 0 },
	{ "",				-1,	NULL, 0 }
};

int	cvs_server(int, char **);
char	*cvs_server_path = NULL;

static char *server_currentdir = NULL;
static char **server_argv;
static int server_argc = 1;

extern int disable_fast_checkout;

struct cvs_cmd cvs_cmd_server = {
	CVS_OP_SERVER, CVS_USE_WDIR, "server", { "", "" },
	"server mode",
	NULL,
	NULL,
	NULL,
	cvs_server
};


int
cvs_server(int argc, char **argv)
{
	char *cmd, *data;
	struct cvs_req *req;

	if (argc > 1)
		fatal("server does not take any extra arguments");

	/* Be on server-side very verbose per default. */
	verbosity = 2;

	setvbuf(stdin, NULL, _IOLBF, 0);
	setvbuf(stdout, NULL, _IOLBF, 0);

	cvs_server_active = 1;

	server_argv = xcalloc(server_argc + 1, sizeof(*server_argv));
	server_argv[0] = xstrdup("server");

	(void)xasprintf(&cvs_server_path, "%s/cvs-serv%d", cvs_tmpdir,
	    getpid());

	if (mkdir(cvs_server_path, 0700) == -1)
		fatal("failed to create temporary server directory: %s, %s",
		    cvs_server_path, strerror(errno));

	if (chdir(cvs_server_path) == -1)
		fatal("failed to change directory to '%s'", cvs_server_path);

	for (;;) {
		cmd = cvs_remote_input();

		if ((data = strchr(cmd, ' ')) != NULL)
			(*data++) = '\0';

		req = cvs_remote_get_request_info(cmd);
		if (req == NULL)
			fatal("request '%s' is not supported by our server",
			    cmd);

		if (req->hdlr == NULL)
			fatal("opencvs server does not support '%s'", cmd);

		if ((req->flags & REQ_NEEDDIR) && (server_currentdir == NULL))
			fatal("`%s' needs a directory to be sent with "
			    "the `Directory` request first", cmd);

		(*req->hdlr)(data);
		free(cmd);
	}

	return (0);
}

void
cvs_server_send_response(char *fmt, ...)
{
	int i;
	va_list ap;
	char *data;

	va_start(ap, fmt);
	i = vasprintf(&data, fmt, ap);
	va_end(ap);
	if (i == -1)
		fatal("cvs_server_send_response: could not allocate memory");

	cvs_log(LP_TRACE, "%s", data);
	cvs_remote_output(data);
	free(data);
}

void
cvs_server_root(char *data)
{
	if (data == NULL)
		fatal("Missing argument for Root");

	if (current_cvsroot != NULL)
		return;

	if (data[0] != '/' || (current_cvsroot = cvsroot_get(data)) == NULL)
		fatal("Invalid Root specified!");

	cvs_parse_configfile();
	cvs_parse_modules();
	umask(cvs_umask);
}

void
cvs_server_validresp(char *data)
{
	int i;
	char *sp, *ep;
	struct cvs_resp *resp;

	if ((sp = data) == NULL)
		fatal("Missing argument for Valid-responses");

	do {
		if ((ep = strchr(sp, ' ')) != NULL)
			*ep = '\0';

		resp = cvs_remote_get_response_info(sp);
		if (resp != NULL)
			resp->supported = 1;

		if (ep != NULL)
			sp = ep + 1;
	} while (ep != NULL);

	for (i = 0; cvs_responses[i].supported != -1; i++) {
		resp = &cvs_responses[i];
		if ((resp->flags & RESP_NEEDED) &&
		    resp->supported != 1) {
			fatal("client does not support required '%s'",
			    resp->name);
		}
	}
}

void
cvs_server_validreq(char *data)
{
	BUF *bp;
	char *d;
	int i, first;

	first = 0;
	bp = buf_alloc(512);
	for (i = 0; cvs_requests[i].supported != -1; i++) {
		if (cvs_requests[i].hdlr == NULL)
			continue;

		if (first != 0)
			buf_putc(bp, ' ');
		else
			first++;

		buf_puts(bp, cvs_requests[i].name);
	}

	buf_putc(bp, '\0');
	d = buf_release(bp);

	cvs_server_send_response("Valid-requests %s", d);
	cvs_server_send_response("ok");
	free(d);
}

void
cvs_server_static_directory(char *data)
{
	FILE *fp;
	char fpath[PATH_MAX];

	(void)xsnprintf(fpath, PATH_MAX, "%s/%s",
	    server_currentdir, CVS_PATH_STATICENTRIES);

	if ((fp = fopen(fpath, "w+")) == NULL) {
		cvs_log(LP_ERRNO, "%s", fpath);
		return;
	}
	(void)fclose(fp);
}

void
cvs_server_sticky(char *data)
{
	FILE *fp;
	char tagpath[PATH_MAX];

	if (data == NULL)
		fatal("Missing argument for Sticky");

	(void)xsnprintf(tagpath, PATH_MAX, "%s/%s",
	    server_currentdir, CVS_PATH_TAG);

	if ((fp = fopen(tagpath, "w+")) == NULL) {
		cvs_log(LP_ERRNO, "%s", tagpath);
		return;
	}

	(void)fprintf(fp, "%s\n", data);
	(void)fclose(fp);
}

void
cvs_server_globalopt(char *data)
{
	if (data == NULL)
		fatal("Missing argument for Global_option");

	if (!strcmp(data, "-l"))
		cvs_nolog = 1;

	if (!strcmp(data, "-n"))
		cvs_noexec = 1;

	if (!strcmp(data, "-Q"))
		verbosity = 0;

	if (!strcmp(data, "-q"))
		verbosity = 1;

	if (!strcmp(data, "-r"))
		cvs_readonly = 1;

	if (!strcmp(data, "-t"))
		cvs_trace = 1;
}

void
cvs_server_set(char *data)
{
	char *ep;

	if (data == NULL)
		fatal("Missing argument for Set");

	ep = strchr(data, '=');
	if (ep == NULL)
		fatal("no = in variable assignment");

	*(ep++) = '\0';
	if (cvs_var_set(data, ep) < 0)
		fatal("cvs_server_set: cvs_var_set failed");
}

void
cvs_server_directory(char *data)
{
	CVSENTRIES *entlist;
	char *dir, *repo, *parent, *entry, *dirn, *p;

	if (current_cvsroot == NULL)
		fatal("No Root specified for Directory");

	dir = cvs_remote_input();
	STRIP_SLASH(dir);

	if (strlen(dir) < strlen(current_cvsroot->cr_dir))
		fatal("cvs_server_directory: bad Directory request");

	repo = dir + strlen(current_cvsroot->cr_dir);

	/*
	 * This is somewhat required for checkout, as the
	 * directory request will be:
	 *
	 * Directory .
	 * /path/to/cvs/root
	 */
	if (repo[0] == '\0')
		p = xstrdup(".");
	else
		p = xstrdup(repo + 1);

	cvs_mkpath(p, NULL);

	if ((dirn = basename(p)) == NULL)
		fatal("cvs_server_directory: %s", strerror(errno));

	if ((parent = dirname(p)) == NULL)
		fatal("cvs_server_directory: %s", strerror(errno));

	if (strcmp(parent, ".")) {
		entry = xmalloc(CVS_ENT_MAXLINELEN);
		cvs_ent_line_str(dirn, NULL, NULL, NULL, NULL, 1, 0,
		    entry, CVS_ENT_MAXLINELEN);

		entlist = cvs_ent_open(parent);
		cvs_ent_add(entlist, entry);
		free(entry);
	}

	free(server_currentdir);
	server_currentdir = p;

	free(dir);
}

void
cvs_server_entry(char *data)
{
	CVSENTRIES *entlist;

	if (data == NULL)
		fatal("Missing argument for Entry");

	entlist = cvs_ent_open(server_currentdir);
	cvs_ent_add(entlist, data);
}

void
cvs_server_modified(char *data)
{
	int fd;
	size_t flen;
	mode_t fmode;
	const char *errstr;
	char *mode, *len, fpath[PATH_MAX];

	if (data == NULL)
		fatal("Missing argument for Modified");

	/* sorry, we have to use TMP_DIR */
	disable_fast_checkout = 1;

	mode = cvs_remote_input();
	len = cvs_remote_input();

	cvs_strtomode(mode, &fmode);
	free(mode);

	flen = strtonum(len, 0, INT_MAX, &errstr);
	if (errstr != NULL)
		fatal("cvs_server_modified: %s", errstr);
	free(len);

	(void)xsnprintf(fpath, PATH_MAX, "%s/%s", server_currentdir, data);

	if ((fd = open(fpath, O_WRONLY | O_CREAT | O_TRUNC)) == -1)
		fatal("cvs_server_modified: %s: %s", fpath, strerror(errno));

	cvs_remote_receive_file(fd, flen);

	if (fchmod(fd, 0600) == -1)
		fatal("cvs_server_modified: failed to set file mode");

	(void)close(fd);
}

void
cvs_server_useunchanged(char *data)
{
}

void
cvs_server_unchanged(char *data)
{
	char fpath[PATH_MAX];
	CVSENTRIES *entlist;
	struct cvs_ent *ent;
	char sticky[CVS_ENT_MAXLINELEN];
	char rev[CVS_REV_BUFSZ], entry[CVS_ENT_MAXLINELEN];

	if (data == NULL)
		fatal("Missing argument for Unchanged");

	/* sorry, we have to use TMP_DIR */
	disable_fast_checkout = 1;

	(void)xsnprintf(fpath, PATH_MAX, "%s/%s", server_currentdir, data);

	entlist = cvs_ent_open(server_currentdir);
	ent = cvs_ent_get(entlist, data);
	if (ent == NULL)
		fatal("received Unchanged request for non-existing file");

	sticky[0] = '\0';
	if (ent->ce_tag != NULL)
		(void)xsnprintf(sticky, sizeof(sticky), "T%s", ent->ce_tag);

	rcsnum_tostr(ent->ce_rev, rev, sizeof(rev));
	(void)xsnprintf(entry, sizeof(entry), "/%s/%s/%s/%s/%s",
	    ent->ce_name, rev, CVS_SERVER_UNCHANGED, ent->ce_opts ?
	    ent->ce_opts : "", sticky);

	cvs_ent_free(ent);
	cvs_ent_add(entlist, entry);
}

void
cvs_server_questionable(char *data)
{
	CVSENTRIES *entlist;
	char entry[CVS_ENT_MAXLINELEN];

	if (data == NULL)
		fatal("Questionable request with no data attached");

	(void)xsnprintf(entry, sizeof(entry), "/%s/%c///", data,
	    CVS_SERVER_QUESTIONABLE);

	entlist = cvs_ent_open(server_currentdir);
	cvs_ent_add(entlist, entry);

	/* sorry, we have to use TMP_DIR */
	disable_fast_checkout = 1;
}

void
cvs_server_argument(char *data)
{
	if (data == NULL)
		fatal("Missing argument for Argument");

	server_argv = xreallocarray(server_argv, server_argc + 2,
	    sizeof(*server_argv));
	server_argv[server_argc] = xstrdup(data);
	server_argv[++server_argc] = NULL;
}

void
cvs_server_argumentx(char *data)
{
	int idx;
	size_t len;

	if (server_argc == 1)
		fatal("Protocol Error: ArgumentX without previous argument");

	idx = server_argc - 1;

	len = strlen(server_argv[idx]) + strlen(data) + 2;
	server_argv[idx] = xreallocarray(server_argv[idx], len, sizeof(char));
	strlcat(server_argv[idx], "\n", len);
	strlcat(server_argv[idx], data, len);
}

void
cvs_server_update_patches(char *data)
{
	/*
	 * This does not actually do anything.
	 * It is used to tell that the server is able to
	 * generate patches when given an `update' request.
	 * The client must issue the -u argument to `update'
	 * to receive patches.
	 */
}

void
cvs_server_add(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_add: %s", strerror(errno));

	cvs_cmdop = CVS_OP_ADD;
	cmdp->cmd_flags = cvs_cmd_add.cmd_flags;
	cvs_add(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_import(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_import: %s", strerror(errno));

	cvs_cmdop = CVS_OP_IMPORT;
	cmdp->cmd_flags = cvs_cmd_import.cmd_flags;
	cvs_import(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_admin(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_admin: %s", strerror(errno));

	cvs_cmdop = CVS_OP_ADMIN;
	cmdp->cmd_flags = cvs_cmd_admin.cmd_flags;
	cvs_admin(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_annotate(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_annotate: %s", strerror(errno));

	cvs_cmdop = CVS_OP_ANNOTATE;
	cmdp->cmd_flags = cvs_cmd_annotate.cmd_flags;
	cvs_annotate(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_rannotate(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_rannotate: %s", strerror(errno));

	cvs_cmdop = CVS_OP_RANNOTATE;
	cmdp->cmd_flags = cvs_cmd_rannotate.cmd_flags;
	cvs_annotate(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_commit(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_commit: %s", strerror(errno));

	cvs_cmdop = CVS_OP_COMMIT;
	cmdp->cmd_flags = cvs_cmd_commit.cmd_flags;
	cvs_commit(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_checkout(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_checkout: %s", strerror(errno));

	cvs_cmdop = CVS_OP_CHECKOUT;
	cmdp->cmd_flags = cvs_cmd_checkout.cmd_flags;
	cvs_checkout(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_diff(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_diff: %s", strerror(errno));

	cvs_cmdop = CVS_OP_DIFF;
	cmdp->cmd_flags = cvs_cmd_diff.cmd_flags;
	cvs_diff(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_rdiff(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_rdiff: %s", strerror(errno));

	cvs_cmdop = CVS_OP_RDIFF;
	cmdp->cmd_flags = cvs_cmd_rdiff.cmd_flags;
	cvs_diff(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_export(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_export: %s", strerror(errno));

	cvs_cmdop = CVS_OP_EXPORT;
	cmdp->cmd_flags = cvs_cmd_export.cmd_flags;
	cvs_export(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_init(char *data)
{
	if (data == NULL)
		fatal("Missing argument for init");

	if (current_cvsroot != NULL)
		fatal("Root in combination with init is not supported");

	if ((current_cvsroot = cvsroot_get(data)) == NULL)
		fatal("Invalid argument for init");

	cvs_cmdop = CVS_OP_INIT;
	cmdp->cmd_flags = cvs_cmd_init.cmd_flags;
	cvs_init(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_release(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_release: %s", strerror(errno));

	cvs_cmdop = CVS_OP_RELEASE;
	cmdp->cmd_flags = cvs_cmd_release.cmd_flags;
	cvs_release(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_remove(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_remove: %s", strerror(errno));

	cvs_cmdop = CVS_OP_REMOVE;
	cmdp->cmd_flags = cvs_cmd_remove.cmd_flags;
	cvs_remove(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_status(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_status: %s", strerror(errno));

	cvs_cmdop = CVS_OP_STATUS;
	cmdp->cmd_flags = cvs_cmd_status.cmd_flags;
	cvs_status(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_log(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_log: %s", strerror(errno));

	cvs_cmdop = CVS_OP_LOG;
	cmdp->cmd_flags = cvs_cmd_log.cmd_flags;
	cvs_getlog(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_rlog(char *data)
{
	if (chdir(current_cvsroot->cr_dir) == -1)
		fatal("cvs_server_rlog: %s", strerror(errno));

	cvs_cmdop = CVS_OP_RLOG;
	cmdp->cmd_flags = cvs_cmd_rlog.cmd_flags;
	cvs_getlog(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_tag(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_tag: %s", strerror(errno));

	cvs_cmdop = CVS_OP_TAG;
	cmdp->cmd_flags = cvs_cmd_tag.cmd_flags;
	cvs_tag(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_rtag(char *data)
{
	if (chdir(current_cvsroot->cr_dir) == -1)
		fatal("cvs_server_rtag: %s", strerror(errno));

	cvs_cmdop = CVS_OP_RTAG;
	cmdp->cmd_flags = cvs_cmd_rtag.cmd_flags;
	cvs_tag(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_update(char *data)
{
	if (chdir(server_currentdir) == -1)
		fatal("cvs_server_update: %s", strerror(errno));

	cvs_cmdop = CVS_OP_UPDATE;
	cmdp->cmd_flags = cvs_cmd_update.cmd_flags;
	cvs_update(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_version(char *data)
{
	cvs_cmdop = CVS_OP_VERSION;
	cmdp->cmd_flags = cvs_cmd_version.cmd_flags;
	cvs_version(server_argc, server_argv);
	cvs_server_send_response("ok");
}

void
cvs_server_update_entry(const char *resp, struct cvs_file *cf)
{
	char *p;
	char repo[PATH_MAX], fpath[PATH_MAX];

	if ((p = strrchr(cf->file_rpath, ',')) != NULL)
		*p = '\0';

	cvs_get_repository_path(cf->file_wd, repo, PATH_MAX);
	(void)xsnprintf(fpath, PATH_MAX, "%s/%s", repo, cf->file_name);

	cvs_server_send_response("%s %s/", resp, cf->file_wd);
	cvs_remote_output(fpath);

	if (p != NULL)
		*p = ',';
}

void
cvs_server_set_sticky(const char *dir, char *tag)
{
	char fpath[PATH_MAX];
	char repo[PATH_MAX];

	cvs_get_repository_path(dir, repo, PATH_MAX);
	(void)xsnprintf(fpath, PATH_MAX, "%s/", repo);

	cvs_server_send_response("Set-sticky %s/", dir);
	cvs_remote_output(fpath);
	cvs_remote_output(tag);
}

void
cvs_server_clear_sticky(char *dir)
{
	char fpath[PATH_MAX];
	char repo[PATH_MAX];

	cvs_get_repository_path(dir, repo, PATH_MAX);
	(void)xsnprintf(fpath, PATH_MAX, "%s/", repo);

	cvs_server_send_response("Clear-sticky %s//", dir);
	cvs_remote_output(fpath);
}

void
cvs_server_exp_modules(char *module)
{
	struct module_checkout *mo;
	struct cvs_filelist *fl;

	if (server_argc != 2)
		fatal("expand-modules with no arguments");

	mo = cvs_module_lookup(server_argv[1]);

	RB_FOREACH(fl, cvs_flisthead, &(mo->mc_modules))
		cvs_server_send_response("Module-expansion %s", fl->file_path);
	cvs_server_send_response("ok");

	server_argc--;
	free(server_argv[1]);
	server_argv[1] = NULL;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: server.c,v 1.105 2017/08/28 19:33:20 otto Exp $ */
2			/*
3			* Copyright (c) 2006 Joris Vink <joris@openbsd.org>
4			*
5			* Permission to use, copy, modify, and distribute this software for any
6			* purpose with or without fee is hereby granted, provided that the above
7			* copyright notice and this permission notice appear in all copies.
8			*
9			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16			*/
17
18			#include <sys/types.h>
19			#include <sys/stat.h>
20
21			#include <errno.h>
22			#include <fcntl.h>
23			#include <libgen.h>
24			#include <stdio.h>
25			#include <stdlib.h>
26			#include <string.h>
27			#include <unistd.h>
28
29			#include "cvs.h"
30			#include "remote.h"
31
32			struct cvs_resp cvs_responses[] = {
33			/* this is what our server uses, the client should support it */
34			{ "Valid-requests", 1, cvs_client_validreq, RESP_NEEDED },
35			{ "ok", 0, cvs_client_ok, RESP_NEEDED},
36			{ "error", 0, cvs_client_error, RESP_NEEDED },
37			{ "E", 0, cvs_client_e, RESP_NEEDED },
38			{ "M", 0, cvs_client_m, RESP_NEEDED },
39			{ "Checked-in", 0, cvs_client_checkedin, RESP_NEEDED },
40			{ "Updated", 0, cvs_client_updated, RESP_NEEDED },
41			{ "Merged", 0, cvs_client_merged, RESP_NEEDED },
42			{ "Removed", 0, cvs_client_removed, RESP_NEEDED },
43			{ "Remove-entry", 0, cvs_client_remove_entry, 0 },
44			{ "Set-static-directory", 0,
45			cvs_client_set_static_directory, 0 },
46			{ "Clear-static-directory", 0,
47			cvs_client_clear_static_directory, 0 },
48			{ "Set-sticky", 0, cvs_client_set_sticky, 0 },
49			{ "Clear-sticky", 0, cvs_client_clear_sticky, 0 },
50
51			/* unsupported responses until told otherwise */
52			{ "New-entry", 0, NULL, 0 },
53			{ "Created", 0, NULL, 0 },
54			{ "Update-existing", 0, NULL, 0 },
55			{ "Rcs-diff", 0, NULL, 0 },
56			{ "Patched", 0, NULL, 0 },
57			{ "Mode", 0, NULL, 0 },
58			{ "Mod-time", 0, NULL, 0 },
59			{ "Checksum", 0, NULL, 0 },
60			{ "Copy-file", 0, NULL, 0 },
61			{ "Template", 0, NULL, 0 },
62			{ "Set-checkin-prog", 0, NULL, 0 },
63			{ "Set-update-prog", 0, NULL, 0 },
64			{ "Notified", 0, NULL, 0 },
65			{ "Module-expansion", 0, NULL, 0 },
66			{ "Wrapper-rcsOption", 0, NULL, 0 },
67			{ "Mbinary", 0, NULL, 0 },
68			{ "F", 0, NULL, 0 },
69			{ "MT", 0, NULL, 0 },
70			{ "", -1, NULL, 0 }
71			};
72
73			int cvs_server(int, char **);
74			char *cvs_server_path = NULL;
75
76			static char *server_currentdir = NULL;
77			static char **server_argv;
78			static int server_argc = 1;
79
80			extern int disable_fast_checkout;
81
82			struct cvs_cmd cvs_cmd_server = {
83			CVS_OP_SERVER, CVS_USE_WDIR, "server", { "", "" },
84			"server mode",
85			NULL,
86			NULL,
87			NULL,
88			cvs_server
89			};
90
91
92			int
93			cvs_server(int argc, char **argv)
94			{
95			char cmd, data;
96			struct cvs_req *req;
97
98			if (argc > 1)
99			fatal("server does not take any extra arguments");
100
101			/* Be on server-side very verbose per default. */
102			verbosity = 2;
103
104			setvbuf(stdin, NULL, _IOLBF, 0);
105			setvbuf(stdout, NULL, _IOLBF, 0);
106
107			cvs_server_active = 1;
108
109			server_argv = xcalloc(server_argc + 1, sizeof(*server_argv));
110			server_argv[0] = xstrdup("server");
111
112			(void)xasprintf(&cvs_server_path, "%s/cvs-serv%d", cvs_tmpdir,
113			getpid());
114
115			if (mkdir(cvs_server_path, 0700) == -1)
116			fatal("failed to create temporary server directory: %s, %s",
117			cvs_server_path, strerror(errno));
118
119			if (chdir(cvs_server_path) == -1)
120			fatal("failed to change directory to '%s'", cvs_server_path);
121
122			for (;;) {
123			cmd = cvs_remote_input();
124
125			if ((data = strchr(cmd, ' ')) != NULL)
126			(*data++) = '\0';
127
128			req = cvs_remote_get_request_info(cmd);
129			if (req == NULL)
130			fatal("request '%s' is not supported by our server",
131			cmd);
132
133			if (req->hdlr == NULL)
134			fatal("opencvs server does not support '%s'", cmd);
135
136			if ((req->flags & REQ_NEEDDIR) && (server_currentdir == NULL))
137			fatal("`%s' needs a directory to be sent with "
138			"the `Directory` request first", cmd);
139
140			(*req->hdlr)(data);
141			free(cmd);
142			}
143
144			return (0);
145			}
146
147			void
148			cvs_server_send_response(char *fmt, ...)
149			{
150			int i;
151			va_list ap;
152			char *data;
153
154			va_start(ap, fmt);
155			i = vasprintf(&data, fmt, ap);
156			va_end(ap);
157			if (i == -1)
158			fatal("cvs_server_send_response: could not allocate memory");
159
160			cvs_log(LP_TRACE, "%s", data);
161			cvs_remote_output(data);
162			free(data);
163			}
164
165			void
166			cvs_server_root(char *data)
167			{
168			if (data == NULL)
169			fatal("Missing argument for Root");
170
171			if (current_cvsroot != NULL)
172			return;
173
174			if (data[0] != '/' \|\| (current_cvsroot = cvsroot_get(data)) == NULL)
175			fatal("Invalid Root specified!");
176
177			cvs_parse_configfile();
178			cvs_parse_modules();
179			umask(cvs_umask);
180			}
181
182			void
183			cvs_server_validresp(char *data)
184			{
185			int i;
186			char sp, ep;
187			struct cvs_resp *resp;
188
189			if ((sp = data) == NULL)
190			fatal("Missing argument for Valid-responses");
191
192			do {
193			if ((ep = strchr(sp, ' ')) != NULL)
194			*ep = '\0';
195
196			resp = cvs_remote_get_response_info(sp);
197			if (resp != NULL)
198			resp->supported = 1;
199
200			if (ep != NULL)
201			sp = ep + 1;
202			} while (ep != NULL);
203
204			for (i = 0; cvs_responses[i].supported != -1; i++) {
205			resp = &cvs_responses[i];
206			if ((resp->flags & RESP_NEEDED) &&
207			resp->supported != 1) {
208			fatal("client does not support required '%s'",
209			resp->name);
210			}
211			}
212			}
213
214			void
215			cvs_server_validreq(char *data)
216			{
217			BUF *bp;
218			char *d;
219			int i, first;
220
221			first = 0;
222			bp = buf_alloc(512);
223			for (i = 0; cvs_requests[i].supported != -1; i++) {
224			if (cvs_requests[i].hdlr == NULL)
225			continue;
226
227			if (first != 0)
228			buf_putc(bp, ' ');
229			else
230			first++;
231
232			buf_puts(bp, cvs_requests[i].name);
233			}
234
235			buf_putc(bp, '\0');
236			d = buf_release(bp);
237
238			cvs_server_send_response("Valid-requests %s", d);
239			cvs_server_send_response("ok");
240			free(d);
241			}
242
243			void
244			cvs_server_static_directory(char *data)
245			{
246			FILE *fp;
247			char fpath[PATH_MAX];
248
249			(void)xsnprintf(fpath, PATH_MAX, "%s/%s",
250			server_currentdir, CVS_PATH_STATICENTRIES);
251
252			if ((fp = fopen(fpath, "w+")) == NULL) {
253			cvs_log(LP_ERRNO, "%s", fpath);
254			return;
255			}
256			(void)fclose(fp);
257			}
258
259			void
260			cvs_server_sticky(char *data)
261			{
262			FILE *fp;
263			char tagpath[PATH_MAX];
264
265			if (data == NULL)
266			fatal("Missing argument for Sticky");
267
268			(void)xsnprintf(tagpath, PATH_MAX, "%s/%s",
269			server_currentdir, CVS_PATH_TAG);
270
271			if ((fp = fopen(tagpath, "w+")) == NULL) {
272			cvs_log(LP_ERRNO, "%s", tagpath);
273			return;
274			}
275
276			(void)fprintf(fp, "%s\n", data);
277			(void)fclose(fp);
278			}
279
280			void
281			cvs_server_globalopt(char *data)
282			{
283			if (data == NULL)
284			fatal("Missing argument for Global_option");
285
286			if (!strcmp(data, "-l"))
287			cvs_nolog = 1;
288
289			if (!strcmp(data, "-n"))
290			cvs_noexec = 1;
291
292			if (!strcmp(data, "-Q"))
293			verbosity = 0;
294
295			if (!strcmp(data, "-q"))
296			verbosity = 1;
297
298			if (!strcmp(data, "-r"))
299			cvs_readonly = 1;
300
301			if (!strcmp(data, "-t"))
302			cvs_trace = 1;
303			}
304
305			void
306			cvs_server_set(char *data)
307			{
308			char *ep;
309
310			if (data == NULL)
311			fatal("Missing argument for Set");
312
313			ep = strchr(data, '=');
314			if (ep == NULL)
315			fatal("no = in variable assignment");
316
317			*(ep++) = '\0';
318			if (cvs_var_set(data, ep) < 0)
319			fatal("cvs_server_set: cvs_var_set failed");
320			}
321
322			void
323			cvs_server_directory(char *data)
324			{
325			CVSENTRIES *entlist;
326			char dir, repo, parent, entry, dirn, p;
327
328			if (current_cvsroot == NULL)
329			fatal("No Root specified for Directory");
330
331			dir = cvs_remote_input();
332			STRIP_SLASH(dir);
333
334			if (strlen(dir) < strlen(current_cvsroot->cr_dir))
335			fatal("cvs_server_directory: bad Directory request");
336
337			repo = dir + strlen(current_cvsroot->cr_dir);
338
339			/*
340			* This is somewhat required for checkout, as the
341			* directory request will be:
342			*
343			* Directory .
344			* /path/to/cvs/root
345			*/
346			if (repo[0] == '\0')
347			p = xstrdup(".");
348			else
349			p = xstrdup(repo + 1);
350
351			cvs_mkpath(p, NULL);
352
353			if ((dirn = basename(p)) == NULL)
354			fatal("cvs_server_directory: %s", strerror(errno));
355
356			if ((parent = dirname(p)) == NULL)
357			fatal("cvs_server_directory: %s", strerror(errno));
358
359			if (strcmp(parent, ".")) {
360			entry = xmalloc(CVS_ENT_MAXLINELEN);
361			cvs_ent_line_str(dirn, NULL, NULL, NULL, NULL, 1, 0,
362			entry, CVS_ENT_MAXLINELEN);
363
364			entlist = cvs_ent_open(parent);
365			cvs_ent_add(entlist, entry);
366			free(entry);
367			}
368
369			free(server_currentdir);
370			server_currentdir = p;
371
372			free(dir);
373			}
374
375			void
376			cvs_server_entry(char *data)
377			{
378			CVSENTRIES *entlist;
379
380			if (data == NULL)
381			fatal("Missing argument for Entry");
382
383			entlist = cvs_ent_open(server_currentdir);
384			cvs_ent_add(entlist, data);
385			}
386
387			void
388			cvs_server_modified(char *data)
389			{
390			int fd;
391			size_t flen;
392			mode_t fmode;
393			const char *errstr;
394			char mode, len, fpath[PATH_MAX];
395
396			if (data == NULL)
397			fatal("Missing argument for Modified");
398
399			/* sorry, we have to use TMP_DIR */
400			disable_fast_checkout = 1;
401
402			mode = cvs_remote_input();
403			len = cvs_remote_input();
404
405			cvs_strtomode(mode, &fmode);
406			free(mode);
407
408			flen = strtonum(len, 0, INT_MAX, &errstr);
409			if (errstr != NULL)
410			fatal("cvs_server_modified: %s", errstr);
411			free(len);
412
413			(void)xsnprintf(fpath, PATH_MAX, "%s/%s", server_currentdir, data);
414
415			if ((fd = open(fpath, O_WRONLY \| O_CREAT \| O_TRUNC)) == -1)
416			fatal("cvs_server_modified: %s: %s", fpath, strerror(errno));
417
418			cvs_remote_receive_file(fd, flen);
419
420			if (fchmod(fd, 0600) == -1)
421			fatal("cvs_server_modified: failed to set file mode");
422
423			(void)close(fd);
424			}
425
426			void
427			cvs_server_useunchanged(char *data)
428			{
429			}
430
431			void
432			cvs_server_unchanged(char *data)
433			{
434			char fpath[PATH_MAX];
435			CVSENTRIES *entlist;
436			struct cvs_ent *ent;
437			char sticky[CVS_ENT_MAXLINELEN];
438			char rev[CVS_REV_BUFSZ], entry[CVS_ENT_MAXLINELEN];
439
440			if (data == NULL)
441			fatal("Missing argument for Unchanged");
442
443			/* sorry, we have to use TMP_DIR */
444			disable_fast_checkout = 1;
445
446			(void)xsnprintf(fpath, PATH_MAX, "%s/%s", server_currentdir, data);
447
448			entlist = cvs_ent_open(server_currentdir);
449			ent = cvs_ent_get(entlist, data);
450			if (ent == NULL)
451			fatal("received Unchanged request for non-existing file");
452
453			sticky[0] = '\0';
454			if (ent->ce_tag != NULL)
455			(void)xsnprintf(sticky, sizeof(sticky), "T%s", ent->ce_tag);
456
457			rcsnum_tostr(ent->ce_rev, rev, sizeof(rev));
458			(void)xsnprintf(entry, sizeof(entry), "/%s/%s/%s/%s/%s",
459			ent->ce_name, rev, CVS_SERVER_UNCHANGED, ent->ce_opts ?
460			ent->ce_opts : "", sticky);
461
462			cvs_ent_free(ent);
463			cvs_ent_add(entlist, entry);
464			}
465
466			void
467			cvs_server_questionable(char *data)
468			{
469			CVSENTRIES *entlist;
470			char entry[CVS_ENT_MAXLINELEN];
471
472			if (data == NULL)
473			fatal("Questionable request with no data attached");
474
475			(void)xsnprintf(entry, sizeof(entry), "/%s/%c///", data,
476			CVS_SERVER_QUESTIONABLE);
477
478			entlist = cvs_ent_open(server_currentdir);
479			cvs_ent_add(entlist, entry);
480
481			/* sorry, we have to use TMP_DIR */
482			disable_fast_checkout = 1;
483			}
484
485			void
486			cvs_server_argument(char *data)
487			{
488			if (data == NULL)
489			fatal("Missing argument for Argument");
490
491			server_argv = xreallocarray(server_argv, server_argc + 2,
492			sizeof(*server_argv));
493			server_argv[server_argc] = xstrdup(data);
494			server_argv[++server_argc] = NULL;
495			}
496
497			void
498			cvs_server_argumentx(char *data)
499			{
500			int idx;
501			size_t len;
502
503			if (server_argc == 1)
504			fatal("Protocol Error: ArgumentX without previous argument");
505
506			idx = server_argc - 1;
507
508			len = strlen(server_argv[idx]) + strlen(data) + 2;
509			server_argv[idx] = xreallocarray(server_argv[idx], len, sizeof(char));
510			strlcat(server_argv[idx], "\n", len);
511			strlcat(server_argv[idx], data, len);
512			}
513
514			void
515			cvs_server_update_patches(char *data)
516			{
517			/*
518			* This does not actually do anything.
519			* It is used to tell that the server is able to
520			* generate patches when given an `update' request.
521			* The client must issue the -u argument to `update'
522			* to receive patches.
523			*/
524			}
525
526			void
527			cvs_server_add(char *data)
528			{
529			if (chdir(server_currentdir) == -1)
530			fatal("cvs_server_add: %s", strerror(errno));
531
532			cvs_cmdop = CVS_OP_ADD;
533			cmdp->cmd_flags = cvs_cmd_add.cmd_flags;
534			cvs_add(server_argc, server_argv);
535			cvs_server_send_response("ok");
536			}
537
538			void
539			cvs_server_import(char *data)
540			{
541			if (chdir(server_currentdir) == -1)
542			fatal("cvs_server_import: %s", strerror(errno));
543
544			cvs_cmdop = CVS_OP_IMPORT;
545			cmdp->cmd_flags = cvs_cmd_import.cmd_flags;
546			cvs_import(server_argc, server_argv);
547			cvs_server_send_response("ok");
548			}
549
550			void
551			cvs_server_admin(char *data)
552			{
553			if (chdir(server_currentdir) == -1)
554			fatal("cvs_server_admin: %s", strerror(errno));
555
556			cvs_cmdop = CVS_OP_ADMIN;
557			cmdp->cmd_flags = cvs_cmd_admin.cmd_flags;
558			cvs_admin(server_argc, server_argv);
559			cvs_server_send_response("ok");
560			}
561
562			void
563			cvs_server_annotate(char *data)
564			{
565			if (chdir(server_currentdir) == -1)
566			fatal("cvs_server_annotate: %s", strerror(errno));
567
568			cvs_cmdop = CVS_OP_ANNOTATE;
569			cmdp->cmd_flags = cvs_cmd_annotate.cmd_flags;
570			cvs_annotate(server_argc, server_argv);
571			cvs_server_send_response("ok");
572			}
573
574			void
575			cvs_server_rannotate(char *data)
576			{
577			if (chdir(server_currentdir) == -1)
578			fatal("cvs_server_rannotate: %s", strerror(errno));
579
580			cvs_cmdop = CVS_OP_RANNOTATE;
581			cmdp->cmd_flags = cvs_cmd_rannotate.cmd_flags;
582			cvs_annotate(server_argc, server_argv);
583			cvs_server_send_response("ok");
584			}
585
586			void
587			cvs_server_commit(char *data)
588			{
589			if (chdir(server_currentdir) == -1)
590			fatal("cvs_server_commit: %s", strerror(errno));
591
592			cvs_cmdop = CVS_OP_COMMIT;
593			cmdp->cmd_flags = cvs_cmd_commit.cmd_flags;
594			cvs_commit(server_argc, server_argv);
595			cvs_server_send_response("ok");
596			}
597
598			void
599			cvs_server_checkout(char *data)
600			{
601			if (chdir(server_currentdir) == -1)
602			fatal("cvs_server_checkout: %s", strerror(errno));
603
604			cvs_cmdop = CVS_OP_CHECKOUT;
605			cmdp->cmd_flags = cvs_cmd_checkout.cmd_flags;
606			cvs_checkout(server_argc, server_argv);
607			cvs_server_send_response("ok");
608			}
609
610			void
611			cvs_server_diff(char *data)
612			{
613			if (chdir(server_currentdir) == -1)
614			fatal("cvs_server_diff: %s", strerror(errno));
615
616			cvs_cmdop = CVS_OP_DIFF;
617			cmdp->cmd_flags = cvs_cmd_diff.cmd_flags;
618			cvs_diff(server_argc, server_argv);
619			cvs_server_send_response("ok");
620			}
621
622			void
623			cvs_server_rdiff(char *data)
624			{
625			if (chdir(server_currentdir) == -1)
626			fatal("cvs_server_rdiff: %s", strerror(errno));
627
628			cvs_cmdop = CVS_OP_RDIFF;
629			cmdp->cmd_flags = cvs_cmd_rdiff.cmd_flags;
630			cvs_diff(server_argc, server_argv);
631			cvs_server_send_response("ok");
632			}
633
634			void
635			cvs_server_export(char *data)
636			{
637			if (chdir(server_currentdir) == -1)
638			fatal("cvs_server_export: %s", strerror(errno));
639
640			cvs_cmdop = CVS_OP_EXPORT;
641			cmdp->cmd_flags = cvs_cmd_export.cmd_flags;
642			cvs_export(server_argc, server_argv);
643			cvs_server_send_response("ok");
644			}
645
646			void
647			cvs_server_init(char *data)
648			{
649			if (data == NULL)
650			fatal("Missing argument for init");
651
652			if (current_cvsroot != NULL)
653			fatal("Root in combination with init is not supported");
654
655			if ((current_cvsroot = cvsroot_get(data)) == NULL)
656			fatal("Invalid argument for init");
657
658			cvs_cmdop = CVS_OP_INIT;
659			cmdp->cmd_flags = cvs_cmd_init.cmd_flags;
660			cvs_init(server_argc, server_argv);
661			cvs_server_send_response("ok");
662			}
663
664			void
665			cvs_server_release(char *data)
666			{
667			if (chdir(server_currentdir) == -1)
668			fatal("cvs_server_release: %s", strerror(errno));
669
670			cvs_cmdop = CVS_OP_RELEASE;
671			cmdp->cmd_flags = cvs_cmd_release.cmd_flags;
672			cvs_release(server_argc, server_argv);
673			cvs_server_send_response("ok");
674			}
675
676			void
677			cvs_server_remove(char *data)
678			{
679			if (chdir(server_currentdir) == -1)
680			fatal("cvs_server_remove: %s", strerror(errno));
681
682			cvs_cmdop = CVS_OP_REMOVE;
683			cmdp->cmd_flags = cvs_cmd_remove.cmd_flags;
684			cvs_remove(server_argc, server_argv);
685			cvs_server_send_response("ok");
686			}
687
688			void
689			cvs_server_status(char *data)
690			{
691			if (chdir(server_currentdir) == -1)
692			fatal("cvs_server_status: %s", strerror(errno));
693
694			cvs_cmdop = CVS_OP_STATUS;
695			cmdp->cmd_flags = cvs_cmd_status.cmd_flags;
696			cvs_status(server_argc, server_argv);
697			cvs_server_send_response("ok");
698			}
699
700			void
701			cvs_server_log(char *data)
702			{
703			if (chdir(server_currentdir) == -1)
704			fatal("cvs_server_log: %s", strerror(errno));
705
706			cvs_cmdop = CVS_OP_LOG;
707			cmdp->cmd_flags = cvs_cmd_log.cmd_flags;
708			cvs_getlog(server_argc, server_argv);
709			cvs_server_send_response("ok");
710			}
711
712			void
713			cvs_server_rlog(char *data)
714			{
715			if (chdir(current_cvsroot->cr_dir) == -1)
716			fatal("cvs_server_rlog: %s", strerror(errno));
717
718			cvs_cmdop = CVS_OP_RLOG;
719			cmdp->cmd_flags = cvs_cmd_rlog.cmd_flags;
720			cvs_getlog(server_argc, server_argv);
721			cvs_server_send_response("ok");
722			}
723
724			void
725			cvs_server_tag(char *data)
726			{
727			if (chdir(server_currentdir) == -1)
728			fatal("cvs_server_tag: %s", strerror(errno));
729
730			cvs_cmdop = CVS_OP_TAG;
731			cmdp->cmd_flags = cvs_cmd_tag.cmd_flags;
732			cvs_tag(server_argc, server_argv);
733			cvs_server_send_response("ok");
734			}
735
736			void
737			cvs_server_rtag(char *data)
738			{
739			if (chdir(current_cvsroot->cr_dir) == -1)
740			fatal("cvs_server_rtag: %s", strerror(errno));
741
742			cvs_cmdop = CVS_OP_RTAG;
743			cmdp->cmd_flags = cvs_cmd_rtag.cmd_flags;
744			cvs_tag(server_argc, server_argv);
745			cvs_server_send_response("ok");
746			}
747
748			void
749			cvs_server_update(char *data)
750			{
751			if (chdir(server_currentdir) == -1)
752			fatal("cvs_server_update: %s", strerror(errno));
753
754			cvs_cmdop = CVS_OP_UPDATE;
755			cmdp->cmd_flags = cvs_cmd_update.cmd_flags;
756			cvs_update(server_argc, server_argv);
757			cvs_server_send_response("ok");
758			}
759
760			void
761			cvs_server_version(char *data)
762			{
763			cvs_cmdop = CVS_OP_VERSION;
764			cmdp->cmd_flags = cvs_cmd_version.cmd_flags;
765			cvs_version(server_argc, server_argv);
766			cvs_server_send_response("ok");
767			}
768
769			void
770			cvs_server_update_entry(const char resp, struct cvs_file cf)
771			{
772			char *p;
773			char repo[PATH_MAX], fpath[PATH_MAX];
774
775			if ((p = strrchr(cf->file_rpath, ',')) != NULL)
776			*p = '\0';
777
778			cvs_get_repository_path(cf->file_wd, repo, PATH_MAX);
779			(void)xsnprintf(fpath, PATH_MAX, "%s/%s", repo, cf->file_name);
780
781			cvs_server_send_response("%s %s/", resp, cf->file_wd);
782			cvs_remote_output(fpath);
783
784			if (p != NULL)
785			*p = ',';
786			}
787
788			void
789			cvs_server_set_sticky(const char dir, char tag)
790			{
791			char fpath[PATH_MAX];
792			char repo[PATH_MAX];
793
794			cvs_get_repository_path(dir, repo, PATH_MAX);
795			(void)xsnprintf(fpath, PATH_MAX, "%s/", repo);
796
797			cvs_server_send_response("Set-sticky %s/", dir);
798			cvs_remote_output(fpath);
799			cvs_remote_output(tag);
800			}
801
802			void
803			cvs_server_clear_sticky(char *dir)
804			{
805			char fpath[PATH_MAX];
806			char repo[PATH_MAX];
807
808			cvs_get_repository_path(dir, repo, PATH_MAX);
809			(void)xsnprintf(fpath, PATH_MAX, "%s/", repo);
810
811			cvs_server_send_response("Clear-sticky %s//", dir);
812			cvs_remote_output(fpath);
813			}
814
815			void
816			cvs_server_exp_modules(char *module)
817			{
818			struct module_checkout *mo;
819			struct cvs_filelist *fl;
820
821			if (server_argc != 2)
822			fatal("expand-modules with no arguments");
823
824			mo = cvs_module_lookup(server_argv[1]);
825
826			RB_FOREACH(fl, cvs_flisthead, &(mo->mc_modules))
827			cvs_server_send_response("Module-expansion %s", fl->file_path);
828			cvs_server_send_response("ok");
829
830			server_argc--;
831			free(server_argv[1]);
832			server_argv[1] = NULL;
833			}