Commit | Line | Data |
---|---|---|
f9267e15 EZ |
1 | /* A front-end using readline to "cook" input lines for Kawa. |
2 | * | |
3 | * Copyright (C) 1999 Per Bothner | |
4 | * | |
5 | * This front-end program is free software; you can redistribute it and/or | |
6 | * modify it under the terms of the GNU General Public License as published | |
7 | * by the Free Software Foundation; either version 2, or (at your option) | |
8 | * any later version. | |
9 | * | |
10 | * Some code from Johnson & Troan: "Linux Application Development" | |
11 | * (Addison-Wesley, 1998) was used directly or for inspiration. | |
12 | */ | |
13 | ||
14 | /* PROBLEMS/TODO: | |
15 | * | |
16 | * Only tested under Linux; needs to be ported. | |
17 | * | |
18 | * When running mc -c under the Linux console, mc does not recognize | |
19 | * mouse clicks, which mc does when not running under fep. | |
20 | * | |
21 | * Pasting selected text containing tabs is like hitting the tab character, | |
22 | * which invokes readline completion. We don't want this. I don't know | |
23 | * if this is fixable without integrating fep into a terminal emulator. | |
24 | * | |
25 | * Echo suppression is a kludge, but can only be avoided with better kernel | |
26 | * support: We need a tty mode to disable "real" echoing, while still | |
27 | * letting the inferior think its tty driver to doing echoing. | |
28 | * Stevens's book claims SCR$ and BSD4.3+ have TIOCREMOTE. | |
29 | * | |
30 | * The latest readline may have some hooks we can use to avoid having | |
31 | * to back up the prompt. | |
32 | * | |
33 | * Desirable readline feature: When in cooked no-echo mode (e.g. password), | |
34 | * echo characters are they are types with '*', but remove them when done. | |
35 | * | |
36 | * A synchronous output while we're editing an input line should be | |
37 | * inserted in the output view *before* the input line, so that the | |
38 | * lines being edited (with the prompt) float at the end of the input. | |
39 | * | |
40 | * A "page mode" option to emulate more/less behavior: At each page of | |
41 | * output, pause for a user command. This required parsing the output | |
42 | * to keep track of line lengths. It also requires remembering the | |
43 | * output, if we want an option to scroll back, which suggests that | |
44 | * this should be integrated with a terminal emulator like xterm. | |
45 | */ | |
46 | ||
47 | #ifdef HAVE_CONFIG_H | |
48 | # include <config.h> | |
49 | #endif | |
50 | ||
51 | #include <stdio.h> | |
52 | #include <fcntl.h> | |
53 | #include <sys/types.h> | |
54 | #include <sys/socket.h> | |
55 | #include <netinet/in.h> | |
56 | #include <arpa/inet.h> | |
57 | #include <signal.h> | |
58 | #include <netdb.h> | |
59 | #include <stdlib.h> | |
60 | #include <errno.h> | |
61 | #include <grp.h> | |
62 | #include <string.h> | |
63 | #include <sys/stat.h> | |
64 | #include <unistd.h> | |
65 | #include <sys/ioctl.h> | |
66 | #include <termios.h> | |
9255ee31 EZ |
67 | #include <limits.h> |
68 | #include <dirent.h> | |
f9267e15 EZ |
69 | |
70 | #ifdef READLINE_LIBRARY | |
71 | # include "readline.h" | |
72 | # include "history.h" | |
73 | #else | |
74 | # include <readline/readline.h> | |
75 | # include <readline/history.h> | |
76 | #endif | |
77 | ||
78 | #ifndef COMMAND | |
79 | #define COMMAND "/bin/sh" | |
80 | #endif | |
81 | #ifndef COMMAND_ARGS | |
82 | #define COMMAND_ARGS COMMAND | |
83 | #endif | |
84 | ||
85 | #ifndef HAVE_MEMMOVE | |
9255ee31 | 86 | #ifndef memmove |
f9267e15 EZ |
87 | # if __GNUC__ > 1 |
88 | # define memmove(d, s, n) __builtin_memcpy(d, s, n) | |
89 | # else | |
90 | # define memmove(d, s, n) memcpy(d, s, n) | |
91 | # endif | |
92 | #else | |
93 | # define memmove(d, s, n) memcpy(d, s, n) | |
94 | #endif | |
9255ee31 EZ |
95 | #endif |
96 | ||
97 | #define APPLICATION_NAME "Rlfe" | |
98 | ||
99 | #ifndef errno | |
100 | extern int errno; | |
101 | #endif | |
f9267e15 | 102 | |
9255ee31 EZ |
103 | extern int optind; |
104 | extern char *optarg; | |
105 | ||
106 | static char *progname; | |
107 | static char *progversion; | |
f9267e15 EZ |
108 | |
109 | static int in_from_inferior_fd; | |
110 | static int out_to_inferior_fd; | |
111 | ||
112 | /* Unfortunately, we cannot safely display echo from the inferior process. | |
113 | The reason is that the echo bit in the pty is "owned" by the inferior, | |
114 | and if we try to turn it off, we could confuse the inferior. | |
115 | Thus, when echoing, we get echo twice: First readline echoes while | |
116 | we're actually editing. Then we send the line to the inferior, and the | |
117 | terminal driver send back an extra echo. | |
118 | The work-around is to remember the input lines, and when we see that | |
119 | line come back, we supress the output. | |
120 | A better solution (supposedly available on SVR4) would be a smarter | |
121 | terminal driver, with more flags ... */ | |
122 | #define ECHO_SUPPRESS_MAX 1024 | |
123 | char echo_suppress_buffer[ECHO_SUPPRESS_MAX]; | |
124 | int echo_suppress_start = 0; | |
125 | int echo_suppress_limit = 0; | |
126 | ||
9255ee31 EZ |
127 | /* #define DEBUG */ |
128 | ||
129 | static FILE *logfile = NULL; | |
f9267e15 EZ |
130 | |
131 | #ifdef DEBUG | |
9255ee31 EZ |
132 | FILE *debugfile = NULL; |
133 | #define DPRINT0(FMT) (fprintf(debugfile, FMT), fflush(debugfile)) | |
134 | #define DPRINT1(FMT, V1) (fprintf(debugfile, FMT, V1), fflush(debugfile)) | |
135 | #define DPRINT2(FMT, V1, V2) (fprintf(debugfile, FMT, V1, V2), fflush(debugfile)) | |
f9267e15 EZ |
136 | #else |
137 | #define DPRINT0(FMT) /* Do nothing */ | |
138 | #define DPRINT1(FMT, V1) /* Do nothing */ | |
139 | #define DPRINT2(FMT, V1, V2) /* Do nothing */ | |
140 | #endif | |
141 | ||
142 | struct termios orig_term; | |
143 | ||
9255ee31 EZ |
144 | static int rlfe_directory_completion_hook __P((char **)); |
145 | static int rlfe_directory_rewrite_hook __P((char **)); | |
146 | static char *rlfe_filename_completion_function __P((const char *, int)); | |
147 | ||
f9267e15 EZ |
148 | /* Pid of child process. */ |
149 | static pid_t child = -1; | |
150 | ||
151 | static void | |
152 | sig_child (int signo) | |
153 | { | |
154 | int status; | |
155 | wait (&status); | |
156 | DPRINT0 ("(Child process died.)\n"); | |
157 | tcsetattr(STDIN_FILENO, TCSANOW, &orig_term); | |
158 | exit (0); | |
159 | } | |
160 | ||
161 | volatile int propagate_sigwinch = 0; | |
162 | ||
163 | /* sigwinch_handler | |
164 | * propagate window size changes from input file descriptor to | |
165 | * master side of pty. | |
166 | */ | |
167 | void sigwinch_handler(int signal) { | |
168 | propagate_sigwinch = 1; | |
169 | } | |
170 | ||
171 | /* get_master_pty() takes a double-indirect character pointer in which | |
172 | * to put a slave name, and returns an integer file descriptor. | |
173 | * If it returns < 0, an error has occurred. | |
174 | * Otherwise, it has returned the master pty file descriptor, and fills | |
175 | * in *name with the name of the corresponding slave pty. | |
176 | * Once the slave pty has been opened, you are responsible to free *name. | |
177 | */ | |
178 | ||
179 | int get_master_pty(char **name) { | |
180 | int i, j; | |
181 | /* default to returning error */ | |
182 | int master = -1; | |
183 | ||
184 | /* create a dummy name to fill in */ | |
185 | *name = strdup("/dev/ptyXX"); | |
186 | ||
187 | /* search for an unused pty */ | |
188 | for (i=0; i<16 && master <= 0; i++) { | |
189 | for (j=0; j<16 && master <= 0; j++) { | |
190 | (*name)[5] = 'p'; | |
191 | (*name)[8] = "pqrstuvwxyzPQRST"[i]; | |
192 | (*name)[9] = "0123456789abcdef"[j]; | |
193 | /* open the master pty */ | |
194 | if ((master = open(*name, O_RDWR)) < 0) { | |
195 | if (errno == ENOENT) { | |
196 | /* we are out of pty devices */ | |
197 | free (*name); | |
198 | return (master); | |
199 | } | |
200 | } | |
201 | else { | |
202 | /* By substituting a letter, we change the master pty | |
203 | * name into the slave pty name. | |
204 | */ | |
205 | (*name)[5] = 't'; | |
206 | if (access(*name, R_OK|W_OK) != 0) | |
207 | { | |
208 | close(master); | |
209 | master = -1; | |
210 | } | |
211 | } | |
212 | } | |
213 | } | |
214 | if ((master < 0) && (i == 16) && (j == 16)) { | |
215 | /* must have tried every pty unsuccessfully */ | |
216 | free (*name); | |
217 | return (master); | |
218 | } | |
219 | ||
220 | (*name)[5] = 't'; | |
221 | ||
222 | return (master); | |
223 | } | |
224 | ||
225 | /* get_slave_pty() returns an integer file descriptor. | |
226 | * If it returns < 0, an error has occurred. | |
227 | * Otherwise, it has returned the slave file descriptor. | |
228 | */ | |
229 | ||
230 | int get_slave_pty(char *name) { | |
231 | struct group *gptr; | |
232 | gid_t gid; | |
233 | int slave = -1; | |
234 | ||
235 | /* chown/chmod the corresponding pty, if possible. | |
236 | * This will only work if the process has root permissions. | |
237 | * Alternatively, write and exec a small setuid program that | |
238 | * does just this. | |
239 | */ | |
240 | if ((gptr = getgrnam("tty")) != 0) { | |
241 | gid = gptr->gr_gid; | |
242 | } else { | |
243 | /* if the tty group does not exist, don't change the | |
244 | * group on the slave pty, only the owner | |
245 | */ | |
246 | gid = -1; | |
247 | } | |
248 | ||
249 | /* Note that we do not check for errors here. If this is code | |
250 | * where these actions are critical, check for errors! | |
251 | */ | |
252 | chown(name, getuid(), gid); | |
253 | /* This code only makes the slave read/writeable for the user. | |
254 | * If this is for an interactive shell that will want to | |
255 | * receive "write" and "wall" messages, OR S_IWGRP into the | |
256 | * second argument below. | |
257 | */ | |
258 | chmod(name, S_IRUSR|S_IWUSR); | |
259 | ||
260 | /* open the corresponding slave pty */ | |
261 | slave = open(name, O_RDWR); | |
262 | return (slave); | |
263 | } | |
264 | ||
265 | /* Certain special characters, such as ctrl/C, we want to pass directly | |
266 | to the inferior, rather than letting readline handle them. */ | |
267 | ||
268 | static char special_chars[20]; | |
269 | static int special_chars_count; | |
270 | ||
271 | static void | |
272 | add_special_char(int ch) | |
273 | { | |
274 | if (ch != 0) | |
275 | special_chars[special_chars_count++] = ch; | |
276 | } | |
277 | ||
278 | static int eof_char; | |
279 | ||
280 | static int | |
281 | is_special_char(int ch) | |
282 | { | |
283 | int i; | |
284 | #if 0 | |
285 | if (ch == eof_char && rl_point == rl_end) | |
286 | return 1; | |
287 | #endif | |
288 | for (i = special_chars_count; --i >= 0; ) | |
289 | if (special_chars[i] == ch) | |
290 | return 1; | |
291 | return 0; | |
292 | } | |
293 | ||
294 | static char buf[1024]; | |
295 | /* buf[0 .. buf_count-1] is the what has been emitted on the current line. | |
296 | It is used as the readline prompt. */ | |
297 | static int buf_count = 0; | |
298 | ||
299 | int num_keys = 0; | |
300 | ||
301 | static void | |
302 | null_prep_terminal (int meta) | |
303 | { | |
304 | } | |
305 | ||
306 | static void | |
307 | null_deprep_terminal () | |
308 | { | |
309 | } | |
310 | ||
311 | char pending_special_char; | |
312 | ||
313 | static void | |
314 | line_handler (char *line) | |
315 | { | |
316 | if (line == NULL) | |
317 | { | |
318 | char buf[1]; | |
319 | DPRINT0("saw eof!\n"); | |
320 | buf[0] = '\004'; /* ctrl/d */ | |
321 | write (out_to_inferior_fd, buf, 1); | |
322 | } | |
323 | else | |
324 | { | |
325 | static char enter[] = "\r"; | |
326 | /* Send line to inferior: */ | |
327 | int length = strlen (line); | |
328 | if (length > ECHO_SUPPRESS_MAX-2) | |
329 | { | |
330 | echo_suppress_start = 0; | |
331 | echo_suppress_limit = 0; | |
332 | } | |
333 | else | |
334 | { | |
335 | if (echo_suppress_limit + length > ECHO_SUPPRESS_MAX - 2) | |
336 | { | |
337 | if (echo_suppress_limit - echo_suppress_start + length | |
338 | <= ECHO_SUPPRESS_MAX - 2) | |
339 | { | |
340 | memmove (echo_suppress_buffer, | |
341 | echo_suppress_buffer + echo_suppress_start, | |
342 | echo_suppress_limit - echo_suppress_start); | |
343 | echo_suppress_limit -= echo_suppress_start; | |
344 | echo_suppress_start = 0; | |
345 | } | |
346 | else | |
347 | { | |
348 | echo_suppress_limit = 0; | |
349 | } | |
350 | echo_suppress_start = 0; | |
351 | } | |
352 | memcpy (echo_suppress_buffer + echo_suppress_limit, | |
353 | line, length); | |
354 | echo_suppress_limit += length; | |
355 | echo_suppress_buffer[echo_suppress_limit++] = '\r'; | |
356 | echo_suppress_buffer[echo_suppress_limit++] = '\n'; | |
357 | } | |
358 | write (out_to_inferior_fd, line, length); | |
359 | if (pending_special_char == 0) | |
360 | { | |
361 | write (out_to_inferior_fd, enter, sizeof(enter)-1); | |
362 | if (*line) | |
363 | add_history (line); | |
364 | } | |
365 | free (line); | |
366 | } | |
367 | rl_callback_handler_remove (); | |
368 | buf_count = 0; | |
369 | num_keys = 0; | |
370 | if (pending_special_char != 0) | |
371 | { | |
372 | write (out_to_inferior_fd, &pending_special_char, 1); | |
373 | pending_special_char = 0; | |
374 | } | |
375 | } | |
376 | ||
377 | /* Value of rl_getc_function. | |
378 | Use this because readline should read from stdin, not rl_instream, | |
379 | points to the pty (so readline has monitor its terminal modes). */ | |
380 | ||
381 | int | |
382 | my_rl_getc (FILE *dummy) | |
383 | { | |
384 | int ch = rl_getc (stdin); | |
385 | if (is_special_char (ch)) | |
386 | { | |
387 | pending_special_char = ch; | |
388 | return '\r'; | |
389 | } | |
390 | return ch; | |
391 | } | |
392 | ||
9255ee31 EZ |
393 | static void |
394 | usage() | |
395 | { | |
396 | fprintf (stderr, "%s: usage: %s [-l filename] [-a] [-n appname] [-hv] [command [arguments...]]\n", | |
397 | progname, progname); | |
398 | } | |
399 | ||
f9267e15 EZ |
400 | int |
401 | main(int argc, char** argv) | |
402 | { | |
403 | char *path; | |
9255ee31 | 404 | int i, append; |
f9267e15 | 405 | int master; |
9255ee31 | 406 | char *name, *logfname, *appname; |
f9267e15 EZ |
407 | int in_from_tty_fd; |
408 | struct sigaction act; | |
409 | struct winsize ws; | |
410 | struct termios t; | |
411 | int maxfd; | |
412 | fd_set in_set; | |
413 | static char empty_string[1] = ""; | |
414 | char *prompt = empty_string; | |
415 | int ioctl_err = 0; | |
416 | ||
9255ee31 EZ |
417 | if ((progname = strrchr (argv[0], '/')) == 0) |
418 | progname = argv[0]; | |
419 | else | |
420 | progname++; | |
421 | progversion = RL_LIBRARY_VERSION; | |
422 | ||
423 | append = 0; | |
424 | appname = APPLICATION_NAME; | |
425 | logfname = (char *)NULL; | |
426 | ||
427 | while ((i = getopt (argc, argv, "ahl:n:v")) != EOF) | |
428 | { | |
429 | switch (i) | |
430 | { | |
431 | case 'l': | |
432 | logfname = optarg; | |
433 | break; | |
434 | case 'n': | |
435 | appname = optarg; | |
436 | break; | |
437 | case 'a': | |
438 | append = 1; | |
439 | break; | |
440 | case 'h': | |
441 | usage (); | |
442 | exit (0); | |
443 | case 'v': | |
444 | fprintf (stderr, "%s version %s\n", progname, progversion); | |
445 | exit (0); | |
446 | default: | |
447 | usage (); | |
448 | exit (2); | |
449 | } | |
450 | } | |
451 | ||
452 | argc -= optind; | |
453 | argv += optind; | |
454 | ||
455 | if (logfname) | |
456 | { | |
457 | logfile = fopen (logfname, append ? "a" : "w"); | |
458 | if (logfile == 0) | |
459 | fprintf (stderr, "%s: warning: could not open log file %s: %s\n", | |
460 | progname, logfname, strerror (errno)); | |
461 | } | |
462 | ||
463 | rl_readline_name = appname; | |
464 | ||
f9267e15 | 465 | #ifdef DEBUG |
9255ee31 | 466 | debugfile = fopen("LOG", "w"); |
f9267e15 EZ |
467 | #endif |
468 | ||
f9267e15 EZ |
469 | if ((master = get_master_pty(&name)) < 0) |
470 | { | |
471 | perror("ptypair: could not open master pty"); | |
472 | exit(1); | |
473 | } | |
474 | ||
475 | DPRINT1("pty name: '%s'\n", name); | |
476 | ||
477 | /* set up SIGWINCH handler */ | |
478 | act.sa_handler = sigwinch_handler; | |
479 | sigemptyset(&(act.sa_mask)); | |
480 | act.sa_flags = 0; | |
481 | if (sigaction(SIGWINCH, &act, NULL) < 0) | |
482 | { | |
483 | perror("ptypair: could not handle SIGWINCH "); | |
484 | exit(1); | |
485 | } | |
486 | ||
487 | if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) < 0) | |
488 | { | |
489 | perror("ptypair: could not get window size"); | |
490 | exit(1); | |
491 | } | |
492 | ||
493 | if ((child = fork()) < 0) | |
494 | { | |
495 | perror("cannot fork"); | |
496 | exit(1); | |
497 | } | |
498 | ||
499 | if (child == 0) | |
500 | { | |
501 | int slave; /* file descriptor for slave pty */ | |
502 | ||
503 | /* We are in the child process */ | |
504 | close(master); | |
505 | ||
506 | #ifdef TIOCSCTTY | |
507 | if ((slave = get_slave_pty(name)) < 0) | |
508 | { | |
509 | perror("ptypair: could not open slave pty"); | |
510 | exit(1); | |
511 | } | |
512 | free(name); | |
513 | #endif | |
514 | ||
515 | /* We need to make this process a session group leader, because | |
516 | * it is on a new PTY, and things like job control simply will | |
517 | * not work correctly unless there is a session group leader | |
518 | * and process group leader (which a session group leader | |
519 | * automatically is). This also disassociates us from our old | |
520 | * controlling tty. | |
521 | */ | |
522 | if (setsid() < 0) | |
523 | { | |
524 | perror("could not set session leader"); | |
525 | } | |
526 | ||
527 | /* Tie us to our new controlling tty. */ | |
528 | #ifdef TIOCSCTTY | |
529 | if (ioctl(slave, TIOCSCTTY, NULL)) | |
530 | { | |
531 | perror("could not set new controlling tty"); | |
532 | } | |
533 | #else | |
534 | if ((slave = get_slave_pty(name)) < 0) | |
535 | { | |
536 | perror("ptypair: could not open slave pty"); | |
537 | exit(1); | |
538 | } | |
539 | free(name); | |
540 | #endif | |
541 | ||
542 | /* make slave pty be standard in, out, and error */ | |
543 | dup2(slave, STDIN_FILENO); | |
544 | dup2(slave, STDOUT_FILENO); | |
545 | dup2(slave, STDERR_FILENO); | |
546 | ||
547 | /* at this point the slave pty should be standard input */ | |
548 | if (slave > 2) | |
549 | { | |
550 | close(slave); | |
551 | } | |
552 | ||
553 | /* Try to restore window size; failure isn't critical */ | |
554 | if (ioctl(STDOUT_FILENO, TIOCSWINSZ, &ws) < 0) | |
555 | { | |
556 | perror("could not restore window size"); | |
557 | } | |
558 | ||
559 | /* now start the shell */ | |
560 | { | |
561 | static char* command_args[] = { COMMAND_ARGS, NULL }; | |
9255ee31 | 562 | if (argc < 1) |
f9267e15 EZ |
563 | execvp(COMMAND, command_args); |
564 | else | |
9255ee31 | 565 | execvp(argv[0], &argv[0]); |
f9267e15 EZ |
566 | } |
567 | ||
568 | /* should never be reached */ | |
569 | exit(1); | |
570 | } | |
571 | ||
572 | /* parent */ | |
573 | signal (SIGCHLD, sig_child); | |
574 | free(name); | |
575 | ||
576 | /* Note that we only set termios settings for standard input; | |
577 | * the master side of a pty is NOT a tty. | |
578 | */ | |
579 | tcgetattr(STDIN_FILENO, &orig_term); | |
580 | ||
581 | t = orig_term; | |
582 | eof_char = t.c_cc[VEOF]; | |
583 | /* add_special_char(t.c_cc[VEOF]);*/ | |
584 | add_special_char(t.c_cc[VINTR]); | |
585 | add_special_char(t.c_cc[VQUIT]); | |
586 | add_special_char(t.c_cc[VSUSP]); | |
587 | #if defined (VDISCARD) | |
588 | add_special_char(t.c_cc[VDISCARD]); | |
589 | #endif | |
590 | ||
591 | #if 0 | |
592 | t.c_lflag |= (ICANON | ISIG | ECHO | ECHOCTL | ECHOE | \ | |
593 | ECHOK | ECHOKE | ECHONL | ECHOPRT ); | |
594 | #else | |
595 | t.c_lflag &= ~(ICANON | ISIG | ECHO | ECHOCTL | ECHOE | \ | |
596 | ECHOK | ECHOKE | ECHONL | ECHOPRT ); | |
597 | #endif | |
598 | t.c_iflag |= IGNBRK; | |
599 | t.c_cc[VMIN] = 1; | |
600 | t.c_cc[VTIME] = 0; | |
601 | tcsetattr(STDIN_FILENO, TCSANOW, &t); | |
602 | in_from_inferior_fd = master; | |
603 | out_to_inferior_fd = master; | |
604 | rl_instream = fdopen (master, "r"); | |
605 | rl_getc_function = my_rl_getc; | |
606 | ||
607 | rl_prep_term_function = null_prep_terminal; | |
608 | rl_deprep_term_function = null_deprep_terminal; | |
609 | rl_callback_handler_install (prompt, line_handler); | |
610 | ||
9255ee31 EZ |
611 | #if 1 |
612 | rl_directory_completion_hook = rlfe_directory_completion_hook; | |
613 | rl_completion_entry_function = rlfe_filename_completion_function; | |
614 | #else | |
615 | rl_directory_rewrite_hook = rlfe_directory_rewrite_hook; | |
616 | #endif | |
617 | ||
f9267e15 EZ |
618 | in_from_tty_fd = STDIN_FILENO; |
619 | FD_ZERO (&in_set); | |
620 | maxfd = in_from_inferior_fd > in_from_tty_fd ? in_from_inferior_fd | |
621 | : in_from_tty_fd; | |
622 | for (;;) | |
623 | { | |
624 | int num; | |
625 | FD_SET (in_from_inferior_fd, &in_set); | |
626 | FD_SET (in_from_tty_fd, &in_set); | |
627 | ||
628 | num = select(maxfd+1, &in_set, NULL, NULL, NULL); | |
629 | ||
630 | if (propagate_sigwinch) | |
631 | { | |
632 | struct winsize ws; | |
633 | if (ioctl (STDIN_FILENO, TIOCGWINSZ, &ws) >= 0) | |
634 | { | |
635 | ioctl (master, TIOCSWINSZ, &ws); | |
636 | } | |
637 | propagate_sigwinch = 0; | |
638 | continue; | |
639 | } | |
640 | ||
641 | if (num <= 0) | |
642 | { | |
643 | perror ("select"); | |
644 | exit (-1); | |
645 | } | |
646 | if (FD_ISSET (in_from_tty_fd, &in_set)) | |
647 | { | |
648 | extern int readline_echoing_p; | |
649 | struct termios term_master; | |
650 | int do_canon = 1; | |
651 | int ioctl_ret; | |
652 | ||
653 | DPRINT1("[tty avail num_keys:%d]\n", num_keys); | |
654 | ||
655 | /* If we can't get tty modes for the master side of the pty, we | |
656 | can't handle non-canonical-mode programs. Always assume the | |
657 | master is in canonical echo mode if we can't tell. */ | |
658 | ioctl_ret = tcgetattr(master, &term_master); | |
659 | ||
660 | if (ioctl_ret >= 0) | |
661 | { | |
662 | DPRINT2 ("echo:%d, canon:%d\n", | |
663 | (term_master.c_lflag & ECHO) != 0, | |
664 | (term_master.c_lflag & ICANON) != 0); | |
665 | do_canon = (term_master.c_lflag & ICANON) != 0; | |
666 | readline_echoing_p = (term_master.c_lflag & ECHO) != 0; | |
667 | } | |
668 | else | |
669 | { | |
670 | if (ioctl_err == 0) | |
671 | DPRINT1("tcgetattr on master fd failed: errno = %d\n", errno); | |
672 | ioctl_err = 1; | |
673 | } | |
674 | ||
675 | if (do_canon == 0 && num_keys == 0) | |
676 | { | |
677 | char ch[10]; | |
678 | int count = read (STDIN_FILENO, ch, sizeof(ch)); | |
679 | write (out_to_inferior_fd, ch, count); | |
680 | } | |
681 | else | |
682 | { | |
683 | if (num_keys == 0) | |
684 | { | |
685 | int i; | |
686 | /* Re-install callback handler for new prompt. */ | |
687 | if (prompt != empty_string) | |
688 | free (prompt); | |
689 | prompt = malloc (buf_count + 1); | |
690 | if (prompt == NULL) | |
691 | prompt = empty_string; | |
692 | else | |
693 | { | |
694 | memcpy (prompt, buf, buf_count); | |
695 | prompt[buf_count] = '\0'; | |
696 | DPRINT1("New prompt '%s'\n", prompt); | |
697 | #if 0 /* ifdef HAVE_RL_ALREADY_PROMPTED -- doesn't work */ | |
698 | rl_already_prompted = buf_count > 0; | |
699 | #else | |
700 | if (buf_count > 0) | |
701 | write (1, "\r", 1); | |
702 | #endif | |
703 | } | |
704 | rl_callback_handler_install (prompt, line_handler); | |
705 | } | |
706 | num_keys++; | |
707 | rl_callback_read_char (); | |
708 | } | |
709 | } | |
710 | else /* input from inferior. */ | |
711 | { | |
712 | int i; | |
713 | int count; | |
714 | int old_count; | |
715 | if (buf_count > (sizeof(buf) >> 2)) | |
716 | buf_count = 0; | |
717 | count = read (in_from_inferior_fd, buf+buf_count, | |
718 | sizeof(buf) - buf_count); | |
719 | if (count <= 0) | |
720 | { | |
721 | DPRINT0 ("(Connection closed by foreign host.)\n"); | |
722 | tcsetattr(STDIN_FILENO, TCSANOW, &orig_term); | |
723 | exit (0); | |
724 | } | |
725 | old_count = buf_count; | |
726 | ||
9255ee31 EZ |
727 | /* Do some minimal carriage return translation and backspace |
728 | processing before logging the input line. */ | |
729 | if (logfile) | |
730 | { | |
731 | #ifndef __GNUC__ | |
732 | char *b; | |
733 | #else | |
734 | char b[count + 1]; | |
735 | #endif | |
736 | int i, j; | |
737 | ||
738 | #ifndef __GNUC__ | |
739 | b = malloc (count + 1); | |
740 | if (b) { | |
741 | #endif | |
742 | for (i = 0; i < count; i++) | |
743 | b[i] = buf[buf_count + i]; | |
744 | b[i] = '\0'; | |
745 | for (i = j = 0; i <= count; i++) | |
746 | { | |
747 | if (b[i] == '\r') | |
748 | { | |
749 | if (b[i+1] != '\n') | |
750 | b[j++] = '\n'; | |
751 | } | |
752 | else if (b[i] == '\b') | |
753 | { | |
754 | if (i) | |
755 | j--; | |
756 | } | |
757 | else | |
758 | b[j++] = b[i]; | |
759 | } | |
760 | fprintf (logfile, "%s", b); | |
761 | ||
762 | #ifndef __GNUC__ | |
763 | free (b); | |
764 | } | |
765 | #endif | |
766 | } | |
767 | ||
f9267e15 EZ |
768 | /* Look for any pending echo that we need to suppress. */ |
769 | while (echo_suppress_start < echo_suppress_limit | |
770 | && count > 0 | |
771 | && buf[buf_count] == echo_suppress_buffer[echo_suppress_start]) | |
772 | { | |
773 | count--; | |
774 | buf_count++; | |
775 | echo_suppress_start++; | |
776 | } | |
777 | ||
778 | /* Write to the terminal anything that was not suppressed. */ | |
779 | if (count > 0) | |
780 | write (1, buf + buf_count, count); | |
781 | ||
782 | /* Finally, look for a prompt candidate. | |
783 | * When we get around to going input (from the keyboard), | |
784 | * we will consider the prompt to be anything since the last | |
785 | * line terminator. So we need to save that text in the | |
786 | * initial part of buf. However, anything before the | |
787 | * most recent end-of-line is not interesting. */ | |
788 | buf_count += count; | |
789 | #if 1 | |
790 | for (i = buf_count; --i >= old_count; ) | |
791 | #else | |
792 | for (i = buf_count - 1; i-- >= buf_count - count; ) | |
793 | #endif | |
794 | { | |
795 | if (buf[i] == '\n' || buf[i] == '\r') | |
796 | { | |
797 | i++; | |
798 | memmove (buf, buf+i, buf_count - i); | |
799 | buf_count -= i; | |
800 | break; | |
801 | } | |
802 | } | |
803 | DPRINT2("-> i: %d, buf_count: %d\n", i, buf_count); | |
804 | } | |
805 | } | |
806 | } | |
9255ee31 EZ |
807 | |
808 | /* | |
809 | * | |
810 | * FILENAME COMPLETION FOR RLFE | |
811 | * | |
812 | */ | |
813 | ||
814 | #ifndef PATH_MAX | |
815 | # define PATH_MAX 1024 | |
816 | #endif | |
817 | ||
818 | #define DIRSEP '/' | |
819 | #define ISDIRSEP(x) ((x) == '/') | |
820 | #define PATHSEP(x) (ISDIRSEP(x) || (x) == 0) | |
821 | ||
822 | #define DOT_OR_DOTDOT(x) \ | |
823 | ((x)[0] == '.' && (PATHSEP((x)[1]) || \ | |
824 | ((x)[1] == '.' && PATHSEP((x)[2])))) | |
825 | ||
826 | #define FREE(x) if (x) free(x) | |
827 | ||
828 | #define STRDUP(s, x) do { \ | |
829 | s = strdup (x);\ | |
830 | if (s == 0) \ | |
831 | return ((char *)NULL); \ | |
832 | } while (0) | |
833 | ||
834 | static int | |
835 | get_inferior_cwd (path, psize) | |
836 | char *path; | |
837 | size_t psize; | |
838 | { | |
839 | int n; | |
840 | static char procfsbuf[PATH_MAX] = { '\0' }; | |
841 | ||
842 | if (procfsbuf[0] == '\0') | |
843 | sprintf (procfsbuf, "/proc/%d/cwd", (int)child); | |
844 | n = readlink (procfsbuf, path, psize); | |
845 | if (n < 0) | |
846 | return n; | |
847 | if (n > psize) | |
848 | return -1; | |
849 | path[n] = '\0'; | |
850 | return n; | |
851 | } | |
852 | ||
853 | static int | |
854 | rlfe_directory_rewrite_hook (dirnamep) | |
855 | char **dirnamep; | |
856 | { | |
857 | char *ldirname, cwd[PATH_MAX], *retdir, *ld; | |
858 | int n, ldlen; | |
859 | ||
860 | ldirname = *dirnamep; | |
861 | ||
862 | if (*ldirname == '/') | |
863 | return 0; | |
864 | ||
865 | n = get_inferior_cwd (cwd, sizeof(cwd) - 1); | |
866 | if (n < 0) | |
867 | return 0; | |
868 | if (n == 0) /* current directory */ | |
869 | { | |
870 | cwd[0] = '.'; | |
871 | cwd[1] = '\0'; | |
872 | n = 1; | |
873 | } | |
874 | ||
875 | /* Minimally canonicalize ldirname by removing leading `./' */ | |
876 | for (ld = ldirname; *ld; ) | |
877 | { | |
878 | if (ISDIRSEP (ld[0])) | |
879 | ld++; | |
880 | else if (ld[0] == '.' && PATHSEP(ld[1])) | |
881 | ld++; | |
882 | else | |
883 | break; | |
884 | } | |
885 | ldlen = (ld && *ld) ? strlen (ld) : 0; | |
886 | ||
887 | retdir = (char *)malloc (n + ldlen + 3); | |
888 | if (retdir == 0) | |
889 | return 0; | |
890 | if (ldlen) | |
891 | sprintf (retdir, "%s/%s", cwd, ld); | |
892 | else | |
893 | strcpy (retdir, cwd); | |
894 | free (ldirname); | |
895 | ||
896 | *dirnamep = retdir; | |
897 | ||
898 | DPRINT1("rl_directory_rewrite_hook returns %s\n", retdir); | |
899 | return 1; | |
900 | } | |
901 | ||
902 | /* Translate *DIRNAMEP to be relative to the inferior's CWD. Leave a trailing | |
903 | slash on the result. */ | |
904 | static int | |
905 | rlfe_directory_completion_hook (dirnamep) | |
906 | char **dirnamep; | |
907 | { | |
908 | char *ldirname, *retdir; | |
909 | int n, ldlen; | |
910 | ||
911 | ldirname = *dirnamep; | |
912 | ||
913 | if (*ldirname == '/') | |
914 | return 0; | |
915 | ||
916 | n = rlfe_directory_rewrite_hook (dirnamep); | |
917 | if (n == 0) | |
918 | return 0; | |
919 | ||
920 | ldirname = *dirnamep; | |
921 | ldlen = (ldirname && *ldirname) ? strlen (ldirname) : 0; | |
922 | ||
923 | if (ldlen == 0 || ldirname[ldlen - 1] != '/') | |
924 | { | |
925 | retdir = (char *)malloc (ldlen + 3); | |
926 | if (retdir == 0) | |
927 | return 0; | |
928 | if (ldlen) | |
929 | strcpy (retdir, ldirname); | |
930 | else | |
931 | retdir[ldlen++] = '.'; | |
932 | retdir[ldlen] = '/'; | |
933 | retdir[ldlen+1] = '\0'; | |
934 | free (ldirname); | |
935 | ||
936 | *dirnamep = retdir; | |
937 | } | |
938 | ||
939 | DPRINT1("rl_directory_completion_hook returns %s\n", retdir); | |
940 | return 1; | |
941 | } | |
942 | ||
943 | static char * | |
944 | rlfe_filename_completion_function (text, state) | |
945 | const char *text; | |
946 | int state; | |
947 | { | |
948 | static DIR *directory; | |
949 | static char *filename = (char *)NULL; | |
950 | static char *dirname = (char *)NULL, *ud = (char *)NULL; | |
951 | static int flen, udlen; | |
952 | char *temp; | |
953 | struct dirent *dentry; | |
954 | ||
955 | if (state == 0) | |
956 | { | |
957 | if (directory) | |
958 | { | |
959 | closedir (directory); | |
960 | directory = 0; | |
961 | } | |
962 | FREE (dirname); | |
963 | FREE (filename); | |
964 | FREE (ud); | |
965 | ||
966 | if (text && *text) | |
967 | STRDUP (filename, text); | |
968 | else | |
969 | { | |
970 | filename = malloc(1); | |
971 | if (filename == 0) | |
972 | return ((char *)NULL); | |
973 | filename[0] = '\0'; | |
974 | } | |
975 | dirname = (text && *text) ? strdup (text) : strdup ("."); | |
976 | if (dirname == 0) | |
977 | return ((char *)NULL); | |
978 | ||
979 | temp = strrchr (dirname, '/'); | |
980 | if (temp) | |
981 | { | |
982 | strcpy (filename, ++temp); | |
983 | *temp = '\0'; | |
984 | } | |
985 | else | |
986 | { | |
987 | dirname[0] = '.'; | |
988 | dirname[1] = '\0'; | |
989 | } | |
990 | ||
991 | STRDUP (ud, dirname); | |
992 | udlen = strlen (ud); | |
993 | ||
994 | rlfe_directory_completion_hook (&dirname); | |
995 | ||
996 | directory = opendir (dirname); | |
997 | flen = strlen (filename); | |
998 | ||
999 | rl_filename_completion_desired = 1; | |
1000 | } | |
1001 | ||
1002 | dentry = 0; | |
1003 | while (directory && (dentry = readdir (directory))) | |
1004 | { | |
1005 | if (flen == 0) | |
1006 | { | |
1007 | if (DOT_OR_DOTDOT(dentry->d_name) == 0) | |
1008 | break; | |
1009 | } | |
1010 | else | |
1011 | { | |
1012 | if ((dentry->d_name[0] == filename[0]) && | |
1013 | (strlen (dentry->d_name) >= flen) && | |
1014 | (strncmp (filename, dentry->d_name, flen) == 0)) | |
1015 | break; | |
1016 | } | |
1017 | } | |
1018 | ||
1019 | if (dentry == 0) | |
1020 | { | |
1021 | if (directory) | |
1022 | { | |
1023 | closedir (directory); | |
1024 | directory = 0; | |
1025 | } | |
1026 | FREE (dirname); | |
1027 | FREE (filename); | |
1028 | FREE (ud); | |
1029 | dirname = filename = ud = 0; | |
1030 | return ((char *)NULL); | |
1031 | } | |
1032 | ||
1033 | if (ud == 0 || (ud[0] == '.' && ud[1] == '\0')) | |
1034 | temp = strdup (dentry->d_name); | |
1035 | else | |
1036 | { | |
1037 | temp = malloc (1 + udlen + strlen (dentry->d_name)); | |
1038 | strcpy (temp, ud); | |
1039 | strcpy (temp + udlen, dentry->d_name); | |
1040 | } | |
1041 | return (temp); | |
1042 | } |