/* A front-end using readline to "cook" input lines for Kawa. * * Copyright (C) 1999  Per Bothner *  * This front-end 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, or (at your option) * any later version. * * Some code from Johnson & Troan: "Linux Application Development" * (Addison-Wesley, 1998) was used directly or for inspiration. *//* PROBLEMS/TODO: * * Only tested under Linux;  needs to be ported. * * When running mc -c under the Linux console, mc does not recognize * mouse clicks, which mc does when not running under fep. * * Pasting selected text containing tabs is like hitting the tab character, * which invokes readline completion.  We don't want this.  I don't know * if this is fixable without integrating fep into a terminal emulator. * * Echo suppression is a kludge, but can only be avoided with better kernel * support: We need a tty mode to disable "real" echoing, while still * letting the inferior think its tty driver to doing echoing. * Stevens's book claims SCR$ and BSD4.3+ have TIOCREMOTE. * * The latest readline may have some hooks we can use to avoid having * to back up the prompt. * * Desirable readline feature:  When in cooked no-echo mode (e.g. password), * echo characters are they are types with '*', but remove them when done. * * A synchronous output while we're editing an input line should be * inserted in the output view *before* the input line, so that the * lines being edited (with the prompt) float at the end of the input. * * A "page mode" option to emulate more/less behavior:  At each page of * output, pause for a user command.  This required parsing the output * to keep track of line lengths.  It also requires remembering the * output, if we want an option to scroll back, which suggests that * this should be integrated with a terminal emulator like xterm. */#ifdef HAVE_CONFIG_H#  include <config.h>#endif#include <stdio.h>#include <fcntl.h>#include <sys/types.h>#include <sys/socket.h>#include <netinet/in.h>#include <arpa/inet.h>#include <signal.h>#include <netdb.h>#include <stdlib.h>#include <errno.h>#include <grp.h>#include <string.h>#include <sys/stat.h>#include <unistd.h>#include <sys/ioctl.h>#include <termios.h>#include <limits.h>#include <dirent.h>#ifdef READLINE_LIBRARY#  include "readline.h"#  include "history.h"#else#  include <readline/readline.h>#  include <readline/history.h>#endif#ifndef COMMAND#define COMMAND "/bin/sh"#endif#ifndef COMMAND_ARGS#define COMMAND_ARGS COMMAND#endif#ifndef HAVE_MEMMOVE#ifndef memmove#  if __GNUC__ > 1#    define memmove(d, s, n)	__builtin_memcpy(d, s, n)#  else#    define memmove(d, s, n)	memcpy(d, s, n)#  endif#else#  define memmove(d, s, n)	memcpy(d, s, n)#endif#endif#define APPLICATION_NAME "Rlfe"#ifndef errnoextern int errno;#endifextern int optind;extern char *optarg;static char *progname;static char *progversion;static int in_from_inferior_fd;static int out_to_inferior_fd;/* Unfortunately, we cannot safely display echo from the inferior process.   The reason is that the echo bit in the pty is "owned" by the inferior,   and if we try to turn it off, we could confuse the inferior.   Thus, when echoing, we get echo twice:  First readline echoes while   we're actually editing. Then we send the line to the inferior, and the   terminal driver send back an extra echo.   The work-around is to remember the input lines, and when we see that   line come back, we supress the output.   A better solution (supposedly available on SVR4) would be a smarter   terminal driver, with more flags ... */#define ECHO_SUPPRESS_MAX 1024char echo_suppress_buffer[ECHO_SUPPRESS_MAX];int echo_suppress_start = 0;int echo_suppress_limit = 0;/* #define DEBUG */static FILE *logfile = NULL;#ifdef DEBUGFILE *debugfile = NULL;#define DPRINT0(FMT) (fprintf(debugfile, FMT), fflush(debugfile))#define DPRINT1(FMT, V1) (fprintf(debugfile, FMT, V1), fflush(debugfile))#define DPRINT2(FMT, V1, V2) (fprintf(debugfile, FMT, V1, V2), fflush(debugfile))#else#define DPRINT0(FMT) /* Do nothing */#define DPRINT1(FMT, V1) /* Do nothing */#define DPRINT2(FMT, V1, V2) /* Do nothing */#endifstruct termios orig_term;static int rlfe_directory_completion_hook __P((char **));static int rlfe_directory_rewrite_hook __P((char **));static char *rlfe_filename_completion_function __P((const char *, int));/* Pid of child process. */static pid_t child = -1;static voidsig_child (int signo){  int status;  wait (&status);  DPRINT0 ("(Child process died.)\n");  tcsetattr(STDIN_FILENO, TCSANOW, &orig_term);  exit (0);}volatile int propagate_sigwinch = 0;/* sigwinch_handler * propagate window size changes from input file descriptor to * master side of pty. */void sigwinch_handler(int signal) {    propagate_sigwinch = 1;}/* get_master_pty() takes a double-indirect character pointer in which * to put a slave name, and returns an integer file descriptor. * If it returns < 0, an error has occurred. * Otherwise, it has returned the master pty file descriptor, and fills * in *name with the name of the corresponding slave pty. * Once the slave pty has been opened, you are responsible to free *name. */int get_master_pty(char **name) {    int i, j;   /* default to returning error */   int master = -1;   /* create a dummy name to fill in */   *name = strdup("/dev/ptyXX");   /* search for an unused pty */   for (i=0; i<16 && master <= 0; i++) {      for (j=0; j<16 && master <= 0; j++) {         (*name)[5] = 'p';         (*name)[8] = "pqrstuvwxyzPQRST"[i];         (*name)[9] = "0123456789abcdef"[j];         /* open the master pty */         if ((master = open(*name, O_RDWR)) < 0) {            if (errno == ENOENT) {               /* we are out of pty devices */               free (*name);               return (master);            }         }         else {           /* By substituting a letter, we change the master pty            * name into the slave pty name.            */           (*name)[5] = 't';           if (access(*name, R_OK|W_OK) != 0)             {               close(master);               master = -1;             }         }      }   }   if ((master < 0) && (i == 16) && (j == 16)) {      /* must have tried every pty unsuccessfully */      free (*name);      return (master);   }   (*name)[5] = 't';   return (master);}/* get_slave_pty() returns an integer file descriptor. * If it returns < 0, an error has occurred. * Otherwise, it has returned the slave file descriptor. */int get_slave_pty(char *name) {    struct group *gptr;   gid_t gid;   int slave = -1;   /* chown/chmod the corresponding pty, if possible.    * This will only work if the process has root permissions.    * Alternatively, write and exec a small setuid program that    * does just this.    */   if ((gptr = getgrnam("tty")) != 0) {      gid = gptr->gr_gid;   } else {      /* if the tty group does not exist, don't change the       * group on the slave pty, only the owner       */      gid = -1;   }   /* Note that we do not check for errors here.  If this is code    * where these actions are critical, check for errors!    */   chown(name, getuid(), gid);   /* This code only makes the slave read/writeable for the user.    * If this is for an interactive shell that will want to    * receive "write" and "wall" messages, OR S_IWGRP into the    * second argument below.    */   chmod(name, S_IRUSR|S_IWUSR);   /* open the corresponding slave pty */   slave = open(name, O_RDWR);   return (slave);}/* Certain special characters, such as ctrl/C, we want to pass directly   to the inferior, rather than letting readline handle them. */static char special_chars[20];static int special_chars_count;static voidadd_special_char(int ch){  if (ch != 0)    special_chars[special_chars_count++] = ch;}static int eof_char;static intis_special_char(int ch){  int i;#if 0  if (ch == eof_char && rl_point == rl_end)    return 1;#endif  for (i = special_chars_count;  --i >= 0; )    if (special_chars[i] == ch)      return 1;  return 0;}static char buf[1024];/* buf[0 .. buf_count-1] is the what has been emitted on the current line.   It is used as the readline prompt. */static int buf_count = 0;int num_keys = 0;static voidnull_prep_terminal (int meta){}static voidnull_deprep_terminal (){}char pending_special_char;static voidline_handler (char *line){  if (line == NULL)    {      char buf[1];      DPRINT0("saw eof!\n");      buf[0] = '\004'; /* ctrl/d */      write (out_to_inferior_fd, buf, 1);    }  else    {      static char enter[] = "\r";      /*  Send line to inferior: */      int length = strlen (line);      if (length > ECHO_SUPPRESS_MAX-2)	{	  echo_suppress_start = 0;	  echo_suppress_limit = 0;	}      else	{	  if (echo_suppress_limit + length > ECHO_SUPPRESS_MAX - 2)	    {	      if (echo_suppress_limit - echo_suppress_start + length		  <= ECHO_SUPPRESS_MAX - 2)		{		  memmove (echo_suppress_buffer,			   echo_suppress_buffer + echo_suppress_start,			   echo_suppress_limit - echo_suppress_start);		  echo_suppress_limit -= echo_suppress_start;		  echo_suppress_start = 0;		}	      else		{		  echo_suppress_limit = 0;		}	      echo_suppress_start = 0;	    }	  memcpy (echo_suppress_buffer + echo_suppress_limit,		  line, length);	  echo_suppress_limit += length;	  echo_suppress_buffer[echo_suppress_limit++] = '\r';	  echo_suppress_buffer[echo_suppress_limit++] = '\n';	}      write (out_to_inferior_fd, line, length);      if (pending_special_char == 0)        {          write (out_to_inferior_fd, enter, sizeof(enter)-1);          if (*line)            add_history (line);        }      free (line);    }  rl_callback_handler_remove ();  buf_count = 0;  num_keys = 0;  if (pending_special_char != 0)    {      write (out_to_inferior_fd, &pending_special_char, 1);      pending_special_char = 0;    }}/* Value of rl_getc_function.   Use this because readline should read from stdin, not rl_instream,   points to the pty (so readline has monitor its terminal modes). */intmy_rl_getc (FILE *dummy){  int ch = rl_getc (stdin);  if (is_special_char (ch))    {      pending_special_char = ch;      return '\r';    }  return ch;}static voidusage(){  fprintf (stderr, "%s: usage: %s [-l filename] [-a] [-n appname] [-hv] [command [arguments...]]\n",		   progname, progname);}intmain(int argc, char** argv){  char *path;  int i, append;  int master;  char *name, *logfname, *appname;  int in_from_tty_fd;  struct sigaction act;  struct winsize ws;  struct termios t;  int maxfd;  fd_set in_set;  static char empty_string[1] = "";  char *prompt = empty_string;  int ioctl_err = 0;  if ((progname = strrchr (argv[0], '/')) == 0)    progname = argv[0];  else    progname++;  progversion = RL_LIBRARY_VERSION;  append = 0;  appname = APPLICATION_NAME;  logfname = (char *)NULL;  while ((i = getopt (argc, argv, "ahl:n:v")) != EOF)    {      switch (i)	{	case 'l':	  logfname = optarg;	  break;	case 'n':	  appname = optarg;	  break;	case 'a':	  append = 1;	  break;	case 'h':	  usage ();	  exit (0);	case 'v':	  fprintf (stderr, "%s version %s\n", progname, progversion);	  exit (0);	default:	  usage ();	  exit (2);	}    }  argc -= optind;  argv += optind;  if (logfname)    {      logfile = fopen (logfname, append ? "a" : "w");      if (logfile == 0)	fprintf (stderr, "%s: warning: could not open log file %s: %s\n",			 progname, logfname, strerror (errno));    }      rl_readline_name = appname;  #ifdef DEBUG  debugfile = fopen("LOG", "w");#endif  if ((master = get_master_pty(&name)) < 0)    {      perror("ptypair: could not open master pty");      exit(1);    }  DPRINT1("pty name: '%s'\n", name);  /* set up SIGWINCH handler */  act.sa_handler = sigwinch_handler;  sigemptyset(&(act.sa_mask));  act.sa_flags = 0;  if (sigaction(SIGWINCH, &act, NULL) < 0)    {      perror("ptypair: could not handle SIGWINCH ");      exit(1);    }  if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) < 0)    {      perror("ptypair: could not get window size");      exit(1);    }  if ((child = fork()) < 0)    {      perror("cannot fork");      exit(1);    }  if (child == 0)    {       int slave;  /* file descriptor for slave pty */      /* We are in the child process */      close(master);#ifdef TIOCSCTTY      if ((slave = get_slave_pty(name)) < 0)	{	  perror("ptypair: could not open slave pty");	  exit(1);	}      free(name);#endif      /* We need to make this process a session group leader, because       * it is on a new PTY, and things like job control simply will       * not work correctly unless there is a session group leader       * and process group leader (which a session group leader       * automatically is). This also disassociates us from our old       * controlling tty.        */      if (setsid() < 0)