[thirdparty/util-linux.git] / term-utils / scriptreplay.c

/*
 * Copyright (C) 2008, Karel Zak <kzak@redhat.com>
 * Copyright (C) 2008, James Youngman <jay@gnu.org>
 *
 * This file 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 of the License, or
 * (at your option) any later version.
 *
 * This file is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 *
 * Based on scriptreplay.pl by Joey Hess <joey@kitenet.net>
 */

#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <limits.h>
#include <math.h>
#include <sys/select.h>
#include <unistd.h>
#include <getopt.h>


#include "c.h"
#include "debug.h"
#include "xalloc.h"
#include "closestream.h"
#include "nls.h"
#include "strutils.h"
#include "optutils.h"

static UL_DEBUG_DEFINE_MASK(scriptreplay);
UL_DEBUG_DEFINE_MASKNAMES(scriptreplay) = UL_DEBUG_EMPTY_MASKNAMES;

#define SCRIPTREPLAY_DEBUG_INIT (1 << 1)
#define SCRIPTREPLAY_DEBUG_TIMING (1 << 2)
#define SCRIPTREPLAY_DEBUG_LOG  (1 << 3)
#define SCRIPTREPLAY_DEBUG_MISC (1 << 4)
#define SCRIPTREPLAY_DEBUG_ALL  0xFFFF

#define DBG(m, x)       __UL_DBG(scriptreplay, SCRIPTREPLAY_DEBUG_, m, x)
#define ON_DBG(m, x)    __UL_DBG_CALL(scriptreplay, SCRIPTREPLAY_DEBUG_, m, x)

#define SCRIPT_MIN_DELAY 0.0001         /* from original sripreplay.pl */

/*
 * The script replay is driven by timing file where each entry describes one
 * step in the replay. The timing step may refer input or output (or
 * signal, extra informations, etc.)
 *
 * The step data are stored in log files, the right log file for the step is
 * selected from replay_setup.
 *
 * TODO: move struct replay_{log,step,setup} to script-playutils.c to make it
 * usable for scriptlive(1) code.
 */

enum {
        REPLAY_TIMING_SIMPLE,           /* timing info in classic "<delta> <offset>" format */
        REPLAY_TIMING_MULTI             /* multiple streams in format "<type> <delta> <offset|etc> */
};

/* CR to '\n' mode */
enum {
        REPLAY_CRMODE_AUTO      = 0,
        REPLAY_CRMODE_NEVER,
        REPLAY_CRMODE_ALWAYS
};

struct replay_log {
        const char      *streams;       /* 'I'nput, 'O'utput or both */
        const char      *filename;
        FILE            *fp;

        unsigned int    noseek;         /* do not seek in this log */
};

struct replay_step {
        char    type;           /* 'I'nput, 'O'utput, ... */
        double  delay;
        size_t  size;

        char    *name;          /* signals / heders */
        char    *value;

        struct replay_log *data;
};

struct replay_setup {
        struct replay_log       *logs;
        size_t                  nlogs;

        struct replay_step      step;   /* current step */

        FILE                    *timing_fp;
        const char              *timing_filename;
        int                     timing_format;
        int                     timing_line;

        char                    default_type;   /* type for REPLAY_TIMING_SIMPLE */
        int                     crmode;
};

static void scriptreplay_init_debug(void)
{
        __UL_INIT_DEBUG_FROM_ENV(scriptreplay, SCRIPTREPLAY_DEBUG_, 0, SCRIPTREPLAY_DEBUG);
}

static int ignore_line(FILE *f)
{
        int c;

        while((c = fgetc(f)) != EOF && c != '\n');
        if (ferror(f))
                return -errno;

        DBG(LOG, ul_debug("  ignore line"));
        return 0;
}

/* if timing file does not contains types of entries (old format) than use this
 * type as the default */
static int replay_set_default_type(struct replay_setup *stp, char type)
{
        assert(stp);
        stp->default_type = type;

        return 0;
}

static int replay_set_crmode(struct replay_setup *stp, int mode)
{
        assert(stp);
        stp->crmode = mode;

        return 0;
}

static struct replay_log *replay_new_log(struct replay_setup *stp,
                                         const char *streams,
                                         const char *filename,
                                         FILE *f)
{
        struct replay_log *log;

        assert(stp);
        assert(streams);
        assert(filename);

        stp->logs = xrealloc(stp->logs, (stp->nlogs + 1) *  sizeof(*log));
        log = &stp->logs[stp->nlogs];
        stp->nlogs++;

        log->filename = filename;
        log->streams = streams;
        log->fp = f;

        return log;
}

