GCOV - Varnish Cache


/*-
 * Copyright (c) 2008-2018 Varnish Software AS
 * All rights reserved.
 *
 * Author: Frédéric Lécaille <flecaille@haproxy.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.
 */

#include "config.h"

#include <inttypes.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h> /* for MUSL (mode_t) */
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>

#include "vtc.h"

#include "vfil.h"
#include "vpf.h"
#include "vre.h"
#include "vtcp.h"
#include "vsa.h"
#include "vtim.h"

#define HAPROXY_PROGRAM_ENV_VAR "HAPROXY_PROGRAM"
#define HAPROXY_ARGS_ENV_VAR    "HAPROXY_ARGS"
#define HAPROXY_OPT_WORKER      "-W"
#define HAPROXY_OPT_SD_WORKER   "-Ws"
#define HAPROXY_OPT_MCLI        "-S"
#define HAPROXY_OPT_DAEMON      "-D"
#define HAPROXY_SIGNAL          SIGINT
#define HAPROXY_EXPECT_EXIT     (128 + HAPROXY_SIGNAL)

struct envar {
        VTAILQ_ENTRY(envar) list;
        char *name;
        char *value;
};

struct haproxy {
        unsigned                magic;
#define HAPROXY_MAGIC           0x8a45cf75
        char                    *name;
        struct vtclog           *vl;
        VTAILQ_ENTRY(haproxy)   list;

        const char              *filename;
        struct vsb              *args;
        int                     opt_worker;
        int                     opt_mcli;
        int                     opt_daemon;
        int                     opt_check_mode;
        char                    *pid_fn;
        pid_t                   pid;
        pid_t                   ppid;
        int                     fds[4];
        char                    *cfg_fn;
        struct vsb              *cfg_vsb;

        pthread_t               tp;
        int                     expect_exit;
        int                     expect_signal;
        int                     its_dead_jim;

        /* sd_notify unix socket */
        struct sockaddr_un      sd_uds;
        int                     sd_sock;

        /* UNIX socket CLI. */
        char                    *cli_fn;
        /* TCP socket CLI. */
        struct haproxy_cli *cli;

        /* master CLI */
        struct haproxy_cli *mcli;

        char                    *workdir;
        struct vsb              *msgs;
        char                    closed_sock[256]; /* Closed TCP socket */
        VTAILQ_HEAD(,envar) envars;
};

static VTAILQ_HEAD(, haproxy)   haproxies =
    VTAILQ_HEAD_INITIALIZER(haproxies);

struct haproxy_cli {
        unsigned                magic;
#define HAPROXY_CLI_MAGIC       0xb09a4ed8
        struct vtclog           *vl;
        char                    running;

        char                    *spec;

        int                     sock;
        char                    connect[256];

        pthread_t               tp;
        size_t                  txbuf_sz;
        char                    *txbuf;
        size_t                  rxbuf_sz;
        char                    *rxbuf;

        vtim_dur                timeout;
};

static void haproxy_write_conf(struct haproxy *h);

static void
haproxy_add_envar(struct haproxy *h,
                  const char *name, const char *value)
{
        struct envar *e;

        e = malloc(sizeof *e);
        AN(e);
        e->name = strdup(name);
        e->value = strdup(value);
        AN(e->name);
        AN(e->value);
        VTAILQ_INSERT_TAIL(&h->envars, e, list);
}

static void
haproxy_delete_envars(struct haproxy *h)
{
        struct envar *e, *e2;
        VTAILQ_FOREACH_SAFE(e, &h->envars, list, e2) {
                VTAILQ_REMOVE(&h->envars, e, list);
                free(e->name);
                free(e->value);
                free(e);
        }
}

static void
haproxy_build_env(const struct haproxy *h)
{
        struct envar *e;

        VTAILQ_FOREACH(e, &h->envars, list) {
                if (setenv(e->name, e->value, 0) == -1)
                        vtc_fatal(h->vl, "setenv() failed: %s (%d)",
                                  strerror(errno), errno);
        }
}

/**********************************************************************
 * Socket connect (same as client_tcp_connect()).
 */

static int
haproxy_cli_tcp_connect(struct vtclog *vl, const char *addr, vtim_dur tmo,
    const char **errp)
{
        int fd;
        char mabuf[VTCP_ADDRBUFSIZE], mpbuf[VTCP_PORTBUFSIZE];

        AN(addr);
        AN(errp);
        fd = VTCP_open(addr, NULL, tmo, errp);
        if (fd < 0)
                return (fd);
        VTCP_myname(fd, mabuf, sizeof mabuf, mpbuf, sizeof mpbuf);
        vtc_log(vl, 3,
            "CLI connected fd %d from %s %s to %s", fd, mabuf, mpbuf, addr);
        return (fd);
}

/*
 * SECTION: haproxy.cli haproxy CLI Specification
 * SECTION: haproxy.cli.send
 * send STRING
 *         Push STRING on the CLI connection. STRING will be terminated by an
 *         end of line character (\n).
 */
static void v_matchproto_(cmd_f)
cmd_haproxy_cli_send(CMD_ARGS)
{
        struct vsb *vsb;
        struct haproxy_cli *hc;
        int j;

        (void)vl;
        CAST_OBJ_NOTNULL(hc, priv, HAPROXY_CLI_MAGIC);
        AZ(strcmp(av[0], "send"));
        AN(av[1]);
        AZ(av[2]);

        vsb = VSB_new_auto();
        AN(vsb);
        AZ(VSB_cat(vsb, av[1]));
        AZ(VSB_cat(vsb, "\n"));
        AZ(VSB_finish(vsb));
        if (hc->sock == -1) {
                int fd;
                const char *err;
                struct vsb *vsb_connect;

                vsb_connect = macro_expand(hc->vl, hc->connect);
                AN(vsb_connect);
                fd = haproxy_cli_tcp_connect(hc->vl,
                    VSB_data(vsb_connect), 10., &err);
                if (fd < 0)
                        vtc_fatal(hc->vl,
                            "CLI failed to open %s: %s", VSB_data(vsb), err);
                VSB_destroy(&vsb_connect);
                hc->sock = fd;
        }
        vtc_dump(hc->vl, 4, "CLI send", VSB_data(vsb), -1);

        if (VSB_tofile(vsb, hc->sock))
                vtc_fatal(hc->vl,
                    "CLI fd %d send error %s", hc->sock, strerror(errno));

        /* a CLI command must be followed by a SHUT_WR if we want HAProxy to
         * close after the response */
        j = shutdown(hc->sock, SHUT_WR);
        vtc_log(hc->vl, 3, "CLI shutting fd %d", hc->sock);
        if (!VTCP_Check(j))
                vtc_fatal(hc->vl, "Shutdown failed: %s", strerror(errno));

        VSB_destroy(&vsb);
}

