xref: /freebsd-9.3-release/usr.bin/csup/status.c

/*-
 * Copyright (c) 2006, Maxime Henrion <mux@FreeBSD.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. 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 *
 * $FreeBSD: vendor/csup/dist/contrib/csup/status.c 156230 2006-03-03 04:11:29Z mux $
 */

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

#include "config.h"
#include "fattr.h"
#include "misc.h"
#include "pathcomp.h"
#include "proto.h"
#include "queue.h"
#include "status.h"
#include "stream.h"

#define	STATUS_VERSION	5

/* Internal error codes. */
#define	STATUS_ERR_READ		(-1)
#define	STATUS_ERR_WRITE	(-2)
#define	STATUS_ERR_PARSE	(-3)
#define	STATUS_ERR_UNSORTED	(-4)
#define	STATUS_ERR_TRUNC	(-5)
#define	STATUS_ERR_BOGUS_DIRUP	(-6)
#define	STATUS_ERR_BAD_TYPE	(-7)
#define	STATUS_ERR_RENAME	(-8)

static struct status	*status_new(char *, time_t, struct stream *);
static struct statusrec	*status_rd(struct status *);
static struct statusrec	*status_rdraw(struct status *, char **);
static int		 status_wr(struct status *, struct statusrec *);
static int		 status_wrraw(struct status *, struct statusrec *,
			     char *);
static struct status	*status_fromrd(char *, struct stream *);
static struct status	*status_fromnull(char *);
static void		 status_free(struct status *);

static void		 statusrec_init(struct statusrec *);
static void		 statusrec_fini(struct statusrec *);
static int		 statusrec_cook(struct statusrec *, char *);
static int		 statusrec_cmp(struct statusrec *, struct statusrec *);

struct status {
	char *path;
	char *tempfile;
	int error;
	int suberror;
	struct pathcomp *pc;
	struct statusrec buf;
	struct statusrec *previous;
	struct statusrec *current;
	struct stream *rd;
	struct stream *wr;
	time_t scantime;
	int eof;
	int linenum;
	int depth;
	int dirty;
};

static void
statusrec_init(struct statusrec *sr)
{

	memset(sr, 0, sizeof(*sr));
}

static int
statusrec_cook(struct statusrec *sr, char *line)
{
	char *clientattr, *serverattr;

	switch (sr->sr_type) {
	case SR_DIRDOWN:
		/* Nothing to do. */
		if (line != NULL)
			return (-1);
		break;
	case SR_CHECKOUTLIVE:
		sr->sr_tag = proto_get_ascii(&line);
		sr->sr_date = proto_get_ascii(&line);
		serverattr = proto_get_ascii(&line);
		sr->sr_revnum = proto_get_ascii(&line);
		sr->sr_revdate = proto_get_ascii(&line);
		clientattr = proto_get_ascii(&line);
		if (clientattr == NULL || line != NULL)
			return (-1);
		sr->sr_serverattr = fattr_decode(serverattr);
		if (sr->sr_serverattr == NULL)
			return (-1);
		sr->sr_clientattr = fattr_decode(clientattr);
		if (sr->sr_clientattr == NULL) {
			fattr_free(sr->sr_serverattr);
			return (-1);
		}
		break;
	case SR_CHECKOUTDEAD:
		sr->sr_tag = proto_get_ascii(&line);
		sr->sr_date = proto_get_ascii(&line);
		serverattr = proto_get_ascii(&line);
		if (serverattr == NULL || line != NULL)
			return (-1);
		sr->sr_serverattr = fattr_decode(serverattr);
		if (sr->sr_serverattr == NULL)
			return (-1);
		break;
	case SR_DIRUP:
		clientattr = proto_get_ascii(&line);
		if (clientattr == NULL || line != NULL)
			return (-1);
		sr->sr_clientattr = fattr_decode(clientattr);
		if (sr->sr_clientattr == NULL)
			return (-1);
		break;
	default:
		return (-1);
	}
	return (0);
}

