path: root/usr/src/cmd/vntsd/read.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * read thread - Read from tcp client and write to vcc driver. There  are one
 * writer and multiple readers per console. The first client who connects to
 * a console get write access. An error message is returned to readers if they
 * attemp to input commands. Read thread accepts special daemon commands from
 * all clients.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <thread.h>
#include <synch.h>
#include <signal.h>
#include <assert.h>
#include <ctype.h>
#include <syslog.h>
#include <libintl.h>
#include "vntsd.h"
#include "chars.h"

/* write_vcc()  - write to vcc virtual console */
static int
write_vcc(vntsd_client_t *clientp, char c)
{
	int	n;


	assert(clientp);
	assert(clientp->cons);

	n = write(clientp->cons->vcc_fd, &c, 1);

	if (n < 0) {
		/* write error */
		if (errno == EINTR) {
			return (vntsd_cons_chk_intr(clientp));
		}

		return (VNTSD_STATUS_VCC_IO_ERR);
	}

	assert(n != 0);
	return (VNTSD_SUCCESS);

}

/*
 * acquire_writer() the client is going to be writer.
 * insert the client to the head of the console client queue.
 */
static int
acquire_writer(vntsd_client_t *clientp)
{
	vntsd_cons_t	    *consp;
	vntsd_client_t	    *writerp;
	int		    rv;

	D1(stderr, "t@%d:acuire_writer :client@%d\n", thr_self(),
	    clientp->sockfd);

	assert(clientp != NULL);
	consp = clientp->cons;

	assert(consp);

	(void) mutex_lock(&consp->lock);

	assert(consp->clientpq != NULL);
	if (consp->clientpq->handle == clientp) {
		/* clientp is a writer already */
		(void) mutex_unlock(&consp->lock);
		return (VNTSD_SUCCESS);
	}

	/* current writer */
	writerp = (vntsd_client_t *)(consp->clientpq->handle);

	(void) mutex_lock(&writerp->lock);

	rv = vntsd_que_rm(&(consp->clientpq), clientp);
	assert(rv == VNTSD_SUCCESS);

	(void) mutex_lock(&clientp->lock);

	/* move client to be first in the console queue */
	consp->clientpq->handle = clientp;

	/* move previous writer to be the second in the queue */
	rv =  vntsd_que_insert_after(consp->clientpq, clientp, writerp);

	(void) mutex_unlock(&consp->lock);
	(void) mutex_unlock(&writerp->lock);
	(void) mutex_unlock(&clientp->lock);

	if (rv != VNTSD_SUCCESS) {
		return (rv);
	}

	/* write warning message to the writer */

	if ((rv = vntsd_write_line(writerp,
	    gettext("Warning: Console connection forced into read-only mode")))
	    != VNTSD_SUCCESS) {
		return (rv);
	}

	return (VNTSD_SUCCESS);
}

/* interrupt handler */
int
vntsd_cons_chk_intr(vntsd_client_t *clientp)
{

	if (clientp->status & VNTSD_CLIENT_TIMEOUT) {
		return (VNTSD_STATUS_CLIENT_QUIT);
	}
	if (clientp->status & VNTSD_CLIENT_CONS_DELETED) {
		return (VNTSD_STATUS_RESELECT_CONS);
	}

	if (clientp->status & VNTSD_CLIENT_IO_ERR) {
		return (VNTSD_STATUS_CLIENT_QUIT);
	}
	return (VNTSD_STATUS_CONTINUE);
}

/* read from client */
static int
read_char(vntsd_client_t *clientp, char *c)
{
	int	    rv;

	for (; ; ) {

		rv = vntsd_read_data(clientp, c);

		switch (rv) {

		case VNTSD_STATUS_ACQUIRE_WRITER:
			clientp->prev_char = 0;
			rv = acquire_writer(clientp);
			if (rv != VNTSD_SUCCESS) {
				return (rv);
			}
			break;

		case VNTSD_SUCCESS:
			/*
			 * Based on telnet protocol, when an <eol> is entered,
			 * vntsd receives <0x0d,0x00>. However, console expects
			 * <0xd> only. We need to filter out <0x00>.
			 */
			if (clientp->prev_char == 0xd && *c == 0) {
				clientp->prev_char = *c;
				break;
			}

			clientp->prev_char = *c;
			return (rv);

		default:
			assert(rv != VNTSD_STATUS_CONTINUE);
			clientp->prev_char = 0;
			return (rv);

		}
	}
}

/* vntsd_read worker */
int
vntsd_read(vntsd_client_t *clientp)
{
	char		c;
	int		rv;


	assert(clientp);
	D3(stderr, "t@%d vntsd_read@%d\n", thr_self(), clientp->sockfd);

	for (; ; ) {

		/* client input */
		rv = read_char(clientp, &c);

		if (rv == VNTSD_STATUS_INTR) {
			rv = vntsd_cons_chk_intr(clientp);
		}

		if (rv != VNTSD_SUCCESS) {
			return (rv);
		}

		assert(clientp->cons);

		/*
		 * Only keyboard inputs from first connection to a
		 * guest console should be accepted.  Check to see if
		 * this client is the first connection in console
		 * queue
		 */
		if (clientp->cons->clientpq->handle != clientp) {
			/*
			 * Since this console connection is not the first
			 * connection in the console queue,
			 * it is operating in 'reader'
			 * mode, print warning and ignore the input.
			 */
			rv = vntsd_write_line(clientp,
			    gettext(VNTSD_NO_WRITE_ACCESS_MSG));

			/* check errors and interrupts */
			if (rv == VNTSD_STATUS_INTR) {
				rv = vntsd_cons_chk_intr(clientp);
			}

			if (rv != VNTSD_SUCCESS) {
				return (rv);
			}

			continue;
		}

		rv = vntsd_ctrl_cmd(clientp, c);

		switch (rv) {
		case VNTSD_STATUS_CONTINUE:
			continue;
			break;
		case VNTSD_STATUS_INTR:
			rv = vntsd_cons_chk_intr(clientp);
			if (rv != VNTSD_SUCCESS) {
				return (rv);
			}
			break;
		case VNTSD_SUCCESS:
			break;
		default:
			return (rv);
		}

		/* write to vcc */
		rv = write_vcc(clientp, c);
		if (rv == VNTSD_STATUS_INTR) {
			rv = vntsd_cons_chk_intr(clientp);
		}
		if (rv != VNTSD_SUCCESS) {
			return (rv);
		}

	}

	/*NOTREACHED*/
	return (NULL);
}