GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2015 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * 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.
 *
 * VCL management stuff
 */

#include "config.h"

#include <errno.h>
#include <fcntl.h>
#include <fnmatch.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "mgt/mgt.h"
#include "mgt/mgt_vcl.h"
#include "common/heritage.h"

#include "vcli_serve.h"
#include "vct.h"
#include "vev.h"
#include "vte.h"
#include "vtim.h"

struct vclstate {
        const char              *name;
};

#define VCL_STATE(sym, str)                                             \
        static const struct vclstate VCL_STATE_ ## sym[1] = {{ str }};
#include "tbl/vcl_states.h"

static const struct vclstate VCL_STATE_LABEL[1] = {{ "label" }};

static unsigned vcl_count;

struct vclproghead vclhead = VTAILQ_HEAD_INITIALIZER(vclhead);
static struct vclproghead discardhead = VTAILQ_HEAD_INITIALIZER(discardhead);
struct vmodfilehead vmodhead = VTAILQ_HEAD_INITIALIZER(vmodhead);
static struct vclprog *mgt_vcl_active;
static struct vev *e_poker;

static int mgt_vcl_setstate(struct cli *, struct vclprog *,
    const struct vclstate *);
static int mgt_vcl_settemp(struct cli *, struct vclprog *, unsigned);
static int mgt_vcl_askchild(struct cli *, struct vclprog *, unsigned);
static void mgt_vcl_set_cooldown(struct vclprog *, vtim_mono);

/*--------------------------------------------------------------------*/

