* initial import from the cvs-tools module

43 files changed, 11534 insertions, 0 deletions

diff --git a/usr.bin/cvs/Makefile b/usr.bin/cvs/Makefile
new file mode 100644
index 00000000000..3aeff968388
--- /dev/null
+++ b/usr.bin/cvs/Makefile
@@ -0,0 +1,7 @@
+#	$OpenBSD: Makefile,v 1.1 2004/07/13 22:02:40 jfb Exp $
+
+.include <bsd.own.mk>
+
+SUBDIR= cvs cvsd
+
+.include <bsd.subdir.mk>
diff --git a/usr.bin/cvs/README b/usr.bin/cvs/README
new file mode 100644
index 00000000000..2b92661146b
--- /dev/null
+++ b/usr.bin/cvs/README
@@ -0,0 +1,4 @@
+README for cvs
+
+This is a BSD-licensed equivalent of the popular versioning system
+CVS.  Not much more to say for now
diff --git a/usr.bin/cvs/aclparse.y b/usr.bin/cvs/aclparse.y
new file mode 100644
index 00000000000..8fe67693731
--- /dev/null
+++ b/usr.bin/cvs/aclparse.y
@@ -0,0 +1,486 @@
+/*	$OpenBSD: aclparse.y,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ *
+ */
+%{
+#include <sys/types.h>
+#include <sys/queue.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "cvsd.h"
+#include "cvs.h"
+#include "log.h"
+#include "event.h"
+
+
+#define CVS_ACL_DENY         0
+#define CVS_ACL_ALLOW        1
+
+#define CVS_ACL_LOGOPT    0x01
+#define CVS_ACL_QUICKOPT  0x02
+
+
+struct acl_user {
+	uid_t  au_uid;
+	SLIST_ENTRY(acl_user) au_list;
+};
+
+
+struct acl_rule {
+	u_int8_t   ar_act;
+	u_int8_t   ar_opts;
+	u_int8_t   ar_op;
+	char      *ar_path;
+	char      *ar_tag;
+
+	SLIST_HEAD(, acl_user) ar_users;
+};
+
+
+
+
+typedef struct {
+	union {
+		u_int32_t         num;
+		char             *string;
+		struct acl_user  *user_list;
+	} v;
+
+	int lineno;
+} YYSTYPE;
+
+
+
+
+int    lgetc    (FILE *);
+
+
+int    yyerror  (const char *, ...);
+int    yylex    (void);
+int    lookup   (const char *);
+int    kw_cmp   (const void *, const void *);
+
+u_int  cvs_acl_matchuid  (struct acl_rule *, uid_t);
+u_int  cvs_acl_matchtag  (const char *, const char *);
+u_int  cvs_acl_matchpath (const char *, const char *);
+
+
+static char            *acl_file;
+static FILE            *acl_fin;
+static int              acl_lineno = 1;
+static int              acl_errors = 0;
+static struct acl_rule *acl_rules;
+static u_int            acl_nrules = 0;
+static u_int            acl_defact = CVS_ACL_DENY;
+
+
+static u_int            acl_opts = 0;
+
+
+/*
+ * cvs_acl_eval()
+ *
+ * Evaluate a thingamajimmie against the currently loaded ACL ruleset.
+ * Returns CVS_ACL_ALLOW if the operation is permitted, CVS_ACL_DENY otherwise.
+ */
+
+u_int
+cvs_acl_eval(struct cvs_op *op)
+{
+	u_int i, res;
+	struct acl_rule *arp;
+
+	/* deny by default */
+	res = acl_defact;
+
+	for (i = 0; i < acl_nrules; i++) {
+		arp = &(acl_rules[i]);
+
+		if ((op->co_op != arp->ar_op) ||
+		    !cvs_acl_matchuid(arp, op->co_uid) ||
+		    !cvs_acl_matchtag(op->co_tag, arp->ar_tag) ||
+		    !cvs_acl_matchpath(op->co_path, arp->ar_path))
+			continue;
+
+		res = arp->ar_act;
+
+		if (arp->ar_opts & CVS_ACL_LOGOPT)
+			cvs_log(LP_WARN, "act=%u, path=%s, tag=%s, uid=%u",
+			    op->co_op, op->co_path, op->co_tag, op->co_uid);
+		if (arp->ar_opts & CVS_ACL_QUICKOPT)
+			break;
+	}
+
+	return (res);
+}
+
+
+/*
+ * cvs_acl_matchuid()
+ *
+ * Check if an ACL rule has a UID matching <uid>.  If no user is specified
+ * for a given rule, any UID will match.
+ * Returns 1 if this is the case, 0 otherwise.
+ */
+
+u_int
+cvs_acl_matchuid(struct acl_rule *rule, uid_t uid)
+{
+	struct acl_user *aup;
+
+	if (SLIST_EMPTY(&(rule->ar_users)))
+		return (1);
+
+	SLIST_FOREACH(aup, &(rule->ar_users), au_list)
+		if (aup->au_uid == uid)
+			return (1);
+	return (0);
+}
+
+
+/*
+ * cvs_acl_matchtag()
+ *
+ * Returns 1 if this is the case, 0 otherwise.
+ */
+
+u_int
+cvs_acl_matchtag(const char *tag1, const char *tag2)
+{
+	if ((tag1 == NULL) && (tag2 == NULL))   /* HEAD */
+		return (1);
+
+	if ((tag1 != NULL) && (tag2 != NULL) &&
+	    (strcmp(tag1, tag2) == 0))
+		return (1);
+
+	return (0);
+}
+
+
+/*
+ * cvs_acl_matchpath()
+ *
+ * Check if the path <op_path> is a subpath of <acl_path>.
+ * Returns 1 if this is the case, 0 otherwise.
+ */
+
+u_int
+cvs_acl_matchpath(const char *op_path, const char *acl_path)
+{
+	size_t len;
+	char rop_path[MAXPATHLEN];
+
+	/* if the ACL path is NULL, apply on all paths */
+	if (acl_path == NULL)
+		return (1);
+
+	if (realpath(op_path, rop_path) == NULL) {
+		cvs_log(LP_ERRNO, "failed to convert `%s' to a real path",
+		    op_path);
+		return (0);
+	}
+
+	printf("comparing `%s' to `%s'\n", rop_path, acl_path);
+	len = strlen(rop_path);
+
+	if (strncmp(rop_path, acl_path, len) == 0)
+		return (1);
+
+	return (0);
+}
+%}
+
+%token	ALLOW DENY LOG QUICK ON TAG FROM
+%token  ADD CHECKOUT COMMIT DIFF HISTORY UPDATE
+%token  <v.string>    STRING
+%type   <v.num>       action options operation
+%type   <v.userlist>
+%type   <v.string>    pathspec tagspec
+%%
+
+ruleset		: /* empty */
+		| ruleset '\n'
+		| ruleset rule '\n'
+		| ruleset error '\n'	{ acl_errors++; }
+		;
+
+rule		: action options operation pathspec tagspec userspec
+		{
+			void *tmp;
+			struct acl_rule *arp;
+
+			tmp = realloc(acl_rules,
+			    (acl_nrules + 1) * sizeof(struct acl_rule));
+			if (tmp == NULL) {
+				cvs_log(LP_ERRNO, "failed to grow ACL ruleset");
+				free($4);
+				free($5);
+				YYERROR;
+			}
+			acl_rules = (struct acl_rule *)tmp;
+			arp = &(acl_rules[acl_nrules++]);
+
+			arp->ar_act = $1;
+			arp->ar_opts = $2;
+			arp->ar_op = $3;
+			SLIST_INIT(&arp->ar_users);
+			arp->ar_path = $4;
+			arp->ar_tag = $5;
+
+		}
+		;
+
+action		: ALLOW		{ $$ = CVS_ACL_ALLOW; }
+		| DENY		{ $$ = CVS_ACL_DENY;  }
+		;
+
+options		: /* empty */	{ $$ = 0; }
+		| LOG		{ $$ = CVS_ACL_LOGOPT; }
+		| QUICK		{ $$ = CVS_ACL_QUICKOPT; }
+		| LOG QUICK	{ $$ = CVS_ACL_LOGOPT | CVS_ACL_QUICKOPT; }
+		;
+
+operation	: ADD		{ $$ = CVS_OP_ADD; }
+		| COMMIT	{ $$ = CVS_OP_COMMIT; }
+		| TAG		{ $$ = CVS_OP_TAG; }
+		;
+
+pathspec	: /* empty */	{ $$ = NULL; }
+		| ON STRING	{ $$ = $2;   }
+		;
+
+tagspec		: /* empty */	{ $$ = NULL; }
+		| TAG STRING	{ $$ = $2; }
+		;
+
+userspec	: /* empty */
+		| FROM userlist
+		;
+
+userlist	: user
+		| userlist ',' user
+		;
+
+user		: STRING
+		{
+			uid_t uid;
+			char *ep;
+			struct passwd *pw;
+			struct acl_user *aup;
+
+			uid = (uid_t)strtol($1, &ep, 10);
+			if (*ep != '\0')
+				pw = getpwnam($1);
+			else
+				pw = getpwuid(uid);
+			if (pw == NULL) {
+				yyerror("invalid username or ID `%s'", $1);
+				YYERROR;
+			}
+
+			aup = (struct acl_user *)malloc(sizeof(*aup));
+			if (aup == NULL) {
+				yyerror("failed to allocate ACL user data");
+				YYERROR;
+			}
+			aup->au_uid = pw->pw_uid;
+		}
+		;
+%%
+
+
+struct acl_kw {
+	char  *kw_str;
+	u_int  kw_id;
+};
+
+
+
+static const struct acl_kw keywords[] = {
+	{ "add",     ADD    },
+	{ "allow",   ALLOW  },
+	{ "commit",  COMMIT },
+	{ "deny",    DENY   },
+	{ "from",    FROM   },
+	{ "log",     LOG    },
+	{ "on",      ON     },
+	{ "quick",   QUICK  },
+	{ "tag",     TAG    },
+};
+
+int
+kw_cmp(const void *k, const void *e)
+{
+	return (strcmp(k, ((const struct acl_kw *)e)->kw_str));
+}
+
+
+int
+lookup(const char *tstr)
+{
+	int type;
+	const struct acl_kw *kwp;
+
+	kwp = bsearch(tstr, keywords, sizeof(keywords)/sizeof(keywords[0]),
+	    sizeof(keywords[0]), kw_cmp);
+	if (kwp != NULL)
+		type = kwp->kw_id;
+	else
+		type = STRING;
+	return (type);
+}
+
+
+
+int
+lgetc(FILE *f)
+{
+	int c;
+
+	c = getc(f);
+	if ((c == '\t') || (c == ' ')) {
+		do {
+			c = getc(f);
+		} while ((c == ' ') || (c == '\t'));
+		ungetc(c, f);
+		c = ' ';
+	}
+	else if (c == '\\')
+		c = getc(f);
+
+	return (c);
+}
+
+
+int
+yylex(void)
+{
+	int tok, c;
+	char buf[1024], *bp, *ep;
+
+	bp = buf;
+	ep = buf + sizeof(buf) - 1;
+
+	yylval.lineno = acl_lineno;
+
+	/* skip whitespace */
+	while ((c = lgetc(acl_fin)) == ' ')
+		;
+
+	if (c == '#') {
+		do {
+			c = lgetc(acl_fin);
+		} while ((c != '\n') && (c != EOF));
+	}
+	else if (c == EOF)
+		c = 0;
+	else if (c == '\n')
+		acl_lineno++;
+	else if (c != ',') {
+		do {
+			*bp++ = c;
+			if (bp == ep) {
+				yyerror("string too long");
+				return (-1);
+			}
+
+			c = lgetc(acl_fin);
+			if (c == EOF)
+				break;
+		} while ((c != EOF) && (c != ' ') && (c != '\n'));
+		ungetc(c, acl_fin);
+		*bp = '\0';
+		c = lookup(buf);
+		if (c == STRING) {
+			yylval.v.string = strdup(buf);
+			if (yylval.v.string == NULL) {
+				cvs_log(LP_ERRNO,
+				    "failed to copy token string");
+				return (-1);
+			}
+		}
+	}
+
+	return (c);
+}
+
+
+
+int
+yyerror(const char *fmt, ...)
+{
+	char *nfmt;
+	va_list vap;
+
+	va_start(vap, fmt);
+
+	if (asprintf(&nfmt, "%s:%d: %s", acl_file, yylval.lineno, fmt) == -1) {
+		cvs_log(LP_ERRNO, "failed to allocate message buffer");
+		return (-1);
+	}
+	cvs_vlog(LP_ERR, nfmt, vap);
+
+	free(nfmt);
+	va_end(vap);
+	return (0);
+
+}
+
+
+/*
+ * cvs_acl_parse()
+ *
+ * Parse the contents of the ACL file <file>.
+ */
+
+int
+cvs_acl_parse(const char *file)
+{
+	acl_file = strdup(file);
+	if (acl_file == NULL) {
+		cvs_log(LP_ERRNO, "failed to copy ACL file path");
+		return (-1);
+	}
+
+	acl_fin = fopen(file, "r");
+	if (acl_fin == NULL) {
+		cvs_log(LP_ERRNO, "failed to open ACL file `%s'", file);
+		return (-1);
+	}
+
+	if (yyparse() != 0)
+		acl_lineno = -1;
+
+	(void)fclose(acl_fin);
+
+	return (acl_lineno);
+}
diff --git a/usr.bin/cvs/add.c b/usr.bin/cvs/add.c
new file mode 100644
index 00000000000..fde7a4f205a
--- /dev/null
+++ b/usr.bin/cvs/add.c
@@ -0,0 +1,98 @@
+/*	$OpenBSD: add.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/types.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sysexits.h>
+
+#include "cvs.h"
+#include "log.h"
+
+
+
+extern struct cvsroot *cvs_root;
+
+
+
+/*
+ * cvs_add()
+ *
+ * Handler for the `cvs add' command.
+ * Returns 0 on success, or one of the known system exit codes on failure.
+ */
+
+int
+cvs_add(int argc, char **argv)
+{
+	int ch, i, ret;
+	char *kflag, *msg;
+
+	kflag = NULL;
+
+	while ((ch = getopt(argc, argv, "k:m:")) != -1) {
+		switch (ch) {
+		case 'k':
+			kflag = optarg;
+			break;
+		case 'm':
+			msg = optarg;
+			break;
+		default:
+			return (EX_USAGE);
+		}
+	}
+
+	argc -= optind;
+	argv += optind;
+
+	if (argc == 0) {
+		return (EX_USAGE);
+	}
+
+	for (i = 0; i < argc; i++) {
+		/*
+		 * XXX figure out if we should send `Modified' or `Is-Modified'
+		 * The cvs documentation specifies that Modified should be used
+		 * in this case, but GNU CVS sends the latter.
+		 */
+		ret = cvs_client_sendreq(CVS_REQ_ISMODIFIED, argv[i], 0);
+		if (ret < 0)
+			return (EX_DATAERR);
+	}
+
+	for (i = 0; i < argc; i++) {
+		ret = cvs_client_sendreq(CVS_REQ_ARGUMENT, argv[i], 0);
+	}
+
+	ret = cvs_client_sendreq(CVS_REQ_ADD, NULL, 0);
+
+	return (0);
+}
diff --git a/usr.bin/cvs/buf.c b/usr.bin/cvs/buf.c
new file mode 100644
index 00000000000..9aa65b9cd57
--- /dev/null
+++ b/usr.bin/cvs/buf.c
@@ -0,0 +1,457 @@
+/*	$OpenBSD: buf.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2003 Jean-Francois Brousseau <jfb@fugusec.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+
+#include <stdio.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "buf.h"
+#include "log.h"
+
+
+#define BUF_INCR   128
+
+
+struct cvs_buf {
+	u_int    cb_flags;
+
+	/* buffer handle and size */
+	void    *cb_buf;
+	size_t   cb_size;
+
+	/* start and length of valid data in buffer */
+	u_char  *cb_cur;
+	size_t   cb_len;
+};
+
+
+
+#define SIZE_LEFT(b)  ((size_t)((u_char *)b->cb_buf - b->cb_cur) + b->cb_size)
+
+
+static ssize_t   cvs_buf_grow (BUF *, size_t);
+
+
+
+/*
+ * cvs_buf_alloc()
+ *
+ * Create a new buffer structure and return a pointer to it.  This structure
+ * uses dynamically-allocated memory and must be freed with cvs_buf_free(),
+ * once the buffer is no longer needed.
+ */
+
+BUF*
+cvs_buf_alloc(size_t len, u_int flags)
+{
+	BUF *b;
+
+	b = (BUF *)malloc(sizeof(*b));
+	if (b == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate buffer");
+		return (NULL);
+	}
+
+	b->cb_buf = malloc(len);
+	if (b->cb_buf == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate buffer");
+		free(b);
+		return (NULL);
+	}
+	memset(b->cb_buf, 0, sizeof(b->cb_buf));
+
+	b->cb_flags = flags;
+	b->cb_size = len;
+	b->cb_cur = (u_char *)b->cb_buf;
+	b->cb_len = 0;
+
+	return (b);
+}
+
+
+/*
+ * cvs_buf_load()
+ *
+ * Open the file specified by <path> and load all of its contents into a
+ * buffer.
+ * Returns the loaded buffer on success, or NULL on failure.
+ */
+
+BUF*
+cvs_buf_load(const char *path, u_int flags)
+{
+	int fd;
+	ssize_t ret;
+	size_t len;
+	void *bp;
+	struct stat st;
+	BUF *buf;
+
+	fd = open(path, O_RDONLY, 0600);
+	if (fd == -1) {
+		cvs_log(LP_ERRNO, "failed to open buffer source");
+		return (NULL);
+	}
+
+	if (fstat(fd, &st) == -1) {
+		cvs_log(LP_ERRNO, "failed to stat buffer source");
+		(void)close(fd);
+		return (NULL);
+	}
+
+	buf = cvs_buf_alloc((size_t)st.st_size, flags);
+	if (buf == NULL) {
+		(void)close(fd);
+		return (NULL);
+	}
+
+	for (bp = buf->cb_cur; ; bp += (size_t)ret) {
+		len = MIN(SIZE_LEFT(buf), 4096);
+		ret = read(fd, bp, len);
+		if (ret == -1) {
+			cvs_log(LP_ERRNO, "read failed from buffer source");
+			(void)close(fd);
+			cvs_buf_free(bp);
+			return (NULL);
+		}
+		else if (ret == 0)
+			break;
+
+		buf->cb_len += (size_t)ret;
+	}
+
+	(void)close(fd);
+
+	return (buf);
+}
+
+
+/*
+ * cvs_buf_free()
+ *
+ * Free the buffer <b> and all associated data.
+ */
+
+void
+cvs_buf_free(BUF *b)
+{
+	free(b->cb_buf);
+	free(b);
+}
+
+
+/*
+ * cvs_buf_release()
+ *
+ * Free the buffer <b>'s structural information but do not free the contents
+ * of the buffer.  Instead, they are returned and should be freed later using
+ * free().
+ */
+
+void*
+cvs_buf_release(BUF *b)
+{
+	void *tmp;
+	tmp = b->cb_buf;
+	free(b);
+	return (tmp);
+}
+
+
+/*
+ * cvs_buf_empty()
+ *
+ * Empty the contents of the buffer <b> and reset pointers.
+ */
+
+void
+cvs_buf_empty(BUF *b)
+{
+	b->cb_cur = (u_char *)b->cb_buf;
+	b->cb_len = 0;
+}
+
+
+/*
+ * cvs_buf_copy()
+ *
+ * Copy the first <len> bytes of data in the buffer <b> starting at offset
+ * <off> in the destination buffer <dst>, which can accept up to <len> bytes.
+ * Returns the number of bytes successfully copied, or -1 on failure.
+ */
+
+ssize_t
+cvs_buf_copy(BUF *b, size_t off, void *dst, size_t len)
+{
+	size_t rc;
+
+	if (off > b->cb_len)
+		return (-1);
+
+	rc = MIN(len, (b->cb_len - off));
+	memcpy(dst, b->cb_buf, rc);
+
+	return (ssize_t)rc;
+}
+
+
+/*
+ * cvs_buf_set()
+ *
+ * Set the contents of the buffer <b> to the first <len> bytes of data found
+ * at <src>.  If the buffer was not created with BUF_AUTOEXT, as many bytes
+ * as possible will be copied in the buffer.
+ */
+
+int
+cvs_buf_set(BUF *b, const void *src, size_t len, size_t off)
+{
+	size_t rlen;
+
+	if (b->cb_size < (len + off)) {
+		if ((b->cb_flags & BUF_AUTOEXT) && (cvs_buf_grow(b, 
+		    len + off - b->cb_size) < 0))
+			return (-1);
+		else
+			rlen = b->cb_size - off;
+
+	}
+	else
+		rlen = len;
+
+	memcpy((b->cb_buf + off), src, rlen);
+
+	if (b->cb_len == 0) {
+		b->cb_cur = b->cb_buf + off;
+		b->cb_len = rlen;
+	}
+
+	return (int)rlen;
+}
+
+
+/*
+ * cvs_buf_putc()
+ *
+ * Append a single character <c> to the end of the buffer <b>.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+cvs_buf_putc(BUF *b, int c)
+{
+	u_char *bp;
+
+	bp = b->cb_cur + b->cb_len;
+	if (bp == (b->cb_buf + b->cb_size)) {
+		/* extend */
+		if (!(b->cb_flags & BUF_AUTOEXT) ||
+		    (cvs_buf_grow(b, BUF_INCR) < 0))
+			return (-1);
+
+		/* the buffer might have been moved */
+		bp = b->cb_cur + b->cb_len;
+	}
+	*bp = (u_char)c;
+	b->cb_len++;
+
+	return (0);
+}
+
+
+/*
+ * cvs_buf_append()
+ *
+ * Append <len> bytes of data pointed to by <data> to the buffer <b>.  If the
+ * buffer is too small to accept all data, it will attempt to append as much
+ * data as possible, or if the BUF_AUTOEXT flag is set for the buffer, it
+ * will get resized to an appropriate size to accept all data.
+ * Returns the number of bytes successfully appended to the buffer, or -1
+ * on failure.
+ */
+
+ssize_t
+cvs_buf_append(BUF *b, const void *data, size_t len)
+{
+	size_t left, rlen;
+	void *bp, *bep;
+
+	bp = b->cb_cur + b->cb_len;
+	bep = b->cb_buf + b->cb_size;
+	left = bep - bp;
+	rlen = len;
+
+	if (left < len) {
+		if (b->cb_flags & BUF_AUTOEXT) {
+			if (cvs_buf_grow(b, len - left) < 0)
+				return (-1);
+			bp = b->cb_cur + b->cb_len;
+		}
+		else
+			rlen = bep - bp;
+	}
+
+	memcpy(bp, data, rlen);
+	b->cb_len += rlen;
+
+	return (rlen);
+}
+
+
+/*
+ * cvs_buf_fappend()
+ *
+ */
+
+int
+cvs_buf_fappend(BUF *b, const char *fmt, ...)
+{
+	int ret;
+	char *str;
+	va_list vap;
+
+	va_start(vap, fmt);
+
+	ret = vasprintf(&str, fmt, vap);
+	if (ret == -1) {
+		cvs_log(LP_ERRNO, "failed to format data");
+		return (-1);
+	}
+	va_end(vap);
+
+	ret = cvs_buf_append(b, str, ret);
+	free(str);
+	return (ret);
+}
+
+
+/*
+ * cvs_buf_size()
+ *
+ * Returns the size of the buffer that is being used.
+ */
+
+size_t
+cvs_buf_size(BUF *b)
+{
+	return (b->cb_len);
+}
+
+
+/*
+ * cvs_buf_peek()
+ *
+ * Peek at the contents of the buffer <b> at offset <off>.
+ */
+
+const void*
+cvs_buf_peek(BUF *b, size_t off)
+{
+	if (off >= b->cb_len)
+		return (NULL);
+
+	return (b->cb_buf + off);
+}
+
+
+/*
+ * cvs_buf_write()
+ *
+ * Write the contents of the buffer <b> to the file whose path is given in
+ * <path>.  If the file does not exist, it is created with mode <mode>.
+ */
+
+int
+cvs_buf_write(BUF *b, const char *path, mode_t mode)
+{
+	int fd;
+	u_char *bp;
+	size_t len;
+	ssize_t ret;
+
+	fd = open(path, O_WRONLY|O_CREAT|O_TRUNC, mode);
+	if (fd == -1) {
+		cvs_log(LP_ERRNO, "failed to open file `%s'", path);
+		return (-1);
+	}
+
+	len = b->cb_len;
+	bp = b->cb_cur;
+
+	do {
+		ret = write(fd, bp, MIN(len, 8192));
+		if (ret == -1) {
+			cvs_log(LP_ERRNO, "failed to write to file `%s'", path);
+			(void)close(fd);
+			(void)unlink(path);
+			return (-1);
+		}
+
+		len -= (size_t)ret;
+		bp += (size_t)ret;
+	} while (len > 0);
+
+	(void)close(fd);
+
+	return (0);
+}
+
+
+/*
+ * cvs_buf_grow()
+ *
+ * Grow the buffer <b> by <len> bytes.  The contents are unchanged by this
+ * operation regardless of the result.
+ * Returns the new size on success, or -1 on failure.
+ */
+
+static ssize_t
+cvs_buf_grow(BUF *b, size_t len)
+{
+	void *tmp;
+	size_t diff;
+
+	diff = b->cb_cur - (u_char *)b->cb_buf;
+	tmp = realloc(b->cb_buf, b->cb_size + len);
+	if (tmp == NULL) {
+		cvs_log(LP_ERRNO, "failed to grow buffer");
+		return (-1);
+	}
+	b->cb_buf = (u_char *)tmp;
+	b->cb_size += len;
+
+	/* readjust pointers in case the buffer moved in memory */
+	b->cb_cur = b->cb_buf + diff;
+
+	return (ssize_t)b->cb_size;
+}
diff --git a/usr.bin/cvs/buf.h b/usr.bin/cvs/buf.h
new file mode 100644
index 00000000000..fdd569664a1
--- /dev/null
+++ b/usr.bin/cvs/buf.h
@@ -0,0 +1,67 @@
+/*	$OpenBSD: buf.h,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2003 Jean-Francois Brousseau <jfb@fugusec.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Buffer management
+ * -----------------
+ *
+ * This code provides an API to generic memory buffer management.  All
+ * operations are performed on a cvs_buf structure, which is kept opaque to the
+ * API user in order to avoid corruption of the fields and make sure that only
+ * the internals can modify the fields.
+ *
+ * The first step is to allocate a new buffer using the cvs_buf_create()
+ * function, which returns a pointer to a new buffer.
+ */
+
+#ifndef BUF_H
+#define BUF_H
+
+#include <sys/types.h>
+
+
+/* flags */
+#define BUF_AUTOEXT   1      /* autoextend on append */
+
+
+typedef struct cvs_buf BUF;
+
+
+BUF*         cvs_buf_alloc   (size_t, u_int);
+BUF*         cvs_buf_load    (const char *, u_int);
+void         cvs_buf_free    (BUF *);
+void*        cvs_buf_release (BUF *);
+void         cvs_buf_empty   (BUF *);
+ssize_t      cvs_buf_copy    (BUF *, size_t, void *, size_t);
+int          cvs_buf_set     (BUF *, const void *, size_t, size_t);
+int          cvs_buf_append  (BUF *, const void *, size_t);
+int          cvs_buf_fappend (BUF *, const char *, ...);
+int          cvs_buf_putc    (BUF *, int);
+size_t       cvs_buf_size    (BUF *);
+const void*  cvs_buf_peek    (BUF *, size_t);
+int          cvs_buf_write   (BUF *, const char *, mode_t);
+
+#define cvs_buf_get(b)   cvs_buf_peek(b, 0)
+
+#endif /* BUF_H */
diff --git a/usr.bin/cvs/cache.c b/usr.bin/cvs/cache.c
new file mode 100644
index 00000000000..cdd0922c21e
--- /dev/null
+++ b/usr.bin/cvs/cache.c
@@ -0,0 +1,206 @@
+/*	$OpenBSD: cache.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/time.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+
+#include "log.h"
+#include "rcs.h"
+#include "cache.h"
+
+#define RCS_CACHE_BUCKETS    256
+
+
+struct rcs_cachent {
+	u_int           rc_hits;
+	u_int8_t        rc_hash;
+	RCSFILE        *rc_rfp;
+	struct timeval  rc_atime;
+
+	TAILQ_ENTRY(rcs_cachent) rc_list;
+	TAILQ_ENTRY(rcs_cachent)  rc_lru;
+};
+
+
+static u_int8_t rcs_cache_hash (const char *);
+
+
+TAILQ_HEAD(rcs_cachebkt, rcs_cachent) rcs_cache[RCS_CACHE_BUCKETS];
+
+TAILQ_HEAD(rcs_lruhead, rcs_cachent) rcs_cache_lru;
+
+u_int rcs_cache_maxent;
+u_int rcs_cache_nbent;
+
+
+
+/*
+ * rcs_cache_init()
+ *
+ * Initialize the RCS file data cache.
+ * Returns 0 on success, -1 on failure.
+ */
+
+int
+rcs_cache_init(u_int maxent)
+{
+	u_int i;
+
+	for (i = 0; i < RCS_CACHE_BUCKETS; i++)
+		TAILQ_INIT(&rcs_cache[i]);
+
+	TAILQ_INIT(&rcs_cache_lru);
+
+	rcs_cache_maxent = maxent;
+	rcs_cache_nbent = 0;
+
+	return (0);
+}
+
+
+/*
+ * rcs_cache_destroy()
+ */
+
+void
+rcs_cache_destroy(void)
+{
+}
+
+
+/*
+ * rcs_cache_fetch()
+ *
+ */
+
+RCSFILE*
+rcs_cache_fetch(const char *path)
+{
+	u_int8_t hash;
+	struct rcs_cachent *rcp;
+	RCSFILE *rfp;
+
+	rfp = NULL;
+	hash = rcs_cache_hash(path);
+
+	TAILQ_FOREACH(rcp, &(rcs_cache[hash]), rc_list) {
+		if (strcmp(path, rcp->rc_rfp->rf_path) == 0) {
+			rfp = rcp->rc_rfp;
+			break;
+		}
+	}
+
+	if (rcp != NULL) {
+		(void)gettimeofday(&(rcp->rc_atime), NULL);
+		rcp->rc_hits++;
+
+		/* move this item back at the end of the LRU */
+		TAILQ_REMOVE(&rcs_cache_lru, rcp, rc_lru);
+		TAILQ_INSERT_TAIL(&rcs_cache_lru, rcp, rc_lru);
+
+		/* increment reference count for caller */
+		rfp->rf_ref++;
+	}
+
+	return (rfp);
+}
+
+
+/*
+ * rcs_cache_store()
+ *
+ * Store the RCSFILE <rfp> in the RCS file cache.  By storing the file, its
+ * reference count gets incremented for the cache reference, so the caller
+ * should still rcs_close() the file once they are done with it.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+rcs_cache_store(RCSFILE *rfp)
+{
+	struct rcs_cachent *rcp, *old_rcp;
+
+	/* don't store the same element twice */
+	if (rcs_cache_fetch(rfp->rf_path) != NULL)
+		return (0);
+
+	rcp = (struct rcs_cachent *)malloc(sizeof(*rcp));
+	if (rcp == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate RCS cache entry");
+		return (-1);
+	}
+
+	rcp->rc_hits = 0;
+
+	rcp->rc_rfp = rfp;
+	rfp->rf_ref++;
+
+	rcp->rc_hash = rcs_cache_hash(rfp->rf_path);
+
+	rcs_cache_nbent++;
+	if (rcs_cache_nbent == rcs_cache_maxent) {
+		/* ditch the oldest entry in the LRU */
+		old_rcp = TAILQ_FIRST(&rcs_cache_lru);
+		TAILQ_REMOVE(&rcs_cache_lru, old_rcp, rc_lru);
+		TAILQ_REMOVE(&(rcs_cache[old_rcp->rc_hash]), old_rcp, rc_list);
+
+		/* free our reference */
+		rcs_close(old_rcp->rc_rfp);
+		free(old_rcp);
+	}
+
+	TAILQ_INSERT_TAIL(&(rcs_cache[rcp->rc_hash]), rcp, rc_list);
+	TAILQ_INSERT_TAIL(&rcs_cache_lru, rcp, rc_lru);
+
+	return (0);
+}
+
+
+/*
+ * rcs_cache_hash()
+ *
+ * Hash the <path> string.
+ */
+
+static u_int8_t
+rcs_cache_hash(const char *path)
+{
+	const char *sp;
+	u_int8_t hash;
+
+	hash = 0;
+	for (sp = path; *sp != '\0'; sp++)
+		hash ^= (*sp << 3) ^ (*sp >> 2);
+
+	return (hash);
+}
diff --git a/usr.bin/cvs/cache.h b/usr.bin/cvs/cache.h
new file mode 100644
index 00000000000..33b2a485f5b
--- /dev/null
+++ b/usr.bin/cvs/cache.h
@@ -0,0 +1,41 @@
+/*	$OpenBSD: cache.h,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#ifndef CACHE_H
+#define CACHE_H
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <signal.h>
+
+
+int       rcs_cache_init    (u_int);
+RCSFILE  *rcs_cache_fetch   (const char *path);
+int       rcs_cache_store   (RCSFILE *);
+void      rcs_cache_destroy (void);
+
+#endif /* CACHE_H */
diff --git a/usr.bin/cvs/checkout.c b/usr.bin/cvs/checkout.c
new file mode 100644
index 00000000000..25d53f6ae46
--- /dev/null
+++ b/usr.bin/cvs/checkout.c
@@ -0,0 +1,80 @@
+/*	$OpenBSD: checkout.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/types.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sysexits.h>
+
+#include "cvs.h"
+#include "log.h"
+
+
+
+extern struct cvsroot *cvs_root;
+
+
+
+/*
+ * cvs_checkout()
+ *
+ * Handler for the `cvs checkout' command.
+ * Returns 0 on success, or one of the known system exit codes on failure.
+ */
+
+int
+cvs_checkout(int argc, char **argv)
+{
+	int ch;
+
+	while ((ch = getopt(argc, argv, "")) != -1) {
+		switch (ch) {
+		default:
+			return (EX_USAGE);
+		}
+	}
+
+	argc -= optind;
+	argv += optind;
+
+	if (argc == 0) {
+		cvs_log(LP_ERR,
+		    "must specify at least one module or directory");
+		return (EX_USAGE);
+	}
+
+	if (cvs_root->cr_method == CVS_METHOD_LOCAL) {
+		return (0);
+	}
+
+	cvs_client_sendreq(CVS_REQ_ARGUMENT, argv[0], 0);
+
+	return (0);
+}
diff --git a/usr.bin/cvs/client.c b/usr.bin/cvs/client.c
new file mode 100644
index 00000000000..6f2fd2e63df
--- /dev/null
+++ b/usr.bin/cvs/client.c
@@ -0,0 +1,595 @@
+/*	$OpenBSD: client.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+#include <sysexits.h>
+#ifdef CVS_ZLIB
+#include <zlib.h>
+#endif
+
+#include "cvs.h"
+#include "log.h"
+
+
+
+extern int   verbosity;
+extern int   cvs_compress;
+extern char *cvs_rsh;
+extern int   cvs_trace;
+extern int   cvs_nolog;
+extern int   cvs_readonly;
+
+extern struct cvsroot *cvs_root;
+
+
+
+
+static int  cvs_client_sendinfo (void);
+static int  cvs_client_initlog  (void);
+
+
+
+static int    cvs_server_infd = -1;
+static int    cvs_server_outfd = -1;
+static FILE  *cvs_server_in;
+static FILE  *cvs_server_out;
+
+/* protocol log files, if the CVS_CLIENT_LOG environment variable is used */
+static FILE  *cvs_server_inlog;
+static FILE  *cvs_server_outlog;
+
+static char   cvs_client_buf[4096];
+
+/* last directory sent with `Directory' */
+static char   cvs_lastdir[MAXPATHLEN] = "";
+
+
+
+/*
+ * cvs_client_connect()
+ *
+ * Open a client connection to the cvs server whose address is given in
+ * the global <cvs_root> variable.  The method used to connect depends on the
+ * setting of the CVS_RSH variable.
+ */
+
+int
+cvs_client_connect(void)
+{
+	int argc, infd[2], outfd[2];
+	pid_t pid;
+	char *argv[16], *cvs_server_cmd;
+
+	if (pipe(infd) == -1) {
+		cvs_log(LP_ERRNO,
+		    "failed to create input pipe for client connection");
+		return (-1);
+	}
+
+	if (pipe(outfd) == -1) {
+		cvs_log(LP_ERRNO,
+		    "failed to create output pipe for client connection");
+		(void)close(infd[0]);
+		(void)close(infd[1]);
+		return (-1);
+	}
+
+	pid = fork();
+	if (pid == -1) {
+		cvs_log(LP_ERRNO, "failed to fork for cvs server connection");
+		return (-1);
+	}
+	if (pid == 0) {
+		if ((dup2(infd[0], STDIN_FILENO) == -1) ||
+		    (dup2(outfd[1], STDOUT_FILENO) == -1)) {
+			cvs_log(LP_ERRNO,
+			    "failed to setup standard streams for cvs server");
+			return (-1);
+		}
+		(void)close(infd[1]);
+		(void)close(outfd[0]);
+
+		argc = 0;
+		argv[argc++] = cvs_rsh;
+
+		if (cvs_root->cr_user != NULL) {
+			argv[argc++] = "-l";
+			argv[argc++] = cvs_root->cr_user;
+		}
+
+
+		cvs_server_cmd = getenv("CVS_SERVER");
+		if (cvs_server_cmd == NULL)
+			cvs_server_cmd = "cvs";
+
+		argv[argc++] = cvs_root->cr_host;
+		argv[argc++] = cvs_server_cmd;
+		argv[argc++] = "server";
+		argv[argc] = NULL;
+
+		execvp(argv[0], argv);
+		cvs_log(LP_ERRNO, "failed to exec");
+		exit(EX_OSERR);
+	}
+
+	/* we are the parent */
+	cvs_server_infd = infd[1];
+	cvs_server_outfd = outfd[0];
+
+	cvs_server_in = fdopen(cvs_server_infd, "w");
+	if (cvs_server_in == NULL) {
+		cvs_log(LP_ERRNO, "failed to create pipe stream");
+		return (-1);
+	}
+
+	cvs_server_out = fdopen(cvs_server_outfd, "r");
+	if (cvs_server_out == NULL) {
+		cvs_log(LP_ERRNO, "failed to create pipe stream");
+		return (-1);
+	}
+
+	/* make the streams line-buffered */
+	setvbuf(cvs_server_in, NULL, _IOLBF, 0);
+	setvbuf(cvs_server_out, NULL, _IOLBF, 0);
+
+	(void)close(infd[0]);
+	(void)close(outfd[1]);
+
+	cvs_client_initlog();
+
+	cvs_client_sendinfo();
+
+#ifdef CVS_ZLIB
+	/* if compression was requested, initialize it */
+#endif
+
+	return (0);
+}
+
+
+/*
+ * cvs_client_disconnect()
+ *
+ * Disconnect from the cvs server.
+ */
+
+void
+cvs_client_disconnect(void)
+{
+	cvs_log(LP_DEBUG, "closing client connection");
+	(void)fclose(cvs_server_in);
+	(void)fclose(cvs_server_out);
+	cvs_server_in = NULL;
+	cvs_server_out = NULL;
+	cvs_server_infd = -1;
+	cvs_server_outfd = -1;
+
+	if (cvs_server_inlog != NULL)
+		fclose(cvs_server_inlog);
+	if (cvs_server_outlog != NULL)
+		fclose(cvs_server_outlog);
+}
+
+
+/*
+ * cvs_client_sendreq()
+ *
+ * Send a request to the server of type <rid>, with optional arguments
+ * contained in <arg>, which should not be terminated by a newline.
+ * The <resp> argument is 0 if no response is expected, or any other value if
+ * a response is expected.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+cvs_client_sendreq(u_int rid, const char *arg, int resp)
+{
+	int ret;
+	size_t len;
+	char *rbp;
+	const char *reqp;
+
+	if (cvs_server_in == NULL) {
+		cvs_log(LP_ERR, "cannot send request: Not connected");
+		return (-1);
+	}
+
+	reqp = cvs_req_getbyid(rid);
+	if (reqp == NULL) {
+		cvs_log(LP_ERR, "unsupported request type %u", rid);
+		return (-1);
+	}
+
+	snprintf(cvs_client_buf, sizeof(cvs_client_buf), "%s %s\n", reqp,
+	    (arg == NULL) ? "" : arg);
+
+	rbp = cvs_client_buf;
+
+	if (cvs_server_inlog != NULL)
+		fputs(cvs_client_buf, cvs_server_inlog);
+
+	ret = fputs(cvs_client_buf, cvs_server_in);
+	if (ret == EOF) {
+		cvs_log(LP_ERRNO, "failed to send request to server");
+		return (-1);
+	}
+
+	if (resp) {
+		do {
+			/* wait for incoming data */
+			if (fgets(cvs_client_buf, sizeof(cvs_client_buf),
+			    cvs_server_out) == NULL) {
+				if (feof(cvs_server_out))
+					return (0);
+				cvs_log(LP_ERRNO,
+				    "failed to read response from server");
+				return (-1);
+			}
+
+			if (cvs_server_outlog != NULL)
+				fputs(cvs_client_buf, cvs_server_outlog);
+
+			if ((len = strlen(cvs_client_buf)) != 0) {
+				if (cvs_client_buf[len - 1] != '\n') {
+					/* truncated line */
+				}
+				else
+					cvs_client_buf[--len] = '\0';
+			}
+
+			ret = cvs_resp_handle(cvs_client_buf);
+		} while (ret == 0);
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvs_client_sendln()
+ *
+ * Send a single line <line> string to the server.  The line is sent as is,
+ * without any modifications.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+cvs_client_sendln(const char *line)
+{
+	int nl;
+	size_t len;
+
+	nl = 0;
+	len = strlen(line);
+
+	if ((len > 0) && (line[len - 1] != '\n'))
+		nl = 1;
+
+	if (cvs_server_inlog != NULL) {
+		fputs(line, cvs_server_inlog);
+		if (nl)
+			fputc('\n', cvs_server_inlog);
+	}
+	fputs(line, cvs_server_in);
+	if (nl)
+		fputc('\n', cvs_server_in);
+
+	return (0);
+}
+
+
+/*
+ * cvs_client_sendraw()
+ *
+ * Send the first <len> bytes from the buffer <src> to the server.
+ */
+
+int
+cvs_client_sendraw(const void *src, size_t len)
+{
+	if (cvs_server_inlog != NULL)
+		fwrite(src, sizeof(char), len, cvs_server_inlog);
+	if (fwrite(src, sizeof(char), len, cvs_server_in) < len) {
+		return (-1);
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvs_client_recvraw()
+ *
+ * Receive the first <len> bytes from the buffer <src> to the server.
+ */
+
+ssize_t
+cvs_client_recvraw(void *dst, size_t len)
+{
+	size_t ret;
+
+	ret = fread(dst, sizeof(char), len, cvs_server_out);
+	if (ret == 0)
+		return (-1);
+	if (cvs_server_outlog != NULL)
+		fwrite(dst, sizeof(char), len, cvs_server_outlog);
+	return (ssize_t)ret;
+}
+
+
+/*
+ * cvs_client_getln()
+ *
+ * Get a line from the server's output and store it in <lbuf>.  The terminating
+ * newline character is stripped from the result.
+ */
+
+int
+cvs_client_getln(char *lbuf, size_t len)
+{
+	size_t rlen;
+
+	if (fgets(lbuf, len, cvs_server_out) == NULL) {
+		if (ferror(cvs_server_out)) {
+			cvs_log(LP_ERRNO, "failed to read line from server");
+			return (-1);
+		}
+
+		if (feof(cvs_server_out))
+			*lbuf = '\0';
+	}
+
+	if (cvs_server_outlog != NULL)
+		fputs(lbuf, cvs_server_outlog);
+
+	rlen = strlen(lbuf);
+	if ((rlen > 0) && (lbuf[rlen - 1] == '\n'))
+		lbuf[--rlen] = '\0';
+
+	return (0);
+}
+
+
+/*
+ * cvs_client_sendinfo()
+ *
+ * Initialize the connection status by first requesting the list of
+ * supported requests from the server.  Then, we send the CVSROOT variable
+ * with the `Root' request.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+static int
+cvs_client_sendinfo(void)
+{
+	char *vresp;
+	/*
+	 * First, send the server the list of valid responses, then ask
+	 * for valid requests
+	 */
+
+	vresp = cvs_resp_getvalid();
+	if (vresp == NULL) {
+		cvs_log(LP_ERR, "can't generate list of valid responses");
+		return (-1);
+	}
+
+	if (cvs_client_sendreq(CVS_REQ_VALIDRESP, vresp, 0) < 0) {
+	}
+	free(vresp);
+
+	if (cvs_client_sendreq(CVS_REQ_VALIDREQ, NULL, 1) < 0) {
+		cvs_log(LP_ERR, "failed to get valid requests from server");
+		return (-1);
+	}
+
+	/* now share our global options with the server */
+	if (verbosity == 1)
+		cvs_client_sendreq(CVS_REQ_GLOBALOPT, "-q", 0);
+	else if (verbosity == 0)
+		cvs_client_sendreq(CVS_REQ_GLOBALOPT, "-Q", 0);
+
+	if (cvs_nolog)
+		cvs_client_sendreq(CVS_REQ_GLOBALOPT, "-l", 0);
+	if (cvs_readonly)
+		cvs_client_sendreq(CVS_REQ_GLOBALOPT, "-r", 0);
+	if (cvs_trace)
+		cvs_client_sendreq(CVS_REQ_GLOBALOPT, "-t", 0);
+
+	/* now send the CVSROOT to the server */
+	if (cvs_client_sendreq(CVS_REQ_ROOT, cvs_root->cr_dir, 0) < 0)
+		return (-1);
+
+	/* not sure why, but we have to send this */
+	if (cvs_client_sendreq(CVS_REQ_USEUNCHANGED, NULL, 0) < 0)
+		return (-1);
+
+	return (0);
+}
+
+
+/*
+ * cvs_client_senddir()
+ *
+ * Send a `Directory' request along with the 2 paths that follow it.
+ */
+
+int
+cvs_client_senddir(const char *dir)
+{
+	char repo[MAXPATHLEN], buf[MAXPATHLEN];
+
+	/* don't bother sending if it's the same as the last Directory sent */
+	if (strcmp(dir, cvs_lastdir) == 0)
+		return (0);
+
+	if (cvs_readrepo(dir, repo, sizeof(repo)) < 0)
+		return (-1);
+
+	snprintf(buf, sizeof(buf), "%s/%s", cvs_root->cr_dir, repo);
+
+	if ((cvs_client_sendreq(CVS_REQ_DIRECTORY, dir, 0) < 0) ||
+	    (cvs_client_sendln(buf) < 0))
+		return (-1);
+	strlcpy(cvs_lastdir, dir, sizeof(cvs_lastdir));
+
+	return (0);
+}
+
+
+/*
+ * cvs_client_sendarg()
+ *
+ * Send the argument <arg> to the server.  The argument <append> is used to
+ * determine if the argument should be simply appended to the last argument
+ * sent or if it should be created as a new argument (0).
+ */
+
+int
+cvs_client_sendarg(const char *arg, int append)
+{
+	return cvs_client_sendreq(((append == 0) ?
+	    CVS_REQ_ARGUMENT : CVS_REQ_ARGUMENTX), arg, 0);
+}
+
+
+/*
+ * cvs_client_sendentry()
+ *
+ * Send an `Entry' request to the server along with the mandatory fields from
+ * the CVS entry <ent> (which are the name and revision).
+ */
+
+int
+cvs_client_sendentry(const struct cvs_ent *ent)
+{
+	char ebuf[128], numbuf[64];
+
+	snprintf(ebuf, sizeof(ebuf), "/%s/%s///", ent->ce_name,
+	    rcsnum_tostr(ent->ce_rev, numbuf, sizeof(numbuf)));
+
+	return cvs_client_sendreq(CVS_REQ_ENTRY, ebuf, 0);
+}
+
+
+/*
+ * cvs_client_initlog()
+ *
+ * Initialize protocol logging if the CVS_CLIENT_LOG environment variable is
+ * set.  In this case, the variable's value is used as a path to which the
+ * appropriate suffix is added (".in" for server input and ".out" for server
+ * output.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+static int
+cvs_client_initlog(void)
+{
+	char *env, fpath[MAXPATHLEN];
+
+	env = getenv("CVS_CLIENT_LOG");
+	if (env == NULL)
+		return (0);
+
+	strlcpy(fpath, env, sizeof(fpath));
+	strlcat(fpath, ".in", sizeof(fpath));
+	cvs_server_inlog = fopen(fpath, "w");
+	if (cvs_server_inlog == NULL) {
+		cvs_log(LP_ERRNO, "failed to open server input log `%s'",
+		    fpath);
+		return (-1);
+	}
+
+	strlcpy(fpath, env, sizeof(fpath));
+	strlcat(fpath, ".out", sizeof(fpath));
+	cvs_server_outlog = fopen(fpath, "w");
+	if (cvs_server_outlog == NULL) {
+		cvs_log(LP_ERRNO, "failed to open server output log `%s'",
+		    fpath);
+		return (-1);
+	}
+
+	/* make the streams line-buffered */
+	setvbuf(cvs_server_inlog, NULL, _IOLBF, 0);
+	setvbuf(cvs_server_outlog, NULL, _IOLBF, 0);
+
+	return (0);
+}
+
+
+/*
+ * cvs_client_sendfile()
+ *
+ */
+
+int
+cvs_client_sendfile(const char *path)
+{
+	int fd;
+	ssize_t ret;
+	char buf[4096];
+	struct stat st;
+
+	if (stat(path, &st) == -1) {
+		cvs_log(LP_ERRNO, "failed to stat `%s'", path);
+		return (-1);
+	}
+
+	fd = open(path, O_RDONLY, 0);
+	if (fd == -1) {
+		return (-1);
+	}
+
+	if (cvs_modetostr(st.st_mode, buf, sizeof(buf)) < 0)
+		return (-1);
+
+	cvs_client_sendln(buf);
+	snprintf(buf, sizeof(buf), "%lld\n", st.st_size);
+	cvs_client_sendln(buf);
+
+	while ((ret = read(fd, buf, sizeof(buf))) != 0) {
+		if (ret == -1) {
+			cvs_log(LP_ERRNO, "failed to read file `%s'", path);
+			return (-1);
+		}
+
+		cvs_client_sendraw(buf, (size_t)ret);
+
+	}
+
+	(void)close(fd);
+
+	return (0);
+}
diff --git a/usr.bin/cvs/commit.c b/usr.bin/cvs/commit.c
new file mode 100644
index 00000000000..839bd29abb2
--- /dev/null
+++ b/usr.bin/cvs/commit.c
@@ -0,0 +1,145 @@
+/*	$OpenBSD: commit.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sysexits.h>
+
+#include "cvs.h"
+#include "log.h"
+
+
+
+
+static char*  cvs_commit_openmsg   (const char *);
+
+
+
+
+/*
+ * cvs_commit()
+ *
+ * Handler for the `cvs commit' command.
+ */
+
+int
+cvs_commit(int argc, char **argv)
+{
+	int ch, recurse;
+	char *msg, *mfile;
+
+	recurse = 1;
+	mfile = NULL;
+	msg = NULL;
+
+	while ((ch = getopt(argc, argv, "F:flm:R")) != -1) {
+		switch (ch) {
+		case 'F':
+			mfile = optarg;
+			break;
+		case 'f':
+			recurse = 0;
+			break;
+		case 'l':
+			recurse = 0;
+			break;
+		case 'm':
+			msg = optarg;
+			break;
+		case 'R':
+			recurse = 1;
+			break;
+		default:
+			return (EX_USAGE);
+		}
+	}
+
+	if ((msg != NULL) && (mfile != NULL)) {
+		cvs_log(LP_ERR, "the -F and -m flags are mutually exclusive");
+		return (EX_USAGE);
+	}
+
+	if ((mfile != NULL) && (msg = cvs_commit_openmsg(mfile)) == NULL)
+		return (EX_DATAERR);
+
+	argc -= optind;
+	argv += optind;
+
+	return (0);
+}
+
+
+/*
+ * cvs_commit_openmsg()
+ *
+ * Open the file specified by <path> and allocate a buffer large enough to
+ * hold all of the file's contents.  The returned value must later be freed
+ * using the free() function.
+ * Returns a pointer to the allocated buffer on success, or NULL on failure.
+ */
+
+static char*
+cvs_commit_openmsg(const char *path)
+{
+	int fd;
+	size_t sz;
+	char *msg;
+	struct stat st;
+
+	if (stat(path, &st) == -1) {
+		cvs_log(LP_ERRNO, "failed to stat `%s'", path);
+		return (NULL);
+	}
+
+	sz = st.st_size + 1;
+
+	msg = (char *)malloc(sz);
+	if (msg == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate message buffer");
+		return (NULL);
+	}
+
+	fd = open(path, O_RDONLY, 0);
+	if (fd == -1) {
+		cvs_log(LP_ERRNO, "failed to open message file `%s'", path);
+		return (NULL);
+	}
+
+	if (read(fd, msg, sz - 1) == -1) {
+		cvs_log(LP_ERRNO, "failed to read CVS commit message");
+		return (NULL);
+	}
+	msg[sz - 1] = '\0';
+
+	return (msg);
+}
diff --git a/usr.bin/cvs/cvs.1 b/usr.bin/cvs/cvs.1
new file mode 100644
index 00000000000..53b17614497
--- /dev/null
+++ b/usr.bin/cvs/cvs.1
@@ -0,0 +1,148 @@
+.\"	$OpenBSD: cvs.1,v 1.1 2004/07/13 22:02:40 jfb Exp $
+.\"
+.\" Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\"
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. The name of the author may not be used to endorse or promote products
+.\"    derived from this software without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+.\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+.\" AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+.\" THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+.\" EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+.\" PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+.\" OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+.\" WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+.\" OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+.\" ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+.\"
+.Dd May 16, 2004
+.Dt CVS 1
+.Os
+.Sh NAME
+.Nm cvs
+.Nd OpenCVS Concurrent Versioning System client/server
+.Sh SYNOPSIS
+.Nm
+.Op Fl flQqv
+.Op Fl d Ar root
+.Op Fl e Ar editor
+.Ar command Op Ar ...
+.Sh DESCRIPTION
+The
+.Nm
+program acts as both client and server for the use of and administration of
+a CVS source repository.
+CVS is used to maintain version information on files that are kept in a
+repository.
+Although it is more commonly used to track changes in source code, there
+are no real limitations to the type of files that you can store in a
+repository.
+.Pp
+The following options are supported:
+.Bl -tag -width Ds
+.It Fl d Ar root
+Use
+.Ar root
+as the path to the root directory of the CVS repository.
+The value must specify an absolute path.
+.It Fl e Ar editor
+Use the program
+.Ar editor
+whenever editing log information.
+This option overrides the environment variables CVSEDITOR, VISUAL and EDITOR.
+.It Fl f
+Do not read the contents of the user's .cvsrc file on startup.
+.It Fl l
+Suppress logging of history information.
+.It Fl Q
+Be extra quiet.
+Only error messages will be displayed.
+.It Fl q
+Be quiet about reporting.
+.It Fl v
+Display version information and exit.
+.El
+.Sh COMMANDS
+.Bl -tag -width Ds
+.Ic add
+.Ar file Op ...
+Before a file is known to CVS, it must be added to the repository using
+this command.
+Adding a file does not actually publish the contents of the
+file, so you must commit the first revision in order to let other users
+see the file with the
+.Ic update
+command.
+.Pp
+.Ic commit
+.Op Fl m Ar msg
+The
+.Ic commit
+command is used to send local changes back to the server and update the
+repository's information to reflect the changes.
+.Pp
+.Ic update
+.Op Fl dP
+.El
+.Sh FILES
+.Bl -tag -width Ds
+.It Pa $HOME/.cvsrc
+File containing a list of implicit options to pass to certain commands.
+This file is read on startup unless the
+.Fl f
+option is specified.
+.It Pa $CVSROOT/CVSROOT
+Directory containing repository administrative files.
+.It Pa $CVSROOT/CVSROOT/loginfo
+File containing associations between modules and handlers for
+post-commit logging.
+.El
+.Sh ENVIRONMENT
+.Bl -tag -width CVS_CLIENT_LOG
+.It Ev CVSROOT
+When set, this variable should contain the string pointing to the root
+directory of the CVS repository.
+The contents of this variable are ignored when the
+.Fl d
+option is given or if `Root' files exist in the checked-out copy.
+.It Ev CVS_RSH
+Name of the program to use when connecting to the server through a remote
+shell.
+The default is to use the
+.Xr ssh 1
+program.
+.It Ev CVS_SERVER
+If set, gives the name of the program to invoke as a
+.Nm
+server when using remote shell.
+The default is to use `cvs'.
+.It Ev CVSEDITOR
+Name of the editor to use when editing commit messages.
+Checked before EDITOR and VISUAL.
+.It Ev EDITOR
+.It Ev VISUAL
+.It Ev CVS_CLIENT_LOG
+This variable enables logging of all communications between the client and
+server when running in non-local mode.
+If set, this environment variable must contain a base path from which two
+paths will be generated by appending ".in" to the value for the server's
+input and ".out" for the server's output.
+.El
+.Sh SEE ALSO
+.Xr rcs 1 ,
+.Xr diff 1 ,
+.Xr patch 1 ,
+.Xr cvsd 8
+.Sh HISTORY
+The OpenCVS project is a BSD-licensed rewrite of the original
+Concurrent Versioning System written by Jean-Francois Brousseau.
+The original CVS code was written in large parts by Dick Grune,
+Brian Berliner and Jeff Polk.
diff --git a/usr.bin/cvs/cvs.c b/usr.bin/cvs/cvs.c
new file mode 100644
index 00000000000..8ec94769df0
--- /dev/null
+++ b/usr.bin/cvs/cvs.c
@@ -0,0 +1,497 @@
+#define DEBUG
+/*	$OpenBSD: cvs.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <err.h>
+#include <pwd.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+#include <sysexits.h>
+
+#include "cvs.h"
+#include "log.h"
+
+
+extern char *__progname;
+
+
+/* verbosity level: 0 = really quiet, 1 = quiet, 2 = verbose */
+int verbosity = 2;
+
+
+
+/* compression level used with zlib, 0 meaning no compression taking place */
+int   cvs_compress = 0;
+int   cvs_trace = 0;
+int   cvs_nolog = 0;
+int   cvs_readonly = 0;
+
+/* name of the command we are running */
+char *cvs_command;
+char *cvs_rootstr;
+char *cvs_rsh = CVS_RSH_DEFAULT;
+char *cvs_editor = CVS_EDITOR_DEFAULT;
+
+struct cvsroot *cvs_root = NULL;
+
+
+/*
+ * Command dispatch table
+ * ----------------------
+ *
+ * The synopsis field should only contain the list of arguments that the
+ * command supports, without the actual command's name.
+ *
+ * Command handlers are expected to return 0 if no error occured, or one of
+ * the values known in sysexits.h in case of an error.  In case the error
+ * returned is EX_USAGE, the command's usage string is printed to standard
+ * error before returning.
+ */
+
+static struct cvs_cmd {
+	char    cmd_name[CVS_CMD_MAXNAMELEN];
+	char    cmd_alias[CVS_CMD_MAXALIAS][CVS_CMD_MAXNAMELEN];
+	int   (*cmd_hdlr)(int, char **);
+	char   *cmd_synopsis;
+	char    cmd_descr[CVS_CMD_MAXDESCRLEN];
+} cvs_cdt[] = {
+	{
+		"add",      { "ad",  "new" }, cvs_add,
+		"[-m msg] file ...",
+		"Add a new file/directory to the repository",
+	},
+	{
+		"admin",    { "adm", "rcs" }, NULL,
+		"",
+		"Administration front end for rcs",
+	},
+	{
+		"annotate", { "ann"        }, NULL,
+		"",
+		"Show last revision where each line was modified",
+	},
+	{
+		"checkout", { "co",  "get" }, NULL,
+		"",
+		"Checkout sources for editing",
+	},
+	{
+		"commit",   { "ci",  "com" }, cvs_commit,
+		"",
+		"Check files into the repository",
+	},
+	{
+		"diff",     { "di",  "dif" }, cvs_diff,
+		"",
+		"Show differences between revisions",
+	},
+	{
+		"edit",     {              }, NULL,
+		"",
+		"Get ready to edit a watched file",
+	},
+	{
+		"editors",  {              }, NULL,
+		"",
+		"See who is editing a watched file",
+	},
+	{
+		"export",   { "ex",  "exp" }, NULL,
+		"",
+		"Export sources from CVS, similar to checkout",
+	},
+	{
+		"history",  { "hi",  "his" }, cvs_history,
+		"",
+		"Show repository access history",
+	},
+	{
+		"import",   { "im",  "imp" }, NULL,
+		"",
+		"Import sources into CVS, using vendor branches",
+	},
+	{
+		"init",     {              }, cvs_init,
+		"",
+		"Create a CVS repository if it doesn't exist",
+	},
+#if defined(HAVE_KERBEROS)
+	{
+		"kserver",  {}, NULL
+		"",
+		"Start a Kerberos authentication CVS server",
+	},
+#endif
+	{
+		"log",      { "lo"         }, cvs_getlog,
+		"",
+		"Print out history information for files",
+	},
+	{
+		"login",    {}, NULL,
+		"",
+		"Prompt for password for authenticating server",
+	},
+	{
+		"logout",   {}, NULL,
+		"",
+		"Removes entry in .cvspass for remote repository",
+	},
+	{
+		"rdiff",    {}, NULL,
+		"",
+		"Create 'patch' format diffs between releases",
+	},
+	{
+		"release",  {}, NULL,
+		"",
+		"Indicate that a Module is no longer in use",
+	},
+	{
+		"remove",   {}, NULL,
+		"",
+		"Remove an entry from the repository",
+	},
+	{
+		"rlog",     {}, NULL,
+		"",
+		"Print out history information for a module",
+	},
+	{
+		"rtag",     {}, NULL,
+		"",
+		"Add a symbolic tag to a module",
+	},
+	{
+		"server",   {}, cvs_server,
+		"",
+		"Server mode",
+	},
+	{
+		"status",   {}, NULL,
+		"",
+		"Display status information on checked out files",
+	},
+	{
+		"tag",      { "ta", }, NULL,
+		"",
+		"Add a symbolic tag to checked out version of files",
+	},
+	{
+		"unedit",   {}, NULL,
+		"",
+		"Undo an edit command",
+	},
+	{
+		"update",   {}, cvs_update,
+		"",
+		"Bring work tree in sync with repository",
+	},
+	{
+		"version",  {}, cvs_version,
+		"",
+		"Show current CVS version(s)",
+	},
+	{
+		"watch",    {}, NULL,
+		"",
+		"Set watches",
+	},
+	{
+		"watchers", {}, NULL,
+		"",
+		"See who is watching a file",
+	},
+};
+
+#define CVS_NBCMD  (sizeof(cvs_cdt)/sizeof(cvs_cdt[0]))
+
+
+
+void             usage        (void);
+void             sigchld_hdlr (int);
+void             cvs_readrc   (void);
+struct cvs_cmd*  cvs_findcmd  (const char *); 
+
+
+
+/*
+ * sigchld_hdlr()
+ *
+ * Handler for the SIGCHLD signal, which can be received in case we are
+ * running a remote server and it dies.
+ */
+
+void
+sigchld_hdlr(int signo)
+{
+	int status;
+	pid_t pid;
+
+	if ((pid = wait(&status)) == -1) {
+	}
+}
+
+
+/*
+ * usage()
+ *
+ * Display usage information.
+ */
+
+void
+usage(void)
+{
+	fprintf(stderr,
+	    "Usage: %s [-lQqtv] [-d root] [-e editor] [-z level] "
+	    "command [options] ...\n",
+	    __progname);
+}
+
+
+int
+main(int argc, char **argv)
+{
+	char *envstr, *ep;
+	int ret;
+	u_int i, readrc;
+	struct cvs_cmd *cmdp;
+
+	readrc = 1;
+
+	if (cvs_log_init(LD_STD, 0) < 0)
+		err(1, "failed to initialize logging");
+
+	/* by default, be very verbose */
+	(void)cvs_log_filter(LP_FILTER_UNSET, LP_INFO);
+
+#ifdef DEBUG
+	(void)cvs_log_filter(LP_FILTER_UNSET, LP_DEBUG);
+#endif
+
+	/* check environment so command-line options override it */
+	if ((envstr = getenv("CVS_RSH")) != NULL)
+		cvs_rsh = envstr;
+
+	if (((envstr = getenv("CVSEDITOR")) != NULL) ||
+	    ((envstr = getenv("VISUAL")) != NULL) ||
+	    ((envstr = getenv("EDITOR")) != NULL))
+		cvs_editor = envstr;
+
+	while ((ret = getopt(argc, argv, "d:e:fHlnQqrtvz:")) != -1) {
+		switch (ret) {
+		case 'd':
+			cvs_rootstr = optarg;
+			break;
+		case 'e':
+			cvs_editor = optarg;
+			break;
+		case 'f':
+			readrc = 0;
+			break;
+		case 'l':
+			cvs_nolog = 1;
+			break;
+		case 'n':
+			break;
+		case 'Q':
+			verbosity = 0;
+			break;
+		case 'q':
+			/* don't override -Q */
+			if (verbosity > 1)
+				verbosity = 1;
+			break;
+		case 'r':
+			cvs_readonly = 1;
+			break;
+		case 't':
+			cvs_trace = 1;
+			break;
+		case 'v':
+			printf("%s\n", CVS_VERSION);
+			exit(0);
+			/* NOTREACHED */
+			break;
+		case 'z':
+			cvs_compress = (int)strtol(optarg, &ep, 10); 
+			if (*ep != '\0')
+				errx(1, "error parsing compression level");
+			if (cvs_compress < 0 || cvs_compress > 9)
+				errx(1, "gzip compression level must be "
+				    "between 0 and 9");
+			break;
+		default:
+			usage();
+			exit(EX_USAGE);
+		}
+	}
+
+	argc -= optind;
+	argv += optind;
+
+	/* reset getopt() for use by commands */
+	optind = 1;
+	optreset = 1;
+
+	if (argc == 0) {
+		usage();
+		exit(EX_USAGE);
+	}
+
+	/* setup signal handlers */
+	signal(SIGCHLD, sigchld_hdlr);
+
+	if (readrc)
+		cvs_readrc();
+
+	cvs_command = argv[0];
+	ret = -1;
+
+	cmdp = cvs_findcmd(cvs_command);
+	if (cmdp == NULL) {
+		fprintf(stderr, "Unknown command: `%s'\n\n", cvs_command);
+		fprintf(stderr, "CVS commands are:\n");
+		for (i = 0; i < CVS_NBCMD; i++)
+			fprintf(stderr, "\t%-16s%s\n",
+			    cvs_cdt[i].cmd_name, cvs_cdt[i].cmd_descr);
+		exit(EX_USAGE);
+	}
+
+	if (cmdp->cmd_hdlr == NULL) {
+		cvs_log(LP_ERR, "command `%s' not implemented", cvs_command);
+		exit(1);
+	}
+
+	ret = (*cmdp->cmd_hdlr)(argc, argv);
+	if (ret == EX_USAGE) {
+		fprintf(stderr, "Usage: %s %s %s\n", __progname, cvs_command,
+		    cmdp->cmd_synopsis);
+	}
+
+	return (ret);
+}
+
+
+/*
+ * cvs_findcmd()
+ *
+ * Find the entry in the command dispatch table whose name or one of its
+ * aliases matches <cmd>.
+ * Returns a pointer to the command entry on success, NULL on failure.
+ */
+
+struct cvs_cmd*
+cvs_findcmd(const char *cmd)
+{
+	u_int i, j;
+	struct cvs_cmd *cmdp;
+
+	cmdp = NULL;
+
+	for (i = 0; (i < CVS_NBCMD) && (cmdp == NULL); i++) {
+		if (strcmp(cmd, cvs_cdt[i].cmd_name) == 0)
+			cmdp = &cvs_cdt[i];
+		else {
+			for (j = 0; j < CVS_CMD_MAXALIAS; j++) {
+				if (strcmp(cmd, cvs_cdt[i].cmd_alias[j]) == 0) {
+					cmdp = &cvs_cdt[i];
+					break;
+				}
+			}
+		}
+	}
+
+	return (cmdp);
+}
+
+
+/*
+ * cvs_readrc()
+ *
+ * Read the CVS `.cvsrc' file in the user's home directory.  If the file
+ * exists, it should contain a list of arguments that should always be given
+ * implicitly to the specified commands.
+ */
+
+void
+cvs_readrc(void)
+{
+	char rcpath[MAXPATHLEN], linebuf[128], *lp;
+	struct cvs_cmd *cmdp;
+	struct passwd *pw;
+	FILE *fp;
+
+	pw = getpwuid(getuid());
+	if (pw == NULL) {
+		cvs_log(LP_NOTICE, "failed to get user's password entry");
+		return;
+	}
+
+	snprintf(rcpath, sizeof(rcpath), "%s/%s", pw->pw_dir, CVS_PATH_RC);
+
+	fp = fopen(rcpath, "r");
+	if (fp == NULL) {
+		if (errno != ENOENT)
+			cvs_log(LP_NOTICE, "failed to open `%s': %s", rcpath,
+			    strerror(errno));
+		return;
+	}
+
+	while (fgets(linebuf, sizeof(linebuf), fp) != NULL) {
+		lp = strchr(linebuf, ' ');
+
+		/* ignore lines with no arguments */
+		if (lp == NULL)
+			continue;
+
+		*(lp++) = '\0';
+		if (strcmp(linebuf, "cvs") == 0) {
+			/* global options */
+		}
+		else {
+			cmdp = cvs_findcmd(linebuf);
+			if (cmdp == NULL) {
+				cvs_log(LP_NOTICE,
+				    "unknown command `%s' in cvsrc",
+				    linebuf);
+				continue;
+			}
+		}
+	}
+	if (ferror(fp)) {
+		cvs_log(LP_NOTICE, "failed to read line from cvsrc");
+	}
+
+	(void)fclose(fp);
+}
diff --git a/usr.bin/cvs/cvs.h b/usr.bin/cvs/cvs.h
new file mode 100644
index 00000000000..0a5b5120619
--- /dev/null
+++ b/usr.bin/cvs/cvs.h
@@ -0,0 +1,374 @@
+/*	$OpenBSD: cvs.h,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#ifndef CVS_H
+#define CVS_H
+
+#include <sys/param.h>
+
+#include "rcs.h"
+
+#define CVS_VERSION    "OpenCVS 0.1"
+
+
+#define CVS_HIST_CACHE     128
+#define CVS_HIST_NBFLD     6
+
+
+#define CVS_REQ_TIMEOUT    300
+
+
+
+#define CVS_CKSUM_LEN      33     /* length of a CVS checksum string */
+
+
+/* operations */
+#define CVS_OP_ADD          1
+#define CVS_OP_ANNOTATE     2
+#define CVS_OP_COMMIT       3
+#define CVS_OP_DIFF         4
+#define CVS_OP_TAG          5
+#define CVS_OP_UPDATE       6
+
+
+
+
+/* methods */
+#define CVS_METHOD_NONE       0
+#define CVS_METHOD_LOCAL      1    /* local access */
+#define CVS_METHOD_SERVER     2    /* tunnel through CVS_RSH */
+#define CVS_METHOD_PSERVER    3    /* cvs pserver */
+#define CVS_METHOD_KSERVER    4    /* kerberos */
+#define CVS_METHOD_GSERVER    5    /* gssapi server */
+#define CVS_METHOD_EXT        6
+#define CVS_METHOD_FORK       7    /* local but fork */
+
+/* client/server protocol requests */
+#define CVS_REQ_NONE          0
+#define CVS_REQ_ROOT          1
+#define CVS_REQ_VALIDREQ      2
+#define CVS_REQ_VALIDRESP     3
+#define CVS_REQ_DIRECTORY     4
+#define CVS_REQ_MAXDOTDOT     5
+#define CVS_REQ_STATICDIR     6
+#define CVS_REQ_STICKY        7
+#define CVS_REQ_ENTRY         8
+#define CVS_REQ_ENTRYEXTRA    9
+#define CVS_REQ_CHECKINTIME  10
+#define CVS_REQ_MODIFIED     11
+#define CVS_REQ_ISMODIFIED   12
+#define CVS_REQ_UNCHANGED    13
+#define CVS_REQ_USEUNCHANGED 14
+#define CVS_REQ_NOTIFY       15
+#define CVS_REQ_NOTIFYUSER   16
+#define CVS_REQ_QUESTIONABLE 17
+#define CVS_REQ_CASE         18
+#define CVS_REQ_UTF8         19
+#define CVS_REQ_ARGUMENT     20
+#define CVS_REQ_ARGUMENTX    21
+#define CVS_REQ_GLOBALOPT    22
+#define CVS_REQ_GZIPSTREAM   23
+#define CVS_REQ_KERBENCRYPT  24
+#define CVS_REQ_GSSENCRYPT   25
+#define CVS_REQ_PROTOENCRYPT 26
+#define CVS_REQ_GSSAUTH      27
+#define CVS_REQ_PROTOAUTH    28
+#define CVS_REQ_READCVSRC2   29
+#define CVS_REQ_READWRAP     30
+#define CVS_REQ_ERRIFREADER  31
+#define CVS_REQ_VALIDRCSOPT  32
+#define CVS_REQ_READIGNORE   33
+#define CVS_REQ_SET          34
+#define CVS_REQ_XPANDMOD     35
+#define CVS_REQ_CI           36
+#define CVS_REQ_CHOWN        37
+#define CVS_REQ_SETOWN       38
+#define CVS_REQ_SETPERM      39
+#define CVS_REQ_CHACL        40
+#define CVS_REQ_LISTPERM     41
+#define CVS_REQ_LISTACL      42
+#define CVS_REQ_SETPASS      43
+#define CVS_REQ_PASSWD       44
+#define CVS_REQ_DIFF         45
+#define CVS_REQ_STATUS       46
+#define CVS_REQ_LS           47
+#define CVS_REQ_TAG          48
+#define CVS_REQ_IMPORT       49
+#define CVS_REQ_ADMIN        50
+#define CVS_REQ_HISTORY      51
+#define CVS_REQ_WATCHERS     52
+#define CVS_REQ_EDITORS      53
+#define CVS_REQ_ANNOTATE     54
+#define CVS_REQ_LOG          55
+#define CVS_REQ_CO           56
+#define CVS_REQ_EXPORT       57
+#define CVS_REQ_RANNOTATE    58
+#define CVS_REQ_INIT         59
+#define CVS_REQ_UPDATE       60
+#define CVS_REQ_ADD          62
+#define CVS_REQ_REMOVE       63
+#define CVS_REQ_NOOP         64
+#define CVS_REQ_RTAG         65
+#define CVS_REQ_RELEASE      66
+#define CVS_REQ_RLOG         67
+#define CVS_REQ_RDIFF        68
+#define CVS_REQ_VERSION      69
+
+#define CVS_REQ_MAX          69
+
+
+/* responses */
+#define CVS_RESP_OK           1
+#define CVS_RESP_ERROR        2
+#define CVS_RESP_VALIDREQ     3
+#define CVS_RESP_CHECKEDIN    4
+#define CVS_RESP_NEWENTRY     5
+#define CVS_RESP_CKSUM        6
+#define CVS_RESP_COPYFILE     7
+#define CVS_RESP_UPDATED      8
+#define CVS_RESP_CREATED      9
+#define CVS_RESP_UPDEXIST    10
+#define CVS_RESP_MERGED      11
+#define CVS_RESP_PATCHED     12
+#define CVS_RESP_RCSDIFF     13
+#define CVS_RESP_MODE        14
+#define CVS_RESP_MODTIME     15
+#define CVS_RESP_REMOVED     16
+#define CVS_RESP_RMENTRY     17
+#define CVS_RESP_SETSTATDIR  18
+#define CVS_RESP_CLRSTATDIR  19
+#define CVS_RESP_SETSTICKY   20
+#define CVS_RESP_CLRSTICKY   21
+#define CVS_RESP_TEMPLATE    22
+#define CVS_RESP_SETCIPROG   23
+#define CVS_RESP_SETUPDPROG  24
+#define CVS_RESP_NOTIFIED    25
+#define CVS_RESP_MODXPAND    26
+#define CVS_RESP_WRAPRCSOPT  27
+#define CVS_RESP_M           28
+#define CVS_RESP_MBINARY     29
+#define CVS_RESP_E           30
+#define CVS_RESP_F           31
+#define CVS_RESP_MT          32
+
+
+
+
+#define CVS_CMD_MAXNAMELEN   16
+#define CVS_CMD_MAXALIAS      2
+#define CVS_CMD_MAXDESCRLEN  64
+
+
+/* defaults */
+#define CVS_RSH_DEFAULT     "ssh"
+#define CVS_EDITOR_DEFAULT  "vi"
+
+
+/* server-side paths */
+#define CVS_PATH_ROOT         "CVSROOT"
+#define CVS_PATH_COMMITINFO   CVS_PATH_ROOT "/commitinfo"
+#define CVS_PATH_CONFIG       CVS_PATH_ROOT "/config"
+#define CVS_PATH_CVSIGNORE    CVS_PATH_ROOT "/cvsignore"
+#define CVS_PATH_CVSWRAPPERS  CVS_PATH_ROOT "/cvswrappers"
+#define CVS_PATH_EDITINFO     CVS_PATH_ROOT "/editinfo"
+#define CVS_PATH_HISTORY      CVS_PATH_ROOT "/history"
+#define CVS_PATH_LOGINFO      CVS_PATH_ROOT "/loginfo"
+#define CVS_PATH_MODULES      CVS_PATH_ROOT "/modules"
+#define CVS_PATH_NOTIFY       CVS_PATH_ROOT "/notify"
+#define CVS_PATH_RCSINFO      CVS_PATH_ROOT "/rcsinfo"
+#define CVS_PATH_TAGINFO      CVS_PATH_ROOT "/taginfo"
+#define CVS_PATH_VERIFYMSG    CVS_PATH_ROOT "/verifymsg"
+
+
+/* client-side paths */
+#define CVS_PATH_RC             ".cvsrc"
+#define CVS_PATH_CVSDIR         "CVS"
+#define CVS_PATH_ENTRIES        CVS_PATH_CVSDIR "/Entries"
+#define CVS_PATH_STATICENTRIES  CVS_PATH_CVSDIR "/Entries.Static"
+#define CVS_PATH_LOGENTRIES     CVS_PATH_CVSDIR "/Entries.Log"
+#define CVS_PATH_ROOTSPEC       CVS_PATH_CVSDIR "/Root"
+
+
+struct cvs_op {
+	u_int  co_op;
+	uid_t  co_uid;    /* user performing the operation */
+	char  *co_path;   /* target path of the operation */
+	char  *co_tag;    /* tag or branch, NULL if HEAD */
+};
+
+
+
+
+
+
+struct cvsroot {
+	u_int   cr_method;
+	char   *cr_buf;
+	char   *cr_user;
+	char   *cr_pass;
+	char   *cr_host;
+	char   *cr_dir;
+	u_int   cr_port;
+};
+
+
+#define CVS_HIST_ADDED    'A'
+#define CVS_HIST_EXPORT   'E'
+#define CVS_HIST_RELEASE  'F'
+#define CVS_HIST_MODIFIED 'M'
+#define CVS_HIST_CHECKOUT 'O'
+#define CVS_HIST_COMMIT   'R'
+#define CVS_HIST_TAG      'T'
+
+
+#define CVS_ENT_NONE    0
+#define CVS_ENT_FILE    1
+#define CVS_ENT_DIR     2
+
+
+struct cvs_ent {
+	char    *ce_line;
+	char    *ce_buf;
+	u_int    ce_type;
+	char    *ce_name;
+	RCSNUM  *ce_rev;
+	char    *ce_timestamp;
+	char    *ce_opts;
+	char    *ce_tag;
+};
+
+typedef struct cvs_entries {
+	char    *cef_path;
+
+	u_int    cef_nid;  /* next entry index to return for next() */
+
+	struct cvs_ent **cef_entries;
+	u_int            cef_nbent;
+} CVSENTRIES;
+
+
+
+struct cvs_hent {
+	char    ch_event;
+	time_t  ch_date;
+	uid_t   ch_uid;
+	char   *ch_user;
+	char   *ch_curdir;
+	char   *ch_repo;
+	RCSNUM *ch_rev;
+	char   *ch_arg;
+};
+
+
+typedef struct cvs_histfile {
+	int     chf_fd;
+	char   *chf_buf;       /* read buffer */
+	size_t  chf_blen;      /* buffer size */
+	size_t  chf_bused;     /* bytes used in buffer */
+
+	off_t   chf_off;       /* next read */
+	u_int   chf_sindex;    /* history entry index of first in array */
+	u_int   chf_cindex;    /* current index (for getnext()) */
+	u_int   chf_nbhent;    /* number of valid entries in the array */
+
+	struct cvs_hent chf_hent[CVS_HIST_CACHE];
+
+} CVSHIST;
+
+
+
+/* client command handlers */
+int  cvs_add      (int, char **);
+int  cvs_commit   (int, char **);
+int  cvs_diff     (int, char **);
+int  cvs_getlog   (int, char **);
+int  cvs_history  (int, char **);
+int  cvs_init     (int, char **);
+int  cvs_server   (int, char **);
+int  cvs_update   (int, char **);
+int  cvs_version  (int, char **);
+
+
+/* proto.c */
+int         cvs_req_handle     (char *);
+const char* cvs_req_getbyid    (int);
+int         cvs_req_getbyname  (const char *);
+char*       cvs_req_getvalid   (void);
+
+int         cvs_resp_handle    (char *);
+const char* cvs_resp_getbyid   (int);
+int         cvs_resp_getbyname (const char *);
+char*       cvs_resp_getvalid  (void);
+
+int         cvs_sendfile       (const char *);
+int         cvs_recvfile       (const char *);
+
+
+/* from client.c */
+int     cvs_client_connect     (void);
+void    cvs_client_disconnect  (void);
+int     cvs_client_sendreq     (u_int, const char *, int);
+int     cvs_client_sendarg     (const char *, int);
+int     cvs_client_sendln      (const char *);
+int     cvs_client_sendraw     (const void *, size_t);
+ssize_t cvs_client_recvraw     (void *, size_t);
+int     cvs_client_getln       (char *, size_t);
+int     cvs_client_senddir     (const char *);
+
+
+/* from root.c */
+struct cvsroot*  cvsroot_parse (const char *);
+void             cvsroot_free  (struct cvsroot *);
+struct cvsroot*  cvsroot_get   (const char *);
+
+
+/* Entries API */
+CVSENTRIES*      cvs_ent_open   (const char *);
+struct cvs_ent*  cvs_ent_get    (CVSENTRIES *, const char *);
+struct cvs_ent*  cvs_ent_next   (CVSENTRIES *);
+int              cvs_ent_add    (CVSENTRIES *, struct cvs_ent *);
+int              cvs_ent_remove (CVSENTRIES *, const char *);
+struct cvs_ent*  cvs_ent_parse  (const char *);
+void             cvs_ent_close  (CVSENTRIES *);
+
+/* history API */
+CVSHIST*         cvs_hist_open    (const char *);
+void             cvs_hist_close   (CVSHIST *);
+int              cvs_hist_parse   (CVSHIST *);
+struct cvs_hent* cvs_hist_getnext (CVSHIST *);
+int              cvs_hist_append  (CVSHIST *, struct cvs_hent *);
+
+
+/* from util.c */
+int    cvs_readrepo   (const char *, char *, size_t);
+int    cvs_splitpath  (const char *, char *, size_t, char *, size_t);
+int    cvs_modetostr  (mode_t, char *, size_t);
+int    cvs_strtomode  (const char *, mode_t *);
+int    cvs_cksum      (const char *, char *, size_t);
+int    cvs_exec       (int, char **, int []);
+
+
+#endif /* CVS_H */
diff --git a/usr.bin/cvs/cvs/Makefile b/usr.bin/cvs/cvs/Makefile
new file mode 100644
index 00000000000..1b01c901887
--- /dev/null
+++ b/usr.bin/cvs/cvs/Makefile
@@ -0,0 +1,16 @@
+# $Id: Makefile,v 1.1 2004/07/13 22:02:40 jfb Exp $
+
+.PATH:	${.CURDIR}/..
+
+PROG=ocvs
+BINDIR=/usr/bin
+BINOWN=root
+BINGRP=_cvsd
+BINMODE=2555
+MAN=cvs.1 cvsrc.5
+
+SRCS= cvs.c add.c buf.c client.c commit.c diff.c entries.c getlog.c \
+	history.c hist.c init.c lock.c log.c proto.c rcs.c rcsnum.c root.c \
+	server.c sock.c update.c util.c version.c
+
+.include <bsd.prog.mk>
diff --git a/usr.bin/cvs/cvsacl.5 b/usr.bin/cvs/cvsacl.5
new file mode 100644
index 00000000000..f1f12cf370a
--- /dev/null
+++ b/usr.bin/cvs/cvsacl.5
@@ -0,0 +1,107 @@
+.\"	$OpenBSD: cvsacl.5,v 1.1 2004/07/13 22:02:40 jfb Exp $
+.\"
+.\" Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. The name of the author may not be used to endorse or promote products
+.\"    derived from this software without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+.\" IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+.\" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+.\" IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+.\" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+.\" NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+.\" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+.\" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+.\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+.\" THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+.\"
+.Dd June 22, 2004
+.Dt CVSACL 5
+.Os
+.Sh NAME
+.Nm cvsacl
+.Nd CVS Access Control Lists format
+.Sh DESCRIPTION
+The
+.Nm
+file format is the format understood by the
+.Xr cvsd 8
+daemon for performing access control on files within the CVS repository.
+It is composed of access rules, each on a single line, which either allow
+or deny certain operations on files or entire directories.
+.Sh GRAMMAR
+The
+.Nm
+grammar is expressed in BNF (Backus-Naur Form) notation.
+Terminals are displayed as normal text.
+Nonterminals are in bold.
+Anything enclosed between angle brackets
+.Po
+.Ql [
+and
+.Ql \&]
+.Pc
+is optional.
+The pipe character
+.Pq Ql \&|
+is used to separate multiple choices.
+.Pp
+Here is the BNF syntax for
+.Nm
+rules:
+.Bl -tag -width "this is a test"
+.It Ic line
+::=
+.It Ic rule
+::=
+.Ic action
+.Bo
+.Ic optlist
+.Bc
+.Ic op
+[ branch
+.Ic branch
+]
+.Pp
+[ from
+.Ic userlist
+]
+.It Ic action
+::= allow | deny
+.It Ic option
+::= quick | log
+.It Ic optlist
+::=
+.Ic option
+|
+.Ic optlist ,
+.Ic option
+.It Ic op
+::= add | commit | tag | update
+.It Ic userlist
+::=
+.El
+.Pp
+.Sh EXAMPLES
+The following rule denies all operations:
+.Bd -literal
+	deny quick
+.Ed
+.Sh SEE ALSO
+.Xr cvs 1 ,
+.Xr cvsd 8
+.Sh HISTORY
+The
+.Nm
+file format appeared with the OpenCVS project.
+.Sh AUTHORS
+.An Jean-Francois Brousseau
diff --git a/usr.bin/cvs/cvsd.8 b/usr.bin/cvs/cvsd.8
new file mode 100644
index 00000000000..f65eba78929
--- /dev/null
+++ b/usr.bin/cvs/cvsd.8
@@ -0,0 +1,116 @@
+.\"	$OpenBSD: cvsd.8,v 1.1 2004/07/13 22:02:40 jfb Exp $
+.\"
+.\" Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. Redistributions in binary form must reproduce the above copyright
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 3. The name of the author may not be used to endorse or promote products
+.\"    derived from this software without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+.\" IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+.\" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+.\" IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+.\" INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+.\" NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+.\" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+.\" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+.\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+.\" THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+.\"
+.Dd May 16, 2004
+.Dt CVSD 8
+.Os
+.Sh NAME
+.Nm cvsd
+.Nd Concurrent Versions System daemon
+.Sh SYNOPSIS
+.Nm cvsd
+.Op Fl dfpv
+.Op Fl a Ar aclfile
+.Op Fl r Ar cvsroot
+.Op Fl s Ar sockpath
+.Sh DESCRIPTION
+The
+.Nm
+daemon manages access to a CVS repository.
+It provides a much more secure alternative to the traditional client-server
+model commonly used by
+.Xr cvs 1
+through various mechanisms described below.
+.Pp
+On startup, 
+.Nm
+spawns a child process that chroots to the CVS repository's root directory.
+Both processes then drop privileges to user and group
+.Ic _cvsd .
+Once this is done, the child process loads the list of ACLs and opens a local
+socket on which it listens for requests.
+The parent process' only purpose is to answer requests for things outside of
+the child's jail.
+.Pp
+In order to enforce ACLs and prevent users from modifying the files in the
+repository directly, all of the files within the repository should be owned
+by the user and group
+.Ic _cvsd
+and should only be writable by the user.
+.Pp
+The options are as follows:
+.Bl -tag -width "-s sockpath"
+.It Fl a Ar aclfile
+Use
+.Ar aclfile
+as the source file for the Access Control Lists to apply on the repository.
+.It Fl d
+Start the server with debugging enabled.
+This option overrides the
+.Fl v
+option.
+.It Fl f
+Stay in foreground instead of performing the usual operations to become
+a daemon.
+This causes all log messages to be printed on standard input or standard
+error, depending on the priority of each message.
+.It Fl p
+On startup, perform a check on the whole contents of the CVS repository to
+check file permissions and ownership, and print warnings for any files or
+directories that do not match the expected permission masks.
+When running with this option,
+.Nm
+will exit with an error message if any of the files have permissions that are
+too open.
+.It Fl r Ar cvsroot
+Use
+.Ar cvsroot
+as the CVS repository's root directory.
+.It Fl s Ar sockpath
+Use the path specified by
+.Ar sockpath
+as the file to bind to for the local socket.
+.It Fl v
+Be verbose.
+.Sh FILES
+.Bl -tag -width /var/run/cvsd.sock -compact
+.It Pa /var/run/cvsd.pid
+Process ID of the currently running
+.Nm .
+.It Pa /var/run/cvsd.sock
+Default listening socket for incoming cvs requests.
+.El
+.Sh SEE ALSO
+.Xr cvs 1 ,
+.Xr rcs 1 ,
+.Xr rcsfile 5 ,
+.Xr cvsacl 5
+.Sh HISTORY
+The
+.Nm
+server appeared as part of the OpenCVS project.
+.Sh AUTHORS
+.An Jean-Francois Brousseau
diff --git a/usr.bin/cvs/cvsd.c b/usr.bin/cvs/cvsd.c
new file mode 100644
index 00000000000..748eadfe5ef
--- /dev/null
+++ b/usr.bin/cvs/cvsd.c
@@ -0,0 +1,649 @@
+/*	$OpenBSD: cvsd.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <sys/uio.h>
+
+#include <err.h>
+#include <pwd.h>
+#include <grp.h>
+#include <poll.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <signal.h>
+#include <errno.h>
+#include <string.h>
+#include <sysexits.h>
+
+#include "log.h"
+#include "sock.h"
+#include "cvs.h"
+#include "cvsd.h"
+
+
+static void  cvsd_parent_loop (void);
+static void  cvsd_child_loop  (void);
+static int   cvsd_privdrop    (void);
+
+
+extern char *__progname;
+
+
+
+int foreground = 0;
+
+volatile sig_atomic_t restart = 0;
+
+
+uid_t cvsd_uid = -1;
+gid_t cvsd_gid = -1;
+
+
+char *cvsd_root = NULL;
+char *cvsd_aclfile = NULL;
+
+
+static int    cvsd_privfd = -1;
+
+
+
+static TAILQ_HEAD(,cvsd_child) cvsd_children;
+static volatile sig_atomic_t   cvsd_chnum = 0;
+static volatile sig_atomic_t   cvsd_chmin = CVSD_CHILD_DEFMIN;
+static volatile sig_atomic_t   cvsd_chmax = CVSD_CHILD_DEFMAX;
+
+
+/*
+ * sighup_handler()
+ *
+ * Handler for the SIGHUP signal.
+ */
+
+void
+sighup_handler(int signo)
+{
+	restart = 1;
+}
+
+
+/*
+ * sigint_handler()
+ *
+ * Handler for the SIGINT signal.
+ */
+
+void
+sigint_handler(int signo)
+{
+	cvs_sock_doloop = 0;
+}
+
+
+/*
+ * sigchld_handler()
+ *
+ */
+
+void
+sigchld_handler(int signo)
+{
+	int status;
+
+	wait(&status);
+
+}
+
+
+/*
+ * usage()
+ *
+ * Display program usage.
+ */
+
+void
+usage(void)
+{
+	fprintf(stderr,
+	    "Usage: %s [-dfpv] [-a aclfile] [-c config] [-r root] [-s path]\n"
+	    "\t-a aclfile\tUse the file <aclfile> for ACL ruleset\n"
+	    "\t-d\t\tStart the server in debugging mode (very verbose)\n"
+	    "\t-f\t\tStay in foreground instead of becoming a daemon\n"
+	    "\t-p\t\tPerform permission and ownership check on the repository\n"
+	    "\t-r root\tUse <root> as the root directory of the repository\n"
+	    "\t-s path\tUse <path> as the path for the CVS server socket\n"
+	    "\t-v\t\tBe verbose\n",
+	    __progname);
+}
+
+
+int
+main(int argc, char **argv)
+{
+	u_int i;
+	int ret, checkrepo;
+	uid_t uid;
+	struct passwd *pwd;
+	struct group *grp;
+
+	checkrepo = 0;
+
+	if (cvs_log_init(LD_STD|LD_SYSLOG, LF_PID) < 0)
+		err(1, "failed to initialize logging mechanism");
+
+	while ((ret = getopt(argc, argv, "a:dfpr:s:v")) != -1) {
+		switch (ret) {
+		case 'a':
+			cvsd_aclfile = optarg;
+			break;
+		case 'd':
+			cvs_log_filter(LP_FILTER_UNSET, LP_DEBUG);
+			cvs_log_filter(LP_FILTER_UNSET, LP_INFO);
+			break;
+		case 'f':
+			foreground = 1;
+			break;
+		case 'p':
+			checkrepo = 1;
+			break;
+		case 'r':
+			cvsd_root = optarg;
+			break;
+		case 's':
+			cvsd_sock_path = optarg;
+			break;
+		case 'v':
+			cvs_log_filter(LP_FILTER_UNSET, LP_INFO);
+			break;
+		default:
+			usage();
+			exit(EX_USAGE);
+		}
+	}
+
+	argc -= optind;
+	argv += optind;
+
+	if ((cvsd_aclfile != NULL) && (cvs_acl_parse(cvsd_aclfile) < 0))
+		errx(1, "error while parsing the ACL file `%s'", cvsd_aclfile);
+
+	if (cvsd_root == NULL)
+		errx(1, "no CVS root directory specified");
+
+	if (argc > 0)
+		errx(EX_USAGE, "unrecognized trailing arguments");
+
+	TAILQ_INIT(&cvsd_children);
+
+	pwd = getpwnam(CVSD_USER);
+	if (pwd == NULL)
+		err(EX_NOUSER, "failed to get user `%s'", CVSD_USER);
+
+	grp = getgrnam(CVSD_GROUP);
+	if (grp == NULL)
+		err(EX_NOUSER, "failed to get group `%s'", CVSD_GROUP);
+
+	cvsd_uid = pwd->pw_uid;
+	cvsd_gid = grp->gr_gid;
+
+	signal(SIGHUP, sighup_handler);
+	signal(SIGINT, sigint_handler);
+	signal(SIGQUIT, sigint_handler);
+	signal(SIGTERM, sigint_handler);
+
+	if (!foreground && daemon(0, 0) == -1) {
+		cvs_log(LP_ERRNO, "failed to become a daemon");
+		exit(EX_OSERR);
+	}
+
+	if (cvsd_sock_open() < 0) {
+		exit(1);
+	}
+
+	if (setegid(cvsd_gid) == -1) {
+		cvs_log(LP_ERRNO, "failed to drop group privileges");
+		exit(EX_OSERR);
+	}
+	if (seteuid(cvsd_uid) == -1) {
+		cvs_log(LP_ERRNO, "failed to drop user privileges");
+		exit(EX_OSERR);
+	}
+
+	if (checkrepo && cvsd_checkperms("/") != 0) {
+		cvs_log(LP_ERR,
+		    "exiting due to permission errors on repository");
+		exit(1);
+	}
+
+	/* spawn the initial pool of children */
+	for (i = 0; i < cvsd_chmin; i++) {
+		ret = cvsd_forkchild();
+		if (ret == -1) {
+			cvs_log(LP_ERR, "failed to spawn child");
+			exit(EX_OSERR);
+		}
+	}
+
+	cvsd_sock_loop();
+
+	cvs_log(LP_NOTICE, "shutting down");
+	cvs_log_cleanup();
+
+	cvsd_sock_close();
+
+	return (0);
+}
+
+
+/*
+ * cvsd_privdrop()
+ *
+ * Drop privileges.
+ */
+
+int
+cvsd_privdrop(void)
+{
+	cvs_log(LP_INFO, "dropping privileges to %s:%s", CVSD_USER,
+	    CVSD_GROUP);
+	if (setegid(cvsd_gid) == -1) {
+		cvs_log(LP_ERRNO, "failed to drop group privileges to %s",
+		    CVSD_GROUP);
+		return (-1);
+	}
+
+	if (seteuid(cvsd_uid) == -1) {
+		cvs_log(LP_ERRNO, "failed to drop user privileges to %s",
+		    CVSD_USER);
+		return (-1);
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvsd_checkperms()
+ *
+ * Check permissions on the CVS repository and log warnings for any
+ * weird of loose permissions.
+ * Returns the number of warnings on success, or -1 on failure.
+ */
+
+int
+cvsd_checkperms(const char *path)
+{
+	int fd, nbwarn, ret;
+	mode_t fmode;
+	long base;
+	void *dp, *endp;
+	char buf[1024], spath[MAXPATHLEN];
+	struct stat st;
+	struct dirent *dep;
+
+	nbwarn = 0;
+
+	cvs_log(LP_DEBUG, "checking permissions on `%s'", path);
+
+	if (stat(path, &st) == -1) {
+		cvs_log(LP_ERRNO, "failed to stat `%s'", path);
+		return (-1);
+	}
+
+	if (S_ISDIR(st.st_mode))
+		fmode = CVSD_DPERM;
+	else
+		fmode = CVSD_FPERM;
+
+	if (st.st_uid != cvsd_uid) {
+		cvs_log(LP_WARN, "owner of `%s' is not %s", path, CVSD_USER);
+		nbwarn++;
+	}
+
+	if (st.st_gid != cvsd_gid) {
+		cvs_log(LP_WARN, "group of `%s' is not %s", path, CVSD_GROUP);
+		nbwarn++;
+	}
+
+	if (st.st_mode & S_IWGRP) {
+		cvs_log(LP_WARN, "file `%s' is group-writable", path,
+		    fmode);
+		nbwarn++;
+	}
+
+	if (st.st_mode & S_IWOTH) {
+		cvs_log(LP_WARN, "file `%s' is world-writable", path,
+		    fmode);
+		nbwarn++;
+	}
+
+	if (S_ISDIR(st.st_mode)) {
+		fd = open(path, O_RDONLY, 0);
+		if (fd == -1) {
+			cvs_log(LP_ERRNO, "failed to open directory `%s'",
+			    path);
+			return (nbwarn);
+		}
+		/* recurse */
+		ret = getdirentries(fd, buf, sizeof(buf), &base);
+		if (ret == -1) {
+			cvs_log(LP_ERRNO,
+			    "failed to get directory entries for `%s'", path);
+			(void)close(fd);
+			return (nbwarn);
+		}
+
+		dp = buf;
+		endp = buf + ret;
+
+		while (dp < endp) {
+			dep = (struct dirent *)dp;
+			dp += dep->d_reclen;
+
+			if ((dep->d_namlen == 1) && (dep->d_name[0] == '.'))
+				continue;
+			if ((dep->d_namlen == 2) && (dep->d_name[0] == '.') &&
+			    (dep->d_name[1] == '.'))
+				continue;
+
+			/* skip the CVSROOT directory */
+			if (strcmp(dep->d_name, CVS_PATH_ROOT) == 0)
+				continue;
+
+			snprintf(spath, sizeof(spath), "%s/%s", path,
+			    dep->d_name);
+			ret = cvsd_checkperms(spath);
+			if (ret == -1)
+				nbwarn++;
+			else
+				nbwarn += ret;
+		}
+		(void)close(fd);
+	}
+
+
+	return (nbwarn);
+}
+
+
+/*
+ * cvsd_forkchild()
+ *
+ * Fork a child process which chroots to the CVS repository's root directory.
+ * We need to temporarily regain privileges in order to chroot.
+ * On success, returns 0 if this is the child process, 1 if this is the
+ * parent, or -1 on failure.
+ */
+
+int
+cvsd_forkchild(void)
+{
+	int svec[2];
+	pid_t pid;
+	struct cvsd_child *chp;
+
+	if (socketpair(AF_LOCAL, SOCK_STREAM, PF_UNSPEC, svec) == -1) {
+		cvs_log(LP_ERRNO, "failed to create socket pair");
+		return (-1);
+	}
+
+	/*
+	 * We need to temporarily regain original privileges in order for the
+	 * child to chroot().
+	 */
+	if (seteuid(0) == -1) {
+		cvs_log(LP_ERRNO, "failed to regain privileges");
+		return (-1);
+	}
+
+	pid = fork();
+	if (pid == -1) {
+		cvs_log(LP_ERRNO, "failed to fork child");
+		(void)close(svec[0]);
+		(void)close(svec[1]);
+		return (-1);
+	}
+
+	if (pid == 0) {
+		cvsd_privfd = svec[1];
+		(void)close(svec[0]);
+
+		cvs_log(LP_INFO, "changing root to %s", cvsd_root);
+		if (chroot(cvsd_root) == -1) {
+			cvs_log(LP_ERRNO, "failed to chroot to `%s'",
+			    cvsd_root);
+			exit(EX_OSERR);
+		}
+		(void)chdir("/");
+
+		/* redrop privileges */
+		if (setgid(cvsd_gid) == -1) {
+			cvs_log(LP_ERRNO, "failed to drop privileges");
+			exit(EX_OSERR);
+		}
+		if (setuid(cvsd_uid) == -1) {
+			cvs_log(LP_ERRNO, "failed to drop privileges");
+			exit(EX_OSERR);
+		}
+
+		setproctitle("%s [child %d]", __progname, getpid());
+
+		cvsd_child_loop();
+
+		return (0);
+	}
+
+	cvs_log(LP_INFO, "spawning child %d", pid);
+
+	if (seteuid(cvsd_uid) == -1) {
+		cvs_log(LP_ERRNO, "failed to redrop privs");
+		return (-1);
+	}
+
+	chp = (struct cvsd_child *)malloc(sizeof(*chp));
+	if (chp == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate child data");
+		return (-1);
+	}
+
+	chp->ch_pid = pid;
+	chp->ch_sock = svec[0];
+	(void)close(svec[1]);
+
+	return (1);
+}
+
+
+/*
+ * cvsd_parent_loop()
+ *
+ * Main loop of the parent cvsd process, which listens on its end of the
+ * socket pair for requests from the chrooted child.
+ */
+
+static void
+cvsd_parent_loop(void)
+{
+	uid_t uid;
+	int timeout, ret;
+	nfds_t nfds, i;
+	struct pollfd *pfd;
+	struct cvsd_child *chp;
+
+	nfds = 0;
+	timeout = INFTIM;
+
+	for (;;) {
+		nfds = cvsd_chnum;
+		pfd = (struct pollfd *)realloc(pfd,
+		    nfds * sizeof(struct pollfd));
+		if (pfd == NULL) {
+			cvs_log(LP_ERRNO, "failed to reallocate polling data");
+			return;
+		}
+
+		i = 0;
+		TAILQ_FOREACH(chp, &cvsd_children, ch_list) {
+			pfd[i].fd = chp->ch_sock;
+			pfd[i].events = POLLIN;
+			pfd[i].revents = 0;
+			i++;
+
+			if (i == nfds)
+				break;
+		}
+
+		ret = poll(pfd, nfds, timeout);
+		if (ret == -1) {
+			cvs_log(LP_ERRNO, "poll error");
+			break;
+		}
+
+		chp = TAILQ_FIRST(&cvsd_children);
+		for (i = 0; i < nfds; i++) {
+			if (pfd[i].revents & (POLLERR|POLLNVAL)) {
+				cvs_log(LP_ERR,
+				    "poll error on child socket (PID %d)",
+				    chp->ch_pid);
+			}
+			else
+				cvsd_msghdlr(chp, pfd[i].fd);
+
+			chp = TAILQ_NEXT(chp, ch_list);
+		}
+
+	}
+}
+
+
+/*
+ * cvsd_child_loop()
+ *
+ */
+
+static void
+cvsd_child_loop(void)
+{
+	int ret, timeout;
+	struct pollfd pfd[1];
+
+	pfd[0].fd = cvsd_privfd;
+	pfd[0].events = POLLIN;
+	timeout = INFTIM;
+
+	for (;;) {
+		ret = poll(pfd, 1, timeout);
+		if (ret == -1) {
+		}
+		else if (ret == 0) {
+			cvs_log(LP_INFO, "parent process closed descriptor");
+			break;
+		}
+		cvs_log(LP_INFO, "polling");
+
+	}
+
+	exit(0);
+}
+
+
+/*
+ * cvsd_msghdlr()
+ */
+
+int
+cvsd_msghdlr(struct cvsd_child *child, int fd)
+{
+	uid_t uid;
+	ssize_t ret;
+	char rbuf[CVSD_MSG_MAXLEN];
+	struct group *gr;
+	struct passwd *pw;
+	struct iovec iov[2];
+	struct cvsd_msg msg;
+
+	ret = read(fd, &msg, sizeof(msg));
+	if (ret == -1) {
+		cvs_log(LP_ERRNO, "failed to read CVS message");
+		return (-1);
+	}
+	else if (ret == 0) {
+		cvs_log(LP_WARN, "child closed socket pair");
+		return (0);
+	}
+
+	if (msg.cm_len > 0) {
+		ret = read(fd, rbuf, msg.cm_len);
+		if (ret != (ssize_t)msg.cm_len) {
+			cvs_log(LP_ERR, "failed to read entire msg");
+			return (-1);
+		}
+	}
+
+	/* setup the I/O vector for the reply */
+	iov[0].iov_base = &msg;
+	iov[0].iov_len = sizeof(msg);
+
+	msg.cm_type = CVSD_MSG_ERROR;
+	msg.cm_len = 0;
+
+	switch (msg.cm_type) {
+	case CVSD_MSG_GETUID:
+		rbuf[ret] = '\0';
+		cvs_log(LP_INFO, "getting UID for `%s'", rbuf); 
+
+		pw = getpwnam(rbuf);
+		if (pw != NULL) {
+			msg.cm_type = CVSD_MSG_UID;
+			msg.cm_len = sizeof(uid_t);
+			iov[1].iov_len = msg.cm_len;
+			iov[1].iov_base = &(pw->pw_uid);
+		}
+		break;
+	case CVSD_MSG_GETUNAME:
+		memcpy(&uid, rbuf, sizeof(uid));
+		cvs_log(LP_INFO, "getting username for UID %u", uid); 
+		pw = getpwuid(uid);
+		if (pw != NULL) {
+			msg.cm_type = CVSD_MSG_UNAME;
+			msg.cm_len = strlen(pw->pw_name);
+			iov[1].iov_len = msg.cm_len;
+			iov[1].iov_base = pw->pw_name;
+		}
+		break;
+	default:
+		cvs_log(LP_ERR, "unknown command type %u", msg.cm_type);
+		return (-1);
+	}
+
+	ret = writev(fd, iov, 2);
+
+	return (ret);
+}
diff --git a/usr.bin/cvs/cvsd.h b/usr.bin/cvs/cvsd.h
new file mode 100644
index 00000000000..e35dc8d9634
--- /dev/null
+++ b/usr.bin/cvs/cvsd.h
@@ -0,0 +1,106 @@
+/*	$OpenBSD: cvsd.h,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#ifndef CVSD_H
+#define CVSD_H
+
+#include <sys/types.h>
+#include <sys/queue.h>
+#include <sys/stat.h>
+
+#include <pwd.h>
+#include <signal.h>
+
+#include "cvs.h"
+
+#define CVSD_USER   "_cvsd"
+#define CVSD_GROUP  "_cvsd"
+
+#define CVSD_CHILD_DEFMIN    3
+#define CVSD_CHILD_DEFMAX    5
+
+
+
+#define CVSD_FPERM  (S_IRUSR | S_IWUSR)
+#define CVSD_DPERM  (S_IRWXU)
+
+
+/* requests */
+#define CVSD_MSG_GETUID    1
+#define CVSD_MSG_GETUNAME  2
+#define CVSD_MSG_PASSFD    3   /* server passes client file descriptor */
+#define CVSD_MSG_SETIDLE   4   /* client has no further processing to do */
+
+/* replies */
+#define CVSD_MSG_UID       128
+#define CVSD_MSG_UNAME     129
+
+#define CVSD_MSG_SHUTDOWN  253
+#define CVSD_MSG_OK        254
+#define CVSD_MSG_ERROR     255
+
+#define CVSD_MSG_MAXLEN    256
+
+
+/* message structure to pass data between the parent and the chrooted child */
+struct cvsd_msg {
+	u_int8_t  cm_type;
+	u_int8_t  cm_len;    /* length of message data in bytes */
+};
+
+
+struct cvsd_child {
+	pid_t  ch_pid;
+	int    ch_sock;
+
+	TAILQ_ENTRY(cvsd_child) ch_list;
+};
+
+
+
+extern int foreground;
+
+extern volatile sig_atomic_t running;
+extern volatile sig_atomic_t restart;
+
+
+
+
+
+
+int  cvsd_checkperms (const char *);
+int  cvsd_forkchild  (void);
+
+
+/* from aclparse.y */
+int    cvs_acl_parse  (const char *);
+u_int  cvs_acl_eval   (struct cvs_op *);
+
+/* from msg.c */
+int    cvsd_sendmsg (int, u_int, const void *, size_t);
+int    cvsd_recvmsg (int, u_int *, void *, size_t *);
+
+#endif /* CVSD_H */
diff --git a/usr.bin/cvs/cvsd/Makefile b/usr.bin/cvs/cvsd/Makefile
new file mode 100644
index 00000000000..ad2e5ec891c
--- /dev/null
+++ b/usr.bin/cvs/cvsd/Makefile
@@ -0,0 +1,11 @@
+# $Id: Makefile,v 1.1 2004/07/13 22:02:40 jfb Exp $
+
+.PATH:	${.CURDIR}/..
+
+BINDIR=/usr/sbin
+PROG=cvsd
+MAN=cvsd.8
+
+SRCS= cvsd.c aclparse.y log.c msg.c sock.c
+
+.include <bsd.prog.mk>
diff --git a/usr.bin/cvs/cvsrc.5 b/usr.bin/cvs/cvsrc.5
new file mode 100644
index 00000000000..035d4c0cbfc
--- /dev/null
+++ b/usr.bin/cvs/cvsrc.5
@@ -0,0 +1,65 @@
+.\"	$OpenBSD: cvsrc.5,v 1.1 2004/07/13 22:02:40 jfb Exp $
+.\"
+.\" Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+.\" All rights reserved.
+.\"
+.\" Redistribution and use in source and binary forms, with or without
+.\" modification, are permitted provided that the following conditions
+.\" are met:
+.\"
+.\" 1. Redistributions of source code must retain the above copyright
+.\"    notice, this list of conditions and the following disclaimer.
+.\" 2. The name of the author may not be used to endorse or promote products
+.\"    derived from this software without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+.\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+.\" AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+.\" THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+.\" EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+.\" PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+.\" OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+.\" WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+.\" OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+.\" ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+.\"
+.Dd June 14, 2004
+.Dt CVSRC 5
+.Os
+.Sh NAME
+.Nm cvsrc
+.Nd startup resource file for CVS
+.Sh DESCRIPTION
+The cvsrc file provides a way to give the
+.Xr cvs 1
+program implicit global options and command-specific options.
+The file is read on startup unless the
+.Fl f
+option is specified.
+.Pp
+The format of each line is as follows:
+.Pp
+.Dl command [arg ...]
+.Pp
+where
+.Ar command
+is either the `cvs' keyword to specify global options, one of the supported
+.Xr cvs 1
+commands or a command alias.
+Arguments following
+.Ar command
+will be added implicitly to the appropriate command's argument vector if it is
+run.
+Empty lines and lines specifying no optional arguments are ignored.
+Lines whose
+.Ar command
+argument is not a valid command will generate a warning when running without
+the
+.Fl q
+or
+.Fl Q
+flags.
+.Sh EXAMPLES
+Need to put in some examples!
+.Sh SEE ALSO
+.Xr cvs 1
diff --git a/usr.bin/cvs/diff.c b/usr.bin/cvs/diff.c
new file mode 100644
index 00000000000..61291c7031e
--- /dev/null
+++ b/usr.bin/cvs/diff.c
@@ -0,0 +1,1678 @@
+/*	$OpenBSD: diff.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (C) Caldera International Inc.  2001-2002.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code and documentation must retain the above
+ *    copyright notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed or owned by Caldera
+ *	International, Inc.
+ * 4. Neither the name of Caldera International, Inc. nor the names of other
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
+ * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE FOR ANY DIRECT,
+ * INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+/*-
+ * Copyright (c) 1991, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ * Copyright (c) 2004 Jean-Francois Brousseau.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)diffreg.c   8.1 (Berkeley) 6/6/93
+ */
+/*
+ *	Uses an algorithm due to Harold Stone, which finds
+ *	a pair of longest identical subsequences in the two
+ *	files.
+ *
+ *	The major goal is to generate the match vector J.
+ *	J[i] is the index of the line in file1 corresponding
+ *	to line i file0. J[i] = 0 if there is no
+ *	such line in file1.
+ *
+ *	Lines are hashed so as to work in core. All potential
+ *	matches are located by sorting the lines of each file
+ *	on the hash (called ``value''). In particular, this
+ *	collects the equivalence classes in file1 together.
+ *	Subroutine equiv replaces the value of each line in
+ *	file0 by the index of the first element of its
+ *	matching equivalence in (the reordered) file1.
+ *	To save space equiv squeezes file1 into a single
+ *	array member in which the equivalence classes
+ *	are simply concatenated, except that their first
+ *	members are flagged by changing sign.
+ *
+ *	Next the indices that point into member are unsorted into
+ *	array class according to the original order of file0.
+ *
+ *	The cleverness lies in routine stone. This marches
+ *	through the lines of file0, developing a vector klist
+ *	of "k-candidates". At step i a k-candidate is a matched
+ *	pair of lines x,y (x in file0 y in file1) such that
+ *	there is a common subsequence of length k
+ *	between the first i lines of file0 and the first y
+ *	lines of file1, but there is no such subsequence for
+ *	any smaller y. x is the earliest possible mate to y
+ *	that occurs in such a subsequence.
+ *
+ *	Whenever any of the members of the equivalence class of
+ *	lines in file1 matable to a line in file0 has serial number
+ *	less than the y of some k-candidate, that k-candidate
+ *	with the smallest such y is replaced. The new
+ *	k-candidate is chained (via pred) to the current
+ *	k-1 candidate so that the actual subsequence can
+ *	be recovered. When a member has serial number greater
+ *	that the y of all k-candidates, the klist is extended.
+ *	At the end, the longest subsequence is pulled out
+ *	and placed in the array J by unravel
+ *
+ *	With J in hand, the matches there recorded are
+ *	check'ed against reality to assure that no spurious
+ *	matches have crept in due to hashing. If they have,
+ *	they are broken, and "jackpot" is recorded--a harmless
+ *	matter except that a true match for a spuriously
+ *	mated line may now be unnecessarily reported as a change.
+ *
+ *	Much of the complexity of the program comes simply
+ *	from trying to minimize core utilization and
+ *	maximize the range of doable problems by dynamically
+ *	allocating what is needed and reusing what is not.
+ *	The core requirements for problems larger than somewhat
+ *	are (in words) 2*length(file0) + length(file1) +
+ *	3*(number of k-candidates installed),  typically about
+ *	6n words for files of length n.
+ */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+
+#include <errno.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <paths.h>
+#include <regex.h>
+#include <dirent.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <string.h>
+#include <sysexits.h>
+
+#include "cvs.h"
+#include "log.h"
+#include "buf.h"
+
+
+#define CVS_DIFF_DEFCTX    3   /* default context length */
+
+
+/*
+ * Output format options
+ */
+#define	D_NORMAL	0	/* Normal output */
+#define	D_CONTEXT	1	/* Diff with context */
+#define	D_UNIFIED	2	/* Unified context diff */
+#define	D_IFDEF		3	/* Diff with merged #ifdef's */
+#define	D_BRIEF		4	/* Say if the files differ */
+
+/*
+ * Status values for print_status() and diffreg() return values
+ */
+#define	D_SAME		0	/* Files are the same */
+#define	D_DIFFER	1	/* Files are different */
+#define	D_BINARY	2	/* Binary files are different */
+#define	D_COMMON	3	/* Subdirectory common to both dirs */
+#define	D_ONLY		4	/* Only exists in one directory */
+#define	D_MISMATCH1	5	/* path1 was a dir, path2 a file */
+#define	D_MISMATCH2	6	/* path1 was a file, path2 a dir */
+#define	D_ERROR		7	/* An error occurred */
+#define	D_SKIPPED1	8	/* path1 was a special file */
+#define	D_SKIPPED2	9	/* path2 was a special file */
+
+struct cand {
+	int x;
+	int y;
+	int pred;
+} cand;
+
+struct line {
+	int serial;
+	int value;
+} *file[2];
+
+/*
+ * The following struct is used to record change information when
+ * doing a "context" or "unified" diff.  (see routine "change" to
+ * understand the highly mnemonic field names)
+ */
+struct context_vec {
+	int a;			/* start line in old file */
+	int b;			/* end line in old file */
+	int c;			/* start line in new file */
+	int d;			/* end line in new file */
+};
+
+
+struct excludes {
+	char *pattern;
+	struct excludes *next;
+};
+
+
+char	*splice(char *, char *);
+int  cvs_diffreg(const char *, const char *);
+int  cvs_diff_file  (const char *, const char *, const char *);
+int  cvs_diff_dir   (const char *, int);
+static void output(const char *, FILE *, const char *, FILE *);
+static void check(FILE *, FILE *);
+static void range(int, int, char *);
+static void uni_range(int, int);
+static void dump_context_vec(FILE *, FILE *);
+static void dump_unified_vec(FILE *, FILE *);
+static void prepare(int, FILE *, off_t);
+static void prune(void);
+static void equiv(struct line *, int, struct line *, int, int *);
+static void unravel(int);
+static void unsort(struct line *, int, int *);
+static void change(const char *, FILE *, const char *, FILE *, int, int, int, int);
+static void sort(struct line *, int);
+static int  ignoreline(char *);
+static int  asciifile(FILE *);
+static int  fetch(long *, int, int, FILE *, int, int);
+static int  newcand(int, int, int);
+static int  search(int *, int, int);
+static int  skipline(FILE *);
+static int  isqrt(int);
+static int  stone(int *, int, int *, int *);
+static int  readhash(FILE *);
+static int  files_differ(FILE *, FILE *);
+static __inline int min(int, int);
+static __inline int max(int, int);
+static char *match_function(const long *, int, FILE *);
+static char *preadline(int, size_t, off_t);
+
+
+
+extern int cvs_client;
+extern struct cvsroot *cvs_root;
+
+
+
+static int aflag, bflag, dflag, iflag, tflag, Tflag, wflag;
+static int context, status;
+static int format = D_NORMAL;
+static struct stat stb1, stb2;
+static char *ifdefname, *diffargs, *ignore_pats, *diff_file;
+regex_t ignore_re;
+
+static int  *J;			/* will be overlaid on class */
+static int  *class;		/* will be overlaid on file[0] */
+static int  *klist;		/* will be overlaid on file[0] after class */
+static int  *member;		/* will be overlaid on file[1] */
+static int   clen;
+static int   inifdef;		/* whether or not we are in a #ifdef block */
+static int   len[2];
+static int   pref, suff;	/* length of prefix and suffix */
+static int   slen[2];
+static int   anychange;
+static long *ixnew;		/* will be overlaid on file[1] */
+static long *ixold;		/* will be overlaid on klist */
+static struct cand *clist;	/* merely a free storage pot for candidates */
+static int   clistlen;		/* the length of clist */
+static struct line *sfile[2];	/* shortened by pruning common prefix/suffix */
+static u_char *chrtran;		/* translation table for case-folding */
+static struct context_vec *context_vec_start;
+static struct context_vec *context_vec_end;
+static struct context_vec *context_vec_ptr;
+
+#define FUNCTION_CONTEXT_SIZE	41
+static char lastbuf[FUNCTION_CONTEXT_SIZE];
+static int lastline;
+static int lastmatchline;
+
+
+
+
+/*
+ * chrtran points to one of 2 translation tables: cup2low if folding upper to
+ * lower case clow2low if not folding case
+ */
+u_char clow2low[256] = {
+	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
+	0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
+	0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+	0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
+	0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
+	0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41,
+	0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c,
+	0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+	0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62,
+	0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d,
+	0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+	0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83,
+	0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e,
+	0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
+	0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
+	0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+	0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba,
+	0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5,
+	0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0,
+	0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb,
+	0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6,
+	0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1,
+	0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc,
+	0xfd, 0xfe, 0xff
+};
+
+u_char cup2low[256] = {
+	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
+	0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
+	0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
+	0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b,
+	0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
+	0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x60, 0x61,
+	0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c,
+	0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+	0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x60, 0x61, 0x62,
+	0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d,
+	0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+	0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83,
+	0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e,
+	0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
+	0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
+	0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+	0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba,
+	0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5,
+	0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0,
+	0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb,
+	0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6,
+	0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1,
+	0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc,
+	0xfd, 0xfe, 0xff
+};
+
+
+
+/*
+ * cvs_diff()
+ *
+ * Handler for the `cvs diff' command.
+ *
+ * SYNOPSIS: cvs [args] diff [-clipu] [-D date] [-r rev]
+ */
+
+int
+cvs_diff(int argc, char **argv)
+{
+	int i, ch, recurse;
+	size_t dalen;
+	char dir[MAXPATHLEN], file[MAXPATHLEN], *d1, *d2, *r1, *r2;
+
+	context = CVS_DIFF_DEFCTX;
+
+	d1 = d2 = NULL;
+	r1 = r2 = NULL;
+	recurse = 1;
+
+	while ((ch = getopt(argc, argv, "cD:lir:u")) != -1) {
+		switch (ch) {
+		case 'c':
+			format = D_CONTEXT;
+			break;
+		case 'D':
+			if (d1 == NULL && r1 == NULL)
+				d1 = optarg;
+			else if (d2 == NULL && r2 == NULL)
+				d2 = optarg;
+			else {
+				cvs_log(LP_ERR,
+				    "no more than two revisions/dates can "
+				    "be specified");
+			}
+			break;
+		case 'l':
+			recurse = 0;
+			break;
+		case 'i':
+			iflag = 1;
+			break;
+		case 'r':
+			if ((r1 == NULL) && (d1 == NULL))
+				r1 = optarg;
+			else if ((r2 == NULL) && (d2 == NULL))
+				r2 = optarg;
+			else {
+				cvs_log(LP_ERR,
+				    "no more than two revisions/dates can "
+				    "be specified");
+				return (EX_USAGE);
+			}
+			break;
+		case 'u':
+			format = D_UNIFIED;
+			break;
+		default:
+			return (EX_USAGE);
+		}
+	}
+
+	argc -= optind;
+	argv += optind;
+
+	if (argc == 0) {
+		/* get the CVSROOT from current dir */
+		strlcpy(dir, ".", sizeof(dir));
+
+		cvs_root = cvsroot_get(dir);
+		if (cvs_root == NULL)
+			return (EX_USAGE);
+
+		if (cvs_root->cr_method != CVS_METHOD_LOCAL) {
+			cvs_client_connect();
+
+			/* send the flags */
+			if (format == D_CONTEXT)
+				cvs_client_sendarg("-c", 0);
+			else if (format == D_UNIFIED)
+				cvs_client_sendarg("-u", 0);
+
+			if (r1 != NULL) {
+				cvs_client_sendarg("-r", 0);
+				cvs_client_sendarg(r1, 1);
+			}
+			else if (d1 != NULL) {
+				cvs_client_sendarg("-D", 0);
+				cvs_client_sendarg(d1, 1);
+			}
+			if (r2 != NULL) {
+				cvs_client_sendarg("-r", 0);
+				cvs_client_sendarg(r2, 1);
+			}
+			else if (d2 != NULL) {
+				cvs_client_sendarg("-D", 0);
+				cvs_client_sendarg(d2, 1);
+			}
+		}
+
+		cvs_diff_dir(dir, recurse);
+	}
+	else {
+		for (i = 0; i < argc; i++) {
+			cvs_splitpath(argv[i], dir, sizeof(dir),
+			    file, sizeof(file));
+			cvs_root = cvsroot_get(dir);
+			if (cvs_root == NULL)
+				return (EX_USAGE);
+
+			if (cvs_root->cr_method != CVS_METHOD_LOCAL) {
+				cvs_client_connect();
+
+				if (i == 0) {
+					/* send the flags */
+					if (format == D_CONTEXT)
+						cvs_client_sendarg("-c", 0);
+					else if (format == D_UNIFIED)
+						cvs_client_sendarg("-u", 0);
+				}
+			}
+
+			cvs_diff_file(argv[i], r1, r2);
+		}
+	}
+
+	if (cvs_root->cr_method != CVS_METHOD_LOCAL)
+		cvs_client_sendreq(CVS_REQ_DIFF, NULL, 1);
+
+	return (0);
+}
+
+
+/*
+ * cvs_diff_file()
+ *
+ * Diff a single file.
+ */
+
+int
+cvs_diff_file(const char *path, const char *rev1, const char *rev2)
+{
+	int modif;
+	char dir[MAXPATHLEN], file[MAXPATHLEN], rcspath[MAXPATHLEN];
+	char repo[MAXPATHLEN], buf[64];
+	time_t tsec;
+	BUF *b1, *b2;
+	RCSNUM *r1, *r2;
+	RCSFILE *rf;
+	CVSENTRIES *entf;
+	struct tm tmstamp;
+	struct stat fst;
+	struct cvs_ent *entp;
+
+	rf = NULL;
+	diff_file = path;
+
+	if (stat(path, &fst) == -1) {
+		cvs_log(LP_ERRNO, "cannot find %s", path);
+		return (-1);
+	}
+
+	cvs_splitpath(path, dir, sizeof(dir), file, sizeof(file));
+	cvs_readrepo(dir, repo, sizeof(repo));
+
+	entf = cvs_ent_open(dir);
+	if (entf == NULL) {
+		cvs_log(LP_ERR, "no CVS/Entries file in `%s'", dir);
+		return (-1);
+	}
+
+	entp = cvs_ent_get(entf, file);
+	if ((entp == NULL) && (cvs_root->cr_method == CVS_METHOD_LOCAL)) {
+		cvs_log(LP_WARN, "I know nothing about %s", path);
+		return (-1);
+	}
+
+	if (cvs_root->cr_method != CVS_METHOD_LOCAL) {
+		if (cvs_client_senddir(dir) < 0)
+			return (-1);
+	}
+
+	tsec = (time_t)fst.st_mtimespec.tv_sec;
+
+	if ((gmtime_r(&tsec, &tmstamp) == NULL) ||
+	    (asctime_r(&tmstamp, buf) == NULL)) {
+		cvs_log(LP_ERR, "failed to generate file timestamp");
+		return (-1);
+	}
+	modif = (strcmp(buf, entp->ce_timestamp) == 0) ? 0 : 1;
+
+	if (cvs_root->cr_method != CVS_METHOD_LOCAL)
+		cvs_client_sendentry(entp);
+
+	if (!modif) {
+		if (cvs_root->cr_method != CVS_METHOD_LOCAL)
+			cvs_client_sendreq(CVS_REQ_UNCHANGED, file, 0);
+		cvs_ent_close(entf);
+		return (0);
+	}
+
+	/* at this point, the file is modified */
+	if (cvs_root->cr_method != CVS_METHOD_LOCAL) {
+		cvs_client_sendreq(CVS_REQ_MODIFIED, file, 0);
+		cvs_sendfile(path);
+	}
+	else {
+		snprintf(rcspath, sizeof(rcspath), "%s/%s/%s%s",
+		    cvs_root->cr_dir, repo, path, RCS_FILE_EXT);
+
+		rf = rcs_open(rcspath, RCS_MODE_READ);
+		if (rf == NULL)
+			return (-1);
+
+		printf("Index: %s\n%s\nRCS file: %s\n", path,
+		    RCS_DIFF_DIV, rcspath);
+
+		if (rev1 == NULL)
+			r1 = entp->ce_rev;
+		else {
+			r1 = rcsnum_alloc();
+			rcsnum_aton(rev1, NULL, r1);
+		}
+
+		printf("retrieving revision %s\n",
+		    rcsnum_tostr(r1, buf, sizeof(buf)));
+		b1 = rcs_getrev(rf, r1);
+
+		if (rev2 != NULL) {
+			printf("retrieving revision %s\n", rev2);
+			r2 = rcsnum_alloc();
+			rcsnum_aton(rev2, NULL, r2);
+			b2 = rcs_getrev(rf, r2);
+		}
+		else {
+			b2 = cvs_buf_load(path, BUF_AUTOEXT);
+		}
+
+		printf("%s\n", diffargs);
+		cvs_buf_write(b1, "/tmp/diff1", 0600);
+		cvs_buf_write(b2, "/tmp/diff2", 0600);
+		cvs_diffreg("/tmp/diff1", "/tmp/diff2");
+	}
+
+	cvs_ent_close(entf);
+
+	return (0);
+}
+
+
+/*
+ * cvs_diff_dir()
+ *
+ */
+
+int
+cvs_diff_dir(const char *dir, int recurse)
+{
+	char path[MAXPATHLEN];
+	DIR *dirp;
+	CVSENTRIES *entf;
+	struct dirent *dentp;
+	struct cvs_ent *entp;
+
+	printf("cvs_diff_dir(%s)\n", dir);
+
+	dirp = opendir(dir);
+	if (dirp == NULL) {
+		cvs_log(LP_ERRNO, "failed to open directory `%s'", dir);
+		return (-1);
+	}
+
+	entf = cvs_ent_open(dir);
+	if (entf == NULL) {
+		cvs_log(LP_ERR, "no CVS/Entries file in `%s'", dir);
+		(void)closedir(dirp);
+		return (-1);
+	}
+
+	while ((dentp = readdir(dirp)) != NULL) {
+		if ((strcmp(dentp->d_name, "CVS") == 0) ||
+		    (dentp->d_name[0] == '.'))
+			continue;
+
+		if (strcmp(dir, ".") != 0) {
+			strlcpy(path, dir, sizeof(path));
+			strlcat(path, "/", sizeof(path));
+		}
+		else
+			path[0] = '\0';
+		strlcat(path, dentp->d_name, sizeof(path));
+		if (dentp->d_type == DT_DIR) {
+			if (!recurse)
+				continue;
+			cvs_diff_dir(path, recurse);
+		}
+		else {
+			entp = cvs_ent_get(entf, dentp->d_name);
+			if (entp == NULL) {
+				cvs_client_sendreq(CVS_REQ_QUESTIONABLE, path,
+				    0);
+			}
+			else {
+#if 0
+				cvs_diff_file(path);
+#endif
+			}
+		}
+	}
+
+	return (0);
+}
+
+
+
+
+int
+cvs_diffreg(const char *file1, const char *file2)
+{
+	FILE *f1, *f2;
+	int i, rval;
+
+	f1 = f2 = NULL;
+	rval = D_SAME;
+	anychange = 0;
+	lastline = 0;
+	lastmatchline = 0;
+	context_vec_ptr = context_vec_start - 1;
+	chrtran = (iflag ? cup2low : clow2low);
+
+	f1 = fopen(file1, "r");
+	if (f1 == NULL) {
+		cvs_log(LP_ERRNO, "%s", file1);
+		status |= 2;
+		goto closem;
+	}
+
+	f2 = fopen(file2, "r");
+	if (f2 == NULL) {
+		cvs_log(LP_ERRNO, "%s", file2);
+		status |= 2;
+		goto closem;
+	}
+
+	switch (files_differ(f1, f2)) {
+	case 0:
+		goto closem;
+	case 1:
+		break;
+	default:
+		/* error */
+		status |= 2;
+		goto closem;
+	}
+
+	if (!asciifile(f1) || !asciifile(f2)) {
+		rval = D_BINARY;
+		status |= 1;
+		goto closem;
+	}
+	prepare(0, f1, stb1.st_size);
+	prepare(1, f2, stb2.st_size);
+	prune();
+	sort(sfile[0], slen[0]);
+	sort(sfile[1], slen[1]);
+
+	member = (int *)file[1];
+	equiv(sfile[0], slen[0], sfile[1], slen[1], member);
+	member = realloc(member, (slen[1] + 2) * sizeof(int));
+
+	class = (int *)file[0];
+	unsort(sfile[0], slen[0], class);
+	class = realloc(class, (slen[0] + 2) * sizeof(int));
+
+	klist = malloc((slen[0] + 2) * sizeof(int));
+	clen = 0;
+	clistlen = 100;
+	clist = malloc(clistlen * sizeof(cand));
+	i = stone(class, slen[0], member, klist);
+	free(member);
+	free(class);
+
+	J = realloc(J, (len[0] + 2) * sizeof(int));
+	unravel(klist[i]);
+	free(clist);
+	free(klist);
+
+	ixold = realloc(ixold, (len[0] + 2) * sizeof(long));
+	ixnew = realloc(ixnew, (len[1] + 2) * sizeof(long));
+	check(f1, f2);
+	output(file1, f1, file2, f2);
+
+closem:
+	if (anychange) {
+		status |= 1;
+		if (rval == D_SAME)
+			rval = D_DIFFER;
+	}
+	if (f1 != NULL)
+		fclose(f1);
+	if (f2 != NULL)
+		fclose(f2);
+	return (rval);
+}
+
+/*
+ * Check to see if the given files differ.
+ * Returns 0 if they are the same, 1 if different, and -1 on error.
+ * XXX - could use code from cmp(1) [faster]
+ */
+static int
+files_differ(FILE *f1, FILE *f2)
+{
+	char buf1[BUFSIZ], buf2[BUFSIZ];
+	size_t i, j;
+
+	if (stb1.st_size != stb2.st_size)
+		return (1);
+	for (;;) {
+		i = fread(buf1, 1, sizeof(buf1), f1);
+		j = fread(buf2, 1, sizeof(buf2), f2);
+		if (i != j)
+			return (1);
+		if (i == 0 && j == 0) {
+			if (ferror(f1) || ferror(f2))
+				return (1);
+			return (0);
+		}
+		if (memcmp(buf1, buf2, i) != 0)
+			return (1);
+	}
+}
+
+
+char *
+splice(char *dir, char *file)
+{
+	char *tail, *buf;
+
+	if ((tail = strrchr(file, '/')) == NULL)
+		tail = file;
+	else
+		tail++;
+	asprintf(&buf, "%s/%s", dir, tail);
+	return (buf);
+}
+
+static void
+prepare(int i, FILE *fd, off_t filesize)
+{
+	struct line *p;
+	int j, h;
+	size_t sz;
+
+	rewind(fd);
+
+	sz = (filesize <= SIZE_MAX ? filesize : SIZE_MAX) / 25;
+	if (sz < 100)
+		sz = 100;
+
+	p = malloc((sz + 3) * sizeof(struct line));
+	for (j = 0; (h = readhash(fd));) {
+		if (j == (int)sz) {
+			sz = sz * 3 / 2;
+			p = realloc(p, (sz + 3) * sizeof(struct line));
+		}
+		p[++j].value = h;
+	}
+	len[i] = j;
+	file[i] = p;
+}
+
+static void
+prune(void)
+{
+	int i, j;
+
+	for (pref = 0; pref < len[0] && pref < len[1] &&
+	    file[0][pref + 1].value == file[1][pref + 1].value;
+	    pref++)
+		;
+	for (suff = 0; suff < len[0] - pref && suff < len[1] - pref &&
+	    file[0][len[0] - suff].value == file[1][len[1] - suff].value;
+	    suff++)
+		;
+	for (j = 0; j < 2; j++) {
+		sfile[j] = file[j] + pref;
+		slen[j] = len[j] - pref - suff;
+		for (i = 0; i <= slen[j]; i++)
+			sfile[j][i].serial = i;
+	}
+}
+
+static void
+equiv(struct line *a, int n, struct line *b, int m, int *c)
+{
+	int i, j;
+
+	i = j = 1;
+	while (i <= n && j <= m) {
+		if (a[i].value < b[j].value)
+			a[i++].value = 0;
+		else if (a[i].value == b[j].value)
+			a[i++].value = j;
+		else
+			j++;
+	}
+	while (i <= n)
+		a[i++].value = 0;
+	b[m + 1].value = 0;
+	j = 0;
+	while (++j <= m) {
+		c[j] = -b[j].serial;
+		while (b[j + 1].value == b[j].value) {
+			j++;
+			c[j] = b[j].serial;
+		}
+	}
+	c[j] = -1;
+}
+
+/* Code taken from ping.c */
+static int
+isqrt(int n)
+{
+	int y, x = 1;
+
+	if (n == 0)
+		return(0);
+
+	do { /* newton was a stinker */
+		y = x;
+		x = n / x;
+		x += y;
+		x /= 2;
+	} while ((x - y) > 1 || (x - y) < -1);
+
+	return (x);
+}
+
+static int
+stone(int *a, int n, int *b, int *c)
+{
+	int i, k, y, j, l;
+	int oldc, tc, oldl;
+	u_int numtries;
+
+	const u_int bound = dflag ? UINT_MAX : max(256, isqrt(n));
+
+	k = 0;
+	c[0] = newcand(0, 0, 0);
+	for (i = 1; i <= n; i++) {
+		j = a[i];
+		if (j == 0)
+			continue;
+		y = -b[j];
+		oldl = 0;
+		oldc = c[0];
+		numtries = 0;
+		do {
+			if (y <= clist[oldc].y)
+				continue;
+			l = search(c, k, y);
+			if (l != oldl + 1)
+				oldc = c[l - 1];
+			if (l <= k) {
+				if (clist[c[l]].y <= y)
+					continue;
+				tc = c[l];
+				c[l] = newcand(i, y, oldc);
+				oldc = tc;
+				oldl = l;
+				numtries++;
+			} else {
+				c[l] = newcand(i, y, oldc);
+				k++;
+				break;
+			}
+		} while ((y = b[++j]) > 0 && numtries < bound);
+	}
+	return (k);
+}
+
+static int
+newcand(int x, int y, int pred)
+{
+	struct cand *q;
+
+	if (clen == clistlen) {
+		clistlen = clistlen * 11 / 10;
+		clist = realloc(clist, clistlen * sizeof(cand));
+	}
+	q = clist + clen;
+	q->x = x;
+	q->y = y;
+	q->pred = pred;
+	return (clen++);
+}
+
+static int
+search(int *c, int k, int y)
+{
+	int i, j, l, t;
+
+	if (clist[c[k]].y < y)	/* quick look for typical case */
+		return (k + 1);
+	i = 0;
+	j = k + 1;
+	while (1) {
+		l = i + j;
+		if ((l >>= 1) <= i)
+			break;
+		t = clist[c[l]].y;
+		if (t > y)
+			j = l;
+		else if (t < y)
+			i = l;
+		else
+			return (l);
+	}
+	return (l + 1);
+}
+
+static void
+unravel(int p)
+{
+	struct cand *q;
+	int i;
+
+	for (i = 0; i <= len[0]; i++)
+		J[i] = i <= pref ? i :
+		    i > len[0] - suff ? i + len[1] - len[0] : 0;
+	for (q = clist + p; q->y != 0; q = clist + q->pred)
+		J[q->x + pref] = q->y + pref;
+}
+
+/*
+ * Check does double duty:
+ *  1.	ferret out any fortuitous correspondences due
+ *	to confounding by hashing (which result in "jackpot")
+ *  2.  collect random access indexes to the two files
+ */
+static void
+check(FILE *f1, FILE *f2)
+{
+	int i, j, jackpot, c, d;
+	long ctold, ctnew;
+
+	rewind(f1);
+	rewind(f2);
+	j = 1;
+	ixold[0] = ixnew[0] = 0;
+	jackpot = 0;
+	ctold = ctnew = 0;
+	for (i = 1; i <= len[0]; i++) {
+		if (J[i] == 0) {
+			ixold[i] = ctold += skipline(f1);
+			continue;
+		}
+		while (j < J[i]) {
+			ixnew[j] = ctnew += skipline(f2);
+			j++;
+		}
+		if (bflag || wflag || iflag) {
+			for (;;) {
+				c = getc(f1);
+				d = getc(f2);
+				/*
+				 * GNU diff ignores a missing newline
+				 * in one file if bflag || wflag.
+				 */
+				if ((bflag || wflag) &&
+				    ((c == EOF && d == '\n') ||
+				    (c == '\n' && d == EOF))) {
+					break;
+				}
+				ctold++;
+				ctnew++;
+				if (bflag && isspace(c) && isspace(d)) {
+					do {
+						if (c == '\n')
+							break;
+						ctold++;
+					} while (isspace(c = getc(f1)));
+					do {
+						if (d == '\n')
+							break;
+						ctnew++;
+					} while (isspace(d = getc(f2)));
+				} else if (wflag) {
+					while (isspace(c) && c != '\n') {
+						c = getc(f1);
+						ctold++;
+					}
+					while (isspace(d) && d != '\n') {
+						d = getc(f2);
+						ctnew++;
+					}
+				}
+				if (chrtran[c] != chrtran[d]) {
+					jackpot++;
+					J[i] = 0;
+					if (c != '\n' && c != EOF)
+						ctold += skipline(f1);
+					if (d != '\n' && c != EOF)
+						ctnew += skipline(f2);
+					break;
+				}
+				if (c == '\n' || c == EOF)
+					break;
+			}
+		} else {
+			for (;;) {
+				ctold++;
+				ctnew++;
+				if ((c = getc(f1)) != (d = getc(f2))) {
+					/* jackpot++; */
+					J[i] = 0;
+					if (c != '\n' && c != EOF)
+						ctold += skipline(f1);
+					if (d != '\n' && c != EOF)
+						ctnew += skipline(f2);
+					break;
+				}
+				if (c == '\n' || c == EOF)
+					break;
+			}
+		}
+		ixold[i] = ctold;
+		ixnew[j] = ctnew;
+		j++;
+	}
+	for (; j <= len[1]; j++)
+		ixnew[j] = ctnew += skipline(f2);
+	/*
+	 * if (jackpot)
+	 *	fprintf(stderr, "jackpot\n");
+	 */
+}
+
+/* shellsort CACM #201 */
+static void
+sort(struct line *a, int n)
+{
+	struct line *ai, *aim, w;
+	int j, m = 0, k;
+
+	if (n == 0)
+		return;
+	for (j = 1; j <= n; j *= 2)
+		m = 2 * j - 1;
+	for (m /= 2; m != 0; m /= 2) {
+		k = n - m;
+		for (j = 1; j <= k; j++) {
+			for (ai = &a[j]; ai > a; ai -= m) {
+				aim = &ai[m];
+				if (aim < ai)
+					break;	/* wraparound */
+				if (aim->value > ai[0].value ||
+				    (aim->value == ai[0].value &&
+					aim->serial > ai[0].serial))
+					break;
+				w.value = ai[0].value;
+				ai[0].value = aim->value;
+				aim->value = w.value;
+				w.serial = ai[0].serial;
+				ai[0].serial = aim->serial;
+				aim->serial = w.serial;
+			}
+		}
+	}
+}
+
+static void
+unsort(struct line *f, int l, int *b)
+{
+	int *a, i;
+
+	a = malloc((l + 1) * sizeof(int));
+	for (i = 1; i <= l; i++)
+		a[f[i].serial] = f[i].value;
+	for (i = 1; i <= l; i++)
+		b[i] = a[i];
+	free(a);
+}
+
+static int
+skipline(FILE *f)
+{
+	int i, c;
+
+	for (i = 1; (c = getc(f)) != '\n' && c != EOF; i++)
+		continue;
+	return (i);
+}
+
+static void
+output(const char *file1, FILE *f1, const char *file2, FILE *f2)
+{
+	int m, i0, i1, j0, j1;
+
+	rewind(f1);
+	rewind(f2);
+	m = len[0];
+	J[0] = 0;
+	J[m + 1] = len[1] + 1;
+	for (i0 = 1; i0 <= m; i0 = i1 + 1) {
+		while (i0 <= m && J[i0] == J[i0 - 1] + 1)
+			i0++;
+		j0 = J[i0 - 1] + 1;
+		i1 = i0 - 1;
+		while (i1 < m && J[i1 + 1] == 0)
+			i1++;
+		j1 = J[i1 + 1] - 1;
+		J[i1] = j1;
+		change(file1, f1, file2, f2, i0, i1, j0, j1);
+	}
+	if (m == 0)
+		change(file1, f1, file2, f2, 1, 0, 1, len[1]);
+	if (format == D_IFDEF) {
+		for (;;) {
+#define	c i0
+			if ((c = getc(f1)) == EOF)
+				return;
+			putchar(c);
+		}
+#undef c
+	}
+	if (anychange != 0) {
+		if (format == D_CONTEXT)
+			dump_context_vec(f1, f2);
+		else if (format == D_UNIFIED)
+			dump_unified_vec(f1, f2);
+	}
+}
+
+static __inline void
+range(int a, int b, char *separator)
+{
+	printf("%d", a > b ? b : a);
+	if (a < b)
+		printf("%s%d", separator, b);
+}
+
+static __inline void
+uni_range(int a, int b)
+{
+	if (a < b)
+		printf("%d,%d", a, b - a + 1);
+	else if (a == b)
+		printf("%d", b);
+	else
+		printf("%d,0", b);
+}
+
+static char *
+preadline(int fd, size_t len, off_t off)
+{
+	char *line;
+	ssize_t nr;
+
+	line = malloc(len + 1);
+	if (line == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate line");
+		return (NULL);
+	}
+	if ((nr = pread(fd, line, len, off)) < 0) {
+		cvs_log(LP_ERRNO, "preadline failed");
+		return (NULL);
+	}
+	line[nr] = '\0';
+	return (line);
+}
+
+static int
+ignoreline(char *line)
+{
+	int ret;
+
+	ret = regexec(&ignore_re, line, 0, NULL, 0);
+	free(line);
+	return (ret == 0);	/* if it matched, it should be ignored. */
+}
+
+/*
+ * Indicate that there is a difference between lines a and b of the from file
+ * to get to lines c to d of the to file.  If a is greater then b then there
+ * are no lines in the from file involved and this means that there were
+ * lines appended (beginning at b).  If c is greater than d then there are
+ * lines missing from the to file.
+ */
+static void
+change(const char *file1, FILE *f1, const char *file2, FILE *f2,
+	int a, int b, int c, int d)
+{
+	static size_t max_context = 64;
+	int i;
+
+	if (format != D_IFDEF && a > b && c > d)
+		return;
+	if (ignore_pats != NULL) {
+		char *line;
+		/*
+		 * All lines in the change, insert, or delete must
+		 * match an ignore pattern for the change to be
+		 * ignored.
+		 */
+		if (a <= b) {		/* Changes and deletes. */
+			for (i = a; i <= b; i++) {
+				line = preadline(fileno(f1),
+				    ixold[i] - ixold[i - 1], ixold[i - 1]);
+				if (!ignoreline(line))
+					goto proceed;
+			}
+		}
+		if (a > b || c <= d) {	/* Changes and inserts. */
+			for (i = c; i <= d; i++) {
+				line = preadline(fileno(f2),
+				    ixnew[i] - ixnew[i - 1], ixnew[i - 1]);
+				if (!ignoreline(line))
+					goto proceed;
+			}
+		}
+		return;
+	}
+proceed:
+	if (format == D_CONTEXT || format == D_UNIFIED) {
+		/*
+		 * Allocate change records as needed.
+		 */
+		if (context_vec_ptr == context_vec_end - 1) {
+			ptrdiff_t offset = context_vec_ptr - context_vec_start;
+			max_context <<= 1;
+			context_vec_start = realloc(context_vec_start,
+			    max_context * sizeof(struct context_vec));
+			context_vec_end = context_vec_start + max_context;
+			context_vec_ptr = context_vec_start + offset;
+		}
+		if (anychange == 0) {
+			/*
+			 * Print the context/unidiff header first time through.
+			 */
+			printf("%s %s	%s",
+			    format == D_CONTEXT ? "***" : "---", diff_file,
+			    ctime(&stb1.st_mtime));
+			printf("%s %s	%s",
+			    format == D_CONTEXT ? "---" : "+++", diff_file,
+			    ctime(&stb2.st_mtime));
+			anychange = 1;
+		} else if (a > context_vec_ptr->b + (2 * context) + 1 &&
+		    c > context_vec_ptr->d + (2 * context) + 1) {
+			/*
+			 * If this change is more than 'context' lines from the
+			 * previous change, dump the record and reset it.
+			 */
+			if (format == D_CONTEXT)
+				dump_context_vec(f1, f2);
+			else
+				dump_unified_vec(f1, f2);
+		}
+		context_vec_ptr++;
+		context_vec_ptr->a = a;
+		context_vec_ptr->b = b;
+		context_vec_ptr->c = c;
+		context_vec_ptr->d = d;
+		return;
+	}
+	if (anychange == 0)
+		anychange = 1;
+	switch (format) {
+	case D_BRIEF:
+		return;
+	case D_NORMAL:
+		range(a, b, ",");
+		putchar(a > b ? 'a' : c > d ? 'd' : 'c');
+		if (format == D_NORMAL)
+			range(c, d, ",");
+		putchar('\n');
+		break;
+	}
+	if (format == D_NORMAL || format == D_IFDEF) {
+		fetch(ixold, a, b, f1, '<', 1);
+		if (a <= b && c <= d && format == D_NORMAL)
+			puts("---");
+	}
+	i = fetch(ixnew, c, d, f2, format == D_NORMAL ? '>' : '\0', 0);
+	if (inifdef) {
+		printf("#endif /* %s */\n", ifdefname);
+		inifdef = 0;
+	}
+}
+
+static int
+fetch(long *f, int a, int b, FILE *lb, int ch, int oldfile)
+{
+	int i, j, c, lastc, col, nc;
+
+	/*
+	 * When doing #ifdef's, copy down to current line
+	 * if this is the first file, so that stuff makes it to output.
+	 */
+	if (format == D_IFDEF && oldfile) {
+		long curpos = ftell(lb);
+		/* print through if append (a>b), else to (nb: 0 vs 1 orig) */
+		nc = f[a > b ? b : a - 1] - curpos;
+		for (i = 0; i < nc; i++)
+			putchar(getc(lb));
+	}
+	if (a > b)
+		return (0);
+	if (format == D_IFDEF) {
+		if (inifdef) {
+			printf("#else /* %s%s */\n",
+			    oldfile == 1 ? "!" : "", ifdefname);
+		} else {
+			if (oldfile)
+				printf("#ifndef %s\n", ifdefname);
+			else
+				printf("#ifdef %s\n", ifdefname);
+		}
+		inifdef = 1 + oldfile;
+	}
+	for (i = a; i <= b; i++) {
+		fseek(lb, f[i - 1], SEEK_SET);
+		nc = f[i] - f[i - 1];
+		if (format != D_IFDEF && ch != '\0') {
+			putchar(ch);
+			if (Tflag && (format == D_NORMAL || format == D_CONTEXT
+			    || format == D_UNIFIED))
+				putchar('\t');
+			else if (format != D_UNIFIED)
+				putchar(' ');
+		}
+		col = 0;
+		for (j = 0, lastc = '\0'; j < nc; j++, lastc = c) {
+			if ((c = getc(lb)) == EOF) {
+				puts("\n\\ No newline at end of file");
+				return (0);
+			}
+			if (c == '\t' && tflag) {
+				do {
+					putchar(' ');
+				} while (++col & 7);
+			} else {
+				putchar(c);
+				col++;
+			}
+		}
+	}
+	return (0);
+}
+
+/*
+ * Hash function taken from Robert Sedgewick, Algorithms in C, 3d ed., p 578.
+ */
+static int
+readhash(FILE *f)
+{
+	int i, t, space;
+	int sum;
+
+	sum = 1;
+	space = 0;
+	if (!bflag && !wflag) {
+		if (iflag)
+			for (i = 0; (t = getc(f)) != '\n'; i++) {
+				if (t == EOF) {
+					if (i == 0)
+						return (0);
+					break;
+				}
+				sum = sum * 127 + chrtran[t];
+			}
+		else
+			for (i = 0; (t = getc(f)) != '\n'; i++) {
+				if (t == EOF) {
+					if (i == 0)
+						return (0);
+					break;
+				}
+				sum = sum * 127 + t;
+			}
+	} else {
+		for (i = 0;;) {
+			switch (t = getc(f)) {
+			case '\t':
+			case ' ':
+				space++;
+				continue;
+			default:
+				if (space && !wflag) {
+					i++;
+					space = 0;
+				}
+				sum = sum * 127 + chrtran[t];
+				i++;
+				continue;
+			case EOF:
+				if (i == 0)
+					return (0);
+				/* FALLTHROUGH */
+			case '\n':
+				break;
+			}
+			break;
+		}
+	}
+	/*
+	 * There is a remote possibility that we end up with a zero sum.
+	 * Zero is used as an EOF marker, so return 1 instead.
+	 */
+	return (sum == 0 ? 1 : sum);
+}
+
+static int
+asciifile(FILE *f)
+{
+	char buf[BUFSIZ];
+	int i, cnt;
+
+	if (aflag || f == NULL)
+		return (1);
+
+	rewind(f);
+	cnt = fread(buf, 1, sizeof(buf), f);
+	for (i = 0; i < cnt; i++)
+		if (!isprint(buf[i]) && !isspace(buf[i]))
+			return (0);
+	return (1);
+}
+
+static __inline int min(int a, int b)
+{
+	return (a < b ? a : b);
+}
+
+static __inline int max(int a, int b)
+{
+	return (a > b ? a : b);
+}
+
+static char *
+match_function(const long *f, int pos, FILE *file)
+{
+	char buf[FUNCTION_CONTEXT_SIZE];
+	size_t nc;
+	int last = lastline;
+	char *p;
+
+	lastline = pos;
+	while (pos > last) {
+		fseek(file, f[pos - 1], SEEK_SET);
+		nc = f[pos] - f[pos - 1];
+		if (nc >= sizeof(buf))
+			nc = sizeof(buf) - 1;
+		nc = fread(buf, 1, nc, file);
+		if (nc > 0) {
+			buf[nc] = '\0';
+			p = strchr(buf, '\n');
+			if (p != NULL)
+				*p = '\0';
+			if (isalpha(buf[0]) || buf[0] == '_' || buf[0] == '$') {
+				strlcpy(lastbuf, buf, sizeof lastbuf);
+				lastmatchline = pos;
+				return lastbuf;
+			}
+		}
+		pos--;
+	}
+	return lastmatchline > 0 ? lastbuf : NULL;
+}
+
+/* dump accumulated "context" diff changes */
+static void
+dump_context_vec(FILE *f1, FILE *f2)
+{
+	struct context_vec *cvp = context_vec_start;
+	int lowa, upb, lowc, upd, do_output;
+	int a, b, c, d;
+	char ch, *f;
+
+	if (context_vec_start > context_vec_ptr)
+		return;
+
+	b = d = 0;		/* gcc */
+	lowa = max(1, cvp->a - context);
+	upb = min(len[0], context_vec_ptr->b + context);
+	lowc = max(1, cvp->c - context);
+	upd = min(len[1], context_vec_ptr->d + context);
+
+	printf("***************");
+	printf("\n*** ");
+	range(lowa, upb, ",");
+	printf(" ****\n");
+
+	/*
+	 * Output changes to the "old" file.  The first loop suppresses
+	 * output if there were no changes to the "old" file (we'll see
+	 * the "old" lines as context in the "new" list).
+	 */
+	do_output = 0;
+	for (; cvp <= context_vec_ptr; cvp++)
+		if (cvp->a <= cvp->b) {
+			cvp = context_vec_start;
+			do_output++;
+			break;
+		}
+	if (do_output) {
+		while (cvp <= context_vec_ptr) {
+			a = cvp->a;
+			b = cvp->b;
+			c = cvp->c;
+			d = cvp->d;
+
+			if (a <= b && c <= d)
+				ch = 'c';
+			else
+				ch = (a <= b) ? 'd' : 'a';
+
+			if (ch == 'a')
+				fetch(ixold, lowa, b, f1, ' ', 0);
+			else {
+				fetch(ixold, lowa, a - 1, f1, ' ', 0);
+				fetch(ixold, a, b, f1,
+				    ch == 'c' ? '!' : '-', 0);
+			}
+			lowa = b + 1;
+			cvp++;
+		}
+		fetch(ixold, b + 1, upb, f1, ' ', 0);
+	}
+	/* output changes to the "new" file */
+	printf("--- ");
+	range(lowc, upd, ",");
+	printf(" ----\n");
+
+	do_output = 0;
+	for (cvp = context_vec_start; cvp <= context_vec_ptr; cvp++)
+		if (cvp->c <= cvp->d) {
+			cvp = context_vec_start;
+			do_output++;
+			break;
+		}
+	if (do_output) {
+		while (cvp <= context_vec_ptr) {
+			a = cvp->a;
+			b = cvp->b;
+			c = cvp->c;
+			d = cvp->d;
+
+			if (a <= b && c <= d)
+				ch = 'c';
+			else
+				ch = (a <= b) ? 'd' : 'a';
+
+			if (ch == 'd')
+				fetch(ixnew, lowc, d, f2, ' ', 0);
+			else {
+				fetch(ixnew, lowc, c - 1, f2, ' ', 0);
+				fetch(ixnew, c, d, f2,
+				    ch == 'c' ? '!' : '+', 0);
+			}
+			lowc = d + 1;
+			cvp++;
+		}
+		fetch(ixnew, d + 1, upd, f2, ' ', 0);
+	}
+	context_vec_ptr = context_vec_start - 1;
+}
+
+/* dump accumulated "unified" diff changes */
+static void
+dump_unified_vec(FILE *f1, FILE *f2)
+{
+	struct context_vec *cvp = context_vec_start;
+	int lowa, upb, lowc, upd;
+	int a, b, c, d;
+	char ch, *f;
+
+	if (context_vec_start > context_vec_ptr)
+		return;
+
+	b = d = 0;		/* gcc */
+	lowa = max(1, cvp->a - context);
+	upb = min(len[0], context_vec_ptr->b + context);
+	lowc = max(1, cvp->c - context);
+	upd = min(len[1], context_vec_ptr->d + context);
+
+	fputs("@@ -", stdout);
+	uni_range(lowa, upb);
+	fputs(" +", stdout);
+	uni_range(lowc, upd);
+	fputs(" @@", stdout);
+	putchar('\n');
+
+	/*
+	 * Output changes in "unified" diff format--the old and new lines
+	 * are printed together.
+	 */
+	for (; cvp <= context_vec_ptr; cvp++) {
+		a = cvp->a;
+		b = cvp->b;
+		c = cvp->c;
+		d = cvp->d;
+
+		/*
+		 * c: both new and old changes
+		 * d: only changes in the old file
+		 * a: only changes in the new file
+		 */
+		if (a <= b && c <= d)
+			ch = 'c';
+		else
+			ch = (a <= b) ? 'd' : 'a';
+
+		switch (ch) {
+		case 'c':
+			fetch(ixold, lowa, a - 1, f1, ' ', 0);
+			fetch(ixold, a, b, f1, '-', 0);
+			fetch(ixnew, c, d, f2, '+', 0);
+			break;
+		case 'd':
+			fetch(ixold, lowa, a - 1, f1, ' ', 0);
+			fetch(ixold, a, b, f1, '-', 0);
+			break;
+		case 'a':
+			fetch(ixnew, lowc, c - 1, f2, ' ', 0);
+			fetch(ixnew, c, d, f2, '+', 0);
+			break;
+		}
+		lowa = b + 1;
+		lowc = d + 1;
+	}
+	fetch(ixnew, d + 1, upd, f2, ' ', 0);
+
+	context_vec_ptr = context_vec_start - 1;
+}
diff --git a/usr.bin/cvs/entries.c b/usr.bin/cvs/entries.c
new file mode 100644
index 00000000000..033eb59518e
--- /dev/null
+++ b/usr.bin/cvs/entries.c
@@ -0,0 +1,263 @@
+/*	$OpenBSD: entries.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "log.h"
+#include "cvs.h"
+
+
+#define CVS_ENTRIES_NFIELDS  5
+#define CVS_ENTRIES_DELIM   '/'
+
+
+/*
+ * cvs_ent_open()
+ *
+ * Open the CVS Entries file for the directory <dir>.
+ * Returns a pointer to the CVSENTRIES file structure on success, or NULL
+ * on failure.
+ */
+
+CVSENTRIES*
+cvs_ent_open(const char *dir)
+{
+	size_t len;
+	char entpath[MAXPATHLEN], ebuf[128];
+	FILE *fp;
+	struct cvs_ent *ent;
+	CVSENTRIES *ep;
+
+	snprintf(entpath, sizeof(entpath), "%s/" CVS_PATH_ENTRIES, dir);
+	fp = fopen(entpath, "r");
+	if (fp == NULL) {
+		cvs_log(LP_ERRNO, "cannot open CVS/Entries for reading",
+		    entpath);
+		return (NULL);
+	}
+
+	ep = (CVSENTRIES *)malloc(sizeof(CVSENTRIES));
+	if (ep == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate Entries data");
+		(void)fclose(fp);
+		return (NULL);
+	}
+	ep->cef_path = strdup(dir);
+	if (ep->cef_path == NULL) {
+		cvs_log(LP_ERRNO, "failed to copy Entries path");
+		free(ep);
+		(void)fclose(fp);
+		return (NULL);
+	}
+
+	ep->cef_nid = 0;
+	ep->cef_entries = NULL;
+	ep->cef_nbent = 0;
+
+	while (fgets(ebuf, sizeof(ebuf), fp) != NULL) {
+		len = strlen(ebuf);
+		if ((len > 0) && (ebuf[len - 1] == '\n'))
+			ebuf[--len] = '\0';
+		ent = cvs_ent_parse(ebuf);
+		if (ent == NULL)
+			continue;
+
+		if (cvs_ent_add(ep, ent) < 0) {
+			cvs_ent_close(ep);
+			ep = NULL;
+			break;
+		}
+	}
+
+	(void)fclose(fp);
+	return (ep);
+}
+
+
+/*
+ * cvs_ent_close()
+ *
+ * Close the Entries file <ep>.
+ */
+
+void
+cvs_ent_close(CVSENTRIES *ep)
+{
+	free(ep);
+}
+
+
+/*
+ * cvs_ent_add()
+ *
+ * Add the entry <ent>
+ */
+
+int
+cvs_ent_add(CVSENTRIES *ef, struct cvs_ent *ent)
+{
+	void *tmp;
+	struct cvs_ent *entp;
+
+	if (cvs_ent_get(ef, ent->ce_name) != NULL)
+		return (-1);
+
+	entp = cvs_ent_parse(ent->ce_line);
+	if (entp == NULL) {
+		return (-1);
+	}
+
+	tmp = realloc(ef->cef_entries, (ef->cef_nbent + 1) * sizeof(entp));
+	if (tmp == NULL) {
+		cvs_log(LP_ERRNO, "failed to resize entries buffer");
+		return (-1);
+	}
+
+	ef->cef_entries = (struct cvs_ent **)tmp;
+	ef->cef_entries[ef->cef_nbent++] = entp;
+
+	return (0);
+}
+
+
+/*
+ * cvs_ent_get()
+ *
+ * Get the CVS entry from the Entries file <ef> whose 'name' portion matches
+ * <file>.
+ * Returns a pointer to the cvs entry structure on success, or NULL on failure.
+ */
+
+struct cvs_ent*
+cvs_ent_get(CVSENTRIES *ef, const char *file)
+{
+	u_int i;
+
+	for (i = 0; i < ef->cef_nbent; i++) {
+		if (strcmp(ef->cef_entries[i]->ce_name, file) == 0)
+			return ef->cef_entries[i]; 
+	}
+
+	return (NULL);
+}
+
+
+/*
+ * cvs_ent_next()
+ *
+ * Returns a pointer to the cvs entry structure on success, or NULL on failure.
+ */
+
+struct cvs_ent*
+cvs_ent_next(CVSENTRIES *ef)
+{
+	if (ef->cef_nid >= ef->cef_nbent)
+		return (NULL);
+
+	return (ef->cef_entries[ef->cef_nid++]);
+}
+
+
+/*
+ * cvs_ent_parse()
+ *
+ * Parse a single line from a CVS/Entries file and return a cvs_entry structure
+ * containing all the parsed information.
+ */
+
+struct cvs_ent*
+cvs_ent_parse(const char *entry)
+{
+	int i;
+	char *fields[CVS_ENTRIES_NFIELDS], *sp, *dp;
+	struct cvs_ent *entp;
+
+	entp = (struct cvs_ent *)malloc(sizeof(*entp));
+	if (entp == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate CVS entry");
+		return (NULL);
+	}
+
+	entp->ce_rev = rcsnum_alloc();
+	if (entp->ce_rev == NULL) {
+		free(entp);
+		return (NULL);
+	}
+
+	entp->ce_line = strdup(entry);
+	if (entp->ce_line == NULL) {
+		free(entp);
+		return (NULL);
+	}
+
+	entp->ce_buf = strdup(entry);
+	if (entp->ce_buf == NULL) {
+		free(entp->ce_line);
+		free(entp);
+		return (NULL);
+	}
+	sp = entp->ce_buf;
+
+	if (*sp == CVS_ENTRIES_DELIM)
+		entp->ce_type = CVS_ENT_FILE;
+	else if (*sp == 'D') {
+		entp->ce_type = CVS_ENT_DIR;
+		sp++;
+	}
+	else {
+		/* unknown entry, ignore for future expansion */
+		entp->ce_type = CVS_ENT_NONE;
+		sp++;
+	}
+
+	sp++;
+	i = 0;
+	do {
+		dp = strchr(sp, CVS_ENTRIES_DELIM);
+		if (dp != NULL)
+			*(dp++) = '\0';
+		fields[i++] = sp;
+		sp = dp;
+	} while ((dp != NULL) && (i < CVS_ENTRIES_NFIELDS));
+
+	entp->ce_name = fields[0];
+
+	if (entp->ce_type == CVS_ENT_FILE) {
+		rcsnum_aton(fields[1], NULL, entp->ce_rev);
+		entp->ce_timestamp = fields[2];
+		entp->ce_opts = fields[3];
+		entp->ce_tag = fields[4];
+	}
+
+	return (entp);
+}
diff --git a/usr.bin/cvs/event.h b/usr.bin/cvs/event.h
new file mode 100644
index 00000000000..f70896b8c5e
--- /dev/null
+++ b/usr.bin/cvs/event.h
@@ -0,0 +1,69 @@
+/*	$OpenBSD: event.h,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#ifndef EVENT_H
+#define EVENT_H
+
+#include <sys/types.h>
+#include <sys/queue.h>
+#include <sys/time.h>
+
+#include <pwd.h>
+
+
+
+#define CVS_EVENT_ADD         1
+#define CVS_EVENT_ANNOTATE    2
+#define CVS_EVENT_CHECKOUT    3
+#define CVS_EVENT_COMMIT      4
+#define CVS_EVENT_DIFF        5
+#define CVS_EVENT_HISTORY     6
+#define CVS_EVENT_IMPORT      7
+#define CVS_EVENT_REMOVE      8
+#define CVS_EVENT_UPDATE      9
+#define CVS_EVENT_TAG        10
+
+
+struct cvs_file {
+	char                 *cf_path;  /* path relative to the module */
+	LIST_ENTRY(cvs_file)  cf_list;
+};
+
+
+
+
+struct cvs_event {
+	u_int          ev_type;
+	uid_t          ev_user;
+	struct timeval ev_time;
+
+	char          *ev_branch;
+
+	LIST_HEAD(, cvs_file) ev_files;   /* files affected by this event */
+};
+
+
+#endif /* EVENT_H */
diff --git a/usr.bin/cvs/getlog.c b/usr.bin/cvs/getlog.c
new file mode 100644
index 00000000000..e36a9fbc7eb
--- /dev/null
+++ b/usr.bin/cvs/getlog.c
@@ -0,0 +1,148 @@
+/*	$OpenBSD: getlog.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/param.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <paths.h>
+#include <sysexits.h>
+
+#include "cvs.h"
+#include "log.h"
+#include "rcs.h"
+#include "sock.h"
+
+
+#define CVS_GLOG_RFONLY    0x01
+#define CVS_GLOG_HDONLY    0x02
+
+
+#define CVS_GETLOG_REVSEP   "----------------------------"
+#define CVS_GETLOG_REVEND \
+ "============================================================================="
+
+static void cvs_getlog_print   (const char *, RCSFILE *, u_int);
+
+
+
+extern struct cvsroot *cvs_root;
+
+
+/*
+ * cvs_getlog()
+ *
+ * Implement the `cvs log' command.
+ */
+
+int
+cvs_getlog(int argc, char **argv)
+{
+	int i, rfonly, honly, recurse;
+	u_int flags;
+	char rcspath[MAXPATHLEN];
+	RCSFILE *rfp;
+
+	rfonly = 0;
+	honly = 0;
+	recurse = 1;
+
+	while ((i = getopt(argc, argv, "d:hlRr:")) != -1) {
+		switch (i) {
+		case 'd':
+			break;
+		case 'h':
+			honly = 1;
+			break;
+		case 'l':
+			recurse = 0;
+			break;
+		case 'R':
+			rfonly = 1;
+			break;
+		case 'r':
+			break;
+		default:
+			return (EX_USAGE);
+		}
+	}
+
+	argc -= optind;
+	argv += optind;
+
+	for (i = 0; i < argc; i++) {
+		rfp = NULL;
+#if 0
+		if (cvs_root->cr_method == CVS_METHOD_LOCCAL) {
+			snprintf(rcspath, sizeof(rcspath), "%s/%s/%s%s",
+			    cvs_root->cr_dir, argv[i], RCS_FILE_EXT);
+
+			rfp = rcs_open(rcspath, RCS_MODE_READ);
+			if (rfp == NULL)
+				continue;
+		}
+#endif
+
+		cvs_getlog_print(argv[i], rfp, 0);
+	}
+
+	return (0);
+}
+
+
+static void
+cvs_getlog_print(const char *file, RCSFILE *rfp, u_int flags)
+{
+	char numbuf[64], datebuf[64], *sp;
+	struct rcs_delta *rdp;
+
+	printf("RCS file: %s\nWorking file: %s\n",
+	    rfp->rf_path, file);
+	printf("Working file: %s\n", NULL);
+	printf("head: %s\nbranch:\nlocks:\naccess list:\n");
+	printf("symbolic names:\nkeyword substitutions:\n");
+	printf("total revisions: %u;\tselected revisions: %u\n", 1, 1);
+
+	printf("description:\n");
+
+	for (;;) {
+		printf(CVS_GETLOG_REVSEP "\n");
+		rcsnum_tostr(&(rdp->rd_num), numbuf, sizeof(numbuf));
+		printf("revision %s\n", numbuf);
+		printf("date: %d/%02d/%d %02d:%02d:%02d;  author: %s;"
+		    "  state: %s;  lines:",
+		    rdp->rd_date.tm_year, rdp->rd_date.tm_mon + 1,
+		    rdp->rd_date.tm_mday, rdp->rd_date.tm_hour,
+		    rdp->rd_date.tm_min, rdp->rd_date.tm_sec,
+		    rdp->rd_author, rdp->rd_state);
+	}
+
+	printf(CVS_GETLOG_REVEND "\n");
+
+}
diff --git a/usr.bin/cvs/hist.c b/usr.bin/cvs/hist.c
new file mode 100644
index 00000000000..71598f4cd9a
--- /dev/null
+++ b/usr.bin/cvs/hist.c
@@ -0,0 +1,300 @@
+/*	$OpenBSD: hist.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "log.h"
+#include "cvs.h"
+
+#define CVS_HIST_BUFSIZE    8192
+
+
+
+static int  cvs_hist_fillbuf  (CVSHIST *);
+static int  cvs_hist_fmt      (const struct cvs_hent *, char *, size_t);
+
+
+
+
+
+/*
+ * cvs_hist_open()
+ *
+ * Open a CVS history file.
+ * Returns the number of entries in the file on success, or -1 on error.
+ */
+
+CVSHIST*
+cvs_hist_open(const char *path)
+{
+	CVSHIST *histp;
+
+	histp = (CVSHIST *)malloc(sizeof(*histp));
+	if (histp == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate CVS history");
+		return (NULL);
+	}
+	memset(histp, 0, sizeof(*histp));
+
+	histp->chf_buf = (char *)malloc(CVS_HIST_BUFSIZE);
+	if (histp->chf_buf == NULL) {
+		cvs_log(LP_ERRNO,
+		    "failed to allocate CVS history parse buffer");
+		free(histp);
+		return (NULL);
+	}
+	histp->chf_blen = CVS_HIST_BUFSIZE;
+	histp->chf_off = 0;
+
+	histp->chf_sindex = 0;
+	histp->chf_cindex = 0;
+	histp->chf_nbhent = 0;
+
+	histp->chf_fd = open(path, O_RDONLY, 0);
+	if (histp->chf_fd == -1) {
+		cvs_log(LP_ERRNO,
+		    "failed to open CVS history file `%s'", path);
+		free(histp->chf_buf);
+		free(histp);
+		return (NULL);
+	}
+
+	cvs_hist_fillbuf(histp);
+
+	return (histp);
+}
+
+
+/*
+ * cvs_hist_close()
+ *
+ * Close the CVS history file previously opened by a call to cvs_hist_open()
+ */
+
+void
+cvs_hist_close(CVSHIST *histp)
+{
+	if (histp->chf_fd >= 0)
+		(void)close(histp->chf_fd);
+	free(histp->chf_buf);
+	free(histp);
+}
+
+
+/*
+ * cvs_hist_getnext()
+ *
+ * Get the next entry from the history file <histp>.  Whenever using this
+ * function, it should be assumed that the return value of the previous call
+ * to cvs_hist_getnext() is now invalid.
+ * Returns the next entry from the file on success, or NULL on failure or if
+ * no entries are left.
+ */
+
+struct cvs_hent*
+cvs_hist_getnext(CVSHIST *histp)
+{
+	if (histp->chf_cindex == histp->chf_nbhent) {
+		/* no more cached entries, refill buf and parse */
+		cvs_hist_fillbuf(histp);
+		cvs_hist_parse(histp);
+	}
+	return (&(histp->chf_hent[histp->chf_cindex++]));
+}
+
+
+/*
+ * cvs_hist_append()
+ *
+ * Append a history entry to the history file <histp>.  The file offset is
+ * first set to the end of the file.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+cvs_hist_append(CVSHIST *histp, struct cvs_hent *hentp)
+{
+	char hbuf[128];
+
+	if (cvs_hist_fmt(hentp, hbuf, sizeof(hbuf)) < 0) {
+		cvs_log(LP_ERR, "failed to append CVS history entry");
+		return (-1);
+	}
+
+	/* position ourself at the end */
+	if (lseek(histp->chf_fd, (off_t)0, SEEK_END) == -1) {
+		cvs_log(LP_ERRNO, "failed to seek to end of CVS history file");
+		return (-1);
+	}
+
+	if (write(histp->chf_fd, hbuf, strlen(hbuf)) == -1) {
+		cvs_log(LP_ERR, "failed to write CVS history entry to file");
+		return (-1);
+	}
+
+	return (0);
+}
+
+
+
+/*
+ * cvs_hist_fillbuf()
+ *
+ * Fill the history file's internal buffer for future parsing.
+ */
+
+static int
+cvs_hist_fillbuf(CVSHIST *histp)
+{
+	ssize_t ret;
+
+	/* reposition ourself in case we're missing the start of a record */
+	if (lseek(histp->chf_fd, histp->chf_off, SEEK_SET) == -1) {
+		cvs_log(LP_ERRNO, "failed to seek in CVS history file");
+		return (-1);
+	}
+	ret = read(histp->chf_fd, histp->chf_buf, histp->chf_blen);
+	if (ret == -1) {
+		cvs_log(LP_ERRNO, "failed to buffer CVS history file");
+		return (-1);
+	}
+	else {
+		histp->chf_bused = (size_t)ret;
+	}
+
+	return (ret);
+}
+
+
+/*
+ * cvs_hist_parse()
+ *
+ * Parse the current contents of the internal buffer of <histp> and regenerate
+ * the buffered history entries.
+ * Returns the number of entries parsed on success, or -1 on failure.
+ */
+
+int
+cvs_hist_parse(CVSHIST *histp)
+{
+	u_int i, fld;
+	char *fields[CVS_HIST_NBFLD], *sp, *bep, *ep, *errp;
+
+	sp = histp->chf_buf;
+	bep = histp->chf_buf + histp->chf_bused - 1;
+
+	for (i = 0; i < CVS_HIST_CACHE; i++) {
+		ep = memchr(sp, '\n', bep - sp);
+		if (ep == NULL) {
+			/*
+			 * No record or incomplete record left to parse,
+			 * so adjust the next read offset in consequence.
+			 */
+			histp->chf_off += (off_t)(sp - histp->chf_buf);
+			break;
+		}
+		else if (ep == bep) {
+			histp->chf_off += (off_t)histp->chf_bused;
+		}
+		*(ep++) = '\0';
+
+		printf("hist(%s)\n", sp);
+
+		histp->chf_hent[i].ch_event = *sp++;
+
+		/* split the record in fields */
+		fields[0] = sp;
+
+		fld = 1;
+		while (sp < ep) {
+			if (*sp == '|') {
+				*sp = '\0';
+				fields[fld++] = sp + 1;
+			}
+			if (fld == CVS_HIST_NBFLD)
+				break;
+			sp++;
+		}
+#if 0
+		for (fld = 0; fld < CVS_HIST_NBFLD; fld++)
+			printf("fields[%u] = `%s'\n", fld, fields[fld]);
+#endif
+
+		histp->chf_hent[i].ch_date = (time_t)strtol(fields[0],
+		    &errp, 16);
+		if (*errp != '\0') {
+			cvs_log(LP_ERR,
+			    "parse error in date field of CVS history entry");
+			continue;
+		}
+
+		histp->chf_hent[i].ch_user = fields[1];
+		histp->chf_hent[i].ch_curdir = fields[2];
+		histp->chf_hent[i].ch_repo = fields[3];
+		histp->chf_hent[i].ch_rev = rcsnum_alloc();
+		rcsnum_aton(fields[4], NULL, histp->chf_hent[i].ch_rev);
+		histp->chf_hent[i].ch_arg = fields[5];
+		sp = ep;
+	}
+
+	/* update indexes */
+	histp->chf_sindex += histp->chf_nbhent;
+	histp->chf_nbhent = i;
+	histp->chf_cindex = 0;
+
+
+	return (i);
+}
+
+
+/*
+ * cvs_hist_fmt()
+ *
+ * Format the contents of the CVS history entry <ent> into the format used in
+ * the CVS `history' file, and store the resulting string in <buf>, which is
+ * of size <blen>.
+ */
+
+static int
+cvs_hist_fmt(const struct cvs_hent *ent, char *buf, size_t blen)
+{
+	char numbuf[64];
+
+	if (rcsnum_tostr(ent->ch_rev, numbuf, sizeof(numbuf)) == NULL) {
+		return (-1);
+	}
+
+	return snprintf(buf, blen, "%c%8x|%s|%s|%s|%s|%s",
+	    ent->ch_event, ent->ch_date, ent->ch_user, ent->ch_curdir,
+	    ent->ch_repo, numbuf, ent->ch_arg);
+}
diff --git a/usr.bin/cvs/history.c b/usr.bin/cvs/history.c
new file mode 100644
index 00000000000..b291869b7d6
--- /dev/null
+++ b/usr.bin/cvs/history.c
@@ -0,0 +1,205 @@
+/*	$OpenBSD: history.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sysexits.h>
+
+#include "cvs.h"
+#include "rcs.h"
+#include "log.h"
+
+#define CVS_HISTORY_MAXMOD    16
+
+/* history flags */
+#define CVS_HF_A     0x01
+#define CVS_HF_C     0x02
+#define CVS_HF_E     0x04
+#define CVS_HF_L     0x08
+#define CVS_HF_M     0x10
+#define CVS_HF_O     0x20
+#define CVS_HF_T     0x40
+#define CVS_HF_W     0x80
+
+#define CVS_HF_EXCL (CVS_HF_C|CVS_HF_E|CVS_HF_M|CVS_HF_O|CVS_HF_T|CVS_HF_X)
+
+static void  cvs_history_print  (struct cvs_hent *);
+
+
+extern char *__progname;
+
+extern struct cvsroot *cvs_root;
+
+
+/*
+ * cvs_history()
+ *
+ * Handle the `cvs history' command.
+ */
+
+
+int
+cvs_history(int argc, char **argv)
+{
+	int ch, flags;
+	u_int nbmod, rep;
+	char *user, *zone, *tag, *cp;
+	char *modules[CVS_HISTORY_MAXMOD], histpath[MAXPATHLEN];
+	struct cvs_hent *hent;
+	CVSHIST *hp;
+
+	tag = NULL;
+	user = NULL;
+	zone = "+0000";
+	nbmod = 0;
+	flags = 0;
+	rep = 0;
+
+	while ((ch = getopt(argc, argv, "acelm:oTt:u:wx:z:")) != -1) {
+		switch (ch) {
+		case 'a':
+			flags |= CVS_HF_A;
+			break;
+		case 'c':
+			rep++;
+			flags |= CVS_HF_C;
+			break;
+		case 'e':
+			rep++;
+			flags |= CVS_HF_E;
+			break;
+		case 'l':
+			flags |= CVS_HF_L;
+			break;
+		case 'm':
+			rep++;
+			flags |= CVS_HF_M;
+			if (nbmod == CVS_HISTORY_MAXMOD) {
+				cvs_log(LP_ERR, "too many `-m' options");
+				return (EX_USAGE);
+			}
+			modules[nbmod++] = optarg;
+			break;
+		case 'o':
+			rep++;
+			flags |= CVS_HF_O;
+			break;
+		case 'T':
+			rep++;
+			flags |= CVS_HF_T;
+			break;
+		case 't':
+			tag = optarg;
+			break;
+		case 'u':
+			user = optarg;
+			break;
+		case 'w':
+			flags |= CVS_HF_W;
+			break;
+		case 'x':
+			rep++;
+			for (cp = optarg; *cp != '\0'; cp++) {
+			}
+			break;
+		case 'z':
+			zone = optarg;
+			break;
+		default:
+			return (EX_USAGE);
+		}
+	}
+
+	if (rep > 1) {
+		cvs_log(LP_ERR,
+		    "Only one report type allowed from: \"-Tcomxe\"");
+		return (EX_USAGE);
+	}
+	else if (rep == 0)
+		flags |= CVS_HF_O;    /* use -o as default */
+
+	if (cvs_root->cr_method == CVS_METHOD_LOCAL) {
+		snprintf(histpath, sizeof(histpath), "%s/%s", cvs_root->cr_dir,
+		    CVS_PATH_HISTORY);
+		hp = cvs_hist_open(histpath);
+		if (hp == NULL) {
+			return (EX_UNAVAILABLE);
+		}
+
+		while ((hent = cvs_hist_getnext(hp)) != NULL) {
+			cvs_history_print(hent);
+		}
+		cvs_hist_close(hp);
+	}
+	else {
+		if (flags & CVS_HF_C)
+			cvs_client_sendarg("-c", 0);
+
+		if (flags & CVS_HF_O)
+			cvs_client_sendarg("-o", 0);
+
+		if (tag != NULL) {
+			cvs_client_sendarg("-t", 0);
+			cvs_client_sendarg(tag, 0);
+		}
+		if (user != NULL) {
+			cvs_client_sendarg("-u", 0);
+			cvs_client_sendarg(user, 0);
+		}
+
+
+		cvs_client_sendarg("-z", 0);
+		cvs_client_sendarg(zone, 0);
+
+		cvs_client_sendreq(CVS_REQ_HISTORY, NULL, 1);
+	}
+
+	return (0);
+}
+
+
+static void
+cvs_history_print(struct cvs_hent *hent)
+{
+	struct tm etime;
+
+	if (localtime_r(&(hent->ch_date), &etime) == NULL) {
+		cvs_log(LP_ERROR, "failed to convert timestamp to structure");
+		return;
+	}
+
+	printf("%c %4d-%02d-%02d %02d:%02d +%04d %-16s %-16s\n",
+	    hent->ch_event, etime.tm_year + 1900, etime.tm_mon + 1,
+	    etime.tm_mday, etime.tm_hour, etime.tm_min,
+	    0, hent->ch_user, hent->ch_repo);
+}
diff --git a/usr.bin/cvs/init.c b/usr.bin/cvs/init.c
new file mode 100644
index 00000000000..f823ce77dbc
--- /dev/null
+++ b/usr.bin/cvs/init.c
@@ -0,0 +1,127 @@
+/*	$OpenBSD: init.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sysexits.h>
+
+#include "cvs.h"
+#include "rcs.h"
+#include "log.h"
+
+extern struct cvsroot *cvs_root;
+
+
+extern char cvs_loginfo_data[];
+
+
+#define CFT_FILE   1
+#define CFT_DIR    2
+
+
+struct cvsroot_file {
+	char   *cf_path;   /* path relative to CVS root directory */
+	u_int   cf_type;
+	mode_t  cf_mode;
+} cvsroot_files[] = {
+	{ CVS_PATH_ROOT,   CFT_DIR, (S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) },
+
+	{ CVS_PATH_COMMITINFO,  CFT_FILE, (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) },
+	{ CVS_PATH_CONFIG,      CFT_FILE, (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) },
+	{ CVS_PATH_CVSIGNORE,   CFT_FILE, (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) },
+	{ CVS_PATH_CVSWRAPPERS, CFT_FILE, (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) },
+	{ CVS_PATH_EDITINFO,    CFT_FILE, (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) },
+	{ CVS_PATH_HISTORY,     CFT_FILE, (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) },
+	{ CVS_PATH_LOGINFO,     CFT_FILE, (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) },
+	{ CVS_PATH_MODULES,     CFT_FILE, (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) },
+	{ CVS_PATH_NOTIFY,      CFT_FILE, (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) },
+	{ CVS_PATH_RCSINFO,     CFT_FILE, (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) },
+	{ CVS_PATH_TAGINFO,     CFT_FILE, (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) },
+	{ CVS_PATH_VERIFYMSG,   CFT_FILE, (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) },
+};
+
+
+
+
+
+int
+cvs_init(int argc, char **argv)
+{
+	int fd;
+	u_int i;
+	char path[MAXPATHLEN];
+	RCSFILE *rfp;
+	struct stat st;
+
+	if (argc != 1)
+		return (EX_USAGE);
+
+	for (i = 0; i < sizeof(cvsroot_files)/sizeof(cvsroot_files[i]); i++) {
+		snprintf(path, sizeof(path), "%s/%s", cvs_root->cr_dir,
+		    cvsroot_files[i].cf_path);
+
+		if (cvsroot_files[i].cf_type == CFT_DIR) {
+			if (mkdir(path, cvsroot_files[i].cf_mode) == -1) {
+				cvs_log(LP_ERRNO, "failed to create `%s'",
+				    path);
+				return (EX_CANTCREAT);
+			}
+		}
+		else if (cvsroot_files[i].cf_type == CFT_FILE) {
+			fd = open(path, O_WRONLY|O_CREAT|O_EXCL,
+			    cvsroot_files[i].cf_mode);
+			if (fd == -1) {
+				cvs_log(LP_ERRNO, "failed to create `%s'",
+				    path);
+				return (EX_CANTCREAT);
+			}
+
+			(void)close(fd);
+
+			strlcat(path, RCS_FILE_EXT, sizeof(path));
+			rfp = rcs_open(path, RCS_MODE_WRITE);
+			if (rfp == NULL) {
+				return (EX_CANTCREAT);
+			}
+
+			if (rcs_write(rfp) < 0) {
+				rcs_close(rfp);
+				return (EX_CANTCREAT);
+			}
+
+			rcs_close(rfp);
+		}
+	}
+
+	return (0);
+}
diff --git a/usr.bin/cvs/lock.c b/usr.bin/cvs/lock.c
new file mode 100644
index 00000000000..3dddc4c0508
--- /dev/null
+++ b/usr.bin/cvs/lock.c
@@ -0,0 +1,65 @@
+/*	$OpenBSD: lock.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <stdlib.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <err.h>
+#include <errno.h>
+#include <string.h>
+
+#include "cvs.h"
+
+
+
+
+
+int
+cvs_lock(const char *path)
+{
+	int fd;
+
+	fd = open(path, O_WRONLY|O_CREAT|O_EXCL);
+	if (fd == -1) {
+		warn("failed to open lock file `%s'", path);
+		return (-1);
+	}
+
+	return (0);
+}
+
+
+int
+cvs_unlock(const char *path)
+{
+
+
+
+}
diff --git a/usr.bin/cvs/log.c b/usr.bin/cvs/log.c
new file mode 100644
index 00000000000..55d1be069a1
--- /dev/null
+++ b/usr.bin/cvs/log.c
@@ -0,0 +1,254 @@
+/*	$OpenBSD: log.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@fugusec.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <syslog.h>
+
+#include "log.h"
+
+extern char *__progname;
+
+static char *cvs_log_levels[] = {
+	"debug",
+	"info",
+	"notice",
+	"warning",
+	"error",
+	"alert",
+	"error"
+};
+
+
+static int cvs_slpriomap[] = {
+	LOG_DEBUG,
+	LOG_INFO,
+	LOG_NOTICE,
+	LOG_WARNING,
+	LOG_ERR,
+	LOG_ALERT,
+	LOG_ERR,
+};
+
+
+
+static u_int cvs_log_dest = LD_STD;
+static u_int cvs_log_flags = 0;
+
+static u_int cvs_log_filters[LP_MAX + 1];
+#define NB_FILTERS  sizeof(cvs_log_filters)/sizeof(cvs_log_filters[0])
+
+
+static struct syslog_data cvs_sl;
+
+
+/*
+ * cvs_log_init()
+ *
+ * Initialize the logging facility of the server.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+cvs_log_init(u_int dest, u_int flags)
+{
+	int slopt;
+
+	cvs_log_dest = dest;
+	cvs_log_flags = flags;
+
+	/* by default, filter only LP_DEBUG and LP_INFO levels */
+	memset(cvs_log_filters, 0, sizeof(cvs_log_filters));
+	cvs_log_filters[LP_DEBUG] = 1;
+	cvs_log_filters[LP_INFO] = 1;
+
+	if (dest & LD_SYSLOG) {
+		slopt = 0;
+
+		if (dest & LD_CONS)
+			slopt |= LOG_CONS;
+		if (flags & LF_PID)
+			slopt |= LOG_PID;
+
+		openlog_r(__progname, slopt, LOG_DAEMON, &cvs_sl);
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvs_log_cleanup()
+ *
+ * Cleanup the logging facility.
+ */
+
+void
+cvs_log_cleanup(void)
+{
+	closelog_r(&cvs_sl);
+
+}
+
+
+/*
+ * cvs_log_filter()
+ *
+ * Apply or remove filters on the logging facility.  The exact operation is
+ * specified by the <how> and <level> arguments.  The <how> arguments tells
+ * how the filters will be affected, and <level> gives the log levels that
+ * will be affected by the change.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+cvs_log_filter(u_int how, u_int level)
+{
+	u_int i;
+
+	if ((level > LP_MAX) && (level != LP_ALL)) {
+		cvs_log(LP_ERR, "invalid log level for filter");
+		return (-1);
+	}
+
+	switch (how) {
+	case LP_FILTER_SET:
+		if (level == LP_ALL)
+			for (i = 0; i < NB_FILTERS; i++)
+				cvs_log_filters[i] = 1;
+		else
+			cvs_log_filters[level] = 1;
+		break;
+	case LP_FILTER_UNSET:
+		if (level == LP_ALL)
+			for (i = 0; i < NB_FILTERS; i++)
+				cvs_log_filters[i] = 0;
+		else
+			cvs_log_filters[level] = 0;
+		break;
+	case LP_FILTER_TOGGLE:
+		if (level == LP_ALL)
+			for (i = 0; i < NB_FILTERS; i++)
+				cvs_log_filters[i] =
+				    (cvs_log_filters[i] == 0) ? 1 : 0;
+		else
+			cvs_log_filters[level] =
+			    (cvs_log_filters[level] == 0) ? 1 : 0;
+		break;
+	default:
+		return (-1);
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvs_log()
+ *
+ * Log the format-string message
+ * The <fmt> argument should not have a terminating newline, as this is taken
+ * care of by the logging facility.
+ */
+
+int
+cvs_log(u_int level, const char *fmt, ...)
+{
+	int ret;
+	va_list vap;
+
+	va_start(vap, fmt);
+	ret = cvs_vlog(level, fmt, vap);
+	va_end(vap);
+
+	return (ret);
+}
+
+
+/*
+ * cvs_vlog()
+ *
+ * The <fmt> argument should not have a terminating newline, as this is taken
+ * care of by the logging facility.
+ */
+
+int
+cvs_vlog(u_int level, const char *fmt, va_list vap)
+{
+	int ecp;
+	pid_t pid;
+	char prefix[64], buf[1024], ebuf[32];
+	FILE *out;
+
+	ecp = 0;
+
+	if (level > LP_MAX) {
+		return (-1);
+	}
+
+	/* apply any filters */
+	if (cvs_log_filters[level] == 1)
+		return (0);
+
+	if (level == LP_ERRNO)
+		ecp = errno;
+
+	strlcpy(prefix, __progname, sizeof(prefix));
+	if (cvs_log_flags & LF_PID) {
+		snprintf(buf, sizeof(buf), "[%d]", (int)getpid());
+		strlcat(prefix, buf, sizeof(prefix));
+	}
+
+	vsnprintf(buf, sizeof(buf), fmt, vap);
+	if (level == LP_ERRNO) {
+		snprintf(ebuf, sizeof(ebuf), ": %s", strerror(errno));
+		strlcat(buf, ebuf, sizeof(buf));
+	}
+
+	if (cvs_log_dest & LD_STD) {
+		if (level <= LP_NOTICE)
+			out = stdout;
+		else
+			out = stderr;
+
+		fprintf(out, "%s: %s\n", prefix, buf);
+	}
+
+	if (cvs_log_dest & LD_SYSLOG)
+		syslog_r(cvs_slpriomap[level], &cvs_sl, "%s", buf);
+
+	/* preserve it just in case we changed it? */
+	if (level == LP_ERRNO)
+		errno = ecp;
+
+	return (0);
+}
diff --git a/usr.bin/cvs/log.h b/usr.bin/cvs/log.h
new file mode 100644
index 00000000000..a33c6d7c921
--- /dev/null
+++ b/usr.bin/cvs/log.h
@@ -0,0 +1,71 @@
+/*	$OpenBSD: log.h,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@fugusec.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LOG_H
+#define LOG_H
+
+#include <sys/types.h>
+
+#include <stdarg.h>
+
+/* log destinations */
+#define LD_STD      0x01
+#define LD_SYSLOG   0x02
+#define LD_CONS     0x04
+
+#define LD_ALL      (LD_STD|LD_SYSLOG|LD_CONS)
+
+/* log flags */
+#define LF_PID     0x01     /* include PID in messages */
+
+
+
+/* log priority levels */
+#define LP_DEBUG    0
+#define LP_INFO     1
+#define LP_NOTICE   2
+#define LP_WARNING  3
+#define LP_WARN     LP_WARNING
+#define LP_ERROR    4
+#define LP_ERR      LP_ERROR
+#define LP_ALERT    5
+#define LP_ERRNO    6
+ 
+#define LP_MAX      6
+#define LP_ALL      255
+ 
+/* filtering methods */
+#define LP_FILTER_SET     0     /* set a filter */
+#define LP_FILTER_UNSET   1     /* remove a filter */
+#define LP_FILTER_TOGGLE  2
+
+int   cvs_log_init    (u_int, u_int);
+void  cvs_log_cleanup (void);
+int   cvs_log_filter  (u_int, u_int);
+int   cvs_log         (u_int, const char *, ...);
+int   cvs_vlog        (u_int, const char *, va_list);
+
+#endif /* LOG_H */
diff --git a/usr.bin/cvs/msg.c b/usr.bin/cvs/msg.c
new file mode 100644
index 00000000000..6e9aadd82cf
--- /dev/null
+++ b/usr.bin/cvs/msg.c
@@ -0,0 +1,121 @@
+/*	$OpenBSD: msg.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/param.h>
+#include <sys/uio.h>
+
+#include <pwd.h>
+#include <grp.h>
+#include <poll.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+
+#include "log.h"
+#include "cvsd.h"
+
+
+
+
+
+/*
+ * cvsd_sendmsg()
+ *
+ * Send a message of type <type> along with the first <len> bytes of data
+ * from <data> (which can be up to CVSD_MSG_MAXLEN bytes) on the descriptor
+ * <fd>.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+cvsd_sendmsg(int fd, u_int type, const void *data, size_t len)
+{
+	struct iovec iov[2];
+	struct cvsd_msg msg;
+
+	if (len > CVSD_MSG_MAXLEN) {
+		cvs_log(LP_ERR, "message too large");
+		return (-1);
+	}
+
+	msg.cm_type = type;
+	msg.cm_len = len;
+
+	iov[0].iov_base = &msg;
+	iov[0].iov_len = sizeof(msg);
+	iov[1].iov_base = (void *)data;
+	iov[1].iov_len = len;
+
+	if (writev(fd, iov, 2) == -1) {
+		cvs_log(LP_ERRNO, "failed to send message");
+		return (-1);
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvsd_recvmsg()
+ *
+ * Read a message from the file descriptor <fd> and store the message data
+ * in the <dst> buffer.  The <len> parameter should contain the maximum
+ * length of data that can be stored in <dst>, and will contain the actual
+ * size of data stored on return.  The message type is stored in <type>.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+cvsd_recvmsg(int fd, u_int *type, void *dst, size_t *len)
+{
+	ssize_t ret;
+	struct cvsd_msg msg;
+
+	if (read(fd, &msg, sizeof(msg)) == -1) {
+		cvs_log(LP_ERRNO, "failed to read message header");
+		return (-1);
+	}
+
+	if (*len < msg.cm_len) {
+		cvs_log(LP_ERR, "buffer size too small for message data");
+		return (-1);
+	}
+
+	ret = read(fd, dst, msg.cm_len);
+	if (ret == -1) {
+		cvs_log(LP_ERRNO, "failed to read message");
+		return (-1);
+	}
+	else if (ret == 0) {
+	}
+
+	*type = msg.cm_type;
+
+	return (0);
+}
diff --git a/usr.bin/cvs/proto.c b/usr.bin/cvs/proto.c
new file mode 100644
index 00000000000..e5e23cdc6e2
--- /dev/null
+++ b/usr.bin/cvs/proto.c
@@ -0,0 +1,821 @@
+/*	$OpenBSD: proto.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/*
+ * CVS client/server protocol
+ * ==========================
+ *
+ * The following code implements the CVS client/server protocol, which is
+ * documented at the following URL:
+ *	http://www.loria.fr/~molli/cvs/doc/cvsclient_toc.html
+ *
+ * The protocol is split up into two parts; the first part is the client side
+ * of things and is composed of all the response handlers, which are all named
+ * with a prefix of "cvs_resp_".  The second part is the set of request
+ * handlers used by the server.  These handlers process the request and
+ * generate the appropriate response to send back.  The prefix for request
+ * handlers is "cvs_req_".
+ *
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+#include <sysexits.h>
+#ifdef CVS_ZLIB
+#include <zlib.h>
+#endif
+
+#include "buf.h"
+#include "cvs.h"
+#include "log.h"
+
+
+
+extern int   verbosity;
+extern int   cvs_compress;
+extern char *cvs_rsh;
+extern int   cvs_trace;
+extern int   cvs_nolog;
+extern int   cvs_readonly;
+
+extern struct cvsroot *cvs_root;
+
+
+
+/*
+ * Local and remote directory used by the `Directory' request.
+ */
+char  cvs_ldir[MAXPATHLEN];
+char  cvs_rdir[MAXPATHLEN];
+
+
+
+char *cvs_fcksum = NULL;
+
+mode_t  cvs_lastmode = 0;
+
+
+static int  cvs_resp_validreq  (int, char *);
+static int  cvs_resp_cksum     (int, char *);
+static int  cvs_resp_m         (int, char *);
+static int  cvs_resp_ok        (int, char *);
+static int  cvs_resp_error     (int, char *);
+static int  cvs_resp_statdir   (int, char *);
+static int  cvs_resp_newentry  (int, char *);
+static int  cvs_resp_updated   (int, char *);
+static int  cvs_resp_removed   (int, char *);
+static int  cvs_resp_mode      (int, char *);
+
+
+
+
+struct cvs_req {
+	int      req_id;
+	char     req_str[32];
+	u_int    req_flags;
+	int    (*req_hdlr)(int, char *);
+} cvs_requests[] = {
+	{ CVS_REQ_DIRECTORY,     "Directory",         0,  NULL },
+	{ CVS_REQ_MAXDOTDOT,     "Max-dotdot",        0,  NULL },
+	{ CVS_REQ_STATICDIR,     "Static-directory",  0,  NULL },
+	{ CVS_REQ_STICKY,        "Sticky",            0,  NULL },
+	{ CVS_REQ_ENTRY,         "Entry",             0,  NULL },
+	{ CVS_REQ_ENTRYEXTRA,    "EntryExtra",        0,  NULL },
+	{ CVS_REQ_CHECKINTIME,   "Checkin-time",      0,  NULL },
+	{ CVS_REQ_MODIFIED,      "Modified",          0,  NULL },
+	{ CVS_REQ_ISMODIFIED,    "Is-modified",       0,  NULL },
+	{ CVS_REQ_UNCHANGED,     "Unchanged",         0,  NULL },
+	{ CVS_REQ_USEUNCHANGED,  "UseUnchanged",      0,  NULL },
+	{ CVS_REQ_NOTIFY,        "Notify",            0,  NULL },
+	{ CVS_REQ_NOTIFYUSER,    "NotifyUser",        0,  NULL },
+	{ CVS_REQ_QUESTIONABLE,  "Questionable",      0,  NULL },
+	{ CVS_REQ_CASE,          "Case",              0,  NULL },
+	{ CVS_REQ_UTF8,          "Utf8",              0,  NULL },
+	{ CVS_REQ_ARGUMENT,      "Argument",          0,  NULL },
+	{ CVS_REQ_ARGUMENTX,     "Argumentx",         0,  NULL },
+	{ CVS_REQ_GLOBALOPT,     "Global_option",     0,  NULL },
+	{ CVS_REQ_GZIPSTREAM,    "Gzip-stream",       0,  NULL },
+	{ CVS_REQ_READCVSRC2,    "read-cvsrc2",       0,  NULL },
+	{ CVS_REQ_READWRAP,      "read-cvswrappers",  0,  NULL },
+	{ CVS_REQ_READIGNORE,    "read-cvsignore",    0,  NULL },
+	{ CVS_REQ_ERRIFREADER,   "Error-If-Reader",   0,  NULL },
+	{ CVS_REQ_VALIDRCSOPT,   "Valid-RcsOptions",  0,  NULL },
+	{ CVS_REQ_SET,           "Set",               0,  NULL },
+	{ CVS_REQ_XPANDMOD,      "expand-modules",    0,  NULL },
+	{ CVS_REQ_LOG,           "log",               0,  NULL },
+	{ CVS_REQ_CO,            "co",                0,  NULL },
+	{ CVS_REQ_EXPORT,        "export",            0,  NULL },
+	{ CVS_REQ_RANNOTATE,     "rannotate",         0,  NULL },
+	{ CVS_REQ_RDIFF,         "rdiff",             0,  NULL },
+	{ CVS_REQ_RLOG,          "rlog",              0,  NULL },
+	{ CVS_REQ_RTAG,          "rtag",              0,  NULL },
+	{ CVS_REQ_INIT,          "init",              0,  NULL },
+	{ CVS_REQ_UPDATE,        "update",            0,  NULL },
+	{ CVS_REQ_HISTORY,       "history",           0,  NULL },
+	{ CVS_REQ_IMPORT,        "import",            0,  NULL },
+	{ CVS_REQ_ADD,           "add",               0,  NULL },
+	{ CVS_REQ_REMOVE,        "remove",            0,  NULL },
+	{ CVS_REQ_RELEASE,       "release",           0,  NULL },
+	{ CVS_REQ_ROOT,          "Root",              0,  NULL },
+	{ CVS_REQ_VALIDRESP,     "Valid-responses",   0,  NULL },
+	{ CVS_REQ_VALIDREQ,      "valid-requests",    0,  NULL },
+	{ CVS_REQ_VERSION,       "version",           0,  NULL },
+	{ CVS_REQ_NOOP,          "noop",              0,  NULL },
+	{ CVS_REQ_DIFF,          "diff",              0,  NULL },
+};
+
+
+struct cvs_resp {
+	u_int  resp_id;
+	char   resp_str[32];
+	int  (*resp_hdlr)(int, char *);
+} cvs_responses[] = {
+	{ CVS_RESP_OK,         "ok",                     cvs_resp_ok       },
+	{ CVS_RESP_ERROR,      "error",                  cvs_resp_error    },
+	{ CVS_RESP_VALIDREQ,   "Valid-requests",         cvs_resp_validreq },
+	{ CVS_RESP_M,          "M",                      cvs_resp_m        },
+	{ CVS_RESP_MBINARY,    "Mbinary",                cvs_resp_m        },
+	{ CVS_RESP_MT,         "MT",                     cvs_resp_m        },
+	{ CVS_RESP_E,          "E",                      cvs_resp_m        },
+	{ CVS_RESP_F,          "F",                      cvs_resp_m        },
+	{ CVS_RESP_CREATED,    "Created",                cvs_resp_updated  },
+	{ CVS_RESP_UPDATED,    "Updated",                cvs_resp_updated  },
+	{ CVS_RESP_UPDEXIST,   "Update-existing",        cvs_resp_updated  },
+	{ CVS_RESP_REMOVED,    "Removed",                cvs_resp_removed  },
+	{ CVS_RESP_MERGED,     "Merged",                 NULL              },
+	{ CVS_RESP_CKSUM,      "Checksum",               cvs_resp_cksum    },
+	{ CVS_RESP_CLRSTATDIR, "Clear-static-directory", cvs_resp_statdir  },
+	{ CVS_RESP_SETSTATDIR, "Set-static-directory",   cvs_resp_statdir  },
+	{ CVS_RESP_NEWENTRY,   "New-entry",              cvs_resp_newentry },
+	{ CVS_RESP_CHECKEDIN,  "Checked-in",             cvs_resp_newentry },
+	{ CVS_RESP_MODE,       "Mode",                   cvs_resp_mode     },
+};
+
+
+#define CVS_NBREQ   (sizeof(cvs_requests)/sizeof(cvs_requests[0]))
+#define CVS_NBRESP  (sizeof(cvs_responses)/sizeof(cvs_responses[0]))
+
+/* mask of requets supported by server */
+static u_char  cvs_server_validreq[CVS_REQ_MAX + 1];
+
+
+/*
+ * cvs_req_getbyid()
+ *
+ */
+
+const char*
+cvs_req_getbyid(int reqid)
+{
+	u_int i;
+
+	for (i = 0; i < CVS_NBREQ; i++)
+		if (cvs_requests[i].req_id == reqid)
+			return (cvs_requests[i].req_str);
+	return (NULL);
+}
+
+
+/*
+ * cvs_req_getbyname()
+ */
+
+int
+cvs_req_getbyname(const char *rname)
+{
+	u_int i;
+
+	for (i = 0; i < CVS_NBREQ; i++)
+		if (strcmp(cvs_requests[i].req_str, rname) == 0)
+			return (cvs_requests[i].req_id);
+
+	return (-1);
+}
+
+
+/*
+ * cvs_req_getvalid()
+ *
+ * Build a space-separated list of all the requests that this protocol
+ * implementation supports.
+ */
+
+char*
+cvs_req_getvalid(void)
+{
+	u_int i;
+	size_t len;
+	char *vrstr;
+	BUF *buf;
+
+	buf = cvs_buf_alloc(512, BUF_AUTOEXT);
+	if (buf == NULL)
+		return (NULL);
+
+	cvs_buf_set(buf, cvs_requests[0].req_str,
+	    strlen(cvs_requests[0].req_str), 0);
+
+	for (i = 1; i < CVS_NBREQ; i++) {
+		if ((cvs_buf_putc(buf, ' ') < 0) ||
+		    (cvs_buf_append(buf, cvs_requests[i].req_str,
+		    strlen(cvs_requests[i].req_str)) < 0)) {
+			cvs_buf_free(buf);
+			return (NULL);
+		}
+	}
+
+	/* NUL-terminate */
+	if (cvs_buf_putc(buf, '\0') < 0) {
+		cvs_buf_free(buf);
+		return (NULL);
+	}
+
+	len = cvs_buf_size(buf);
+	vrstr = (char *)malloc(len);
+
+	cvs_buf_copy(buf, 0, vrstr, len);
+
+	cvs_buf_free(buf);
+
+	return (vrstr);
+}
+
+
+/*
+ * cvs_req_handle()
+ *
+ * Generic request handler dispatcher.
+ */
+
+int
+cvs_req_handle(char *line)
+{
+	return (0);
+}
+
+
+/*
+ * cvs_resp_getbyid()
+ *
+ */
+
+const char*
+cvs_resp_getbyid(int respid)
+{
+	u_int i;
+
+	for (i = 0; i < CVS_NBREQ; i++)
+		if (cvs_responses[i].resp_id == respid)
+			return (cvs_responses[i].resp_str);
+	return (NULL);
+}
+
+
+/*
+ * cvs_resp_getbyname()
+ */
+
+int
+cvs_resp_getbyname(const char *rname)
+{
+	u_int i;
+
+	for (i = 0; i < CVS_NBREQ; i++)
+		if (strcmp(cvs_responses[i].resp_str, rname) == 0)
+			return (cvs_responses[i].resp_id);
+
+	return (-1);
+}
+
+
+/*
+ * cvs_resp_getvalid()
+ *
+ * Build a space-separated list of all the responses that this protocol
+ * implementation supports.
+ */
+
+char*
+cvs_resp_getvalid(void)
+{
+	u_int i;
+	size_t len;
+	char *vrstr;
+	BUF *buf;
+
+	buf = cvs_buf_alloc(512, BUF_AUTOEXT);
+	if (buf == NULL)
+		return (NULL);
+
+	cvs_buf_set(buf, cvs_responses[0].resp_str,
+	    strlen(cvs_responses[0].resp_str), 0);
+
+	for (i = 1; i < CVS_NBRESP; i++) {
+		if ((cvs_buf_putc(buf, ' ') < 0) ||
+		    (cvs_buf_append(buf, cvs_responses[i].resp_str,
+		    strlen(cvs_responses[i].resp_str)) < 0)) {
+			cvs_buf_free(buf);
+			return (NULL);
+		}
+	}
+
+	/* NUL-terminate */
+	if (cvs_buf_putc(buf, '\0') < 0) {
+		cvs_buf_free(buf);
+		return (NULL);
+	}
+
+	len = cvs_buf_size(buf);
+	vrstr = (char *)malloc(len);
+
+	cvs_buf_copy(buf, 0, vrstr, len);
+	cvs_buf_free(buf);
+
+	return (vrstr);
+}
+
+
+/*
+ * cvs_resp_handle()
+ *
+ * Generic response handler dispatcher.  The handler expects the first line
+ * of the command as single argument.
+ * Returns the return value of the command on success, or -1 on failure.
+ */
+
+int
+cvs_resp_handle(char *line)
+{
+	u_int i;
+	size_t len;
+	char *cp, *cmd;
+
+	cmd = line;
+
+	cp = strchr(cmd, ' ');
+	if (cp != NULL)
+		*(cp++) = '\0';
+
+	for (i = 0; i < CVS_NBRESP; i++) {
+		if (strcmp(cvs_responses[i].resp_str, cmd) == 0)
+			return (*cvs_responses[i].resp_hdlr)
+			    (cvs_responses[i].resp_id, cp);
+	}
+
+	/* unhandled */
+	return (-1);
+}
+
+
+/*
+ * cvs_client_sendinfo()
+ *
+ * Initialize the connection status by first requesting the list of
+ * supported requests from the server.  Then, we send the CVSROOT variable
+ * with the `Root' request.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+static int
+cvs_client_sendinfo(void)
+{
+	/* first things first, get list of valid requests from server */
+	if (cvs_client_sendreq(CVS_REQ_VALIDREQ, NULL, 1) < 0) {
+		cvs_log(LP_ERR, "failed to get valid requests from server");
+		return (-1);
+	}
+
+	/* now share our global options with the server */
+	if (verbosity == 1)
+		cvs_client_sendreq(CVS_REQ_GLOBALOPT, "-q", 0);
+	else if (verbosity == 0)
+		cvs_client_sendreq(CVS_REQ_GLOBALOPT, "-Q", 0);
+
+	if (cvs_nolog)
+		cvs_client_sendreq(CVS_REQ_GLOBALOPT, "-l", 0);
+	if (cvs_readonly)
+		cvs_client_sendreq(CVS_REQ_GLOBALOPT, "-r", 0);
+	if (cvs_trace)
+		cvs_client_sendreq(CVS_REQ_GLOBALOPT, "-t", 0);
+
+	/* now send the CVSROOT to the server */
+	if (cvs_client_sendreq(CVS_REQ_ROOT, cvs_root->cr_dir, 0) < 0)
+		return (-1);
+
+	/* not sure why, but we have to send this */
+	if (cvs_client_sendreq(CVS_REQ_USEUNCHANGED, NULL, 0) < 0)
+		return (-1);
+
+	return (0);
+}
+
+
+/*
+ * cvs_resp_validreq()
+ *
+ * Handler for the `Valid-requests' response.  The list of valid requests is
+ * split on spaces and each request's entry in the valid request array is set
+ * to 1 to indicate the validity.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+static int
+cvs_resp_validreq(int type, char *line)
+{
+	int i;
+	char *sp, *ep;
+
+	/* parse the requests */
+	sp = line;
+	do {
+		ep = strchr(sp, ' ');
+		if (ep != NULL)
+			*ep = '\0';
+
+		i = cvs_req_getbyname(sp);
+		if (i != -1)
+			cvs_server_validreq[i] = 1;
+
+		if (ep != NULL)
+			sp = ep + 1;
+	} while (ep != NULL);
+
+	return (0);
+}
+
+
+/*
+ * cvs_resp_m()
+ *
+ * Handler for the `M', `F' and `E' responses.
+ */
+
+static int
+cvs_resp_m(int type, char *line)
+{
+	FILE *stream;
+
+	stream = NULL;
+
+	switch (type) {
+	case CVS_RESP_F:
+		fflush(stderr);
+		return (0);
+	case CVS_RESP_M:
+		stream = stdout;
+		break;
+	case CVS_RESP_E:
+		stream = stderr;
+		break;
+	case CVS_RESP_MT:
+	case CVS_RESP_MBINARY:
+		cvs_log(LP_WARN, "MT and Mbinary not supported in client yet");
+		break;
+	}
+
+	fputs(line, stream);
+	fputc('\n', stream);
+
+	return (0);
+}
+
+
+/*
+ * cvs_resp_ok()
+ *
+ * Handler for the `ok' response.  This handler's job is to 
+ */
+
+static int
+cvs_resp_ok(int type, char *line)
+{
+	return (1);
+}
+
+
+/*
+ * cvs_resp_error()
+ *
+ * Handler for the `error' response.  This handler's job is to 
+ */
+
+static int
+cvs_resp_error(int type, char *line)
+{
+	return (1);
+}
+
+
+/*
+ * cvs_resp_statdir()
+ *
+ * Handler for the `Clear-static-directory' and `Set-static-directory'
+ * responses.
+ */
+
+static int
+cvs_resp_statdir(int type, char *line)
+{
+	int fd;
+	char statpath[MAXPATHLEN];
+
+	snprintf(statpath, sizeof(statpath), "%s/%s", line,
+	    CVS_PATH_STATICENTRIES);
+
+	if ((type == CVS_RESP_CLRSTATDIR) &&
+	    (unlink(statpath) == -1)) {
+		cvs_log(LP_ERRNO, "failed to unlink %s file",
+		    CVS_PATH_STATICENTRIES);
+		return (-1);
+	}
+	else if (type == CVS_RESP_SETSTATDIR) {
+		fd = open(statpath, O_CREAT|O_TRUNC|O_WRONLY, 0400); 
+		if (fd == -1) {
+			cvs_log(LP_ERRNO, "failed to create %s file",
+			    CVS_PATH_STATICENTRIES);
+			return (-1);
+		}
+		(void)close(fd);
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvs_resp_newentry()
+ *
+ * Handler for the `New-entry' response and `Checked-in' responses.
+ */
+
+static int
+cvs_resp_newentry(int type, char *line)
+{
+	char entbuf[128], path[MAXPATHLEN];
+	struct cvs_ent *entp;
+	CVSENTRIES *entfile;
+
+	if (cvs_splitpath(line, entbuf, sizeof(entbuf), NULL, 0) < 0)
+		return (-1);
+
+	snprintf(path, sizeof(path), "%s/" CVS_PATH_ENTRIES, entbuf);
+
+	/* get the remote path */
+	cvs_client_getln(entbuf, sizeof(entbuf));
+
+	/* get the new Entries line */
+	if (cvs_client_getln(entbuf, sizeof(entbuf)) < 0)
+		return (-1);
+
+	entp = cvs_ent_parse(entbuf);
+	if (entp == NULL)
+		return (-1);
+
+	entfile = cvs_ent_open(path);
+	if (entfile == NULL)
+		return (-1);
+
+	cvs_ent_add(entfile, entp);
+
+	cvs_ent_close(entfile);
+
+	return (0);
+}
+
+
+/*
+ * cvs_resp_cksum()
+ *
+ * Handler for the `Checksum' response.  We store the checksum received for
+ * the next file in a dynamically-allocated buffer pointed to by <cvs_fcksum>.
+ * Upon next file reception, the handler checks to see if there is a stored
+ * checksum.
+ * The file handler must make sure that the checksums match and free the
+ * checksum buffer once it's done to indicate there is no further checksum.
+ */
+
+static int
+cvs_resp_cksum(int type, char *line)
+{
+	if (cvs_fcksum != NULL) {
+		cvs_log(LP_WARN, "unused checksum");
+		free(cvs_fcksum);
+	}
+
+	cvs_fcksum = strdup(line);
+	if (cvs_fcksum == NULL) {
+		cvs_log(LP_ERRNO, "failed to copy checksum string");
+		return (-1);
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvs_resp_updated()
+ *
+ * Handler for the `Updated' response.
+ */
+
+static int
+cvs_resp_updated(int type, char *line)
+{
+	char cksum_buf[CVS_CKSUM_LEN];
+
+	if (type == CVS_RESP_CREATED) {
+	}
+	else if (type == CVS_RESP_UPDEXIST) {
+	}
+	else if (type == CVS_RESP_UPDATED) {
+	}
+
+	if (cvs_recvfile(line) < 0) {
+		return (-1);
+	}
+
+	/* now see if there is a checksum */
+	if (cvs_cksum(line, cksum_buf, sizeof(cksum_buf)) < 0) {
+	}
+
+	if (strcmp(cksum_buf, cvs_fcksum) != 0) {
+		cvs_log(LP_ERR, "checksum error on received file");
+		(void)unlink(line);
+	}
+
+	free(cvs_fcksum);
+	cvs_fcksum = NULL;
+
+	return (0);
+}
+
+
+/*
+ * cvs_resp_removed()
+ *
+ * Handler for the `Updated' response.
+ */
+
+static int
+cvs_resp_removed(int type, char *line)
+{
+	return (0);
+}
+
+
+/*
+ * cvs_resp_mode()
+ *
+ * Handler for the `Mode' response.
+ */
+
+static int
+cvs_resp_mode(int type, char *line)
+{
+	if (cvs_strtomode(line, &cvs_lastmode) < 0) {
+		return (-1);
+	}
+	return (0);
+}
+
+
+/*
+ * cvs_sendfile()
+ *
+ * Send the mode and size of a file followed by the file's contents.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+cvs_sendfile(const char *path)
+{
+	int fd;
+	ssize_t ret;
+	char buf[4096];
+	struct stat st;
+
+	if (stat(path, &st) == -1) {
+		cvs_log(LP_ERRNO, "failed to stat `%s'", path);
+		return (-1);
+	}
+
+	fd = open(path, O_RDONLY, 0);
+	if (fd == -1) {
+		return (-1);
+	}
+
+	if (cvs_modetostr(st.st_mode, buf, sizeof(buf)) < 0)
+		return (-1);
+
+	cvs_client_sendln(buf);
+	snprintf(buf, sizeof(buf), "%lld\n", st.st_size);
+	cvs_client_sendln(buf);
+
+	while ((ret = read(fd, buf, sizeof(buf))) != 0) {
+		if (ret == -1) {
+			cvs_log(LP_ERRNO, "failed to read file `%s'", path);
+			return (-1);
+		}
+
+		cvs_client_sendraw(buf, (size_t)ret);
+
+	}
+
+	(void)close(fd);
+
+	return (0);
+}
+
+
+/*
+ * cvs_recvfile()
+ *
+ * Receive the mode and size of a file followed the file's contents and
+ * create or update the file whose path is <path> with the received
+ * information.
+ */
+
+int
+cvs_recvfile(const char *path)
+{
+	int fd;
+	mode_t mode;
+	size_t len;
+	ssize_t ret;
+	off_t fsz, cnt;
+	char buf[4096], *ep;
+
+	if ((cvs_client_getln(buf, sizeof(buf)) < 0) ||
+	    (cvs_strtomode(buf, &mode) < 0)) {
+		return (-1);
+	}
+
+	cvs_client_getln(buf, sizeof(buf));
+
+	fsz = (off_t)strtol(buf, &ep, 10);
+	if (*ep != '\0') {
+		cvs_log(LP_ERR, "parse error in file size transmission");
+		return (-1);
+	}
+
+	fd = open(path, O_RDONLY, mode);
+	if (fd == -1) {
+		cvs_log(LP_ERRNO, "failed to open `%s'", path);
+		return (-1);
+	}
+
+	cnt = 0;
+	do {
+		len = MIN(sizeof(buf), (size_t)(fsz - cnt));
+		ret = cvs_client_recvraw(buf, len);
+		if (ret == -1) {
+			(void)close(fd);
+			(void)unlink(path);
+			return (-1);
+		}
+
+		if (write(fd, buf, (size_t)ret) == -1) {
+			cvs_log(LP_ERRNO,
+			    "failed to write contents to file `%s'", path);
+			(void)close(fd);
+			(void)unlink(path);
+			return (-1);
+		}
+
+		cnt += (off_t)ret;
+	} while (cnt < fsz);
+
+	(void)close(fd);
+
+	return (0);
+}
diff --git a/usr.bin/cvs/rcs.c b/usr.bin/cvs/rcs.c
new file mode 100644
index 00000000000..20ded61cde4
--- /dev/null
+++ b/usr.bin/cvs/rcs.c
@@ -0,0 +1,1557 @@
+/*	$OpenBSD: rcs.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/stat.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "rcs.h"
+#include "log.h"
+
+#define RCS_BUFSIZE   8192
+
+
+/* RCS token types */
+#define RCS_TOK_ERR     -1
+#define RCS_TOK_EOF      0
+#define RCS_TOK_NUM      1
+#define RCS_TOK_ID       2
+#define RCS_TOK_STRING   3
+#define RCS_TOK_SCOLON   4
+#define RCS_TOK_COLON    5
+
+
+#define RCS_TOK_HEAD     8
+#define RCS_TOK_BRANCH   9
+#define RCS_TOK_ACCESS   10
+#define RCS_TOK_SYMBOLS  11
+#define RCS_TOK_LOCKS    12
+#define RCS_TOK_COMMENT  13
+#define RCS_TOK_EXPAND   14
+#define RCS_TOK_DATE     15
+#define RCS_TOK_AUTHOR   16
+#define RCS_TOK_STATE    17
+#define RCS_TOK_NEXT     18
+#define RCS_TOK_BRANCHES 19
+#define RCS_TOK_DESC     20
+#define RCS_TOK_LOG      21
+#define RCS_TOK_TEXT     22
+#define RCS_TOK_STRICT   23
+
+#define RCS_ISKEY(t)    (((t) >= RCS_TOK_HEAD) && ((t) <= RCS_TOK_BRANCHES))
+
+
+#define RCS_NOSCOL   0x01   /* no terminating semi-colon */
+#define RCS_VOPT     0x02   /* value is optional */
+
+
+
+/* opaque parse data */
+struct rcs_pdata {
+	u_int  rp_line;
+
+	char  *rp_buf;
+	size_t rp_blen;
+
+	/* pushback token buffer */
+	char   rp_ptok[128];
+	int    rp_pttype;       /* token type, RCS_TOK_ERR if no token */
+
+	FILE  *rp_file;
+};
+
+
+struct rcs_line {
+	char *rl_line;
+	int   rl_lineno;
+	TAILQ_ENTRY(rcs_line) rl_list;
+};
+
+
+struct rcs_foo {
+	int       rl_nblines;
+	char     *rl_data;
+	TAILQ_HEAD(rcs_tqh, rcs_line) rl_lines;
+};
+
+
+
+static int  rcs_parse_admin     (RCSFILE *);
+static int  rcs_parse_delta     (RCSFILE *);
+static int  rcs_parse_deltatext (RCSFILE *);
+
+static int      rcs_parse_access      (RCSFILE *);
+static int      rcs_parse_symbols     (RCSFILE *);
+static int      rcs_parse_locks       (RCSFILE *);
+static int      rcs_parse_branches    (RCSFILE *, struct rcs_delta *);
+static void     rcs_freedelta         (struct rcs_delta *);
+static void     rcs_freepdata         (struct rcs_pdata *);
+static int      rcs_gettok            (RCSFILE *);
+static int      rcs_pushtok           (RCSFILE *, const char *, int);
+static struct rcs_delta*  rcs_findrev (RCSFILE *, RCSNUM *);
+static struct rcs_foo* rcs_splitlines (const char *);
+
+#define RCS_TOKSTR(rfp)   ((struct rcs_pdata *)rfp->rf_pdata)->rp_buf
+#define RCS_TOKLEN(rfp)   ((struct rcs_pdata *)rfp->rf_pdata)->rp_blen
+
+
+static struct rcs_key {
+	char  rk_str[16];
+	int   rk_id;
+	int   rk_val;
+	int   rk_flags;
+} rcs_keys[] = {
+	{ "access",   RCS_TOK_ACCESS,   RCS_TOK_ID,     RCS_VOPT     },
+	{ "author",   RCS_TOK_AUTHOR,   RCS_TOK_STRING, 0            },
+	{ "branch",   RCS_TOK_BRANCH,   RCS_TOK_NUM,    RCS_VOPT     },
+	{ "branches", RCS_TOK_BRANCHES, RCS_TOK_NUM,    RCS_VOPT     },
+	{ "comment",  RCS_TOK_COMMENT,  RCS_TOK_STRING, RCS_VOPT     },
+	{ "date",     RCS_TOK_DATE,     RCS_TOK_NUM,    0            },
+	{ "desc",     RCS_TOK_DESC,     RCS_TOK_STRING, RCS_NOSCOL   },
+	{ "expand",   RCS_TOK_EXPAND,   RCS_TOK_STRING, RCS_VOPT     },
+	{ "head",     RCS_TOK_HEAD,     RCS_TOK_NUM,    RCS_VOPT     },
+	{ "locks",    RCS_TOK_LOCKS,    RCS_TOK_ID,     0            },
+	{ "log",      RCS_TOK_LOG,      RCS_TOK_STRING, RCS_NOSCOL   },
+	{ "next",     RCS_TOK_NEXT,     RCS_TOK_NUM,    RCS_VOPT     },
+	{ "state",    RCS_TOK_STATE,    RCS_TOK_STRING, RCS_VOPT     },
+	{ "strict",   RCS_TOK_STRICT,   0,              0,           },
+	{ "symbols",  RCS_TOK_SYMBOLS,  0,              0            },
+	{ "text",     RCS_TOK_TEXT,     RCS_TOK_STRING, RCS_NOSCOL   },
+};
+
+
+
+/*
+ * rcs_open()
+ *
+ * Open a file containing RCS-formatted information.  The file's path is
+ * given in <path>, and the opening mode is given in <mode>, which is either
+ * RCS_MODE_READ, RCS_MODE_WRITE, or RCS_MODE_RDWR.  If the mode requests write
+ * access and the file does not exist, it will be created.
+ * The file isn't actually parsed by rcs_open(); parsing is delayed until the
+ * first operation that requires information from the file.
+ * Returns a handle to the opened file on success, or NULL on failure.
+ */
+
+RCSFILE*
+rcs_open(const char *path, u_int mode)
+{
+	RCSFILE *rfp;
+	struct stat st;
+
+	if ((stat(path, &st) == -1) && (errno == ENOENT) &&
+	   !(mode & RCS_MODE_WRITE)) {
+		cvs_log(LP_ERRNO, "cannot open RCS file `%s'", path);
+		return (NULL);
+	}
+
+	rfp = (RCSFILE *)malloc(sizeof(*rfp));
+	if (rfp == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate RCS file structure");
+		return (NULL);
+	}
+	memset(rfp, 0, sizeof(*rfp));
+
+	rfp->rf_head = rcsnum_alloc();
+	if (rfp->rf_head == NULL) {
+		free(rfp);
+		return (NULL);
+	}
+
+	rfp->rf_path = strdup(path);
+	if (rfp->rf_path == NULL) {
+		cvs_log(LP_ERRNO, "failed to duplicate RCS file path");
+		rcs_close(rfp);
+		return (NULL);
+	}
+
+	rcsnum_aton(RCS_HEAD_INIT, NULL, rfp->rf_head);
+
+	rfp->rf_ref = 1;
+	rfp->rf_flags |= RCS_RF_SLOCK;
+	rfp->rf_mode = mode;
+
+	TAILQ_INIT(&(rfp->rf_delta));
+	TAILQ_INIT(&(rfp->rf_symbols));
+	TAILQ_INIT(&(rfp->rf_locks));
+
+	if (rcs_parse(rfp) < 0) {
+		rcs_close(rfp);
+		return (NULL);
+	}
+
+	return (rfp);
+}
+
+
+/*
+ * rcs_close()
+ *
+ * Close an RCS file handle.
+ */
+
+void
+rcs_close(RCSFILE *rfp)
+{
+	struct rcs_delta *rdp;
+
+	if (rfp->rf_ref > 1) {
+		rfp->rf_ref--;
+		return;
+	}
+
+	while (!TAILQ_EMPTY(&(rfp->rf_delta))) {
+		rdp = TAILQ_FIRST(&(rfp->rf_delta));
+		TAILQ_REMOVE(&(rfp->rf_delta), rdp, rd_list);
+		rcs_freedelta(rdp);
+	}
+
+	if (rfp->rf_head != NULL)
+		rcsnum_free(rfp->rf_head);
+
+	if (rfp->rf_path != NULL)
+		free(rfp->rf_path);
+	if (rfp->rf_comment != NULL)
+		free(rfp->rf_comment);
+	if (rfp->rf_expand != NULL)
+		free(rfp->rf_expand);
+	if (rfp->rf_desc != NULL)
+		free(rfp->rf_desc);
+	free(rfp);
+}
+
+
+/*
+ * rcs_write()
+ *
+ * Write the contents of the RCS file handle <rfp> to disk in the file whose
+ * path is in <rf_path>.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+rcs_write(RCSFILE *rfp)
+{
+	FILE *fp;
+	char buf[128], numbuf[64];
+	struct rcs_sym *symp;
+	struct rcs_lock *lkp;
+	struct rcs_delta *rdp;
+
+	if (rfp->rf_flags & RCS_RF_SYNCED)
+		return (0);
+
+	fp = fopen(rfp->rf_path, "w");
+	if (fp == NULL) {
+		cvs_log(LP_ERRNO, "failed to open RCS output file `%s'",
+		    rfp->rf_path);
+		return (-1);
+	}
+
+	rcsnum_tostr(rfp->rf_head, numbuf, sizeof(numbuf));
+	fprintf(fp, "head\t%s;\n", numbuf);
+	fprintf(fp, "access;\n");
+
+	fprintf(fp, "symbols\n");
+	TAILQ_FOREACH(symp, &(rfp->rf_symbols), rs_list) {
+		rcsnum_tostr(symp->rs_num, numbuf, sizeof(numbuf));
+		snprintf(buf, sizeof(buf), "%s:%s", symp->rs_name, numbuf);
+		fprintf(fp, "\t%s", buf);
+		if (symp != TAILQ_LAST(&(rfp->rf_symbols), rcs_slist))
+			fputc('\n', fp);
+	}
+	fprintf(fp, ";\n");
+
+	fprintf(fp, "locks;");
+
+	if (rfp->rf_flags & RCS_RF_SLOCK)
+		fprintf(fp, " strict;");
+	fputc('\n', fp);
+
+	if (rfp->rf_comment != NULL)
+		fprintf(fp, "comment\t@%s@;\n", rfp->rf_comment);
+
+	if (rfp->rf_expand != NULL)
+		fprintf(fp, "expand @ %s @;\n", rfp->rf_expand);
+
+	fprintf(fp, "\n\n");
+
+	TAILQ_FOREACH(rdp, &(rfp->rf_delta), rd_list) {
+		fprintf(fp, "%s\n", rcsnum_tostr(rdp->rd_num, numbuf,
+		    sizeof(numbuf)));
+		fprintf(fp, "date\t%d.%02d.%02d.%02d.%02d.%02d;",
+		    rdp->rd_date.tm_year, rdp->rd_date.tm_mon + 1,
+		    rdp->rd_date.tm_mday, rdp->rd_date.tm_hour,
+		    rdp->rd_date.tm_min, rdp->rd_date.tm_sec);
+		fprintf(fp, "\tauthor %s;\tstate %s;\n",
+		    rdp->rd_author, rdp->rd_state);
+		fprintf(fp, "branches;\n");
+		fprintf(fp, "next\t%s;\n\n", rcsnum_tostr(rdp->rd_next,
+		    numbuf, sizeof(numbuf)));
+	}
+
+	fprintf(fp, "\ndesc\n@%s@\n\n", rfp->rf_desc);
+
+	/* deltatexts */
+	TAILQ_FOREACH(rdp, &(rfp->rf_delta), rd_list) {
+		fprintf(fp, "\n%s\n", rcsnum_tostr(rdp->rd_num, numbuf,
+		    sizeof(numbuf)));
+		fprintf(fp, "log\n@%s@\n", rdp->rd_log);
+		fprintf(fp, "text\n@%s@\n\n", rdp->rd_text);
+	}
+	fclose(fp);
+
+	rfp->rf_flags |= RCS_RF_SYNCED;
+
+	return (0);
+}
+
+
+/*
+ * rcs_addsym()
+ *
+ * Add a symbol to the list of symbols for the RCS file <rfp>.  The new symbol
+ * is named <sym> and is bound to the RCS revision <snum>.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+rcs_addsym(RCSFILE *rfp, const char *sym, RCSNUM *snum)
+{
+	struct rcs_sym *symp;
+
+	/* first look for duplication */
+	TAILQ_FOREACH(symp, &(rfp->rf_symbols), rs_list) {
+		if (strcmp(symp->rs_name, sym) == 0) {
+			return (-1);
+		}
+	}
+
+	symp = (struct rcs_sym *)malloc(sizeof(*symp));
+	if (symp == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate RCS symbol");
+		return (-1);
+	}
+
+	symp->rs_name = strdup(sym);
+	symp->rs_num = rcsnum_alloc();
+	rcsnum_cpy(snum, symp->rs_num, 0);
+
+	TAILQ_INSERT_HEAD(&(rfp->rf_symbols), symp, rs_list);
+
+	/* not synced anymore */
+	rfp->rf_flags &= ~RCS_RF_SYNCED;
+
+	return (0);
+}
+
+
+/*
+ * rcs_patch()
+ *
+ * Apply an RCS-format patch pointed to by <patch> to the file contents
+ * found in <data>.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+BUF*
+rcs_patch(const char *data, const char *patch)
+{
+	char op, *ep;
+	size_t len;
+	int i, lineno, nbln;
+	struct rcs_foo *dlines, *plines;
+	struct rcs_line *lp, *dlp, *ndlp;
+	BUF *res;
+	FILE *fp;
+
+	len = strlen(data);
+	res = cvs_buf_alloc(len, BUF_AUTOEXT);
+	if (res == NULL)
+		return (NULL);
+
+	dlines = rcs_splitlines(data);
+	if (dlines == NULL)
+		return (NULL);
+	plines = rcs_splitlines(patch);
+	if (plines == NULL)
+		return (NULL);
+
+	dlp = TAILQ_FIRST(&(dlines->rl_lines));
+	lp = TAILQ_FIRST(&(plines->rl_lines));
+
+	/* skip first bogus line */
+	for (lp = TAILQ_NEXT(lp, rl_list); lp != NULL;
+	    lp = TAILQ_NEXT(lp, rl_list)) {
+		op = *(lp->rl_line);
+		lineno = (int)strtol((lp->rl_line + 1), &ep, 10);
+		if ((lineno > dlines->rl_nblines) || (lineno <= 0) ||
+		    (*ep != ' ')) {
+			cvs_log(LP_ERR,
+			    "invalid line specification in RCS patch");
+			return (NULL);
+		}
+		ep++;
+		nbln = (int)strtol(ep, &ep, 10);
+		if ((nbln <= 0) || (*ep != '\0')) {
+			cvs_log(LP_ERR,
+			    "invalid line number specification in RCS patch");
+			return (NULL);
+		}
+
+		/* find the appropriate line */
+		for (;;) {
+			if (dlp == NULL)
+				break;
+			if (dlp->rl_lineno == lineno)
+				break;
+			if (dlp->rl_lineno > lineno) {
+				dlp = TAILQ_PREV(dlp, rcs_tqh, rl_list);
+			}
+			else if (dlp->rl_lineno < lineno) {
+				ndlp = TAILQ_NEXT(dlp, rl_list);
+				if (ndlp->rl_lineno > lineno)
+					break;
+				dlp = ndlp;
+			}
+		}
+		if (dlp == NULL) {
+			cvs_log(LP_ERR,
+			    "can't find referenced line in RCS patch");
+			return (NULL);
+		}
+
+		if (op == 'd') {
+			for (i = 0; (i < nbln) && (dlp != NULL); i++) {
+				ndlp = TAILQ_NEXT(dlp, rl_list);
+				TAILQ_REMOVE(&(dlines->rl_lines), dlp, rl_list);
+				dlp = ndlp;
+			}
+		}
+		else if (op == 'a') {
+			for (i = 0; i < nbln; i++) {
+				ndlp = lp;
+				lp = TAILQ_NEXT(lp, rl_list);
+				if (lp == NULL) {
+					cvs_log(LP_ERR, "truncated RCS patch");
+					return (NULL);
+				}
+				TAILQ_REMOVE(&(plines->rl_lines), lp, rl_list);
+				TAILQ_INSERT_AFTER(&(dlines->rl_lines), dlp,
+				    lp, rl_list);
+				dlp = lp;
+
+				/* we don't want lookup to block on those */
+				lp->rl_lineno = lineno;
+
+				lp = ndlp;
+			}
+		}
+		else {
+			cvs_log(LP_ERR, "unknown RCS patch operation `%c'", op);
+			return (NULL);
+		}
+
+		/* last line of the patch, done */
+		if (lp->rl_lineno == plines->rl_nblines)
+			break;
+	}
+
+	/* once we're done patching, rebuild the line numbers */
+	lineno = 1;
+	TAILQ_FOREACH(lp, &(dlines->rl_lines), rl_list) {
+		if (lineno == 1) {
+			lineno++;
+			continue;
+		}
+		cvs_buf_fappend(res, "%s\n", lp->rl_line);
+		lp->rl_lineno = lineno++;
+	}
+
+	dlines->rl_nblines = lineno - 1;
+
+	return (res);
+}
+
+
+/*
+ * rcs_getrev()
+ *
+ * Get the whole contents of revision <rev> from the RCSFILE <rfp>.  The
+ * returned buffer is dynamically allocated and should be released using free()
+ * once the caller is done using it.
+ */
+
+BUF*
+rcs_getrev(RCSFILE *rfp, RCSNUM *rev)
+{
+	int res;
+	size_t len;
+	void *bp;
+	RCSNUM *crev;
+	BUF *rbuf;
+	struct rcs_delta *rdp = NULL;
+
+	res = rcsnum_cmp(rfp->rf_head, rev, 0);
+	if (res == 1) {
+		cvs_log(LP_ERR, "sorry, can't travel in the future yet");
+		return (NULL);
+	}
+	else {
+		rdp = rcs_findrev(rfp, rfp->rf_head);
+		if (rdp == NULL) {
+			cvs_log(LP_ERR, "failed to get RCS HEAD revision");
+			return (NULL);
+		}
+
+		len = strlen(rdp->rd_text);
+		rbuf = cvs_buf_alloc(len, BUF_AUTOEXT);
+		if (rbuf == NULL)
+			return (NULL);
+		cvs_buf_append(rbuf, rdp->rd_text, len);
+
+		if (res != 0) {
+			/* Apply patches backwards to get the right version.
+			 * This will need some rework to support sub branches.
+			 */
+			crev = rcsnum_alloc();
+
+			rcsnum_cpy(rfp->rf_head, crev, 0);
+			do {
+				crev->rn_id[crev->rn_len - 1]--;
+				rdp = rcs_findrev(rfp, crev);
+				if (rdp == NULL)
+					return (NULL);
+
+				cvs_buf_putc(rbuf, '\0');
+				bp = cvs_buf_release(rbuf);
+				rbuf = rcs_patch((char *)bp, rdp->rd_text);
+				if (rbuf == NULL)
+					break;
+			} while (rcsnum_cmp(crev, rev, 0) != 0);
+
+			rcsnum_free(crev);
+		}
+	}
+
+
+	return (rbuf);
+}
+
+
+/*
+ * rcs_getrevbydate()
+ *
+ * Get an RCS revision by a specific date.
+ */
+
+RCSNUM*
+rcs_getrevbydate(RCSFILE *rfp, struct tm *date)
+{
+	return (NULL);
+}
+
+
+/*
+ * rcs_findrev()
+ *
+ * Find a specific revision's delta entry in the tree of the RCS file <rfp>.
+ * The revision number is given in <rev>.
+ * Returns a pointer to the delta on success, or NULL on failure.
+ */
+
+static struct rcs_delta*
+rcs_findrev(RCSFILE *rfp, RCSNUM *rev)
+{
+	u_int cmplen;
+	struct rcs_delta *rdp;
+	struct rcs_dlist *hp;
+
+	cmplen = 2;
+	hp = &(rfp->rf_delta);
+
+	TAILQ_FOREACH(rdp, hp, rd_list) {
+		if (rcsnum_cmp(rdp->rd_num, rev, cmplen) == 0) {
+			if (cmplen == rev->rn_len)
+				return (rdp);
+
+			hp = &(rdp->rd_snodes);
+			cmplen += 2;
+		}
+	}
+
+	return (NULL);
+}
+
+
+/*
+ * rcs_parse()
+ *
+ * Parse the contents of file <path>, which are in the RCS format.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+rcs_parse(RCSFILE *rfp)
+{
+	int ret;
+	struct rcs_pdata *pdp;
+
+	if (rfp->rf_flags & RCS_RF_PARSED)
+		return (0);
+
+	pdp = (struct rcs_pdata *)malloc(sizeof(*pdp));
+	if (pdp == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate RCS parser data");
+		return (-1);
+	}
+	memset(pdp, 0, sizeof(*pdp));
+
+	pdp->rp_line = 1;
+	pdp->rp_pttype = RCS_TOK_ERR;
+
+	pdp->rp_file = fopen(rfp->rf_path, "r");
+	if (pdp->rp_file == NULL) {
+		cvs_log(LP_ERRNO, "failed to open RCS file `%s'", rfp->rf_path);
+		rcs_freepdata(pdp);
+		return (-1);
+	}
+
+	pdp->rp_buf = (char *)malloc(RCS_BUFSIZE);
+	if (pdp->rp_buf == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate RCS parser buffer");
+		rcs_freepdata(pdp);
+		return (-1);
+	}
+	pdp->rp_blen = RCS_BUFSIZE;
+
+	/* ditch the strict lock */
+	rfp->rf_flags &= ~RCS_RF_SLOCK;
+	rfp->rf_pdata = pdp;
+
+	if (rcs_parse_admin(rfp) < 0) {
+		rcs_freepdata(pdp);
+		return (-1);
+	}
+
+	for (;;) {
+		ret = rcs_parse_delta(rfp);
+		if (ret == 0)
+			break;
+		else if (ret == -1) {
+			rcs_freepdata(pdp);
+			return (-1);
+		}
+	}
+
+	ret = rcs_gettok(rfp);
+	if (ret != RCS_TOK_DESC) {
+		cvs_log(LP_ERR, "token `%s' found where RCS desc expected",
+		    RCS_TOKSTR(rfp));
+		rcs_freepdata(pdp);
+		return (-1);
+	}
+
+	ret = rcs_gettok(rfp);
+	if (ret != RCS_TOK_STRING) {
+		cvs_log(LP_ERR, "token `%s' found where RCS desc expected",
+		    RCS_TOKSTR(rfp));
+		rcs_freepdata(pdp);
+		return (-1);
+	}
+
+	rfp->rf_desc = strdup(RCS_TOKSTR(rfp));
+
+	for (;;) {
+		ret = rcs_parse_deltatext(rfp);
+		if (ret == 0)
+			break;
+		else if (ret == -1) {
+			rcs_freepdata(pdp);
+			return (-1);
+		}
+	}
+
+	cvs_log(LP_DEBUG, "RCS file `%s' parsed OK (%u lines)", rfp->rf_path,
+	    pdp->rp_line);
+
+	rcs_freepdata(pdp);
+
+	rfp->rf_pdata = NULL;
+	rfp->rf_flags |= RCS_RF_PARSED|RCS_RF_SYNCED;
+
+	return (0);
+}
+
+
+/*
+ * rcs_parse_admin()
+ *
+ * Parse the administrative portion of an RCS file.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+static int
+rcs_parse_admin(RCSFILE *rfp)
+{
+	u_int i;
+	int tok, ntok, hmask;
+	struct rcs_key *rk;
+
+	/* hmask is a mask of the headers already encountered */
+	hmask = 0;
+	for (;;) {
+		tok = rcs_gettok(rfp);
+		if (tok == RCS_TOK_ERR) {
+			cvs_log(LP_ERR, "parse error in RCS admin section");
+			return (-1);
+		}
+		else if (tok == RCS_TOK_NUM) {
+			/* assume this is the start of the first delta */
+			rcs_pushtok(rfp, RCS_TOKSTR(rfp), tok);
+			return (0);
+		}
+
+		rk = NULL;
+		for (i = 0; i < sizeof(rcs_keys)/sizeof(rcs_keys[0]); i++)
+			if (rcs_keys[i].rk_id == tok)
+				rk = &(rcs_keys[i]);
+
+		if (hmask & (1 << tok)) {
+			cvs_log(LP_ERR, "duplicate RCS key");
+			return (-1);
+		}
+		hmask |= (1 << tok);
+
+		switch (tok) {
+		case RCS_TOK_HEAD:
+		case RCS_TOK_BRANCH:
+		case RCS_TOK_COMMENT:
+		case RCS_TOK_EXPAND:
+			ntok = rcs_gettok(rfp);
+			if (ntok == RCS_TOK_SCOLON)
+				break;
+			if (ntok != rk->rk_val) {
+				cvs_log(LP_ERR,
+				    "invalid value type for RCS key `%s'",
+				    rk->rk_str);
+			}
+
+			if (tok == RCS_TOK_HEAD) {
+				rcsnum_aton(RCS_TOKSTR(rfp), NULL,
+				    rfp->rf_head);
+			}
+			else if (tok == RCS_TOK_BRANCH) {
+				rcsnum_aton(RCS_TOKSTR(rfp), NULL,
+				    rfp->rf_branch);
+			}
+			else if (tok == RCS_TOK_COMMENT) {
+				rfp->rf_comment = strdup(RCS_TOKSTR(rfp));
+			}
+			else if (tok == RCS_TOK_EXPAND) {
+				rfp->rf_expand = strdup(RCS_TOKSTR(rfp));
+			}
+
+			/* now get the expected semi-colon */
+			ntok = rcs_gettok(rfp);
+			if (ntok != RCS_TOK_SCOLON) {
+				cvs_log(LP_ERR,
+				    "missing semi-colon after RCS `%s' key",
+				    rk->rk_str);	
+				return (-1);
+			}
+			break;
+		case RCS_TOK_ACCESS:
+			rcs_parse_access(rfp);
+			break;
+		case RCS_TOK_SYMBOLS:
+			rcs_parse_symbols(rfp);
+			break;
+		case RCS_TOK_LOCKS:
+			rcs_parse_locks(rfp);
+			break;
+		default:
+			cvs_log(LP_ERR,
+			    "unexpected token `%s' in RCS admin section",
+			    RCS_TOKSTR(rfp));
+			return (-1);
+		}
+	}
+
+	return (0);
+}
+
+
+/*
+ * rcs_parse_delta()
+ *
+ * Parse an RCS delta section and allocate the structure to store that delta's
+ * information in the <rfp> delta list.
+ * Returns 1 if the section was parsed OK, 0 if it is the last delta, and
+ * -1 on error.
+ */
+
+static int
+rcs_parse_delta(RCSFILE *rfp)
+{
+	int ret, tok, ntok, hmask;
+	u_int i;
+	char *tokstr;
+	RCSNUM datenum;
+	struct rcs_delta *rdp;
+	struct rcs_key *rk;
+
+	rdp = (struct rcs_delta *)malloc(sizeof(*rdp));
+	if (rdp == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate RCS delta structure");
+		return (-1);
+	}
+	memset(rdp, 0, sizeof(*rdp));
+
+	rdp->rd_num = rcsnum_alloc();
+	rdp->rd_next = rcsnum_alloc();
+
+	TAILQ_INIT(&(rdp->rd_branches));
+
+	tok = rcs_gettok(rfp);
+	if (tok != RCS_TOK_NUM) {
+		cvs_log(LP_ERR, "unexpected token `%s' at start of delta",
+		    RCS_TOKSTR(rfp));
+		rcs_freedelta(rdp);
+		return (-1);
+	}
+	rcsnum_aton(RCS_TOKSTR(rfp), NULL, rdp->rd_num);
+
+	hmask = 0;
+	ret = 0;
+	tokstr = NULL;
+
+	for (;;) {
+		tok = rcs_gettok(rfp);
+		if (tok == RCS_TOK_ERR) {
+			cvs_log(LP_ERR, "parse error in RCS delta section");
+			rcs_freedelta(rdp);
+			return (-1);
+		}
+		else if (tok == RCS_TOK_NUM || tok == RCS_TOK_DESC) {
+			rcs_pushtok(rfp, RCS_TOKSTR(rfp), tok); 
+			ret = (tok == RCS_TOK_NUM ? 1 : 0);
+			break;
+		}
+
+		rk = NULL;
+		for (i = 0; i < sizeof(rcs_keys)/sizeof(rcs_keys[0]); i++)
+			if (rcs_keys[i].rk_id == tok)
+				rk = &(rcs_keys[i]);
+
+		if (hmask & (1 << tok)) {
+			cvs_log(LP_ERR, "duplicate RCS key");
+			rcs_freedelta(rdp);
+			return (-1);
+		}
+		hmask |= (1 << tok);
+
+		switch (tok) {
+		case RCS_TOK_DATE:
+		case RCS_TOK_AUTHOR:
+		case RCS_TOK_STATE:
+		case RCS_TOK_NEXT:
+			ntok = rcs_gettok(rfp);
+			if (ntok == RCS_TOK_SCOLON) {
+				if (rk->rk_flags & RCS_VOPT)
+					break;
+				else {
+					cvs_log(LP_ERR, "missing mandatory "
+					    "value to RCS key `%s'",
+					    rk->rk_str);
+					rcs_freedelta(rdp);
+					return (-1);
+				}
+			}
+
+			if (ntok != rk->rk_val) {
+				cvs_log(LP_ERR,
+				    "invalid value type for RCS key `%s'",
+				    rk->rk_str);
+				rcs_freedelta(rdp);
+				return (-1);
+			}
+
+			if (tokstr != NULL)
+				free(tokstr);
+			tokstr = strdup(RCS_TOKSTR(rfp));
+
+
+			/* now get the expected semi-colon */
+			ntok = rcs_gettok(rfp);
+			if (ntok != RCS_TOK_SCOLON) {
+				cvs_log(LP_ERR,
+				    "missing semi-colon after RCS `%s' key",
+				    rk->rk_str);	
+				rcs_freedelta(rdp);
+				return (-1);
+			}
+
+			if (tok == RCS_TOK_DATE) {
+				rcsnum_aton(tokstr, NULL, &datenum);
+				if (datenum.rn_len != 6) {
+					cvs_log(LP_ERR,
+					    "RCS date specification has %s "
+					    "fields",
+					    (datenum.rn_len > 6) ? "too many" :
+					    "missing");
+					rcs_freedelta(rdp);
+				}
+				rdp->rd_date.tm_year = datenum.rn_id[0];
+				rdp->rd_date.tm_mon = datenum.rn_id[1] - 1;
+				rdp->rd_date.tm_mday = datenum.rn_id[2];
+				rdp->rd_date.tm_hour = datenum.rn_id[3];
+				rdp->rd_date.tm_min = datenum.rn_id[4];
+				rdp->rd_date.tm_sec = datenum.rn_id[5];
+			}
+			else if (tok == RCS_TOK_AUTHOR) {
+				rdp->rd_author = tokstr;
+				tokstr = NULL;
+			}
+			else if (tok == RCS_TOK_STATE) {
+				rdp->rd_state = tokstr;
+				tokstr = NULL;
+			}
+			else if (tok == RCS_TOK_NEXT) {
+				rcsnum_aton(tokstr, NULL, rdp->rd_next);
+			}
+			break;
+		case RCS_TOK_BRANCHES:
+			rcs_parse_branches(rfp, rdp);
+			break;
+		default:
+			cvs_log(LP_ERR,
+			    "unexpected token `%s' in RCS delta",
+			    RCS_TOKSTR(rfp));
+			rcs_freedelta(rdp);
+			return (-1);
+		}
+	}
+
+	TAILQ_INSERT_TAIL(&(rfp->rf_delta), rdp, rd_list);
+
+	return (ret);
+}
+
+
+/*
+ * rcs_parse_deltatext()
+ *
+ * Parse an RCS delta text section and fill in the log and text field of the
+ * appropriate delta section.
+ * Returns 1 if the section was parsed OK, 0 if it is the last delta, and
+ * -1 on error.
+ */
+
+static int
+rcs_parse_deltatext(RCSFILE *rfp)
+{
+	int tok;
+	RCSNUM *tnum;
+	struct rcs_delta *rdp;
+
+	tnum = rcsnum_alloc();
+	if (tnum == NULL)
+		return (-1);
+
+	tok = rcs_gettok(rfp);
+	if (tok == RCS_TOK_EOF)
+		return (0);
+
+	if (tok != RCS_TOK_NUM) {
+		cvs_log(LP_ERR,
+		    "unexpected token `%s' at start of RCS delta text",
+		    RCS_TOKSTR(rfp));
+		return (-1);
+	}
+	rcsnum_aton(RCS_TOKSTR(rfp), NULL, tnum);
+
+	TAILQ_FOREACH(rdp, &(rfp->rf_delta), rd_list) {
+		if (rcsnum_cmp(tnum, rdp->rd_num, 0) == 0)
+			break;
+	}
+	if (rdp == NULL) {
+		cvs_log(LP_ERR, "RCS delta text `%s' has no matching delta",
+		    RCS_TOKSTR(rfp));
+		return (-1);
+	}
+
+	tok = rcs_gettok(rfp);
+	if (tok != RCS_TOK_LOG) {
+		cvs_log(LP_ERR, "unexpected token `%s' where RCS log expected",
+		    RCS_TOKSTR(rfp));
+		return (-1);
+	}
+
+	tok = rcs_gettok(rfp);
+	if (tok != RCS_TOK_STRING) {
+		cvs_log(LP_ERR, "unexpected token `%s' where RCS log expected",
+		    RCS_TOKSTR(rfp));
+		return (-1);
+	}
+	rdp->rd_log = strdup(RCS_TOKSTR(rfp));
+	if (rdp->rd_log == NULL) {
+		cvs_log(LP_ERRNO, "failed to copy RCS deltatext log");
+		return (-1);
+	}
+
+	tok = rcs_gettok(rfp);
+	if (tok != RCS_TOK_TEXT) {
+		cvs_log(LP_ERR, "unexpected token `%s' where RCS text expected",
+		    RCS_TOKSTR(rfp));
+		return (-1);
+	}
+
+	tok = rcs_gettok(rfp);
+	if (tok != RCS_TOK_STRING) {
+		cvs_log(LP_ERR, "unexpected token `%s' where RCS text expected",
+		    RCS_TOKSTR(rfp));
+		return (-1);
+	}
+
+	rdp->rd_text = strdup(RCS_TOKSTR(rfp));
+	if (rdp->rd_text == NULL) {
+		cvs_log(LP_ERRNO, "failed to copy RCS delta text");
+		return (-1);
+	}
+
+	return (1);
+}
+
+
+/*
+ * rcs_parse_access()
+ *
+ * Parse the access list given as value to the `access' keyword.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+static int
+rcs_parse_access(RCSFILE *rfp)
+{
+	int type;
+
+	while ((type = rcs_gettok(rfp)) != RCS_TOK_SCOLON) {
+		if (type != RCS_TOK_ID) {
+			cvs_log(LP_ERR, "unexpected token `%s' in access list",
+			    RCS_TOKSTR(rfp));
+			return (-1);
+		}
+	}
+
+	return (0);
+}
+
+
+/*
+ * rcs_parse_symbols()
+ *
+ * Parse the symbol list given as value to the `symbols' keyword.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+static int
+rcs_parse_symbols(RCSFILE *rfp)
+{
+	int type;
+	struct rcs_sym *symp;
+
+	for (;;) {
+		type = rcs_gettok(rfp);
+		if (type == RCS_TOK_SCOLON)
+			break;
+
+		if (type != RCS_TOK_STRING) {
+			cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
+			    RCS_TOKSTR(rfp));
+			return (-1);
+		}
+
+		symp = (struct rcs_sym *)malloc(sizeof(*symp));
+		if (symp == NULL) {
+			cvs_log(LP_ERRNO, "failed to allocate RCS symbol");
+			return (-1);
+		}
+		symp->rs_name = strdup(RCS_TOKSTR(rfp));
+		symp->rs_num = rcsnum_alloc();
+
+		type = rcs_gettok(rfp);
+		if (type != RCS_TOK_COLON) {
+			cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
+			    RCS_TOKSTR(rfp));
+			free(symp->rs_name);
+			free(symp);
+			return (-1);
+		}
+
+		type = rcs_gettok(rfp);
+		if (type != RCS_TOK_NUM) {
+			cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
+			    RCS_TOKSTR(rfp));
+			free(symp->rs_name);
+			free(symp);
+			return (-1);
+		}
+
+		if (rcsnum_aton(RCS_TOKSTR(rfp), NULL, symp->rs_num) < 0) {
+			cvs_log(LP_ERR, "failed to parse RCS NUM `%s'",
+			    RCS_TOKSTR(rfp));
+			free(symp->rs_name);
+			free(symp);
+			return (-1);
+		}
+
+		TAILQ_INSERT_HEAD(&(rfp->rf_symbols), symp, rs_list);
+	}
+
+	return (0);
+}
+
+
+/*
+ * rcs_parse_locks()
+ *
+ * Parse the lock list given as value to the `locks' keyword.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+static int
+rcs_parse_locks(RCSFILE *rfp)
+{
+	int type;
+	struct rcs_lock *lkp;
+
+	for (;;) {
+		type = rcs_gettok(rfp);
+		if (type == RCS_TOK_SCOLON)
+			break;
+
+		if (type != RCS_TOK_ID) {
+			cvs_log(LP_ERR, "unexpected token `%s' in lock list",
+			    RCS_TOKSTR(rfp));
+			return (-1);
+		}
+
+		lkp = (struct rcs_lock *)malloc(sizeof(*lkp));
+		if (lkp == NULL) {
+			cvs_log(LP_ERRNO, "failed to allocate RCS lock");
+			return (-1);
+		}
+		lkp->rl_num = rcsnum_alloc();
+
+		type = rcs_gettok(rfp);
+		if (type != RCS_TOK_COLON) {
+			cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
+			    RCS_TOKSTR(rfp));
+			free(lkp);
+			return (-1);
+		}
+
+		type = rcs_gettok(rfp);
+		if (type != RCS_TOK_NUM) {
+			cvs_log(LP_ERR, "unexpected token `%s' in symbol list",
+			    RCS_TOKSTR(rfp));
+			free(lkp);
+			return (-1);
+		}
+
+		if (rcsnum_aton(RCS_TOKSTR(rfp), NULL, lkp->rl_num) < 0) {
+			cvs_log(LP_ERR, "failed to parse RCS NUM `%s'",
+			    RCS_TOKSTR(rfp));
+			free(lkp);
+			return (-1);
+		}
+
+		TAILQ_INSERT_HEAD(&(rfp->rf_locks), lkp, rl_list);
+	}
+
+	/* check if we have a `strict' */
+	type = rcs_gettok(rfp);
+	if (type != RCS_TOK_STRICT) {
+		rcs_pushtok(rfp, RCS_TOKSTR(rfp), type);
+	}
+	else {
+		rfp->rf_flags |= RCS_RF_SLOCK;
+
+		type = rcs_gettok(rfp);
+		if (type != RCS_TOK_SCOLON) {
+			cvs_log(LP_ERR,
+			    "missing semi-colon after `strict' keyword");
+			return (-1);
+		}
+	}
+
+	return (0);
+}
+
+/*
+ * rcs_parse_branches()
+ *
+ * Parse the list of branches following a `branches' keyword in a delta.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+static int
+rcs_parse_branches(RCSFILE *rfp, struct rcs_delta *rdp)
+{
+	int type;
+	struct rcs_branch *brp;
+
+	for (;;) {
+		type = rcs_gettok(rfp);
+		if (type == RCS_TOK_SCOLON)
+			break;
+
+		if (type != RCS_TOK_NUM) {
+			cvs_log(LP_ERR,
+			    "unexpected token `%s' in list of branches",
+			    RCS_TOKSTR(rfp));
+			return (-1);
+		}
+
+		brp = (struct rcs_branch *)malloc(sizeof(*brp));
+		if (brp == NULL) {
+			cvs_log(LP_ERRNO, "failed to allocate RCS branch");
+			return (-1);
+		}
+		brp->rb_num = rcsnum_alloc();
+		rcsnum_aton(RCS_TOKSTR(rfp), NULL, brp->rb_num);
+
+		TAILQ_INSERT_TAIL(&(rdp->rd_branches), brp, rb_list);
+	}
+
+	return (0);
+}
+
+
+/*
+ * rcs_freedelta()
+ *
+ * Free the contents of a delta structure.
+ */
+
+void
+rcs_freedelta(struct rcs_delta *rdp)
+{
+	struct rcs_delta *crdp;
+
+	if (rdp->rd_author != NULL)
+		free(rdp->rd_author);
+	if (rdp->rd_state != NULL)
+		free(rdp->rd_state);
+	if (rdp->rd_log != NULL)
+		free(rdp->rd_log);
+	if (rdp->rd_text != NULL)
+		free(rdp->rd_text);
+
+	while ((crdp = TAILQ_FIRST(&(rdp->rd_snodes))) != NULL) {
+		TAILQ_REMOVE(&(rdp->rd_snodes), crdp, rd_list);
+		rcs_freedelta(crdp);
+	}
+
+	free(rdp);
+}
+
+
+/*
+ * rcs_freepdata()
+ *
+ * Free the contents of the parser data structure.
+ */
+
+static void
+rcs_freepdata(struct rcs_pdata *pd)
+{
+	if (pd->rp_file != NULL)
+		(void)fclose(pd->rp_file);
+	if (pd->rp_buf != NULL)
+		free(pd->rp_buf);
+	free(pd);
+}
+
+
+/*
+ * rcs_gettok()
+ *
+ * Get the next RCS token from the string <str>.
+ */
+
+static int
+rcs_gettok(RCSFILE *rfp)
+{
+	u_int i;
+	int ch, last, type;
+	char *bp, *bep;
+	struct rcs_pdata *pdp = (struct rcs_pdata *)rfp->rf_pdata;
+
+	type = RCS_TOK_ERR;
+	bp = pdp->rp_buf;
+	bep = pdp->rp_buf + pdp->rp_blen - 1;
+	*bp = '\0';
+
+	if (pdp->rp_pttype != RCS_TOK_ERR) {
+		type = pdp->rp_pttype;
+		strlcpy(pdp->rp_buf, pdp->rp_ptok, pdp->rp_blen);
+		pdp->rp_pttype = RCS_TOK_ERR;
+		return (type);
+	}
+
+	/* skip leading whitespace */
+	/* XXX we must skip backspace too for compatibility, should we? */
+	do {
+		ch = getc(pdp->rp_file);
+		if (ch == '\n')
+			pdp->rp_line++;
+	} while (isspace(ch));
+
+	if (ch == EOF) {
+		type = RCS_TOK_EOF;
+	}
+	else if (ch == ';') {
+		type = RCS_TOK_SCOLON;
+	}
+	else if (ch == ':') {
+		type = RCS_TOK_COLON;
+	}
+	else if (isalpha(ch)) {
+		*(bp++) = ch;
+		while (bp <= bep - 1) {
+			ch = getc(pdp->rp_file);
+			if (!isalnum(ch)) {
+				ungetc(ch, pdp->rp_file);
+				break;
+			}
+			*(bp++) = ch;
+		}
+		*bp = '\0';
+
+		for (i = 0; i < sizeof(rcs_keys)/sizeof(rcs_keys[0]); i++) {
+			if (strcmp(rcs_keys[i].rk_str, pdp->rp_buf) == 0) { 
+				type = rcs_keys[i].rk_id;
+				break;
+			}
+		}
+
+		/* not a keyword, assume it's just a string */
+		if (type == RCS_TOK_ERR)
+			type = RCS_TOK_STRING;
+	}
+	else if (ch == '@') {
+		/* we have a string */
+		for (;;) {
+			ch = getc(pdp->rp_file);
+			if (ch == '@') {
+				ch = getc(pdp->rp_file);
+				if (ch != '@') {
+					ungetc(ch, pdp->rp_file);
+					break;
+				}
+			}
+			else if (ch == '\n')
+				pdp->rp_line++;
+
+			*(bp++) = ch;
+			if (bp == bep)
+				break;
+		}
+
+		*bp = '\0';
+		type = RCS_TOK_STRING;
+	}
+	else if (isdigit(ch)) {
+		*(bp++) = ch;
+		last = ch;
+		type = RCS_TOK_NUM;
+
+		for (;;) {
+			ch = getc(pdp->rp_file);
+			if (bp == bep)
+				break;
+			if (!isdigit(ch) && ch != '.') {
+				ungetc(ch, pdp->rp_file);
+				break;
+			}
+
+			if (last == '.' && ch == '.') {
+				type = RCS_TOK_ERR;
+				break;
+			}
+			last = ch;
+			*(bp++) = ch;
+		}
+		*(bp) = '\0';
+	}
+
+	return (type);
+}
+
+
+/*
+ * rcs_pushtok()
+ *
+ * Push a token back in the parser's token buffer.
+ */
+
+static int
+rcs_pushtok(RCSFILE *rfp, const char *tok, int type)
+{
+	struct rcs_pdata *pdp = (struct rcs_pdata *)rfp->rf_pdata;
+
+	if (pdp->rp_pttype != RCS_TOK_ERR)
+		return (-1);
+
+	pdp->rp_pttype = type;
+	strlcpy(pdp->rp_ptok, tok, sizeof(pdp->rp_ptok));
+	return (0);
+}
+
+
+/*
+ * rcs_stresc()
+ *
+ * Performs either escaping or unescaping of the string stored in <str>.
+ * The operation is to escape special RCS characters if the <esc> argument
+ * is 1, or unescape otherwise.  The result is stored in the <buf> destination
+ * buffer, and <blen> must originally point to the size of <buf>.
+ * Returns the number of bytes which have been read from the source <str> and
+ * operated on.  The <blen> parameter will contain the number of bytes
+ * actually copied in <buf>.
+ */
+
+size_t
+rcs_stresc(int esc, const char *str, char *buf, size_t *blen)
+{
+	size_t rlen;
+	const char *sp;
+	char *bp, *bep;
+
+	if (!esc)
+		printf("unescaping `%s'\n", str);
+
+	rlen = 0;
+	bp = buf;
+	bep = buf + *blen - 1;
+
+	for (sp = str; (*sp != '\0') && (bp <= (bep - 1)); sp++) {
+		if (*sp == '@') {
+			if (esc) {
+				if (bp > (bep - 2))
+					break;
+				*(bp++) = '@';
+			}
+			else {
+				sp++;
+				if (*sp != '@') {
+					cvs_log(LP_WARN,
+					    "unknown escape character `%c' in "
+					    "RCS file", *sp);
+					if (*sp == '\0')
+						break;
+				}
+			}
+		}
+
+		*(bp++) = *sp;
+	}
+
+	*bp = '\0';
+	*blen = (bp - buf);
+	return (sp - str);
+}
+
+
+/*
+ * rcs_splitlines()
+ *
+ * Split the contents of a file into a list of lines.
+ */
+
+static struct rcs_foo*
+rcs_splitlines(const char *fcont)
+{
+	char *dcp;
+	struct rcs_foo *foo;
+	struct rcs_line *lp;
+
+	foo = (struct rcs_foo *)malloc(sizeof(*foo));
+	if (foo == NULL) {
+		cvs_log(LP_ERR, "failed to allocate line structure");
+		return (NULL);
+	}
+	TAILQ_INIT(&(foo->rl_lines));
+	foo->rl_nblines = 0;
+	foo->rl_data = strdup(fcont);
+	if (foo->rl_data == NULL) {
+		cvs_log(LP_ERRNO, "failed to copy file contents");
+		free(foo);
+		return (NULL);
+	}
+
+	/*
+	 * Add a first bogus line with line number 0.  This is used so we
+	 * can position the line pointer before 1 when changing the first line
+	 * in rcs_patch().
+	 */
+	lp = (struct rcs_line *)malloc(sizeof(*lp));
+	if (lp == NULL) {
+		return (NULL);
+	}
+	lp->rl_line = NULL;
+	lp->rl_lineno = 0;
+	TAILQ_INSERT_TAIL(&(foo->rl_lines), lp, rl_list);
+
+
+	for (dcp = foo->rl_data; *dcp != '\0';) {
+		lp = (struct rcs_line *)malloc(sizeof(*lp));
+		if (lp == NULL) {
+			cvs_log(LP_ERR, "failed to allocate line entry");
+			return (NULL);
+		}
+
+		lp->rl_line = dcp;
+		lp->rl_lineno = ++(foo->rl_nblines);
+		TAILQ_INSERT_TAIL(&(foo->rl_lines), lp, rl_list);
+
+		dcp = strchr(dcp, '\n');
+		if (dcp == NULL) {
+			break;
+		}
+		*(dcp++) = '\0';
+	}
+
+	return (foo);
+}
diff --git a/usr.bin/cvs/rcs.h b/usr.bin/cvs/rcs.h
new file mode 100644
index 00000000000..b902ce3e1ef
--- /dev/null
+++ b/usr.bin/cvs/rcs.h
@@ -0,0 +1,151 @@
+/*	$OpenBSD: rcs.h,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#ifndef RCS_H
+#define RCS_H
+
+#include <sys/types.h>
+#include <sys/queue.h>
+
+#include <time.h>
+
+#include "buf.h"
+
+#define RCS_DIFF_MAXARG   32
+#define RCS_DIFF_DIV \
+	"==================================================================="
+
+#define RCS_FILE_EXT   ",v"
+
+#define RCS_HEAD_INIT  "1.1"
+
+
+/* open modes */
+#define RCS_MODE_READ   0x01
+#define RCS_MODE_WRITE  0x02
+#define RCS_MODE_RDWR   (RCS_MODE_READ|RCS_MODE_WRITE)
+
+
+/* file flags */
+#define RCS_RF_PARSED  0x01   /* file has been parsed */
+#define RCS_RF_SYNCED  0x02   /* in-memory copy is in sync with disk copy */
+#define RCS_RF_SLOCK   0x04   /* strict lock */
+
+/* delta flags */
+#define RCS_RD_DEAD   0x01     /* dead */
+
+
+typedef struct rcs_num {
+	u_int      rn_len;
+	u_int16_t *rn_id;
+} RCSNUM;
+
+
+
+struct rcs_sym {
+	char    *rs_name;
+	RCSNUM  *rs_num;
+	TAILQ_ENTRY(rcs_sym) rs_list;
+};
+
+struct rcs_lock {
+	RCSNUM   *rl_num;
+
+	TAILQ_ENTRY(rcs_lock) rl_list;
+};
+
+
+struct rcs_branch {
+	RCSNUM  *rb_num;
+	TAILQ_ENTRY(rcs_branch) rb_list;
+};
+
+struct rcs_dlist {
+	struct rcs_delta *tqh_first;
+	struct rcs_delta **tqh_last;
+};
+
+struct rcs_delta {
+	RCSNUM      *rd_num;
+	RCSNUM      *rd_next;
+	u_int        rd_flags;
+	struct tm    rd_date;
+	char        *rd_author;
+	char        *rd_state;
+	char        *rd_log;
+	char        *rd_text;
+
+	struct rcs_dlist rd_snodes;
+
+	TAILQ_HEAD(, rcs_branch) rd_branches;
+	TAILQ_ENTRY(rcs_delta)  rd_list;
+};
+
+
+
+typedef struct rcs_file {
+	char   *rf_path;
+	u_int   rf_ref;
+	u_int   rf_mode;
+	u_int   rf_flags;
+
+	RCSNUM *rf_head;
+	RCSNUM *rf_branch;
+	char   *rf_comment;
+	char   *rf_expand;
+	char   *rf_desc;
+
+	struct rcs_dlist rf_delta;
+	TAILQ_HEAD(rcs_slist, rcs_sym)   rf_symbols;
+	TAILQ_HEAD(rcs_llist, rcs_lock)  rf_locks;
+
+	void   *rf_pdata;
+} RCSFILE;
+
+
+
+
+RCSFILE*  rcs_open         (const char *, u_int);
+void      rcs_close        (RCSFILE *);
+int       rcs_parse        (RCSFILE *);
+int       rcs_write        (RCSFILE *);
+int       rcs_addsym       (RCSFILE *, const char *, RCSNUM *);
+int       rcs_rmsym        (RCSFILE *, const char *);
+BUF*      rcs_getrev       (RCSFILE *, RCSNUM *);
+RCSNUM*   rcs_getrevbydate (RCSFILE *, struct tm *);
+
+BUF*      rcs_patch     (const char *, const char *);
+size_t    rcs_stresc    (int, const char *, char *, size_t *);
+
+RCSNUM*   rcsnum_alloc  (void);
+void      rcsnum_free   (RCSNUM *);
+int       rcsnum_aton   (const char *, char **, RCSNUM *);
+char*     rcsnum_tostr  (const RCSNUM *, char *, size_t);
+int       rcsnum_cpy    (const RCSNUM *, RCSNUM *, u_int);
+int       rcsnum_cmp    (const RCSNUM *, const RCSNUM *, u_int);
+
+
+#endif /* RCS_H */
diff --git a/usr.bin/cvs/rcsnum.c b/usr.bin/cvs/rcsnum.c
new file mode 100644
index 00000000000..b2694c62da7
--- /dev/null
+++ b/usr.bin/cvs/rcsnum.c
@@ -0,0 +1,231 @@
+/*	$OpenBSD: rcsnum.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/param.h>
+
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "rcs.h"
+#include "log.h"
+
+
+
+/*
+ * rcsnum_alloc()
+ *
+ * Allocate an RCS number structure.
+ */
+
+RCSNUM*
+rcsnum_alloc(void)
+{
+	RCSNUM *rnp;
+
+	rnp = (RCSNUM *)malloc(sizeof(*rnp));
+	if (rnp == NULL) {
+		cvs_log(LP_ERR, "failed to allocate RCS number");
+		return (NULL);
+	}
+	rnp->rn_len = 0;
+	rnp->rn_id = NULL;
+
+	return (rnp);
+}
+
+
+/*
+ * rcsnum_free()
+ *
+ * Free an RCSNUM structure previously allocated with rcsnum_alloc().
+ */
+
+void
+rcsnum_free(RCSNUM *rn)
+{
+	if (rn->rn_id != NULL)
+		free(rn->rn_id);
+	free(rn);
+}
+
+
+/*
+ * rcsnum_tostr()
+ * Returns a pointer to the start of <buf> on success, or NULL on failure.
+ */
+
+char*
+rcsnum_tostr(const RCSNUM *nump, char *buf, size_t blen)
+{
+	u_int i;
+	char tmp[8];
+
+	if (nump->rn_len == 0) {
+		buf[0] = '\0';
+		return (buf);
+	}
+
+	snprintf(buf, blen, "%u", nump->rn_id[0]); 
+	for (i = 1; i < nump->rn_len; i++) {
+		snprintf(tmp, sizeof(tmp), ".%u", nump->rn_id[i]);
+		strlcat(buf, tmp, blen);
+	}
+
+	return (buf);
+}
+
+
+/*
+ * rcsnum_cpy()
+ *
+ * Copy the number stored in <nsrc> in the destination <ndst> up to <depth>
+ * numbers deep.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+rcsnum_cpy(const RCSNUM *nsrc, RCSNUM *ndst, u_int depth)
+{
+	u_int len;
+	size_t sz;
+	void *tmp;
+
+	len = nsrc->rn_len;
+	if ((depth != 0) && (len > depth))
+		len = depth;
+	sz = len * sizeof(u_int16_t);
+
+	tmp = realloc(ndst->rn_id, sz);
+	if (tmp == NULL) {
+		cvs_log(LP_ERR, "failed to reallocate RCSNUM");
+		return (-1);
+	}
+
+	ndst->rn_id = (u_int16_t *)tmp;
+	ndst->rn_len = len;
+	memcpy(ndst->rn_id, nsrc->rn_id, sz);
+	return (0);
+}
+
+
+/*
+ * rcsnum_cmp()
+ *
+ * Compare the two numbers <n1> and <n2>. Returns -1 if <n1> is larger than
+ * <n2>, 0 if they are both the same, and 1 if <n2> is larger than <n1>.
+ * The <depth> argument specifies how many numbers deep should be checked for
+ * the result.  A value of 0 means that the depth will be the minimum of the
+ * two numbers.
+ */
+
+int
+rcsnum_cmp(const RCSNUM *n1, const RCSNUM *n2, u_int depth)
+{
+	int res;
+	u_int i;
+	size_t slen;
+
+	slen = MIN(n1->rn_len, n2->rn_len);
+	if ((depth != 0) && (slen > depth))
+		slen = depth;
+		
+	for (i = 0; i < slen; i++) {
+		res = n1->rn_id[i] - n2->rn_id[i];
+		if (res < 0)
+			return (1);
+		else if (res > 0)
+			return (-1);
+	}
+
+	if (n1->rn_len > n2->rn_len)
+		return (-1);
+	else if (n2->rn_len > n1->rn_len)
+		return (1);
+
+	return (0);
+}
+
+
+/*
+ * rcsnum_aton()
+ *
+ * Translate the string <str> containing a sequence of digits and periods into
+ * its binary representation, which is stored in <nump>.  The address of the
+ * first byte not part of the number is stored in <ep> on return, if it is not
+ * NULL.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+rcsnum_aton(const char *str, char **ep, RCSNUM *nump)
+{
+	const char *sp;
+	void *tmp;
+
+	if (!isdigit(*str))
+		return (-1);
+
+	nump->rn_id = (u_int16_t *)malloc(sizeof(u_int16_t));
+	if (nump->rn_id == NULL)
+		return (-1);
+
+	nump->rn_len = 0;
+
+	for (sp = str; ; sp++) {
+		if (!isdigit(*sp) && (*sp != '.')) {
+			if (nump->rn_id[nump->rn_len] == 0) {
+				return (-1);
+			}
+			break;
+		}
+
+		if (*sp == '.') {
+			nump->rn_len++;
+			tmp = realloc(nump->rn_id,
+			    (nump->rn_len + 1) * sizeof(u_int16_t));
+			if (tmp == NULL) {
+				free(nump->rn_id);
+				nump->rn_len = 0;
+				nump->rn_id = NULL;
+				return (-1);
+			}
+			nump->rn_id = (u_int16_t *)tmp;
+			continue;
+		}
+
+		nump->rn_id[nump->rn_len] *= 10;
+		nump->rn_id[nump->rn_len] += *sp - 0x30;
+	}
+
+	if (ep != NULL)
+		*ep = (char *)sp;
+
+	nump->rn_len++;
+	return (nump->rn_len);
+}
diff --git a/usr.bin/cvs/root.c b/usr.bin/cvs/root.c
new file mode 100644
index 00000000000..3b34a38fb5b
--- /dev/null
+++ b/usr.bin/cvs/root.c
@@ -0,0 +1,261 @@
+/*	$OpenBSD: root.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/types.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <err.h>
+#include <errno.h>
+#include <string.h>
+#include <paths.h>
+
+#include "cvs.h"
+#include "log.h"
+
+
+extern char *cvs_rootstr;
+
+
+/* keep these ordered with the defines */
+const char *cvs_methods[] = {
+	"",
+	"local",
+	"ssh",
+	"pserver",
+	"kserver",
+	"gserver",
+	"ext",
+	"fork",
+};
+
+#define CVS_NBMETHODS  (sizeof(cvs_methods)/sizeof(cvs_methods[0]))
+ 
+
+
+/*
+ * cvsroot_parse()
+ *
+ * Parse a CVS root string (as found in CVS/Root files or the CVSROOT
+ * environment variable) and store the fields in a dynamically
+ * allocated cvs_root structure.  The format of the string is as follows:
+ *	:method:path
+ * Returns a pointer to the allocated information on success, or NULL
+ * on failure.
+ */
+
+struct cvsroot*
+cvsroot_parse(const char *str)
+{
+	u_int i;
+	char *cp, *sp, *pp;
+	struct cvsroot *root;
+
+	root = (struct cvsroot *)malloc(sizeof(*root));
+	if (root == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate CVS root data");
+		return (NULL);
+	}
+
+	root->cr_method = CVS_METHOD_NONE;
+
+	root->cr_buf = strdup(str);
+	if (root->cr_buf == NULL) {
+		cvs_log(LP_ERRNO, "failed to copy CVS root");
+		free(root);
+		return (NULL);
+	}
+
+	sp = root->cr_buf;
+	cp = root->cr_buf;
+
+	if (*sp == ':') {
+		sp++;
+		cp = strchr(sp, ':');
+		if (cp == NULL) {
+			cvs_log(LP_ERR, "failed to parse CVSROOT: "
+			    "unterminated method");
+			free(root->cr_buf);
+			free(root);
+			return (NULL);
+		}
+		*(cp++) = '\0';
+
+		for (i = 0; i < CVS_NBMETHODS; i++) {
+			if (strcmp(sp, cvs_methods[i]) == 0) {
+				root->cr_method = i;
+				break;
+			}
+		}
+	}
+
+	/* find the start of the actual path */
+	sp = strchr(cp, '/');
+	if (sp == NULL) {
+		cvs_log(LP_ERR, "no path specification in CVSROOT");
+		free(root->cr_buf);
+		free(root);
+		return (NULL);
+	}
+
+	root->cr_dir = sp;
+	if (sp == cp) {
+		if (root->cr_method == CVS_METHOD_NONE)
+			root->cr_method = CVS_METHOD_LOCAL;
+		/* stop here, it's just a path */
+		return (root);
+	}
+
+	if (*(sp - 1) != ':') {
+		cvs_log(LP_ERR, "missing host/path delimiter in CVS root");
+		free(root);
+		return (NULL);
+	}
+	*(sp - 1) = '\0';
+
+	/*
+	 * looks like we have more than just a directory path, so
+	 * attempt to split it into user and host parts
+	 */
+	sp = strchr(cp, '@');
+	if (sp != NULL) {
+		*(sp++) = '\0';
+
+		/* password ? */
+		pp = strchr(cp, ':');
+		if (pp != NULL) {
+			*(pp++) = '\0';
+			root->cr_pass = pp;
+		}
+
+		root->cr_user = cp;
+	}
+
+	pp = strchr(sp, ':');
+	if (pp != NULL) {
+		*(pp++) = '\0';
+		root->cr_port = (u_int)strtol(pp, &cp, 10);
+		if (*cp != '\0' || root->cr_port > 65535) {
+			cvs_log(LP_ERR,
+			    "invalid port specification in CVSROOT");
+			free(root);
+			return (NULL);
+		}
+
+	}
+
+	root->cr_host = sp;
+
+	if (root->cr_method == CVS_METHOD_NONE) {
+		/* no method found from start of CVSROOT, guess */
+		if (root->cr_host != NULL)
+			root->cr_method = CVS_METHOD_SERVER;
+		else
+			root->cr_method = CVS_METHOD_LOCAL;
+	}
+
+	return (root);
+}
+
+
+/*
+ * cvsroot_free()
+ *
+ * Free a CVSROOT structure previously allocated and returned by
+ * cvsroot_parse().
+ */
+
+void
+cvsroot_free(struct cvsroot *root)
+{
+	free(root->cr_buf);
+	free(root);
+}
+
+
+/*
+ * cvsroot_get()
+ *
+ * Get the CVSROOT information for a specific directory <dir>.  The
+ * value is taken from one of 3 possible sources (in order of precedence):
+ *
+ * 1) the `-d' command-line option
+ * 2) the CVS/Root file found in checked-out trees
+ * 3) the CVSROOT environment variable
+ */
+
+struct cvsroot*
+cvsroot_get(const char *dir)
+{
+	size_t len;
+	char rootpath[MAXPATHLEN], *rootstr, *line;
+	FILE *fp;
+	struct cvsroot *rp;
+
+	if (cvs_rootstr != NULL)
+		return cvsroot_parse(cvs_rootstr);
+
+	snprintf(rootpath, sizeof(rootpath), "%s/" CVS_PATH_ROOTSPEC, dir);
+	fp = fopen(rootpath, "r");
+	if (fp == NULL) {
+		if (errno == ENOENT) {
+			/* try env as a last resort */
+			if ((rootstr = getenv("CVSROOT")) != NULL)
+				return cvsroot_parse(rootstr);
+			else
+				return (NULL);
+		}
+		else {
+			cvs_log(LP_ERRNO, "failed to open CVS/Root");
+			return (NULL);
+		}
+	}
+
+	line = fgetln(fp, &len);
+	if (line == NULL) {
+		cvs_log(LP_ERR, "failed to read CVSROOT line from CVS/Root");
+		(void)fclose(fp);
+	}
+
+	/* line is not NUL-terminated, but we don't need to allocate an
+	 * extra byte because we don't want the trailing newline.  It will
+	 * get replaced by a \0.
+	 */
+	rootstr = (char *)malloc(len);
+	if (rootstr == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate CVSROOT string");
+		(void)fclose(fp);
+		return (NULL);
+	}
+	strlcpy(rootstr, line, len);
+	rp = cvsroot_parse(rootstr);
+
+	(void)fclose(fp);
+	free(rootstr);
+
+	return (rp);
+}
diff --git a/usr.bin/cvs/server.c b/usr.bin/cvs/server.c
new file mode 100644
index 00000000000..6cc75bec08c
--- /dev/null
+++ b/usr.bin/cvs/server.c
@@ -0,0 +1,95 @@
+/*	$OpenBSD: server.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/types.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <paths.h>
+#include <sysexits.h>
+
+#include "cvs.h"
+#include "log.h"
+#include "sock.h"
+
+
+extern struct cvsroot *cvs_root;
+
+
+
+/* argument vector built by the `Argument' and `Argumentx' requests */
+char   **cvs_args;
+u_int    cvs_nbarg = 0;
+
+u_int   cvs_utf8ok = 0;
+u_int   cvs_case   = 0;
+
+
+
+/*
+ * cvs_server()
+ *
+ * Implement the `cvs server' command.  As opposed to the general method of
+ * CVS client/server implementation, the cvs program merely acts as a
+ * redirector to the cvs daemon for most of the tasks.
+ *
+ * The `cvs server' command is only used on the server side of a remote
+ * cvs command.  With this command, the cvs program starts listening on
+ * standard input for CVS protocol requests.
+ */
+
+int
+cvs_server(int argc, char **argv)
+{
+	ssize_t ret;
+	char reqbuf[128];
+
+	if (argc != 1) {
+		return (EX_USAGE);
+	}
+
+	for (;;) {
+		ret = read(STDIN_FILENO, reqbuf, sizeof(reqbuf));
+		if (ret == 0) {
+			break;
+		}
+
+
+	}
+
+
+	if (cvs_sock_connect(cvs_root->cr_dir) < 0) {
+		cvs_log(LP_ERR, "failed to connect to CVS server socket");
+		return (-1);
+	}
+
+	cvs_sock_disconnect();
+
+	return (0);
+}
diff --git a/usr.bin/cvs/sock.c b/usr.bin/cvs/sock.c
new file mode 100644
index 00000000000..0dcfbdcaca2
--- /dev/null
+++ b/usr.bin/cvs/sock.c
@@ -0,0 +1,237 @@
+/*	$OpenBSD: sock.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#include <poll.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+
+#include "log.h"
+#include "sock.h"
+#include "cvsd.h"
+#include "event.h"
+
+
+volatile sig_atomic_t  cvs_sock_doloop;
+
+
+char     *cvsd_sock_path = CVSD_SOCK_PATH;
+
+
+
+/* daemon API */
+static int cvsd_sock = -1;
+static struct sockaddr_un cvsd_sun;
+
+/* for client API */
+static int cvs_sock = -1;
+static struct sockaddr_un cvs_sun;
+
+
+/*
+ * cvsd_sock_open()
+ *
+ * Open the daemon's local socket.
+ */
+
+int
+cvsd_sock_open(void)
+{
+	cvsd_sun.sun_family = AF_LOCAL;
+	strlcpy(cvsd_sun.sun_path, cvsd_sock_path, sizeof(cvsd_sun.sun_path));
+
+	cvsd_sock = socket(AF_LOCAL, SOCK_STREAM, 0);
+	if (cvsd_sock == -1) {
+		cvs_log(LP_ERRNO, "failed to open socket"); 
+		return (-1);
+	}
+
+	if (bind(cvsd_sock, (struct sockaddr *)&cvsd_sun,
+	    SUN_LEN(&cvsd_sun)) == -1) {
+		cvs_log(LP_ERRNO, "failed to bind local socket to `%s'",
+		    cvsd_sock_path);
+		(void)close(cvsd_sock);
+		return (-1);
+	}
+
+	listen(cvsd_sock, 10);
+
+	if (chmod(cvsd_sock_path, CVSD_SOCK_PERMS) == -1) {
+		cvs_log(LP_ERRNO, "failed to change mode of `%s'",
+		    cvsd_sock_path);
+		(void)close(cvsd_sock);
+		(void)unlink(cvsd_sock_path);
+		return (-1);
+	}
+
+	cvs_log(LP_DEBUG, "opened local socket `%s'", cvsd_sock_path);
+
+	return (0);
+}
+
+
+/*
+ * cvsd_sock_close()
+ *
+ * Close the local socket.
+ */
+
+void
+cvsd_sock_close(void)
+{
+	cvs_log(LP_DEBUG, "closing local socket `%s'", CVSD_SOCK_PATH);
+	if (close(cvsd_sock) == -1) {
+		cvs_log(LP_ERRNO, "failed to close local socket");
+	}
+	if (unlink(cvsd_sock_path) == -1)
+		cvs_log(LP_ERRNO, "failed to unlink local socket `%s'",
+		    CVSD_SOCK_PATH);
+}
+
+
+/*
+ * cvsd_sock_loop()
+ *
+ */
+
+void
+cvsd_sock_loop(void)
+{
+	int nfds, sock;
+	socklen_t slen;
+	struct sockaddr_un sun;
+	struct pollfd pfd[1];
+
+	cvs_sock_doloop = 1;
+
+	while (cvs_sock_doloop) {
+		pfd[0].fd = cvsd_sock;
+		pfd[0].events = POLLIN;
+
+		nfds = poll(pfd, 1, INFTIM);
+		if (nfds == -1) {
+			if (errno == EINTR)
+				continue;
+			cvs_log(LP_ERR, "failed to poll local socket");
+		}
+
+		if ((nfds == 0) || !(pfd[0].revents & POLLIN))
+			continue;
+
+		sock = accept(pfd[0].fd, (struct sockaddr *)&sun, &slen);
+		if (sock == -1) {
+			cvs_log(LP_ERRNO, "failed to accept connection");
+		}
+		cvs_log(LP_DEBUG, "accepted connection");
+
+		cvsd_sock_hdl(sock);
+	}
+
+
+}
+
+
+/*
+ * cvsd_sock_hdl()
+ *
+ * Handle the events for a single connection.
+ */
+
+int
+cvsd_sock_hdl(int fd)
+{
+	uid_t uid;
+	gid_t gid;
+	struct cvs_event ev;
+
+	/* don't trust what the other end put in */
+	if (getpeereid(fd, &uid, &gid) == -1) {
+		cvs_log(LP_ERR, "failed to get peer credentials");
+		(void)close(fd);
+		return (-1);
+	}
+
+	if (read(fd, &ev, sizeof(ev)) == -1) {
+		cvs_log(LP_ERR, "failed to read cvs event");
+		return (-1);
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvs_sock_connect()
+ *
+ * Open a connection to the CVS server's local socket.
+ */
+
+int
+cvs_sock_connect(const char *cvsroot)
+{
+	cvs_sun.sun_family = AF_LOCAL;
+	snprintf(cvs_sun.sun_path, sizeof(cvs_sun.sun_path), "%s/%s",
+	    cvsroot, CVSD_SOCK_PATH);
+
+	cvs_log(LP_INFO, "connecting to CVS server socket `%s'",
+	    cvs_sun.sun_path);
+
+	cvs_sock = socket(AF_LOCAL, SOCK_STREAM, 0);
+	if (cvs_sock == -1) {
+		cvs_log(LP_ERRNO, "failed to open local socket");
+		return (-1);
+	}
+
+	if (connect(cvs_sock, (struct sockaddr *)&cvs_sun,
+	    SUN_LEN(&cvs_sun)) == -1) {
+		cvs_log(LP_ERRNO, "failed to connect to server socket `%s'",
+		    cvs_sun.sun_path);
+		(void)close(cvs_sock);
+		return (-1);
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvs_sock_disconnect()
+ *
+ * Disconnect from the open socket to the CVS server.
+ */
+
+void
+cvs_sock_disconnect(void)
+{
+	if (close(cvs_sock) == -1)
+		cvs_log(LP_ERRNO, "failed to close local socket");
+}
diff --git a/usr.bin/cvs/sock.h b/usr.bin/cvs/sock.h
new file mode 100644
index 00000000000..6595cec951a
--- /dev/null
+++ b/usr.bin/cvs/sock.h
@@ -0,0 +1,65 @@
+/*	$OpenBSD: sock.h,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#ifndef SOCK_H
+#define SOCK_H
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+
+#include <err.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "cvs.h"
+
+
+#define CVSD_SOCK_PATH  "/var/run/cvsd.sock"
+
+#define CVSD_SOCK_PERMS (S_IRWXU | S_IRWXG)
+
+
+extern char *cvsd_sock_path;
+
+extern volatile sig_atomic_t cvs_sock_doloop;
+
+
+/* daemon api */
+int  cvsd_sock_open   (void);
+void cvsd_sock_close  (void);
+void cvsd_sock_loop   (void);
+int  cvsd_sock_hdl    (int);
+
+/* client api */
+int  cvs_sock_connect    (const char *);
+void cvs_sock_disconnect (void);
+
+#endif /* SOCK_H */
diff --git a/usr.bin/cvs/update.c b/usr.bin/cvs/update.c
new file mode 100644
index 00000000000..4305740f7e5
--- /dev/null
+++ b/usr.bin/cvs/update.c
@@ -0,0 +1,85 @@
+/*	$OpenBSD: update.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sysexits.h>
+
+#include "cvs.h"
+#include "rcs.h"
+#include "log.h"
+
+extern char *__progname;
+
+extern struct cvsroot *cvs_root;
+
+
+/*
+ * cvs_update()
+ *
+ * Handle the `cvs update' command.
+ */
+
+
+int
+cvs_update(int argc, char **argv)
+{
+	int ch;
+
+	while ((ch = getopt(argc, argv, "ACD:dflPpQqRr:")) != -1) {
+		switch (ch) {
+		case 'A':
+		case 'C':
+		case 'D':
+		case 'd':
+		case 'f':
+		case 'l':
+		case 'P':
+		case 'p':
+		case 'Q':
+		case 'q':
+		case 'R':
+		case 'r':
+			break;
+		default:
+			fprintf(stderr, "Usage: %s [args] update [args] ...\n",
+			    __progname);
+			return (EX_USAGE);
+		}
+	}
+
+	argc -= optind;
+	argv += optind;
+
+	return (0);
+}
diff --git a/usr.bin/cvs/util.c b/usr.bin/cvs/util.c
new file mode 100644
index 00000000000..f0c579bdebf
--- /dev/null
+++ b/usr.bin/cvs/util.c
@@ -0,0 +1,386 @@
+/*	$OpenBSD: util.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <md5.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "cvs.h"
+#include "log.h"
+
+
+/* letter -> mode type map */
+static const int cvs_modetypes[26] = {
+	-1, -1, -1, -1, -1, -1,  1, -1, -1, -1, -1, -1, -1,
+	-1,  2, -1, -1, -1, -1, -1,  0, -1, -1, -1, -1, -1,
+};
+
+/* letter -> mode map */
+static const mode_t cvs_modes[3][26] = {
+	{
+		0,  0,       0,       0,       0,  0,  0,    /* a - g */
+		0,  0,       0,       0,       0,  0,  0,    /* h - m */
+		0,  0,       0,       S_IRUSR, 0,  0,  0,    /* n - u */
+		0,  S_IWUSR, S_IXUSR, 0,       0             /* v - z */
+	},
+	{
+		0,  0,       0,       0,       0,  0,  0,    /* a - g */
+		0,  0,       0,       0,       0,  0,  0,    /* h - m */
+		0,  0,       0,       S_IRGRP, 0,  0,  0,    /* n - u */
+		0,  S_IWGRP, S_IXGRP, 0,       0             /* v - z */
+	},
+	{
+		0,  0,       0,       0,       0,  0,  0,    /* a - g */
+		0,  0,       0,       0,       0,  0,  0,    /* h - m */
+		0,  0,       0,       S_IROTH, 0,  0,  0,    /* n - u */
+		0,  S_IWOTH, S_IXOTH, 0,       0             /* v - z */
+	}
+};
+
+
+/* octal -> string */
+static const char *cvs_modestr[8] = {
+	"", "x", "w", "wx", "r", "rx", "rw", "rwx"
+};
+
+
+
+
+/*
+ * cvs_readrepo()
+ *
+ * Read the path stored in the `Repository' CVS file for a given directory
+ * <dir>, and store that path into the buffer pointed to by <dst>, whose size
+ * is <len>.
+ */
+
+int
+cvs_readrepo(const char *dir, char *dst, size_t len)
+{
+	size_t dlen;
+	FILE *fp;
+	char repo_path[MAXPATHLEN];
+
+	snprintf(repo_path, sizeof(repo_path), "%s/CVS/Repository", dir);
+
+	fp = fopen(repo_path, "r");
+	if (fp == NULL) {
+		cvs_log(LP_ERRNO, "failed to open `%s'", repo_path);
+		return (-1);
+	}
+
+	if (fgets(dst, (int)len, fp) == NULL) {
+		if (ferror(fp)) {
+			cvs_log(LP_ERRNO, "failed to read from `%s'",
+			    repo_path);
+		}
+		(void)fclose(fp);
+		return (-1);
+	}
+	dlen = strlen(dst);
+	if ((dlen > 0) && (dst[dlen - 1] == '\n'))
+		dst[--dlen] = '\0';
+
+	(void)fclose(fp);
+
+	return (0);
+}
+
+
+/*
+ * cvs_strtomode()
+ *
+ * Read the contents of the string <str> and generate a permission mode from
+ * the contents of <str>, which is assumed to have the mode format of CVS.
+ * The CVS protocol specification states that any modes or mode types that are
+ * not recognized should be silently ignored.  This function does not return
+ * an error in such cases, but will issue warnings.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+cvs_strtomode(const char *str, mode_t *mode)
+{
+	int type;
+	mode_t m;
+	char buf[32], ms[4], *sp, *ep;
+
+	m = 0;
+	strlcpy(buf, str, sizeof(buf));
+	sp = buf;
+	ep = sp;
+
+	for (sp = buf; ep != NULL; sp = ep + 1) {
+		ep = strchr(sp, ',');
+		if (ep != NULL)
+			*(ep++) = '\0';
+
+		if (sscanf(sp, "%c=%3s", (char *)&type, ms) != 2) {
+			cvs_log(LP_WARN, "failed to scan mode string `%s'", sp);
+			continue;
+		}
+
+		if ((type <= 'a') || (type >= 'z') ||
+		    (cvs_modetypes[type - 'a'] == -1)) {
+			cvs_log(LP_WARN,
+			    "invalid mode type `%c'"
+			    " (`u', `g' or `o' expected), ignoring", type);
+			continue;
+		}
+
+		/* make type contain the actual mode index */
+		type = cvs_modetypes[type - 'a'];
+
+		for (sp = ms; *sp != '\0'; sp++) {
+			if ((*sp <= 'a') || (*sp >= 'z') ||
+			    (cvs_modes[type][*sp - 'a'] == 0)) {
+				cvs_log(LP_WARN,
+				    "invalid permission bit `%c'", *sp);
+			}
+			else
+				m |= cvs_modes[type][*sp - 'a'];
+		}
+	}
+
+	*mode = m;
+
+	return (0);
+}
+
+
+/*
+ * cvs_modetostr()
+ *
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+cvs_modetostr(mode_t mode, char *buf, size_t len)
+{
+	size_t l;
+	char tmp[16], *bp;
+	mode_t um, gm, om;
+
+	um = (mode & S_IRWXU) >> 6;
+	gm = (mode & S_IRWXG) >> 3;
+	om = mode & S_IRWXO;
+
+	bp = buf;
+	*bp = '\0';
+	l = 0;
+
+	if (um) {
+		snprintf(tmp, sizeof(tmp), "u=%s", cvs_modestr[um]);
+		l = strlcat(buf, tmp, len); 
+	}
+	if (gm) {
+		if (um)
+			strlcat(buf, ",", len);
+		snprintf(tmp, sizeof(tmp), "g=%s", cvs_modestr[gm]);
+		strlcat(buf, tmp, len); 
+	}
+	if (om) {
+		if (um || gm)
+			strlcat(buf, ",", len);
+		snprintf(tmp, sizeof(tmp), "o=%s", cvs_modestr[gm]);
+		strlcat(buf, tmp, len); 
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvs_cksum()
+ *
+ * Calculate the MD5 checksum of the file whose path is <file> and generate
+ * a CVS-format 32 hex-digit string, which is stored in <dst>, whose size is
+ * given in <len> and must be at least 33.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+cvs_cksum(const char *file, char *dst, size_t len)
+{
+	if (len < CVS_CKSUM_LEN) {
+		cvs_log(LP_WARN, "buffer too small for checksum");
+		return (-1);
+	}
+	if (MD5File(file, dst) == NULL) {
+		cvs_log(LP_ERRNO, "failed to generate file checksum");
+		return (-1);
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvs_splitpath()
+ *
+ * Split a path <path> into the directory portion and the filename portion
+ * and copy them in <dir> and <file>, whose lengths are <dlen> and <flen>,
+ * unless they are NULL.
+ * Returns 0 on success, or -1 on failure.
+ */
+
+int
+cvs_splitpath(const char *path, char *dir, size_t dlen, char *file, size_t flen)
+{
+	size_t rlen;
+	const char *sp;
+	struct stat st;
+
+	sp = strrchr(path, '/');
+	if (sp == NULL) {
+		if (stat(path, &st) == -1)
+			return (-1);
+
+		if (S_ISDIR(st.st_mode)) {
+			if (dir != NULL)
+				strlcpy(dir, path, dlen);
+			if (file != NULL)
+				file[0] = '\0';
+		}
+		else {
+			if (file != NULL)
+				strlcpy(file, path, flen);
+			if (dir != NULL)
+				strlcpy(dir, ".", dlen);
+		}
+	}
+	else {
+		rlen = MIN(dlen - 1, sp - path);
+		if (dir != NULL) {
+			strncpy(dir, path, rlen);
+			dir[rlen] = '\0';
+		}
+
+		sp++;
+		if (file != NULL)
+			strlcpy(file, sp, flen);
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvs_getargv()
+ *
+ * Parse a line contained in <line> and generate an argument vector by
+ * splitting the line on spaces and tabs.  The resulting vector is stored in
+ * <argv>, which can accept up to <argvlen> entries.
+ * Returns the number of arguments in the vector, or -1 if an error occured.
+ */
+
+int
+cvs_getargv(const char *line, char **argv, int argvlen)
+{
+	u_int i;
+	int argc, err;
+	char linebuf[256], qbuf[128], *lp, *cp, *arg;
+
+	strlcpy(linebuf, line, sizeof(linebuf));
+	memset(argv, 0, sizeof(argv));
+	argc = 0;
+
+	/* build the argument vector */
+	err = 0;
+	for (lp = linebuf; lp != NULL;) {
+		if (*lp == '"') {
+			/* double-quoted string */
+			lp++;
+			i = 0;
+			memset(qbuf, 0, sizeof(qbuf));
+			while (*lp != '"') {
+				if (*lp == '\0') {
+					cvs_log(LP_ERR, "no terminating quote");
+					err++;
+					break;
+				}
+				else if (*lp == '\\')
+					lp++;
+
+				qbuf[i++] = *lp++; 
+				if (i == sizeof(qbuf)) {
+					err++;
+					break;
+				}
+			}
+
+			arg = qbuf;
+		}
+		else {
+			cp = strsep(&lp, " \t");
+			if (cp == NULL)
+				break;
+			else if (*cp == '\0')
+				continue;
+
+			arg = cp;
+		}
+
+		argv[argc] = strdup(arg);
+		if (argv[argc] == NULL) {
+			cvs_log(LP_ERRNO, "failed to copy argument");
+			err++;
+			break;
+		}
+		argc++;
+	}
+
+	if (err) {
+		/* ditch the argument vector */
+		for (i = 0; i < (u_int)argc; i++)
+			free(argv[i]);
+		argc = -1;
+	}
+
+	return (argc);
+}
+
+
+/*
+ * cvs_freeargv()
+ *
+ * Free an argument vector previously generated by cvs_getargv().
+ */
+
+void
+cvs_freeargv(char **argv, int argc)
+{
+	int i;
+
+	for (i = 0; i < argc; i++)
+		free(argv[i]);
+}
diff --git a/usr.bin/cvs/version.c b/usr.bin/cvs/version.c
new file mode 100644
index 00000000000..ab220397d1d
--- /dev/null
+++ b/usr.bin/cvs/version.c
@@ -0,0 +1,69 @@
+/*	$OpenBSD: version.c,v 1.1 2004/07/13 22:02:40 jfb Exp $	*/
+/*
+ * Copyright (c) 2004 Jean-Francois Brousseau <jfb@openbsd.org>
+ * All rights reserved. 
+ *
+ * Redistribution and use in source and binary forms, with or without 
+ * modification, are permitted provided that the following conditions 
+ * are met: 
+ *
+ * 1. Redistributions of source code must retain the above copyright 
+ *    notice, this list of conditions and the following disclaimer. 
+ * 2. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <sys/types.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sysexits.h>
+
+#include "cvs.h"
+
+
+
+extern struct cvsroot *cvs_root;
+
+
+
+int
+cvs_version(int argc, char **argv)
+{
+	if (argc > 1)
+		return (EX_USAGE);
+
+	cvs_root = cvsroot_get(".");
+
+	if ((cvs_root) && (cvs_root->cr_method != CVS_METHOD_LOCAL))
+		printf("Client: ");
+
+	printf("%s\n", CVS_VERSION);
+
+
+	if ((cvs_root) && (cvs_root->cr_method != CVS_METHOD_LOCAL))
+		if (cvs_client_connect() < 0)
+			return (1);
+
+	if ((cvs_root) && (cvs_root->cr_method != CVS_METHOD_LOCAL)) {
+		printf("Server: ");
+		cvs_client_sendreq(CVS_REQ_VERSION, NULL, 1);
+		cvs_client_disconnect();
+	}
+
+	return (0);
+}