Subversion Repositories openrisc_me

/* 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>

   Copyright (C) 2008 Embecosm Limited

   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>

   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 3 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, see <http://www.gnu.org/licenses/>. */

/* This program is commented throughout in a fashion suitable for processing

   with Doxygen. */

/* Autoconf and/or portability configuration */

#include "config.h"

#include "port.h"

/* System includes */

#if defined(HAVE_GRANTPT) && defined(HAVE_UNLOCKPT) && defined(HAVE_PTSNAME)

#endif

#include <stdlib.h>

#include <unistd.h>

#include <signal.h>

#include <termios.h>

#include <errno.h>

#include <stdio.h>

#include <fcntl.h>

#include <sys/types.h>

#include <sys/wait.h>

#if HAVE_SYS_STROPTS_H

#include <sys/stropts.h>        /* I_PUSH ioctl */

#endif

#if HAVE_BASENAME

#include <libgen.h>             /* basename() */

#endif

/* Package includes */

#include "channel.h"

#include "generic.h"

#include "fd.h"

/*! Data structure to represent the connection to the xterm */

struct xterm_channel

{

  struct fd_channel fds;

  int pid;

  char **argv;

};

/* Forward declaration of static functions */

static void  xterm_close (void *data);

static void *xterm_init (const char *input);

static int   xterm_open (void *data);

/*! Global data structure with the xterm interface functions */

struct channel_ops  xterm_channel_ops = {

        .init  = xterm_init,

        .open  = xterm_open,

        .close = xterm_close,

        .read  = fd_read,

        .write = fd_write,

        .free  = generic_free,

};

#if !(HAVE_BASENAME)

static char *

basename (const char *filename)

{

  char *p = strrchr (filename, '/');

  return p ? p + 1 : (char *) filename;

}

#endif /* HAVE_BASENAME */

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;

}

#if defined(HAVE_ON_EXIT)

static void

xterm_exit (int i, void *data)

{

  xterm_close (data);

}

#endif

#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;

#if defined(HAVE_ON_EXIT)

      /* reset cause exit(1), leaving an xterm opened */

      on_exit (xterm_exit, retval);

#endif

      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)

{

#if defined(HAVE_GRANTPT) && defined(HAVE_UNLOCKPT) && defined(HAVE_PTSNAME)

  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 HAVE_DECL_I_PUSH

  /* These modules must be pushed onto the stream for some non-Linux and

     non-Cygwin operating systems. */

  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);

      if (write (master, "\n", 1) < 0)   /* Don't ignore result */

        {

          printf ("ERROR: xterm: write failed\n");

        }

      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;

#else

  /* I don't see how this stuff should be working on a system that doesn't know

     grantpt(), unlockpt(), ptsname(). Mac OS X also does not have /dev/ptmx.

     -hpanther

   */

  return -1;

#endif

}