#define HAPROXY_CLI_RECV_LEN (1 << 14)
static void
haproxy_cli_recv(struct haproxy_cli *hc)
{
        ssize_t ret;
        size_t rdz, left, off;

        rdz = ret = off = 0;
        /* We want to null terminate this buffer. */
        left = hc->rxbuf_sz - 1;
        while (!vtc_error && left > 0) {
                VTCP_set_read_timeout(hc->sock, hc->timeout);

                ret = recv(hc->sock, hc->rxbuf + off, HAPROXY_CLI_RECV_LEN, 0);
                if (ret < 0) {
                        if (errno == EINTR || errno == EAGAIN)
                                continue;

                        vtc_fatal(hc->vl,
                            "CLI fd %d recv() failed (%s)",
                            hc->sock, strerror(errno));
                }
                /* Connection closed. */
                if (ret == 0) {
                        if (rdz > 0 && hc->rxbuf[rdz - 1] != '\n')
                                vtc_fatal(hc->vl,
                                    "CLI rx timeout (fd: %d %.3fs ret: %zd)",
                                    hc->sock, hc->timeout, ret);

                        vtc_log(hc->vl, 4, "CLI connection normally closed");
                        vtc_log(hc->vl, 3, "CLI closing fd %d", hc->sock);
                        VTCP_close(&hc->sock);
                        break;
                }

                rdz += ret;
                left -= ret;
                off  += ret;
        }
        hc->rxbuf[rdz] = '\0';
        vtc_dump(hc->vl, 4, "CLI recv", hc->rxbuf, rdz);
}

/*
 * SECTION: haproxy.cli.expect
 * expect OP STRING
 *         Regex match the CLI reception buffer with STRING
 *         if OP is ~ or, on the contrary, if OP is !~ check that there is
 *         no regex match.
 */
static void v_matchproto_(cmd_f)
cmd_haproxy_cli_expect(CMD_ARGS)
{
        struct haproxy_cli *hc;
        struct vsb vsb[1];
        vre_t *vre;
        int error, erroroffset, i, ret;
        char *cmp, *spec, errbuf[VRE_ERROR_LEN];

        (void)vl;
        CAST_OBJ_NOTNULL(hc, priv, HAPROXY_CLI_MAGIC);
        AZ(strcmp(av[0], "expect"));
        av++;

        cmp = av[0];
        spec = av[1];
        AN(cmp);
        AN(spec);
        AZ(av[2]);

        assert(!strcmp(cmp, "~") || !strcmp(cmp, "!~"));

        haproxy_cli_recv(hc);

        vre = VRE_compile(spec, 0, &error, &erroroffset, 1);
        if (vre == NULL) {
                AN(VSB_init(vsb, errbuf, sizeof errbuf));
                AZ(VRE_error(vsb, error));
                AZ(VSB_finish(vsb));
                VSB_fini(vsb);
                vtc_fatal(hc->vl, "CLI regexp error: '%s' (@%d) (%s)",
                    errbuf, erroroffset, spec);
        }

        i = VRE_match(vre, hc->rxbuf, 0, 0, NULL);

        VRE_free(&vre);

        ret = (i >= 0 && *cmp == '~') || (i < 0 && *cmp == '!');
        if (!ret)
                vtc_fatal(hc->vl, "CLI expect failed %s \"%s\"", cmp, spec);
        else
                vtc_log(hc->vl, 4, "CLI expect match %s \"%s\"", cmp, spec);
}

static const struct cmds haproxy_cli_cmds[] = {
#define CMD_HAPROXY_CLI(n) { #n, cmd_haproxy_cli_##n },
        CMD_HAPROXY_CLI(send)
        CMD_HAPROXY_CLI(expect)
#undef CMD_HAPROXY_CLI
        { NULL, NULL }
};

/**********************************************************************
 * HAProxy CLI client thread
 */

static void *
haproxy_cli_thread(void *priv)
{
        struct haproxy_cli *hc;
        struct vsb *vsb;
        int fd;
        const char *err;

        CAST_OBJ_NOTNULL(hc, priv, HAPROXY_CLI_MAGIC);
        AN(*hc->connect);

        vsb = macro_expand(hc->vl, hc->connect);
        AN(vsb);

        fd = haproxy_cli_tcp_connect(hc->vl, VSB_data(vsb), 10., &err);
        if (fd < 0)
                vtc_fatal(hc->vl,
                    "CLI failed to open %s: %s", VSB_data(vsb), err);
        VTCP_blocking(fd);
        hc->sock = fd;
        parse_string(hc->vl, hc, hc->spec);
        vtc_log(hc->vl, 2, "CLI ending");
        VSB_destroy(&vsb);
        return (NULL);
}

/**********************************************************************
 * Wait for the CLI client thread to stop
 */

static void
haproxy_cli_wait(struct haproxy_cli *hc)
{
        void *res;

        CHECK_OBJ_NOTNULL(hc, HAPROXY_CLI_MAGIC);
        vtc_log(hc->vl, 2, "CLI waiting");
        PTOK(pthread_join(hc->tp, &res));
        if (res != NULL)
                vtc_fatal(hc->vl, "CLI returned \"%s\"", (char *)res);
        REPLACE(hc->spec, NULL);
        hc->tp = 0;
        hc->running = 0;
}

/**********************************************************************
 * Start the CLI client thread
 */

static void
haproxy_cli_start(struct haproxy_cli *hc)
{
        CHECK_OBJ_NOTNULL(hc, HAPROXY_CLI_MAGIC);
        vtc_log(hc->vl, 2, "CLI starting");
        PTOK(pthread_create(&hc->tp, NULL, haproxy_cli_thread, hc));
        hc->running = 1;

}

/**********************************************************************
 * Run the CLI client thread
 */

static void
haproxy_cli_run(struct haproxy_cli *hc)
{
        haproxy_cli_start(hc);
        haproxy_cli_wait(hc);
}

/**********************************************************************
 * Wait for the pidfile
 */

static void
haproxy_wait_pidfile(struct haproxy *h)
{
        char buf_err[1024] = {0};
        int usleep_time = 1000;
        double t0;
        pid_t pid;

        vtc_log(h->vl, 3, "wait-pid-file");
        for (t0 = VTIM_mono(); VTIM_mono() - t0 < 3;) {
                if (vtc_error)
                        return;

                if (VPF_Read(h->pid_fn, &pid) != 0) {
                        bprintf(buf_err,
                            "Could not read PID file '%s'", h->pid_fn);
                        usleep(usleep_time);
                        continue;
                }

                if (!h->opt_daemon && pid != h->pid) {
                        bprintf(buf_err,
                            "PID file has different PID (%ld != %lld)",
                            (long)pid, (long long)h->pid);
                        usleep(usleep_time);
                        continue;
                }

                if (kill(pid, 0) < 0) {
                        bprintf(buf_err,
                            "Could not find PID %ld process", (long)pid);
                        usleep(usleep_time);
                        continue;
                }

                h->pid = pid;

                vtc_log(h->vl, 2, "haproxy PID %ld successfully started",
                    (long)pid);
                return;
        }
        vtc_fatal(h->vl, "haproxy %s PID file check failed:\n\t%s\n",
                  h->name, buf_err);
}

/**********************************************************************
 * Bind the sd_notify socket
 */
