1 /*
2 * Copyright (C) 2019, Karel Zak <kzak@redhat.com>
3 *
4 * This file is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This file is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 */
14
15 #include <stdio.h>
16 #include <stdarg.h>
17 #include <stdlib.h>
18 #include <string.h>
19 #include <errno.h>
20 #include <time.h>
21 #include <limits.h>
22 #include <math.h>
23 #include <sys/select.h>
24 #include <unistd.h>
25 #include <getopt.h>
26 #include <signal.h>
27 #include <sys/types.h>
28 #include <sys/wait.h>
29 #include <termios.h>
30 #include <paths.h>
31
32 #include "c.h"
33 #include "xalloc.h"
34 #include "closestream.h"
35 #include "nls.h"
36 #include "strutils.h"
37 #include "optutils.h"
38 #include "pty-session.h"
39 #include "script-playutils.h"
40 #include "monotonic.h"
41
42
43 #define SCRIPT_MIN_DELAY 0.0001 /* from original scriptreplay.pl */
44
45 struct scriptlive {
46 struct ul_pty *pty;
47 struct replay_setup *setup;
48 struct replay_step *step;
49 };
50
51 static void __attribute__((__noreturn__))
52 usage(void)
53 {
54 FILE *out = stdout;
55 fputs(USAGE_HEADER, out);
56 fprintf(out,
57 _(" %s [options]\n"),
58 program_invocation_short_name);
59 fprintf(out,
60 _(" %s [-t] timingfile [-I|-B] typescript\n"),
61 program_invocation_short_name);
62
63 fputs(USAGE_SEPARATOR, out);
64 fputs(_("Execute terminal typescript.\n"), out);
65
66 fputs(USAGE_OPTIONS, out);
67 fputs(_(" -t, --timing <file> script timing log file\n"), out);
68 fputs(_(" -T, --log-timing <file> alias to -t\n"), out);
69 fputs(_(" -I, --log-in <file> script stdin log file\n"), out);
70 fputs(_(" -B, --log-io <file> script stdin and stdout log file\n"), out);
71
72 fputs(USAGE_SEPARATOR, out);
73 fputs(_(" -c, --command <command> run command rather than interactive shell\n"), out);
74 fputs(_(" -d, --divisor <num> speed up or slow down execution with time divisor\n"), out);
75 fputs(_(" -m, --maxdelay <num> wait at most this many seconds between updates\n"), out);
76 printf(USAGE_HELP_OPTIONS(25));
77
78 printf(USAGE_MAN_TAIL("scriptlive(1)"));
79 exit(EXIT_SUCCESS);
80 }
81
82 static double
83 getnum(const char *s)
84 {
85 const double d = strtod_or_err(s, _("failed to parse number"));
86
87 if (isnan(d)) {
88 errno = EINVAL;
89 err(EXIT_FAILURE, "%s: %s", _("failed to parse number"), s);
90 }
91 return d;
92 }
93
94 static void callback_child_sigstop(
95 void *data __attribute__((__unused__)),
96 pid_t child)
97 {
98 kill(getpid(), SIGSTOP);
99 kill(child, SIGCONT);
100 }
101
102 static int process_next_step(struct scriptlive *ss)
103 {
104 int rc = 0, fd = ul_pty_get_childfd(ss->pty);
105
106 /* read next step(s) */
107 do {
108 struct timeval *delay;
109
110 rc = replay_get_next_step(ss->setup, "I", &ss->step);
111 if (rc == 1) {
112 ul_pty_write_eof_to_child(ss->pty);
113 rc = 0;
114 break;
115 }
116 if (rc)
117 break;
118
119 delay = replay_step_get_delay(ss->step);
120 if (timerisset(delay)) {
121 /* wait until now+delay in mainloop */
122 struct timeval now = { 0 }, target = { 0 };
123
124 gettime_monotonic(&now);
125 timeradd(&now, delay, &target);
126
127 ul_pty_set_mainloop_time(ss->pty, &target);
128 break;
129 }
130
131 /* no delay -- immediately write */
132 rc = replay_emit_step_data(ss->setup, ss->step, fd);
133 fdatasync(fd);
134 } while (rc == 0);
135
136 return rc;
137 }
138
139 static int mainloop_cb(void *data)
140 {
141 struct scriptlive *ss = (struct scriptlive *) data;
142 int rc = 0;
143
144 /* emit previous waiting step */
145 if (ss->step && !replay_step_is_empty(ss->step)) {
146 int fd = ul_pty_get_childfd(ss->pty);;
147
148 rc = replay_emit_step_data(ss->setup, ss->step, fd);
149 fdatasync(fd);
150 if (rc)
151 return rc;
152 }
153
154 return process_next_step(ss);
155 }
156
157 int
158 main(int argc, char *argv[])
159 {
160 static const struct timeval mindelay = { .tv_sec = 0, .tv_usec = 100 };
161 struct timeval maxdelay;
162
163 const char *log_in = NULL, *log_io = NULL, *log_tm = NULL,
164 *shell = NULL, *command = NULL;
165 double divi = 1;
166 int diviopt = FALSE, idx;
167 int ch, caught_signal = 0;
168 struct ul_pty_callbacks *cb;
169 struct scriptlive ss = { .pty = NULL };
170 pid_t child;
171
172 static const struct option longopts[] = {
173 { "command", required_argument, 0, 'c' },
174 { "timing", required_argument, 0, 't' },
175 { "log-timing", required_argument, 0, 'T' },
176 { "log-in", required_argument, 0, 'I'},
177 { "log-io", required_argument, 0, 'B'},
178 { "divisor", required_argument, 0, 'd' },
179 { "maxdelay", required_argument, 0, 'm' },
180 { "version", no_argument, 0, 'V' },
181 { "help", no_argument, 0, 'h' },
182 { NULL, 0, 0, 0 }
183 };
184 static const ul_excl_t excl[] = { /* rows and cols in ASCII order */
185 { 'B', 'I' },
186 { 0 }
187 };
188 int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
189 /* Because we use space as a separator, we can't afford to use any
190 * locale which tolerates a space in a number. In any case, script.c
191 * sets the LC_NUMERIC locale to C, anyway.
192 */
193 setlocale(LC_ALL, "");
194 setlocale(LC_NUMERIC, "C");
195
196 bindtextdomain(PACKAGE, LOCALEDIR);
197 textdomain(PACKAGE);
198 close_stdout_atexit();
199
200 replay_init_debug();
201 timerclear(&maxdelay);
202
203 while ((ch = getopt_long(argc, argv, "c:B:I:T:t:d:m:Vh", longopts, NULL)) != -1) {
204
205 err_exclusive_options(ch, longopts, excl, excl_st);
206
207 switch(ch) {
208 case 'c':
209 command = optarg;
210 break;
211 case 't':
212 case 'T':
213 log_tm = optarg;
214 break;
215 case 'I':
216 log_in = optarg;
217 break;
218 case 'B':
219 log_io = optarg;
220 break;
221 case 'd':
222 diviopt = TRUE;
223 divi = getnum(optarg);
224 break;
225 case 'm':
226 strtotimeval_or_err(optarg, &maxdelay, _("failed to parse maximal delay argument"));
227 break;
228 case 'V':
229 print_version(EXIT_SUCCESS);
230 case 'h':
231 usage();
232 default:
233 errtryhelp(EXIT_FAILURE);
234 }
235 }
236 argc -= optind;
237 argv += optind;
238 idx = 0;
239
240 if (!log_tm && idx < argc)
241 log_tm = argv[idx++];
242 if (!log_in && !log_io && idx < argc)
243 log_in = argv[idx++];
244
245 if (!diviopt)
246 divi = idx < argc ? getnum(argv[idx]) : 1;
247
248 if (!log_tm)
249 errx(EXIT_FAILURE, _("timing file not specified"));
250 if (!(log_in || log_io))
251 errx(EXIT_FAILURE, _("stdin typescript file not specified"));
252
253 ss.setup = replay_new_setup();
254
255 if (replay_set_timing_file(ss.setup, log_tm) != 0)
256 err(EXIT_FAILURE, _("cannot open %s"), log_tm);
257
258 if (log_in && replay_associate_log(ss.setup, "I", log_in) != 0)
259 err(EXIT_FAILURE, _("cannot open %s"), log_in);
260
261 if (log_io && replay_associate_log(ss.setup, "IO", log_io) != 0)
262 err(EXIT_FAILURE, _("cannot open %s"), log_io);
263
264 replay_set_default_type(ss.setup, 'I');
265 replay_set_crmode(ss.setup, REPLAY_CRMODE_NEVER);
266
267 if (divi != 1)
268 replay_set_delay_div(ss.setup, divi);
269 if (timerisset(&maxdelay))
270 replay_set_delay_max(ss.setup, &maxdelay);
271 replay_set_delay_min(ss.setup, &mindelay);
272
273 shell = getenv("SHELL");
274 if (shell == NULL)
275 shell = _PATH_BSHELL;
276
277 fprintf(stdout, _(">>> scriptlive: Starting your typescript execution by %s.\n"),
278 command ? command : shell);
279
280 ul_pty_init_debug(0);
281
282 ss.pty = ul_new_pty(isatty(STDIN_FILENO));
283 if (!ss.pty)
284 err(EXIT_FAILURE, _("failed to allocate PTY handler"));
285
286 ul_pty_set_callback_data(ss.pty, (void *) &ss);
287 cb = ul_pty_get_callbacks(ss.pty);
288 cb->child_sigstop = callback_child_sigstop;
289 cb->mainloop = mainloop_cb;
290
291 if (!isatty(STDIN_FILENO))
292 /* We keep ECHO flag for compatibility with script(1) */
293 ul_pty_slave_echo(ss.pty, 1);
294
295 if (ul_pty_setup(ss.pty))
296 err(EXIT_FAILURE, _("failed to create pseudo-terminal"));
297 if (ul_pty_signals_setup(ss.pty))
298 err(EXIT_FAILURE, _("failed to initialize signals handler"));
299
300 fflush(stdout); /* ??? */
301
302 switch ((int) (child = fork())) {
303 case -1: /* error */
304 ul_pty_cleanup(ss.pty);
305 err(EXIT_FAILURE, _("cannot create child process"));
306 break;
307
308 case 0: /* child */
309 {
310 const char *shname;
311
312 ul_pty_init_slave(ss.pty);
313
314 signal(SIGTERM, SIG_DFL); /* because /etc/csh.login */
315
316 shname = strrchr(shell, '/');
317 shname = shname ? shname + 1 : shell;
318
319 if (access(shell, X_OK) == 0) {
320 if (command)
321 execl(shell, shname, "-c", command, (char *)NULL);
322 else
323 execl(shell, shname, "-i", (char *)NULL);
324 } else {
325 if (command)
326 execlp(shname, shname, "-c", command, (char *)NULL);
327 else
328 execlp(shname, shname, "-i", (char *)NULL);
329 }
330 err(EXIT_FAILURE, "failed to execute %s", shell);
331 break;
332 }
333 default:
334 break;
335 }
336
337 /* parent */
338 ul_pty_set_child(ss.pty, child);
339
340 /* read the first step and set initial delay for pty main loop; the
341 * next steps will be processed by mainloop_cb() */
342 process_next_step(&ss);
343
344 /* this is the main loop */
345 ul_pty_proxy_master(ss.pty);
346
347 /* all done; cleanup and kill */
348 caught_signal = ul_pty_get_delivered_signal(ss.pty);
349
350 if (!caught_signal && ul_pty_get_child(ss.pty) != (pid_t)-1)
351 ul_pty_wait_for_child(ss.pty); /* final wait */
352
353 if (caught_signal && ul_pty_get_child(ss.pty) != (pid_t)-1) {
354 fprintf(stderr, _("\nSession terminated, killing shell..."));
355 kill(child, SIGTERM);
356 sleep(2);
357 kill(child, SIGKILL);
358 fprintf(stderr, " ...killed.\n");
359 }
360
361 ul_pty_cleanup(ss.pty);
362 ul_free_pty(ss.pty);
363 replay_free_setup(ss.setup);
364
365 fprintf(stdout, _("\n>>> scriptlive: done.\n"));
366 return EXIT_SUCCESS;
367 }