GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Martin Blix Grydeland <martin@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.
 *
 * Common functions for the utilities
 */

#include "config.h"

#include <ctype.h>
#include <math.h>
#include <stdint.h>
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h> /* for MUSL */

#include "compat/daemon.h"
#include "vdef.h"
#include "vpf.h"
#include "vapi/vsm.h"
#include "vapi/vsl.h"
#include "vtim.h"
#include "vas.h"
#include "miniobj.h"
#include "vcs.h"
#include "vsb.h"
#include "vfil.h"

#include "vapi/voptget.h"
#include "vapi/vsig.h"

#include "vut.h"


static int vut_synopsis(const struct vopt_spec *);
static int vut_options(const struct vopt_spec *);

static struct vpf_fh    *pfh;
static unsigned         daemonized;

static struct VUT pfh_vut;

static int
vut_daemon(struct VUT *vut)
{
        if (daemonized)
                VUT_Error(vut, 1, "Already running as a daemon");
        daemonized = 1;
        return (vinyl_daemon(0, 0));
}

static void
vut_vpf_remove(void)
{

        CHECK_OBJ(&pfh_vut, VUT_MAGIC);
        AN(pfh);
        AN(pfh_vut.P_arg);

        VPF_Remove(pfh);
        free(pfh_vut.P_arg);
        ZERO_OBJ(&pfh_vut, sizeof pfh_vut);
        pfh = NULL;
}

static int v_matchproto_(VSLQ_dispatch_f)
vut_dispatch(struct VSL_data *vsl, struct VSL_transaction * const trans[],
    void *priv)
{
        struct VUT *vut;
        int i;

        CAST_OBJ_NOTNULL(vut, priv, VUT_MAGIC);

        if (vut->k_arg == 0)
                return (-1);    /* End of file */
        AN(vut->dispatch_f);
        i = vut->dispatch_f(vsl, trans, vut->dispatch_priv);
        if (vut->k_arg > 0)
                vut->k_arg--;
        if (i >= 0 && vut->k_arg == 0)
                return (-1);    /* End of file */
        return (i);
}

void
VUT_Error(struct VUT *vut, int status, const char *fmt, ...)
{
        va_list ap;

        CHECK_OBJ_NOTNULL(vut, VUT_MAGIC);
        AN(status);

        va_start(ap, fmt);
        if (vut->error_f != NULL) {
                vut->error_f(vut, status, fmt, ap);
        } else {
                vfprintf(stderr, fmt, ap);
                fprintf(stderr, "\n");
        }
        va_end(ap);
        exit(status);
}

static void
vut_arg_q(struct VUT *vut, const char *arg)
{
        struct vsb *vsb;

        AN(arg);
        if (vut->q_arg == NULL) {
                REPLACE(vut->q_arg, arg);
                return;
        }

        vsb = VSB_new_auto();
        AN(vsb);
        AZ(VSB_printf(vsb, "%s\n%s", vut->q_arg, arg));
        AZ(VSB_finish(vsb));

        REPLACE(vut->q_arg, VSB_data(vsb));

        VSB_destroy(&vsb);
}

int
VUT_Arg(struct VUT *vut, int opt, const char *arg)
{
        int i;
        char *p;

        CHECK_OBJ_NOTNULL(vut, VUT_MAGIC);
        AN(opt);

        switch (opt) {
        case '0':
                vut->dryrun_opt = 1;
                return (1);
        case 'd':
                /* Head */
                vut->d_opt = 1;
                return (1);
        case 'D':
                /* Daemon mode */
                vut->D_opt = 1;
                return (1);
        case 'g':
                /* Grouping */
                AN(arg);
                vut->g_arg = VSLQ_Name2Grouping(arg, -1);
                if (vut->g_arg == -2)
                        VUT_Error(vut, 1, "Ambiguous grouping type: %s", arg);
                else if (vut->g_arg < 0)
                        VUT_Error(vut, 1, "Unknown grouping type: %s", arg);
                return (1);
        case 'k':
                /* Log transaction limit */
                AN(arg);
                vut->k_arg = (int)strtol(arg, &p, 10);
                if (*p != '\0' || vut->k_arg <= 0)
                        VUT_Error(vut, 1, "-k: Invalid number '%s'", arg);
                return (1);
        case 'n':
                /* Vinyl instance name */
                AN(arg);
                REPLACE(vut->n_arg, arg);
                return (1);
        case 'P':
                /* PID file */
                AN(arg);
                REPLACE(vut->P_arg, arg);
                return (1);
        case 'Q':
                AN(arg);
                p = VFIL_readfile(NULL, arg, NULL);
                if (p == NULL)
                        VUT_Error(vut, 1, "-Q %s: %s", arg, strerror(errno));
                vut_arg_q(vut, p);
                free(p);
                return (1);
        case 'q':
                /* Query to use */
                AN(arg);
                vut_arg_q(vut, arg);
                return (1);
        case 'r':
                /* Binary file input */
                AN(arg);
                REPLACE(vut->r_arg, arg);
                return (1);
        case 't':
                /* VSM connect timeout */
                REPLACE(vut->t_arg, arg);
                return (1);
        case 'V':
                /* Print version number and exit */
                VCS_Message(vut->progname);
                exit(0);
        default:
                AN(vut->vsl);
                i = VSL_Arg(vut->vsl, opt, arg);
                if (i < 0)
                        VUT_Error(vut, 1, "%s", VSL_Error(vut->vsl));
                return (i);
        }
}

