basic repository handling code, not plugged yet

2 files changed, 794 insertions, 0 deletions

diff --git a/usr.bin/cvs/repo.c b/usr.bin/cvs/repo.c
new file mode 100644
index 00000000000..013f3538441
--- /dev/null
+++ b/usr.bin/cvs/repo.c
@@ -0,0 +1,638 @@
+/*	$OpenBSD: repo.c,v 1.1 2005/02/16 15:41:15 jfb Exp $	*/
+/*
+ * Copyright (c) 2005 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 <sys/stat.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <string.h>
+#include <libgen.h>
+
+#include "log.h"
+#include "repo.h"
+#include "cvsd.h"
+
+
+
+static CVSRPENT*  cvs_repo_loadrec (CVSREPO *, const char *);
+
+
+/*
+ * cvs_repo_load()
+ *
+ * Load the information for a specific CVS repository whose base directory
+ * is specified in <base>.
+ */
+
+CVSREPO*
+cvs_repo_load(const char *base, int flags)
+{
+	struct stat st;
+	CVSREPO *repo;
+
+	cvs_log(LP_DEBUG, "loading repository %s", base);
+
+	if (stat(base, &st) == -1) {
+		cvs_log(LP_ERRNO, "failed to stat %s", base);
+		return (NULL);
+	}
+
+	if (!S_ISDIR(st.st_mode)) {
+		cvs_log(LP_ERR, "%s: repository path is not a directory", base);
+		return (NULL);
+	}
+
+	repo = (struct cvs_repo *)malloc(sizeof(*repo));
+	if (repo == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate repository data");
+		return (NULL);
+	}
+	memset(repo, 0, sizeof(*repo));
+
+	TAILQ_INIT(&(repo->cr_modules));
+
+	repo->cr_path = strdup(base);
+	if (repo->cr_path == NULL) {
+		cvs_log(LP_ERRNO, "failed to copy repository path");
+		free(repo);
+		return (NULL);
+	}
+
+	repo->cr_tree = cvs_repo_loadrec(repo, repo->cr_path);
+	if (repo->cr_tree == NULL) {
+		cvs_repo_free(repo);
+		return (NULL);
+	}
+
+	return (repo);
+}
+
+
+/*
+ * cvs_repo_free()
+ *
+ * Free the data associated to a repository.
+ */
+
+void
+cvs_repo_free(CVSREPO *repo)
+{
+	CVSMODULE *mod;
+
+	if (repo != NULL) {
+		if (repo->cr_path != NULL)
+			free(repo->cr_path);
+
+		while ((mod = TAILQ_FIRST(&(repo->cr_modules))) != NULL) {
+			TAILQ_REMOVE(&(repo->cr_modules), mod, cm_link);
+			cvs_repo_modfree(mod);
+		}
+
+		if (repo->cr_tree != NULL)
+			cvs_repo_entfree(repo->cr_tree);
+
+		free(repo);
+	}
+}
+
+
+/*
+ * cvs_repo_lockdir()
+ *
+ * Obtain a lock on the directory <dir> which is relative to the root of
+ * the repository <repo>.  The owner of the lock becomes <pid>.
+ * Returns 0 on success, or -1 on failure.
+ */
+int
+cvs_repo_lockdir(CVSREPO *repo, const char *dir, int type, pid_t owner)
+{
+	CVSRPENT *ent;
+
+	if ((ent = cvs_repo_find(repo, dir)) == NULL) {
+		return (-1);
+	}
+
+	return cvs_repo_lockent(ent, type, owner);
+}
+
+
+/*
+ * cvs_repo_unlockdir()
+ *
+ * Attempt to unlock the directory <dir> in the repository <repo>.  The <owner>
+ * argument is used to make sure that the caller really owns the lock it is
+ * trying to release.
+ * Returns 0 on success, or -1 on failure.
+ */
+int
+cvs_repo_unlockdir(CVSREPO *repo, const char *dir, pid_t owner)
+{
+	CVSRPENT *ent;
+
+	if ((ent = cvs_repo_find(repo, dir)) == NULL) {
+		return (-1);
+	}
+
+	return cvs_repo_unlockent(ent, owner);
+}
+
+
+/*
+ * cvs_repo_lockent()
+ *
+ * Obtain a lock on the entry <ent>.  The owner of the lock becomes <pid>.
+ * Returns 0 on success, or -1 on failure.
+ */
+int
+cvs_repo_lockent(CVSRPENT *ent, int type, pid_t owner)
+{
+	struct cvs_lock *lk;
+	struct cvs_lklist *list;
+
+	if ((type != CVS_LOCK_READ) && (type != CVS_LOCK_WRITE)) {
+		cvs_log(LP_ERR, "invalid lock type (%d) requested");
+		return (-1);
+	}
+
+	lk = (struct cvs_lock *)malloc(sizeof(*lk));
+	if (lk == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate repository lock");
+		return (-1);
+	}
+	lk->lk_owner = owner;
+	lk->lk_type = type;
+	lk->lk_ent = ent;
+
+	if ((ent->cr_wlock != NULL) && (ent->cr_wlock->lk_owner != 0)) {
+		/*
+		 * Another process has already locked the entry with a write
+		 * lock, so regardless of the type of lock we are requesting,
+		 * we'll have to wait in the pending requests queue.
+		 */ 
+		if (ent->cr_wlock->lk_owner == owner) {
+			cvs_log(LP_WARN, "double-lock attempt");
+			free(lk);
+		} else
+			TAILQ_INSERT_TAIL(&(ent->cr_lkreq), lk, lk_link);
+	} else {
+		if (type == CVS_LOCK_READ) {
+			/*
+			 * If there are any pending write lock requests,
+			 * add the read lock request at the tail of the queue
+			 * instead of assigning it right away.  Otherwise,
+			 * we could end up with a write lock request never
+			 * being obtained if other processes make overlapping
+			 * read lock requests.
+			 */
+			if (TAILQ_EMPTY(&(ent->cr_lkreq)))
+				list = &(ent->cr_rlocks);
+			else
+				list = &(ent->cr_lkreq);
+			TAILQ_INSERT_TAIL(list, lk, lk_link);
+		} else if (type == CVS_LOCK_WRITE) {
+			if (TAILQ_EMPTY(&(ent->cr_rlocks)))
+				ent->cr_wlock = lk;
+			else
+				TAILQ_INSERT_TAIL(&(ent->cr_lkreq), lk, lk_link);
+		}
+	}
+
+	return (0);
+}
+
+
+/*
+ * cvs_repo_unlockent()
+ *
+ * Attempt to unlock the entry <ent>.  The <owner> argument is used to make
+ * sure that the caller really owns the lock it is trying to release.
+ * Returns 0 on success, or -1 on failure.
+ */
+int
+cvs_repo_unlockent(CVSRPENT *ent, pid_t owner)
+{
+	struct cvs_lock *lk;
+
+	if ((ent->cr_wlock != NULL) && (ent->cr_wlock->lk_owner != 0)) {
+		if (ent->cr_wlock->lk_owner != owner) {
+			cvs_log(LP_ERR, "child %d attempted to unlock write "
+			    "lock owned by %d", ent->cr_wlock->lk_owner);
+			return (-1);
+		}
+
+		free(ent->cr_wlock);
+		ent->cr_wlock = NULL;
+	} else {
+		TAILQ_FOREACH(lk, &(ent->cr_rlocks), lk_link) {
+			if (lk->lk_owner == owner) {
+				TAILQ_REMOVE(&(ent->cr_rlocks), lk, lk_link);
+				free(lk);
+				break;
+			}
+		}
+	}
+
+#ifdef notyet
+	/* assign lock to any process with a pending request */
+	while ((lk = TAILQ_FIRST(&(ent->cr_lkreq))) != NULL) {
+		TAILQ_REMOVE(&(ent->cr_lkreq), lk, lk_link);
+		/* XXX send message to process */
+		child = cvsd_child_find(lk->lk_owner);
+		if (child == NULL)
+			continue;
+
+		break;
+	}
+#endif
+
+	return (0);
+}
+
+
+/*
+ * cvs_repo_alias()
+ *
+ * Add a new module entry with name <alias> in the repository <repo>, which
+ * points to the path <path> within the repository. 
+ * Returns 0 on success, or -1 on failure.
+ */
+int
+cvs_repo_alias(CVSREPO *repo, const char *path, const char *alias)
+{
+	CVSMODULE *mod;
+
+	mod = (CVSMODULE *)malloc(sizeof(*mod));
+	if (mod == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate module alias");
+		return (-1);
+	}
+	memset(mod, 0, sizeof(*mod));
+
+	mod->cm_name = strdup(alias);
+	if (mod->cm_name == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate module alias");
+		free(mod);
+		return (-1);
+	}
+	mod->cm_flags |= CVS_MODULE_ISALIAS;
+
+	mod->cm_path = strdup(path);
+	if (mod->cm_path == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate module alias");
+		free(mod->cm_name);
+		free(mod);
+		return (-1);
+	}
+
+	TAILQ_INSERT_TAIL(&(repo->cr_modules), mod, cm_link);
+
+	return (0);
+}
+
+
+/*
+ * cvs_repo_unalias()
+ *
+ * Remove the module alias <alias> from the repository <repo>.
+ * Returns 0 on success, or -1 on failure.
+ */
+int
+cvs_repo_unalias(CVSREPO *repo, const char *alias)
+{
+	CVSMODULE *mod;
+
+	TAILQ_FOREACH(mod, &(repo->cr_modules), cm_link) {
+		if (strcmp(mod->cm_name, alias) == 0) {
+			if (!(mod->cm_flags & CVS_MODULE_ISALIAS)) {
+				cvs_log(LP_ERR,
+				    "attempt to remove non-aliased module `%s'",
+				    mod->cm_name);
+				return (-1);
+			}
+
+			break;
+		}
+	}
+	if (mod == NULL)
+		return (-1);
+
+	TAILQ_REMOVE(&(repo->cr_modules), mod, cm_link);
+	return (0);
+}
+
+
+/*
+ * cvs_repo_find()
+ *
+ * Find the pointer to a CVS file entry within the file hierarchy <hier>.
+ * The file's pathname <path> must be relative to the base of <hier>.
+ * Returns the entry on success, or NULL on failure.
+ */
+CVSRPENT*
+cvs_repo_find(CVSREPO *repo, const char *path)
+{
+	size_t len;
+	char *pp, *sp, pbuf[MAXPATHLEN];
+	CVSRPENT *sf, *cf;
+
+	if ((len = strlcpy(pbuf, path, sizeof(pbuf))) >= sizeof(pbuf)) {
+		cvs_log(LP_ERR, "path %s too long", path);
+		return (NULL);
+	}
+
+	/* remove any trailing slashes */
+	while ((len > 0) && (pbuf[len - 1] == '/'))
+		pbuf[--len] = '\0';
+
+	cf = repo->cr_tree;
+	pp = pbuf;
+	do {
+		if (cf->cr_type != CVS_RPENT_DIR) {
+			cvs_log(LP_ERR,
+			    "part of the path %s is not a directory", path);
+			return (NULL);
+		}
+		sp = strchr(pp, '/');
+		if (sp != NULL)
+			*(sp++) = '\0';
+
+		/* special case */
+		if (*pp == '.') {
+			if ((*(pp + 1) == '.') && (*(pp + 2) == '\0')) {
+				/* request to go back to parent */
+				if (cf->cr_parent == NULL) {
+					cvs_log(LP_NOTICE,
+					    "path %s goes back too far", path);
+					return (NULL);
+				}
+				cf = cf->cr_parent;
+				continue;
+			} else if (*(pp + 1) == '\0')
+				continue;
+		}
+
+		TAILQ_FOREACH(sf, &(cf->cr_files), cr_link) {
+			if (strcmp(pp, sf->cr_name) == 0)
+				break;
+		}
+		if (sf == NULL)
+			return (NULL);
+
+		cf = sf;
+		pp = sp;
+	} while (sp != NULL);
+
+	return (cf);
+}
+
+
+#if 0
+/*
+ * cvs_repo_getpath()
+ *
+ * Get the full path of the file <file> and store it in <buf>, which is of
+ * size <len>.  For portability, it is recommended that <buf> always be
+ * at least MAXPATHLEN bytes long.
+ * Returns a pointer to the start of the path on success, or NULL on failure.
+ */
+char*
+cvs_repo_getpath(CVSRPENT *file, char *buf, size_t len)
+{
+	u_int i;
+	char *fp, *namevec[CVS_FILE_MAXDEPTH];
+	CVSRPENT *top;
+
+	buf[0] = '\0';
+	i = CVS_FILE_MAXDEPTH;
+	memset(namevec, 0, sizeof(namevec));
+
+	/* find the top node */
+	for (top = file; (top != NULL) && (i > 0); top = top->cr_parent) {
+		fp = top->cr_name;
+
+		/* skip self-references */
+		if ((fp[0] == '.') && (fp[1] == '\0'))
+			continue;
+		namevec[--i] = fp;
+	}
+
+	if (i == 0)
+		return (NULL);
+	else if (i == CVS_FILE_MAXDEPTH) {
+		strlcpy(buf, ".", len);
+		return (buf);
+	}
+
+	while (i < CVS_FILE_MAXDEPTH - 1) {
+		strlcat(buf, namevec[i++], len);
+		strlcat(buf, "/", len);
+	}
+	strlcat(buf, namevec[i], len);
+
+	return (buf);
+}
+#endif
+
+
+/*
+ * cvs_repo_loadrec()
+ *
+ * Recursively load the repository structure
+ */
+static CVSRPENT*
+cvs_repo_loadrec(CVSREPO *repo, const char *path)
+{
+	int ret, fd;
+	long base;
+	u_char *dp, *ep;
+	mode_t fmode;
+	char fbuf[2048], pbuf[MAXPATHLEN];
+	struct dirent *ent;
+	CVSRPENT *cfp, *cr_ent;
+	struct stat st;
+
+	cvs_log(LP_NOTICE, "loading %s", path);
+	if (stat(path, &st) == -1) {
+		cvs_log(LP_ERRNO, "failed to stat %s", path);
+		return (NULL);
+	}
+
+	cfp = (CVSRPENT *)malloc(sizeof(*cfp));
+	if (cfp == NULL) {
+		cvs_log(LP_ERRNO, "failed to allocate repository entry");
+		return (NULL);
+	}
+	memset(cfp, 0, sizeof(*cfp));
+	TAILQ_INIT(&(cfp->cr_rlocks));
+	TAILQ_INIT(&(cfp->cr_lkreq));
+
+	cfp->cr_name = strdup(basename(path));
+	if (cfp->cr_name == NULL) {
+		cvs_log(LP_ERRNO, "failed to copy entry name");
+		free(cfp);
+		return (NULL);
+	}
+
+	if (repo->cr_flags & CVS_REPO_CHKPERM) {
+		if (S_ISDIR(st.st_mode))
+			fmode = CVSD_DPERM;
+		else
+			fmode = CVSD_FPERM;
+		/* perform permission checks on the file */
+		if (st.st_uid != cvsd_uid) {
+			cvs_log(LP_WARN, "owner of `%s' is not %s",
+			    path, CVSD_USER);
+		}
+
+		if (st.st_gid != cvsd_gid) {
+			cvs_log(LP_WARN, "group of `%s' is not %s",
+			    path, CVSD_GROUP);
+		}
+
+		if (st.st_mode & S_IWGRP) {
+			cvs_log(LP_WARN, "file `%s' is group-writable",
+			    path, fmode);
+		}
+
+		if (st.st_mode & S_IWOTH) {
+			cvs_log(LP_WARN, "file `%s' is world-writable",
+			    path, fmode);
+		}
+	}
+
+	if (S_ISREG(st.st_mode))
+		cfp->cr_type = CVS_RPENT_RCSFILE;
+	else if (S_ISDIR(st.st_mode)) {
+		cfp->cr_type = CVS_RPENT_DIR;
+
+		TAILQ_INIT(&(cfp->cr_files));
+
+		if ((fd = open(path, O_RDONLY)) == -1) {
+			cvs_log(LP_ERRNO, "failed to open `%s'", path);
+			cvs_repo_entfree(cfp);
+			return (NULL);
+		}
+
+		do {
+			ret = getdirentries(fd, fbuf, sizeof(fbuf), &base);
+			if (ret == -1) {
+				cvs_log(LP_ERRNO,
+				    "failed to get directory entries");
+				cvs_repo_entfree(cfp);
+				(void)close(fd);
+				return (NULL);
+			}
+
+			dp = fbuf;
+			ep = fbuf + (size_t)ret;
+			while (dp < ep) {
+				ent = (struct dirent *)dp;
+				dp += ent->d_reclen;
+				if (ent->d_fileno == 0)
+					continue;
+
+				if (((ent->d_namlen == 1) &&
+				    (ent->d_name[0] == '.')) ||
+				    ((ent->d_namlen == 2) &&
+				    (ent->d_name[0] == '.') &&
+				    (ent->d_name[1] == '.')))
+					continue;
+
+				snprintf(pbuf, sizeof(pbuf), "%s/%s", path,
+				    ent->d_name);
+
+				if ((ent->d_type != DT_DIR) &&
+				    (ent->d_type != DT_REG)) {
+					cvs_log(LP_NOTICE, "skipping non-"
+					    "regular file `%s'", pbuf);
+					continue;
+				}
+
+				cr_ent = cvs_repo_loadrec(repo, pbuf);
+				if (cr_ent == NULL) {
+					cvs_repo_entfree(cfp);
+					(void)close(fd);
+					return (NULL);
+				}
+
+				cr_ent->cr_parent = cfp;
+				TAILQ_INSERT_TAIL(&(cfp->cr_files), cr_ent, cr_link);
+			}
+		} while (ret > 0);
+
+		(void)close(fd);
+	}
+
+	return (cfp);
+}
+
+
+/*
+ * cvs_repo_entfree()
+ *
+ * Free a repository entry structure and all underlying data.  In the case of
+ * directories, any child entries are also freed recursively.
+ */
+void
+cvs_repo_entfree(CVSRPENT *ent)
+{
+	CVSRPENT *ch_ent;
+
+	if (ent->cr_type == CVS_RPENT_DIR) {
+		while ((ch_ent = TAILQ_FIRST(&(ent->cr_files))) != NULL) {
+			TAILQ_REMOVE(&(ent->cr_files), ch_ent, cr_link);
+			cvs_repo_entfree(ch_ent);
+		}
+
+	}
+
+	if (ent->cr_name != NULL)
+		free(ent->cr_name);
+	free(ent);
+}
+
+
+/*
+ * cvs_repo_modfree()
+ *
+ * Free a CVS module structure.
+ */
+void
+cvs_repo_modfree(CVSMODULE *mod)
+{
+	if (mod->cm_name != NULL)
+		free(mod->cm_name);
+	if (mod->cm_path != NULL)
+		free(mod->cm_path);
+	free(mod);
+}
diff --git a/usr.bin/cvs/repo.h b/usr.bin/cvs/repo.h
new file mode 100644
index 00000000000..a641097ea6d
--- /dev/null
+++ b/usr.bin/cvs/repo.h
@@ -0,0 +1,156 @@
+/*	$OpenBSD: repo.h,v 1.1 2005/02/16 15:41:15 jfb Exp $	*/
+/*
+ * Copyright (c) 2005 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 REPO_H
+#define REPO_H
+
+#include <sys/types.h>
+#include <sys/queue.h>
+
+
+#define CVS_MODULE_ISALIAS     0x01
+
+typedef struct cvs_module {
+	char  *cm_name;
+	int    cm_flags;
+	char  *cm_path;		/* subpath for aliases, NULL otherwise */
+
+	TAILQ_ENTRY(cvs_module) cm_link;
+} CVSMODULE;
+
+
+
+#define CVS_RPENT_UNKNOWN   0
+#define CVS_RPENT_DIR       1
+#define CVS_RPENT_RCSFILE   2
+
+typedef struct cvs_repoent CVSRPENT;
+
+/*
+ * Repository locks
+ * ================
+ *
+ * OpenCVS derives from the standard CVS mechanism in the way it manages locks
+ * on the repository.  GNU CVS uses files with 'rfl' and 'wfl' extensions for
+ * read and write locks on particular directories.
+ * Using the filesystem for locking semantics has one major drawback: a lock
+ * can stay even after the process that created it is gone, if it didn't
+ * perform the appropriate cleanup.  This stale lock problem has been known
+ * to happen with GNU CVS and an intervention from one of the repository
+ * administrators is required before anyone else can access parts of the
+ * repository.
+ * In OpenCVS, a child cvsd needing to access a particular part of the tree
+ * must first request a lock on that part of the tree by issuing a
+ * CVS_MSG_LOCK message with the appropriate path.  Although the code
+ * supports locking at the file level, it should only be applied to the
+ * directory level to avoid extra overhead.  Both read and write locks can be
+ * obtained, though with different behaviour.  Multiple simultaneous read locks
+ * can be obtained on the same entry, but there can only be one active write
+ * lock.  In the case where the directory
+ * is already locked by another child, a lock wait is added to that entry
+ * and the child requesting the lock will get a CVSD_MSG_LOCKPEND reply,
+ * meaning that the lock has not been obtained but the child should block
+ * until it receives a CVSD_MSG_OK or CVSD_MSG_ERR telling it whether it
+ * obtained the lock or not.  When a child is done modifying the locked portion
+ * it should release its lock using the CVSD_MSG_UNLOCK request with the path.
+ *
+ * NOTES:
+ *  * The current locking mechanism allows a lock to be obtained on a
+ *    subportion of a part that has already been locked by another process.
+ *  * A lock on a directory only allows the owner to modify RCS files found
+ *    within that directory.  Any modifications on subdirectories require the
+ *    process to lock those subdirectories as well.
+ */
+
+#define CVS_LOCK_READ    1
+#define CVS_LOCK_WRITE   2
+
+
+struct cvs_lock {
+	pid_t     lk_owner;
+	int       lk_type;
+	CVSRPENT *lk_ent;		/* backpointer to the entry */
+
+	TAILQ_ENTRY(cvs_lock) lk_link;
+	TAILQ_ENTRY(cvs_lock) lk_chlink;
+};
+
+TAILQ_HEAD(cvs_lklist, cvs_lock);
+
+struct cvs_repoent {
+	char      *cr_name;
+	int        cr_type;
+	CVSRPENT  *cr_parent;
+
+	union {
+		TAILQ_HEAD(, cvs_repoent) files;
+	} cr_data;
+
+	struct cvs_lock   *cr_wlock;	/* write lock, NULL if none */
+	struct cvs_lklist  cr_rlocks;	/* read locks */
+	struct cvs_lklist  cr_lkreq;	/* pending lock requests */
+
+	TAILQ_ENTRY(cvs_repoent) cr_link;
+};
+
+#define cr_files cr_data.files
+
+
+
+#define CVS_REPO_LOCKED    0x01
+#define CVS_REPO_READONLY  0x02
+#define CVS_REPO_CHKPERM   0x04
+
+TAILQ_HEAD(cvs_modlist, cvs_module);
+
+typedef struct cvs_repo {
+	char     *cr_path;
+	int       cr_flags;
+	CVSRPENT *cr_tree;
+
+	struct cvs_modlist cr_modules;
+	TAILQ_ENTRY(cvs_repo) cr_link;
+} CVSREPO;
+
+
+
+
+CVSREPO*  cvs_repo_load      (const char *, int);
+void      cvs_repo_free      (CVSREPO *);
+int       cvs_repo_alias     (CVSREPO *, const char *, const char *);
+int       cvs_repo_unalias   (CVSREPO *, const char *);
+int       cvs_repo_lockdir   (CVSREPO *, const char *, int, pid_t);
+int       cvs_repo_unlockdir (CVSREPO *, const char *, pid_t);
+int       cvs_repo_lockent   (CVSRPENT *, int, pid_t);
+int       cvs_repo_unlockent (CVSRPENT *, pid_t);
+void      cvs_repo_entfree   (CVSRPENT *);
+void      cvs_repo_modfree   (CVSMODULE *);
+
+CVSRPENT* cvs_repo_find      (CVSREPO *, const char *);
+
+
+
+#endif /* REPO_H */