xref: /openbmc/obmc-console/console-server.c (revision 957818b41f7fc6b7d1a090098fbd34722041aba3)

/**
 * Console server process for OpenBMC
 *
 * Copyright © 2016 IBM Corporation <jk@ozlabs.org>
 */

#define _GNU_SOURCE

#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <err.h>
#include <termios.h>
#include <string.h>
#include <getopt.h>
#include <limits.h>

#include <sys/types.h>
#include <sys/poll.h>

#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))

static const char esc_str[] = { '\r', '~', '.' };

struct console_ctx {
	const char	*tty_kname;
	char		*tty_sysfs_devnode;
	char		*tty_dev;
	int		tty_sirq;
	int		tty_lpc_addr;
	int		tty_fd;
	int		console_fd_in;
	int		console_fd_out;
	bool		console_is_tty;
	struct termios	orig_termios;
	int		esc_str_pos;
};

static void usage(const char *progname)
{
	fprintf(stderr,
"usage: %s [options]\n"
"\n"
"Options:\n"
"  --device <TTY>  Use serial device TTY (eg, ttyS0)\n"
"",
		progname);
}

/* populates tty_dev and tty_sysfs_devnode, using the tty kernel name */
static int tty_find_device(struct console_ctx *ctx)
{
	char *tty_class_device_link;
	char *tty_device_tty_dir;
	char *tty_device_reldir;
	int rc;

	rc = -1;
	tty_class_device_link = NULL;
	tty_device_tty_dir = NULL;
	tty_device_reldir = NULL;

	rc = asprintf(&tty_class_device_link,
			"/sys/class/tty/%s", ctx->tty_kname);
	if (rc < 0)
		return -1;

	tty_device_tty_dir = realpath(tty_class_device_link, NULL);
	if (rc < 0) {
		warn("Can't query sysfs for device %s", ctx->tty_kname);
		goto out_free;
	}

	rc = asprintf(&tty_device_reldir, "%s/../../", tty_device_tty_dir);
	if (rc < 0)
		goto out_free;

	ctx->tty_sysfs_devnode = realpath(tty_device_reldir, NULL);
	if (!ctx->tty_sysfs_devnode)
		warn("Can't find parent device for %s", ctx->tty_kname);


	/* todo: lookup from major/minor info in sysfs, in case udev has
	 * renamed us */
	rc = asprintf(&ctx->tty_dev, "/dev/%s", ctx->tty_kname);
	if (rc < 0)
		goto out_free;

	rc = 0;

out_free:
	free(tty_class_device_link);
	free(tty_device_tty_dir);
	free(tty_device_reldir);
	return rc;
}

static int tty_set_sysfs_attr(struct console_ctx *ctx, const char *name,
		int value)
{
	char *path;
	FILE *fp;
	int rc;

	rc = asprintf(&path, "%s/%s", ctx->tty_sysfs_devnode, name);
	if (rc < 0)
		return -1;

	fp = fopen(path, "w");
	if (!fp) {
		warn("Can't access attribute %s on device %s",
				name, ctx->tty_kname);
		rc = -1;
		goto out_free;
	}
	setvbuf(fp, NULL, _IONBF, 0);

	rc = fprintf(fp, "0x%x", value);
	if (rc < 0)
		warn("Error writing to %s attribute of device %s",
				name, ctx->tty_kname);
	fclose(fp);



out_free:
	free(path);
	return rc;
}

/**
 * Open and initialise the serial device
 */
static int tty_init_io(struct console_ctx *ctx)
{
	if (ctx->tty_sirq)
		tty_set_sysfs_attr(ctx, "sirq", ctx->tty_sirq);
	if (ctx->tty_lpc_addr)
		tty_set_sysfs_attr(ctx, "lpc_address", ctx->tty_lpc_addr);
	tty_set_sysfs_attr(ctx, "enabled", 1);


	ctx->tty_fd = open(ctx->tty_dev, O_RDWR);
	if (ctx->tty_fd <= 0) {
		warn("Can't open tty %s", ctx->tty_dev);
		return -1;
	}

	/* Disable character delay. We may want to later enable this when
	 * we detect larger amounts of data
	 */
	fcntl(ctx->tty_fd, F_SETFL, FNDELAY);

	return 0;
}

/*
 * Setup our console channel for IO: use stdin/stdout, and if we're on a TTY,
 * put it in canonical mode
 */