static int replay_set_timing_file(struct replay_setup *stp, const char *filename)
{
        int c, rc = 0;

        assert(stp);
        assert(filename);

        stp->timing_filename = filename;
        stp->timing_line = 0;

        stp->timing_fp = fopen(filename, "r");
        if (!stp->timing_fp)
                rc = -errno;
        else {
                /* detect timing file format */
                c = fgetc(stp->timing_fp);
                if (c != EOF) {
                        if (isdigit((unsigned int) c))
                                stp->timing_format = REPLAY_TIMING_SIMPLE;
                        else
                                stp->timing_format = REPLAY_TIMING_MULTI;
                        ungetc(c, stp->timing_fp);
                } else if (ferror(stp->timing_fp))
                        rc = -errno;
        }

        if (rc && stp->timing_fp) {
                fclose(stp->timing_fp);
                stp->timing_fp = NULL;
        }

        /* create quasi-log for signals, headers, etc. */
        if (rc == 0 && stp->timing_format == REPLAY_TIMING_MULTI) {
                struct replay_log *log = replay_new_log(stp, "SH",
                                                filename, stp->timing_fp);
                if (!log)
                        rc = -ENOMEM;
                else {
                        log->noseek = 1;
                        DBG(LOG, ul_debug("accociate log file '%s' with 'SH'", filename));
                }
        }

        DBG(TIMING, ul_debug("timing file set to '%s' [rc=%d]", filename, rc));
        return rc;
}


static int replay_associate_log(struct replay_setup *stp,
                                const char *streams, const char *filename)
{
        FILE *f;
        int rc;

        assert(stp);
        assert(streams);
        assert(filename);

        /* open the file and skip the first line */
        f = fopen(filename, "r");
        rc = f == NULL ? -errno : ignore_line(f);

        if (rc == 0)
                replay_new_log(stp, streams, filename, f);

        DBG(LOG, ul_debug("accociate log file '%s' with '%s' [rc=%d]", filename, streams, rc));
        return rc;
}

static int is_wanted_stream(char type, const char *streams)
{
        if (streams == NULL)
                return 1;
        if (strchr(streams, type))
                return 1;
        return 0;
}

static void replay_reset_step(struct replay_step *step)
{
        assert(step);

        step->size = 0;
        step->delay = 0;
        step->data = NULL;
        step->type = 0;
}

static int read_multistream_step(struct replay_step *step, FILE *f, char type)
{
        int rc = 0;
        char nl;


        switch (type) {
        case 'O': /* output */
        case 'I': /* input */
                rc = fscanf(f, "%lf %zu%c\n", &step->delay, &step->size, &nl);
                if (rc != 3 || nl != '\n')
                        rc = -EINVAL;
                else
                        rc = 0;
                break;

        case 'S': /* signal */
        case 'H': /* header */
        {
                char buf[BUFSIZ];

                rc = fscanf(f, "%lf ", &step->delay);   /* delay */
                if (rc != 1)
                        break;

                rc = fscanf(f, "%s", buf);              /* name */
                if (rc != 1)
                        break;
                step->name = strrealloc(step->name, buf);
                if (!step->name)
                        err_oom();

                if (!fgets(buf, sizeof(buf), f)) {      /* value */
                        rc = -errno;
                        break;
                }
                if (*buf) {
                        strrem(buf, '\n');
                        step->value = strrealloc(step->value, buf);
                        if (!step->value)
                                err_oom();
                }
                rc = 0;
                break;
        }
        default:
                break;
        }

        DBG(TIMING, ul_debug(" read step delay & size [rc=%d]", rc));
        return rc;
}

static struct replay_log *replay_get_stream_log(struct replay_setup *stp, char stream)
{
        size_t i;

        for (i = 0; i < stp->nlogs; i++) {
                struct replay_log *log = &stp->logs[i];

                if (is_wanted_stream(stream, log->streams))
                        return log;
        }
        return NULL;
}

static int replay_seek_log(struct replay_log *log, size_t move)
{
        if (log->noseek)
                return 0;

        DBG(LOG, ul_debug(" %s: seek ++ %zu", log->filename, move));
        return fseek(log->fp, move, SEEK_CUR) == (off_t) -1 ? -errno : 0;
}

/* returns next step with pointer to the right log file for specified streams (e.g.
 * "IOS" for in/out/signals) or all streams if stream is NULL.
 *
 * returns: 0 = success, <0 = error, 1 = done (EOF)
 */
