/*	$OpenBSD: log.c,v 1.12 2017/04/18 01:45:35 deraadt Exp $	*/

/*-

 * Copyright (c) 1992, 1993, 1994

 *	The Regents of the University of California.  All rights reserved.

 * Copyright (c) 1992, 1993, 1994, 1995, 1996

 *	Keith Bostic.  All rights reserved.

 *

 * See the LICENSE file for redistribution information.

 */

#include "config.h"

#include <sys/types.h>

#include <sys/queue.h>

#include <sys/stat.h>

#include <bitstring.h>

#include <errno.h>

#include <fcntl.h>

#include <libgen.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "common.h"

/*

 * The log consists of records, each containing a type byte and a variable

 * length byte string, as follows:

 *

 *	LOG_CURSOR_INIT		MARK

 *	LOG_CURSOR_END		MARK

 *	LOG_LINE_APPEND		recno_t		char *

 *	LOG_LINE_DELETE		recno_t		char *

 *	LOG_LINE_INSERT		recno_t		char *

 *	LOG_LINE_RESET_F	recno_t		char *

 *	LOG_LINE_RESET_B	recno_t		char *

 *	LOG_MARK		LMARK

 *

 * We do before image physical logging.  This means that the editor layer

 * MAY NOT modify records in place, even if simply deleting or overwriting

 * characters.  Since the smallest unit of logging is a line, we're using

 * up lots of space.  This may eventually have to be reduced, probably by

 * doing logical logging, which is a much cooler database phrase.

 *

 * The implementation of the historic vi 'u' command, using roll-forward and

 * roll-back, is simple.  Each set of changes has a LOG_CURSOR_INIT record,

 * followed by a number of other records, followed by a LOG_CURSOR_END record.

 * LOG_LINE_RESET records come in pairs.  The first is a LOG_LINE_RESET_B

 * record, and is the line before the change.  The second is LOG_LINE_RESET_F,

 * and is the line after the change.  Roll-back is done by backing up to the

 * first LOG_CURSOR_INIT record before a change.  Roll-forward is done in a

 * similar fashion.

 *

 * The 'U' command is implemented by rolling backward to a LOG_CURSOR_END

 * record for a line different from the current one.  It should be noted that

 * this means that a subsequent 'u' command will make a change based on the

 * new position of the log's cursor.  This is okay, and, in fact, historic vi

 * behaved that way.

 */

static int	log_cursor1(SCR *, int);

static void	log_err(SCR *, char *, int);

#if defined(DEBUG) && 0

static void	log_trace(SCR *, char *, recno_t, u_char *);

#endif

/* Try and restart the log on failure, i.e. if we run out of memory. */

#define	LOG_ERR {							\

	log_err(sp, __FILE__, __LINE__);				\

	return (1);							\

}

/*

 * log_init --

 *	Initialize the logging subsystem.

 *

 * PUBLIC: int log_init(SCR *, EXF *);

 */

int

log_init(SCR *sp, EXF *ep)

{

	/*

	 * !!!

	 * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.

	 *

	 * Initialize the buffer.  The logging subsystem has its own

	 * buffers because the global ones are almost by definition

	 * going to be in use when the log runs.

	 */

	    S_IRUSR | S_IWUSR, DB_RECNO, NULL);

	}

}

/*

 * log_end --

 *	Close the logging subsystem.

 *

 * PUBLIC: int log_end(SCR *, EXF *);

 */

int

log_end(SCR *sp, EXF *ep)

{

	/*

	 * !!!

	 * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.

	 */

	}

}

/*

 * log_cursor --

 *	Log the current cursor position, starting an event.

 *

 * PUBLIC: int log_cursor(SCR *);

 */

int

log_cursor(SCR *sp)

{

	EXF *ep;

	/*

	 * If any changes were made since the last cursor init,

	 * put out the ending cursor record.

	 */

		ep->l_cursor.lno = sp->lno;

		ep->l_cursor.cno = sp->cno;

	}

	ep->l_cursor.lno = sp->lno;

	ep->l_cursor.cno = sp->cno;

}

/*

 * log_cursor1 --

 *	Actually push a cursor record out.

 */

static int

log_cursor1(SCR *sp, int type)