static struct statusrec *
status_rd(struct status *st)
{
	struct statusrec *sr;
	char *line;
	int error;

	sr = status_rdraw(st, &line);
	if (sr == NULL)
		return (NULL);
	error = statusrec_cook(sr, line);
	if (error) {
		st->error = STATUS_ERR_PARSE;
		return (NULL);
	}
	return (sr);
}

static struct statusrec *
status_rdraw(struct status *st, char **linep)
{
	struct statusrec sr;
	char *cmd, *line, *file;

	if (st->rd == NULL || st->eof)
		return (NULL);
	line = stream_getln(st->rd, NULL);
	if (line == NULL) {
		if (stream_eof(st->rd)) {
			if (st->depth != 0) {
				st->error = STATUS_ERR_TRUNC;
				return (NULL);
			}
			st->eof = 1;
			return (NULL);
		}
		st->error = STATUS_ERR_READ;
		st->suberror = errno;
		return (NULL);
	}
	st->linenum++;
	cmd = proto_get_ascii(&line);
	file = proto_get_ascii(&line);
	if (file == NULL || strlen(cmd) != 1) {
		st->error = STATUS_ERR_PARSE;
		return (NULL);
	}

	switch (cmd[0]) {
	case 'D':
		sr.sr_type = SR_DIRDOWN;
		st->depth++;
		break;
	case 'C':
		sr.sr_type = SR_CHECKOUTLIVE;
		break;
	case 'c':
		sr.sr_type = SR_CHECKOUTDEAD;
		break;
	case 'U':
		sr.sr_type = SR_DIRUP;
		if (st->depth <= 0) {
			st->error = STATUS_ERR_BOGUS_DIRUP;
			return (NULL);
		}
		st->depth--;
		break;
	default:
		st->error = STATUS_ERR_BAD_TYPE;
		st->suberror = cmd[0];
		return (NULL);
	}

	sr.sr_file = xstrdup(file);
	if (st->previous != NULL &&
	    statusrec_cmp(st->previous, &sr) >= 0) {
		st->error = STATUS_ERR_UNSORTED;
		free(sr.sr_file);
		return (NULL);
	}

	if (st->previous == NULL) {
		st->previous = &st->buf;
	} else {
		statusrec_fini(st->previous);
		statusrec_init(st->previous);
	}
	st->previous->sr_type = sr.sr_type;
	st->previous->sr_file = sr.sr_file;
	*linep = line;
	return (st->previous);
}

static int
status_wr(struct status *st, struct statusrec *sr)
{
	struct pathcomp *pc;
	const struct fattr *fa;
	char *name;
	int error, type, usedirupattr;

	pc = st->pc;
	error = 0;
	usedirupattr = 0;
	if (sr->sr_type == SR_DIRDOWN) {
		pathcomp_put(pc, PC_DIRDOWN, sr->sr_file);
	} else if (sr->sr_type == SR_DIRUP) {
		pathcomp_put(pc, PC_DIRUP, sr->sr_file);
		usedirupattr = 1;
	} else {
		pathcomp_put(pc, PC_FILE, sr->sr_file);
	}

	while (pathcomp_get(pc, &type, &name)) {
		if (type == PC_DIRDOWN) {
			error = proto_printf(st->wr, "D %s\n", name);
		} else if (type == PC_DIRUP) {
			if (usedirupattr)
				fa = sr->sr_clientattr;
			else
				fa = fattr_bogus;
			usedirupattr = 0;
			error = proto_printf(st->wr, "U %s %f\n", name, fa);
		}
		if (error)
			goto bad;
	}

	switch (sr->sr_type) {
	case SR_DIRDOWN:
	case SR_DIRUP:
		/* Already emitted above. */
		break;
	case SR_CHECKOUTLIVE:
		error = proto_printf(st->wr, "C %s %s %s %f %s %s %f\n",
		    sr->sr_file, sr->sr_tag, sr->sr_date, sr->sr_serverattr,
		    sr->sr_revnum, sr->sr_revdate, sr->sr_clientattr);
		break;
	case SR_CHECKOUTDEAD:
		error = proto_printf(st->wr, "c %s %s %s %f\n", sr->sr_file,
		    sr->sr_tag, sr->sr_date, sr->sr_serverattr);
		break;
	}
	if (error)
		goto bad;
	return (0);
bad:
	st->error = STATUS_ERR_WRITE;
	st->suberror = errno;
	return (-1);
}

