GCOV - Varnish Cache


/*-
 * Copyright (c) 2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Dridi Boukelmoune <dridi@varnish-software.com>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * XXX:
 *      -ignore-stderr (otherwise output to stderr is fail)
 */

#include "config.h"

#include <sys/ioctl.h>          // Linux: struct winsize

#include <ctype.h>
#include <fcntl.h>
#include <inttypes.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef __sun
#  include <stropts.h>
#endif
#include <termios.h>
#include <unistd.h>

#include "vtc.h"

#include "vre.h"
#include "vev.h"
#include "vlu.h"
#include "vsb.h"
#include "vsub.h"
#include "vtim.h"

#include "teken.h"

struct process {
        unsigned                magic;
#define PROCESS_MAGIC           0x1617b43e
        char                    *name;
        struct vtclog           *vl;
        VTAILQ_ENTRY(process)   list;

        char                    *spec;
        char                    *dir;
        char                    *out;
        char                    *err;
        int                     fd_term;
        int                     fd_stderr;
        int                     f_stdout;
        int                     f_stderr;
        struct vlu              *vlu_stdout;
        struct vlu              *vlu_stderr;
        int                     log;
        pid_t                   pid;
        int                     expect_exit;
        int                     expect_signal;
        int                     allow_core;

        uintmax_t               stdout_bytes;
        uintmax_t               stderr_bytes;

        pthread_mutex_t         mtx;
        pthread_t               tp;
        unsigned                hasthread;

        int                     nlin;
        int                     ncol;
        int                     ansi_response;
        char                    **vram;
        teken_t                 tek[1];
};

static VTAILQ_HEAD(, process)   processes =
    VTAILQ_HEAD_INITIALIZER(processes);

static void term_resize(struct process *pp, int lin, int col);

/**********************************************************************
 * Terminal emulation
 */

static void
term_cursor(void *priv, const teken_pos_t *pos)
{
        (void)priv;
        (void)pos;
}

static void
term_putchar(void *priv, const teken_pos_t *pos, teken_char_t ch,
    const teken_attr_t *at)
{
        struct process *pp;

        CAST_OBJ_NOTNULL(pp, priv, PROCESS_MAGIC);
        (void)at;
        if (ch > 126 || ch < 32)
                ch = '?';
        assert(pos->tp_row < pp->nlin);
        assert(pos->tp_col < pp->ncol);
        pp->vram[pos->tp_row][pos->tp_col] = ch;
}

static void
term_fill(void *priv, const teken_rect_t *r, teken_char_t c,
    const teken_attr_t *a)
{
        teken_pos_t p;

        /* Braindead implementation of fill() - just call putchar(). */
        for (p.tp_row = r->tr_begin.tp_row;
            p.tp_row < r->tr_end.tp_row; p.tp_row++)
                for (p.tp_col = r->tr_begin.tp_col;
                    p.tp_col < r->tr_end.tp_col; p.tp_col++)
                        term_putchar(priv, &p, c, a);
}

static void
term_copy(void *priv, const teken_rect_t *r, const teken_pos_t *p)
{
        struct process *pp;
        int nrow, ncol, y; /* Has to be signed - >= 0 comparison */

        /*
         * Copying is a little tricky. We must make sure we do it in
         * correct order, to make sure we don't overwrite our own data.
         */
        CAST_OBJ_NOTNULL(pp, priv, PROCESS_MAGIC);

        nrow = r->tr_end.tp_row - r->tr_begin.tp_row;
        ncol = r->tr_end.tp_col - r->tr_begin.tp_col;

        if (p->tp_row < r->tr_begin.tp_row) {
                /* Copy from top to bottom. */
                for (y = 0; y < nrow; y++)
                        memmove(&pp->vram[p->tp_row + y][p->tp_col],
                            &pp->vram[r->tr_begin.tp_row + y][r->tr_begin.tp_col], ncol);
        } else {
                /* Copy from bottom to top. */
                for (y = nrow - 1; y >= 0; y--)
                        memmove(&pp->vram[p->tp_row + y][p->tp_col],
                            &pp->vram[r->tr_begin.tp_row + y][r->tr_begin.tp_col], ncol);
        }
}

static void
term_respond(void *priv, const void *p, size_t l)
{
        struct process *pp;
        int r;

        CAST_OBJ_NOTNULL(pp, priv, PROCESS_MAGIC);

        vtc_dump(pp->vl, 4, "term_response", p, l);
        if (pp->ansi_response) {
                r = write(pp->fd_term, p, l);
                if (r != l)
                        vtc_fatal(pp->vl, "Could not write to process: %s",
                            strerror(errno));
        }
}

static void
term_param(void *priv, int p, unsigned int v)
{
        struct process *pp;

        CAST_OBJ_NOTNULL(pp, priv, PROCESS_MAGIC);
        if (p == TP_132COLS && v)
                term_resize(pp, pp->nlin, 132);
        if (p == TP_132COLS && !v)
                term_resize(pp, pp->nlin, 80);
}

static const teken_funcs_t process_teken_func = {
        .tf_cursor      =       term_cursor,
        .tf_putchar     =       term_putchar,
        .tf_fill        =       term_fill,
        .tf_copy        =       term_copy,
        .tf_respond     =       term_respond,
        .tf_param       =       term_param,
};

static void
term_screen_dump(const struct process *pp)
{
        int i;
        const teken_pos_t *pos;

        for (i = 0; i < pp->nlin; i++)
                vtc_dump(pp->vl, 3, "screen", pp->vram[i], pp->ncol);
        pos = teken_get_cursor(pp->tek);
        vtc_log(pp->vl, 3, "Cursor at line %d column %d",
            pos->tp_row + 1, pos->tp_col + 1);
}

static void
term_resize(struct process *pp, int lin, int col)
{
        teken_pos_t pos;
        char **vram;
        int i, j;

        vram = calloc(lin, sizeof *pp->vram);
        AN(vram);
        for (i = 0; i < lin; i++) {
                vram[i] = calloc(col + 1L, 1);
                AN(vram[i]);
                memset(vram[i], ' ', col);
                vram[i][col] = '\0';
        }
        if (pp->vram != NULL) {
                for (i = 0; i < lin; i++) {
                        if (i >= pp->nlin)
                                break;
                        j = col;
                        if (j > pp->ncol)
                                j = pp->ncol;
                        memcpy(vram[i], pp->vram[i], j);
                }
                for (i = 0; i < pp->nlin; i++)
                        free(pp->vram[i]);
                free(pp->vram);
        }
        pp->vram = vram;
        pp->nlin = lin;
        pp->ncol = col;

        pos.tp_row = lin;
        pos.tp_col = col;
        teken_set_winsize(pp->tek, &pos);
}

static int
term_find_textline(const struct process *pp, int *x, int y, const char *pat)
{
        const char *t;
        int l;

        if (*x == 0) {
                t = strstr(pp->vram[y], pat);
                if (t != NULL) {
                        *x = 1 + (t - pp->vram[y]);
                        return (1);
                }
        } else if (*x <= pp->ncol) {
                t = pp->vram[y] + *x - 1;
                l = strlen(pat);
                assert((*x - 1) + (l - 1) < pp->ncol);
                if (!memcmp(t, pat, l))
                        return (1);
        }
        return (0);
}