{

	EXF *ep;

#if defined(DEBUG) && 0

	TRACE(sp, "%lu: %s: %u/%u\n", ep->l_cur,

	    type == LOG_CURSOR_INIT ? "log_cursor_init" : "log_cursor_end",

	    sp->lno, sp->cno);

#endif

	/* Reset high water mark. */

}

/*

 * log_line --

 *	Log a line change.

 *

 * PUBLIC: int log_line(SCR *, recno_t, u_int);

 */

int

log_line(SCR *sp, recno_t lno, u_int action)

{

	EXF *ep;

	/*

	 * XXX

	 *

	 * Kluge for vi.  Clear the EXF undo flag so that the

	 * next 'u' command does a roll-back, regardless.

	 */

	/* Put out one initial cursor record per set of changes. */

	}

	/*

	 * Put out the changes.  If it's a LOG_LINE_RESET_B call, it's a

	 * special case, avoid the caches.  Also, if it fails and it's

	 * line 1, it just means that the user started with an empty file,

	 * so fake an empty length line.

	 */

			}

		}

	} else

	    ep->l_lp, ep->l_len, len + sizeof(u_char) + sizeof(recno_t));

#if defined(DEBUG) && 0

	switch (action) {

	case LOG_LINE_APPEND:

		TRACE(sp, "%u: log_line: append: %lu {%u}\n",

		    ep->l_cur, lno, len);

		break;

	case LOG_LINE_DELETE:

		TRACE(sp, "%lu: log_line: delete: %lu {%u}\n",

		    ep->l_cur, lno, len);

		break;

	case LOG_LINE_INSERT:

		TRACE(sp, "%lu: log_line: insert: %lu {%u}\n",

		    ep->l_cur, lno, len);

		break;

	case LOG_LINE_RESET_F:

		TRACE(sp, "%lu: log_line: reset_f: %lu {%u}\n",

		    ep->l_cur, lno, len);

		break;

	case LOG_LINE_RESET_B:

		TRACE(sp, "%lu: log_line: reset_b: %lu {%u}\n",

		    ep->l_cur, lno, len);

		break;

	}

#endif

	/* Reset high water mark. */

}

/*

 * log_mark --

 *	Log a mark position.  For the log to work, we assume that there

 *	aren't any operations that just put out a log record -- this

 *	would mean that undo operations would only reset marks, and not

 *	cause any other change.

 *

 * PUBLIC: int log_mark(SCR *, LMARK *);

 */

int

log_mark(SCR *sp, LMARK *lmp)

{

	EXF *ep;

	/* Put out one initial cursor record per set of changes. */

	}

	    ep->l_len, sizeof(u_char) + sizeof(LMARK));

#if defined(DEBUG) && 0

	TRACE(sp, "%lu: mark %c: %lu/%u\n",

	    ep->l_cur, lmp->name, lmp->lno, lmp->cno);

#endif

	/* Reset high water mark. */

}

/*

 * Log_backward --

 *	Roll the log backward one operation.

 *

 * PUBLIC: int log_backward(SCR *, MARK *);

 */

int

log_backward(SCR *sp, MARK *rp)

{

	EXF *ep;

	recno_t lno;

	int didop;

	u_char *p;

		    "Logging not being performed, undo not possible");

	}

	}

#if defined(DEBUG) && 0

		log_trace(sp, "log_backward", ep->l_cur, data.data);

#endif

		case LOG_CURSOR_INIT:

			}

			break;

		case LOG_CURSOR_END:

			break;

		case LOG_LINE_APPEND:

		case LOG_LINE_INSERT:

			didop = 1;

				goto err;

		case LOG_LINE_DELETE:

			didop = 1;

			    sizeof(recno_t)))

				goto err;

		case LOG_LINE_RESET_F:

			break;

		case LOG_LINE_RESET_B:

			didop = 1;

			    sizeof(recno_t)))

				goto err;

			}

			break;

		case LOG_MARK:

			didop = 1;

				goto err;

			break;

		default:

		}

	}

}

/*

 * Log_setline --

 *	Reset the line to its original appearance.

 *

 * XXX

 * There's a bug in this code due to our not logging cursor movements

 * unless a change was made.  If you do a change, move off the line,

 * then move back on and do a 'U', the line will be restored to the way

 * it was before the original change.

 *

 * PUBLIC: int log_setline(SCR *);

 */