static void
haproxy_bind_sdnotify(struct haproxy *h)
{
        char sd_path[PATH_MAX];
        int sd;
        int ret;
        const char *err = NULL;
        struct sockaddr_un *uds = &h->sd_uds;
        socklen_t sl = sizeof(*uds);

        bprintf(sd_path, "%s/sd_notify.sock", h->workdir);
        assert(sd_path[0] == '/');

        if (strlen(sd_path) + 1 > sizeof(uds->sun_path)) {
                vtc_fatal(h->vl, "Path %s too long for a Unix domain socket", sd_path);
        }
        memset(uds->sun_path, 0, sizeof(uds->sun_path));
        bprintf(uds->sun_path, "%s", sd_path);
        uds->sun_family = PF_UNIX;

        sd = socket(AF_UNIX, SOCK_DGRAM, 0);
        if (sd < 0) {
                err = "socket(2)";
                goto error;
        }

        if (unlink(uds->sun_path) != 0 && errno != ENOENT) {
                err = "unlink(2)";
                closefd(&sd);
                goto error;
        }

        if (bind(sd, (const void*)uds, sl) != 0) {
                err = "bind(2)";
                closefd(&sd);
                goto error;
        }

        h->sd_sock = sd;

        assert(h->sd_sock > 0);
        vtc_log(h->vl, 4, "sd_notify %s", sd_path);
        ret = setenv("NOTIFY_SOCKET", sd_path, 1);
        assert(ret == 0);

error:
        if (err != NULL)
                vtc_fatal(h->vl, "Create sd_notify socket failed: %s", err);
}

/**********************************************************************
 * Wait for the "READY" from sd_notify
 */
static void
haproxy_wait_sdnotify_ready(struct haproxy *h)
{
        struct pollfd fd[1];
        char buf[BUFSIZ];
        int i, r;
        char *ready = NULL;

        vtc_log(h->vl, 3, "wait-sdnotify-ready");

        /* First try to do an accept on h->sd_sock */
        memset(fd, 0, sizeof(fd));
        fd[0].fd = h->sd_sock;
        fd[0].events = POLLIN;

        i = poll(fd, 1, vtc_maxdur * 1000 / 3);
        vtc_log(h->vl, 4, "sd_notify recv poll %d 0x%x ", i, fd[0].revents);
        if (i == 0)
                vtc_fatal(h->vl, "FAIL timeout waiting for sd_notify recv");
        if (!(fd[0].revents & POLLIN))
                vtc_fatal(h->vl, "FAIL sd_notify recv wait failure");

        r = recv(h->sd_sock, buf, sizeof(buf) - 1, 0);
        if (r > 0) {
                buf[r] = '\0';
                ready = strstr(buf, "READY=1");
        }

        if (!ready)
                vtc_fatal(h->vl, "FAIL sd_notify recv READY failure");
        else
                vtc_log(h->vl, 3, "sd_notify READY=1");
}
/**********************************************************************
 * Allocate and initialize a CLI client
 */

static struct haproxy_cli *
haproxy_cli_new(struct haproxy *h)
{
        struct haproxy_cli *hc;

        ALLOC_OBJ(hc, HAPROXY_CLI_MAGIC);
        AN(hc);

        hc->vl = h->vl;
        vtc_log_set_cmd(hc->vl, haproxy_cli_cmds);
        hc->sock = -1;
        bprintf(hc->connect, "${%s_cli_sock}", h->name);

        hc->txbuf_sz = hc->rxbuf_sz = 2048 * 1024;
        hc->txbuf = malloc(hc->txbuf_sz);
        AN(hc->txbuf);
        hc->rxbuf = malloc(hc->rxbuf_sz);
        AN(hc->rxbuf);

        return (hc);
}

/* creates a master CLI client (-mcli) */
static struct haproxy_cli *
haproxy_mcli_new(struct haproxy *h)
{
        struct haproxy_cli *hc;

        ALLOC_OBJ(hc, HAPROXY_CLI_MAGIC);
        AN(hc);

        hc->vl = h->vl;
        vtc_log_set_cmd(hc->vl, haproxy_cli_cmds);
        hc->sock = -1;
        bprintf(hc->connect, "${%s_mcli_sock}", h->name);

        hc->txbuf_sz = hc->rxbuf_sz = 2048 * 1024;
        hc->txbuf = malloc(hc->txbuf_sz);
        AN(hc->txbuf);
        hc->rxbuf = malloc(hc->rxbuf_sz);
        AN(hc->rxbuf);

        return (hc);
}

/* Bind an address/port for the master CLI (-mcli) */
static int
haproxy_create_mcli(struct haproxy *h)
{
        int sock;
        const char *err;
        char buf[128], addr[128], port[128];
        char vsabuf[vsa_suckaddr_len];
        const struct suckaddr *sua;

        sock = VTCP_listen_on(default_listen_addr, NULL, 100, &err);
        if (err != NULL)
                vtc_fatal(h->vl,
                          "Create listen socket failed: %s", err);
        assert(sock > 0);
        sua = VSA_getsockname(sock, vsabuf, sizeof vsabuf);
        AN(sua);

        VTCP_name(sua, addr, sizeof addr, port, sizeof port);
        bprintf(buf, "%s_mcli", h->name);
        if (VSA_Get_Proto(sua) == AF_INET)
                macro_def(h->vl, buf, "sock", "%s:%s", addr, port);
        else
                macro_def(h->vl, buf, "sock", "[%s]:%s", addr, port);
        macro_def(h->vl, buf, "addr", "%s", addr);
        macro_def(h->vl, buf, "port", "%s", port);

        return (sock);
}

static void
haproxy_cli_delete(struct haproxy_cli *hc)
{
        CHECK_OBJ_NOTNULL(hc, HAPROXY_CLI_MAGIC);
        REPLACE(hc->spec, NULL);
        REPLACE(hc->txbuf, NULL);
        REPLACE(hc->rxbuf, NULL);
        FREE_OBJ(hc);
}

/**********************************************************************
 * Allocate and initialize a haproxy
 */