static int
term_find_text(const struct process *pp, int *x, int *y, const char *pat)
{
        int yy;

        if (*y == 0) {
                for (yy = 0; yy < pp->nlin; yy++) {
                        if (term_find_textline(pp, x, yy, pat)) {
                                *y = yy + 1;
                                return (1);
                        }
                }
        } else if (*y <= pp->nlin) {
                if (term_find_textline(pp, x, *y - 1, pat))
                        return (1);
        }
        return (0);
}

static void
term_expect_text(struct process *pp,
    const char *lin, const char *col, const char *pat)
{
        int x, y, l, d = 10000;
        char *t;

        y = strtoul(lin, NULL, 0);
        if (y < 0 || y > pp->nlin)
                vtc_fatal(pp->vl, "YYY %d nlin %d", y, pp->nlin);
        x = strtoul(col, NULL, 0);
        for(l = 0; l <= 10 && x > pp->ncol; l++)        // wait for screen change
                VTIM_sleep(0.1);
        if (x < 0 || x > pp->ncol)
                vtc_fatal(pp->vl, "XXX %d ncol %d", x, pp->ncol);
        l = strlen(pat);
        if (x + l - 1 > pp->ncol)
                vtc_fatal(pp->vl, "XXX %d ncol %d", x + l - 1, pp->ncol);
        PTOK(pthread_mutex_lock(&pp->mtx));
        while (!term_find_text(pp, &x, &y, pat)) {
                if (x != 0 && y != 0) {
                        t = pp->vram[y - 1] + x - 1;
                        vtc_log(pp->vl, 4,
                            "text at %d,%d: '%.*s'", y, x, l, t);
                }
                PTOK(pthread_mutex_unlock(&pp->mtx));
                usleep(d);
                PTOK(pthread_mutex_lock(&pp->mtx));
                if (d < 3000000)
                        d += d;
        }
        PTOK(pthread_mutex_unlock(&pp->mtx));
        vtc_log(pp->vl, 4, "found expected text at %d,%d: '%s'", y, x, pat);
}

static void
term_expect_cursor(const struct process *pp, const char *lin, const char *col)
{
        int x, y, l;
        const teken_pos_t *pos;

        pos = teken_get_cursor(pp->tek);
        y = strtoul(lin, NULL, 0);
        if (y < 0 || y > pp->nlin)
                vtc_fatal(pp->vl, "YYY %d nlin %d", y, pp->nlin);
        x = strtoul(col, NULL, 0);
        for(l = 0; l < 10 && x > pp->ncol; l++) // wait for screen change
                VTIM_sleep(0.1);
        if (x < 0 || x > pp->ncol)
                vtc_fatal(pp->vl, "XXX %d ncol %d", x, pp->ncol);
        if (y != 0 && (y-1) != pos->tp_row)
                vtc_fatal(pp->vl, "Cursor on line %d (expected %d)",
                    pos->tp_row + 1, y);
        if (x != 0 && (x-1) != pos->tp_col)
                vtc_fatal(pp->vl, "Cursor in column %d (expected %d)",
                    pos->tp_col + 1, y);
}

static void
term_match_text(struct process *pp,
    const char *lin, const char *col, const char *re)
{
        int i, l, err, erroff;
        struct vsb *vsb, re_vsb[1];
        size_t len;
        ssize_t x, y;
        vre_t *vre;
        char errbuf[VRE_ERROR_LEN];

        vsb = VSB_new_auto();
        AN(vsb);

        y = strtoul(lin, NULL, 0);
        if (y < 0 || y > pp->nlin)
                vtc_fatal(pp->vl, "YYY %zd nlin %d", y, pp->nlin);
        x = strtoul(col, NULL, 0);
        for(l = 0; l < 10 && x > pp->ncol; l++) // wait for screen change
                VTIM_sleep(0.1);
        if (x < 0 || x > pp->ncol)
                vtc_fatal(pp->vl, "XXX %zd ncol %d", x, pp->ncol);

        if (x)
                x--;

        if (y)
                y--;

        vre = VRE_compile(re, 0, &err, &erroff, 1);
        if (vre == NULL) {
                AN(VSB_init(re_vsb, errbuf, sizeof errbuf));
                AZ(VRE_error(re_vsb, err));
                AZ(VSB_finish(re_vsb));
                VSB_fini(re_vsb);
                vtc_fatal(pp->vl, "invalid regexp \"%s\" at %d (%s)",
                    re, erroff, errbuf);
        }

        PTOK(pthread_mutex_lock(&pp->mtx));

        len = (pp->nlin - y) * (pp->ncol - x);
        for (i = y; i < pp->nlin; i++) {
                VSB_bcat(vsb, &pp->vram[i][x], pp->ncol - x);
                VSB_putc(vsb, '\n');
        }

        AZ(VSB_finish(vsb));

        if (VRE_match(vre, VSB_data(vsb), len, 0, NULL) < 1)
                vtc_fatal(pp->vl, "match failed: (\"%s\")", re);
        else
                vtc_log(pp->vl, 4, "match succeeded");

        PTOK(pthread_mutex_unlock(&pp->mtx));
        VSB_destroy(&vsb);
        VRE_free(&vre);
}

/**********************************************************************
 * Allocate and initialize a process
 */

#define PROCESS_EXPAND(field, format, ...)                              \
        do {                                                            \
                vsb = macro_expandf(p->vl, format, __VA_ARGS__);        \
                AN(vsb);                                                \
                p->field = strdup(VSB_data(vsb));                       \
                AN(p->field);                                           \
                VSB_destroy(&vsb);                                      \
        } while (0)

static void
process_coverage(struct process *p)
{
        const teken_attr_t *a;
        teken_pos_t pos;
        int fg, bg;

        // Code-Coverage of Teken

        (void)teken_get_sequence(p->tek, TKEY_UP);
        (void)teken_get_sequence(p->tek, TKEY_F1);
        (void)teken_256to8(0);
        (void)teken_256to16(0);
        a = teken_get_defattr(p->tek);
        teken_set_defattr(p->tek, a);
        a = teken_get_curattr(p->tek);
        teken_set_curattr(p->tek, a);
        (void)teken_get_winsize(p->tek);
        pos.tp_row = 0;
        pos.tp_col = 8;
        teken_set_cursor(p->tek, &pos);
        teken_get_defattr_cons25(p->tek, &fg, &bg);
}

static struct process *
process_new(const char *name)
{
        struct process *p;
        struct vsb *vsb;
        char buf[1024];

        ALLOC_OBJ(p, PROCESS_MAGIC);
        AN(p);
        REPLACE(p->name, name);
        PTOK(pthread_mutex_init(&p->mtx, NULL));

        p->vl = vtc_logopen("%s", name);
        AN(p->vl);

        PROCESS_EXPAND(dir, "${tmpdir}/%s", name);
        PROCESS_EXPAND(out, "${tmpdir}/%s/term", name);
        PROCESS_EXPAND(err, "${tmpdir}/%s/stderr", name);

        bprintf(buf, "rm -rf %s ; mkdir -p %s ; touch %s %s",
            p->dir, p->dir, p->out, p->err);
        AZ(system(buf));

        p->fd_term = -1;

        VTAILQ_INSERT_TAIL(&processes, p, list);
        teken_init(p->tek, &process_teken_func, p);
        term_resize(p, 24, 80);
        process_coverage(p);
        return (p);
}