struct VUT *
VUT_Init(const char *progname, int argc, char * const *argv,
    const struct vopt_spec *voc)
{
        struct VUT *vut;

        AN(progname);
        AN(argv);
        AN(voc);

        VSIG_Arm_hup();
        VSIG_Arm_int();
        VSIG_Arm_term();
        VSIG_Arm_usr1();

        if (argc == 2 && !vstrcmp(argv[1], "--synopsis"))
                exit(vut_synopsis(voc));
        if (argc == 2 && !vstrcmp(argv[1], "--options"))
                exit(vut_options(voc));
        if (argc == 2 && !vstrcmp(argv[1], "--optstring")) {
                (void)printf("%s\n", voc->vopt_optstring);
                exit(0);
        }

        ALLOC_OBJ(vut, VUT_MAGIC);
        AN(vut);
        vut->progname = progname;
        vut->g_arg = VSL_g_vxid;
        vut->k_arg = -1;
        AZ(vut->vsl);
        vut->vsl = VSL_New();
        AN(vut->vsl);
        return (vut);
}

void
VUT_Signal(VUT_sighandler_f sig_cb)
{

        AN(sig_cb);
        (void)signal(SIGHUP, sig_cb);
        (void)signal(SIGINT, sig_cb);
        (void)signal(SIGTERM, sig_cb);
        (void)signal(SIGUSR1, sig_cb);
}

void
VUT_Signaled(struct VUT *vut, int sig)
{

        CHECK_OBJ_NOTNULL(vut, VUT_MAGIC);
#define VSIG_SIGNAL(UPPER, lower) \
        VSIG_##lower += (int)(sig == SIG##UPPER);
#include "tbl/vsig_list.h"
}

void
VUT_Setup(struct VUT *vut)
{
        struct VSL_cursor *c;

        CHECK_OBJ_NOTNULL(vut, VUT_MAGIC);
        AN(vut->vsl);
        AZ(vut->vsm);
        AZ(vut->vslq);

        /* Check input arguments (2 used for bug in FlexeLint) */
        if ((vut->n_arg == NULL ? 0 : 2) +
            (vut->r_arg == NULL ? 0 : 2) > 2)
                VUT_Error(vut, 1, "Only one of -n and -r options may be used");

        if (vut->r_arg != NULL && !vstrcmp(vut->r_arg, "-") && vut->D_opt)
                VUT_Error(vut, 1, "Daemon cannot read from stdin");

        /* Create and validate the query expression */
        vut->vslq = VSLQ_New(vut->vsl, NULL,
            (enum VSL_grouping_e)vut->g_arg, vut->q_arg);
        if (vut->vslq == NULL)
                VUT_Error(vut, 1, "Query expression error:\n%s",
                    VSL_Error(vut->vsl));

        if (vut->dryrun_opt)
                return;

        /* Setup input */
        if (vut->r_arg) {
                c = VSL_CursorFile(vut->vsl, vut->r_arg, 0);
                if (c == NULL)
                        VUT_Error(vut, 1, "%s", VSL_Error(vut->vsl));
                VSLQ_SetCursor(vut->vslq, &c);
                AZ(c);
        } else {
                vut->vsm = VSM_New();
                AN(vut->vsm);
                if (vut->n_arg && VSM_Arg(vut->vsm, 'n', vut->n_arg) <= 0)
                        VUT_Error(vut, 1, "%s", VSM_Error(vut->vsm));
                if (vut->t_arg && VSM_Arg(vut->vsm, 't', vut->t_arg) <= 0)
                        VUT_Error(vut, 1, "%s", VSM_Error(vut->vsm));
                if (VSM_Attach(vut->vsm, STDERR_FILENO))
                        VUT_Error(vut, 1, "VSM: %s", VSM_Error(vut->vsm));
                // Cursor is handled in VUT_Main()
        }

        /* Open PID file */
        if (vut->P_arg) {
                if (pfh != NULL)
                        VUT_Error(vut, 1, "PID file already created");
                pfh = VPF_Open(vut->P_arg, 0644, NULL);
                if (pfh == NULL)
                        VUT_Error(vut, 1,
                            "%s: %s", vut->P_arg, strerror(errno));
        }

        /* Daemon mode */
        if (vut->D_opt && vut_daemon(vut) == -1)
                VUT_Error(vut, 1, "Daemon mode: %s", strerror(errno));

        /* Write PID and setup exit handler */
        if (vut->P_arg) {
                AN(pfh);
                VPF_Write(pfh);

                /* NB: move ownership to a global pseudo-VUT. */
                INIT_OBJ(&pfh_vut, VUT_MAGIC);
                pfh_vut.P_arg = vut->P_arg;
                pfh_vut.error_f = vut->error_f;
                vut->P_arg = NULL;

                AZ(atexit(vut_vpf_remove));
        }
}