static struct haproxy *
haproxy_new(const char *name)
{
        struct haproxy *h;
        struct vsb *vsb;
        char buf[PATH_MAX];
        int closed_sock;
        char addr[128], port[128];
        const char *err;
        const char *env_args;
        char vsabuf[vsa_suckaddr_len];
        const struct suckaddr *sua;

        ALLOC_OBJ(h, HAPROXY_MAGIC);
        AN(h);
        REPLACE(h->name, name);

        h->args = VSB_new_auto();
        env_args = getenv(HAPROXY_ARGS_ENV_VAR);
        if (env_args) {
                VSB_cat(h->args, env_args);
                VSB_cat(h->args, " ");
        }

        h->vl = vtc_logopen("%s", name);
        vtc_log_set_cmd(h->vl, haproxy_cli_cmds);
        AN(h->vl);

        h->filename = getenv(HAPROXY_PROGRAM_ENV_VAR);
        if (h->filename == NULL)
                h->filename = "haproxy";

        bprintf(buf, "${tmpdir}/%s", name);
        vsb = macro_expand(h->vl, buf);
        AN(vsb);
        h->workdir = strdup(VSB_data(vsb));
        AN(h->workdir);
        VSB_destroy(&vsb);

        bprintf(buf, "%s/stats.sock", h->workdir);
        h->cli_fn = strdup(buf);
        AN(h->cli_fn);

        bprintf(buf, "%s/cfg", h->workdir);
        h->cfg_fn = strdup(buf);
        AN(h->cfg_fn);

        /* Create a new TCP socket to reserve an IP:port and close it asap.
         * May be useful to simulate an unreachable server.
         */
        bprintf(h->closed_sock, "%s_closed", h->name);
        closed_sock = VTCP_listen_on("127.0.0.1:0", NULL, 100, &err);
        if (err != NULL)
                vtc_fatal(h->vl,
                        "Create listen socket failed: %s", err);
        assert(closed_sock > 0);
        sua = VSA_getsockname(closed_sock, vsabuf, sizeof vsabuf);
        AN(sua);
        VTCP_name(sua, addr, sizeof addr, port, sizeof port);
        if (VSA_Get_Proto(sua) == AF_INET)
                macro_def(h->vl, h->closed_sock, "sock", "%s:%s", addr, port);
        else
                macro_def(h->vl, h->closed_sock, "sock", "[%s]:%s", addr, port);
        macro_def(h->vl, h->closed_sock, "addr", "%s", addr);
        macro_def(h->vl, h->closed_sock, "port", "%s", port);
        VTCP_close(&closed_sock);

        h->cli = haproxy_cli_new(h);
        AN(h->cli);

        h->mcli = haproxy_mcli_new(h);
        AN(h->mcli);

        bprintf(buf, "rm -rf \"%s\" ; mkdir -p \"%s\"", h->workdir, h->workdir);
        AZ(system(buf));

        h->sd_sock = -1;

        VTAILQ_INIT(&h->envars);
        VTAILQ_INSERT_TAIL(&haproxies, h, list);

        return (h);
}

/**********************************************************************
 * Delete a haproxy instance
 */