#undef PROCESS_EXPAND

/**********************************************************************
 * Clean up process
 */

static void
process_delete(struct process *p)
{
        int i;

        CHECK_OBJ_NOTNULL(p, PROCESS_MAGIC);
        PTOK(pthread_mutex_destroy(&p->mtx));
        vtc_logclose(p->vl);
        free(p->name);
        free(p->dir);
        free(p->out);
        free(p->err);

        for (i = 0; i < p->nlin; i++)
                free(p->vram[i]);
        free(p->vram);

        /*
         * We do not delete the directory, it may contain useful stdout
         * and stderr files. They will be deleted on account of belonging
         * to the test's tmpdir.
         */

        /* XXX: MEMLEAK (?) */
        FREE_OBJ(p);
}

static void
process_undef(const struct process *p)
{
        CHECK_OBJ_NOTNULL(p, PROCESS_MAGIC);

        macro_undef(p->vl, p->name, "dir");
        macro_undef(p->vl, p->name, "out");
        macro_undef(p->vl, p->name, "err");
}

/**********************************************************************
 * Data stream handling
 */

static int
process_vlu_func(void *priv, const char *l)
{
        struct process *p;

        CAST_OBJ_NOTNULL(p, priv, PROCESS_MAGIC);
        vtc_dump(p->vl, 4, "output", l, -1);
        return (0);
}

static int v_matchproto_(vev_cb_f)
process_stdout(const struct vev *ev, int what)
{
        struct process *p;
        char buf[BUFSIZ];
        int i;

        CAST_OBJ_NOTNULL(p, ev->priv, PROCESS_MAGIC);
        (void)what;
        i = read(p->fd_term, buf, sizeof buf);
        if (i <= 0) {
                vtc_log(p->vl, 4, "stdout read %d", i);
                return (1);
        }
        PTOK(pthread_mutex_lock(&p->mtx));
        p->stdout_bytes += i;
        PTOK(pthread_mutex_unlock(&p->mtx));
        if (p->log == 1)
                (void)VLU_Feed(p->vlu_stdout, buf, i);
        else if (p->log == 2)
                vtc_dump(p->vl, 4, "stdout", buf, i);
        else if (p->log == 3)
                vtc_hexdump(p->vl, 4, "stdout", buf, i);
        assert(write(p->f_stdout, buf, i) == i);
        PTOK(pthread_mutex_lock(&p->mtx));
        teken_input(p->tek, buf, i);
        PTOK(pthread_mutex_unlock(&p->mtx));
        return (0);
}

static int v_matchproto_(vev_cb_f)
process_stderr(const struct vev *ev, int what)
{
        struct process *p;
        char buf[BUFSIZ];
        int i;

        CAST_OBJ_NOTNULL(p, ev->priv, PROCESS_MAGIC);
        (void)what;
        i = read(p->fd_stderr, buf, sizeof buf);
        if (i <= 0) {
                vtc_log(p->vl, 4, "stderr read %d", i);
                return (1);
        }
        PTOK(pthread_mutex_lock(&p->mtx));
        p->stderr_bytes += i;
        PTOK(pthread_mutex_unlock(&p->mtx));
        vtc_dump(p->vl, 4, "stderr", buf, i);
        assert(write(p->f_stderr, buf, i) == i);
        return (0);
}

static void
process_cleanup(void *priv)
{
        struct vev_root *evb = priv;
        VEV_Destroy(&evb);
}

static void *
process_thread(void *priv)
{
        struct process *p;
        struct vev_root *evb;
        struct vev *ev;
        int r;

        CAST_OBJ_NOTNULL(p, priv, PROCESS_MAGIC);

        p->f_stdout = open(p->out, O_WRONLY|O_APPEND);
        assert(p->f_stdout >= 0);
        p->f_stderr = open(p->err, O_WRONLY|O_APPEND);
        assert(p->f_stderr >= 0);

        evb = VEV_New();
        AN(evb);
        pthread_cleanup_push(process_cleanup, evb);

        ev = VEV_Alloc();
        AN(ev);
        ev->fd = p->fd_term;
        ev->fd_flags = VEV__RD | VEV__HUP | VEV__ERR;
        ev->callback = process_stdout;
        ev->priv = p;
        AZ(VEV_Start(evb, ev));

        ev = VEV_Alloc();
        AN(ev);
        ev->fd = p->fd_stderr;
        ev->fd_flags = VEV__RD | VEV__HUP | VEV__ERR;
        ev->callback = process_stderr;
        ev->priv = p;
        AZ(VEV_Start(evb, ev));

        if (p->log == 1) {
                p->vlu_stdout = VLU_New(process_vlu_func, p, 1024);
                AN(p->vlu_stdout);
                p->vlu_stderr = VLU_New(process_vlu_func, p, 1024);
                AN(p->vlu_stderr);
        }

        do {
                r = VEV_Once(evb);
        } while (r == 1);

        if (r < 0)
                vtc_fatal(p->vl, "VEV_Once() = %d, error %s", r,
                    strerror(errno));

        vtc_wait4(p->vl, p->pid,
            p->expect_exit, p->expect_signal, p->allow_core);
        closefd(&p->f_stdout);
        closefd(&p->f_stderr);

        PTOK(pthread_mutex_lock(&p->mtx));

        /* NB: We keep the other macros around */
        macro_undef(p->vl, p->name, "pid");
        p->pid = -1;

        PTOK(pthread_mutex_unlock(&p->mtx));

        pthread_cleanup_pop(0);
        VEV_Destroy(&evb);
        if (p->log == 1) {
                VLU_Destroy(&p->vlu_stdout);
                VLU_Destroy(&p->vlu_stderr);
        }
        return (NULL);
}

static void
process_winsz(struct process *p, int fd)
{
        struct winsize ws;
        int i;

        memset(&ws, 0, sizeof ws);
        ws.ws_row = (short)p->nlin;
        ws.ws_col = (short)p->ncol;
        i = ioctl(fd, TIOCSWINSZ, &ws);
        if (i)
                vtc_log(p->vl, 4, "TIOCWINSZ %d %s", i, strerror(errno));
}