static int
status_wrraw(struct status *st, struct statusrec *sr, char *line)
{
	char *name;
	char cmd;
	int error, ret, type;

	if (st->wr == NULL)
		return (0);

	/*
	 * Keep the compressor in sync.  At this point, the necessary
	 * DirDowns and DirUps should have already been emitted, so the
	 * compressor should return exactly one value in the PC_DIRDOWN
	 * and PC_DIRUP case and none in the PC_FILE case.
	 */
	if (sr->sr_type == SR_DIRDOWN)
		pathcomp_put(st->pc, PC_DIRDOWN, sr->sr_file);
	else if (sr->sr_type == SR_DIRUP)
		pathcomp_put(st->pc, PC_DIRUP, sr->sr_file);
	else
		pathcomp_put(st->pc, PC_FILE, sr->sr_file);
	if (sr->sr_type == SR_DIRDOWN || sr->sr_type == SR_DIRUP) {
		ret = pathcomp_get(st->pc, &type, &name);
		assert(ret);
		if (sr->sr_type == SR_DIRDOWN)
			assert(type == PC_DIRDOWN);
		else
			assert(type == PC_DIRUP);
	}
	ret = pathcomp_get(st->pc, &type, &name);
	assert(!ret);

	switch (sr->sr_type) {
	case SR_DIRDOWN:
		cmd = 'D';
		break;
	case SR_DIRUP:
		cmd = 'U';
		break;
	case SR_CHECKOUTLIVE:
		cmd = 'C';
		break;
	case SR_CHECKOUTDEAD:
		cmd = 'c';
		break;
	default:
		assert(0);
		return (-1);
	}
	if (sr->sr_type == SR_DIRDOWN)
		error = proto_printf(st->wr, "%c %S\n", cmd, sr->sr_file);
	else
		error = proto_printf(st->wr, "%c %s %S\n", cmd, sr->sr_file,
		    line);
	if (error) {
		st->error = STATUS_ERR_WRITE;
		st->suberror = errno;
		return (-1);
	}
	return (0);
}

static void
statusrec_fini(struct statusrec *sr)
{

	fattr_free(sr->sr_serverattr);
	fattr_free(sr->sr_clientattr);
	free(sr->sr_file);
}

static int
statusrec_cmp(struct statusrec *a, struct statusrec *b)
{
	size_t lena, lenb;

	if (a->sr_type == SR_DIRUP || b->sr_type == SR_DIRUP) {
		lena = strlen(a->sr_file);
		lenb = strlen(b->sr_file);
		if (a->sr_type == SR_DIRUP &&
		    ((lena < lenb && b->sr_file[lena] == '/') || lena == lenb)
		    && strncmp(a->sr_file, b->sr_file, lena) == 0)
			return (1);
		if (b->sr_type == SR_DIRUP &&
		    ((lenb < lena && a->sr_file[lenb] == '/') || lenb == lena)
		    && strncmp(a->sr_file, b->sr_file, lenb) == 0)
			return (-1);
	}
	return (pathcmp(a->sr_file, b->sr_file));
}