static void
haproxy_delete(struct haproxy *h)
{
        char buf[PATH_MAX];

        CHECK_OBJ_NOTNULL(h, HAPROXY_MAGIC);
        vtc_logclose(h->vl);

        if (!leave_temp) {
                bprintf(buf, "rm -rf \"%s\"", h->workdir);
                AZ(system(buf));
        }

        if (h->sd_sock >= 0)
                closefd(&h->sd_sock);

        free(h->name);
        free(h->workdir);
        free(h->cli_fn);
        free(h->cfg_fn);
        free(h->pid_fn);
        VSB_destroy(&h->args);
        haproxy_cli_delete(h->cli);
        haproxy_cli_delete(h->mcli);

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

/**********************************************************************
 * HAProxy listener
 */

static void *
haproxy_thread(void *priv)
{
        struct haproxy *h;

        CAST_OBJ_NOTNULL(h, priv, HAPROXY_MAGIC);
        (void)vtc_record(h->vl, h->fds[0], h->msgs);
        h->its_dead_jim = 1;
        return (NULL);
}


/**********************************************************************
 * Start a HAProxy instance.
 */

static void
haproxy_start(struct haproxy *h)
{
        char buf[PATH_MAX];
        struct vsb *vsb;

        vtc_log(h->vl, 2, "%s", __func__);

        AZ(VSB_finish(h->args));
        vtc_log(h->vl, 4, "opt_worker %d opt_daemon %d opt_check_mode %d opt_mcli %d",
            h->opt_worker, h->opt_daemon, h->opt_check_mode, h->opt_mcli);

        vsb = VSB_new_auto();
        AN(vsb);

        VSB_printf(vsb, "exec \"%s\"", h->filename);
        if (h->opt_check_mode)
                VSB_cat(vsb, " -c");
        else if (h->opt_daemon)
                VSB_cat(vsb, " -D");
        else
                VSB_cat(vsb, " -d");

        if (h->opt_worker) {
                if (h->opt_worker == 2) { /* sd_notify mode */
                        VSB_cat(vsb, " -Ws");
                        haproxy_bind_sdnotify(h);
                } else {
                        VSB_cat(vsb, " -W");
                }
                if (h->opt_mcli) {
                        int sock;
                        sock = haproxy_create_mcli(h);
                        VSB_printf(vsb, " -S \"fd@%d\"", sock);
                }
        }

        VSB_printf(vsb, " %s", VSB_data(h->args));

        VSB_printf(vsb, " -f \"%s\" ", h->cfg_fn);

        if (h->opt_worker || h->opt_daemon) {
                bprintf(buf, "%s/pid", h->workdir);
                h->pid_fn = strdup(buf);
                AN(h->pid_fn);
                VSB_printf(vsb, " -p \"%s\"", h->pid_fn);
        }

        AZ(VSB_finish(vsb));
        vtc_dump(h->vl, 4, "argv", VSB_data(vsb), -1);

        if (h->opt_worker && !h->opt_daemon) {
                /*
                 * HAProxy master process must exit with status 128 + <signum>
                 * if signaled by <signum> signal.
                 */
                h->expect_exit = HAPROXY_EXPECT_EXIT;
        }

        haproxy_write_conf(h);

        AZ(pipe(&h->fds[0]));
        vtc_log(h->vl, 4, "XXX %d @%d", h->fds[1], __LINE__);
        AZ(pipe(&h->fds[2]));
        h->pid = h->ppid = fork();
        assert(h->pid >= 0);
        if (h->pid == 0) {
                haproxy_build_env(h);
                haproxy_delete_envars(h);
                AZ(chdir(h->name));
                AZ(dup2(h->fds[0], 0));
                assert(dup2(h->fds[3], 1) == 1);
                assert(dup2(1, 2) == 2);
                closefd(&h->fds[0]);
                closefd(&h->fds[1]);
                closefd(&h->fds[2]);
                closefd(&h->fds[3]);
                AZ(execl("/bin/sh", "/bin/sh", "-c", VSB_data(vsb), (char*)0));
                exit(1);
        }
        VSB_destroy(&vsb);

        vtc_log(h->vl, 3, "PID: %ld", (long)h->pid);
        macro_def(h->vl, h->name, "pid", "%ld", (long)h->pid);
        macro_def(h->vl, h->name, "name", "%s", h->workdir);

        closefd(&h->fds[0]);
        closefd(&h->fds[3]);
        h->fds[0] = h->fds[2];
        h->fds[2] = h->fds[3] = -1;

        PTOK(pthread_create(&h->tp, NULL, haproxy_thread, h));

        if (h->pid_fn != NULL)
                haproxy_wait_pidfile(h);

        if (h->opt_worker == 2) /* sd_notify mode */
                haproxy_wait_sdnotify_ready(h);
}


/**********************************************************************
 * Wait for a HAProxy instance.
 */

static void
haproxy_wait(struct haproxy *h)
{
        void *p;
        int i, n, sig;

        vtc_log(h->vl, 2, "Wait");

        if (h->pid < 0)
                haproxy_start(h);

        if (h->cli->spec)
                haproxy_cli_run(h->cli);

        if (h->mcli->spec)
                haproxy_cli_run(h->mcli);

        closefd(&h->fds[1]);

        sig = SIGINT;
        n = 0;
        vtc_log(h->vl, 2, "Stop HAproxy pid=%ld", (long)h->pid);
        while (h->opt_daemon || (!h->opt_check_mode && !h->its_dead_jim)) {
                assert(h->pid > 0);
                if (n == 0) {
                        i = kill(h->pid, sig);
                        if (i == 0)
                                h->expect_signal = -sig;
                        if (i && errno == ESRCH)
                                break;
                        vtc_log(h->vl, 4,
                            "Kill(%d)=%d: %s", sig, i, strerror(errno));
                }
                VTIM_sleep(0.1);
                if (++n == 20) {
                        switch (sig) {
                        case SIGINT:    sig = SIGTERM ; break;
                        case SIGTERM:   sig = SIGKILL ; break;
                        default:        break;
                        }
                        n = 0;
                }
        }

        PTOK(pthread_join(h->tp, &p));
        AZ(p);
        closefd(&h->fds[0]);
        if (!h->opt_daemon) {
                vtc_wait4(h->vl, h->ppid, h->expect_exit, h->expect_signal, 0);
                h->ppid = -1;
        }
        h->pid = -1;
}

#define HAPROXY_BE_FD_STR     "fd@${"
#define HAPROXY_BE_FD_STRLEN  strlen(HAPROXY_BE_FD_STR)

static int
haproxy_build_backends(struct haproxy *h, const char *vsb_data)
{
        char *s, *p, *q;

        s = strdup(vsb_data);
        if (!s)
                return (-1);

        p = s;
        while (1) {
                int sock;
                char buf[128], addr[128], port[128];
                const char *err;
                char vsabuf[vsa_suckaddr_len];
                const struct suckaddr *sua;

                p = strstr(p, HAPROXY_BE_FD_STR);
                if (!p)
                        break;

                q = p += HAPROXY_BE_FD_STRLEN;
                while (*q && *q != '}')
                        q++;
                if (*q != '}')
                        break;

                *q++ = '\0';
                sock = VTCP_listen_on("127.0.0.1:0", NULL, 100, &err);
                if (err != NULL)
                        vtc_fatal(h->vl,
                            "Create listen socket failed: %s", err);
                assert(sock > 0);
                sua = VSA_getsockname(sock, vsabuf, sizeof vsabuf);
                AN(sua);

                VTCP_name(sua, addr, sizeof addr, port, sizeof port);
                bprintf(buf, "%s_%s", h->name, p);
                if (VSA_Get_Proto(sua) == AF_INET)
                        macro_def(h->vl, buf, "sock", "%s:%s", addr, port);
                else
                        macro_def(h->vl, buf, "sock", "[%s]:%s", addr, port);
                macro_def(h->vl, buf, "addr", "%s", addr);
                macro_def(h->vl, buf, "port", "%s", port);

                bprintf(buf, "%d", sock);
                vtc_log(h->vl, 4, "setenv(%s, %s)", p, buf);
                haproxy_add_envar(h, p, buf);
                p = q;
        }
        free(s);
        return (0);
}

static void
haproxy_check_conf(struct haproxy *h, const char *expect)
{

        h->msgs = VSB_new_auto();
        AN(h->msgs);
        h->opt_check_mode = 1;
        haproxy_start(h);
        haproxy_wait(h);
        AZ(VSB_finish(h->msgs));
        if (strstr(VSB_data(h->msgs), expect) == NULL)
                vtc_fatal(h->vl, "Did not find expected string '%s'", expect);
        vtc_log(h->vl, 2, "Found expected '%s'", expect);
        VSB_destroy(&h->msgs);
}

/**********************************************************************
 * Write a configuration for <h> HAProxy instance.
 */

static void
haproxy_store_conf(struct haproxy *h, const char *cfg, int auto_be)
{
        struct vsb *vsb, *vsb2;

        vsb = VSB_new_auto();
        AN(vsb);

        vsb2 = VSB_new_auto();
        AN(vsb2);

        VSB_printf(vsb, "    global\n\tstats socket \"%s\" "
                   "level admin mode 600\n", h->cli_fn);
        VSB_cat(vsb, "    stats socket \"fd@${cli}\" level admin\n");
        AZ(VSB_cat(vsb, cfg));

        if (auto_be)
                cmd_server_gen_haproxy_conf(vsb);

        AZ(VSB_finish(vsb));

        AZ(haproxy_build_backends(h, VSB_data(vsb)));

        h->cfg_vsb = macro_expand(h->vl, VSB_data(vsb));
        AN(h->cfg_vsb);

        VSB_destroy(&vsb2);
        VSB_destroy(&vsb);
}

static void
haproxy_write_conf(struct haproxy *h)
{
        struct vsb *vsb;

        vsb = macro_expand(h->vl, VSB_data(h->cfg_vsb));
        AN(vsb);
        assert(VSB_len(vsb) >= 0);

        vtc_dump(h->vl, 4, "conf", VSB_data(vsb), VSB_len(vsb));
        if (VFIL_writefile(h->workdir, h->cfg_fn,
            VSB_data(vsb), VSB_len(vsb)) != 0)
                vtc_fatal(h->vl,
                    "failed to write haproxy configuration file: %s (%d)",
                    strerror(errno), errno);

        VSB_destroy(&vsb);
}

/* SECTION: haproxy haproxy
 *
 * Define and interact with haproxy instances.
 *
 * To define a haproxy server, you'll use this syntax::
 *
 *      haproxy hNAME -conf-OK CONFIG
 *      haproxy hNAME -conf-BAD ERROR CONFIG
 *      haproxy hNAME [-D] [-W] [-arg STRING] [-conf[+vcl] STRING]
 *
 * The first ``haproxy hNAME`` invocation will start the haproxy master
 * process in the background, waiting for the ``-start`` switch to actually
 * start the child.
 *
 * Arguments:
 *
 * hNAME
 *         Identify the HAProxy server with a string, it must starts with 'h'.
 *
 * \-conf-OK CONFIG
 *         Run haproxy in '-c' mode to check config is OK
 *         stdout/stderr should contain 'Configuration file is valid'
 *         The exit code should be 0.
 *
 * \-conf-BAD ERROR CONFIG
 *         Run haproxy in '-c' mode to check config is BAD.
 *         "ERROR" should be part of the diagnostics on stdout/stderr.
 *         The exit code should be 1.
 *
 * \-D
 *         Run HAproxy in daemon mode.  If not given '-d' mode used.
 *
 * \-W
 *         Enable HAproxy in Worker mode.
 *
 * \-S
 *         Enable HAproxy Master CLI in Worker mode
 *
 * \-arg STRING
 *         Pass an argument to haproxy, for example "-h simple_list".
 *
 * \-cli STRING
 *         Specify the spec to be run by the command line interface (CLI).
 *
 * \-mcli STRING
 *         Specify the spec to be run by the command line interface (CLI)
 *         of the Master process.
 *
 * \-conf STRING
 *         Specify the configuration to be loaded by this HAProxy instance.
 *
 * \-conf+backend STRING
 *         Specify the configuration to be loaded by this HAProxy instance,
 *         all server instances will be automatically appended
 *
 * \-start
 *         Start this HAProxy instance.
 *
 * \-wait
 *         Stop this HAProxy instance.
 *
 * \-expectexit NUMBER
 *         Expect haproxy to exit(3) with this value
 *
 */

void
cmd_haproxy(CMD_ARGS)
{
        struct haproxy *h, *h2;

        (void)priv;

        if (av == NULL) {
                /* Reset and free */
                VTAILQ_FOREACH_SAFE(h, &haproxies, list, h2) {
                        vtc_log(h->vl, 2,
                            "Reset and free %s haproxy %ld",
                            h->name, (long)h->pid);
                        if (h->pid >= 0)
                                haproxy_wait(h);
                        VTAILQ_REMOVE(&haproxies, h, list);
                        haproxy_delete(h);
                }
                return;
        }

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

        VTC_CHECK_NAME(vl, av[0], "haproxy", 'h');
        VTAILQ_FOREACH(h, &haproxies, list)
                if (!strcmp(h->name, av[0]))
                        break;
        if (h == NULL)
                h = haproxy_new(av[0]);
        av++;

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

                if (!strcmp(*av, "-conf-OK")) {
                        AN(av[1]);
                        haproxy_store_conf(h, av[1], 0);
                        h->expect_exit = 0;
                        haproxy_check_conf(h, "");
                        av++;
                        continue;
                }
                if (!strcmp(*av, "-conf-BAD")) {
                        AN(av[1]);
                        AN(av[2]);
                        haproxy_store_conf(h, av[2], 0);
                        h->expect_exit = 1;
                        haproxy_check_conf(h, av[1]);
                        av += 2;
                        continue;
                }

                if (!strcmp(*av, HAPROXY_OPT_DAEMON)) {
                        h->opt_daemon = 1;
                        continue;
                }
                if (!strcmp(*av, HAPROXY_OPT_WORKER)) {
                        h->opt_worker = 1;
                        continue;
                }
                if (!strcmp(*av, HAPROXY_OPT_SD_WORKER)) {
                        h->opt_worker = 2;
                        continue;
                }
                if (!strcmp(*av, HAPROXY_OPT_MCLI)) {
                        h->opt_mcli = 1;
                        continue;
                }
                if (!strcmp(*av, "-arg")) {
                        AN(av[1]);
                        AZ(h->pid);
                        VSB_cat(h->args, " ");
                        VSB_cat(h->args, av[1]);
                        av++;
                        continue;
                }

                if (!strcmp(*av, "-cli")) {
                        REPLACE(h->cli->spec, av[1]);
                        if (h->tp)
                                haproxy_cli_run(h->cli);
                        av++;
                        continue;
                }

                if (!strcmp(*av, "-mcli")) {
                        REPLACE(h->mcli->spec, av[1]);
                        if (h->tp)
                                haproxy_cli_run(h->mcli);
                        av++;
                        continue;
                }

                if (!strcmp(*av, "-conf")) {
                        AN(av[1]);
                        haproxy_store_conf(h, av[1], 0);
                        av++;
                        continue;
                }
                if (!strcmp(*av, "-conf+backend")) {
                        AN(av[1]);
                        haproxy_store_conf(h, av[1], 1);
                        av++;
                        continue;
                }

                if (!strcmp(*av, "-expectexit")) {
                        h->expect_exit = strtoul(av[1], NULL, 0);
                        av++;
                        continue;
                }
                if (!strcmp(*av, "-start")) {
                        haproxy_start(h);
                        continue;
                }
                if (!strcmp(*av, "-wait")) {
                        haproxy_wait(h);
                        continue;
                }
                vtc_fatal(h->vl, "Unknown haproxy argument: %s", *av);
        }
}

		varnish-cache/bin/varnishtest/vtest2/src/vtc_haproxy.c
