Subversion Repositories or1k

/* xterm.c -- Definition of functions and structures for 
   peripheral to communicate with host through an xterm.
   Inspired from SWI-Prolog by Jan Wielemaker (GPL too)
   even if there is really few in common.
 
   Copyright (C) 2002 Richard Prescott <rip@step.polymtl.ca>
 
This file is part of OpenRISC 1000 Architectural Simulator.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
/*
 *  I really dislike using stuff beginning with '_' 
 *  They are suppose to be reserved for the compiler
 *  as explained in C standards.
 */
#define _XOPEN_SOURCE		/* grantpt() and al. */
#define _GNU_SOURCE		/* on_exit */
 
#include <sys/types.h>		/* waitpid() */
#include <sys/wait.h>		/* waitpid() */
#include <stdio.h>		/* sprintf() */
#include <stdlib.h>		/* kill(), on_exit() */
#include <unistd.h>		/* close() */
#include <fcntl.h>		/* O_RDWR */
#include <string.h>		/* strchr() */
 
#ifndef __CYGWIN__
#include <sys/stropts.h>	/* grantpt(), unlockpt() */
#include <libgen.h>		/* basename() */
#endif /* __CYGWIN__ */
 
#include <termios.h>		/* struct termios and al. */
#include <signal.h>		/* signal() and al. */
#include <errno.h>		/* errno and al. */
 
#include "channel.h"
#include "generic.h"
#include "fd.h"
 
struct xterm_channel
{
	struct fd_channel fds;
	int pid;
	char** argv;
};
 
#ifdef __CYGWIN__
char *basename(const char *filename)
{
	char *p = strrchr (filename, '/');
 
	return p ? p + 1 : (char *) filename;
}
#endif /* __CYGWIN__ */
 
static void xterm_close(void * data)
{
	struct xterm_channel * xt = data;
 
	if(!xt)
		return;
 
	if(xt->fds.fdin != -1)
		close(xt->fds.fdin);
 
	if(xt->pid != -1)
	{
		kill(xt->pid, SIGKILL);
		waitpid(xt->pid, NULL, 0);
	}
 
	if (xt->argv)
		free (xt->argv);
 
	xt->fds.fdin = -1;
	xt->fds.fdout = -1;
	xt->pid = -1;
	xt->argv = NULL;
 
}
 
static void xterm_exit(int i, void * data)
{
	xterm_close(data);
}
 
#define MAX_XTERM_ARGS 100
static void * xterm_init(const char * input)
{
	struct xterm_channel * retval = malloc(sizeof(struct xterm_channel));
	if(retval)
	{
		int i;
		char *arglist;
 
		retval->fds.fdin = -1;
		retval->fds.fdout = -1;
		retval->pid = -1;
		/* reset cause exit(1), leaving an xterm opened */
		on_exit(xterm_exit, retval);
 
		i = 2;
		arglist = (char*)input;
		retval->argv = malloc(sizeof(char*) * MAX_XTERM_ARGS);
		if (!retval->argv) {
			free(retval);
			return NULL;
		}
		/* Assume xterm arguments are separated by whitespace */
		while (retval->argv[i++] = strtok(arglist, " \t\n")) {
			arglist = NULL;
			if (i == MAX_XTERM_ARGS - 1) {
				free(retval);
				return NULL;
			}
		}
 
	}
	return (void*)retval;
}
 
 
 
static int xterm_open(void * data)
{
	struct xterm_channel * xt = data;
	int master, retval;
	char * slavename;
	struct termios termio;
	char arg[64], * fin;
 
	if(!data)
	{
		errno = ENODEV;
		return -1;
	}
 
	master = open("/dev/ptmx", O_RDWR);
 
	if(master < 0)
		return -1;
 
	grantpt(master);                             
	unlockpt(master);
	slavename = (char*)ptsname(master);
 
	if(!slavename)
	{
		errno = ENOTTY;
		goto closemastererror;
	}
 
	xt->fds.fdout = xt->fds.fdin = open(slavename, O_RDWR);
	if(xt->fds.fdout < 0) goto closemastererror;
 
#if !defined(linux) && !defined(__CYGWIN__)
	/* Linux does not support STREAMS-style line discipline, even with LiS. */
	retval = ioctl(xt->fds.fdin, I_PUSH, "ptem"); 
	if(retval < 0) goto closeslaveerror;
 
	retval = ioctl(xt->fds.fdin, I_PUSH, "ldterm");
	if(retval < 0) goto closeslaveerror;
#endif
 
	retval = tcgetattr(xt->fds.fdin, &termio);
	if(retval < 0) goto closeslaveerror;
	termio.c_lflag &= ~ECHO;
	retval = tcsetattr(xt->fds.fdin, TCSADRAIN, &termio);
	if(retval < 0) goto closeslaveerror;
 
	xt->pid = fork();
 
	if(xt->pid == -1) goto closeslaveerror;
 
	if(xt->pid == 0)
	{
		/* Ctrl-C on sim still kill the xterm, grrr */
		signal(SIGINT, SIG_IGN);
 
		fin = slavename+strlen(slavename)-2;
		if (strchr(fin, '/' ))
		{
			sprintf(arg, "-S%s/%d",
				basename(slavename),
				master);
		}
		else
		{
		      sprintf(arg, "-S%c%c%d", fin[0], fin[1], master);
		}
		xt->argv[0] = "xterm";
		xt->argv[1] = arg;
		execvp("xterm", xt->argv);
		write(master, "\n", 1);
		exit(1);
	}
 
	do retval = read(xt->fds.fdin, &arg, 1);
	while(retval >= 0 && arg[0] != '\n');
	if(retval < 0) goto closeslaveerror;
 
	termio.c_lflag |= ECHO;
	retval = tcsetattr(xt->fds.fdin, TCSADRAIN, &termio);
 
	if(retval < 0) goto closeslaveerror;
 
	return 0;
 
closeslaveerror:
	close(xt->fds.fdin);
 
closemastererror:
	close(master);
	xt->pid = xt->fds.fdin = xt->fds.fdout = -1;
	return -1;
}
 
struct channel_ops xterm_channel_ops =
{
	init:	xterm_init,
	open:	xterm_open,
	close:	xterm_close,
	read:	fd_read,
	write:	fd_write,
	free:	generic_free,
};
 
/*
 * Local variables:
 * c-file-style: "linux"
 * End:
 */