diff options
Diffstat (limited to 'examples/rlfe/rlfe.c')
| -rw-r--r-- | examples/rlfe/rlfe.c | 792 |
1 files changed, 792 insertions, 0 deletions
diff --git a/examples/rlfe/rlfe.c b/examples/rlfe/rlfe.c new file mode 100644 index 0000000..f40b2dd --- /dev/null +++ b/examples/rlfe/rlfe.c @@ -0,0 +1,792 @@ +/* A front-end using readline to "cook" input lines. + * + * Copyright (C) 2004, 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. + * + * 2003-11-07 Wolfgang Taeuber <wolfgang_taeuber@agilent.com> + * Specify a history file and the size of the history file with command + * line options; use EDITOR/VISUAL to set vi/emacs preference. + */ + +/* PROBLEMS/TODO: + * + * Only tested under GNU/Linux and Mac OS 10.x; needs to be ported. + * + * Switching between line-editing-mode vs raw-char-mode depending on + * what tcgetattr returns is inherently not robust, plus it doesn't + * work when ssh/telnetting in. A better solution is possible if the + * tty system can send in-line escape sequences indicating the current + * mode, echo'd input, etc. That would also allow a user preference + * to set different colors for prompt, input, stdout, and stderr. + * + * When running mc -c under the Linux console, mc does not recognize + * mouse clicks, which mc does when not running under rlfe. + * + * 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 rlfe 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. (See HAVE_ALREADY_PROMPTED.) + * + * Desirable readline feature: When in cooked no-echo mode (e.g. password), + * echo characters are they are types with '*', but remove them when done. + * + * Asynchronous 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. + */ + +#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 "config.h" +#include "extern.h" + +#if defined (HAVE_SYS_WAIT_H) +# include <sys/wait.h> +#endif + +#ifdef READLINE_LIBRARY +# include "readline.h" +# include "history.h" +#else +# include <readline/readline.h> +# include <readline/history.h> +#endif + +#ifndef COMMAND +#define COMMAND "/bin/bash" +#endif +#ifndef COMMAND_ARGS +#define COMMAND_ARGS COMMAND +#endif + +#ifndef ALT_COMMAND +#define ALT_COMMAND "/bin/sh" +#endif +#ifndef ALT_COMMAND_ARGS +#define ALT_COMMAND_ARGS ALT_COMMAND +#endif + +#ifndef HAVE_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 + +#define APPLICATION_NAME "rlfe" + +static int in_from_inferior_fd; +static int out_to_inferior_fd; +static void set_edit_mode (); +static void usage_exit (); +static char *hist_file = 0; +static int hist_size = 0; + +/* 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 1024 +char echo_suppress_buffer[ECHO_SUPPRESS_MAX]; +int echo_suppress_start = 0; +int echo_suppress_limit = 0; + +/*#define DEBUG*/ + +#ifdef DEBUG +FILE *logfile = NULL; +#define DPRINT0(FMT) (fprintf(logfile, FMT), fflush(logfile)) +#define DPRINT1(FMT, V1) (fprintf(logfile, FMT, V1), fflush(logfile)) +#define DPRINT2(FMT, V1, V2) (fprintf(logfile, FMT, V1, V2), fflush(logfile)) +#else +#define DPRINT0(FMT) ((void) 0) /* Do nothing */ +#define DPRINT1(FMT, V1) ((void) 0) /* Do nothing */ +#define DPRINT2(FMT, V1, V2) ((void) 0) /* Do nothing */ +#endif + +struct termios orig_term; + +/* Pid of child process. */ +static pid_t child = -1; + +static void +sig_child (int signo) +{ + int status; + wait (&status); + if (hist_file != 0) + { + write_history (hist_file); + if (hist_size) + history_truncate_file (hist_file, hist_size); + } + 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_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 void +add_special_char(int ch) +{ + if (ch != 0) + special_chars[special_chars_count++] = ch; +} + +static int eof_char; + +static int +is_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 do_emphasize_input = 1; +int current_emphasize_input; + +char *start_input_mode = "\033[1m"; +char *end_input_mode = "\033[0m"; + +int num_keys = 0; + +static void maybe_emphasize_input (int on) +{ + if (on == current_emphasize_input + || (on && ! do_emphasize_input)) + return; + fprintf (rl_outstream, on ? start_input_mode : end_input_mode); + fflush (rl_outstream); + current_emphasize_input = on; +} + +static void +null_prep_terminal (int meta) +{ +} + +static void +null_deprep_terminal () +{ + maybe_emphasize_input (0); +} + +static int +pre_input_change_mode (void) +{ + return 0; +} + +char pending_special_char; + +static void +line_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). */ + +int +my_rl_getc (FILE *dummy) +{ + int ch = rl_getc (stdin); + if (is_special_char (ch)) + { + pending_special_char = ch; + return '\r'; + } + return ch; +} + +int +main(int argc, char** argv) +{ + char *path; + int i; + int master; + char *name; + 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; + int arg_base = 1; + +#ifdef DEBUG + logfile = fopen("/tmp/rlfe.log", "w"); +#endif + + while (arg_base<argc) + { + if (argv[arg_base][0] != '-') + break; + if (arg_base+1 >= argc ) + usage_exit(); + switch(argv[arg_base][1]) + { + case 'h': + arg_base++; + hist_file = argv[arg_base]; + break; + case 's': + arg_base++; + hist_size = atoi(argv[arg_base]); + if (hist_size<0) + usage_exit(); + break; + default: + usage_exit(); + } + arg_base++; + } + if (hist_file) + read_history (hist_file); + + set_edit_mode (); + + rl_readline_name = APPLICATION_NAME; + + if ((master = OpenPTY (&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); + } +#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) + { + perror("could not set session leader"); + } + + /* Tie us to our new controlling tty. */ +#ifdef TIOCSCTTY + if (ioctl(slave, TIOCSCTTY, NULL)) + { + perror("could not set new controlling tty"); + } +#else + if ((slave = get_slave_pty(name)) < 0) + { + perror("ptypair: could not open slave pty"); + exit(1); + } +#endif + + /* make slave pty be standard in, out, and error */ + dup2(slave, STDIN_FILENO); + dup2(slave, STDOUT_FILENO); + dup2(slave, STDERR_FILENO); + + /* at this point the slave pty should be standard input */ + if (slave > 2) + { + close(slave); + } + + /* Try to restore window size; failure isn't critical */ + if (ioctl(STDOUT_FILENO, TIOCSWINSZ, &ws) < 0) + { + perror("could not restore window size"); + } + + /* now start the shell */ + { + static char* command_args[] = { COMMAND_ARGS, NULL }; + static char* alt_command_args[] = { ALT_COMMAND_ARGS, NULL }; + if (argc <= 1) + { + execvp (COMMAND, command_args); + execvp (ALT_COMMAND, alt_command_args); + } + else + execvp (argv[arg_base], &argv[arg_base]); + } + + /* should never be reached */ + exit(1); + } + + /* parent */ + signal (SIGCHLD, sig_child); + + /* Note that we only set termios settings for standard input; + * the master side of a pty is NOT a tty. + */ + tcgetattr(STDIN_FILENO, &orig_term); + + t = orig_term; + eof_char = t.c_cc[VEOF]; + /* add_special_char(t.c_cc[VEOF]);*/ + add_special_char(t.c_cc[VINTR]); + add_special_char(t.c_cc[VQUIT]); + add_special_char(t.c_cc[VSUSP]); +#if defined (VDISCARD) + add_special_char(t.c_cc[VDISCARD]); +#endif + + t.c_lflag &= ~(ICANON | ISIG | ECHO | ECHOCTL | ECHOE | \ + ECHOK | ECHONL +#if defined (ECHOKE) + | ECHOKE +#endif +#if defined (ECHOPRT) + | ECHOPRT +#endif + ); + t.c_iflag &= ~ICRNL; + t.c_iflag |= IGNBRK; + t.c_cc[VMIN] = 1; + t.c_cc[VTIME] = 0; + tcsetattr(STDIN_FILENO, TCSANOW, &t); + in_from_inferior_fd = master; + out_to_inferior_fd = master; + rl_instream = fdopen (master, "r"); + rl_getc_function = my_rl_getc; + + rl_prep_term_function = null_prep_terminal; + rl_deprep_term_function = null_deprep_terminal; + rl_pre_input_hook = pre_input_change_mode; + rl_callback_handler_install (prompt, line_handler); + + in_from_tty_fd = STDIN_FILENO; + FD_ZERO (&in_set); + maxfd = in_from_inferior_fd > in_from_tty_fd ? in_from_inferior_fd + : in_from_tty_fd; + for (;;) + { + int num; + FD_SET (in_from_inferior_fd, &in_set); + FD_SET (in_from_tty_fd, &in_set); + + num = select(maxfd+1, &in_set, NULL, NULL, NULL); + + if (propagate_sigwinch) + { + struct winsize ws; + if (ioctl (STDIN_FILENO, TIOCGWINSZ, &ws) >= 0) + { + ioctl (master, TIOCSWINSZ, &ws); + } + propagate_sigwinch = 0; + continue; + } + + if (num <= 0) + { + perror ("select"); + exit (-1); + } + if (FD_ISSET (in_from_tty_fd, &in_set)) + { + extern int _rl_echoing_p; + struct termios term_master; + int do_canon = 1; + int do_icrnl = 1; + int ioctl_ret; + + DPRINT1("[tty avail num_keys:%d]\n", num_keys); + + /* If we can't get tty modes for the master side of the pty, we + can't handle non-canonical-mode programs. Always assume the + master is in canonical echo mode if we can't tell. */ + ioctl_ret = tcgetattr(master, &term_master); + + if (ioctl_ret >= 0) + { + do_canon = (term_master.c_lflag & ICANON) != 0; + do_icrnl = (term_master.c_lflag & ICRNL) != 0; + _rl_echoing_p = (term_master.c_lflag & ECHO) != 0; + DPRINT1 ("echo,canon,crnl:%03d\n", + 100 * _rl_echoing_p + + 10 * do_canon + + 1 * do_icrnl); + } + else + { + if (ioctl_err == 0) + DPRINT1("tcgetattr on master fd failed: errno = %d\n", errno); + ioctl_err = 1; + } + + if (do_canon == 0 && num_keys == 0) + { + char ch[10]; + int count = read (STDIN_FILENO, ch, sizeof(ch)); + DPRINT1("[read %d chars from stdin: ", count); + DPRINT2(" \"%.*s\"]\n", count, ch); + if (do_icrnl) + { + int i = count; + while (--i >= 0) + { + if (ch[i] == '\r') + ch[i] = '\n'; + } + } + maybe_emphasize_input (1); + write (out_to_inferior_fd, ch, count); + } + else + { + if (num_keys == 0) + { + int i; + /* Re-install callback handler for new prompt. */ + if (prompt != empty_string) + free (prompt); + if (prompt == NULL) + { + DPRINT0("New empty prompt\n"); + prompt = empty_string; + } + else + { + if (do_emphasize_input && buf_count > 0) + { + prompt = malloc (buf_count + strlen (end_input_mode) + + strlen (start_input_mode) + 5); + sprintf (prompt, "\001%s\002%.*s\001%s\002", + end_input_mode, + buf_count, buf, + start_input_mode); + } + else + { + prompt = malloc (buf_count + 1); + memcpy (prompt, buf, buf_count); + prompt[buf_count] = '\0'; + } + DPRINT1("New prompt '%s'\n", prompt); +#if 0 /* ifdef HAVE_RL_ALREADY_PROMPTED */ + /* Doesn't quite work when do_emphasize_input is 1. */ + rl_already_prompted = buf_count > 0; +#else + if (buf_count > 0) + write (1, "\r", 1); +#endif + } + + rl_callback_handler_install (prompt, line_handler); + } + num_keys++; + maybe_emphasize_input (1); + rl_callback_read_char (); + } + } + else /* output from inferior. */ + { + int i; + int count; + int old_count; + if (buf_count > (sizeof(buf) >> 2)) + buf_count = 0; + count = read (in_from_inferior_fd, buf+buf_count, + sizeof(buf) - buf_count); + DPRINT2("read %d from inferior, buf_count=%d", count, buf_count); + DPRINT2(": \"%.*s\"", count, buf+buf_count); + maybe_emphasize_input (0); + if (count <= 0) + { + DPRINT0 ("(Connection closed by foreign host.)\n"); + tcsetattr(STDIN_FILENO, TCSANOW, &orig_term); + exit (0); + } + old_count = buf_count; + + /* Look for any pending echo that we need to suppress. */ + while (echo_suppress_start < echo_suppress_limit + && count > 0 + && buf[buf_count] == echo_suppress_buffer[echo_suppress_start]) + { + count--; + buf_count++; + echo_suppress_start++; + } + DPRINT1("suppressed %d characters of echo.\n", buf_count-old_count); + + /* Write to the terminal anything that was not suppressed. */ + if (count > 0) + write (1, buf + buf_count, count); + + /* Finally, look for a prompt candidate. + * When we get around to going input (from the keyboard), + * we will consider the prompt to be anything since the last + * line terminator. So we need to save that text in the + * initial part of buf. However, anything before the + * most recent end-of-line is not interesting. */ + buf_count += count; +#if 1 + for (i = buf_count; --i >= old_count; ) +#else + for (i = buf_count - 1; i-- >= buf_count - count; ) +#endif + { + if (buf[i] == '\n' || buf[i] == '\r') + { + i++; + memmove (buf, buf+i, buf_count - i); + buf_count -= i; + break; + } + } + DPRINT2("-> i: %d, buf_count: %d\n", i, buf_count); + } + } +} + +static void set_edit_mode () +{ + int vi = 0; + char *shellopts; + + shellopts = getenv ("SHELLOPTS"); + while (shellopts != 0) + { + if (strncmp ("vi", shellopts, 2) == 0) + { + vi = 1; + break; + } + shellopts = strchr (shellopts + 1, ':'); + } + + if (!vi) + { + if (getenv ("EDITOR") != 0) + vi |= strcmp (getenv ("EDITOR"), "vi") == 0; + } + + if (vi) + rl_variable_bind ("editing-mode", "vi"); + else + rl_variable_bind ("editing-mode", "emacs"); +} + + +static void usage_exit () +{ + fprintf (stderr, "Usage: rlfe [-h histfile] [-s size] cmd [arg1] [arg2] ...\n\n"); + exit (1); +} |