static void
process_init_term(struct process *p, int fd)
{
        struct termios tt;
        int i;

        process_winsz(p, fd);

        memset(&tt, 0, sizeof tt);
        tt.c_cflag = CREAD | CS8 | HUPCL;
        tt.c_iflag = BRKINT | ICRNL | IMAXBEL | IXON | IXANY;
        tt.c_lflag = ICANON | ISIG | IEXTEN | ECHO | ECHOE | ECHOKE | ECHOCTL;
        tt.c_oflag = OPOST | ONLCR;
        i = cfsetispeed(&tt, B9600);
        if (i)
                vtc_log(p->vl, 4, "cfsetispeed %d %s", i, strerror(errno));
        i = cfsetospeed(&tt, B9600);
        if (i)
                vtc_log(p->vl, 4, "cfsetospeed %d %s", i, strerror(errno));
        tt.c_cc[VEOF] = '\x04';                 // CTRL-D
        tt.c_cc[VERASE] = '\x08';               // CTRL-H (Backspace)
        tt.c_cc[VKILL] = '\x15';                // CTRL-U
        tt.c_cc[VINTR] = '\x03';                // CTRL-C
        tt.c_cc[VQUIT] = '\x1c';                // CTRL-backslash

        i = tcsetattr(fd, TCSAFLUSH, &tt);
        if (i)
                vtc_log(p->vl, 4, "TCSAFLUSH %d %s", i, strerror(errno));
}

/**********************************************************************
 * Start the process thread
 */

static void
process_start(struct process *p)
{
        struct vsb *cl;
        int fd2[2];
        int master, slave;
        const char *slavename;
        char c;

        CHECK_OBJ_NOTNULL(p, PROCESS_MAGIC);
        if (p->hasthread)
                vtc_fatal(p->vl, "Already running, -wait first");

        vtc_log(p->vl, 4, "CMD: %s", p->spec);

        cl = macro_expand(p->vl, p->spec);
        AN(cl);

        master = posix_openpt(O_RDWR|O_NOCTTY);
        assert(master >= 0);
        AZ(grantpt(master));
        AZ(unlockpt(master));
        slavename = ptsname(master);
        AN(slavename);

        AZ(pipe(fd2));

        p->pid = fork();
        assert(p->pid >= 0);
        if (p->pid == 0) {
                assert(setsid() == getpid());
                assert(dup2(fd2[1], STDERR_FILENO) == STDERR_FILENO);
                AZ(close(STDIN_FILENO));
                slave = open(slavename, O_RDWR);
                assert(slave == STDIN_FILENO);
#ifdef __sun
                if (ioctl(slave, I_PUSH, "ptem"))
                        vtc_log(p->vl, 4, "PUSH ptem: %s", strerror(errno));
                if (ioctl(slave, I_PUSH, "ldterm"))
                        vtc_log(p->vl, 4, "PUSH ldterm: %s", strerror(errno));
                (void)ioctl(STDIN_FILENO, TIOCSCTTY, NULL);
#else
                AZ(ioctl(STDIN_FILENO, TIOCSCTTY, NULL));
#endif
                AZ(close(STDOUT_FILENO));
                assert(dup2(slave, STDOUT_FILENO) == STDOUT_FILENO);
                VSUB_closefrom(STDERR_FILENO + 1);
                process_init_term(p, slave);

                AZ(setenv("TERM", "xterm", 1));
                AZ(unsetenv("TERMCAP"));
                // Not using NULL because GCC is now even more demented...
                assert(write(STDERR_FILENO, "+", 1) == 1);
                AZ(execl("/bin/sh", "/bin/sh", "-c", VSB_data(cl), (char*)0));
                exit(1);
        }
        vtc_log(p->vl, 3, "PID: %ld", (long)p->pid);
        VSB_destroy(&cl);

        assert(read(fd2[0], &c, 1) == 1);
        p->fd_term = master;
        closefd(&fd2[1]);
        p->fd_stderr = fd2[0];
        macro_def(p->vl, p->name, "pid", "%ld", (long)p->pid);
        macro_def(p->vl, p->name, "dir", "%s", p->dir);
        macro_def(p->vl, p->name, "out", "%s", p->out);
        macro_def(p->vl, p->name, "err", "%s", p->err);
        p->hasthread = 1;
        PTOK(pthread_create(&p->tp, NULL, process_thread, p));
}

/**********************************************************************
 * Wait for process thread to stop
 */

static void
process_wait(struct process *p)
{
        void *v;

        if (p->hasthread) {
                PTOK(pthread_join(p->tp, &v));
                p->hasthread = 0;
        }
        vtc_log(p->vl, 4, "stdout %ju bytes, stderr %ju bytes",
            p->stdout_bytes, p->stderr_bytes);
}

/**********************************************************************
 * Send a signal to a process
 */

static void
process_kill(struct process *p, const char *sig)
{
        int j = 0;
        pid_t pid;

        CHECK_OBJ_NOTNULL(p, PROCESS_MAGIC);
        AN(sig);

        PTOK(pthread_mutex_lock(&p->mtx));
        pid = p->pid;
        PTOK(pthread_mutex_unlock(&p->mtx));

        if (pid <= 0)
                vtc_fatal(p->vl, "Cannot signal a non-running process");

        if (!strcmp(sig, "TERM"))
                j = SIGTERM;
        else if (!strcmp(sig, "INT"))
                j = SIGINT;
        else if (!strcmp(sig, "KILL"))
                j = SIGKILL;
        else if (!strcmp(sig, "HUP"))
                j = SIGHUP;
        else if (*sig == '-')
                j = strtoul(sig + 1, NULL, 10);
        else
                vtc_fatal(p->vl, "Could not grok signal (%s)", sig);

        if (p->expect_signal == 0)
                p->expect_signal = -j;
        if (kill(-pid, j) < 0)
                vtc_fatal(p->vl, "Failed to send signal %d (%s)",
                    j, strerror(errno));
        else
                vtc_log(p->vl, 4, "Sent signal %d", j);
}

/**********************************************************************
 * Write to a process' stdin
 */

static void
process_write(const struct process *p, const char *text)
{
        int r, len;

        if (!p->hasthread)
                vtc_fatal(p->vl, "Cannot write to a non-running process");

        len = strlen(text);
        vtc_log(p->vl, 4, "Writing %d bytes", len);
        r = write(p->fd_term, text, len);
        if (r != len)
                vtc_fatal(p->vl, "Failed to write: len=%d %s (%d)",
                    len, strerror(errno), errno);
}

static void
process_write_hex(const struct process *p, const char *text)
{
        struct vsb *vsb;

        if (!p->hasthread)
                vtc_fatal(p->vl, "Cannot write to a non-running process");

        vsb = vtc_hex_to_bin(p->vl, text);
        assert(VSB_len(vsb) >= 0);
        vtc_hexdump(p->vl, 4, "sendhex", VSB_data(vsb), VSB_len(vsb));
        AZ(VSB_tofile(vsb, p->fd_term));
        VSB_destroy(&vsb);
}

static void
process_close(struct process *p)
{

        if (!p->hasthread)
                vtc_fatal(p->vl, "Cannot close a non-running process");

        process_kill(p, "HUP");
}

