/*
 * Copyright (c) 1994, David Greenman
 * All rights reserved.
 * Copyright (c) 2003-2011 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
  * by Matthew Dillon <dillon@backplane.com>
 *
 * 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 unmodified, 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.
 */

/*
 * clist support routines
 *
 * The clist now contains two linear buffers c_quote and c_info, sized
 * to c_cbmax.  The caller must hold a lock or token specific to the clist
 * being manipulated.
 */
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/tty.h>

/*
 * Allocate or reallocate clist buffers.
 */
void
clist_alloc_cblocks(struct clist *cl, int ccmax)
{
	short *data;
	int count;
	int n;

	if (ccmax == cl->c_ccmax)
		return;
	if (ccmax == 0) {
		clist_free_cblocks(cl);
		return;
	}
	data = kmalloc(ccmax * sizeof(*data), M_TTYS, M_INTWAIT|M_ZERO);
	/* NOTE: cl fields may now be different due to blocking */

	count = cl->c_cc;
	if (cl->c_cc) {
		if (count > ccmax)
			count = ccmax;
		n = cl->c_ccmax - cl->c_cchead;
		if (n > count)
			n = count;
		bcopy(cl->c_data + cl->c_cchead, data, n * sizeof(*data));
		if (n < count) {
			bcopy(cl->c_data, data + n,
			      (count - n) * sizeof(*data));
		}
	}
	cl->c_cc = count;
	cl->c_ccmax = ccmax;
	cl->c_cchead = 0;
	cl->c_data = data;
}

/*
 * Free the clist's buffer.
 */
void
clist_free_cblocks(struct clist *cl)
{
	short *data;

	data = cl->c_data;

	cl->c_cc = 0;
	cl->c_ccmax = 0;
	cl->c_cchead = 0;
	cl->c_unused01 = 0;
	cl->c_data = NULL;
	if (data)
		kfree(data, M_TTYS);
}

/*
 * Get a character from the head of a clist.
 */
int
clist_getc(struct clist *cl)
{
	short c;
	int i;

	if (cl->c_cc == 0)
		return -1;
	i = cl->c_cchead;
	c = cl->c_data[i];
	if (++i == cl->c_ccmax)
		i = 0;
	cl->c_cchead = i;
	--cl->c_cc;
	return ((int)c);
}

/*
 * Copy data from the clist to the destination linear buffer.
 * Return the number of characters actually copied.
 */
int
clist_qtob(struct clist *cl, char *dest, int n)
{
	int count;
	int i;
	short c;

	if (n > cl->c_cc)
		n = cl->c_cc;
	count = n;
	i = cl->c_cchead;

	while (n) {
		c = cl->c_data[i];
		if (++i == cl->c_ccmax)
			i = 0;
		*dest++ = (char)c;
		--n;
	}
	cl->c_cchead = i;
	cl->c_cc -= count;

	return count;
}

/*
 * Flush characters from the head of the clist, deleting them.
 */
void
ndflush(struct clist *cl, int n)
{
	int i;

	if (n > cl->c_cc)
		n = cl->c_cc;
	i = cl->c_cchead + n;
	if (i >= cl->c_ccmax)
		i -= cl->c_ccmax;
	cl->c_cchead = i;
	cl->c_cc -= n;
}

/*
 * Append a character to the clist, return 0 on success, -1 if
 * there is no room.  The character can be quoted by setting TTY_QUOTE.
 */
int
clist_putc(int c, struct clist *cl)
{
	int i;

	if (cl->c_cc == cl->c_ccmax)
		return -1;
	i = cl->c_cchead + cl->c_cc;
	if (i >= cl->c_ccmax)
		i -= cl->c_ccmax;
	cl->c_data[i] = (short)c & (TTY_QUOTE | TTY_CHARMASK);
	++cl->c_cc;

	return 0;
}

/*
 * Copy data from linear buffer to clist chain.  Return the
 * number of characters not copied.  The data will be flagged
 * as not being quoted.
 */
int
clist_btoq(char *src, int n, struct clist *cl)
{
	int i;
	int count;
	int remain;

	count = cl->c_ccmax - cl->c_cc;		/* space available */
	if (count > n)
		count = n;			/* count = bytes to copy */
	remain = n - count;			/* remain = bytes not copied */

	i = cl->c_cchead + cl->c_cc;		/* clist write index */
	if (i >= cl->c_ccmax)
		i -= cl->c_ccmax;

	while (count) {
		cl->c_data[i] = (short)(uint8_t)*src;
		if (++i == cl->c_ccmax)
			i = 0;
		++src;
		--count;
	}
	cl->c_cc += n - remain;			/* bytes actually copied */

	return remain;				/* return bytes not copied */
}

/*
 * Get the next character in the clist relative to cp.  If cp is NULL
 * returns the first character in the clist.  The character is stored in
 * *dst.  No clist pointers are advanced or adjusted.
 *
 * The returned pointer can be used as an iterator but should not be
 * directly dereferenced.
 */
void *
clist_nextc(struct clist *cl, void *cp, int *dst)
{
	int i;

	if (cp == NULL) {
		if (cl->c_cc == 0) {
			*dst = -1;
			return NULL;
		}
		cp = &cl->c_data[cl->c_cchead];
		*dst = (uint16_t)*(short *)cp;	/* can be quoted */
		return cp;
	}

	/*
	 * Use i to calculate the next logical index to determine if
	 * there are any characters remaining.
	 */
	i = (short *)cp - cl->c_data;
	if (i < cl->c_cchead)
		i += cl->c_ccmax - cl->c_cchead;
	else
		i -= cl->c_cchead;
	if (i + 1 == cl->c_cc) {		/* no more chars */
		*dst = 0;
		return NULL;
	}

	/*
	 * We can just use cp to iterate the next actual buffer
	 * position.
	 */
	cp = (short *)cp + 1;			/* next char (use pointer) */
	if (cp == &cl->c_data[cl->c_ccmax])
		cp = &cl->c_data[0];
	*dst = (uint16_t)*(short *)cp;

	return cp;
}

/*
 * "Unput" a character from a clist, returning it.
 */
int
clist_unputc(struct clist *cl)
{
	int c;
	int i;

	if (cl->c_cc == 0)
		return -1;
	--cl->c_cc;
	i = cl->c_cchead + cl->c_cc;
	if (i >= cl->c_ccmax)
		i -= cl->c_ccmax;
	c = (int)(uint16_t)cl->c_data[i];

	return c;
}

/*
 * Move characters in source clist to destination clist,
 * preserving quote bits.  Non-critical path.
 */
void
clist_catq(struct clist *cls, struct clist *cld)
{
	int c;

	while ((c = clist_getc(cls)) != -1)
		clist_putc(c, cld);
}