static int console_init_io(struct console_ctx *ctx)
{
	struct termios termios;
	int rc;

	ctx->console_fd_in = STDIN_FILENO;
	ctx->console_fd_out = STDOUT_FILENO;
	ctx->console_is_tty = isatty(ctx->console_fd_in);

	if (!ctx->console_is_tty)
		return 0;

	rc = tcgetattr(ctx->console_fd_in, &termios);
	if (rc) {
		warn("Can't get terminal attributes for console");
		return -1;
	}
	memcpy(&ctx->orig_termios, &termios, sizeof(ctx->orig_termios));
	cfmakeraw(&termios);

	rc = tcsetattr(ctx->console_fd_in, TCSANOW, &termios);
	if (rc) {
		warn("Can't set terminal attributes for console");
		return -1;
	}

	return 0;
}

static int console_process_input(struct console_ctx *ctx,
		uint8_t *buf, size_t len)
{
	unsigned long i;
	uint8_t e;

	e = esc_str[ctx->esc_str_pos];

	for (i = 0; i < len; i++) {
		if (buf[i] == e) {
			ctx->esc_str_pos++;
			if (ctx->esc_str_pos == ARRAY_SIZE(esc_str))
				return 1;
			e = esc_str[ctx->esc_str_pos];
		} else {

			ctx->esc_str_pos = 0;
		}
	}
	return 0;
}

static void console_restore_termios(struct console_ctx *ctx)
{
	if (ctx->console_is_tty)
		tcsetattr(ctx->console_fd_in, TCSANOW, &ctx->orig_termios);
}

static int write_buf_to_fd(int fd, uint8_t *buf, size_t len)
{
	size_t pos;
	ssize_t rc;

	for (pos = 0; pos < len; pos += rc) {
		rc = write(fd, buf + pos, len - pos);
		if (rc <= 0) {
			warn("Write error");
			return -1;
		}
	}

	return 0;
}

int run_console(struct console_ctx *ctx)
{
	struct pollfd pollfds[2];
	int rc, len;

	pollfds[0].fd = ctx->tty_fd;
	pollfds[0].events = POLLIN;
	pollfds[1].fd = ctx->console_fd_in;
	pollfds[1].events = POLLIN;

	for (;;) {
		uint8_t buf[4096];

		rc = poll(pollfds, 2, -1);
		if (rc < 0) {
			warn("poll error");
			return -1;
		}

		if (pollfds[0].revents) {
			rc = read(ctx->tty_fd, buf, sizeof(buf));
			if (rc <= 0) {
				warn("Error reading from tty device");
				return -1;
			}
			rc = write_buf_to_fd(ctx->console_fd_out, buf, rc);
			if (rc < 0)
				return -1;
		}
		if (pollfds[1].revents) {
			rc = read(ctx->console_fd_in, buf, sizeof(buf));
			if (rc == 0)
				return 0;

			if (rc <= 0) {
				warn("Error reading from console");
				return -1;
			}
			len = rc;
			rc = console_process_input(ctx, buf, len);
			if (rc) {
				rc = 0;
				return 0;
			}
			rc = write_buf_to_fd(ctx->tty_fd, buf, len);
			if (rc < 0)
				return -1;
		}
	}
}

static const struct option options[] = {
	{ "device",	required_argument,	0, 'd'},
	{ "sirq",	required_argument,	0, 's'},
	{ "lpc-addr",	required_argument,	0, 'l'},
	{ },
};

int main(int argc, char **argv)
{
	struct console_ctx *ctx;
	int rc;

	ctx = malloc(sizeof(struct console_ctx));
	memset(ctx, 0, sizeof(*ctx));
	rc = -1;

	for (;;) {
		char *endp;
		int c, idx;

		c = getopt_long(argc, argv, "d:s:l:", options, &idx);
		if (c == -1)
			break;

		switch (c) {
		case 'd':
			ctx->tty_kname = optarg;
			break;
		case 'l':
			ctx->tty_lpc_addr = strtoul(optarg, &endp, 0);
			if (endp == optarg) {
				warnx("Invalid sirq: '%s'", optarg);
				goto out_free;
			}
			break;

		case 's':
			ctx->tty_sirq = strtoul(optarg, &endp, 0);
			if (endp == optarg) {
				warnx("Invalid sirq: '%s'", optarg);
				goto out_free;
			}
			break;

		case 'h':
		case '?':
			usage(argv[0]);
			rc = 0;
			goto out_free;
		}
	}

	if (!ctx->tty_kname) {
		fprintf(stderr,
			"Error: No TTY device specified (use --device)\n");
		return EXIT_FAILURE;
	}

	rc = tty_find_device(ctx);
	if (rc)
		return EXIT_FAILURE;

	rc = tty_init_io(ctx);
	if (rc)
		return EXIT_FAILURE;

	rc = console_init_io(ctx);
	if (rc)
		return EXIT_FAILURE;

	rc = run_console(ctx);

	console_restore_termios(ctx);

out_free:
	free(ctx->tty_sysfs_devnode);
	free(ctx->tty_dev);
	free(ctx);

	return rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}