/* SECTION: process process
 *
 * Run a process with stdin+stdout on a pseudo-terminal and stderr on a pipe.
 *
 * Output from the pseudo-terminal is copied verbatim to ${pNAME_out},
 * and the -log/-dump/-hexdump flags will also put it in the vtc-log.
 *
 * The pseudo-terminal is not in ECHO mode, but if the programs run set
 * it to ECHO mode ("stty sane") any input sent to the process will also
 * appear in this stream because of the ECHO.
 *
 * Output from the stderr-pipe is copied verbatim to ${pNAME_err}, and
 * is always included in the vtc_log.
 *
 *      process pNAME SPEC [-allow-core] [-expect-exit N] [-expect-signal N]
 *              [-dump] [-hexdump] [-log]
 *              [-run] [-close] [-kill SIGNAL] [-start] [-stop] [-wait]
 *              [-write STRING] [-writeln STRING] [-writehex HEXSTRING]
 *              [-need-bytes [+]NUMBER]
 *              [-screen-dump] [-winsz LINES COLUMNS] [-ansi-response]
 *              [-expect-cursor LINE COLUMN] [-expect-text LINE COLUMN TEXT]
 *              [-match-text LINE COLUMN REGEXP]
 *
 * pNAME
 *      Name of the process. It must start with 'p'.
 *
 * SPEC
 *      The command(s) to run in this process.
 *
 * \-hexdump
 *      Log output with vtc_hexdump(). Must be before -start/-run.
 *
 * \-dump
 *      Log output with vtc_dump(). Must be before -start/-run.
 *
 * \-log
 *      Log output with VLU/vtc_log(). Must be before -start/-run.
 *
 * \-start
 *      Start the process.
 *
 * \-expect-exit N
 *      Expect exit status N
 *
 * \-expect-signal N
 *      Expect signal in exit status N
 *
 * \-allow-core
 *      Core dump in exit status is OK
 *
 * \-wait
 *      Wait for the process to finish.
 *
 * \-run
 *      Shorthand for -start -wait.
 *
 *      In most cases, if you just want to start a process and wait for it
 *      to finish, you can use the ``shell`` command instead.
 *      The following commands are equivalent::
 *
 *          shell "do --something"
 *
 *          process p1 "do --something" -run
 *
 *      However, you may use the ``process`` variant to conveniently
 *      collect the standard input and output without dealing with shell
 *      redirections yourself. The ``shell`` command can also expect an
 *      expression from either output, consider using it if you only need
 *      to match one.
 *
 * \-key KEYSYM
 *      Send emulated key-press.
 *      KEYSYM can be one of (NPAGE, PPAGE, HOME, END)
 *
 *
 * \-kill SIGNAL
 *      Send a signal to the process. The argument can be either
 *      the string "TERM", "INT", or "KILL" for SIGTERM, SIGINT or SIGKILL
 *      signals, respectively, or a hyphen (-) followed by the signal
 *      number.
 *
 *      If you need to use other signal names, you can use the ``kill``\(1)
 *      command directly::
 *
 *          shell "kill -USR1 ${pNAME_pid}"
 *
 *      Note that SIGHUP usage is discouraged in test cases.
 *
 * \-stop
 *      Shorthand for -kill TERM.
 *
 * \-close
 *      Alias for "-kill HUP"
 *
 * \-winsz LINES COLUMNS
 *      Change the terminal window size to LIN lines and COL columns.
 *
 * \-write STRING
 *      Write a string to the process' stdin.
 *
 * \-writeln STRING
 *      Same as -write followed by a newline (\\n).
 *
 * \-writehex HEXSTRING
 *      Same as -write but interpreted as hexadecimal bytes.
 *
 * \-need-bytes [+]NUMBER
 *      Wait until at least NUMBER bytes have been received in total.
 *      If '+' is prefixed, NUMBER new bytes must be received.
 *
 * \-ansi-response
 *      Respond to terminal respond-back sequences
 *
 * \-expect-cursor LINE COLUMN
 *      Expect cursors location
 *
 * \-expect-text LINE COLUMNS TEXT
 *      Wait for TEXT to appear at LIN,COL on the virtual screen.
 *      Lines and columns are numbered 1...N
 *      LIN==0 means "on any line"
 *      COL==0 means "anywhere on the line"
 *
 * \-match-text LINE COLUMN REGEXP
 *      Wait for the PAT regular expression to match the text at LIN,COL on the virtual screen.
 *      Lines and columns are numbered 1...N
 *      LIN==0 means "on any line"
 *      COL==0 means "anywhere on the line"
 *
 *
 * \-screen-dump
 *      Dump the virtual screen into vtc_log
 *
 */

