/*-

 * 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,

{

        struct envar *e;

        e = malloc(sizeof *e);

static void

haproxy_delete_envars(struct haproxy *h)

        struct envar *e, *e2;

        VTAILQ_FOREACH_SAFE(e, &h->envars, list, e2) {

static void

haproxy_build_env(const struct haproxy *h)

        struct envar *e;

        VTAILQ_FOREACH(e, &h->envars, list) {

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

 * Socket connect (same as client_tcp_connect()).

 */

static int

haproxy_cli_tcp_connect(struct vtclog *vl, const char *addr, vtim_dur tmo,

{

        int fd;

        char mabuf[VTCP_ADDRBUFSIZE], mpbuf[VTCP_PORTBUFSIZE];

        AN(addr);

/*

 * 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;

        vsb = VSB_new_auto();

                const char *err;

                struct vsb *vsb_connect;

                vsb_connect = macro_expand(hc->vl, hc->connect);

        if (VSB_tofile(vsb, hc->sock))

        /* 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);

        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;

        left = hc->rxbuf_sz - 1;

                ret = recv(hc->sock, hc->rxbuf + off, HAPROXY_CLI_RECV_LEN, 0);

                        vtc_fatal(hc->vl,

                            hc->sock, strerror(errno));

                /* Connection closed. */

                if (ret == 0) {

                                    hc->sock, hc->timeout, ret);

                        vtc_log(hc->vl, 4, "CLI connection normally closed");

                rdz += ret;

        hc->rxbuf[rdz] = '\0';

/*

 * 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;

        cmp = av[0];

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

        haproxy_cli_recv(hc);

        vre = VRE_compile(spec, 0, &error, &erroroffset, 1);

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

        VRE_free(&vre);

        ret = (i >= 0 && *cmp == '~') || (i < 0 && *cmp == '!');

                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);

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

        fd = haproxy_cli_tcp_connect(hc->vl, VSB_data(vsb), 10., &err);

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

 * 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);

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

 * Start the CLI client thread

 */

static void

haproxy_cli_start(struct haproxy_cli *hc)

        CHECK_OBJ_NOTNULL(hc, HAPROXY_CLI_MAGIC);

}

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

 * Run the CLI client thread

 */

static void

haproxy_cli_run(struct haproxy_cli *hc)

        haproxy_cli_start(hc);

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

 * Wait for the pidfile

 */

static void

haproxy_wait_pidfile(struct haproxy *h)

        char buf_err[1024] = {0};

        pid_t pid;

        vtc_log(h->vl, 3, "wait-pid-file");

                if (VPF_Read(h->pid_fn, &pid) != 0) {

                        usleep(usleep_time);

                if (!h->opt_daemon && pid != h->pid) {

                            (long)pid, (long long)h->pid);

                        usleep(usleep_time);

                if (kill(pid, 0) < 0) {

                        usleep(usleep_time);

                h->pid = pid;

                vtc_log(h->vl, 2, "haproxy PID %ld successfully started",

        vtc_fatal(h->vl, "haproxy %s PID file check failed:\n\t%s\n",

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

 * 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;

        bprintf(sd_path, "%s/sd_notify.sock", h->workdir);

        if (strlen(sd_path) + 1 > sizeof(uds->sun_path)) {

        memset(uds->sun_path, 0, sizeof(uds->sun_path));

        sd = socket(AF_UNIX, SOCK_DGRAM, 0);

        if (unlink(uds->sun_path) != 0 && errno != ENOENT) {

        if (bind(sd, (const void*)uds, sl) != 0) {

        h->sd_sock = sd;

        assert(h->sd_sock > 0);

error:

        if (err != NULL)

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

 * 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));

        i = poll(fd, 1, vtc_maxdur * 1000 / 3);

        r = recv(h->sd_sock, buf, sizeof(buf) - 1, 0);

        if (!ready)

                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);

        hc->vl = h->vl;

        hc->txbuf_sz = hc->rxbuf_sz = 2048 * 1024;

        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);

        hc->vl = h->vl;

        hc->txbuf_sz = hc->rxbuf_sz = 2048 * 1024;

        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];

        sock = VTCP_listen_on(default_listen_addr, NULL, 100, &err);

        VTCP_name(sua, addr, sizeof addr, port, sizeof port);

                macro_def(h->vl, buf, "sock", "[%s]:%s", addr, port);

        return (sock);

static void

haproxy_cli_delete(struct haproxy_cli *hc)

        CHECK_OBJ_NOTNULL(hc, HAPROXY_CLI_MAGIC);

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

 * 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];

        ALLOC_OBJ(h, HAPROXY_MAGIC);

        h->args = VSB_new_auto();

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

        h->filename = getenv(HAPROXY_PROGRAM_ENV_VAR);

        bprintf(buf, "${tmpdir}/%s", name);

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

        bprintf(buf, "%s/cfg", h->workdir);

        /* 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);

                macro_def(h->vl, h->closed_sock, "sock", "[%s]:%s", addr, port);

        h->cli = haproxy_cli_new(h);

        h->mcli = haproxy_mcli_new(h);

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

        h->sd_sock = -1;

        VTAILQ_INIT(&h->envars);

        return (h);

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

 * Delete a haproxy instance

 */

static void

haproxy_delete(struct haproxy *h)

        char buf[PATH_MAX];

        CHECK_OBJ_NOTNULL(h, HAPROXY_MAGIC);

        if (!leave_temp) {

        if (h->sd_sock >= 0)

        free(h->name);

        /* XXX: MEMLEAK (?) */

        FREE_OBJ(h);

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

 * HAProxy listener

 */

static void *

haproxy_thread(void *priv)

        struct haproxy *h;

        CAST_OBJ_NOTNULL(h, priv, HAPROXY_MAGIC);

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

 * 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));

        vsb = VSB_new_auto();

        VSB_printf(vsb, "exec \"%s\"", h->filename);

                VSB_cat(vsb, " -d");

        if (h->opt_worker) {

                if (h->opt_mcli) {

                        sock = haproxy_create_mcli(h);

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

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

        if (h->opt_worker || h->opt_daemon) {

        AZ(VSB_finish(vsb));

        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]));

        VSB_destroy(&vsb);

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

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

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

        if (h->pid_fn != NULL)

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

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

 * 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)

        if (h->cli->spec)

        if (h->mcli->spec)

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

        sig = SIGINT;

                        n = 0;

        PTOK(pthread_join(h->tp, &p));