static struct status *
status_new(char *path, time_t scantime, struct stream *file)
{
	struct status *st;

	st = xmalloc(sizeof(struct status));
	st->path = path;
	st->error = 0;
	st->suberror = 0;
	st->tempfile = NULL;
	st->scantime = scantime;
	st->rd = file;
	st->wr = NULL;
	st->previous = NULL;
	st->current = NULL;
	st->dirty = 0;
	st->eof = 0;
	st->linenum = 0;
	st->depth = 0;
	st->pc = pathcomp_new();
	statusrec_init(&st->buf);
	return (st);
}

static void
status_free(struct status *st)
{

	if (st->previous != NULL)
		statusrec_fini(st->previous);
	if (st->rd != NULL)
		stream_close(st->rd);
	if (st->wr != NULL)
		stream_close(st->wr);
	if (st->tempfile != NULL)
		free(st->tempfile);
	free(st->path);
	pathcomp_free(st->pc);
	free(st);
}

static struct status *
status_fromrd(char *path, struct stream *file)
{
	struct status *st;
	char *id, *line;
	time_t scantime;
	int error, ver;

	/* Get the first line of the file and validate it. */
	line = stream_getln(file, NULL);
	if (line == NULL) {
		stream_close(file);
		return (NULL);
	}
	id = proto_get_ascii(&line);
	error = proto_get_int(&line, &ver, 10);
	if (error) {
		stream_close(file);
		return (NULL);
	}
	error = proto_get_time(&line, &scantime);
	if (error || line != NULL) {
		stream_close(file);
		return (NULL);
	}

	if (strcmp(id, "F") != 0 || ver != STATUS_VERSION) {
		stream_close(file);
		return (NULL);
	}

	st = status_new(path, scantime, file);
	st->linenum = 1;
	return (st);
}

static struct status *
status_fromnull(char *path)
{
	struct status *st;

	st = status_new(path, -1, NULL);
	st->eof = 1;
	return (st);
}

/*
 * Open the status file.  If scantime is not -1, the file is opened
 * for updating, otherwise, it is opened read-only. If the status file
 * couldn't be opened, NULL is returned and errmsg is set to the error
 * message.
 */
struct status *
status_open(struct coll *coll, time_t scantime, char **errmsg)
{
	struct status *st;
	struct stream *file;
	struct fattr *fa;
	char *destpath, *path;
	int error, rv;

	path = coll_statuspath(coll);
	file = stream_open_file(path, O_RDONLY);
	if (file == NULL) {
		if (errno != ENOENT) {
			xasprintf(errmsg, "Could not open \"%s\": %s\n",
			    path, strerror(errno));
			free(path);
			return (NULL);
		}
		st = status_fromnull(path);
	} else {
		st = status_fromrd(path, file);
		if (st == NULL) {
			xasprintf(errmsg, "Error in \"%s\": Bad header line",
			    path);
			free(path);
			return (NULL);
		}
	}

	if (scantime != -1) {
		/* Open for writing too. */
		xasprintf(&destpath, "%s/%s/%s/", coll->co_base,
		    coll->co_colldir, coll->co_name);
		st->tempfile = tempname(destpath);
		if (mkdirhier(destpath, coll->co_umask) != 0) {
			xasprintf(errmsg, "Cannot create directories leading "
			    "to \"%s\": %s", destpath, strerror(errno));
			free(destpath);
			status_free(st);
			return (NULL);
		}
		free(destpath);
		st->wr = stream_open_file(st->tempfile,
		    O_CREAT | O_TRUNC | O_WRONLY, 0644);
		if (st->wr == NULL) {
			xasprintf(errmsg, "Cannot create \"%s\": %s",
			    st->tempfile, strerror(errno));
			status_free(st);
			return (NULL);
		}
		fa = fattr_new(FT_FILE, -1);
		fattr_mergedefault(fa);
		fattr_umask(fa, coll->co_umask);
		rv = fattr_install(fa, st->tempfile, NULL);
		fattr_free(fa);
		if (rv == -1) {
			xasprintf(errmsg,
			    "Cannot set attributes for \"%s\": %s",
			    st->tempfile, strerror(errno));
			status_free(st);
			return (NULL);
		}
		if (scantime != st->scantime)
			st->dirty = 1;
		error = proto_printf(st->wr, "F %d %t\n", STATUS_VERSION,
		    scantime);
		if (error) {
			st->error = STATUS_ERR_WRITE;
			st->suberror = errno;
			*errmsg = status_errmsg(st);
			status_free(st);
			return (NULL);
		}
	}
	return (st);
}

