| /* 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 errno |
| extern int errno; |
| #endif |
| |
| extern 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 1024 |
| char echo_suppress_buffer[ECHO_SUPPRESS_MAX]; |
| int echo_suppress_start = 0; |
| int echo_suppress_limit = 0; |
| |
| /* #define DEBUG */ |
| |
| static FILE *logfile = NULL; |
| |
| #ifdef DEBUG |
| FILE *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 */ |
| #endif |
| |
| struct 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 void |
| sig_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 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 num_keys = 0; |
| |
| static void |
| null_prep_terminal (int meta) |
| { |
| } |
| |
| static void |
| null_deprep_terminal () |
| { |
| } |
| |
| 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; |
| } |
| |
| static void |
| usage() |
| { |
| fprintf (stderr, "%s: usage: %s [-l filename] [-a] [-n appname] [-hv] [command [arguments...]]\n", |
| progname, progname); |
| } |
| |
| int |
| main(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) |
| { |
| 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); |
| } |
| free(name); |
| #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 }; |
| if (argc < 1) |
| execvp(COMMAND, command_args); |
| else |
| execvp(argv[0], &argv[0]); |
| } |
| |
| /* should never be reached */ |
| exit(1); |
| } |
| |
| /* parent */ |
| signal (SIGCHLD, sig_child); |
| free(name); |
| |
| /* 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 |
| |
| #if 0 |
| t.c_lflag |= (ICANON | ISIG | ECHO | ECHOCTL | ECHOE | \ |
| ECHOK | ECHOKE | ECHONL | ECHOPRT ); |
| #else |
| t.c_lflag &= ~(ICANON | ISIG | ECHO | ECHOCTL | ECHOE | \ |
| ECHOK | ECHOKE | ECHONL | ECHOPRT ); |
| #endif |
| 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_callback_handler_install (prompt, line_handler); |
| |
| #if 1 |
| rl_directory_completion_hook = rlfe_directory_completion_hook; |
| rl_completion_entry_function = rlfe_filename_completion_function; |
| #else |
| rl_directory_rewrite_hook = rlfe_directory_rewrite_hook; |
| #endif |
| |
| 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 readline_echoing_p; |
| struct termios term_master; |
| int do_canon = 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) |
| { |
| DPRINT2 ("echo:%d, canon:%d\n", |
| (term_master.c_lflag & ECHO) != 0, |
| (term_master.c_lflag & ICANON) != 0); |
| do_canon = (term_master.c_lflag & ICANON) != 0; |
| readline_echoing_p = (term_master.c_lflag & ECHO) != 0; |
| } |
| 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)); |
| 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); |
| prompt = malloc (buf_count + 1); |
| if (prompt == NULL) |
| prompt = empty_string; |
| else |
| { |
| memcpy (prompt, buf, buf_count); |
| prompt[buf_count] = '\0'; |
| DPRINT1("New prompt '%s'\n", prompt); |
| #if 0 /* ifdef HAVE_RL_ALREADY_PROMPTED -- doesn't work */ |
| 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++; |
| rl_callback_read_char (); |
| } |
| } |
| else /* input 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); |
| if (count <= 0) |
| { |
| DPRINT0 ("(Connection closed by foreign host.)\n"); |
| tcsetattr(STDIN_FILENO, TCSANOW, &orig_term); |
| exit (0); |
| } |
| old_count = buf_count; |
| |
| /* Do some minimal carriage return translation and backspace |
| processing before logging the input line. */ |
| if (logfile) |
| { |
| #ifndef __GNUC__ |
| char *b; |
| #else |
| char b[count + 1]; |
| #endif |
| int i, j; |
| |
| #ifndef __GNUC__ |
| b = malloc (count + 1); |
| if (b) { |
| #endif |
| for (i = 0; i < count; i++) |
| b[i] = buf[buf_count + i]; |
| b[i] = '\0'; |
| for (i = j = 0; i <= count; i++) |
| { |
| if (b[i] == '\r') |
| { |
| if (b[i+1] != '\n') |
| b[j++] = '\n'; |
| } |
| else if (b[i] == '\b') |
| { |
| if (i) |
| j--; |
| } |
| else |
| b[j++] = b[i]; |
| } |
| fprintf (logfile, "%s", b); |
| |
| #ifndef __GNUC__ |
| free (b); |
| } |
| #endif |
| } |
| |
| /* 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++; |
| } |
| |
| /* 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); |
| } |
| } |
| } |
| |
| /* |
| * |
| * FILENAME COMPLETION FOR RLFE |
| * |
| */ |
| |
| #ifndef PATH_MAX |
| # define PATH_MAX 1024 |
| #endif |
| |
| #define DIRSEP '/' |
| #define ISDIRSEP(x) ((x) == '/') |
| #define PATHSEP(x) (ISDIRSEP(x) || (x) == 0) |
| |
| #define DOT_OR_DOTDOT(x) \ |
| ((x)[0] == '.' && (PATHSEP((x)[1]) || \ |
| ((x)[1] == '.' && PATHSEP((x)[2])))) |
| |
| #define FREE(x) if (x) free(x) |
| |
| #define STRDUP(s, x) do { \ |
| s = strdup (x);\ |
| if (s == 0) \ |
| return ((char *)NULL); \ |
| } while (0) |
| |
| static int |
| get_inferior_cwd (path, psize) |
| char *path; |
| size_t psize; |
| { |
| int n; |
| static char procfsbuf[PATH_MAX] = { '\0' }; |
| |
| if (procfsbuf[0] == '\0') |
| sprintf (procfsbuf, "/proc/%d/cwd", (int)child); |
| n = readlink (procfsbuf, path, psize); |
| if (n < 0) |
| return n; |
| if (n > psize) |
| return -1; |
| path[n] = '\0'; |
| return n; |
| } |
| |
| static int |
| rlfe_directory_rewrite_hook (dirnamep) |
| char **dirnamep; |
| { |
| char *ldirname, cwd[PATH_MAX], *retdir, *ld; |
| int n, ldlen; |
| |
| ldirname = *dirnamep; |
| |
| if (*ldirname == '/') |
| return 0; |
| |
| n = get_inferior_cwd (cwd, sizeof(cwd) - 1); |
| if (n < 0) |
| return 0; |
| if (n == 0) /* current directory */ |
| { |
| cwd[0] = '.'; |
| cwd[1] = '\0'; |
| n = 1; |
| } |
| |
| /* Minimally canonicalize ldirname by removing leading `./' */ |
| for (ld = ldirname; *ld; ) |
| { |
| if (ISDIRSEP (ld[0])) |
| ld++; |
| else if (ld[0] == '.' && PATHSEP(ld[1])) |
| ld++; |
| else |
| break; |
| } |
| ldlen = (ld && *ld) ? strlen (ld) : 0; |
| |
| retdir = (char *)malloc (n + ldlen + 3); |
| if (retdir == 0) |
| return 0; |
| if (ldlen) |
| sprintf (retdir, "%s/%s", cwd, ld); |
| else |
| strcpy (retdir, cwd); |
| free (ldirname); |
| |
| *dirnamep = retdir; |
| |
| DPRINT1("rl_directory_rewrite_hook returns %s\n", retdir); |
| return 1; |
| } |
| |
| /* Translate *DIRNAMEP to be relative to the inferior's CWD. Leave a trailing |
| slash on the result. */ |
| static int |
| rlfe_directory_completion_hook (dirnamep) |
| char **dirnamep; |
| { |
| char *ldirname, *retdir; |
| int n, ldlen; |
| |
| ldirname = *dirnamep; |
| |
| if (*ldirname == '/') |
| return 0; |
| |
| n = rlfe_directory_rewrite_hook (dirnamep); |
| if (n == 0) |
| return 0; |
| |
| ldirname = *dirnamep; |
| ldlen = (ldirname && *ldirname) ? strlen (ldirname) : 0; |
| |
| if (ldlen == 0 || ldirname[ldlen - 1] != '/') |
| { |
| retdir = (char *)malloc (ldlen + 3); |
| if (retdir == 0) |
| return 0; |
| if (ldlen) |
| strcpy (retdir, ldirname); |
| else |
| retdir[ldlen++] = '.'; |
| retdir[ldlen] = '/'; |
| retdir[ldlen+1] = '\0'; |
| free (ldirname); |
| |
| *dirnamep = retdir; |
| } |
| |
| DPRINT1("rl_directory_completion_hook returns %s\n", retdir); |
| return 1; |
| } |
| |
| static char * |
| rlfe_filename_completion_function (text, state) |
| const char *text; |
| int state; |
| { |
| static DIR *directory; |
| static char *filename = (char *)NULL; |
| static char *dirname = (char *)NULL, *ud = (char *)NULL; |
| static int flen, udlen; |
| char *temp; |
| struct dirent *dentry; |
| |
| if (state == 0) |
| { |
| if (directory) |
| { |
| closedir (directory); |
| directory = 0; |
| } |
| FREE (dirname); |
| FREE (filename); |
| FREE (ud); |
| |
| if (text && *text) |
| STRDUP (filename, text); |
| else |
| { |
| filename = malloc(1); |
| if (filename == 0) |
| return ((char *)NULL); |
| filename[0] = '\0'; |
| } |
| dirname = (text && *text) ? strdup (text) : strdup ("."); |
| if (dirname == 0) |
| return ((char *)NULL); |
| |
| temp = strrchr (dirname, '/'); |
| if (temp) |
| { |
| strcpy (filename, ++temp); |
| *temp = '\0'; |
| } |
| else |
| { |
| dirname[0] = '.'; |
| dirname[1] = '\0'; |
| } |
| |
| STRDUP (ud, dirname); |
| udlen = strlen (ud); |
| |
| rlfe_directory_completion_hook (&dirname); |
| |
| directory = opendir (dirname); |
| flen = strlen (filename); |
| |
| rl_filename_completion_desired = 1; |
| } |
| |
| dentry = 0; |
| while (directory && (dentry = readdir (directory))) |
| { |
| if (flen == 0) |
| { |
| if (DOT_OR_DOTDOT(dentry->d_name) == 0) |
| break; |
| } |
| else |
| { |
| if ((dentry->d_name[0] == filename[0]) && |
| (strlen (dentry->d_name) >= flen) && |
| (strncmp (filename, dentry->d_name, flen) == 0)) |
| break; |
| } |
| } |
| |
| if (dentry == 0) |
| { |
| if (directory) |
| { |
| closedir (directory); |
| directory = 0; |
| } |
| FREE (dirname); |
| FREE (filename); |
| FREE (ud); |
| dirname = filename = ud = 0; |
| return ((char *)NULL); |
| } |
| |
| if (ud == 0 || (ud[0] == '.' && ud[1] == '\0')) |
| temp = strdup (dentry->d_name); |
| else |
| { |
| temp = malloc (1 + udlen + strlen (dentry->d_name)); |
| strcpy (temp, ud); |
| strcpy (temp + udlen, dentry->d_name); |
| } |
| return (temp); |
| } |