void
VUT_Fini(struct VUT **vutp)
{
        struct VUT *vut;

        TAKE_OBJ_NOTNULL(vut, vutp, VUT_MAGIC);
        AN(vut->progname);

        free(vut->n_arg);
        free(vut->q_arg);
        free(vut->r_arg);
        free(vut->t_arg);
        AZ(vut->P_arg);

        if (vut->vslq)
                VSLQ_Delete(&vut->vslq);
        if (vut->vsl)
                VSL_Delete(vut->vsl);
        if (vut->vsm)
                VSM_Destroy(&vut->vsm);

        FREE_OBJ(vut);
}

static void
vut_CursorError(struct VUT *vut, vtim_mono *last)
{
        const char *diag;
        vtim_mono now;

        CHECK_OBJ_NOTNULL(vut, VUT_MAGIC);
        AN(vut->vsl);
        AN(last);

        diag = VSL_Error(vut->vsl);
        if (diag == NULL)
                diag = "Missing diagnostic";

        now = VTIM_mono();
        if (isnan(*last) || *last + 1 < now) {
                fprintf(stderr, "Failed to acquire log: %s\n", diag);
                *last = now;
        }
}

int
VUT_Main(struct VUT *vut)
{
        struct VSL_cursor *c;
        int i = -1;
        int hascursor = -1;
        vtim_mono t_failcursor = NAN;

        CHECK_OBJ_NOTNULL(vut, VUT_MAGIC);
        AN(vut->vslq);

        while (!VSIG_int && !VSIG_term && !vut->dryrun_opt) {
                if (VSIG_hup != vut->last_sighup) {
                        /* sighup callback */
                        vut->last_sighup = VSIG_hup;
                        if (vut->sighup_f != NULL)
                                i = vut->sighup_f(vut);
                        else
                                i = 1;
                        if (i)
                                break;
                }

                if (VSIG_usr1 != vut->last_sigusr1) {
                        /* Flush and report any incomplete records */
                        vut->last_sigusr1 = VSIG_usr1;
                        (void)VSLQ_Flush(vut->vslq, vut_dispatch, vut);
                }

                /* We must repeatedly call VSM_Status() when !hascursor
                 * to make VSM discover our segment.
                 *
                 * XXX consider moving the error handling to VSLQ_Dispatch.
                 * or some other VSL utility function
                 * Reasons:
                 *
                 * - it does not seem to make much sense to call VSM_StillValid
                 *   in vsl if that can only detect invalid segments after
                 *   VSM_Status has run, so it appears both should be
                 *   consolidated
                 *
                 * - not all VSL Clients will use VUT, yet the log abandoned/
                 *   overrun situation will be occur for all of them.
                 */

                if (vut->vsm != NULL &&
                    (VSM_Status(vut->vsm) & VSM_WRK_RESTARTED)) {
                        if (hascursor < 1) {
                                fprintf(stderr, "Log abandoned (vsm)\n");
                                VSLQ_SetCursor(vut->vslq, NULL);
                                hascursor = 0;
                        }
                }
                if (vut->vsm != NULL && hascursor < 1) {
                        /* Reconnect VSM */
                        AZ(vut->r_arg);
                        VTIM_sleep(0.1);
                        c = VSL_CursorVSM(vut->vsl, vut->vsm,
                            (vut->d_opt ? VSL_COPT_TAILSTOP : VSL_COPT_TAIL)
                            | VSL_COPT_BATCH);
                        if (c == NULL) {
                                vut_CursorError(vut, &t_failcursor);
                                VSL_ResetError(vut->vsl);
                                continue;
                        }
                        if (hascursor >= 0)
                                fprintf(stderr, "Log reacquired\n");
                        hascursor = 1;
                        VSLQ_SetCursor(vut->vslq, &c);
                        AZ(c);
                }

                do
                        i = VSLQ_Dispatch(vut->vslq, vut_dispatch, vut);
                while (i == vsl_more &&
                    VSIG_usr1 == vut->last_sigusr1 &&
                    VSIG_hup == vut->last_sighup);

                if (i == vsl_more)
                        continue;
                else if (i == vsl_end) {
                        if (vut->idle_f) {
                                i = vut->idle_f(vut);
                                if (i)
                                        break;
                        }
                        VTIM_sleep(0.01);
                        continue;
                } else if (i == vsl_e_eof)
                        break;

                if (vut->vsm == NULL)
                        break;

                /* XXX: Make continuation optional */

                (void)VSLQ_Flush(vut->vslq, vut_dispatch, vut);

                if (i == vsl_e_abandon) {
                        fprintf(stderr, "Log abandoned (vsl)\n");
                        VSLQ_SetCursor(vut->vslq, NULL);
                        hascursor = 0;
                } else if (i == vsl_e_overrun) {
                        fprintf(stderr, "Log overrun\n");
                        VSLQ_SetCursor(vut->vslq, NULL);
                        hascursor = 0;
                } else
                        fprintf(stderr, "Error %d from VSLQ_Dispatch()", i);
        }

        return (i);
}