int

log_setline(SCR *sp)

{

	EXF *ep;

	recno_t lno;

	u_char *p;

		    "Logging not being performed, undo not possible");

	}

#if defined(DEBUG) && 0

		log_trace(sp, "log_setline", ep->l_cur, data.data);

#endif

		case LOG_CURSOR_INIT:

			}

			break;

		case LOG_CURSOR_END:

			}

			break;

		case LOG_LINE_APPEND:

		case LOG_LINE_INSERT:

		case LOG_LINE_DELETE:

		case LOG_LINE_RESET_F:

			break;

		case LOG_LINE_RESET_B:

			    sizeof(recno_t)))

				goto err;

			}

		case LOG_MARK:

				goto err;

			break;

		default:

		}

	}

}

/*

 * Log_forward --

 *	Roll the log forward one operation.

 *

 * PUBLIC: int log_forward(SCR *, MARK *);

 */

int

log_forward(SCR *sp, MARK *rp)

{

	EXF *ep;

	recno_t lno;

	int didop;

	u_char *p;

	    "Logging not being performed, roll-forward not possible");

	}

	}

#if defined(DEBUG) && 0

		log_trace(sp, "log_forward", ep->l_cur, data.data);

#endif

		case LOG_CURSOR_END:

			}

			break;

		case LOG_CURSOR_INIT:

			break;

		case LOG_LINE_APPEND:

		case LOG_LINE_INSERT:

			didop = 1;

			    sizeof(recno_t)))

				goto err;

		case LOG_LINE_DELETE:

			didop = 1;

				goto err;

		case LOG_LINE_RESET_B:

			break;

		case LOG_LINE_RESET_F:

			didop = 1;

			    sizeof(recno_t)))

				goto err;

			}

			break;

		case LOG_MARK:

			didop = 1;

				goto err;

			break;

		default:

		}

	}

}

/*

 * log_err --

 *	Try and restart the log on failure, i.e. if we run out of memory.

 */

static void

log_err(SCR *sp, char *file, int line)

{

	EXF *ep;

}

#if defined(DEBUG) && 0

static void

log_trace(SCR *sp, char *msg, recno_t rno, u_char *p)

{

	LMARK lm;

	MARK m;

	recno_t lno;

	switch (*p) {

	case LOG_CURSOR_INIT:

		memmove(&m, p + sizeof(u_char), sizeof(MARK));

		TRACE(sp, "%lu: %s:  C_INIT: %u/%u\n", rno, msg, m.lno, m.cno);

		break;

	case LOG_CURSOR_END:

		memmove(&m, p + sizeof(u_char), sizeof(MARK));

		TRACE(sp, "%lu: %s:   C_END: %u/%u\n", rno, msg, m.lno, m.cno);

		break;

	case LOG_LINE_APPEND:

		memmove(&lno, p + sizeof(u_char), sizeof(recno_t));

		TRACE(sp, "%lu: %s:  APPEND: %lu\n", rno, msg, lno);

		break;

	case LOG_LINE_INSERT:

		memmove(&lno, p + sizeof(u_char), sizeof(recno_t));

		TRACE(sp, "%lu: %s:  INSERT: %lu\n", rno, msg, lno);

		break;

	case LOG_LINE_DELETE:

		memmove(&lno, p + sizeof(u_char), sizeof(recno_t));

		TRACE(sp, "%lu: %s:  DELETE: %lu\n", rno, msg, lno);

		break;

	case LOG_LINE_RESET_F:

		memmove(&lno, p + sizeof(u_char), sizeof(recno_t));

		TRACE(sp, "%lu: %s: RESET_F: %lu\n", rno, msg, lno);

		break;

	case LOG_LINE_RESET_B:

		memmove(&lno, p + sizeof(u_char), sizeof(recno_t));

		TRACE(sp, "%lu: %s: RESET_B: %lu\n", rno, msg, lno);

		break;

	case LOG_MARK:

		memmove(&lm, p + sizeof(u_char), sizeof(LMARK));

		TRACE(sp,

		    "%lu: %s:    MARK: %u/%u\n", rno, msg, lm.lno, lm.cno);

		break;

	default:

		abort();

	}

}

#endif