static const struct vclstate *
mcf_vcl_parse_state(struct cli *cli, const char *s)
{
        if (s != NULL) {
#define VCL_STATE(sym, str)                             \
                if (!strcmp(s, str))                    \
                        return (VCL_STATE_ ## sym);
#include "tbl/vcl_states.h"
        }
        VCLI_Out(cli, "State must be one of auto, cold or warm.");
        VCLI_SetResult(cli, CLIS_PARAM);
        return (NULL);
}

struct vclprog *
mcf_vcl_byname(const char *name)
{
        struct vclprog *vp;

        VTAILQ_FOREACH(vp, &vclhead, list)
                if (!strcmp(name, vp->name))
                        return (vp);
        return (NULL);
}

static int
mcf_invalid_vclname(struct cli *cli, const char *name)
{
        const char *bad;

        AN(name);
        bad = VCT_invalid_name(name, NULL);

        if (bad != NULL) {
                VCLI_SetResult(cli, CLIS_PARAM);
                VCLI_Out(cli, "Illegal character in VCL name ");
                if (*bad > 0x20 && *bad < 0x7f)
                        VCLI_Out(cli, "('%c')", *bad);
                else
                        VCLI_Out(cli, "(0x%02x)", *bad & 0xff);
                return (-1);
        }
        return (0);
}

static struct vclprog *
mcf_find_vcl(struct cli *cli, const char *name)
{
        struct vclprog *vp;

        if (mcf_invalid_vclname(cli, name))
                return (NULL);

        vp = mcf_vcl_byname(name);
        if (vp == NULL) {
                VCLI_SetResult(cli, CLIS_PARAM);
                VCLI_Out(cli, "No VCL named %s known\n", name);
        }
        return (vp);
}

static int
mcf_find_no_vcl(struct cli *cli, const char *name)
{

        if (mcf_invalid_vclname(cli, name))
                return (0);

        if (mcf_vcl_byname(name) != NULL) {
                VCLI_SetResult(cli, CLIS_PARAM);
                VCLI_Out(cli, "Already a VCL named %s", name);
                return (0);
        }
        return (1);
}

int
mcf_is_label(const struct vclprog *vp)
{
        return (vp->state == VCL_STATE_LABEL);
}

/*--------------------------------------------------------------------*/

struct vcldep *
mgt_vcl_dep_add(struct vclprog *vp_from, struct vclprog *vp_to)
{
        struct vcldep *vd;

        CHECK_OBJ_NOTNULL(vp_from, VCLPROG_MAGIC);
        CHECK_OBJ_NOTNULL(vp_to, VCLPROG_MAGIC);
        assert(vp_to->state != VCL_STATE_COLD);

        ALLOC_OBJ(vd, VCLDEP_MAGIC);
        AN(vd);

        mgt_vcl_set_cooldown(vp_from, -1);
        mgt_vcl_set_cooldown(vp_to, -1);

        vd->from = vp_from;
        VTAILQ_INSERT_TAIL(&vp_from->dfrom, vd, lfrom);
        vd->to = vp_to;
        VTAILQ_INSERT_TAIL(&vp_to->dto, vd, lto);
        vp_to->nto++;
        return (vd);
}

static void
mgt_vcl_dep_del(struct vcldep *vd)
{

        CHECK_OBJ_NOTNULL(vd, VCLDEP_MAGIC);
        VTAILQ_REMOVE(&vd->from->dfrom, vd, lfrom);
        VTAILQ_REMOVE(&vd->to->dto, vd, lto);
        vd->to->nto--;
        if (vd->to->nto == 0)
                mgt_vcl_set_cooldown(vd->to, VTIM_mono());
        FREE_OBJ(vd);
}

/*--------------------------------------------------------------------*/

static struct vclprog *
mgt_vcl_add(const char *name, const struct vclstate *state)
{
        struct vclprog *vp;

        assert(state == VCL_STATE_WARM ||
               state == VCL_STATE_COLD ||
               state == VCL_STATE_AUTO ||
               state == VCL_STATE_LABEL);
        ALLOC_OBJ(vp, VCLPROG_MAGIC);
        XXXAN(vp);
        REPLACE(vp->name, name);
        VTAILQ_INIT(&vp->dfrom);
        VTAILQ_INIT(&vp->dto);
        VTAILQ_INIT(&vp->vmods);
        vp->state = state;

        if (vp->state != VCL_STATE_COLD)
                vp->warm = 1;

        VTAILQ_INSERT_TAIL(&vclhead, vp, list);
        if (vp->state != VCL_STATE_LABEL)
                vcl_count++;
        return (vp);
}

static void
mgt_vcl_del(struct vclprog *vp)
{
        char *p;
        struct vmoddep *vd;
        struct vmodfile *vf;
        struct vcldep *dep;

        CHECK_OBJ_NOTNULL(vp, VCLPROG_MAGIC);
        assert(VTAILQ_EMPTY(&vp->dto));

        mgt_vcl_symtab_clean(vp);

        while ((dep = VTAILQ_FIRST(&vp->dfrom)) != NULL) {
                assert(dep->from == vp);
                mgt_vcl_dep_del(dep);
        }

        VTAILQ_REMOVE(&vclhead, vp, list);
        if (vp->state != VCL_STATE_LABEL)
                vcl_count--;
        if (vp->fname != NULL) {
                if (!MGT_DO_DEBUG(DBG_VCL_KEEP))
                        AZ(unlink(vp->fname));
                p = strrchr(vp->fname, '/');
                AN(p);
                *p = '\0';
                VJ_master(JAIL_MASTER_FILE);
                /*
                 * This will fail if any files are dropped next to the library
                 * without us knowing.  This happens for instance with GCOV.
                 * Assume developers know how to clean up after themselves
                 * (or alternatively:  How to run out of disk space).
                 */
                (void)rmdir(vp->fname);
                VJ_master(JAIL_MASTER_LOW);
                free(vp->fname);
        }
        while (!VTAILQ_EMPTY(&vp->vmods)) {
                vd = VTAILQ_FIRST(&vp->vmods);
                CHECK_OBJ(vd, VMODDEP_MAGIC);
                vf = vd->to;
                CHECK_OBJ(vf, VMODFILE_MAGIC);
                VTAILQ_REMOVE(&vp->vmods, vd, lfrom);
                VTAILQ_REMOVE(&vf->vcls, vd, lto);
                FREE_OBJ(vd);

                if (VTAILQ_EMPTY(&vf->vcls)) {
                        if (!MGT_DO_DEBUG(DBG_VMOD_SO_KEEP))
                                AZ(unlink(vf->fname));
                        VTAILQ_REMOVE(&vmodhead, vf, list);
                        free(vf->fname);
                        FREE_OBJ(vf);
                }
        }
        free(vp->name);
        FREE_OBJ(vp);
}

const char *
mgt_has_vcl(void)
{
        if (VTAILQ_EMPTY(&vclhead))
                return ("No VCL loaded");
        if (mgt_vcl_active == NULL)
                return ("No active VCL");
        CHECK_OBJ_NOTNULL(mgt_vcl_active, VCLPROG_MAGIC);
        AN(mgt_vcl_active->warm);
        return (NULL);
}

/*
 * go_cold
 *
 * -1: leave alone
 *  0: timer not started - not currently used
 * >0: when timer started
 */
static void
mgt_vcl_set_cooldown(struct vclprog *vp, vtim_mono now)
{
        CHECK_OBJ_NOTNULL(vp, VCLPROG_MAGIC);

        if (vp == mgt_vcl_active ||
            vp->state != VCL_STATE_AUTO ||
            vp->warm == 0 ||
            !VTAILQ_EMPTY(&vp->dto) ||
            !VTAILQ_EMPTY(&vp->dfrom))
                vp->go_cold = -1;
        else
                vp->go_cold = now;
}

static int
mgt_vcl_settemp(struct cli *cli, struct vclprog *vp, unsigned warm)
{
        int i;

        CHECK_OBJ_NOTNULL(vp, VCLPROG_MAGIC);

        if (warm == vp->warm)
                return (0);

        if (vp->state == VCL_STATE_AUTO || vp->state == VCL_STATE_LABEL) {
                mgt_vcl_set_cooldown(vp, -1);
                i = mgt_vcl_askchild(cli, vp, warm);
                mgt_vcl_set_cooldown(vp, VTIM_mono());
        } else {
                i = mgt_vcl_setstate(cli, vp,
                    warm ? VCL_STATE_WARM : VCL_STATE_COLD);
        }

        return (i);
}

static int
mgt_vcl_requirewarm(struct cli *cli, struct vclprog *vp)
{
        if (vp->state == VCL_STATE_COLD) {
                VCLI_SetResult(cli, CLIS_CANT);
                VCLI_Out(cli, "VCL '%s' is cold - set to auto or warm first",
                    vp->name);
                return (1);
        }
        return (mgt_vcl_settemp(cli, vp, 1));
}

static int
mgt_vcl_askchild(struct cli *cli, struct vclprog *vp, unsigned warm)
{
        unsigned status;
        char *p;
        int i;

        CHECK_OBJ_NOTNULL(vp, VCLPROG_MAGIC);

        if (!MCH_Running()) {
                vp->warm = warm;
                return (0);
        }

        i = mgt_cli_askchild(&status, &p, "vcl.state %s %d%s\n",
            vp->name, warm, vp->state->name);
        if (i && cli != NULL) {
                VCLI_SetResult(cli, status);
                VCLI_Out(cli, "%s", p);
        } else if (i) {
                MGT_Complain(C_ERR,
                    "Please file ticket: VCL poker problem: "
                    "'vcl.state %s %d%s' -> %03d '%s'",
                    vp->name, warm, vp->state->name, i, p);
        } else {
                /* Success, update mgt's VCL state to reflect child's
                   state */
                vp->warm = warm;
        }

        free(p);
        return (i);
}

static int
mgt_vcl_setstate(struct cli *cli, struct vclprog *vp, const struct vclstate *vs)
{
        unsigned warm;
        int i;
        const struct vclstate *os;

        CHECK_OBJ_NOTNULL(vp, VCLPROG_MAGIC);

        assert(vs != VCL_STATE_LABEL);

        if (mcf_is_label(vp)) {
                AN(vp->warm);
                /* do not touch labels */
                return (0);
        }

        if (vp->state == vs)
                return (0);

        os = vp->state;
        vp->state = vs;

        if (vp == mgt_vcl_active) {
                assert (vs == VCL_STATE_WARM || vs == VCL_STATE_AUTO);
                AN(vp->warm);
                warm = 1;
        } else if (vs == VCL_STATE_AUTO) {
                warm = vp->warm;
        } else {
                warm = (vs == VCL_STATE_WARM ? 1 : 0);
        }

        i = mgt_vcl_askchild(cli, vp, warm);
        if (i == 0)
                mgt_vcl_set_cooldown(vp, VTIM_mono());
        else
                vp->state = os;
        return (i);
}

/*--------------------------------------------------------------------*/

static struct vclprog *
mgt_new_vcl(struct cli *cli, const char *vclname, const char *vclsrc,
    const char *vclsrcfile, const char *state, int C_flag)
{
        unsigned status;
        char *lib, *p;
        struct vclprog *vp;
        const struct vclstate *vs;

        AN(cli);

        if (vcl_count >= mgt_param.max_vcl &&
            mgt_param.max_vcl_handling == 2) {
                VCLI_Out(cli, "Too many (%d) VCLs already loaded\n", vcl_count);
                VCLI_Out(cli, "(See max_vcl and max_vcl_handling parameters)");
                VCLI_SetResult(cli, CLIS_CANT);
                return (NULL);
        }

        if (state == NULL)
                vs = VCL_STATE_AUTO;
        else
                vs = mcf_vcl_parse_state(cli, state);

        if (vs == NULL)
                return (NULL);

        vp = mgt_vcl_add(vclname, vs);
        lib = mgt_VccCompile(cli, vp, vclname, vclsrc, vclsrcfile, C_flag);
        if (lib == NULL) {
                mgt_vcl_del(vp);
                return (NULL);
        }

        AZ(C_flag);
        vp->fname = lib;

        if ((cli->result == CLIS_OK || cli->result == CLIS_TRUNCATED) &&
            vcl_count > mgt_param.max_vcl &&
            mgt_param.max_vcl_handling == 1) {
                VCLI_Out(cli, "%d VCLs loaded\n", vcl_count);
                VCLI_Out(cli, "Remember to vcl.discard the old/unused VCLs.\n");
                VCLI_Out(cli, "(See max_vcl and max_vcl_handling parameters)");
        }

        if (!MCH_Running())
                return (vp);

        if (mgt_cli_askchild(&status, &p, "vcl.load %s %s %d%s\n",
            vp->name, vp->fname, vp->warm, vp->state->name)) {
                mgt_vcl_del(vp);
                VCLI_Out(cli, "%s", p);
                VCLI_SetResult(cli, status);
                free(p);
                return (NULL);
        }
        free(p);

        mgt_vcl_set_cooldown(vp, VTIM_mono());
        return (vp);
}

/*--------------------------------------------------------------------*/

void
mgt_vcl_startup(struct cli *cli, const char *vclsrc, const char *vclname,
    const char *origin, int C_flag)
{
        char buf[20];
        static int n = 0;
        struct vclprog *vp;

        AZ(MCH_Running());

        AN(vclsrc);
        AN(origin);
        if (vclname == NULL) {
                bprintf(buf, "boot%d", n++);
                vclname = buf;
        }
        vp = mgt_new_vcl(cli, vclname, vclsrc, origin, NULL, C_flag);
        if (vp != NULL) {
                /* Last startup VCL becomes the automatically selected
                 * active VCL. */
                AN(vp->warm);
                mgt_vcl_active = vp;
        }
}

/*--------------------------------------------------------------------*/

int
mgt_push_vcls(struct cli *cli, unsigned *status, char **p)
{
        struct vclprog *vp;
        struct vcldep *vd;
        int done;

        AN(mgt_vcl_active);

        /* The VCL has not been loaded yet, it cannot fail */
        (void)cli;

        VTAILQ_FOREACH(vp, &vclhead, list)
                vp->loaded = 0;

        do {
                done = 1;
                VTAILQ_FOREACH(vp, &vclhead, list) {
                        if (vp->loaded)
                                continue;
                        VTAILQ_FOREACH(vd, &vp->dfrom, lfrom)
                                if (!vd->to->loaded)
                                        break;
                        if (vd != NULL) {
                                done = 0;
                                continue;
                        }
                        if (mcf_is_label(vp)) {
                                vd = VTAILQ_FIRST(&vp->dfrom);
                                AN(vd);
                                if (mgt_cli_askchild(status, p,
                                    "vcl.label %s %s\n",
                                    vp->name, vd->to->name))
                                        return (1);
                        } else {
                                if (mgt_cli_askchild(status, p,
                                    "vcl.load \"%s\" %s %d%s\n",
                                    vp->name, vp->fname, vp->warm,
                                    vp->state->name))
                                        return (1);
                        }
                        vp->loaded = 1;
                        free(*p);
                        *p = NULL;
                }
        } while (!done);

        if (mgt_cli_askchild(status, p, "vcl.use \"%s\"\n",
              mgt_vcl_active->name)) {
                return (1);
        }
        free(*p);
        *p = NULL;
        return (0);
}

/*--------------------------------------------------------------------*/

static void v_matchproto_(cli_func_t)
mcf_vcl_inline(struct cli *cli, const char * const *av, void *priv)
{
        struct vclprog *vp;

        (void)priv;

        if (!mcf_find_no_vcl(cli, av[2]))
                return;

        vp = mgt_new_vcl(cli, av[2], av[3], "<vcl.inline>", av[4], 0);
        if (vp != NULL && !MCH_Running())
                VCLI_Out(cli, "VCL compiled.\n");
}

static void v_matchproto_(cli_func_t)
mcf_vcl_load(struct cli *cli, const char * const *av, void *priv)
{
        struct vclprog *vp;

        (void)priv;
        if (!mcf_find_no_vcl(cli, av[2]))
                return;

        vp = mgt_new_vcl(cli, av[2], NULL, av[3], av[4], 0);
        if (vp != NULL && !MCH_Running())
                VCLI_Out(cli, "VCL compiled.\n");
}


static void v_matchproto_(cli_func_t)
mcf_vcl_state(struct cli *cli, const char * const *av, void *priv)
{
        const struct vclstate *state;
        struct vclprog *vp;

        (void)priv;
        vp = mcf_find_vcl(cli, av[2]);
        if (vp == NULL)
                return;

        if (mcf_is_label(vp)) {
                VCLI_Out(cli, "Labels are always warm");
                VCLI_SetResult(cli, CLIS_PARAM);
                return;
        }

        state = mcf_vcl_parse_state(cli, av[3]);
        if (state == NULL)
                return;

        if (state == VCL_STATE_COLD) {
                if (!VTAILQ_EMPTY(&vp->dto)) {
                        assert(vp->state != VCL_STATE_COLD);
                        VCLI_Out(cli, "A labeled VCL cannot be set cold");
                        VCLI_SetResult(cli, CLIS_CANT);
                        return;
                }
                if (vp == mgt_vcl_active) {
                        VCLI_Out(cli, "Cannot set the active VCL cold.");
                        VCLI_SetResult(cli, CLIS_CANT);
                        return;
                }
        }

        (void)mgt_vcl_setstate(cli, vp, state);
}

static void v_matchproto_(cli_func_t)
mcf_vcl_use(struct cli *cli, const char * const *av, void *priv)
{
        unsigned status;
        char *p = NULL;
        struct vclprog *vp, *vp2;
        vtim_mono now;

        (void)priv;
        vp = mcf_find_vcl(cli, av[2]);
        if (vp == NULL)
                return;
        if (vp == mgt_vcl_active)
                return;

        if (mgt_vcl_requirewarm(cli, vp))
                return;

        if (MCH_Running() &&
            mgt_cli_askchild(&status, &p, "vcl.use %s\n", av[2])) {
                VCLI_SetResult(cli, status);
                VCLI_Out(cli, "%s", p);
        } else {
                VCLI_Out(cli, "VCL '%s' now active", av[2]);
                vp2 = mgt_vcl_active;
                mgt_vcl_active = vp;
                now = VTIM_mono();
                mgt_vcl_set_cooldown(vp, now);
                if (vp2 != NULL)
                        mgt_vcl_set_cooldown(vp2, now);
        }
        free(p);
}

static void
mgt_vcl_discard(struct cli *cli, struct vclprog *vp)
{
        char *p = NULL;
        unsigned status;

        AN(vp);
        AN(vp->discard);
        assert(vp != mgt_vcl_active);

        while (!VTAILQ_EMPTY(&vp->dto))
                mgt_vcl_discard(cli, VTAILQ_FIRST(&vp->dto)->from);

        if (mcf_is_label(vp)) {
                AN(vp->warm);
                vp->warm = 0;
        } else {
                (void)mgt_vcl_setstate(cli, vp, VCL_STATE_COLD);
        }
        if (MCH_Running()) {
                AZ(vp->warm);
                if (mgt_cli_askchild(&status, &p, "vcl.discard %s\n", vp->name))
                        assert(status == CLIS_OK || status == CLIS_COMMS);
                free(p);
        }
        VTAILQ_REMOVE(&discardhead, vp, discard_list);
        mgt_vcl_del(vp);
}

static int
mgt_vcl_discard_mark(struct cli *cli, const char *glob)
{
        struct vclprog *vp;
        unsigned marked = 0;

        VTAILQ_FOREACH(vp, &vclhead, list) {
                if (fnmatch(glob, vp->name, 0))
                        continue;
                if (vp == mgt_vcl_active) {
                        VCLI_SetResult(cli, CLIS_CANT);
                        VCLI_Out(cli, "Cannot discard active VCL program %s\n",
                            vp->name);
                        return (-1);
                }
                if (!vp->discard)
                        VTAILQ_INSERT_TAIL(&discardhead, vp, discard_list);
                vp->discard = 1;
                marked++;
        }

        if (marked == 0) {
                VCLI_SetResult(cli, CLIS_PARAM);
                VCLI_Out(cli, "No VCL name matches %s\n", glob);
        }

        return (marked);
}

static void
mgt_vcl_discard_depfail(struct cli *cli, struct vclprog *vp)
{
        struct vcldep *vd;
        int n;

        AN(cli);
        AN(vp);
        assert(!VTAILQ_EMPTY(&vp->dto));

        VCLI_SetResult(cli, CLIS_CANT);
        AN(vp->warm);
        if (!mcf_is_label(vp))
                VCLI_Out(cli, "Cannot discard labeled VCL program %s:\n",
                    vp->name);
        else
                VCLI_Out(cli,
                    "Cannot discard VCL label %s, other VCLs depend on it:\n",
                    vp->name);
        n = 0;
        VTAILQ_FOREACH(vd, &vp->dto, lto) {
                if (n++ == 5) {
                        VCLI_Out(cli, "\t[...]");
                        break;
                }
                VCLI_Out(cli, "\t%s\n", vd->from->name);
        }
}

static int
mgt_vcl_discard_depcheck(struct cli *cli)
{
        struct vclprog *vp;
        struct vcldep *vd;

        VTAILQ_FOREACH(vp, &discardhead, discard_list) {
                VTAILQ_FOREACH(vd, &vp->dto, lto)
                        if (!vd->from->discard) {
                                mgt_vcl_discard_depfail(cli, vp);
                                return (-1);
                        }
        }

        return (0);
}

static void
mgt_vcl_discard_clear(void)
{
        struct vclprog *vp, *vp2;

        VTAILQ_FOREACH_SAFE(vp, &discardhead, discard_list, vp2) {
                AN(vp->discard);
                vp->discard = 0;
                VTAILQ_REMOVE(&discardhead, vp, discard_list);
        }
}

static void v_matchproto_(cli_func_t)
mcf_vcl_discard(struct cli *cli, const char * const *av, void *priv)
{
        const struct vclprog *vp;

        (void)priv;

        assert(VTAILQ_EMPTY(&discardhead));
        VTAILQ_FOREACH(vp, &vclhead, list)
                AZ(vp->discard);

        for (av += 2; *av != NULL; av++) {
                if (mgt_vcl_discard_mark(cli, *av) <= 0) {
                        mgt_vcl_discard_clear();
                        break;
                }
        }

        if (mgt_vcl_discard_depcheck(cli) != 0)
                mgt_vcl_discard_clear();

        while (!VTAILQ_EMPTY(&discardhead))
                mgt_vcl_discard(cli, VTAILQ_FIRST(&discardhead));
}

static void v_matchproto_(cli_func_t)
mcf_vcl_list(struct cli *cli, const char * const *av, void *priv)
{
        unsigned status;
        char *p;
        struct vclprog *vp;
        struct vcldep *vd;
        const struct vclstate *vs;
        struct vte *vte;

        /* NB: Shall generate same output as vcl_cli_list() */

        (void)av;
        (void)priv;

        if (MCH_Running()) {
                if (!mgt_cli_askchild(&status, &p, "vcl.list\n")) {
                        VCLI_SetResult(cli, status);
                        VCLI_Out(cli, "%s", p);
                }
                free(p);
        } else {
                vte = VTE_new(7, 80);
                AN(vte);

                VTAILQ_FOREACH(vp, &vclhead, list) {
                        VTE_printf(vte, "%s",
                            vp == mgt_vcl_active ? "active" : "available");
                        vs = vp->warm ?  VCL_STATE_WARM : VCL_STATE_COLD;
                        VTE_printf(vte, "\t%s\t%s", vp->state->name, vs->name);
                        VTE_printf(vte, "\t-\t%s", vp->name);
                        if (mcf_is_label(vp)) {
                                vd = VTAILQ_FIRST(&vp->dfrom);
                                AN(vd);
                                VTE_printf(vte, "\t->\t%s", vd->to->name);
                                if (vp->nto > 0)
                                        VTE_printf(vte, " (%d return(vcl)%s)",
                                            vp->nto, vp->nto > 1 ? "'s" : "");
                        } else if (vp->nto > 0) {
                                VTE_printf(vte, "\t<-\t(%d label%s)",
                                    vp->nto, vp->nto > 1 ? "s" : "");
                        }
                        VTE_cat(vte, "\n");
                }
                AZ(VTE_finish(vte));
                AZ(VTE_format(vte, VCLI_VTE_format, cli));
                VTE_destroy(&vte);
        }
}

static void v_matchproto_(cli_func_t)
mcf_vcl_list_json(struct cli *cli, const char * const *av, void *priv)
{
        unsigned status;
        char *p;
        struct vclprog *vp;
        struct vcldep *vd;
        const struct vclstate *vs;

        /* NB: Shall generate same output as vcl_cli_list() */

        (void)priv;
        if (MCH_Running()) {
                if (!mgt_cli_askchild(&status, &p, "vcl.list -j\n")) {
                        VCLI_SetResult(cli, status);
                        VCLI_Out(cli, "%s", p);
                }
                free(p);
        } else {
                VCLI_JSON_begin(cli, 2, av);
                VTAILQ_FOREACH(vp, &vclhead, list) {
                        VCLI_Out(cli, ",\n");
                        VCLI_Out(cli, "{\n");
                        VSB_indent(cli->sb, 2);
                        VCLI_Out(cli, "\"status\": \"%s\",\n",
                            vp == mgt_vcl_active ? "active" : "available");
                        VCLI_Out(cli, "\"state\": \"%s\",\n", vp->state->name);
                        vs = vp->warm ?  VCL_STATE_WARM : VCL_STATE_COLD;
                        VCLI_Out(cli, "\"temperature\": \"%s\",\n", vs->name);
                        VCLI_Out(cli, "\"name\": \"%s\"", vp->name);
                        if (mcf_is_label(vp)) {
                                vd = VTAILQ_FIRST(&vp->dfrom);
                                AN(vd);
                                VCLI_Out(cli, ",\n");
                                VCLI_Out(cli, "\"label\": {\n");
                                VSB_indent(cli->sb, 2);
                                VCLI_Out(cli, "\"name\": \"%s\"", vd->to->name);
                                if (vp->nto > 0)
                                        VCLI_Out(cli, ",\n\"refs\": %d",
                                                 vp->nto);
                                VSB_indent(cli->sb, -2);
                                VCLI_Out(cli, "\n");
                                VCLI_Out(cli, "}");
                        } else if (vp->nto > 0) {
                                VCLI_Out(cli, ",\n");
                                VCLI_Out(cli, "\"labels\": %d", vp->nto);
                        }
                        VSB_indent(cli->sb, -2);
                        VCLI_Out(cli, "\n}");
                }
                VCLI_JSON_end(cli);
        }
}

static int
mcf_vcl_check_dag(struct cli *cli, struct vclprog *tree, struct vclprog *target)
{
        struct vcldep *vd;

        if (target == tree)
                return (1);
        VTAILQ_FOREACH(vd, &tree->dfrom, lfrom) {
                if (!mcf_vcl_check_dag(cli, vd->to, target))
                        continue;
                if (mcf_is_label(tree))
                        VCLI_Out(cli, "Label %s points to vcl %s\n",
                            tree->name, vd->to->name);
                else
                        VCLI_Out(cli, "Vcl %s uses Label %s\n",
                            tree->name, vd->to->name);
                return (1);
        }
        return (0);
}

static void v_matchproto_(cli_func_t)
mcf_vcl_label(struct cli *cli, const char * const *av, void *priv)
{
        struct vclprog *vpl;
        struct vclprog *vpt;
        unsigned status;
        char *p;
        int i;

        (void)priv;
        if (mcf_invalid_vclname(cli, av[2]))
                return;
        vpl = mcf_vcl_byname(av[2]);
        if (vpl != NULL && !mcf_is_label(vpl)) {
                VCLI_SetResult(cli, CLIS_PARAM);
                VCLI_Out(cli, "%s is not a label", vpl->name);
                return;
        }
        vpt = mcf_find_vcl(cli, av[3]);
        if (vpt == NULL)
                return;
        if (mcf_is_label(vpt)) {
                VCLI_SetResult(cli, CLIS_CANT);
                VCLI_Out(cli, "VCL labels cannot point to labels");
                return;
        }
        if (vpl != NULL) {
                if (VTAILQ_FIRST(&vpl->dfrom)->to != vpt &&
                    mcf_vcl_check_dag(cli, vpt, vpl)) {
                        VCLI_Out(cli,
                            "Pointing label %s at %s would create a loop",
                            vpl->name, vpt->name);
                        VCLI_SetResult(cli, CLIS_PARAM);
                        return;
                }
        }

        if (mgt_vcl_requirewarm(cli, vpt))
                return;

        if (vpl != NULL) {
                /* potentially fail before we delete the dependency */
                if (mgt_vcl_requirewarm(cli, vpl))
                        return;
                mgt_vcl_dep_del(VTAILQ_FIRST(&vpl->dfrom));
                AN(VTAILQ_EMPTY(&vpl->dfrom));
        } else {
                vpl = mgt_vcl_add(av[2], VCL_STATE_LABEL);
        }

        AN(vpl);
        if (mgt_vcl_requirewarm(cli, vpl))
                return;
        (void)mgt_vcl_dep_add(vpl, vpt);

        if (!MCH_Running())
                return;

        i = mgt_cli_askchild(&status, &p, "vcl.label %s %s\n", av[2], av[3]);
        if (i) {
                VCLI_SetResult(cli, status);
                VCLI_Out(cli, "%s", p);
        }
        free(p);
}

static void v_matchproto_(cli_func_t)
mcf_vcl_deps(struct cli *cli, const char * const *av, void *priv)
{
        struct vclprog *vp;
        struct vcldep *vd;
        struct vte *vte;

        (void)av;
        (void)priv;

        vte = VTE_new(2, 80);
        AN(vte);

        VTAILQ_FOREACH(vp, &vclhead, list) {
                if (VTAILQ_EMPTY(&vp->dfrom)) {
                        VTE_printf(vte, "%s\n", vp->name);
                        continue;
                }
                VTAILQ_FOREACH(vd, &vp->dfrom, lfrom)
                        VTE_printf(vte, "%s\t%s\n", vp->name, vd->to->name);
        }
        AZ(VTE_finish(vte));
        AZ(VTE_format(vte, VCLI_VTE_format, cli));
        VTE_destroy(&vte);
}

static void v_matchproto_(cli_func_t)
mcf_vcl_deps_json(struct cli *cli, const char * const *av, void *priv)
{
        struct vclprog *vp;
        struct vcldep *vd;
        const char *sepd, *sepa;

        (void)priv;

        VCLI_JSON_begin(cli, 1, av);

        VTAILQ_FOREACH(vp, &vclhead, list) {
                VCLI_Out(cli, ",\n");
                VCLI_Out(cli, "{\n");
                VSB_indent(cli->sb, 2);
                VCLI_Out(cli, "\"name\": \"%s\",\n", vp->name);
                VCLI_Out(cli, "\"deps\": [");
                VSB_indent(cli->sb, 2);
                sepd = "";
                sepa = "";
                VTAILQ_FOREACH(vd, &vp->dfrom, lfrom) {
                        VCLI_Out(cli, "%s\n", sepd);
                        VCLI_Out(cli, "\"%s\"", vd->to->name);
                        sepd = ",";
                        sepa = "\n";
                }
                VSB_indent(cli->sb, -2);
                VCLI_Out(cli, "%s", sepa);
                VCLI_Out(cli, "]\n");
                VSB_indent(cli->sb, -2);
                VCLI_Out(cli, "}");
        }

        VCLI_JSON_end(cli);
}

/*--------------------------------------------------------------------*/

static int v_matchproto_(vev_cb_f)
mgt_vcl_poker(const struct vev *e, int what)
{
        struct vclprog *vp;
        vtim_mono now;

        (void)e;
        (void)what;
        e_poker->timeout = mgt_param.vcl_cooldown * .45;
        now = VTIM_mono();
        VTAILQ_FOREACH(vp, &vclhead, list) {
                if (vp->go_cold == 0)
                        mgt_vcl_set_cooldown(vp, now);
                else if (vp->go_cold > 0 &&
                    vp->go_cold + mgt_param.vcl_cooldown < now)
                        (void)mgt_vcl_settemp(NULL, vp, 0);
        }
        return (0);
}

/*--------------------------------------------------------------------*/

static struct cli_proto cli_vcl[] = {
        { CLICMD_VCL_LOAD,              "", mcf_vcl_load },
        { CLICMD_VCL_INLINE,            "", mcf_vcl_inline },
        { CLICMD_VCL_USE,               "", mcf_vcl_use },
        { CLICMD_VCL_STATE,             "", mcf_vcl_state },
        { CLICMD_VCL_DISCARD,           "", mcf_vcl_discard },
        { CLICMD_VCL_LIST,              "", mcf_vcl_list, mcf_vcl_list_json },
        { CLICMD_VCL_DEPS,              "", mcf_vcl_deps, mcf_vcl_deps_json },
        { CLICMD_VCL_LABEL,             "", mcf_vcl_label },
        { CLICMD_DEBUG_VCL_SYMTAB,      "d", mcf_vcl_symtab },
        { NULL }
};

/*--------------------------------------------------------------------*/

static void
mgt_vcl_atexit(void)
{
        struct vclprog *vp, *vp2;

        if (getpid() != heritage.mgt_pid)
                return;
        mgt_vcl_active = NULL;
        while (!VTAILQ_EMPTY(&vclhead))
                VTAILQ_FOREACH_SAFE(vp, &vclhead, list, vp2)
                        if (VTAILQ_EMPTY(&vp->dto))
                                mgt_vcl_del(vp);
}

void
mgt_vcl_init(void)
{

        e_poker = VEV_Alloc();
        AN(e_poker);
        e_poker->timeout = 3;           // random, prime

        e_poker->callback = mgt_vcl_poker;
        e_poker->name = "vcl poker";
        AZ(VEV_Start(mgt_evb, e_poker));

        AZ(atexit(mgt_vcl_atexit));

        VCLS_AddFunc(mgt_cls, MCF_AUTH, cli_vcl);
}

		varnish-cache/bin/varnishd/mgt/mgt_vcl.c
0		/*-
1	200	* Copyright (c) 2006 Verdens Gang AS
2	96	* Copyright (c) 2006-2015 Varnish Software AS
3	32	* All rights reserved.
4		*
5		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
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		* VCL management stuff
31		*/
32
33		#include "config.h"
34
35		#include <errno.h>
36		#include <fcntl.h>
37		#include <fnmatch.h>
38		#include <signal.h>
39		#include <stdio.h>
40		#include <stdlib.h>
41		#include <string.h>
42		#include <unistd.h>
43
44		#include "mgt/mgt.h"
45		#include "mgt/mgt_vcl.h"
46		#include "common/heritage.h"
47
48		#include "vcli_serve.h"
49		#include "vct.h"
50		#include "vev.h"
51		#include "vte.h"
52		#include "vtim.h"
53
54		struct vclstate {
55		const char *name;
56		};
57
58		#define VCL_STATE(sym, str) \
59		static const struct vclstate VCL_STATE_ ## sym[1] = {{ str }};
60		#include "tbl/vcl_states.h"
61
62		static const struct vclstate VCL_STATE_LABEL[1] = {{ "label" }};
63
64		static unsigned vcl_count;
65
66		struct vclproghead vclhead = VTAILQ_HEAD_INITIALIZER(vclhead);
67		static struct vclproghead discardhead = VTAILQ_HEAD_INITIALIZER(discardhead);
68		struct vmodfilehead vmodhead = VTAILQ_HEAD_INITIALIZER(vmodhead);
69		static struct vclprog *mgt_vcl_active;
70		static struct vev *e_poker;
71
72		static int mgt_vcl_setstate(struct cli , struct vclprog ,
73		const struct vclstate *);
74		static int mgt_vcl_settemp(struct cli , struct vclprog , unsigned);
75		static int mgt_vcl_askchild(struct cli , struct vclprog , unsigned);
76		static void mgt_vcl_set_cooldown(struct vclprog *, vtim_mono);
77
78		/--------------------------------------------------------------------/
79
80		static const struct vclstate *
81	200	mcf_vcl_parse_state(struct cli cli, const char s)
82		{
83	200	if (s != NULL) {
84		#define VCL_STATE(sym, str) \
85		if (!strcmp(s, str)) \
86		return (VCL_STATE_ ## sym);
87		#include "tbl/vcl_states.h"
88		}
89	0	VCLI_Out(cli, "State must be one of auto, cold or warm.");
90	0	VCLI_SetResult(cli, CLIS_PARAM);
91	0	return (NULL);
92	200	}
93
94		struct vclprog *
95	22808	mcf_vcl_byname(const char *name)
96		{
97		struct vclprog *vp;
98
99	38288	VTAILQ_FOREACH(vp, &vclhead, list)
100	25784	if (!strcmp(name, vp->name))
101	10304	return (vp);
102	12504	return (NULL);
103	22808	}
104
105		static int
106	22680	mcf_invalid_vclname(struct cli cli, const char name)
107		{
108		const char *bad;
109
110	22680	AN(name);
111	22680	bad = VCT_invalid_name(name, NULL);
112
113	22680	if (bad != NULL) {
114	40	VCLI_SetResult(cli, CLIS_PARAM);
115	40	VCLI_Out(cli, "Illegal character in VCL name ");
116	40	if (bad > 0x20 && bad < 0x7f)
117	32	VCLI_Out(cli, "('%c')", *bad);
118		else
119	8	VCLI_Out(cli, "(0x%02x)", *bad & 0xff);
120	40	return (-1);
121		}
122	22640	return (0);
123	22680	}
124
125		static struct vclprog *
126	10096	mcf_find_vcl(struct cli cli, const char name)
127		{
128		struct vclprog *vp;
129
130	10096	if (mcf_invalid_vclname(cli, name))
131	0	return (NULL);
132
133	10096	vp = mcf_vcl_byname(name);
134	10096	if (vp == NULL) {
135	24	VCLI_SetResult(cli, CLIS_PARAM);
136	24	VCLI_Out(cli, "No VCL named %s known\n", name);
137	24	}
138	10096	return (vp);
139	10096	}
140
141		static int
142	12280	mcf_find_no_vcl(struct cli cli, const char name)
143		{
144
145	12280	if (mcf_invalid_vclname(cli, name))
146	32	return (0);
147
148	12248	if (mcf_vcl_byname(name) != NULL) {
149	8	VCLI_SetResult(cli, CLIS_PARAM);
150	8	VCLI_Out(cli, "Already a VCL named %s", name);
151	8	return (0);
152		}
153	12240	return (1);
154	12280	}
155
156		int
157	31720	mcf_is_label(const struct vclprog *vp)
158		{
159	31720	return (vp->state == VCL_STATE_LABEL);
160		}
161
162		/--------------------------------------------------------------------/
163
164		struct vcldep *
165	384	mgt_vcl_dep_add(struct vclprog vp_from, struct vclprog vp_to)
166		{
167		struct vcldep *vd;
168
169	384	CHECK_OBJ_NOTNULL(vp_from, VCLPROG_MAGIC);
170	384	CHECK_OBJ_NOTNULL(vp_to, VCLPROG_MAGIC);
171	384	assert(vp_to->state != VCL_STATE_COLD);
172
173	384	ALLOC_OBJ(vd, VCLDEP_MAGIC);
174	384	AN(vd);
175
176	384	mgt_vcl_set_cooldown(vp_from, -1);
177	384	mgt_vcl_set_cooldown(vp_to, -1);
178
179	384	vd->from = vp_from;
180	384	VTAILQ_INSERT_TAIL(&vp_from->dfrom, vd, lfrom);
181	384	vd->to = vp_to;
182	384	VTAILQ_INSERT_TAIL(&vp_to->dto, vd, lto);
183	384	vp_to->nto++;
184	384	return (vd);
185		}
186
187		static void
188	384	mgt_vcl_dep_del(struct vcldep *vd)
189		{
190
191	384	CHECK_OBJ_NOTNULL(vd, VCLDEP_MAGIC);
192	384	VTAILQ_REMOVE(&vd->from->dfrom, vd, lfrom);
193	384	VTAILQ_REMOVE(&vd->to->dto, vd, lto);
194	384	vd->to->nto--;
195	384	if (vd->to->nto == 0)
196	312	mgt_vcl_set_cooldown(vd->to, VTIM_mono());
197	384	FREE_OBJ(vd);
198	384	}
199
200		/--------------------------------------------------------------------/
201
202		static struct vclprog *
203	12672	mgt_vcl_add(const char name, const struct vclstate state)
204		{
205		struct vclprog *vp;
206
207	12672	assert(state == VCL_STATE_WARM \|\|
208		state == VCL_STATE_COLD \|\|
209		state == VCL_STATE_AUTO \|\|
210		state == VCL_STATE_LABEL);
211	12672	ALLOC_OBJ(vp, VCLPROG_MAGIC);
212	12672	XXXAN(vp);
213	12672	REPLACE(vp->name, name);
214	12672	VTAILQ_INIT(&vp->dfrom);
215	12672	VTAILQ_INIT(&vp->dto);
216	12672	VTAILQ_INIT(&vp->vmods);
217	12672	vp->state = state;
218
219	12672	if (vp->state != VCL_STATE_COLD)
220	12656	vp->warm = 1;
221
222	12672	VTAILQ_INSERT_TAIL(&vclhead, vp, list);
223	12672	if (vp->state != VCL_STATE_LABEL)
224	12480	vcl_count++;
225	12672	return (vp);
226		}
227
228		static void
229	12672	mgt_vcl_del(struct vclprog *vp)
230		{
231		char *p;
232		struct vmoddep *vd;
233		struct vmodfile *vf;
234		struct vcldep *dep;
235
236	12672	CHECK_OBJ_NOTNULL(vp, VCLPROG_MAGIC);
237	12672	assert(VTAILQ_EMPTY(&vp->dto));
238
239	12672	mgt_vcl_symtab_clean(vp);
240
241	13032	while ((dep = VTAILQ_FIRST(&vp->dfrom)) != NULL) {
242	360	assert(dep->from == vp);
243	360	mgt_vcl_dep_del(dep);
244		}
245
246	12672	VTAILQ_REMOVE(&vclhead, vp, list);
247	12672	if (vp->state != VCL_STATE_LABEL)
248	12480	vcl_count--;
249	12672	if (vp->fname != NULL) {
250	10056	if (!MGT_DO_DEBUG(DBG_VCL_KEEP))
251	10024	AZ(unlink(vp->fname));
252	10056	p = strrchr(vp->fname, '/');
253	10056	AN(p);
254	10056	*p = '\0';
255	10056	VJ_master(JAIL_MASTER_FILE);
256		/*
257		* This will fail if any files are dropped next to the library
258		* without us knowing. This happens for instance with GCOV.
259		* Assume developers know how to clean up after themselves
260		* (or alternatively: How to run out of disk space).
261		*/
262	10056	(void)rmdir(vp->fname);
263	10056	VJ_master(JAIL_MASTER_LOW);
264	10056	free(vp->fname);
265	10056	}
266	16768	while (!VTAILQ_EMPTY(&vp->vmods)) {
267	4096	vd = VTAILQ_FIRST(&vp->vmods);
268	4096	CHECK_OBJ(vd, VMODDEP_MAGIC);
269	4096	vf = vd->to;
270	4096	CHECK_OBJ(vf, VMODFILE_MAGIC);
271	4096	VTAILQ_REMOVE(&vp->vmods, vd, lfrom);
272	4096	VTAILQ_REMOVE(&vf->vcls, vd, lto);
273	4096	FREE_OBJ(vd);
274
275	4096	if (VTAILQ_EMPTY(&vf->vcls)) {
276	2944	if (!MGT_DO_DEBUG(DBG_VMOD_SO_KEEP))
277	2936	AZ(unlink(vf->fname));
278	2944	VTAILQ_REMOVE(&vmodhead, vf, list);
279	2944	free(vf->fname);
280	2944	FREE_OBJ(vf);
281	2944	}
282		}
283	12672	free(vp->name);
284	12672	FREE_OBJ(vp);
285	12672	}
286
287		const char *
288	15584	mgt_has_vcl(void)
289		{
290	15584	if (VTAILQ_EMPTY(&vclhead))
291	7640	return ("No VCL loaded");
292	7944	if (mgt_vcl_active == NULL)
293	8	return ("No active VCL");
294	7936	CHECK_OBJ_NOTNULL(mgt_vcl_active, VCLPROG_MAGIC);
295	7936	AN(mgt_vcl_active->warm);
296	7936	return (NULL);
297	15584	}
298
299		/*
300		* go_cold
301		*
302		* -1: leave alone
303		* 0: timer not started - not currently used
304		* >0: when timer started
305		*/
306		static void
307	14888	mgt_vcl_set_cooldown(struct vclprog *vp, vtim_mono now)
308		{
309	14888	CHECK_OBJ_NOTNULL(vp, VCLPROG_MAGIC);
310
311	18804	if (vp == mgt_vcl_active \|\|
312	5086	vp->state != VCL_STATE_AUTO \|\|
313	4164	vp->warm == 0 \|\|
314	4076	!VTAILQ_EMPTY(&vp->dto) \|\|
315	3916	!VTAILQ_EMPTY(&vp->dfrom))
316	11180	vp->go_cold = -1;
317		else
318	3708	vp->go_cold = now;
319	14888	}
320
321		static int
322	10064	mgt_vcl_settemp(struct cli cli, struct vclprog vp, unsigned warm)
323		{
324		int i;
325
326	10064	CHECK_OBJ_NOTNULL(vp, VCLPROG_MAGIC);
327
328	10064	if (warm == vp->warm)
329	10000	return (0);
330
331	64	if (vp->state == VCL_STATE_AUTO \|\| vp->state == VCL_STATE_LABEL) {
332	64	mgt_vcl_set_cooldown(vp, -1);
333	64	i = mgt_vcl_askchild(cli, vp, warm);
334	64	mgt_vcl_set_cooldown(vp, VTIM_mono());
335	64	} else {
336	0	i = mgt_vcl_setstate(cli, vp,
337	0	warm ? VCL_STATE_WARM : VCL_STATE_COLD);
338		}
339
340	64	return (i);
341	10064	}
342
343		static int
344	10048	mgt_vcl_requirewarm(struct cli cli, struct vclprog vp)
345		{
346	10048	if (vp->state == VCL_STATE_COLD) {
347	16	VCLI_SetResult(cli, CLIS_CANT);
348	32	VCLI_Out(cli, "VCL '%s' is cold - set to auto or warm first",
349	16	vp->name);
350	16	return (1);
351		}
352	10032	return (mgt_vcl_settemp(cli, vp, 1));
353	10048	}
354
355		static int
356	496	mgt_vcl_askchild(struct cli cli, struct vclprog vp, unsigned warm)
357		{
358		unsigned status;
359		char *p;
360		int i;
361
362	496	CHECK_OBJ_NOTNULL(vp, VCLPROG_MAGIC);
363
364	496	if (!MCH_Running()) {
365	32	vp->warm = warm;
366	32	return (0);
367		}
368
369	464	i = mgt_cli_askchild(&status, &p, "vcl.state %s %d%s\n",
370	464	vp->name, warm, vp->state->name);
371	464	if (i && cli != NULL) {
372	32	VCLI_SetResult(cli, status);
373	32	VCLI_Out(cli, "%s", p);
374	464	} else if (i) {
375	0	MGT_Complain(C_ERR,
376		"Please file ticket: VCL poker problem: "
377		"'vcl.state %s %d%s' -> %03d '%s'",
378	0	vp->name, warm, vp->state->name, i, p);
379	0	} else {
380		/* Success, update mgt's VCL state to reflect child's
381		state */
382	432	vp->warm = warm;
383		}
384
385	464	free(p);
386	464	return (i);
387	496	}
388
389		static int
390	432	mgt_vcl_setstate(struct cli cli, struct vclprog vp, const struct vclstate *vs)
391		{
392		unsigned warm;
393		int i;
394		const struct vclstate *os;
395
396	432	CHECK_OBJ_NOTNULL(vp, VCLPROG_MAGIC);
397
398	432	assert(vs != VCL_STATE_LABEL);
399
400	432	if (mcf_is_label(vp)) {
401	0	AN(vp->warm);
402		/* do not touch labels */
403	0	return (0);
404		}
405
406	432	if (vp->state == vs)
407	0	return (0);
408
409	432	os = vp->state;
410	432	vp->state = vs;
411
412	432	if (vp == mgt_vcl_active) {
413	16	assert (vs == VCL_STATE_WARM \|\| vs == VCL_STATE_AUTO);
414	16	AN(vp->warm);
415	16	warm = 1;
416	432	} else if (vs == VCL_STATE_AUTO) {
417	24	warm = vp->warm;
418	24	} else {
419	392	warm = (vs == VCL_STATE_WARM ? 1 : 0);
420		}
421
422	432	i = mgt_vcl_askchild(cli, vp, warm);
423	432	if (i == 0)
424	408	mgt_vcl_set_cooldown(vp, VTIM_mono());
425		else
426	24	vp->state = os;
427	432	return (i);
428	432	}
429
430		/--------------------------------------------------------------------/
431
432		static struct vclprog *
433	12488	mgt_new_vcl(struct cli cli, const char vclname, const char *vclsrc,
434		const char vclsrcfile, const char state, int C_flag)
435		{
436		unsigned status;
437		char lib, p;
438		struct vclprog *vp;
439		const struct vclstate *vs;
440
441	12488	AN(cli);
442
443	12488	if (vcl_count >= mgt_param.max_vcl &&
444	16	mgt_param.max_vcl_handling == 2) {
445	8	VCLI_Out(cli, "Too many (%d) VCLs already loaded\n", vcl_count);
446	8	VCLI_Out(cli, "(See max_vcl and max_vcl_handling parameters)");
447	8	VCLI_SetResult(cli, CLIS_CANT);
448	8	return (NULL);
449		}
450
451	12480	if (state == NULL)
452	12448	vs = VCL_STATE_AUTO;
453		else
454	32	vs = mcf_vcl_parse_state(cli, state);
455
456	12480	if (vs == NULL)
457	0	return (NULL);
458
459	12480	vp = mgt_vcl_add(vclname, vs);
460	12480	lib = mgt_VccCompile(cli, vp, vclname, vclsrc, vclsrcfile, C_flag);
461	12480	if (lib == NULL) {
462	2424	mgt_vcl_del(vp);
463	2424	return (NULL);
464		}
465
466	10056	AZ(C_flag);
467	10056	vp->fname = lib;
468
469	10064	if ((cli->result == CLIS_OK \|\| cli->result == CLIS_TRUNCATED) &&
470	10056	vcl_count > mgt_param.max_vcl &&
471	8	mgt_param.max_vcl_handling == 1) {
472	8	VCLI_Out(cli, "%d VCLs loaded\n", vcl_count);
473	8	VCLI_Out(cli, "Remember to vcl.discard the old/unused VCLs.\n");
474	8	VCLI_Out(cli, "(See max_vcl and max_vcl_handling parameters)");
475	8	}
476
477	10056	if (!MCH_Running())
478	8136	return (vp);
479
480	1920	if (mgt_cli_askchild(&status, &p, "vcl.load %s %s %d%s\n",
481	1920	vp->name, vp->fname, vp->warm, vp->state->name)) {
482	336	mgt_vcl_del(vp);
483	336	VCLI_Out(cli, "%s", p);
484	336	VCLI_SetResult(cli, status);
485	336	free(p);
486	336	return (NULL);
487		}
488	1584	free(p);
489
490	1584	mgt_vcl_set_cooldown(vp, VTIM_mono());
491	1584	return (vp);
492	12488	}
493
494		/--------------------------------------------------------------------/
495
496		void
497	248	mgt_vcl_startup(struct cli cli, const char vclsrc, const char *vclname,
498		const char *origin, int C_flag)
499		{