/**********************************************************************/

void v_noreturn_
VUT_Usage(const struct VUT *vut, const struct vopt_spec *voc, int status)
{
        const char **opt;

        fprintf(stderr, "Usage: %s <options>\n\n", vut->progname);
        fprintf(stderr, "Options:\n");
        for (opt = voc->vopt_usage; *opt != NULL; opt += 2)
                fprintf(stderr, " %-25s %s\n", *opt, *(opt + 1));
        exit(status);
}

/**********************************************************************/


static void
print_nobrackets(const char *s)
{
        const char *e;

        /* Remove whitespace */
        while (isspace(*s))
                s++;
        e = s + vstrlen(s);
        while (e > s && isspace(e[-1]))
                e--;

        /* Remove outer layer brackets if present */
        if (e > s && *s == '[' && e[-1] == ']') {
                s++;
                e--;
        }

        printf("%.*s", (int)(e - s), s);
}

static void
print_tabbed(const char *string, int tabs)
{
        int i;
        const char *c;

        for (c = string; *c; c++) {
                if (c == string || *(c - 1) == '\n')
                        for (i = 0; i < tabs; i++)
                                printf("\t");
                printf("%c", *c);
        }
}

static void
print_opt(const struct vopt_list *opt)
{
        print_nobrackets(opt->synopsis);
        printf("\n\n");
        print_tabbed(opt->ldesc, 1);
        printf("\n\n");
}

static int
vut_synopsis(const struct vopt_spec *voc)
{
        printf(".. |synopsis| replace:: %s\n", voc->vopt_synopsis);
        return (0);
}

static int
vut_options(const struct vopt_spec *voc)
{
        int i;

        for (i = 0; i < voc->vopt_list_n; i++)
                print_opt(&voc->vopt_list[i]);
        printf("--optstring\n"
            "\tPrint the optstring parameter to ``getopt(3)`` to help"
            " writing wrapper scripts.\n\n");
        return (0);
}

		vinyl-cache/lib/libvinylapi/vut.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2015 Varnish Software AS