static int replay_get_next_step(struct replay_setup *stp, char *streams, struct replay_step **xstep)
{
        struct replay_step *step;
        int rc;
        double ignored_delay = 0;

        assert(stp);
        assert(stp->timing_fp);
        assert(xstep && *xstep);

        step = &stp->step;
        *xstep = NULL;

        do {
                struct replay_log *log = NULL;

                rc = 1; /* done */
                if (feof(stp->timing_fp))
                        break;

                DBG(TIMING, ul_debug("reading next step"));

                replay_reset_step(step);
                stp->timing_line++;

                switch (stp->timing_format) {
                case REPLAY_TIMING_SIMPLE:
                        /* old format is the same as new format, but without <type> prefix */
                        rc = read_multistream_step(step, stp->timing_fp, stp->default_type);
                        if (rc == 0)
                                step->type = stp->default_type;
                        break;
                case REPLAY_TIMING_MULTI:
                        rc = fscanf(stp->timing_fp, "%c ", &step->type);
                        if (rc != 1)
                                rc = -EINVAL;
                        else
                                rc = read_multistream_step(step,
                                                stp->timing_fp,
                                                step->type);
                        break;
                }

                if (rc)
                        break;;         /* error */

                DBG(TIMING, ul_debug(" step entry is '%c'", step->type));

                log = replay_get_stream_log(stp, step->type);
                if (log) {
                        if (is_wanted_stream(step->type, streams)) {
                                step->data = log;
                                *xstep = step;
                                DBG(LOG, ul_debug(" use %s as data source", log->filename));
                                goto done;
                        }
                        /* The step entry is unwanted, but we keep the right
                         * position in the log file although the data are ignored.
                         */
                        replay_seek_log(log, step->size);
                } else
                        DBG(TIMING, ul_debug(" not found log for '%c' stream", step->type));

                DBG(TIMING, ul_debug(" ignore step '%c' [delay=%f]",
                                        step->type, step->delay));
                ignored_delay += step->delay;
        } while (rc == 0);

done:
        if (ignored_delay)
                step->delay += ignored_delay;

        DBG(TIMING, ul_debug("reading next step done [rc=%d delay=%f (ignored=%f) size=%zu]",
                                rc, step->delay, ignored_delay, step->size));
        return rc;
}

/* return: 0 = success, <0 = error, 1 = done (EOF) */
static int replay_emit_step_data(struct replay_setup *stp, struct replay_step *step, int fd)
{
        size_t ct;
        int rc = 0, cr2nl = 0;
        char buf[BUFSIZ];

        assert(stp);
        assert(step);
        switch (step->type) {
        case 'S':
                assert(step->name);
                assert(step->value);
                dprintf(fd, "%s %s\n", step->name, step->value);
                DBG(LOG, ul_debug("log signal emited"));
                return 0;
        case 'H':
                assert(step->name);
                assert(step->value);
                dprintf(fd, "%10s: %s\n", step->name, step->value);
                DBG(LOG, ul_debug("log signal emited"));
                return 0;
        default:
                break;          /* continue with real data */
        }

        assert(step->size);
        assert(step->data);
        assert(step->data->fp);

        switch (stp->crmode) {
        case REPLAY_CRMODE_AUTO:
                if (step->type == 'I')
                        cr2nl = 1;
                break;
        case REPLAY_CRMODE_NEVER:
                cr2nl = 0;
                break;
        case REPLAY_CRMODE_ALWAYS:
                cr2nl = 1;
                break;
        }

        for (ct = step->size; ct > 0; ) {
                size_t len, cc;

                cc = ct > sizeof(buf) ? sizeof(buf): ct;
                len = fread(buf, 1, cc, step->data->fp);

                if (!len) {
                        DBG(LOG, ul_debug("log data emit: failed to read log %m"));
                        break;
                }

                if (cr2nl) {
                        size_t i;

                        for (i = 0; i < len; i++) {
                                if (buf[i] == 0x0D)
                                        buf[i] = '\n';
                        }
                }

                ct -= len;
                cc = write(fd, buf, len);
                if (cc != len) {
                        rc = -errno;
                        DBG(LOG, ul_debug("log data emit: failed write data %m"));
                        break;
                }
        }

        if (ct && ferror(step->data->fp))
                rc = -errno;
        if (ct && feof(step->data->fp))
                rc = 1;

        DBG(LOG, ul_debug("log data emited [rc=%d size=%zu]", rc, step->size));
        return rc;
}