void
cmd_process(CMD_ARGS)
{
        struct process *p, *p2;
        uintmax_t u, v, bsnap;
        unsigned lin,col;
        int spec_set = 0;

        (void)priv;

        if (av == NULL) {
                /* Reset and free */
                VTAILQ_FOREACH_SAFE(p, &processes, list, p2) {
                        if (p->pid > 0) {
                                process_kill(p, "TERM");
                                sleep(1);
                                if (p->pid > 0)
                                        process_kill(p, "KILL");
                        }
                        if (p->hasthread)
                                process_wait(p);
                        VTAILQ_REMOVE(&processes, p, list);
                        process_undef(p);
                        process_delete(p);
                }
                return;
        }

        AZ(strcmp(av[0], "process"));
        av++;

        VTC_CHECK_NAME(vl, av[0], "Process", 'p');
        VTAILQ_FOREACH(p, &processes, list)
                if (!strcmp(p->name, av[0]))
                        break;
        if (p == NULL)
                p = process_new(av[0]);
        av++;

        PTOK(pthread_mutex_lock(&p->mtx));
        bsnap = p->stdout_bytes;
        PTOK(pthread_mutex_unlock(&p->mtx));

        for (; *av != NULL; av++) {
                if (vtc_error)
                        break;

                if (!strcmp(*av, "-allow-core")) {
                        p->allow_core = 1;
                        continue;
                }
                if (!strcmp(*av, "-close")) {
                        process_close(p);
                        continue;
                }
                if (!strcmp(*av, "-dump")) {
                        if (p->hasthread)
                                vtc_fatal(p->vl,
                                    "Cannot dump a running process");
                        p->log = 2;
                        continue;
                }
                if (!strcmp(*av, "-expect-exit")) {
                        p->expect_exit = strtoul(av[1], NULL, 0);
                        av++;
                        continue;
                }
                if (!strcmp(*av, "-expect-signal")) {
                        p->expect_signal = strtoul(av[1], NULL, 0);
                        av++;
                        continue;
                }
                if (!strcmp(*av, "-hexdump")) {
                        if (p->hasthread)
                                vtc_fatal(p->vl,
                                    "Cannot dump a running process");
                        p->log = 3;
                        continue;
                }
                if (!strcmp(*av, "-key")) {
                        if (!strcmp(av[1], "NPAGE"))
                                process_write(p, "\x1b\x5b\x36\x7e");
                        else if (!strcmp(av[1], "PPAGE"))
                                process_write(p, "\x1b\x5b\x35\x7e");
                        else if (!strcmp(av[1], "HOME"))
                                process_write(p, "\x1b\x4f\x48");
                        else if (!strcmp(av[1], "END"))
                                process_write(p, "\x1b\x4f\x46");
                        else
                                vtc_fatal(p->vl, "Unknown key %s", av[1]);
                        continue;
                }
                if (!strcmp(*av, "-kill")) {
                        process_kill(p, av[1]);
                        av++;
                        continue;
                }
                if (!strcmp(*av, "-log")) {
                        if (p->hasthread)
                                vtc_fatal(p->vl,
                                    "Cannot log a running process");
                        p->log = 1;
                        continue;
                }
                if (!strcmp(*av, "-need-bytes")) {
                        u = strtoumax(av[1], NULL, 0);
                        if (av[1][0] == '+')
                                u += bsnap;
                        av++;
                        do {
                                PTOK(pthread_mutex_lock(&p->mtx));
                                v = p->stdout_bytes;
                                PTOK(pthread_mutex_unlock(&p->mtx));
                                vtc_log(p->vl, 4, "Have %ju bytes", v);
                                VTIM_sleep(0.5);
                        } while(v < u);
                        continue;
                }
                if (!strcmp(*av, "-run")) {
                        process_start(p);
                        process_wait(p);
                        continue;
                }
                if (!strcmp(*av, "-ansi-response")) {
                        p->ansi_response = 1;
                        continue;
                }
                if (!strcmp(*av, "-expect-text")) {
                        AN(av[1]);
                        AN(av[2]);
                        AN(av[3]);
                        term_expect_text(p, av[1], av[2], av[3]);
                        av += 3;
                        continue;
                }
                if (!strcmp(*av, "-expect-cursor")) {
                        AN(av[1]);
                        AN(av[2]);
                        term_expect_cursor(p, av[1], av[2]);
                        av += 2;
                        continue;
                }
                if (!strcmp(*av, "-match-text")) {
                        AN(av[1]);
                        AN(av[2]);
                        AN(av[3]);
                        term_match_text(p, av[1], av[2], av[3]);
                        av += 3;
                        continue;
                }
                if (!strcmp(*av, "-screen_dump") ||
                    !strcmp(*av, "-screen-dump")) {
                        term_screen_dump(p);
                        continue;
                }
                if (!strcmp(*av, "-start")) {
                        process_start(p);
                        continue;
                }
                if (!strcmp(*av, "-stop")) {
                        process_kill(p, "TERM");
                        sleep(1);
                        continue;
                }
                if (!strcmp(*av, "-wait")) {
                        process_wait(p);
                        continue;
                }
                if (!strcmp(*av, "-winsz")) {
                        lin = atoi(av[1]);
                        assert(lin > 1);
                        col = atoi(av[2]);
                        assert(col > 1);
                        av += 2;
                        PTOK(pthread_mutex_lock(&p->mtx));
                        term_resize(p, lin, col);
                        PTOK(pthread_mutex_unlock(&p->mtx));
                        process_winsz(p, p->fd_term);
                        continue;
                }
                if (!strcmp(*av, "-write")) {
                        process_write(p, av[1]);
                        av++;
                        continue;
                }
                if (!strcmp(*av, "-writehex")) {
                        process_write_hex(p, av[1]);
                        av++;
                        continue;
                }
                if (!strcmp(*av, "-writeln")) {
                        process_write(p, av[1]);
                        process_write(p, "\n");
                        av++;
                        continue;
                }
                if (**av == '-' || spec_set)
                        vtc_fatal(p->vl, "Unknown process argument: %s", *av);
                REPLACE(p->spec, *av);
                spec_set = 1;
        }
}

		varnish-cache/bin/varnishtest/vtc_process.c
