/* A front-end using readline to "cook" input lines.
|
/* A front-end using readline to "cook" input lines.
|
*
|
*
|
* Copyright (C) 2004, 1999 Per Bothner
|
* Copyright (C) 2004, 1999 Per Bothner
|
*
|
*
|
* This front-end program is free software; you can redistribute it and/or
|
* 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
|
* 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)
|
* by the Free Software Foundation; either version 2, or (at your option)
|
* any later version.
|
* any later version.
|
*
|
*
|
* Some code from Johnson & Troan: "Linux Application Development"
|
* Some code from Johnson & Troan: "Linux Application Development"
|
* (Addison-Wesley, 1998) was used directly or for inspiration.
|
* (Addison-Wesley, 1998) was used directly or for inspiration.
|
*
|
*
|
* 2003-11-07 Wolfgang Taeuber <wolfgang_taeuber@agilent.com>
|
* 2003-11-07 Wolfgang Taeuber <wolfgang_taeuber@agilent.com>
|
* Specify a history file and the size of the history file with command
|
* Specify a history file and the size of the history file with command
|
* line options; use EDITOR/VISUAL to set vi/emacs preference.
|
* line options; use EDITOR/VISUAL to set vi/emacs preference.
|
*/
|
*/
|
|
|
/* PROBLEMS/TODO:
|
/* PROBLEMS/TODO:
|
*
|
*
|
* Only tested under GNU/Linux and Mac OS 10.x; needs to be ported.
|
* 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
|
* Switching between line-editing-mode vs raw-char-mode depending on
|
* what tcgetattr returns is inherently not robust, plus it doesn't
|
* what tcgetattr returns is inherently not robust, plus it doesn't
|
* work when ssh/telnetting in. A better solution is possible if the
|
* work when ssh/telnetting in. A better solution is possible if the
|
* tty system can send in-line escape sequences indicating the current
|
* tty system can send in-line escape sequences indicating the current
|
* mode, echo'd input, etc. That would also allow a user preference
|
* mode, echo'd input, etc. That would also allow a user preference
|
* to set different colors for prompt, input, stdout, and stderr.
|
* to set different colors for prompt, input, stdout, and stderr.
|
*
|
*
|
* When running mc -c under the Linux console, mc does not recognize
|
* When running mc -c under the Linux console, mc does not recognize
|
* mouse clicks, which mc does when not running under rlfe.
|
* mouse clicks, which mc does when not running under rlfe.
|
*
|
*
|
* Pasting selected text containing tabs is like hitting the tab character,
|
* Pasting selected text containing tabs is like hitting the tab character,
|
* which invokes readline completion. We don't want this. I don't know
|
* which invokes readline completion. We don't want this. I don't know
|
* if this is fixable without integrating rlfe into a terminal emulator.
|
* if this is fixable without integrating rlfe into a terminal emulator.
|
*
|
*
|
* Echo suppression is a kludge, but can only be avoided with better kernel
|
* 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
|
* support: We need a tty mode to disable "real" echoing, while still
|
* letting the inferior think its tty driver to doing echoing.
|
* letting the inferior think its tty driver to doing echoing.
|
* Stevens's book claims SCR$ and BSD4.3+ have TIOCREMOTE.
|
* Stevens's book claims SCR$ and BSD4.3+ have TIOCREMOTE.
|
*
|
*
|
* The latest readline may have some hooks we can use to avoid having
|
* The latest readline may have some hooks we can use to avoid having
|
* to back up the prompt. (See HAVE_ALREADY_PROMPTED.)
|
* to back up the prompt. (See HAVE_ALREADY_PROMPTED.)
|
*
|
*
|
* Desirable readline feature: When in cooked no-echo mode (e.g. password),
|
* Desirable readline feature: When in cooked no-echo mode (e.g. password),
|
* echo characters are they are types with '*', but remove them when done.
|
* echo characters are they are types with '*', but remove them when done.
|
*
|
*
|
* Asynchronous output while we're editing an input line should be
|
* Asynchronous output while we're editing an input line should be
|
* inserted in the output view *before* the input line, so that the
|
* 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.
|
* 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
|
* A "page mode" option to emulate more/less behavior: At each page of
|
* output, pause for a user command. This required parsing the output
|
* output, pause for a user command. This required parsing the output
|
* to keep track of line lengths. It also requires remembering the
|
* to keep track of line lengths. It also requires remembering the
|
* output, if we want an option to scroll back, which suggests that
|
* output, if we want an option to scroll back, which suggests that
|
* this should be integrated with a terminal emulator like xterm.
|
* this should be integrated with a terminal emulator like xterm.
|
*/
|
*/
|
|
|
#include <stdio.h>
|
#include <stdio.h>
|
#include <fcntl.h>
|
#include <fcntl.h>
|
#include <sys/types.h>
|
#include <sys/types.h>
|
#include <sys/socket.h>
|
#include <sys/socket.h>
|
#include <netinet/in.h>
|
#include <netinet/in.h>
|
#include <arpa/inet.h>
|
#include <arpa/inet.h>
|
#include <signal.h>
|
#include <signal.h>
|
#include <netdb.h>
|
#include <netdb.h>
|
#include <stdlib.h>
|
#include <stdlib.h>
|
#include <errno.h>
|
#include <errno.h>
|
#include <grp.h>
|
#include <grp.h>
|
#include <string.h>
|
#include <string.h>
|
#include <sys/stat.h>
|
#include <sys/stat.h>
|
#include <unistd.h>
|
#include <unistd.h>
|
#include <sys/ioctl.h>
|
#include <sys/ioctl.h>
|
#include <termios.h>
|
#include <termios.h>
|
|
|
#include "config.h"
|
#include "config.h"
|
|
|
#ifdef READLINE_LIBRARY
|
#ifdef READLINE_LIBRARY
|
# include "readline.h"
|
# include "readline.h"
|
# include "history.h"
|
# include "history.h"
|
#else
|
#else
|
# include <readline/readline.h>
|
# include <readline/readline.h>
|
# include <readline/history.h>
|
# include <readline/history.h>
|
#endif
|
#endif
|
|
|
#ifndef COMMAND
|
#ifndef COMMAND
|
#define COMMAND "/bin/bash"
|
#define COMMAND "/bin/bash"
|
#endif
|
#endif
|
#ifndef COMMAND_ARGS
|
#ifndef COMMAND_ARGS
|
#define COMMAND_ARGS COMMAND
|
#define COMMAND_ARGS COMMAND
|
#endif
|
#endif
|
|
|
#ifndef ALT_COMMAND
|
#ifndef ALT_COMMAND
|
#define ALT_COMMAND "/bin/sh"
|
#define ALT_COMMAND "/bin/sh"
|
#endif
|
#endif
|
#ifndef ALT_COMMAND_ARGS
|
#ifndef ALT_COMMAND_ARGS
|
#define ALT_COMMAND_ARGS ALT_COMMAND
|
#define ALT_COMMAND_ARGS ALT_COMMAND
|
#endif
|
#endif
|
|
|
#ifndef HAVE_MEMMOVE
|
#ifndef HAVE_MEMMOVE
|
# if __GNUC__ > 1
|
# if __GNUC__ > 1
|
# define memmove(d, s, n) __builtin_memcpy(d, s, n)
|
# define memmove(d, s, n) __builtin_memcpy(d, s, n)
|
# else
|
# else
|
# define memmove(d, s, n) memcpy(d, s, n)
|
# define memmove(d, s, n) memcpy(d, s, n)
|
# endif
|
# endif
|
#else
|
#else
|
# define memmove(d, s, n) memcpy(d, s, n)
|
# define memmove(d, s, n) memcpy(d, s, n)
|
#endif
|
#endif
|
|
|
#define APPLICATION_NAME "rlfe"
|
#define APPLICATION_NAME "rlfe"
|
|
|
static int in_from_inferior_fd;
|
static int in_from_inferior_fd;
|
static int out_to_inferior_fd;
|
static int out_to_inferior_fd;
|
static void set_edit_mode ();
|
static void set_edit_mode ();
|
static void usage_exit ();
|
static void usage_exit ();
|
static char *hist_file = 0;
|
static char *hist_file = 0;
|
static int hist_size = 0;
|
static int hist_size = 0;
|
|
|
/* Unfortunately, we cannot safely display echo from the inferior process.
|
/* 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,
|
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.
|
and if we try to turn it off, we could confuse the inferior.
|
Thus, when echoing, we get echo twice: First readline echoes while
|
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
|
we're actually editing. Then we send the line to the inferior, and the
|
terminal driver send back an extra echo.
|
terminal driver send back an extra echo.
|
The work-around is to remember the input lines, and when we see that
|
The work-around is to remember the input lines, and when we see that
|
line come back, we supress the output.
|
line come back, we supress the output.
|
A better solution (supposedly available on SVR4) would be a smarter
|
A better solution (supposedly available on SVR4) would be a smarter
|
terminal driver, with more flags ... */
|
terminal driver, with more flags ... */
|
#define ECHO_SUPPRESS_MAX 1024
|
#define ECHO_SUPPRESS_MAX 1024
|
char echo_suppress_buffer[ECHO_SUPPRESS_MAX];
|
char echo_suppress_buffer[ECHO_SUPPRESS_MAX];
|
int echo_suppress_start = 0;
|
int echo_suppress_start = 0;
|
int echo_suppress_limit = 0;
|
int echo_suppress_limit = 0;
|
|
|
/*#define DEBUG*/
|
/*#define DEBUG*/
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
FILE *logfile = NULL;
|
FILE *logfile = NULL;
|
#define DPRINT0(FMT) (fprintf(logfile, FMT), fflush(logfile))
|
#define DPRINT0(FMT) (fprintf(logfile, FMT), fflush(logfile))
|
#define DPRINT1(FMT, V1) (fprintf(logfile, FMT, V1), fflush(logfile))
|
#define DPRINT1(FMT, V1) (fprintf(logfile, FMT, V1), fflush(logfile))
|
#define DPRINT2(FMT, V1, V2) (fprintf(logfile, FMT, V1, V2), fflush(logfile))
|
#define DPRINT2(FMT, V1, V2) (fprintf(logfile, FMT, V1, V2), fflush(logfile))
|
#else
|
#else
|
#define DPRINT0(FMT) ((void) 0) /* Do nothing */
|
#define DPRINT0(FMT) ((void) 0) /* Do nothing */
|
#define DPRINT1(FMT, V1) ((void) 0) /* Do nothing */
|
#define DPRINT1(FMT, V1) ((void) 0) /* Do nothing */
|
#define DPRINT2(FMT, V1, V2) ((void) 0) /* Do nothing */
|
#define DPRINT2(FMT, V1, V2) ((void) 0) /* Do nothing */
|
#endif
|
#endif
|
|
|
struct termios orig_term;
|
struct termios orig_term;
|
|
|
/* Pid of child process. */
|
/* Pid of child process. */
|
static pid_t child = -1;
|
static pid_t child = -1;
|
|
|
static void
|
static void
|
sig_child (int signo)
|
sig_child (int signo)
|
{
|
{
|
int status;
|
int status;
|
wait (&status);
|
wait (&status);
|
if (hist_file != 0)
|
if (hist_file != 0)
|
{
|
{
|
write_history (hist_file);
|
write_history (hist_file);
|
if (hist_size)
|
if (hist_size)
|
history_truncate_file (hist_file, hist_size);
|
history_truncate_file (hist_file, hist_size);
|
}
|
}
|
DPRINT0 ("(Child process died.)\n");
|
DPRINT0 ("(Child process died.)\n");
|
tcsetattr(STDIN_FILENO, TCSANOW, &orig_term);
|
tcsetattr(STDIN_FILENO, TCSANOW, &orig_term);
|
exit (0);
|
exit (0);
|
}
|
}
|
|
|
volatile int propagate_sigwinch = 0;
|
volatile int propagate_sigwinch = 0;
|
|
|
/* sigwinch_handler
|
/* sigwinch_handler
|
* propagate window size changes from input file descriptor to
|
* propagate window size changes from input file descriptor to
|
* master side of pty.
|
* master side of pty.
|
*/
|
*/
|
void sigwinch_handler(int signal) {
|
void sigwinch_handler(int signal) {
|
propagate_sigwinch = 1;
|
propagate_sigwinch = 1;
|
}
|
}
|
|
|
|
|
/* get_slave_pty() returns an integer file descriptor.
|
/* get_slave_pty() returns an integer file descriptor.
|
* If it returns < 0, an error has occurred.
|
* If it returns < 0, an error has occurred.
|
* Otherwise, it has returned the slave file descriptor.
|
* Otherwise, it has returned the slave file descriptor.
|
*/
|
*/
|
|
|
int get_slave_pty(char *name) {
|
int get_slave_pty(char *name) {
|
struct group *gptr;
|
struct group *gptr;
|
gid_t gid;
|
gid_t gid;
|
int slave = -1;
|
int slave = -1;
|
|
|
/* chown/chmod the corresponding pty, if possible.
|
/* chown/chmod the corresponding pty, if possible.
|
* This will only work if the process has root permissions.
|
* This will only work if the process has root permissions.
|
* Alternatively, write and exec a small setuid program that
|
* Alternatively, write and exec a small setuid program that
|
* does just this.
|
* does just this.
|
*/
|
*/
|
if ((gptr = getgrnam("tty")) != 0) {
|
if ((gptr = getgrnam("tty")) != 0) {
|
gid = gptr->gr_gid;
|
gid = gptr->gr_gid;
|
} else {
|
} else {
|
/* if the tty group does not exist, don't change the
|
/* if the tty group does not exist, don't change the
|
* group on the slave pty, only the owner
|
* group on the slave pty, only the owner
|
*/
|
*/
|
gid = -1;
|
gid = -1;
|
}
|
}
|
|
|
/* Note that we do not check for errors here. If this is code
|
/* Note that we do not check for errors here. If this is code
|
* where these actions are critical, check for errors!
|
* where these actions are critical, check for errors!
|
*/
|
*/
|
chown(name, getuid(), gid);
|
chown(name, getuid(), gid);
|
/* This code only makes the slave read/writeable for the user.
|
/* This code only makes the slave read/writeable for the user.
|
* If this is for an interactive shell that will want to
|
* If this is for an interactive shell that will want to
|
* receive "write" and "wall" messages, OR S_IWGRP into the
|
* receive "write" and "wall" messages, OR S_IWGRP into the
|
* second argument below.
|
* second argument below.
|
*/
|
*/
|
chmod(name, S_IRUSR|S_IWUSR);
|
chmod(name, S_IRUSR|S_IWUSR);
|
|
|
/* open the corresponding slave pty */
|
/* open the corresponding slave pty */
|
slave = open(name, O_RDWR);
|
slave = open(name, O_RDWR);
|
return (slave);
|
return (slave);
|
}
|
}
|
|
|
/* Certain special characters, such as ctrl/C, we want to pass directly
|
/* Certain special characters, such as ctrl/C, we want to pass directly
|
to the inferior, rather than letting readline handle them. */
|
to the inferior, rather than letting readline handle them. */
|
|
|
static char special_chars[20];
|
static char special_chars[20];
|
static int special_chars_count;
|
static int special_chars_count;
|
|
|
static void
|
static void
|
add_special_char(int ch)
|
add_special_char(int ch)
|
{
|
{
|
if (ch != 0)
|
if (ch != 0)
|
special_chars[special_chars_count++] = ch;
|
special_chars[special_chars_count++] = ch;
|
}
|
}
|
|
|
static int eof_char;
|
static int eof_char;
|
|
|
static int
|
static int
|
is_special_char(int ch)
|
is_special_char(int ch)
|
{
|
{
|
int i;
|
int i;
|
#if 0
|
#if 0
|
if (ch == eof_char && rl_point == rl_end)
|
if (ch == eof_char && rl_point == rl_end)
|
return 1;
|
return 1;
|
#endif
|
#endif
|
for (i = special_chars_count; --i >= 0; )
|
for (i = special_chars_count; --i >= 0; )
|
if (special_chars[i] == ch)
|
if (special_chars[i] == ch)
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static char buf[1024];
|
static char buf[1024];
|
/* buf[0 .. buf_count-1] is the what has been emitted on the current line.
|
/* buf[0 .. buf_count-1] is the what has been emitted on the current line.
|
It is used as the readline prompt. */
|
It is used as the readline prompt. */
|
static int buf_count = 0;
|
static int buf_count = 0;
|
|
|
int do_emphasize_input = 1;
|
int do_emphasize_input = 1;
|
int current_emphasize_input;
|
int current_emphasize_input;
|
|
|
char *start_input_mode = "\033[1m";
|
char *start_input_mode = "\033[1m";
|
char *end_input_mode = "\033[0m";
|
char *end_input_mode = "\033[0m";
|
|
|
int num_keys = 0;
|
int num_keys = 0;
|
|
|
static void maybe_emphasize_input (int on)
|
static void maybe_emphasize_input (int on)
|
{
|
{
|
if (on == current_emphasize_input
|
if (on == current_emphasize_input
|
|| (on && ! do_emphasize_input))
|
|| (on && ! do_emphasize_input))
|
return;
|
return;
|
fprintf (rl_outstream, on ? start_input_mode : end_input_mode);
|
fprintf (rl_outstream, on ? start_input_mode : end_input_mode);
|
fflush (rl_outstream);
|
fflush (rl_outstream);
|
current_emphasize_input = on;
|
current_emphasize_input = on;
|
}
|
}
|
|
|
static void
|
static void
|
null_prep_terminal (int meta)
|
null_prep_terminal (int meta)
|
{
|
{
|
}
|
}
|
|
|
static void
|
static void
|
null_deprep_terminal ()
|
null_deprep_terminal ()
|
{
|
{
|
maybe_emphasize_input (0);
|
maybe_emphasize_input (0);
|
}
|
}
|
|
|
static int
|
static int
|
pre_input_change_mode (void)
|
pre_input_change_mode (void)
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
|
|
char pending_special_char;
|
char pending_special_char;
|
|
|
static void
|
static void
|
line_handler (char *line)
|
line_handler (char *line)
|
{
|
{
|
if (line == NULL)
|
if (line == NULL)
|
{
|
{
|
char buf[1];
|
char buf[1];
|
DPRINT0("saw eof!\n");
|
DPRINT0("saw eof!\n");
|
buf[0] = '\004'; /* ctrl/d */
|
buf[0] = '\004'; /* ctrl/d */
|
write (out_to_inferior_fd, buf, 1);
|
write (out_to_inferior_fd, buf, 1);
|
}
|
}
|
else
|
else
|
{
|
{
|
static char enter[] = "\r";
|
static char enter[] = "\r";
|
/* Send line to inferior: */
|
/* Send line to inferior: */
|
int length = strlen (line);
|
int length = strlen (line);
|
if (length > ECHO_SUPPRESS_MAX-2)
|
if (length > ECHO_SUPPRESS_MAX-2)
|
{
|
{
|
echo_suppress_start = 0;
|
echo_suppress_start = 0;
|
echo_suppress_limit = 0;
|
echo_suppress_limit = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (echo_suppress_limit + length > ECHO_SUPPRESS_MAX - 2)
|
if (echo_suppress_limit + length > ECHO_SUPPRESS_MAX - 2)
|
{
|
{
|
if (echo_suppress_limit - echo_suppress_start + length
|
if (echo_suppress_limit - echo_suppress_start + length
|
<= ECHO_SUPPRESS_MAX - 2)
|
<= ECHO_SUPPRESS_MAX - 2)
|
{
|
{
|
memmove (echo_suppress_buffer,
|
memmove (echo_suppress_buffer,
|
echo_suppress_buffer + echo_suppress_start,
|
echo_suppress_buffer + echo_suppress_start,
|
echo_suppress_limit - echo_suppress_start);
|
echo_suppress_limit - echo_suppress_start);
|
echo_suppress_limit -= echo_suppress_start;
|
echo_suppress_limit -= echo_suppress_start;
|
echo_suppress_start = 0;
|
echo_suppress_start = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
echo_suppress_limit = 0;
|
echo_suppress_limit = 0;
|
}
|
}
|
echo_suppress_start = 0;
|
echo_suppress_start = 0;
|
}
|
}
|
memcpy (echo_suppress_buffer + echo_suppress_limit,
|
memcpy (echo_suppress_buffer + echo_suppress_limit,
|
line, length);
|
line, length);
|
echo_suppress_limit += length;
|
echo_suppress_limit += length;
|
echo_suppress_buffer[echo_suppress_limit++] = '\r';
|
echo_suppress_buffer[echo_suppress_limit++] = '\r';
|
echo_suppress_buffer[echo_suppress_limit++] = '\n';
|
echo_suppress_buffer[echo_suppress_limit++] = '\n';
|
}
|
}
|
write (out_to_inferior_fd, line, length);
|
write (out_to_inferior_fd, line, length);
|
if (pending_special_char == 0)
|
if (pending_special_char == 0)
|
{
|
{
|
write (out_to_inferior_fd, enter, sizeof(enter)-1);
|
write (out_to_inferior_fd, enter, sizeof(enter)-1);
|
if (*line)
|
if (*line)
|
add_history (line);
|
add_history (line);
|
}
|
}
|
free (line);
|
free (line);
|
}
|
}
|
rl_callback_handler_remove ();
|
rl_callback_handler_remove ();
|
buf_count = 0;
|
buf_count = 0;
|
num_keys = 0;
|
num_keys = 0;
|
if (pending_special_char != 0)
|
if (pending_special_char != 0)
|
{
|
{
|
write (out_to_inferior_fd, &pending_special_char, 1);
|
write (out_to_inferior_fd, &pending_special_char, 1);
|
pending_special_char = 0;
|
pending_special_char = 0;
|
}
|
}
|
}
|
}
|
|
|
/* Value of rl_getc_function.
|
/* Value of rl_getc_function.
|
Use this because readline should read from stdin, not rl_instream,
|
Use this because readline should read from stdin, not rl_instream,
|
points to the pty (so readline has monitor its terminal modes). */
|
points to the pty (so readline has monitor its terminal modes). */
|
|
|
int
|
int
|
my_rl_getc (FILE *dummy)
|
my_rl_getc (FILE *dummy)
|
{
|
{
|
int ch = rl_getc (stdin);
|
int ch = rl_getc (stdin);
|
if (is_special_char (ch))
|
if (is_special_char (ch))
|
{
|
{
|
pending_special_char = ch;
|
pending_special_char = ch;
|
return '\r';
|
return '\r';
|
}
|
}
|
return ch;
|
return ch;
|
}
|
}
|
|
|
int
|
int
|
main(int argc, char** argv)
|
main(int argc, char** argv)
|
{
|
{
|
char *path;
|
char *path;
|
int i;
|
int i;
|
int master;
|
int master;
|
char *name;
|
char *name;
|
int in_from_tty_fd;
|
int in_from_tty_fd;
|
struct sigaction act;
|
struct sigaction act;
|
struct winsize ws;
|
struct winsize ws;
|
struct termios t;
|
struct termios t;
|
int maxfd;
|
int maxfd;
|
fd_set in_set;
|
fd_set in_set;
|
static char empty_string[1] = "";
|
static char empty_string[1] = "";
|
char *prompt = empty_string;
|
char *prompt = empty_string;
|
int ioctl_err = 0;
|
int ioctl_err = 0;
|
int arg_base = 1;
|
int arg_base = 1;
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
logfile = fopen("/tmp/rlfe.log", "w");
|
logfile = fopen("/tmp/rlfe.log", "w");
|
#endif
|
#endif
|
|
|
while (arg_base<argc)
|
while (arg_base<argc)
|
{
|
{
|
if (argv[arg_base][0] != '-')
|
if (argv[arg_base][0] != '-')
|
break;
|
break;
|
if (arg_base+1 >= argc )
|
if (arg_base+1 >= argc )
|
usage_exit();
|
usage_exit();
|
switch(argv[arg_base][1])
|
switch(argv[arg_base][1])
|
{
|
{
|
case 'h':
|
case 'h':
|
arg_base++;
|
arg_base++;
|
hist_file = argv[arg_base];
|
hist_file = argv[arg_base];
|
break;
|
break;
|
case 's':
|
case 's':
|
arg_base++;
|
arg_base++;
|
hist_size = atoi(argv[arg_base]);
|
hist_size = atoi(argv[arg_base]);
|
if (hist_size<0)
|
if (hist_size<0)
|
usage_exit();
|
usage_exit();
|
break;
|
break;
|
default:
|
default:
|
usage_exit();
|
usage_exit();
|
}
|
}
|
arg_base++;
|
arg_base++;
|
}
|
}
|
if (hist_file)
|
if (hist_file)
|
read_history (hist_file);
|
read_history (hist_file);
|
|
|
set_edit_mode ();
|
set_edit_mode ();
|
|
|
rl_readline_name = APPLICATION_NAME;
|
rl_readline_name = APPLICATION_NAME;
|
|
|
if ((master = OpenPTY (&name)) < 0)
|
if ((master = OpenPTY (&name)) < 0)
|
{
|
{
|
perror("ptypair: could not open master pty");
|
perror("ptypair: could not open master pty");
|
exit(1);
|
exit(1);
|
}
|
}
|
|
|
DPRINT1("pty name: '%s'\n", name);
|
DPRINT1("pty name: '%s'\n", name);
|
|
|
/* set up SIGWINCH handler */
|
/* set up SIGWINCH handler */
|
act.sa_handler = sigwinch_handler;
|
act.sa_handler = sigwinch_handler;
|
sigemptyset(&(act.sa_mask));
|
sigemptyset(&(act.sa_mask));
|
act.sa_flags = 0;
|
act.sa_flags = 0;
|
if (sigaction(SIGWINCH, &act, NULL) < 0)
|
if (sigaction(SIGWINCH, &act, NULL) < 0)
|
{
|
{
|
perror("ptypair: could not handle SIGWINCH ");
|
perror("ptypair: could not handle SIGWINCH ");
|
exit(1);
|
exit(1);
|
}
|
}
|
|
|
if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) < 0)
|
if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) < 0)
|
{
|
{
|
perror("ptypair: could not get window size");
|
perror("ptypair: could not get window size");
|
exit(1);
|
exit(1);
|
}
|
}
|
|
|
if ((child = fork()) < 0)
|
if ((child = fork()) < 0)
|
{
|
{
|
perror("cannot fork");
|
perror("cannot fork");
|
exit(1);
|
exit(1);
|
}
|
}
|
|
|
if (child == 0)
|
if (child == 0)
|
{
|
{
|
int slave; /* file descriptor for slave pty */
|
int slave; /* file descriptor for slave pty */
|
|
|
/* We are in the child process */
|
/* We are in the child process */
|
close(master);
|
close(master);
|
|
|
#ifdef TIOCSCTTY
|
#ifdef TIOCSCTTY
|
if ((slave = get_slave_pty(name)) < 0)
|
if ((slave = get_slave_pty(name)) < 0)
|
{
|
{
|
perror("ptypair: could not open slave pty");
|
perror("ptypair: could not open slave pty");
|
exit(1);
|
exit(1);
|
}
|
}
|
#endif
|
#endif
|
|
|
/* We need to make this process a session group leader, because
|
/* We need to make this process a session group leader, because
|
* it is on a new PTY, and things like job control simply will
|
* it is on a new PTY, and things like job control simply will
|
* not work correctly unless there is a session group leader
|
* not work correctly unless there is a session group leader
|
* and process group leader (which a session group leader
|
* and process group leader (which a session group leader
|
* automatically is). This also disassociates us from our old
|
* automatically is). This also disassociates us from our old
|
* controlling tty.
|
* controlling tty.
|
*/
|
*/
|
if (setsid() < 0)
|
if (setsid() < 0)
|
{
|
{
|
perror("could not set session leader");
|
perror("could not set session leader");
|
}
|
}
|
|
|
/* Tie us to our new controlling tty. */
|
/* Tie us to our new controlling tty. */
|
#ifdef TIOCSCTTY
|
#ifdef TIOCSCTTY
|
if (ioctl(slave, TIOCSCTTY, NULL))
|
if (ioctl(slave, TIOCSCTTY, NULL))
|
{
|
{
|
perror("could not set new controlling tty");
|
perror("could not set new controlling tty");
|
}
|
}
|
#else
|
#else
|
if ((slave = get_slave_pty(name)) < 0)
|
if ((slave = get_slave_pty(name)) < 0)
|
{
|
{
|
perror("ptypair: could not open slave pty");
|
perror("ptypair: could not open slave pty");
|
exit(1);
|
exit(1);
|
}
|
}
|
#endif
|
#endif
|
|
|
/* make slave pty be standard in, out, and error */
|
/* make slave pty be standard in, out, and error */
|
dup2(slave, STDIN_FILENO);
|
dup2(slave, STDIN_FILENO);
|
dup2(slave, STDOUT_FILENO);
|
dup2(slave, STDOUT_FILENO);
|
dup2(slave, STDERR_FILENO);
|
dup2(slave, STDERR_FILENO);
|
|
|
/* at this point the slave pty should be standard input */
|
/* at this point the slave pty should be standard input */
|
if (slave > 2)
|
if (slave > 2)
|
{
|
{
|
close(slave);
|
close(slave);
|
}
|
}
|
|
|
/* Try to restore window size; failure isn't critical */
|
/* Try to restore window size; failure isn't critical */
|
if (ioctl(STDOUT_FILENO, TIOCSWINSZ, &ws) < 0)
|
if (ioctl(STDOUT_FILENO, TIOCSWINSZ, &ws) < 0)
|
{
|
{
|
perror("could not restore window size");
|
perror("could not restore window size");
|
}
|
}
|
|
|
/* now start the shell */
|
/* now start the shell */
|
{
|
{
|
static char* command_args[] = { COMMAND_ARGS, NULL };
|
static char* command_args[] = { COMMAND_ARGS, NULL };
|
static char* alt_command_args[] = { ALT_COMMAND_ARGS, NULL };
|
static char* alt_command_args[] = { ALT_COMMAND_ARGS, NULL };
|
if (argc <= 1)
|
if (argc <= 1)
|
{
|
{
|
execvp (COMMAND, command_args);
|
execvp (COMMAND, command_args);
|
execvp (ALT_COMMAND, alt_command_args);
|
execvp (ALT_COMMAND, alt_command_args);
|
}
|
}
|
else
|
else
|
execvp (argv[arg_base], &argv[arg_base]);
|
execvp (argv[arg_base], &argv[arg_base]);
|
}
|
}
|
|
|
/* should never be reached */
|
/* should never be reached */
|
exit(1);
|
exit(1);
|
}
|
}
|
|
|
/* parent */
|
/* parent */
|
signal (SIGCHLD, sig_child);
|
signal (SIGCHLD, sig_child);
|
|
|
/* Note that we only set termios settings for standard input;
|
/* Note that we only set termios settings for standard input;
|
* the master side of a pty is NOT a tty.
|
* the master side of a pty is NOT a tty.
|
*/
|
*/
|
tcgetattr(STDIN_FILENO, &orig_term);
|
tcgetattr(STDIN_FILENO, &orig_term);
|
|
|
t = orig_term;
|
t = orig_term;
|
eof_char = t.c_cc[VEOF];
|
eof_char = t.c_cc[VEOF];
|
/* add_special_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[VINTR]);
|
add_special_char(t.c_cc[VQUIT]);
|
add_special_char(t.c_cc[VQUIT]);
|
add_special_char(t.c_cc[VSUSP]);
|
add_special_char(t.c_cc[VSUSP]);
|
#if defined (VDISCARD)
|
#if defined (VDISCARD)
|
add_special_char(t.c_cc[VDISCARD]);
|
add_special_char(t.c_cc[VDISCARD]);
|
#endif
|
#endif
|
|
|
t.c_lflag &= ~(ICANON | ISIG | ECHO | ECHOCTL | ECHOE | \
|
t.c_lflag &= ~(ICANON | ISIG | ECHO | ECHOCTL | ECHOE | \
|
ECHOK | ECHOKE | ECHONL | ECHOPRT );
|
ECHOK | ECHOKE | ECHONL | ECHOPRT );
|
t.c_iflag &= ~ICRNL;
|
t.c_iflag &= ~ICRNL;
|
t.c_iflag |= IGNBRK;
|
t.c_iflag |= IGNBRK;
|
t.c_cc[VMIN] = 1;
|
t.c_cc[VMIN] = 1;
|
t.c_cc[VTIME] = 0;
|
t.c_cc[VTIME] = 0;
|
tcsetattr(STDIN_FILENO, TCSANOW, &t);
|
tcsetattr(STDIN_FILENO, TCSANOW, &t);
|
in_from_inferior_fd = master;
|
in_from_inferior_fd = master;
|
out_to_inferior_fd = master;
|
out_to_inferior_fd = master;
|
rl_instream = fdopen (master, "r");
|
rl_instream = fdopen (master, "r");
|
rl_getc_function = my_rl_getc;
|
rl_getc_function = my_rl_getc;
|
|
|
rl_prep_term_function = null_prep_terminal;
|
rl_prep_term_function = null_prep_terminal;
|
rl_deprep_term_function = null_deprep_terminal;
|
rl_deprep_term_function = null_deprep_terminal;
|
rl_pre_input_hook = pre_input_change_mode;
|
rl_pre_input_hook = pre_input_change_mode;
|
rl_callback_handler_install (prompt, line_handler);
|
rl_callback_handler_install (prompt, line_handler);
|
|
|
in_from_tty_fd = STDIN_FILENO;
|
in_from_tty_fd = STDIN_FILENO;
|
FD_ZERO (&in_set);
|
FD_ZERO (&in_set);
|
maxfd = in_from_inferior_fd > in_from_tty_fd ? in_from_inferior_fd
|
maxfd = in_from_inferior_fd > in_from_tty_fd ? in_from_inferior_fd
|
: in_from_tty_fd;
|
: in_from_tty_fd;
|
for (;;)
|
for (;;)
|
{
|
{
|
int num;
|
int num;
|
FD_SET (in_from_inferior_fd, &in_set);
|
FD_SET (in_from_inferior_fd, &in_set);
|
FD_SET (in_from_tty_fd, &in_set);
|
FD_SET (in_from_tty_fd, &in_set);
|
|
|
num = select(maxfd+1, &in_set, NULL, NULL, NULL);
|
num = select(maxfd+1, &in_set, NULL, NULL, NULL);
|
|
|
if (propagate_sigwinch)
|
if (propagate_sigwinch)
|
{
|
{
|
struct winsize ws;
|
struct winsize ws;
|
if (ioctl (STDIN_FILENO, TIOCGWINSZ, &ws) >= 0)
|
if (ioctl (STDIN_FILENO, TIOCGWINSZ, &ws) >= 0)
|
{
|
{
|
ioctl (master, TIOCSWINSZ, &ws);
|
ioctl (master, TIOCSWINSZ, &ws);
|
}
|
}
|
propagate_sigwinch = 0;
|
propagate_sigwinch = 0;
|
continue;
|
continue;
|
}
|
}
|
|
|
if (num <= 0)
|
if (num <= 0)
|
{
|
{
|
perror ("select");
|
perror ("select");
|
exit (-1);
|
exit (-1);
|
}
|
}
|
if (FD_ISSET (in_from_tty_fd, &in_set))
|
if (FD_ISSET (in_from_tty_fd, &in_set))
|
{
|
{
|
extern int readline_echoing_p;
|
extern int readline_echoing_p;
|
struct termios term_master;
|
struct termios term_master;
|
int do_canon = 1;
|
int do_canon = 1;
|
int do_icrnl = 1;
|
int do_icrnl = 1;
|
int ioctl_ret;
|
int ioctl_ret;
|
|
|
DPRINT1("[tty avail num_keys:%d]\n", num_keys);
|
DPRINT1("[tty avail num_keys:%d]\n", num_keys);
|
|
|
/* If we can't get tty modes for the master side of the pty, we
|
/* 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
|
can't handle non-canonical-mode programs. Always assume the
|
master is in canonical echo mode if we can't tell. */
|
master is in canonical echo mode if we can't tell. */
|
ioctl_ret = tcgetattr(master, &term_master);
|
ioctl_ret = tcgetattr(master, &term_master);
|
|
|
if (ioctl_ret >= 0)
|
if (ioctl_ret >= 0)
|
{
|
{
|
do_canon = (term_master.c_lflag & ICANON) != 0;
|
do_canon = (term_master.c_lflag & ICANON) != 0;
|
do_icrnl = (term_master.c_lflag & ICRNL) != 0;
|
do_icrnl = (term_master.c_lflag & ICRNL) != 0;
|
readline_echoing_p = (term_master.c_lflag & ECHO) != 0;
|
readline_echoing_p = (term_master.c_lflag & ECHO) != 0;
|
DPRINT1 ("echo,canon,crnl:%03d\n",
|
DPRINT1 ("echo,canon,crnl:%03d\n",
|
100 * readline_echoing_p
|
100 * readline_echoing_p
|
+ 10 * do_canon
|
+ 10 * do_canon
|
+ 1 * do_icrnl);
|
+ 1 * do_icrnl);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (ioctl_err == 0)
|
if (ioctl_err == 0)
|
DPRINT1("tcgetattr on master fd failed: errno = %d\n", errno);
|
DPRINT1("tcgetattr on master fd failed: errno = %d\n", errno);
|
ioctl_err = 1;
|
ioctl_err = 1;
|
}
|
}
|
|
|
if (do_canon == 0 && num_keys == 0)
|
if (do_canon == 0 && num_keys == 0)
|
{
|
{
|
char ch[10];
|
char ch[10];
|
int count = read (STDIN_FILENO, ch, sizeof(ch));
|
int count = read (STDIN_FILENO, ch, sizeof(ch));
|
DPRINT1("[read %d chars from stdin: ", count);
|
DPRINT1("[read %d chars from stdin: ", count);
|
DPRINT2(" \"%.*s\"]\n", count, ch);
|
DPRINT2(" \"%.*s\"]\n", count, ch);
|
if (do_icrnl)
|
if (do_icrnl)
|
{
|
{
|
int i = count;
|
int i = count;
|
while (--i >= 0)
|
while (--i >= 0)
|
{
|
{
|
if (ch[i] == '\r')
|
if (ch[i] == '\r')
|
ch[i] = '\n';
|
ch[i] = '\n';
|
}
|
}
|
}
|
}
|
maybe_emphasize_input (1);
|
maybe_emphasize_input (1);
|
write (out_to_inferior_fd, ch, count);
|
write (out_to_inferior_fd, ch, count);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (num_keys == 0)
|
if (num_keys == 0)
|
{
|
{
|
int i;
|
int i;
|
/* Re-install callback handler for new prompt. */
|
/* Re-install callback handler for new prompt. */
|
if (prompt != empty_string)
|
if (prompt != empty_string)
|
free (prompt);
|
free (prompt);
|
if (prompt == NULL)
|
if (prompt == NULL)
|
{
|
{
|
DPRINT0("New empty prompt\n");
|
DPRINT0("New empty prompt\n");
|
prompt = empty_string;
|
prompt = empty_string;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (do_emphasize_input && buf_count > 0)
|
if (do_emphasize_input && buf_count > 0)
|
{
|
{
|
prompt = malloc (buf_count + strlen (end_input_mode)
|
prompt = malloc (buf_count + strlen (end_input_mode)
|
+ strlen (start_input_mode) + 5);
|
+ strlen (start_input_mode) + 5);
|
sprintf (prompt, "\001%s\002%.*s\001%s\002",
|
sprintf (prompt, "\001%s\002%.*s\001%s\002",
|
end_input_mode,
|
end_input_mode,
|
buf_count, buf,
|
buf_count, buf,
|
start_input_mode);
|
start_input_mode);
|
}
|
}
|
else
|
else
|
{
|
{
|
prompt = malloc (buf_count + 1);
|
prompt = malloc (buf_count + 1);
|
memcpy (prompt, buf, buf_count);
|
memcpy (prompt, buf, buf_count);
|
prompt[buf_count] = '\0';
|
prompt[buf_count] = '\0';
|
}
|
}
|
DPRINT1("New prompt '%s'\n", prompt);
|
DPRINT1("New prompt '%s'\n", prompt);
|
#if 0 /* ifdef HAVE_RL_ALREADY_PROMPTED */
|
#if 0 /* ifdef HAVE_RL_ALREADY_PROMPTED */
|
/* Doesn't quite work when do_emphasize_input is 1. */
|
/* Doesn't quite work when do_emphasize_input is 1. */
|
rl_already_prompted = buf_count > 0;
|
rl_already_prompted = buf_count > 0;
|
#else
|
#else
|
if (buf_count > 0)
|
if (buf_count > 0)
|
write (1, "\r", 1);
|
write (1, "\r", 1);
|
#endif
|
#endif
|
}
|
}
|
|
|
rl_callback_handler_install (prompt, line_handler);
|
rl_callback_handler_install (prompt, line_handler);
|
}
|
}
|
num_keys++;
|
num_keys++;
|
maybe_emphasize_input (1);
|
maybe_emphasize_input (1);
|
rl_callback_read_char ();
|
rl_callback_read_char ();
|
}
|
}
|
}
|
}
|
else /* output from inferior. */
|
else /* output from inferior. */
|
{
|
{
|
int i;
|
int i;
|
int count;
|
int count;
|
int old_count;
|
int old_count;
|
if (buf_count > (sizeof(buf) >> 2))
|
if (buf_count > (sizeof(buf) >> 2))
|
buf_count = 0;
|
buf_count = 0;
|
count = read (in_from_inferior_fd, buf+buf_count,
|
count = read (in_from_inferior_fd, buf+buf_count,
|
sizeof(buf) - buf_count);
|
sizeof(buf) - buf_count);
|
DPRINT2("read %d from inferior, buf_count=%d", count, buf_count);
|
DPRINT2("read %d from inferior, buf_count=%d", count, buf_count);
|
DPRINT2(": \"%.*s\"", count, buf+buf_count);
|
DPRINT2(": \"%.*s\"", count, buf+buf_count);
|
maybe_emphasize_input (0);
|
maybe_emphasize_input (0);
|
if (count <= 0)
|
if (count <= 0)
|
{
|
{
|
DPRINT0 ("(Connection closed by foreign host.)\n");
|
DPRINT0 ("(Connection closed by foreign host.)\n");
|
tcsetattr(STDIN_FILENO, TCSANOW, &orig_term);
|
tcsetattr(STDIN_FILENO, TCSANOW, &orig_term);
|
exit (0);
|
exit (0);
|
}
|
}
|
old_count = buf_count;
|
old_count = buf_count;
|
|
|
/* Look for any pending echo that we need to suppress. */
|
/* Look for any pending echo that we need to suppress. */
|
while (echo_suppress_start < echo_suppress_limit
|
while (echo_suppress_start < echo_suppress_limit
|
&& count > 0
|
&& count > 0
|
&& buf[buf_count] == echo_suppress_buffer[echo_suppress_start])
|
&& buf[buf_count] == echo_suppress_buffer[echo_suppress_start])
|
{
|
{
|
count--;
|
count--;
|
buf_count++;
|
buf_count++;
|
echo_suppress_start++;
|
echo_suppress_start++;
|
}
|
}
|
DPRINT1("suppressed %d characters of echo.\n", buf_count-old_count);
|
DPRINT1("suppressed %d characters of echo.\n", buf_count-old_count);
|
|
|
/* Write to the terminal anything that was not suppressed. */
|
/* Write to the terminal anything that was not suppressed. */
|
if (count > 0)
|
if (count > 0)
|
write (1, buf + buf_count, count);
|
write (1, buf + buf_count, count);
|
|
|
/* Finally, look for a prompt candidate.
|
/* Finally, look for a prompt candidate.
|
* When we get around to going input (from the keyboard),
|
* When we get around to going input (from the keyboard),
|
* we will consider the prompt to be anything since the last
|
* we will consider the prompt to be anything since the last
|
* line terminator. So we need to save that text in the
|
* line terminator. So we need to save that text in the
|
* initial part of buf. However, anything before the
|
* initial part of buf. However, anything before the
|
* most recent end-of-line is not interesting. */
|
* most recent end-of-line is not interesting. */
|
buf_count += count;
|
buf_count += count;
|
#if 1
|
#if 1
|
for (i = buf_count; --i >= old_count; )
|
for (i = buf_count; --i >= old_count; )
|
#else
|
#else
|
for (i = buf_count - 1; i-- >= buf_count - count; )
|
for (i = buf_count - 1; i-- >= buf_count - count; )
|
#endif
|
#endif
|
{
|
{
|
if (buf[i] == '\n' || buf[i] == '\r')
|
if (buf[i] == '\n' || buf[i] == '\r')
|
{
|
{
|
i++;
|
i++;
|
memmove (buf, buf+i, buf_count - i);
|
memmove (buf, buf+i, buf_count - i);
|
buf_count -= i;
|
buf_count -= i;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
DPRINT2("-> i: %d, buf_count: %d\n", i, buf_count);
|
DPRINT2("-> i: %d, buf_count: %d\n", i, buf_count);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
static void set_edit_mode ()
|
static void set_edit_mode ()
|
{
|
{
|
int vi = 0;
|
int vi = 0;
|
char *shellopts;
|
char *shellopts;
|
|
|
shellopts = getenv ("SHELLOPTS");
|
shellopts = getenv ("SHELLOPTS");
|
while (shellopts != 0)
|
while (shellopts != 0)
|
{
|
{
|
if (strncmp ("vi", shellopts, 2) == 0)
|
if (strncmp ("vi", shellopts, 2) == 0)
|
{
|
{
|
vi = 1;
|
vi = 1;
|
break;
|
break;
|
}
|
}
|
shellopts = index (shellopts + 1, ':');
|
shellopts = index (shellopts + 1, ':');
|
}
|
}
|
|
|
if (!vi)
|
if (!vi)
|
{
|
{
|
if (getenv ("EDITOR") != 0)
|
if (getenv ("EDITOR") != 0)
|
vi |= strcmp (getenv ("EDITOR"), "vi") == 0;
|
vi |= strcmp (getenv ("EDITOR"), "vi") == 0;
|
}
|
}
|
|
|
if (vi)
|
if (vi)
|
rl_variable_bind ("editing-mode", "vi");
|
rl_variable_bind ("editing-mode", "vi");
|
else
|
else
|
rl_variable_bind ("editing-mode", "emacs");
|
rl_variable_bind ("editing-mode", "emacs");
|
}
|
}
|
|
|
|
|
static void usage_exit ()
|
static void usage_exit ()
|
{
|
{
|
fprintf (stderr, "Usage: rlfe [-h histfile] [-s size] cmd [arg1] [arg2] ...\n\n");
|
fprintf (stderr, "Usage: rlfe [-h histfile] [-s size] cmd [arg1] [arg2] ...\n\n");
|
exit (1);
|
exit (1);
|
}
|
}
|
|
|