#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);

        p = s;

                char buf[128], addr[128], port[128];

                const char *err;

                char vsabuf[vsa_suckaddr_len];

                p = strstr(p, HAPROXY_BE_FD_STR);

                if (!p)

                while (*q && *q != '}')

                if (err != NULL)

                AN(sua);

                VTCP_name(sua, addr, sizeof addr, port, sizeof port);

                macro_def(h->vl, buf, "port", "%s", port);

                p = q;

}

        haproxy_start(h);

        haproxy_wait(h);

        if (strstr(VSB_data(h->msgs), expect) == NULL)

                vtc_fatal(h->vl, "Did not find expected string '%s'", expect);

        struct vsb *vsb, *vsb2;

        vsb = VSB_new_auto();

        AN(vsb);

        vsb2 = VSB_new_auto();

        VSB_printf(vsb, "    global\n\tstats socket \"%s\" "

                   "level admin mode 600\n", h->cli_fn);

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

        VSB_destroy(&vsb2);

}

static void

        struct vsb *vsb;

        assert(VSB_len(vsb) >= 0);

        if (VFIL_writefile(h->workdir, h->cfg_fn,

            VSB_data(vsb), VSB_len(vsb)) != 0)

                vtc_fatal(h->vl,

        VSB_destroy(&vsb);

 * Define and interact with haproxy instances.

 * To define a haproxy server, you'll use this syntax::

 *      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 */

                        vtc_log(h->vl, 2,

                            "Reset and free %s haproxy %ld",

                            h->name, (long)h->pid);

                                haproxy_wait(h);

                        haproxy_delete(h);

        }

                        break;

        if (h == NULL)

                        h->expect_exit = 0;

                }

                        continue;

                        continue;

                }

                }

                }

                        VSB_cat(h->args, " ");

                }

                }

                }

                if (!strcmp(*av, "-conf+backend")) {

                        AN(av[1]);

                if (!strcmp(*av, "-expectexit")) {

                        haproxy_start(h);

                        continue;

                }