0		/*-
1		* Copyright (c) 2015 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Dridi Boukelmoune <dridi@varnish-software.com>
5		*
6		* SPDX-License-Identifier: BSD-2-Clause
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted provided that the following conditions
10		* are met:
11		* 1. Redistributions of source code must retain the above copyright
12		* notice, this list of conditions and the following disclaimer.
13		* 2. Redistributions in binary form must reproduce the above copyright
14		* notice, this list of conditions and the following disclaimer in the
15		* documentation and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27		* SUCH DAMAGE.
28		*
29		* XXX:
30		* -ignore-stderr (otherwise output to stderr is fail)
31		*/
32
33		#include "config.h"
34
35		#include <sys/ioctl.h> // Linux: struct winsize
36
37		#include <ctype.h>
38		#include <fcntl.h>
39		#include <inttypes.h>
40		#include <poll.h>
41		#include <stdio.h>
42		#include <stdlib.h>
43		#include <string.h>
44		#ifdef __sun
45		# include <stropts.h>
46		#endif
47		#include <termios.h>
48		#include <unistd.h>
49
50		#include "vtc.h"
51
52		#include "vre.h"
53		#include "vev.h"
54		#include "vlu.h"
55		#include "vsb.h"
56		#include "vsub.h"
57		#include "vtim.h"
58
59		#include "teken.h"
60
61		struct process {
62		unsigned magic;
63		#define PROCESS_MAGIC 0x1617b43e
64		char *name;
65		struct vtclog *vl;
66		VTAILQ_ENTRY(process) list;
67
68		char *spec;
69		char *dir;
70		char *out;
71		char *err;
72		int fd_term;
73		int fd_stderr;
74		int f_stdout;
75		int f_stderr;
76		struct vlu *vlu_stdout;
77		struct vlu *vlu_stderr;
78		int log;
79		pid_t pid;
80		int expect_exit;
81		int expect_signal;
82		int allow_core;
83
84		uintmax_t stdout_bytes;
85		uintmax_t stderr_bytes;
86
87		pthread_mutex_t mtx;
88		pthread_t tp;
89		unsigned hasthread;
90
91		int nlin;
92		int ncol;
93		int ansi_response;
94		char **vram;
95		teken_t tek[1];
96		};
97
98		static VTAILQ_HEAD(, process) processes =
99		VTAILQ_HEAD_INITIALIZER(processes);
100
101		static void term_resize(struct process *pp, int lin, int col);
102
103		/**********************************************************************
104		* Terminal emulation
105		*/
106
107		static void
108	138757	term_cursor(void priv, const teken_pos_t pos)
109		{
110	138757	(void)priv;
111	138757	(void)pos;
112	138757	}
113
114		static void
115	875532	term_putchar(void priv, const teken_pos_t pos, teken_char_t ch,
116		const teken_attr_t *at)
117		{
118		struct process *pp;
119
120	875532	CAST_OBJ_NOTNULL(pp, priv, PROCESS_MAGIC);
121	875534	(void)at;
122	875534	if (ch > 126 \|\| ch < 32)
123	562	ch = '?';
124	875534	assert(pos->tp_row < pp->nlin);
125	875534	assert(pos->tp_col < pp->ncol);
126	875534	pp->vram[pos->tp_row][pos->tp_col] = ch;
127	875534	}
128
129		static void
130	1770	term_fill(void priv, const teken_rect_t r, teken_char_t c,
131		const teken_attr_t *a)
132		{
133		teken_pos_t p;
134
135		/* Braindead implementation of fill() - just call putchar(). */
136	9952	for (p.tp_row = r->tr_begin.tp_row;
137	9952	p.tp_row < r->tr_end.tp_row; p.tp_row++)
138	758203	for (p.tp_col = r->tr_begin.tp_col;
139	758203	p.tp_col < r->tr_end.tp_col; p.tp_col++)
140	758203	term_putchar(priv, &p, c, a);
141	1770	}
142
143		static void
144	1717	term_copy(void priv, const teken_rect_t r, const teken_pos_t *p)
145		{
146		struct process *pp;
147		int nrow, ncol, y; /* Has to be signed - >= 0 comparison */
148
149		/*
150		* Copying is a little tricky. We must make sure we do it in
151		* correct order, to make sure we don't overwrite our own data.
152		*/
153	1717	CAST_OBJ_NOTNULL(pp, priv, PROCESS_MAGIC);
154
155	1717	nrow = r->tr_end.tp_row - r->tr_begin.tp_row;
156	1717	ncol = r->tr_end.tp_col - r->tr_begin.tp_col;
157
158	1717	if (p->tp_row < r->tr_begin.tp_row) {
159		/* Copy from top to bottom. */
160	24062	for (y = 0; y < nrow; y++)
161	46810	memmove(&pp->vram[p->tp_row + y][p->tp_col],
162	23405	&pp->vram[r->tr_begin.tp_row + y][r->tr_begin.tp_col], ncol);
163	657	} else {
164		/* Copy from bottom to top. */
165	5919	for (y = nrow - 1; y >= 0; y--)
166	9718	memmove(&pp->vram[p->tp_row + y][p->tp_col],
167	4859	&pp->vram[r->tr_begin.tp_row + y][r->tr_begin.tp_col], ncol);
168		}
169	1717	}
170
171		static void
172	16	term_respond(void priv, const void p, size_t l)
173		{
174		struct process *pp;
175		int r;
176
177	16	CAST_OBJ_NOTNULL(pp, priv, PROCESS_MAGIC);
178
179	16	vtc_dump(pp->vl, 4, "term_response", p, l);
180	16	if (pp->ansi_response) {
181	2	r = write(pp->fd_term, p, l);
182	2	if (r != l)
183	0	vtc_fatal(pp->vl, "Could not write to process: %s",
184	0	strerror(errno));
185	2	}
186	16	}
187
188		static void
189	139	term_param(void *priv, int p, unsigned int v)
190		{
191		struct process *pp;
192
193	139	CAST_OBJ_NOTNULL(pp, priv, PROCESS_MAGIC);
194	139	if (p == TP_132COLS && v)
195	12	term_resize(pp, pp->nlin, 132);
196	36	if (p == TP_132COLS && !v)
197	24	term_resize(pp, pp->nlin, 80);
198	139	}
199
200		static const teken_funcs_t process_teken_func = {
201		.tf_cursor = term_cursor,
202		.tf_putchar = term_putchar,
203		.tf_fill = term_fill,
204		.tf_copy = term_copy,
205		.tf_respond = term_respond,
206		.tf_param = term_param,
207		};
208
209		static void
210	158	term_screen_dump(const struct process *pp)
211		{
212		int i;
213		const teken_pos_t *pos;
214
215	4126	for (i = 0; i < pp->nlin; i++)
216	3968	vtc_dump(pp->vl, 3, "screen", pp->vram[i], pp->ncol);
217	158	pos = teken_get_cursor(pp->tek);
218	316	vtc_log(pp->vl, 3, "Cursor at line %d column %d",
219	158	pos->tp_row + 1, pos->tp_col + 1);
220	158	}
221
222		static void
223	101	term_resize(struct process *pp, int lin, int col)
224		{
225		teken_pos_t pos;
226		char **vram;
227		int i, j;
228
229	101	vram = calloc(lin, sizeof *pp->vram);
230	101	AN(vram);
231	2621	for (i = 0; i < lin; i++) {
232	2520	vram[i] = calloc(col + 1L, 1);
233	2520	AN(vram[i]);
234	2520	memset(vram[i], ' ', col);
235	2520	vram[i][col] = '\0';
236	2520	}
237	101	if (pp->vram != NULL) {
238	1099	for (i = 0; i < lin; i++) {
239	1062	if (i >= pp->nlin)
240	7	break;
241	1055	j = col;
242	1055	if (j > pp->ncol)
243	384	j = pp->ncol;
244	1055	memcpy(vram[i], pp->vram[i], j);
245	1055	}
246	1100	for (i = 0; i < pp->nlin; i++)
247	1056	free(pp->vram[i]);
248	44	free(pp->vram);
249	44	}
250	101	pp->vram = vram;
251	101	pp->nlin = lin;
252	101	pp->ncol = col;
253
254	101	pos.tp_row = lin;
255	101	pos.tp_col = col;
256	101	teken_set_winsize(pp->tek, &pos);
257	101	}
258
259		static int
260	4961	term_find_textline(const struct process pp, int x, int y, const char *pat)
261		{
262		const char *t;
263		int l;
264
265	4961	if (*x == 0) {
266	3919	t = strstr(pp->vram[y], pat);
267	3919	if (t != NULL) {
268	70	*x = 1 + (t - pp->vram[y]);
269	70	return (1);
270		}
271	4891	} else if (*x <= pp->ncol) {
272	1042	t = pp->vram[y] + *x - 1;
273	1042	l = strlen(pat);
274	1042	assert((*x - 1) + (l - 1) < pp->ncol);
275	1042	if (!memcmp(t, pat, l))
276	182	return (1);
277	860	}
278	4709	return (0);
279	4961	}
280
281		static int
282	506	term_find_text(const struct process pp, int x, int y, const char pat)
283		{
284		int yy;
285
286	506	if (*y == 0) {
287	4766	for (yy = 0; yy < pp->nlin; yy++) {
288	4649	if (term_find_textline(pp, x, yy, pat)) {
289	77	*y = yy + 1;
290	77	return (1);
291		}
292	4572	}
293	429	} else if (*y <= pp->nlin) {
294	312	if (term_find_textline(pp, x, *y - 1, pat))
295	175	return (1);
296	137	}
297	254	return (0);
298	506	}
299
300		static void
301	252	term_expect_text(struct process *pp,
302		const char lin, const char col, const char *pat)
303		{
304	252	int x, y, l, d = 10000;
305		char *t;
306
307	252	y = strtoul(lin, NULL, 0);
308	252	if (y < 0 \|\| y > pp->nlin)
309	0	vtc_fatal(pp->vl, "YYY %d nlin %d", y, pp->nlin);
310	252	x = strtoul(col, NULL, 0);
311	256	for(l = 0; l <= 10 && x > pp->ncol; l++) // wait for screen change
312	4	VTIM_sleep(0.1);
313	252	if (x < 0 \|\| x > pp->ncol)
314	0	vtc_fatal(pp->vl, "XXX %d ncol %d", x, pp->ncol);
315	252	l = strlen(pat);
316	252	if (x + l - 1 > pp->ncol)
317	0	vtc_fatal(pp->vl, "XXX %d ncol %d", x + l - 1, pp->ncol);
318	252	PTOK(pthread_mutex_lock(&pp->mtx));
319	506	while (!term_find_text(pp, &x, &y, pat)) {
320	254	if (x != 0 && y != 0) {
321	125	t = pp->vram[y - 1] + x - 1;
322	250	vtc_log(pp->vl, 4,
323	125	"text at %d,%d: '%.*s'", y, x, l, t);
324	125	}
325	254	PTOK(pthread_mutex_unlock(&pp->mtx));
326	254	usleep(d);
327	254	PTOK(pthread_mutex_lock(&pp->mtx));
328	254	if (d < 3000000)
329	254	d += d;
330		}
331	252	PTOK(pthread_mutex_unlock(&pp->mtx));
332	252	vtc_log(pp->vl, 4, "found expected text at %d,%d: '%s'", y, x, pat);
333	252	}
334
335		static void
336	8	term_expect_cursor(const struct process pp, const char lin, const char *col)
337		{
338		int x, y, l;
339		const teken_pos_t *pos;
340
341	8	pos = teken_get_cursor(pp->tek);
342	8	y = strtoul(lin, NULL, 0);
343	8	if (y < 0 \|\| y > pp->nlin)
344	0	vtc_fatal(pp->vl, "YYY %d nlin %d", y, pp->nlin);
345	8	x = strtoul(col, NULL, 0);
346	8	for(l = 0; l < 10 && x > pp->ncol; l++) // wait for screen change
347	0	VTIM_sleep(0.1);
348	8	if (x < 0 \|\| x > pp->ncol)
349	0	vtc_fatal(pp->vl, "XXX %d ncol %d", x, pp->ncol);
350	8	if (y != 0 && (y-1) != pos->tp_row)
351	0	vtc_fatal(pp->vl, "Cursor on line %d (expected %d)",
352	0	pos->tp_row + 1, y);
353	6	if (x != 0 && (x-1) != pos->tp_col)
354	0	vtc_fatal(pp->vl, "Cursor in column %d (expected %d)",
355	0	pos->tp_col + 1, y);
356	8	}
357
358		static void
359	34	term_match_text(struct process *pp,
360		const char lin, const char col, const char *re)
361		{
362		int i, l, err, erroff;
363		struct vsb *vsb, re_vsb[1];
364		size_t len;
365		ssize_t x, y;
366		vre_t *vre;
367		char errbuf[VRE_ERROR_LEN];
368
369	34	vsb = VSB_new_auto();
370	34	AN(vsb);
371
372	34	y = strtoul(lin, NULL, 0);
373	34	if (y < 0 \|\| y > pp->nlin)
374	0	vtc_fatal(pp->vl, "YYY %zd nlin %d", y, pp->nlin);
375	34	x = strtoul(col, NULL, 0);
376	34	for(l = 0; l < 10 && x > pp->ncol; l++) // wait for screen change
377	0	VTIM_sleep(0.1);
378	34	if (x < 0 \|\| x > pp->ncol)
379	0	vtc_fatal(pp->vl, "XXX %zd ncol %d", x, pp->ncol);
380
381	34	if (x)
382	16	x--;
383
384	18	if (y)
385	18	y--;
386
387	34	vre = VRE_compile(re, 0, &err, &erroff, 1);
388	34	if (vre == NULL) {
389	0	AN(VSB_init(re_vsb, errbuf, sizeof errbuf));
390	0	AZ(VRE_error(re_vsb, err));
391	0	AZ(VSB_finish(re_vsb));
392	0	VSB_fini(re_vsb);
393	0	vtc_fatal(pp->vl, "invalid regexp \"%s\" at %d (%s)",
394	0	re, erroff, errbuf);
395		}
396
397	34	PTOK(pthread_mutex_lock(&pp->mtx));
398
399	34	len = (pp->nlin - y) * (pp->ncol - x);
400	824	for (i = y; i < pp->nlin; i++) {
401	790	VSB_bcat(vsb, &pp->vram[i][x], pp->ncol - x);
402	790	VSB_putc(vsb, '\n');
403	790	}
404
405	34	AZ(VSB_finish(vsb));
406
407	34	if (VRE_match(vre, VSB_data(vsb), len, 0, NULL) < 1)
408	0	vtc_fatal(pp->vl, "match failed: (\"%s\")", re);
409		else
410	34	vtc_log(pp->vl, 4, "match succeeded");
411
412	34	PTOK(pthread_mutex_unlock(&pp->mtx));
413	34	VSB_destroy(&vsb);
414	34	VRE_free(&vre);
415	34	}
416
417		/**********************************************************************
418		* Allocate and initialize a process
419		*/
420
421		#define PROCESS_EXPAND(field, format, ...) \
422		do { \
423		vsb = macro_expandf(p->vl, format, __VA_ARGS__); \
424		AN(vsb); \
425		p->field = strdup(VSB_data(vsb)); \
426		AN(p->field); \
427		VSB_destroy(&vsb); \
428		} while (0)
429
430		static void
431	57	process_coverage(struct process *p)
432		{
433		const teken_attr_t *a;
434		teken_pos_t pos;
435		int fg, bg;
436
437		// Code-Coverage of Teken
438
439	57	(void)teken_get_sequence(p->tek, TKEY_UP);
440	57	(void)teken_get_sequence(p->tek, TKEY_F1);
441	57	(void)teken_256to8(0);
442	57	(void)teken_256to16(0);
443	57	a = teken_get_defattr(p->tek);
444	57	teken_set_defattr(p->tek, a);
445	57	a = teken_get_curattr(p->tek);
446	57	teken_set_curattr(p->tek, a);
447	57	(void)teken_get_winsize(p->tek);
448	57	pos.tp_row = 0;
449	57	pos.tp_col = 8;
450	57	teken_set_cursor(p->tek, &pos);
451	57	teken_get_defattr_cons25(p->tek, &fg, &bg);
452	57	}
453
454		static struct process *
455	57	process_new(const char *name)
456		{
457		struct process *p;
458		struct vsb *vsb;
459		char buf[1024];
460
461	57	ALLOC_OBJ(p, PROCESS_MAGIC);
462	57	AN(p);
463	57	REPLACE(p->name, name);
464	57	PTOK(pthread_mutex_init(&p->mtx, NULL));
465
466	57	p->vl = vtc_logopen("%s", name);
467	57	AN(p->vl);
468
469	57	PROCESS_EXPAND(dir, "${tmpdir}/%s", name);
470	57	PROCESS_EXPAND(out, "${tmpdir}/%s/term", name);
471	57	PROCESS_EXPAND(err, "${tmpdir}/%s/stderr", name);
472
473	57	bprintf(buf, "rm -rf %s ; mkdir -p %s ; touch %s %s",
474		p->dir, p->dir, p->out, p->err);
475	57	AZ(system(buf));
476
477	57	p->fd_term = -1;
478
479	57	VTAILQ_INSERT_TAIL(&processes, p, list);
480	57	teken_init(p->tek, &process_teken_func, p);
481	57	term_resize(p, 24, 80);
482	57	process_coverage(p);
483	57	return (p);
484		}
485
486		#undef PROCESS_EXPAND
487
488		/**********************************************************************
489		* Clean up process
490		*/
491
492		static void
493	57	process_delete(struct process *p)
494		{
495		int i;
496
497	57	CHECK_OBJ_NOTNULL(p, PROCESS_MAGIC);
498	57	PTOK(pthread_mutex_destroy(&p->mtx));
499	57	vtc_logclose(p->vl);