static void __attribute__((__noreturn__))
usage(void)
{
        FILE *out = stdout;
        fputs(USAGE_HEADER, out);
        fprintf(out,
              _(" %s [options]\n"),
              program_invocation_short_name);
        fprintf(out,
              _(" %s [-t] timingfile [typescript] [divisor]\n"),
              program_invocation_short_name);

        fputs(USAGE_SEPARATOR, out);
        fputs(_("Play back terminal typescripts, using timing information.\n"), out);

        fputs(USAGE_OPTIONS, out);
        fputs(_(" -t, --timing <file>     script timing log file\n"), out);
        fputs(_(" -I, --log-in <file>     script stdin log file\n"), out);
        fputs(_(" -O, --log-out <file>    script stdout log file (default)\n"), out);
        fputs(_(" -B, --log-io <file>     script stdin and stdout log file\n"), out);
        fputs(_(" -s, --typescript <file> deprecated alist to -O\n"), out);

        fputs(USAGE_SEPARATOR, out);
        fputs(_(" -d, --divisor <num>     speed up or slow down execution with time divisor\n"), out);
        fputs(_(" -m, --maxdelay <num>    wait at most this many seconds between updates\n"), out);
        fputs(_(" -x, --stream <name>     stream type (out, in, signal or info)\n"), out);
        fputs(_(" -c, --cr-mode <type>    CR char mode (auto, never, always)\n"), out);
        printf(USAGE_HELP_OPTIONS(25));

        printf(USAGE_MAN_TAIL("scriptreplay(1)"));
        exit(EXIT_SUCCESS);
}

static double
getnum(const char *s)
{
        const double d = strtod_or_err(s, _("failed to parse number"));

        if (isnan(d)) {
                errno = EINVAL;
                err(EXIT_FAILURE, "%s: %s", _("failed to parse number"), s);
        }
        return d;
}

static void
delay_for(double delay)
{
#ifdef HAVE_NANOSLEEP
        struct timespec ts, remainder;
        ts.tv_sec = (time_t) delay;
        ts.tv_nsec = (delay - ts.tv_sec) * 1.0e9;

        DBG(TIMING, ul_debug("going to sleep for %fs", delay));

        while (-1 == nanosleep(&ts, &remainder)) {
                if (EINTR == errno)
                        ts = remainder;
                else
                        break;
        }
#else
        struct timeval tv;
        tv.tv_sec = (long) delay;
        tv.tv_usec = (delay - tv.tv_sec) * 1.0e6;
        select(0, NULL, NULL, NULL, &tv);
#endif
}

static void appendchr(char *buf, size_t bufsz, int c)
{
        size_t sz;

        if (strchr(buf, c))
                return;         /* already in */

        sz = strlen(buf);
        if (sz + 1 < bufsz)
                buf[sz] = c;
}