/*
 * Get an entry from the status file.  If name is NULL, the next entry
 * is returned.  If name is not NULL, the entry matching this name is
 * returned, or NULL if it couldn't be found.  If deleteto is set to 1,
 * all the entries read from the status file while looking for the
 * given name are deleted.
 */
int
status_get(struct status *st, char *name, int isdirup, int deleteto,
    struct statusrec **psr)
{
	struct statusrec key;
	struct statusrec *sr;
	char *line;
	int c, error;

	if (st->eof)
		return (0);

	if (st->error)
		return (-1);

	if (name == NULL) {
		sr = status_rd(st);
		if (sr == NULL) {
			if (st->error)
				return (-1);
			return (0);
		}
		*psr = sr;
		return (1);
	}

	if (st->current != NULL) {
		sr = st->current;
		st->current = NULL;
	} else {
		sr = status_rd(st);
		if (sr == NULL) {
			if (st->error)
				return (-1);
			return (0);
		}
	}

	key.sr_file = name;
	if (isdirup)
		key.sr_type = SR_DIRUP;
	else
		key.sr_type = SR_CHECKOUTLIVE;

	c = statusrec_cmp(sr, &key);
	if (c < 0) {
		if (st->wr != NULL && !deleteto) {
			error = status_wr(st, sr);
			if (error)
				return (-1);
		}
		/* Loop until we find the good entry. */
		for (;;) {
			sr = status_rdraw(st, &line);
			if (sr == NULL) {
				if (st->error)
					return (-1);
				return (0);
			}
			c = statusrec_cmp(sr, &key);
			if (c >= 0)
				break;
			if (st->wr != NULL && !deleteto) {
				error = status_wrraw(st, sr, line);
				if (error)
					return (-1);
			}
		}
		error = statusrec_cook(sr, line);
		if (error) {
			st->error = STATUS_ERR_PARSE;
			return (-1);
		}
	}
	st->current = sr;
	if (c != 0)
		return (0);
	*psr = sr;
	return (1);
}

/*
 * Put this entry into the status file.  If an entry with the same name
 * existed in the status file, it is replaced by this one, otherwise,
 * the entry is added to the status file.
 */
int
status_put(struct status *st, struct statusrec *sr)
{
	struct statusrec *old;
	int error, ret;

	ret = status_get(st, sr->sr_file, sr->sr_type == SR_DIRUP, 0, &old);
	if (ret == -1)
		return (-1);
	if (ret) {
		if (old->sr_type == SR_DIRDOWN) {
			/* DirUp should never match DirDown */
			assert(old->sr_type != SR_DIRUP);
			if (sr->sr_type == SR_CHECKOUTLIVE ||
			    sr->sr_type == SR_CHECKOUTDEAD) {
				/* We are replacing a directory with a file.
				   Delete all entries inside the directory we
				   are replacing. */
				ret = status_get(st, sr->sr_file, 1, 1, &old);
				if (ret == -1)
					return (-1);
				assert(ret);
			}
		} else
			st->current = NULL;
	}
	st->dirty = 1;
	error = status_wr(st, sr);
	if (error)
		return (-1);
	return (0);
}

/*
 * Delete the specified entry from the status file.
 */
int
status_delete(struct status *st, char *name, int isdirup)
{
	struct statusrec *sr;
	int ret;

	ret = status_get(st, name, isdirup, 0, &sr);
	if (ret == -1)
		return (-1);
	if (ret) {
		st->current = NULL;
		st->dirty = 1;
	}
	return (0);
}