0		/*-
1		* Copyright (c) 2008-2018 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Frédéric Lécaille <flecaille@haproxy.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
30		#include "config.h"
31
32		#include <inttypes.h>
33		#include <poll.h>
34		#include <stdio.h>
35		#include <stdlib.h>
36		#include <string.h>
37		#include <sys/stat.h> /* for MUSL (mode_t) */
38		#include <sys/types.h>
39		#include <sys/socket.h>
40		#include <sys/un.h>
41		#include <unistd.h>
42
43		#include "vtc.h"
44
45		#include "vfil.h"
46		#include "vpf.h"
47		#include "vre.h"
48		#include "vtcp.h"
49		#include "vsa.h"
50		#include "vtim.h"
51
52		#define HAPROXY_PROGRAM_ENV_VAR "HAPROXY_PROGRAM"
53		#define HAPROXY_ARGS_ENV_VAR "HAPROXY_ARGS"
54		#define HAPROXY_OPT_WORKER "-W"
55		#define HAPROXY_OPT_SD_WORKER "-Ws"
56		#define HAPROXY_OPT_MCLI "-S"
57		#define HAPROXY_OPT_DAEMON "-D"
58		#define HAPROXY_SIGNAL SIGINT
59		#define HAPROXY_EXPECT_EXIT (128 + HAPROXY_SIGNAL)
60
61		struct envar {
62		VTAILQ_ENTRY(envar) list;
63		char *name;
64		char *value;
65		};
66
67		struct haproxy {
68		unsigned magic;
69		#define HAPROXY_MAGIC 0x8a45cf75
70		char *name;
71		struct vtclog *vl;
72		VTAILQ_ENTRY(haproxy) list;
73
74		const char *filename;
75		struct vsb *args;
76		int opt_worker;
77		int opt_mcli;
78		int opt_daemon;
79		int opt_check_mode;
80		char *pid_fn;
81		pid_t pid;
82		pid_t ppid;
83		int fds[4];
84		char *cfg_fn;
85		struct vsb *cfg_vsb;
86
87		pthread_t tp;
88		int expect_exit;
89		int expect_signal;
90		int its_dead_jim;
91
92		/* sd_notify unix socket */
93		struct sockaddr_un sd_uds;
94		int sd_sock;
95
96		/* UNIX socket CLI. */
97		char *cli_fn;
98		/* TCP socket CLI. */
99		struct haproxy_cli *cli;
100
101		/* master CLI */
102		struct haproxy_cli *mcli;
103
104		char *workdir;
105		struct vsb *msgs;
106		char closed_sock[256]; /* Closed TCP socket */
107		VTAILQ_HEAD(,envar) envars;
108		};
109
110		static VTAILQ_HEAD(, haproxy) haproxies =
111		VTAILQ_HEAD_INITIALIZER(haproxies);
112
113		struct haproxy_cli {
114		unsigned magic;
115		#define HAPROXY_CLI_MAGIC 0xb09a4ed8
116		struct vtclog *vl;
117		char running;
118
119		char *spec;
120
121		int sock;
122		char connect[256];
123
124		pthread_t tp;
125		size_t txbuf_sz;
126		char *txbuf;
127		size_t rxbuf_sz;
128		char *rxbuf;
129
130		vtim_dur timeout;
131		};
132
133		static void haproxy_write_conf(struct haproxy *h);
134
135		static void
136	760	haproxy_add_envar(struct haproxy *h,
137		const char name, const char value)
138		{
139		struct envar *e;
140
141	760	e = malloc(sizeof *e);
142	760	AN(e);
143	760	e->name = strdup(name);
144	760	e->value = strdup(value);
145	760	AN(e->name);
146	760	AN(e->value);
147	760	VTAILQ_INSERT_TAIL(&h->envars, e, list);
148	760	}
149
150		static void
151	440	haproxy_delete_envars(struct haproxy *h)
152		{
153		struct envar e, e2;
154	1200	VTAILQ_FOREACH_SAFE(e, &h->envars, list, e2) {
155	760	VTAILQ_REMOVE(&h->envars, e, list);
156	760	free(e->name);
157	760	free(e->value);
158	760	free(e);
159	760	}
160	440	}
161
162		static void
163	440	haproxy_build_env(const struct haproxy *h)
164		{
165		struct envar *e;
166
167	1200	VTAILQ_FOREACH(e, &h->envars, list) {
168	760	if (setenv(e->name, e->value, 0) == -1)
169	0	vtc_fatal(h->vl, "setenv() failed: %s (%d)",
170	0	strerror(errno), errno);
171	760	}
172	440	}
173
174		/**********************************************************************
175		* Socket connect (same as client_tcp_connect()).
176		*/
177
178		static int
179	80	haproxy_cli_tcp_connect(struct vtclog vl, const char addr, vtim_dur tmo,
180		const char **errp)
181		{
182		int fd;
183		char mabuf[VTCP_ADDRBUFSIZE], mpbuf[VTCP_PORTBUFSIZE];
184
185	80	AN(addr);
186	80	AN(errp);
187	80	fd = VTCP_open(addr, NULL, tmo, errp);
188	80	if (fd < 0)
189	0	return (fd);
190	80	VTCP_myname(fd, mabuf, sizeof mabuf, mpbuf, sizeof mpbuf);
191	160	vtc_log(vl, 3,
192	80	"CLI connected fd %d from %s %s to %s", fd, mabuf, mpbuf, addr);
193	80	return (fd);
194	80	}
195
196		/*
197		* SECTION: haproxy.cli haproxy CLI Specification
198		* SECTION: haproxy.cli.send
199		* send STRING
200		* Push STRING on the CLI connection. STRING will be terminated by an
201		* end of line character (\n).
202		*/
203		static void v_matchproto_(cmd_f)
204	80	cmd_haproxy_cli_send(CMD_ARGS)
205		{
206		struct vsb *vsb;
207		struct haproxy_cli *hc;
208		int j;
209
210	80	(void)vl;
211	80	CAST_OBJ_NOTNULL(hc, priv, HAPROXY_CLI_MAGIC);
212	80	AZ(strcmp(av[0], "send"));
213	80	AN(av[1]);
214	80	AZ(av[2]);
215
216	80	vsb = VSB_new_auto();
217	80	AN(vsb);
218	80	AZ(VSB_cat(vsb, av[1]));
219	80	AZ(VSB_cat(vsb, "\n"));
220	80	AZ(VSB_finish(vsb));
221	80	if (hc->sock == -1) {
222		int fd;
223		const char *err;
224		struct vsb *vsb_connect;
225
226	0	vsb_connect = macro_expand(hc->vl, hc->connect);
227	0	AN(vsb_connect);
228	0	fd = haproxy_cli_tcp_connect(hc->vl,
229	0	VSB_data(vsb_connect), 10., &err);
230	0	if (fd < 0)
231	0	vtc_fatal(hc->vl,
232	0	"CLI failed to open %s: %s", VSB_data(vsb), err);
233	0	VSB_destroy(&vsb_connect);
234	0	hc->sock = fd;
235	0	}
236	80	vtc_dump(hc->vl, 4, "CLI send", VSB_data(vsb), -1);
237
238	80	if (VSB_tofile(vsb, hc->sock))
239	0	vtc_fatal(hc->vl,
240	0	"CLI fd %d send error %s", hc->sock, strerror(errno));
241
242		/* a CLI command must be followed by a SHUT_WR if we want HAProxy to
243		* close after the response */
244	80	j = shutdown(hc->sock, SHUT_WR);
245	80	vtc_log(hc->vl, 3, "CLI shutting fd %d", hc->sock);
246	80	if (!VTCP_Check(j))
247	0	vtc_fatal(hc->vl, "Shutdown failed: %s", strerror(errno));
248
249	80	VSB_destroy(&vsb);
250	80	}
251
252		#define HAPROXY_CLI_RECV_LEN (1 << 14)
253		static void
254	80	haproxy_cli_recv(struct haproxy_cli *hc)
255		{
256		ssize_t ret;
257		size_t rdz, left, off;
258
259	80	rdz = ret = off = 0;
260		/* We want to null terminate this buffer. */
261	80	left = hc->rxbuf_sz - 1;
262	160	while (!vtc_error && left > 0) {
263	160	VTCP_set_read_timeout(hc->sock, hc->timeout);
264
265	160	ret = recv(hc->sock, hc->rxbuf + off, HAPROXY_CLI_RECV_LEN, 0);
266	160	if (ret < 0) {
267	0	if (errno == EINTR \|\| errno == EAGAIN)
268	0	continue;
269
270	0	vtc_fatal(hc->vl,
271		"CLI fd %d recv() failed (%s)",
272	0	hc->sock, strerror(errno));
273		}
274		/* Connection closed. */
275	160	if (ret == 0) {
276	80	if (rdz > 0 && hc->rxbuf[rdz - 1] != '\n')
277	0	vtc_fatal(hc->vl,
278		"CLI rx timeout (fd: %d %.3fs ret: %zd)",
279	0	hc->sock, hc->timeout, ret);
280
281	80	vtc_log(hc->vl, 4, "CLI connection normally closed");
282	80	vtc_log(hc->vl, 3, "CLI closing fd %d", hc->sock);
283	80	VTCP_close(&hc->sock);
284	80	break;
285		}
286
287	80	rdz += ret;
288	80	left -= ret;
289	80	off += ret;
290		}
291	80	hc->rxbuf[rdz] = '\0';
292	80	vtc_dump(hc->vl, 4, "CLI recv", hc->rxbuf, rdz);
293	80	}
294
295		/*
296		* SECTION: haproxy.cli.expect
297		* expect OP STRING
298		* Regex match the CLI reception buffer with STRING
299		* if OP is ~ or, on the contrary, if OP is !~ check that there is
300		* no regex match.
301		*/
302		static void v_matchproto_(cmd_f)
303	80	cmd_haproxy_cli_expect(CMD_ARGS)
304		{
305		struct haproxy_cli *hc;
306		struct vsb vsb[1];
307		vre_t *vre;
308		int error, erroroffset, i, ret;
309		char cmp, spec, errbuf[VRE_ERROR_LEN];
310
311	80	(void)vl;
312	80	CAST_OBJ_NOTNULL(hc, priv, HAPROXY_CLI_MAGIC);
313	80	AZ(strcmp(av[0], "expect"));
314	80	av++;
315
316	80	cmp = av[0];
317	80	spec = av[1];
318	80	AN(cmp);
319	80	AN(spec);
320	80	AZ(av[2]);
321
322	80	assert(!strcmp(cmp, "~") \|\| !strcmp(cmp, "!~"));
323
324	80	haproxy_cli_recv(hc);
325
326	80	vre = VRE_compile(spec, 0, &error, &erroroffset, 1);
327	80	if (vre == NULL) {
328	0	AN(VSB_init(vsb, errbuf, sizeof errbuf));
329	0	AZ(VRE_error(vsb, error));
330	0	AZ(VSB_finish(vsb));
331	0	VSB_fini(vsb);
332	0	vtc_fatal(hc->vl, "CLI regexp error: '%s' (@%d) (%s)",
333	0	errbuf, erroroffset, spec);
334		}
335
336	80	i = VRE_match(vre, hc->rxbuf, 0, 0, NULL);
337
338	80	VRE_free(&vre);
339
340	80	ret = (i >= 0 && cmp == '~') \|\| (i < 0 && cmp == '!');
341	80	if (!ret)
342	0	vtc_fatal(hc->vl, "CLI expect failed %s \"%s\"", cmp, spec);
343		else
344	80	vtc_log(hc->vl, 4, "CLI expect match %s \"%s\"", cmp, spec);
345	80	}
346
347		static const struct cmds haproxy_cli_cmds[] = {
348		#define CMD_HAPROXY_CLI(n) { #n, cmd_haproxy_cli_##n },
349		CMD_HAPROXY_CLI(send)
350		CMD_HAPROXY_CLI(expect)
351		#undef CMD_HAPROXY_CLI
352		{ NULL, NULL }
353		};
354
355		/**********************************************************************
356		* HAProxy CLI client thread
357		*/
358
359		static void *
360	80	haproxy_cli_thread(void *priv)
361		{
362		struct haproxy_cli *hc;
363		struct vsb *vsb;
364		int fd;
365		const char *err;
366
367	80	CAST_OBJ_NOTNULL(hc, priv, HAPROXY_CLI_MAGIC);
368	80	AN(*hc->connect);
369
370	80	vsb = macro_expand(hc->vl, hc->connect);
371	80	AN(vsb);
372
373	80	fd = haproxy_cli_tcp_connect(hc->vl, VSB_data(vsb), 10., &err);
374	80	if (fd < 0)
375	0	vtc_fatal(hc->vl,
376	0	"CLI failed to open %s: %s", VSB_data(vsb), err);
377	80	VTCP_blocking(fd);
378	80	hc->sock = fd;
379	80	parse_string(hc->vl, hc, hc->spec);
380	80	vtc_log(hc->vl, 2, "CLI ending");
381	80	VSB_destroy(&vsb);
382	80	return (NULL);
383		}
384
385		/**********************************************************************
386		* Wait for the CLI client thread to stop
387		*/
388
389		static void
390	80	haproxy_cli_wait(struct haproxy_cli *hc)
391		{
392		void *res;
393
394	80	CHECK_OBJ_NOTNULL(hc, HAPROXY_CLI_MAGIC);
395	80	vtc_log(hc->vl, 2, "CLI waiting");
396	80	PTOK(pthread_join(hc->tp, &res));
397	80	if (res != NULL)
398	0	vtc_fatal(hc->vl, "CLI returned \"%s\"", (char *)res);
399	80	REPLACE(hc->spec, NULL);
400	80	hc->tp = 0;
401	80	hc->running = 0;
402	80	}
403
404		/**********************************************************************
405		* Start the CLI client thread
406		*/
407
408		static void
409	80	haproxy_cli_start(struct haproxy_cli *hc)
410		{
411	80	CHECK_OBJ_NOTNULL(hc, HAPROXY_CLI_MAGIC);
412	80	vtc_log(hc->vl, 2, "CLI starting");
413	80	PTOK(pthread_create(&hc->tp, NULL, haproxy_cli_thread, hc));
414	80	hc->running = 1;
415
416	80	}
417
418		/**********************************************************************
419		* Run the CLI client thread
420		*/
421
422		static void
423	80	haproxy_cli_run(struct haproxy_cli *hc)
424		{
425	80	haproxy_cli_start(hc);
426	80	haproxy_cli_wait(hc);
427	80	}
428
429		/**********************************************************************
430		* Wait for the pidfile
431		*/
432
433		static void
434	160	haproxy_wait_pidfile(struct haproxy *h)
435		{
436	160	char buf_err[1024] = {0};
437	160	int usleep_time = 1000;
438		double t0;
439		pid_t pid;
440
441	160	vtc_log(h->vl, 3, "wait-pid-file");
442	5533	for (t0 = VTIM_mono(); VTIM_mono() - t0 < 3;) {
443	5533	if (vtc_error)
444	0	return;
445
446	5533	if (VPF_Read(h->pid_fn, &pid) != 0) {
447	5373	bprintf(buf_err,
448		"Could not read PID file '%s'", h->pid_fn);
449	5373	usleep(usleep_time);
450	5373	continue;
451		}
452
453	160	if (!h->opt_daemon && pid != h->pid) {
454	0	bprintf(buf_err,
455		"PID file has different PID (%ld != %lld)",
456		(long)pid, (long long)h->pid);
457	0	usleep(usleep_time);
458	0	continue;
459		}
460
461	160	if (kill(pid, 0) < 0) {
462	0	bprintf(buf_err,
463		"Could not find PID %ld process", (long)pid);
464	0	usleep(usleep_time);
465	0	continue;
466		}
467
468	160	h->pid = pid;
469
470	320	vtc_log(h->vl, 2, "haproxy PID %ld successfully started",
471	160	(long)pid);
472	160	return;
473		}
474	0	vtc_fatal(h->vl, "haproxy %s PID file check failed:\n\t%s\n",
475	0	h->name, buf_err);
476	160	}
477
478		/**********************************************************************
479		* Bind the sd_notify socket
480		*/
481		static void
482	40	haproxy_bind_sdnotify(struct haproxy *h)
483		{
484		char sd_path[PATH_MAX];
485		int sd;
486		int ret;
487	40	const char *err = NULL;
488	40	struct sockaddr_un *uds = &h->sd_uds;
489	40	socklen_t sl = sizeof(*uds);
490
491	40	bprintf(sd_path, "%s/sd_notify.sock", h->workdir);
492	40	assert(sd_path[0] == '/');
493
494	40	if (strlen(sd_path) + 1 > sizeof(uds->sun_path)) {
495	0	vtc_fatal(h->vl, "Path %s too long for a Unix domain socket", sd_path);
496		}
497	40	memset(uds->sun_path, 0, sizeof(uds->sun_path));
498	40	bprintf(uds->sun_path, "%s", sd_path);
499	40	uds->sun_family = PF_UNIX;