int
main(int argc, char *argv[])
{
        struct replay_setup setup = { .nlogs = 0 };
        struct replay_step *step;
        char streams[6] = {0};          /* IOSI - in, out, signal,info */
        const char *log_out = NULL,
                   *log_in = NULL,
                   *log_io = NULL,
                   *log_tm = NULL;
        double divi = 1, maxdelay = 0;
        int diviopt = FALSE, maxdelayopt = FALSE, idx;
        int ch, rc, crmode = REPLAY_CRMODE_AUTO;

        static const struct option longopts[] = {
                { "cr-mode",    required_argument,      0, 'c' },
                { "timing",     required_argument,      0, 't' },
                { "log-in",     required_argument,      0, 'I'},
                { "log-out",    required_argument,      0, 'O'},
                { "log-io",     required_argument,      0, 'B'},
                { "typescript", required_argument,      0, 's' },
                { "divisor",    required_argument,      0, 'd' },
                { "maxdelay",   required_argument,      0, 'm' },
                { "stream",     required_argument,      0, 'x' },
                { "version",    no_argument,            0, 'V' },
                { "help",       no_argument,            0, 'h' },
                { NULL,         0, 0, 0 }
        };
        static const ul_excl_t excl[] = {       /* rows and cols in ASCII order */
                { 'O', 's' },
                { 0 }
        };
        int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
        /* Because we use space as a separator, we can't afford to use any
         * locale which tolerates a space in a number.  In any case, script.c
         * sets the LC_NUMERIC locale to C, anyway.
         */
        setlocale(LC_ALL, "");
        setlocale(LC_NUMERIC, "C");

        bindtextdomain(PACKAGE, LOCALEDIR);
        textdomain(PACKAGE);
        close_stdout_atexit();

        scriptreplay_init_debug();

        while ((ch = getopt_long(argc, argv, "B:c:I:O:t:s:d:m:x:Vh", longopts, NULL)) != -1) {

                err_exclusive_options(ch, longopts, excl, excl_st);

                switch(ch) {
                case 'c':
                        if (strcmp("auto", optarg) == 0)
                                crmode = REPLAY_CRMODE_AUTO;
                        else if (strcmp("never", optarg) == 0)
                                crmode = REPLAY_CRMODE_NEVER;
                        else if (strcmp("always", optarg) == 0)
                                crmode = REPLAY_CRMODE_ALWAYS;
                        else
                                errx(EXIT_FAILURE, _("unsupported mode name: '%s'"), optarg);
                        break;
                case 't':
                        log_tm = optarg;
                        break;
                case 'O':
                case 's':
                        log_out = optarg;
                        break;
                case 'I':
                        log_in = optarg;
                        break;
                case 'B':
                        log_io = optarg;
                        break;
                case 'd':
                        diviopt = TRUE;
                        divi = getnum(optarg);
                        break;
                case 'm':
                        maxdelayopt = TRUE;
                        maxdelay = getnum(optarg);
                        break;
                case 'x':
                        if (strcmp("in", optarg) == 0)
                                appendchr(streams, sizeof(streams), 'I');
                        else if (strcmp("out", optarg) == 0)
                                appendchr(streams, sizeof(streams), 'O');
                        else if (strcmp("signal", optarg) == 0)
                                appendchr(streams, sizeof(streams), 'S');
                        else if (strcmp("info", optarg) == 0)
                                appendchr(streams, sizeof(streams), 'H');
                        else
                                errx(EXIT_FAILURE, _("unsupported stream name: '%s'"), optarg);
                        break;
                case 'V':
                        print_version(EXIT_SUCCESS);
                case 'h':
                        usage();
                default:
                        errtryhelp(EXIT_FAILURE);
                }
        }
        argc -= optind;
        argv += optind;
        idx = 0;

        if (!log_tm && idx < argc)
                log_tm = argv[idx++];
        if (!log_out && !log_in && !log_io)
                log_out = idx < argc ? argv[idx++] : "typescript";

        if (!diviopt)
                divi = idx < argc ? getnum(argv[idx]) : 1;
        if (maxdelay < 0)
                maxdelay = 0;

        if (!log_tm)
                errx(EXIT_FAILURE, _("timing file not specified"));
        if (!(log_out || log_in || log_io))
                errx(EXIT_FAILURE, _("data log file not specified"));

        if (replay_set_timing_file(&setup, log_tm) != 0)
                err(EXIT_FAILURE, _("cannot open %s"), log_tm);

        if (log_out && replay_associate_log(&setup, "O", log_out) != 0)
                err(EXIT_FAILURE, _("cannot open %s"), log_out);

        if (log_in && replay_associate_log(&setup, "I", log_in) != 0)
                err(EXIT_FAILURE, _("cannot open %s"), log_in);

        if (log_io && replay_associate_log(&setup, "IO", log_io) != 0)
                err(EXIT_FAILURE, _("cannot open %s"), log_io);

        if (!*streams) {
                /* output is prefered default */
                if (log_out || log_io)
                        appendchr(streams, sizeof(streams), 'O');
                else if (log_in)
                        appendchr(streams, sizeof(streams), 'I');
        }

        replay_set_default_type(&setup,
                        *streams && streams[1] == '\0' ? *streams : 'O');
        replay_set_crmode(&setup, crmode);

        do {
                rc = replay_get_next_step(&setup, streams, &step);
                if (rc)
                        break;

                step->delay /= divi;
                if (maxdelayopt && step->delay > maxdelay)
                        step->delay = maxdelay;
                if (step->delay > SCRIPT_MIN_DELAY)
                        delay_for(step->delay);

                rc = replay_emit_step_data(&setup, step, STDOUT_FILENO);
        } while (rc == 0);

        if (step && rc < 0)
                err(EXIT_FAILURE, _("%s: log file error"), step->data->filename);
        else if (rc < 0)
                err(EXIT_FAILURE, _("%s: line %d: timing file error"),
                                setup.timing_filename,
                                setup.timing_line);
        printf("\n");
        exit(EXIT_SUCCESS);
}