/*
 * Check whether we hit the end of file.
 */
int
status_eof(struct status *st)
{

	return (st->eof);
}

/*
 * Returns the error message if there was an error, otherwise returns
 * NULL.  The error message is allocated dynamically and needs to be
 * freed by the caller after use.
 */
char *
status_errmsg(struct status *st)
{
	char *errmsg;

	if (!st->error)
		return (NULL);
	switch (st->error) {
	case STATUS_ERR_READ:
		xasprintf(&errmsg, "Read failure on \"%s\": %s",
		    st->path, strerror(st->suberror));
		break;
	case STATUS_ERR_WRITE:
		xasprintf(&errmsg, "Write failure on \"%s\": %s",
		    st->tempfile, strerror(st->suberror));
		break;
	case STATUS_ERR_PARSE:
		xasprintf(&errmsg, "Error in \"%s\": %d: "
		    "Could not parse status record", st->path, st->linenum);
		break;
	case STATUS_ERR_UNSORTED:
		xasprintf(&errmsg, "Error in \"%s\": %d: "
		    "File is not sorted properly", st->path, st->linenum);
		break;
	case STATUS_ERR_TRUNC:
		xasprintf(&errmsg, "Error in \"%s\": "
		    "File is truncated", st->path);
		break;
	case STATUS_ERR_BOGUS_DIRUP:
		xasprintf(&errmsg, "Error in \"%s\": %d: "
		    "\"U\" entry has no matching \"D\"", st->path, st->linenum);
		break;
	case STATUS_ERR_BAD_TYPE:
		xasprintf(&errmsg, "Error in \"%s\": %d: "
		    "Invalid file type \"%c\"", st->path, st->linenum,
		    st->suberror);
		break;
	case STATUS_ERR_RENAME:
		xasprintf(&errmsg, "Cannot rename \"%s\" to \"%s\": %s",
		    st->tempfile, st->path, strerror(st->suberror));
		break;
	default:
		assert(0);
		return (NULL);
	}
	return (errmsg);
}

/*
 * Close the status file and free any resource associated with it.
 * It is OK to pass NULL for errmsg only if the status file was
 * opened read-only.  If it wasn't opened read-only, status_close()
 * can produce an error and errmsg is not allowed to be NULL.  If
 * there was no errors, errmsg is set to NULL.
 */
void
status_close(struct status *st, char **errmsg)
{
	struct statusrec *sr;
	char *line, *name;
	int error, type;

	if (st->wr != NULL) {
		if (st->dirty) {
			if (st->current != NULL) {
				error = status_wr(st, st->current);
				if (error) {
					*errmsg = status_errmsg(st);
					goto bad;
				}
				st->current = NULL;
			}
			/* Copy the rest of the file. */
			while ((sr = status_rdraw(st, &line)) != NULL) {
				error = status_wrraw(st, sr, line);
				if (error) {
					*errmsg = status_errmsg(st);
					goto bad;
				}
			}
			if (st->error) {
				*errmsg = status_errmsg(st);
				goto bad;
			}

			/* Close off all the open directories. */
			pathcomp_finish(st->pc);
			while (pathcomp_get(st->pc, &type, &name)) {
				assert(type == PC_DIRUP);
				error = proto_printf(st->wr, "U %s %f\n",
				    name, fattr_bogus);
				if (error) {
					st->error = STATUS_ERR_WRITE;
					st->suberror = errno;
					*errmsg = status_errmsg(st);
					goto bad;
				}
			}

			/* Rename tempfile. */
			error = rename(st->tempfile, st->path);
			if (error) {
				st->error = STATUS_ERR_RENAME;
				st->suberror = errno;
				*errmsg = status_errmsg(st);
				goto bad;
			}
		} else {
			/* Just discard the tempfile. */
			unlink(st->tempfile);
		}
		*errmsg = NULL;
	}
	status_free(st);
	return;
bad:
	status_free(st);
}