3		* All rights reserved.
4		*
5		* Author: Martin Blix Grydeland <martin@varnish-software.com>
6		*
7		* SPDX-License-Identifier: BSD-2-Clause
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		* 1. Redistributions of source code must retain the above copyright
13		* notice, this list of conditions and the following disclaimer.
14		* 2. Redistributions in binary form must reproduce the above copyright
15		* notice, this list of conditions and the following disclaimer in the
16		* documentation and/or other materials provided with the distribution.
17		*
18		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28		* SUCH DAMAGE.
29		*
30		* Common functions for the utilities
31		*/
32
33		#include "config.h"
34
35		#include <ctype.h>
36		#include <math.h>
37		#include <stdint.h>
38		#include <stdarg.h>
39		#include <stdlib.h>
40		#include <unistd.h>
41		#include <stdio.h>
42		#include <string.h>
43		#include <sys/stat.h> /* for MUSL */
44
45		#include "compat/daemon.h"
46		#include "vdef.h"
47		#include "vpf.h"
48		#include "vapi/vsm.h"
49		#include "vapi/vsl.h"
50		#include "vtim.h"
51		#include "vas.h"
52		#include "miniobj.h"
53		#include "vcs.h"
54		#include "vsb.h"
55		#include "vfil.h"
56
57		#include "vapi/voptget.h"
58		#include "vapi/vsig.h"
59
60		#include "vut.h"
61
62
63		static int vut_synopsis(const struct vopt_spec *);
64		static int vut_options(const struct vopt_spec *);
65
66		static struct vpf_fh *pfh;
67		static unsigned daemonized;
68
69		static struct VUT pfh_vut;
70
71		static int
72	6	vut_daemon(struct VUT *vut)
73		{
74	6	if (daemonized)
75	0	VUT_Error(vut, 1, "Already running as a daemon");
76	6	daemonized = 1;
77	6	return (vinyl_daemon(0, 0));
78		}
79
80		static void
81	12	vut_vpf_remove(void)
82		{
83
84	12	CHECK_OBJ(&pfh_vut, VUT_MAGIC);
85	12	AN(pfh);
86	12	AN(pfh_vut.P_arg);
87
88	12	VPF_Remove(pfh);
89	12	free(pfh_vut.P_arg);
90	12	ZERO_OBJ(&pfh_vut, sizeof pfh_vut);
91	12	pfh = NULL;
92	12	}
93
94		static int v_matchproto_(VSLQ_dispatch_f)
95	3003	vut_dispatch(struct VSL_data vsl, struct VSL_transaction const trans[],
96		void *priv)
97		{
98		struct VUT *vut;
99		int i;
100
101	3003	CAST_OBJ_NOTNULL(vut, priv, VUT_MAGIC);
102
103	3003	if (vut->k_arg == 0)
104	0	return (-1); /* End of file */
105	3003	AN(vut->dispatch_f);
106	3003	i = vut->dispatch_f(vsl, trans, vut->dispatch_priv);
107	3003	if (vut->k_arg > 0)
108	9	vut->k_arg--;
109	3003	if (i >= 0 && vut->k_arg == 0)
110	9	return (-1); /* End of file */
111	2994	return (i);
112	3003	}
113
114		void
115	291	VUT_Error(struct VUT vut, int status, const char fmt, ...)
116		{
117		va_list ap;
118
119	291	CHECK_OBJ_NOTNULL(vut, VUT_MAGIC);
120	291	AN(status);
121
122	291	va_start(ap, fmt);
123	291	if (vut->error_f != NULL) {
124	0	vut->error_f(vut, status, fmt, ap);
125	0	} else {
126	291	vfprintf(stderr, fmt, ap);
127	291	fprintf(stderr, "\n");
128		}
129	291	va_end(ap);
130	291	exit(status);
131		}
132
133		static void
134	177	vut_arg_q(struct VUT vut, const char arg)
135		{
136		struct vsb *vsb;
137
138	177	AN(arg);
139	177	if (vut->q_arg == NULL) {
140	168	REPLACE(vut->q_arg, arg);
141	168	return;
142		}
143
144	9	vsb = VSB_new_auto();
145	9	AN(vsb);
146	9	AZ(VSB_printf(vsb, "%s\n%s", vut->q_arg, arg));
147	9	AZ(VSB_finish(vsb));
148
149	9	REPLACE(vut->q_arg, VSB_data(vsb));
150
151	9	VSB_destroy(&vsb);
152	177	}
153
154		int
155	1287	VUT_Arg(struct VUT vut, int opt, const char arg)
156		{
157		int i;
158		char *p;
159
160	1287	CHECK_OBJ_NOTNULL(vut, VUT_MAGIC);
161	1287	AN(opt);
162
163	1287	switch (opt) {
164		case '0':
165	0	vut->dryrun_opt = 1;
166	0	return (1);
167		case 'd':
168		/* Head */
169	252	vut->d_opt = 1;
170	252	return (1);
171		case 'D':
172		/* Daemon mode */
173	18	vut->D_opt = 1;
174	18	return (1);
175		case 'g':
176		/* Grouping */
177	42	AN(arg);
178	42	vut->g_arg = VSLQ_Name2Grouping(arg, -1);
179	42	if (vut->g_arg == -2)
180	3	VUT_Error(vut, 1, "Ambiguous grouping type: %s", arg);
181	39	else if (vut->g_arg < 0)
182	3	VUT_Error(vut, 1, "Unknown grouping type: %s", arg);
183	36	return (1);
184		case 'k':
185		/* Log transaction limit */
186	12	AN(arg);
187	12	vut->k_arg = (int)strtol(arg, &p, 10);
188	12	if (*p != '\0' \|\| vut->k_arg <= 0)
189	3	VUT_Error(vut, 1, "-k: Invalid number '%s'", arg);
190	9	return (1);
191		case 'n':
192		/* Vinyl instance name */
193	288	AN(arg);
194	288	REPLACE(vut->n_arg, arg);
195	288	return (1);
196		case 'P':
197		/* PID file */
198	12	AN(arg);
199	12	REPLACE(vut->P_arg, arg);
200	12	return (1);
201		case 'Q':
202	24	AN(arg);
203	24	p = VFIL_readfile(NULL, arg, NULL);
204	24	if (p == NULL)
205	3	VUT_Error(vut, 1, "-Q %s: %s", arg, strerror(errno));
206	21	vut_arg_q(vut, p);
207	21	free(p);
208	21	return (1);
209		case 'q':
210		/* Query to use */
211	156	AN(arg);
212	156	vut_arg_q(vut, arg);
213	156	return (1);
214		case 'r':
215		/* Binary file input */
216	24	AN(arg);
217	24	REPLACE(vut->r_arg, arg);
218	24	return (1);
219		case 't':
220		/* VSM connect timeout */
221	12	REPLACE(vut->t_arg, arg);
222	12	return (1);
223		case 'V':
224		/* Print version number and exit */
225	15	VCS_Message(vut->progname);
226	15	exit(0);
227		default:
228	432	AN(vut->vsl);
229	432	i = VSL_Arg(vut->vsl, opt, arg);
230	432	if (i < 0)
231	54	VUT_Error(vut, 1, "%s", VSL_Error(vut->vsl));
232	378	return (i);
233		}
234	1206	}
235
236		struct VUT *
237	723	VUT_Init(const char progname, int argc, char const *argv,
238		const struct vopt_spec *voc)
239		{
240		struct VUT *vut;
241
242	723	AN(progname);
243	723	AN(argv);
244	723	AN(voc);
245
246	723	VSIG_Arm_hup();
247	723	VSIG_Arm_int();
248	723	VSIG_Arm_term();
249	723	VSIG_Arm_usr1();
250
251	723	if (argc == 2 && !vstrcmp(argv[1], "--synopsis"))
252	15	exit(vut_synopsis(voc));
253	708	if (argc == 2 && !vstrcmp(argv[1], "--options"))
254	15	exit(vut_options(voc));
255	693	if (argc == 2 && !vstrcmp(argv[1], "--optstring")) {
256	0	(void)printf("%s\n", voc->vopt_optstring);
257	0	exit(0);
258		}
259
260	693	ALLOC_OBJ(vut, VUT_MAGIC);
261	693	AN(vut);
262	693	vut->progname = progname;
263	693	vut->g_arg = VSL_g_vxid;
264	693	vut->k_arg = -1;
265	693	AZ(vut->vsl);
266	693	vut->vsl = VSL_New();
267	693	AN(vut->vsl);
268	693	return (vut);
269		}
270
271		void
272	0	VUT_Signal(VUT_sighandler_f sig_cb)
273		{
274
275	0	AN(sig_cb);
276	0	(void)signal(SIGHUP, sig_cb);
277	0	(void)signal(SIGINT, sig_cb);
278	0	(void)signal(SIGTERM, sig_cb);
279	0	(void)signal(SIGUSR1, sig_cb);
280	0	}
281
282		void
283	0	VUT_Signaled(struct VUT *vut, int sig)
284		{
285
286	0	CHECK_OBJ_NOTNULL(vut, VUT_MAGIC);
287		#define VSIG_SIGNAL(UPPER, lower) \
288		VSIG_##lower += (int)(sig == SIG##UPPER);
289		#include "tbl/vsig_list.h"
290		}
291
292		void
293	381	VUT_Setup(struct VUT *vut)
294		{
295		struct VSL_cursor *c;
296
297	381	CHECK_OBJ_NOTNULL(vut, VUT_MAGIC);
298	381	AN(vut->vsl);
299	381	AZ(vut->vsm);
300	381	AZ(vut->vslq);
301
302		/* Check input arguments (2 used for bug in FlexeLint) */
303	1143	if ((vut->n_arg == NULL ? 0 : 2) +
304	762	(vut->r_arg == NULL ? 0 : 2) > 2)
305	3	VUT_Error(vut, 1, "Only one of -n and -r options may be used");
306
307	378	if (vut->r_arg != NULL && !vstrcmp(vut->r_arg, "-") && vut->D_opt)
308	0	VUT_Error(vut, 1, "Daemon cannot read from stdin");
309
310		/* Create and validate the query expression */
311	756	vut->vslq = VSLQ_New(vut->vsl, NULL,
312	378	(enum VSL_grouping_e)vut->g_arg, vut->q_arg);
313	378	if (vut->vslq == NULL)
314	192	VUT_Error(vut, 1, "Query expression error:\n%s",
315	96	VSL_Error(vut->vsl));
316
317	282	if (vut->dryrun_opt)
318	0	return;
319
320		/* Setup input */
321	282	if (vut->r_arg) {
322	21	c = VSL_CursorFile(vut->vsl, vut->r_arg, 0);
323	21	if (c == NULL)
324	6	VUT_Error(vut, 1, "%s", VSL_Error(vut->vsl));
325	15	VSLQ_SetCursor(vut->vslq, &c);
326	15	AZ(c);
327	15	} else {
328	261	vut->vsm = VSM_New();
329	261	AN(vut->vsm);
330	261	if (vut->n_arg && VSM_Arg(vut->vsm, 'n', vut->n_arg) <= 0)
331	0	VUT_Error(vut, 1, "%s", VSM_Error(vut->vsm));
332	261	if (vut->t_arg && VSM_Arg(vut->vsm, 't', vut->t_arg) <= 0)
333	9	VUT_Error(vut, 1, "%s", VSM_Error(vut->vsm));
334	252	if (VSM_Attach(vut->vsm, STDERR_FILENO))
335	3	VUT_Error(vut, 1, "VSM: %s", VSM_Error(vut->vsm));
336		// Cursor is handled in VUT_Main()
337		}
338
339		/* Open PID file */
340	264	if (vut->P_arg) {
341	12	if (pfh != NULL)
342	0	VUT_Error(vut, 1, "PID file already created");
343	12	pfh = VPF_Open(vut->P_arg, 0644, NULL);
344	12	if (pfh == NULL)
345	0	VUT_Error(vut, 1,
346	0	"%s: %s", vut->P_arg, strerror(errno));
347	12	}
348
349		/* Daemon mode */
350	264	if (vut->D_opt && vut_daemon(vut) == -1)
351	0	VUT_Error(vut, 1, "Daemon mode: %s", strerror(errno));
352
353		/* Write PID and setup exit handler */
354	264	if (vut->P_arg) {
355	12	AN(pfh);
356	12	VPF_Write(pfh);
357
358		/* NB: move ownership to a global pseudo-VUT. */
359	12	INIT_OBJ(&pfh_vut, VUT_MAGIC);
360	12	pfh_vut.P_arg = vut->P_arg;
361	12	pfh_vut.error_f = vut->error_f;
362	12	vut->P_arg = NULL;
363
364	12	AZ(atexit(vut_vpf_remove));
365	12	}
366	264	}
367
368		void
369	264	VUT_Fini(struct VUT **vutp)
370		{
371		struct VUT *vut;
372
373	264	TAKE_OBJ_NOTNULL(vut, vutp, VUT_MAGIC);
374	264	AN(vut->progname);
375
376	264	free(vut->n_arg);
377	264	free(vut->q_arg);
378	264	free(vut->r_arg);
379	264	free(vut->t_arg);
380	264	AZ(vut->P_arg);
381
382	264	if (vut->vslq)
383	264	VSLQ_Delete(&vut->vslq);
384	264	if (vut->vsl)
385	264	VSL_Delete(vut->vsl);
386	264	if (vut->vsm)
387	249	VSM_Destroy(&vut->vsm);
388
389	264	FREE_OBJ(vut);
390	264	}
391
392		static void
393	0	vut_CursorError(struct VUT vut, vtim_mono last)
394		{
395		const char *diag;
396		vtim_mono now;
397
398	0	CHECK_OBJ_NOTNULL(vut, VUT_MAGIC);
399	0	AN(vut->vsl);
400	0	AN(last);
401
402	0	diag = VSL_Error(vut->vsl);
403	0	if (diag == NULL)
404	0	diag = "Missing diagnostic";
405
406	0	now = VTIM_mono();
407	0	if (isnan(last) \|\| last + 1 < now) {
408	0	fprintf(stderr, "Failed to acquire log: %s\n", diag);
409	0	*last = now;
410	0	}
411	0	}
412
413		int
414	264	VUT_Main(struct VUT *vut)
415		{
416		struct VSL_cursor *c;
417	264	int i = -1;
418	264	int hascursor = -1;
419	264	vtim_mono t_failcursor = NAN;
420
421	264	CHECK_OBJ_NOTNULL(vut, VUT_MAGIC);
422	264	AN(vut->vslq);
423
424	20662	while (!VSIG_int && !VSIG_term && !vut->dryrun_opt) {
425	20626	if (VSIG_hup != vut->last_sighup) {
426		/* sighup callback */
427	12	vut->last_sighup = VSIG_hup;
428	12	if (vut->sighup_f != NULL)
429	6	i = vut->sighup_f(vut);
430		else
431	6	i = 1;
432	12	if (i)
433	6	break;
434	6	}
435
436	20620	if (VSIG_usr1 != vut->last_sigusr1) {
437		/* Flush and report any incomplete records */
438	0	vut->last_sigusr1 = VSIG_usr1;
439	0	(void)VSLQ_Flush(vut->vslq, vut_dispatch, vut);
440	0	}
441
442		/* We must repeatedly call VSM_Status() when !hascursor
443		* to make VSM discover our segment.
444		*
445		* XXX consider moving the error handling to VSLQ_Dispatch.
446		* or some other VSL utility function
447		* Reasons:
448		*
449		* - it does not seem to make much sense to call VSM_StillValid
450		* in vsl if that can only detect invalid segments after
451		* VSM_Status has run, so it appears both should be
452		* consolidated
453		*
454		* - not all VSL Clients will use VUT, yet the log abandoned/
455		* overrun situation will be occur for all of them.
456		*/
457
458	20620	if (vut->vsm != NULL &&
459	20605	(VSM_Status(vut->vsm) & VSM_WRK_RESTARTED)) {
460	0	if (hascursor < 1) {
461	0	fprintf(stderr, "Log abandoned (vsm)\n");
462	0	VSLQ_SetCursor(vut->vslq, NULL);
463	0	hascursor = 0;
464	0	}
465	0	}
466	20620	if (vut->vsm != NULL && hascursor < 1) {
467		/* Reconnect VSM */
468	249	AZ(vut->r_arg);
469	249	VTIM_sleep(0.1);
470	498	c = VSL_CursorVSM(vut->vsl, vut->vsm,
471	249	(vut->d_opt ? VSL_COPT_TAILSTOP : VSL_COPT_TAIL)
472	249	\| VSL_COPT_BATCH);
473	249	if (c == NULL) {
474	0	vut_CursorError(vut, &t_failcursor);
475	0	VSL_ResetError(vut->vsl);
476	0	continue;
477		}
478	249	if (hascursor >= 0)
479	0	fprintf(stderr, "Log reacquired\n");
480	249	hascursor = 1;
481	249	VSLQ_SetCursor(vut->vslq, &c);
482	249	AZ(c);
483	249	}
484
485	20620	do
486	53734	i = VSLQ_Dispatch(vut->vslq, vut_dispatch, vut);
487	33114	while (i == vsl_more &&
488	12494	VSIG_usr1 == vut->last_sigusr1 &&
489	12494	VSIG_hup == vut->last_sighup);
490
491	20620	if (i == vsl_more)
492	0	continue;
493	20620	else if (i == vsl_end) {
494	20398	if (vut->idle_f) {
495	9691	i = vut->idle_f(vut);
496	9691	if (i)
497	0	break;
498	9691	}
499	20398	VTIM_sleep(0.01);