女同性恋cbcb


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

#include "config.h"

#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>


#include "vcc_compile.h"
#include "vsa.h"
#include "vss.h"
#include "vus.h"

/*--------------------------------------------------------------------
 * Struct sockaddr is not really designed to be a compile time
 * initialized data structure, so we encode it as a byte-string
 * and put it in an official sockaddr when we load the VCL.
 */

static void
Emit_Sockaddr(struct vcc *tl, struct vsb *vsb1, const struct token *t_host,
    const struct token *t_port)
{
        const char *ipv4, *ipv4a, *ipv6, *ipv6a, *pa;
        char buf[BUFSIZ];

        AN(t_host->dec);

        if (t_port != NULL)
                bprintf(buf, "%s %s", t_host->dec, t_port->dec);
        else
                bprintf(buf, "%s", t_host->dec);
        Resolve_Sockaddr(tl, buf, "80",
            &ipv4, &ipv4a, &ipv6, &ipv6a, &pa, 2, t_host, "Backend host");
        ERRCHK(tl);
        if (ipv4 != NULL) {
                VSB_printf(vsb1,
                    "\t.ipv4 = (const struct suckaddr *)%s,\n",
                    ipv4);
        }
        if (ipv6 != NULL) {
                VSB_printf(vsb1,
                    "\t.ipv6 = (const struct suckaddr *)%s,\n",
                    ipv6);
        }
        VSB_cat(vsb1, "\t.uds_path = (void *) 0,\n");
}

/*
 * a string represents an IP address if getaddrinfo(AI_NUMERICHOST) succeeds
 */
static int
isip(const char *addr)
{
        char buf[vsa_suckaddr_len];

        return (VSS_ResolveOne(buf, addr, "80", AF_UNSPEC, SOCK_STREAM,
            AI_NUMERICHOST | AI_NUMERICSERV) != NULL);
}

/*
 * For UDS, we do not create a VSA. We run the VUS_resolver() checks and, if
 * it's a path, can be accessed, and is a socket. If so, just emit the path
 * field and set the IP suckaddrs to NULL.
 */

static int
uds_resolved(void *priv, const struct sockaddr_un *uds)
{
        (void) priv;
        (void) uds;
        return (42);
}

static void
emit_path(struct vsb *vsb1, char *path)
{
        VSB_printf(vsb1, "\t.uds_path = \"%s\",\n", path);
        VSB_cat(vsb1, "\t.ipv4 = (void *) 0,\n");
        VSB_cat(vsb1, "\t.ipv6 = (void *) 0,\n");
}

static void
Emit_UDS_Path(struct vcc *tl, struct vsb *vsb1,
    const struct token *t_path, const char *errid)
{
        struct stat st;
        const char *vus_err;

        AN(t_path);
        AN(t_path->dec);

        if (! VUS_is(t_path->dec)) {
                VSB_printf(tl->sb,
                           "%s: Must be a valid path or abstract socket:\n",
                           errid);
                vcc_ErrWhere(tl, t_path);
                return;
        }
        if (VUS_resolver(t_path->dec, uds_resolved, NULL, &vus_err) != 42) {
                VSB_printf(tl->sb, "%s: %s\n", errid, vus_err);
                vcc_ErrWhere(tl, t_path);
                return;
        }
        if (*t_path->dec == '@') {
                emit_path(vsb1, t_path->dec);
                return;
        }
        assert(*t_path->dec == '/');
        errno = 0;
        if (stat(t_path->dec, &st) != 0) {
                int err = errno;
                VSB_printf(tl->sb, "%s: Cannot stat: %s\n", errid,
                           strerror(errno));
                vcc_ErrWhere(tl, t_path);
                if (err == ENOENT || err == EACCES)
                        vcc_Warn(tl);
                else
                        return;
        } else if (!S_ISSOCK(st.st_mode)) {
                VSB_printf(tl->sb, "%s: Not a socket:\n", errid);
                vcc_ErrWhere(tl, t_path);
                return;
        }
        emit_path(vsb1, t_path->dec);
}

/*--------------------------------------------------------------------
 * Disallow mutually exclusive field definitions
 */

static void
vcc_Redef(struct vcc *tl, const char *redef, const struct token **t_did,
    const struct token *t_field)
{
        if (*t_did != NULL) {
                VSB_printf(tl->sb, "%s redefinition at:\n", redef);
                vcc_ErrWhere(tl, t_field);
                VSB_cat(tl->sb, "Previous definition:\n");
                vcc_ErrWhere(tl, *t_did);
                return;
        }
        *t_did = t_field;
}

/*--------------------------------------------------------------------
 * Parse a backend probe specification
 */

static void
vcc_ParseProbeSpec(struct vcc *tl, const struct symbol *sym, char **namep)
{
        struct fld_spec *fs;
        const struct token *t_field;
        const struct token *t_did = NULL, *t_window = NULL, *t_threshold = NULL;
        struct token *t_initial = NULL;
        unsigned window, threshold, initial, status, exp_close;
        char buf[32];
        const char *name;
        double t;

        fs = vcc_FldSpec(tl,
            "?url",
            "?request",
            "?expected_response",
            "?timeout",
            "?interval",
            "?window",
            "?threshold",
            "?initial",
            "?expect_close",
            NULL);

        SkipToken(tl, '{');

        if (sym != NULL) {
                name = sym->rname;
        } else {
                bprintf(buf, "vgc_probe__%d", tl->nprobe++);
                name = buf;
        }
        Fh(tl, 0, "static const struct vrt_backend_probe %s[] = {{\n", name);
        Fh(tl, 0, "\t.magic = VRT_BACKEND_PROBE_MAGIC,\n");
        if (namep != NULL)
                *namep = TlDup(tl, name);

        window = 0;
        threshold = 0;
        initial = 0;
        status = 0;
        exp_close = 1;
        while (tl->t->tok != '}') {

                vcc_IsField(tl, &t_field, fs);
                ERRCHK(tl);
                if (vcc_IdIs(t_field, "url")) {
                        vcc_Redef(tl, "Probe request", &t_did, t_field);
                        ERRCHK(tl);
                        ExpectErr(tl, CSTR);
                        Fh(tl, 0, "\t.url = ");
                        EncToken(tl->fh, tl->t);
                        Fh(tl, 0, ",\n");
                        vcc_NextToken(tl);
                } else if (vcc_IdIs(t_field, "request")) {
                        vcc_Redef(tl, "Probe request", &t_did, t_field);
                        ERRCHK(tl);
                        ExpectErr(tl, CSTR);
                        Fh(tl, 0, "\t.request =\n");
                        while (tl->t->tok == CSTR) {
                                Fh(tl, 0, "\t\t");
                                EncToken(tl->fh, tl->t);
                                Fh(tl, 0, " \"\\r\\n\"\n");
                                vcc_NextToken(tl);
                        }
                        Fh(tl, 0, "\t\t\"\\r\\n\",\n");
                } else if (vcc_IdIs(t_field, "timeout")) {
                        Fh(tl, 0, "\t.timeout = ");
                        vcc_Duration(tl, &t);
                        ERRCHK(tl);
                        Fh(tl, 0, "%g,\n", t);
                } else if (vcc_IdIs(t_field, "interval")) {
                        Fh(tl, 0, "\t.interval = ");
                        vcc_Duration(tl, &t);
                        ERRCHK(tl);
                        Fh(tl, 0, "%g,\n", t);
                } else if (vcc_IdIs(t_field, "window")) {
                        t_window = tl->t;
                        window = vcc_UintVal(tl);
                        ERRCHK(tl);
                } else if (vcc_IdIs(t_field, "initial")) {
                        t_initial = tl->t;
                        initial = vcc_UintVal(tl);
                        ERRCHK(tl);
                } else if (vcc_IdIs(t_field, "expected_response")) {
                        status = vcc_UintVal(tl);
                        if (status < 100 || status > 999) {
                                VSB_cat(tl->sb,
                                    "Must specify .expected_response with "
                                    "exactly three digits "
                                    "(100 <= x <= 999)\n");
                                vcc_ErrWhere(tl, tl->t);
                                return;
                        }
                        ERRCHK(tl);
                } else if (vcc_IdIs(t_field, "threshold")) {
                        t_threshold = tl->t;
                        threshold = vcc_UintVal(tl);
                        ERRCHK(tl);
                } else if (vcc_IdIs(t_field, "expect_close")) {
                        exp_close = vcc_BoolVal(tl);
                        ERRCHK(tl);
                } else {
                        vcc_ErrToken(tl, t_field);
                        vcc_ErrWhere(tl, t_field);
                        ErrInternal(tl);
                        return;
                }

                SkipToken(tl, ';');
        }
        free(fs);

        if (t_threshold != NULL || t_window != NULL) {
                if (t_threshold == NULL && t_window != NULL) {
                        VSB_cat(tl->sb,
                            "Must specify .threshold with .window\n");
                        vcc_ErrWhere(tl, t_window);
                        return;
                } else if (t_threshold != NULL && t_window == NULL) {
                        if (threshold > 64) {
                                VSB_cat(tl->sb,
                                    "Threshold must be 64 or less.\n");
                                vcc_ErrWhere(tl, t_threshold);
                                return;
                        }
                        window = threshold + 1;
                } else if (window > 64) {
                        AN(t_window);
                        VSB_cat(tl->sb, "Window must be 64 or less.\n");
                        vcc_ErrWhere(tl, t_window);
                        return;
                }
                if (threshold > window ) {
                        VSB_cat(tl->sb,
                            "Threshold cannot be greater than window.\n");
                        AN(t_threshold);
                        vcc_ErrWhere(tl, t_threshold);
                        AN(t_window);
                        vcc_ErrWhere(tl, t_window);
                }
                Fh(tl, 0, "\t.window = %u,\n", window);
                Fh(tl, 0, "\t.threshold = %u,\n", threshold);
        }
        if (t_initial != NULL)
                Fh(tl, 0, "\t.initial = %u,\n", initial);
        else
                Fh(tl, 0, "\t.initial = ~0U,\n");
        if (status > 0)
                Fh(tl, 0, "\t.exp_status = %u,\n", status);
        Fh(tl, 0, "\t.exp_close = %u,\n", exp_close);
        Fh(tl, 0, "}};\n");
        SkipToken(tl, '}');
}

/*--------------------------------------------------------------------
 * Parse and emit a probe definition
 */

void
vcc_ParseProbe(struct vcc *tl)
{
        struct symbol *sym;
        char *p;

        vcc_NextToken(tl);                      /* ID: probe */

        vcc_ExpectVid(tl, "backend probe");     /* ID: name */
        ERRCHK(tl);

        sym = VCC_HandleSymbol(tl, PROBE);
        ERRCHK(tl);
        AN(sym);
        vcc_ParseProbeSpec(tl, sym, &p);

        if (sym->type == DEFAULT)
                tl->default_probe = p;
        else
                free(p);
}

/*--------------------------------------------------------------------
 * Parse and emit a backend host definition
 *
 * The struct vrt_backend is emitted to Fh().
 */

static void
vcc_ParseHostDef(struct vcc *tl, struct symbol *sym,
    const struct token *t_be, const char *vgcname)
{
        const struct token *t_field;
        const struct token *t_val;
        const struct token *t_probe;
        const struct token *t_host = NULL;
        const struct token *t_port = NULL;
        const struct token *t_path = NULL;
        const struct token *t_hosthdr = NULL;
        const struct token *t_authority = NULL;
        const struct token *t_did = NULL;
        const struct token *t_preamble = NULL;
        struct symbol *pb;
        struct fld_spec *fs;
        struct inifin *ifp;
        struct vsb *vsb1;
        struct symbol *via = NULL;
        vtim_dur connect_timeout = NAN;
        vtim_dur first_byte_timeout = NAN;
        vtim_dur between_bytes_timeout = NAN;
        vtim_dur backend_wait_timeout = NAN;
        char *p, *pp;
        unsigned u;
        int l;

        if (tl->t->tok == ID &&
            (vcc_IdIs(tl->t, "none") || vcc_IdIs(tl->t, "None"))) {
                vcc_NextToken(tl);
                SkipToken(tl, ';');
                ifp = New_IniFin(tl);
                VSB_printf(ifp->ini, "\t(void)%s;", vgcname);
                VSB_printf(ifp->fin, "\t\t(void)%s;", vgcname);
                return;
        }

        SkipToken(tl, '{');

        /* Check for old syntax */
        if (tl->t->tok == ID && vcc_IdIs(tl->t, "set")) {
                VSB_cat(tl->sb,
                    "NB: Backend Syntax has changed:\n"
                    "Remove \"set\" and \"backend\" in front"
                    " of backend fields.\n" );
                vcc_ErrToken(tl, tl->t);
                VSB_cat(tl->sb, " at ");
                vcc_ErrWhere(tl, tl->t);
                return;
        }

        fs = vcc_FldSpec(tl,
            "?host",
            "?port",
            "?path",
            "?host_header",
            "?connect_timeout",
            "?first_byte_timeout",
            "?between_bytes_timeout",
            "?probe",
            "?max_connections",
            "?proxy_header",
            "?preamble",
            "?via",
            "?authority",
            "?wait_timeout",
            "?wait_limit",
            NULL);

        tl->fb = VSB_new_auto();
        AN(tl->fb);

        Fb(tl, 0, "\nstatic const struct vrt_backend vgc_dir_priv_%s = {\n",
            vgcname);

        Fb(tl, 0, "\t.magic = VRT_BACKEND_MAGIC,\n");
        Fb(tl, 0, "\t.endpoint = &vgc_dir_ep_%s,\n", vgcname);
        Fb(tl, 0, "\t.vcl_name = \"%.*s", PF(t_be));
        Fb(tl, 0, "\",\n");

        while (tl->t->tok != '}') {

                vcc_IsField(tl, &t_field, fs);
                ERRCHK(tl);
                if (vcc_IdIs(t_field, "host")) {
                        vcc_Redef(tl, "Address", &t_did, t_field);
                        ERRCHK(tl);
                        ExpectErr(tl, CSTR);
                        assert(tl->t->dec != NULL);
                        t_host = tl->t;
                        vcc_NextToken(tl);
                        SkipToken(tl, ';');
                } else if (vcc_IdIs(t_field, "port")) {
                        ExpectErr(tl, CSTR);
                        assert(tl->t->dec != NULL);
                        t_port = tl->t;
                        vcc_NextToken(tl);
                        SkipToken(tl, ';');
                } else if (vcc_IdIs(t_field, "path")) {
                        if (tl->syntax < VCL_41) {
                                VSB_cat(tl->sb,
                                    "Unix socket backends only supported"
                                    " in VCL4.1 and higher.\n");
                                vcc_ErrToken(tl, tl->t);
                                VSB_cat(tl->sb, " at ");
                                vcc_ErrWhere(tl, tl->t);
                                VSB_destroy(&tl->fb);
                                return;
                        }
                        vcc_Redef(tl, "Address", &t_did, t_field);
                        ERRCHK(tl);
                        ExpectErr(tl, CSTR);
                        assert(tl->t->dec != NULL);
                        t_path = tl->t;
                        vcc_NextToken(tl);
                        SkipToken(tl, ';');
                } else if (vcc_IdIs(t_field, "host_header")) {
                        ExpectErr(tl, CSTR);
                        assert(tl->t->dec != NULL);
                        t_hosthdr = tl->t;
                        vcc_NextToken(tl);
                        SkipToken(tl, ';');
                } else if (vcc_IdIs(t_field, "connect_timeout")) {
                        Fb(tl, 0, "\t.connect_timeout = ");
                        vcc_Duration(tl, &connect_timeout);
                        ERRCHK(tl);
                        Fb(tl, 0, "%g,\n", connect_timeout);
                        SkipToken(tl, ';');
                } else if (vcc_IdIs(t_field, "first_byte_timeout")) {
                        Fb(tl, 0, "\t.first_byte_timeout = ");
                        vcc_Duration(tl, &first_byte_timeout);
                        ERRCHK(tl);
                        Fb(tl, 0, "%g,\n", first_byte_timeout);
                        SkipToken(tl, ';');
                } else if (vcc_IdIs(t_field, "between_bytes_timeout")) {
                        Fb(tl, 0, "\t.between_bytes_timeout = ");
                        vcc_Duration(tl, &between_bytes_timeout);
                        ERRCHK(tl);
                        Fb(tl, 0, "%g,\n", between_bytes_timeout);
                        SkipToken(tl, ';');
                } else if (vcc_IdIs(t_field, "max_connections")) {
                        u = vcc_UintVal(tl);
                        ERRCHK(tl);
                        SkipToken(tl, ';');
                        Fb(tl, 0, "\t.max_connections = %u,\n", u);
                } else if (vcc_IdIs(t_field, "proxy_header")) {
                        t_val = tl->t;
                        u = vcc_UintVal(tl);
                        ERRCHK(tl);
                        if (u != 1 && u != 2) {
                                VSB_cat(tl->sb,
                                    ".proxy_header must be 1 or 2\n");
                                vcc_ErrWhere(tl, t_val);
                                VSB_destroy(&tl->fb);
                                return;
                        }
                        SkipToken(tl, ';');
                        Fb(tl, 0, "\t.proxy_header = %u,\n", u);
                } else if (vcc_IdIs(t_field, "probe") && tl->t->tok == '{') {
                        vcc_ParseProbeSpec(tl, NULL, &p);
                        Fb(tl, 0, "\t.probe = %s,\n", p);
                        free(p);
                        ERRCHK(tl);
                } else if (vcc_IdIs(t_field, "probe") && tl->t->tok == ID) {
                        t_probe = tl->t;
                        pb = VCC_SymbolGet(tl, SYM_MAIN, SYM_PROBE,
                            SYMTAB_EXISTING, XREF_REF);
                        ERRCHK(tl);
                        AN(pb);
                        if (pb->type == DEFAULT) {
                                if (tl->default_probe == NULL) {
                                        VSB_cat(tl->sb,
                                            "No default probe defined\n");
                                        vcc_ErrToken(tl, t_probe);
                                        VSB_cat(tl->sb, " at\n");
                                        vcc_ErrWhere(tl, t_probe);
                                }
                                pb = PROBE->default_sym;
                        }
                        ERRCHK(tl);
                        Fb(tl, 0, "\t.probe = %s,\n", pb->rname);
                        SkipToken(tl, ';');
                } else if (vcc_IdIs(t_field, "probe")) {
                        VSB_cat(tl->sb, "Expected '{' or name of probe, got ");
                        vcc_ErrToken(tl, tl->t);
                        VSB_cat(tl->sb, " at\n");
                        vcc_ErrWhere(tl, tl->t);
                        VSB_destroy(&tl->fb);
                        return;
                } else if (vcc_IdIs(t_field, "preamble")) {
                        ExpectErr(tl, CBLOB);
                        t_preamble = tl->t;
                        vcc_NextToken(tl);
                        SkipToken(tl, ';');
                } else if (vcc_IdIs(t_field, "via")) {
                        via = VCC_SymbolGet(tl, SYM_MAIN, SYM_BACKEND,
                            SYMTAB_EXISTING, XREF_REF);
                        ERRCHK(tl);
                        AN(via);
                        AN(via->rname);

                        if (via->extra != NULL) {
                                AZ(strcmp(via->extra, "via"));
                                VSB_cat(tl->sb,
                                        "Cannot stack .via backends at\n");
                                vcc_ErrWhere(tl, tl->t);
                                VSB_destroy(&tl->fb);
                                return;
                        }

                        AN(sym);
                        AZ(sym->extra);
                        sym->extra = "via";
                        SkipToken(tl, ';');
                } else if (vcc_IdIs(t_field, "authority")) {
                        ExpectErr(tl, CSTR);
                        assert(tl->t->dec != NULL);
                        t_authority = tl->t;
                        vcc_NextToken(tl);
                        SkipToken(tl, ';');
                } else if (vcc_IdIs(t_field, "wait_timeout")) {
                        Fb(tl, 0, "\t.backend_wait_timeout = ");
                        vcc_Duration(tl, &backend_wait_timeout);
                        ERRCHK(tl);
                        Fb(tl, 0, "%g,\n", backend_wait_timeout);
                        SkipToken(tl, ';');
                } else if (vcc_IdIs(t_field, "wait_limit")) {
                        u = vcc_UintVal(tl);
                        ERRCHK(tl);
                        SkipToken(tl, ';');
                        Fb(tl, 0, "\t.backend_wait_limit = %u,\n", u);
                } else {
                        ErrInternal(tl);
                        VSB_destroy(&tl->fb);
                        return;
                }

        }

        vcc_FieldsOk(tl, fs);
        free(fs);
        ERRCHK(tl);

        if (isnan(connect_timeout))
                Fb(tl, 0, "\t.connect_timeout = -1.0,\n");
        if (isnan(first_byte_timeout))
                Fb(tl, 0, "\t.first_byte_timeout = -1.0,\n");
        if (isnan(between_bytes_timeout))
                Fb(tl, 0, "\t.between_bytes_timeout = -1.0,\n");
        if (isnan(backend_wait_timeout))
                Fb(tl, 0, "\t.backend_wait_timeout = -1.0,\n");

        ExpectErr(tl, '}');

        if (t_host == NULL && t_path == NULL) {
                VSB_cat(tl->sb, "Expected .host or .path.\n");
                vcc_ErrWhere(tl, t_be);
                VSB_destroy(&tl->fb);
                return;
        }

        if (via != NULL && t_path != NULL) {
                VSB_cat(tl->sb, "Cannot set both .via and .path.\n");
                vcc_ErrWhere(tl, t_be);
                return;
        }

        if (via != NULL)
                AZ(via->extra);

        vsb1 = VSB_new_auto();
        AN(vsb1);
        VSB_printf(vsb1,
            "\nstatic const struct vrt_endpoint vgc_dir_ep_%s = {\n",
            vgcname);
        VSB_cat(vsb1, "\t.magic = VRT_ENDPOINT_MAGIC,\n");

        assert(t_host != NULL || t_path != NULL);
        if (t_host != NULL)
                /* Check that the hostname makes sense */
                Emit_Sockaddr(tl, vsb1, t_host, t_port);
        else
                /* Check that the path can be a legal UDS */
                Emit_UDS_Path(tl, vsb1, t_path, "Backend path");
        ERRCHK(tl);

        if (t_preamble != NULL)
                VSB_printf(vsb1, "\t.preamble = %s,\n", t_preamble->dec);

        VSB_cat(vsb1, "};\n");
        AZ(VSB_finish(vsb1));
        Fh(tl, 0, "%s", VSB_data(vsb1));
        VSB_destroy(&vsb1);

        /* Emit the hosthdr field, fall back to .host if not specified */
        /* If .path is specified, set "0.0.0.0". */
        Fb(tl, 0, "\t.hosthdr = ");
        if (t_hosthdr != NULL)
                EncToken(tl->fb, t_hosthdr);
        else if (t_host != NULL)
                EncToken(tl->fb, t_host);
        else
                Fb(tl, 0, "\"0.0.0.0\"");
        Fb(tl, 0, ",\n");

        /*
         * Emit the authority field, falling back to hosthdr, then host.
         *
         * When authority is "", sending the TLV is disabled.
         *
         * authority must be a valid SNI HostName (RFC 4366 ch. 3.1), but the
         * RFC does not define what that is and defers to "DNS hostname".
         *
         * So instead of trying to attempt a solution to that pandora's box, we
         * just implement >>Literal IPv4 and IPv6 addresses are not permitted in
         * "HostName".<<
         */
        if (via != NULL) {
                AN(t_host);
                if (t_authority != NULL)
                        t_val = t_authority;
                else if (t_hosthdr != NULL)
                        t_val = t_hosthdr;
                else
                        t_val = t_host;
                p = t_val->dec;

                if (isip(p)) {
                        if (t_val == t_authority)
                                VSB_cat(tl->sb, ".authority can not be an ip address with .via.\n");
                        else {
                                VSB_printf(tl->sb, ".%s used as authority can not be an ip address with .via.\n",
                                        t_val == t_hosthdr ? "host_header" : "host");
                                VSB_cat(tl->sb, "Hint: configure .authority explicitly\n");
                        }
                        vcc_ErrWhere(tl, t_val);
                }

                pp = strchr(p, ':');
                l = (pp == NULL) ? -1 : (int)(pp - p);

                Fb(tl, 0, "\t.authority = ");
                VSB_quote(tl->fb, p, l, VSB_QUOTE_CSTR);
                Fb(tl, 0, ",\n");
        }

        /* Close the struct */
        Fb(tl, 0, "};\n");

        vcc_NextToken(tl);

        AZ(VSB_finish(tl->fb));
        Fh(tl, 0, "%s", VSB_data(tl->fb));
        VSB_destroy(&tl->fb);

        ifp = New_IniFin(tl);
        VSB_printf(ifp->ini,
            "\t%s =\n\t    VRT_new_backend_clustered(ctx, vsc_cluster,\n"
            "\t\t&vgc_dir_priv_%s, %s);\n",
            vgcname, vgcname, via ? via->rname : "NULL");
        VSB_printf(ifp->ini,
            "\tif (%s)\n\t\tVRT_StaticDirector(%s);", vgcname, vgcname);
        VSB_printf(ifp->fin, "\t\tVRT_delete_backend(ctx, &%s);", vgcname);
}

/*--------------------------------------------------------------------
 * Parse directors and backends
 */

void
vcc_ParseBackend(struct vcc *tl)
{
        struct token *t_first, *t_be;
        struct symbol *sym;
        const char *dn;

        tl->ndirector++;
        t_first = tl->t;
        SkipToken(tl, ID);              /* ID: backend */

        vcc_ExpectVid(tl, "backend");   /* ID: name */
        ERRCHK(tl);

        t_be = tl->t;

        sym = VCC_HandleSymbol(tl, BACKEND);
        ERRCHK(tl);
        AN(sym);

        if (sym->type == DEFAULT) {
                if (tl->first_director != NULL) {
                        tl->first_director->noref = 0;
                        tl->first_director = NULL;
                        tl->default_director = NULL;
                }
                if (tl->default_director != NULL) {
                        VSB_cat(tl->sb,
                            "Only one default director possible.\n");
                        vcc_ErrWhere(tl, t_first);
                        return;
                }
                dn = "vgc_backend_default";
                tl->default_director = dn;
        } else {
                dn = sym->rname;
                if (tl->default_director == NULL) {
                        tl->first_director = sym;
                        tl->default_director = dn;
                        sym->noref = 1;
                }
        }

        Fh(tl, 0, "\nstatic VCL_BACKEND %s;\n", dn);
        vcc_ParseHostDef(tl, sym, t_be, dn);
        if (tl->err) {
                VSB_printf(tl->sb,
                    "\nIn %.*s specification starting at:\n", PF(t_first));
                vcc_ErrWhere(tl, t_first);
                return;
        }
}

void
vcc_Backend_Init(struct vcc *tl)
{
        struct inifin *ifp;

        Fh(tl, 0, "\nstatic struct vsmw_cluster *vsc_cluster;\n");
        ifp = New_IniFin(tl);
        VSB_cat(ifp->ini, "\tvsc_cluster = VRT_VSM_Cluster_New(ctx,\n"
            "\t    ndirector * VRT_backend_vsm_need(ctx));\n");
        VSB_cat(ifp->ini, "\tif (vsc_cluster == 0)\n\t\treturn(1);");
        VSB_cat(ifp->fin, "\t\tVRT_VSM_Cluster_Destroy(ctx, &vsc_cluster);");
}

		varnish-cache/lib/libvcc/vcc_backend.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2015 Varnish Software AS
3		* 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		*/
31
32		#include "config.h"
33
34		#include <math.h>
35		#include <stdlib.h>
36		#include <string.h>
37		#include <sys/stat.h>
38		#include <sys/types.h>
39		#include <sys/socket.h>
40		#include <netdb.h>
41
42
43		#include "vcc_compile.h"
44		#include "vsa.h"
45		#include "vss.h"
46		#include "vus.h"
47
48		/*--------------------------------------------------------------------
49		* Struct sockaddr is not really designed to be a compile time
50		* initialized data structure, so we encode it as a byte-string
51		* and put it in an official sockaddr when we load the VCL.
52		*/
53
54		static void
55	2742	Emit_Sockaddr(struct vcc tl, struct vsb vsb1, const struct token *t_host,
56		const struct token *t_port)
57		{
58		const char ipv4, ipv4a, ipv6, ipv6a, *pa;
59		char buf[BUFSIZ];
60
61	2742	AN(t_host->dec);
62
63	2742	if (t_port != NULL)
64	2094	bprintf(buf, "%s %s", t_host->dec, t_port->dec);
65		else
66	648	bprintf(buf, "%s", t_host->dec);
67	5484	Resolve_Sockaddr(tl, buf, "80",
68	2742	&ipv4, &ipv4a, &ipv6, &ipv6a, &pa, 2, t_host, "Backend host");
69	2742	ERRCHK(tl);
70	2738	if (ipv4 != NULL) {
71	5452	VSB_printf(vsb1,
72		"\t.ipv4 = (const struct suckaddr *)%s,\n",
73	2726	ipv4);
74	2726	}
75	2738	if (ipv6 != NULL) {
76	28	VSB_printf(vsb1,
77		"\t.ipv6 = (const struct suckaddr *)%s,\n",
78	14	ipv6);
79	14	}
80	2738	VSB_cat(vsb1, "\t.uds_path = (void *) 0,\n");
81	2742	}
82
83		/*
84		* a string represents an IP address if getaddrinfo(AI_NUMERICHOST) succeeds
85		*/
86		static int
87	20	isip(const char *addr)
88		{
89	20	char buf[vsa_suckaddr_len];
90
91	20	return (VSS_ResolveOne(buf, addr, "80", AF_UNSPEC, SOCK_STREAM,
92	20	AI_NUMERICHOST \| AI_NUMERICSERV) != NULL);
93	20	}
94
95		/*
96		* For UDS, we do not create a VSA. We run the VUS_resolver() checks and, if
97		* it's a path, can be accessed, and is a socket. If so, just emit the path
98		* field and set the IP suckaddrs to NULL.
99		*/
100
101		static int
102	64	uds_resolved(void priv, const struct sockaddr_un uds)
103		{
104	64	(void) priv;
105	64	(void) uds;
106	64	return (42);
107		}
108
109		static void
110	62	emit_path(struct vsb vsb1, char path)
111		{
112	62	VSB_printf(vsb1, "\t.uds_path = \"%s\",\n", path);
113	62	VSB_cat(vsb1, "\t.ipv4 = (void *) 0,\n");
114	62	VSB_cat(vsb1, "\t.ipv6 = (void *) 0,\n");
115	62	}
116
117		static void
118	68	Emit_UDS_Path(struct vcc tl, struct vsb vsb1,
119		const struct token t_path, const char errid)
120		{
121		struct stat st;
122		const char *vus_err;
123
124	68	AN(t_path);
125	68	AN(t_path->dec);
126
127	68	if (! VUS_is(t_path->dec)) {
128	4	VSB_printf(tl->sb,
129		"%s: Must be a valid path or abstract socket:\n",
130	2	errid);
131	2	vcc_ErrWhere(tl, t_path);
132	2	return;
133		}
134	66	if (VUS_resolver(t_path->dec, uds_resolved, NULL, &vus_err) != 42) {
135	2	VSB_printf(tl->sb, "%s: %s\n", errid, vus_err);
136	2	vcc_ErrWhere(tl, t_path);
137	2	return;
138		}
139	64	if (*t_path->dec == '@') {
140	0	emit_path(vsb1, t_path->dec);
141	0	return;
142		}
143	64	assert(*t_path->dec == '/');
144	64	errno = 0;
145	64	if (stat(t_path->dec, &st) != 0) {
146	2	int err = errno;
147	4	VSB_printf(tl->sb, "%s: Cannot stat: %s\n", errid,
148	2	strerror(errno));
149	2	vcc_ErrWhere(tl, t_path);
150	2	if (err == ENOENT \|\| err == EACCES)
151	2	vcc_Warn(tl);
152		else
153	0	return;
154	64	} else if (!S_ISSOCK(st.st_mode)) {
155	2	VSB_printf(tl->sb, "%s: Not a socket:\n", errid);
156	2	vcc_ErrWhere(tl, t_path);
157	2	return;
158		}
159	62	emit_path(vsb1, t_path->dec);
160	68	}
161
162		/*--------------------------------------------------------------------
163		* Disallow mutually exclusive field definitions
164		*/
165
166		static void
167	2880	vcc_Redef(struct vcc tl, const char redef, const struct token **t_did,
168		const struct token *t_field)
169		{
170	2880	if (*t_did != NULL) {
171	6	VSB_printf(tl->sb, "%s redefinition at:\n", redef);
172	6	vcc_ErrWhere(tl, t_field);
173	6	VSB_cat(tl->sb, "Previous definition:\n");
174	6	vcc_ErrWhere(tl, *t_did);
175	6	return;
176		}
177	2874	*t_did = t_field;
178	2880	}
179
180		/*--------------------------------------------------------------------
181		* Parse a backend probe specification
182		*/
183
184		static void
185	94	vcc_ParseProbeSpec(struct vcc tl, const struct symbol sym, char **namep)
186		{
187		struct fld_spec *fs;
188		const struct token *t_field;
189	94	const struct token t_did = NULL, t_window = NULL, *t_threshold = NULL;
190	94	struct token *t_initial = NULL;
191		unsigned window, threshold, initial, status, exp_close;
192		char buf[32];
193		const char *name;
194		double t;
195
196	94	fs = vcc_FldSpec(tl,
197		"?url",
198		"?request",
199		"?expected_response",
200		"?timeout",
201		"?interval",
202		"?window",
203		"?threshold",
204		"?initial",
205		"?expect_close",
206		NULL);
207
208	94	SkipToken(tl, '{');
209
210	94	if (sym != NULL) {
211	42	name = sym->rname;
212	42	} else {
213	52	bprintf(buf, "vgc_probe__%d", tl->nprobe++);
214	52	name = buf;
215		}
216	94	Fh(tl, 0, "static const struct vrt_backend_probe %s[] = {{\n", name);
217	94	Fh(tl, 0, "\t.magic = VRT_BACKEND_PROBE_MAGIC,\n");
218	94	if (namep != NULL)
219	94	*namep = TlDup(tl, name);
220
221	94	window = 0;
222	94	threshold = 0;
223	94	initial = 0;
224	94	status = 0;
225	94	exp_close = 1;
226	314	while (tl->t->tok != '}') {
227
228	232	vcc_IsField(tl, &t_field, fs);
229	232	ERRCHK(tl);
230	232	if (vcc_IdIs(t_field, "url")) {
231	26	vcc_Redef(tl, "Probe request", &t_did, t_field);
232	26	ERRCHK(tl);
233	24	ExpectErr(tl, CSTR);
234	24	Fh(tl, 0, "\t.url = ");
235	24	EncToken(tl->fh, tl->t);
236	24	Fh(tl, 0, ",\n");
237	24	vcc_NextToken(tl);
238	230	} else if (vcc_IdIs(t_field, "request")) {
239	10	vcc_Redef(tl, "Probe request", &t_did, t_field);
240	10	ERRCHK(tl);
241	8	ExpectErr(tl, CSTR);
242	8	Fh(tl, 0, "\t.request =\n");
243	32	while (tl->t->tok == CSTR) {
244	24	Fh(tl, 0, "\t\t");
245	24	EncToken(tl->fh, tl->t);
246	24	Fh(tl, 0, " \"\\r\\n\"\n");
247	24	vcc_NextToken(tl);
248		}
249	8	Fh(tl, 0, "\t\t\"\\r\\n\",\n");
250	204	} else if (vcc_IdIs(t_field, "timeout")) {
251	20	Fh(tl, 0, "\t.timeout = ");
252	20	vcc_Duration(tl, &t);
253	20	ERRCHK(tl);
254	18	Fh(tl, 0, "%g,\n", t);
255	194	} else if (vcc_IdIs(t_field, "interval")) {
256	52	Fh(tl, 0, "\t.interval = ");
257	52	vcc_Duration(tl, &t);
258	52	ERRCHK(tl);
259	52	Fh(tl, 0, "%g,\n", t);
260	176	} else if (vcc_IdIs(t_field, "window")) {
261	40	t_window = tl->t;
262	40	window = vcc_UintVal(tl);
263	40	ERRCHK(tl);
264	124	} else if (vcc_IdIs(t_field, "initial")) {
265	28	t_initial = tl->t;
266	28	initial = vcc_UintVal(tl);
267	28	ERRCHK(tl);
268	84	} else if (vcc_IdIs(t_field, "expected_response")) {
269	4	status = vcc_UintVal(tl);
270	4	if (status < 100 \|\| status > 999) {
271	2	VSB_cat(tl->sb,
272		"Must specify .expected_response with "
273		"exactly three digits "
274		"(100 <= x <= 999)\n");
275	2	vcc_ErrWhere(tl, tl->t);
276	2	return;
277		}
278	2	ERRCHK(tl);
279	54	} else if (vcc_IdIs(t_field, "threshold")) {
280	44	t_threshold = tl->t;
281	44	threshold = vcc_UintVal(tl);
282	44	ERRCHK(tl);
283	52	} else if (vcc_IdIs(t_field, "expect_close")) {
284	8	exp_close = vcc_BoolVal(tl);
285	8	ERRCHK(tl);
286	4	} else {
287	0	vcc_ErrToken(tl, t_field);
288	0	vcc_ErrWhere(tl, t_field);
289	0	ErrInternal(tl);
290	0	return;
291		}
292
293	220	SkipToken(tl, ';');
294		}
295	82	free(fs);
296
297	82	if (t_threshold != NULL \|\| t_window != NULL) {
298	46	if (t_threshold == NULL && t_window != NULL) {
299	2	VSB_cat(tl->sb,
300		"Must specify .threshold with .window\n");
301	2	vcc_ErrWhere(tl, t_window);
302	2	return;
303	44	} else if (t_threshold != NULL && t_window == NULL) {
304	6	if (threshold > 64) {
305	2	VSB_cat(tl->sb,
306		"Threshold must be 64 or less.\n");
307	2	vcc_ErrWhere(tl, t_threshold);
308	2	return;
309		}
310	4	window = threshold + 1;
311	42	} else if (window > 64) {
312	2	AN(t_window);
313	2	VSB_cat(tl->sb, "Window must be 64 or less.\n");
314	2	vcc_ErrWhere(tl, t_window);
315	2	return;
316		}
317	40	if (threshold > window ) {
318	2	VSB_cat(tl->sb,
319		"Threshold cannot be greater than window.\n");
320	2	AN(t_threshold);
321	2	vcc_ErrWhere(tl, t_threshold);
322	2	AN(t_window);
323	2	vcc_ErrWhere(tl, t_window);
324	2	}
325	40	Fh(tl, 0, "\t.window = %u,\n", window);
326	40	Fh(tl, 0, "\t.threshold = %u,\n", threshold);
327	40	}
328	76	if (t_initial != NULL)
329	28	Fh(tl, 0, "\t.initial = %u,\n", initial);
330		else
331	48	Fh(tl, 0, "\t.initial = ~0U,\n");
332	76	if (status > 0)
333	2	Fh(tl, 0, "\t.exp_status = %u,\n", status);
334	76	Fh(tl, 0, "\t.exp_close = %u,\n", exp_close);
335	76	Fh(tl, 0, "}};\n");
336	76	SkipToken(tl, '}');
337	94	}
338
339		/*--------------------------------------------------------------------
340		* Parse and emit a probe definition
341		*/
342
343		void
344	44	vcc_ParseProbe(struct vcc *tl)
345		{
346		struct symbol *sym;
347		char *p;
348
349	44	vcc_NextToken(tl); /* ID: probe */
350
351	44	vcc_ExpectVid(tl, "backend probe"); /* ID: name */
352	44	ERRCHK(tl);
353
354	44	sym = VCC_HandleSymbol(tl, PROBE);
355	44	ERRCHK(tl);
356	42	AN(sym);
357	42	vcc_ParseProbeSpec(tl, sym, &p);
358
359	42	if (sym->type == DEFAULT)
360	20	tl->default_probe = p;
361		else
362	22	free(p);
363	44	}
364
365		/*--------------------------------------------------------------------
366		* Parse and emit a backend host definition
367		*
368		* The struct vrt_backend is emitted to Fh().
369		*/
370
371		static void
372	3344	vcc_ParseHostDef(struct vcc tl, struct symbol sym,
373		const struct token t_be, const char vgcname)
374		{
375		const struct token *t_field;
376		const struct token *t_val;
377		const struct token *t_probe;
378	3344	const struct token *t_host = NULL;
379	3344	const struct token *t_port = NULL;
380	3344	const struct token *t_path = NULL;
381	3344	const struct token *t_hosthdr = NULL;
382	3344	const struct token *t_authority = NULL;
383	3344	const struct token *t_did = NULL;
384	3344	const struct token *t_preamble = NULL;
385		struct symbol *pb;
386		struct fld_spec *fs;
387		struct inifin *ifp;
388		struct vsb *vsb1;
389	3344	struct symbol *via = NULL;
390	3344	vtim_dur connect_timeout = NAN;
391	3344	vtim_dur first_byte_timeout = NAN;
392	3344	vtim_dur between_bytes_timeout = NAN;
393	3344	vtim_dur backend_wait_timeout = NAN;
394		char p, pp;
395		unsigned u;
396		int l;
397
398	3554	if (tl->t->tok == ID &&
399	492	(vcc_IdIs(tl->t, "none") \|\| vcc_IdIs(tl->t, "None"))) {
400	492	vcc_NextToken(tl);
401	492	SkipToken(tl, ';');
402	492	ifp = New_IniFin(tl);
403	492	VSB_printf(ifp->ini, "\t(void)%s;", vgcname);
404	492	VSB_printf(ifp->fin, "\t\t(void)%s;", vgcname);
405	492	return;
406		}
407
408	2852	SkipToken(tl, '{');
409
410		/* Check for old syntax */
411	2852	if (tl->t->tok == ID && vcc_IdIs(tl->t, "set")) {
412	2	VSB_cat(tl->sb,
413		"NB: Backend Syntax has changed:\n"
414		"Remove \"set\" and \"backend\" in front"
415		" of backend fields.\n" );
416	2	vcc_ErrToken(tl, tl->t);
417	2	VSB_cat(tl->sb, " at ");
418	2	vcc_ErrWhere(tl, tl->t);
419	2	return;
420		}
421
422	2850	fs = vcc_FldSpec(tl,
423		"?host",
424		"?port",
425		"?path",
426		"?host_header",
427		"?connect_timeout",
428		"?first_byte_timeout",
429		"?between_bytes_timeout",
430		"?probe",
431		"?max_connections",
432		"?proxy_header",
433		"?preamble",
434		"?via",
435		"?authority",
436		"?wait_timeout",
437		"?wait_limit",
438		NULL);
439
440	2850	tl->fb = VSB_new_auto();
441	2850	AN(tl->fb);
442
443	5700	Fb(tl, 0, "\nstatic const struct vrt_backend vgc_dir_priv_%s = {\n",
444	2850	vgcname);
445
446	2850	Fb(tl, 0, "\t.magic = VRT_BACKEND_MAGIC,\n");
447	2850	Fb(tl, 0, "\t.endpoint = &vgc_dir_ep_%s,\n", vgcname);
448	2850	Fb(tl, 0, "\t.vcl_name = \"%.*s", PF(t_be));
449	2850	Fb(tl, 0, "\",\n");
450
451	7956	while (tl->t->tok != '}') {
452
453	5142	vcc_IsField(tl, &t_field, fs);
454	5142	ERRCHK(tl);
455	5138	if (vcc_IdIs(t_field, "host")) {
456	2772	vcc_Redef(tl, "Address", &t_did, t_field);
457	2772	ERRCHK(tl);
458	2772	ExpectErr(tl, CSTR);
459	2772	assert(tl->t->dec != NULL);
460	2772	t_host = tl->t;
461	2772	vcc_NextToken(tl);
462	2772	SkipToken(tl, ';');
463	5138	} else if (vcc_IdIs(t_field, "port")) {
464	2098	ExpectErr(tl, CSTR);
465	2098	assert(tl->t->dec != NULL);
466	2098	t_port = tl->t;
467	2098	vcc_NextToken(tl);
468	2098	SkipToken(tl, ';');
469	2366	} else if (vcc_IdIs(t_field, "path")) {
470	74	if (tl->syntax < VCL_41) {
471	2	VSB_cat(tl->sb,
472		"Unix socket backends only supported"
473		" in VCL4.1 and higher.\n");
474	2	vcc_ErrToken(tl, tl->t);
475	2	VSB_cat(tl->sb, " at ");
476	2	vcc_ErrWhere(tl, tl->t);
477	2	VSB_destroy(&tl->fb);
478	2	return;
479		}
480	72	vcc_Redef(tl, "Address", &t_did, t_field);
481	72	ERRCHK(tl);
482	70	ExpectErr(tl, CSTR);
483	70	assert(tl->t->dec != NULL);
484	70	t_path = tl->t;
485	70	vcc_NextToken(tl);
486	70	SkipToken(tl, ';');
487	264	} else if (vcc_IdIs(t_field, "host_header")) {
488	12	ExpectErr(tl, CSTR);
489	12	assert(tl->t->dec != NULL);
490	12	t_hosthdr = tl->t;
491	12	vcc_NextToken(tl);
492	12	SkipToken(tl, ';');
493	194	} else if (vcc_IdIs(t_field, "connect_timeout")) {
494	6	Fb(tl, 0, "\t.connect_timeout = ");
495	6	vcc_Duration(tl, &connect_timeout);
496	6	ERRCHK(tl);
497	6	Fb(tl, 0, "%g,\n", connect_timeout);
498	6	SkipToken(tl, ';');
499	182	} else if (vcc_IdIs(t_field, "first_byte_timeout")) {

Henceforth, whatever our philosopher says about Matter will apply to extension and to extension alone. It cannot be apprehended by sight, nor by hearing, nor by smell, nor by taste, for it is neither colour, nor sound, nor odour, nor juice. Neither can it be touched, for it is not a body, but it becomes corporeal on being blended with sensible qualities. And, in a later essay, he describes it as receiving all things and letting them depart again without retaining the slightest trace of their presence.483 Why then, it may be asked, if Plotinus meant extension, could he not say so at once, and save us all this trouble in hunting out his meaning? There were very good reasons why he should not. In the first place, he wished to express himself, so far as possible, in Aristotelian phraseology, and this was incompatible with the reduction of Matter to extension. In the next place, the idea of an infinite void had been already appropriated by the Epicureans, to whose system he was bitterly opposed. And, finally, the extension of ordinary327 experience had not the absolute generality which was needed in order to bring Matter into relation with that ultimate abstraction whence, like everything else, it has now to be derived. That the millionaire was genuine, “in person and not a caricature,” as Dick put it, was evident. Both the nurse, his relative, and his wife, were chatting with him as Jeff delivered the heavy packed ball made up of the gum. 233 "I guess not," said Landor, tolerantly, as he turned[Pg 106] his horse over to his orderly; "but, anyway," he added to Ellton, "we had a picnic—of a sort." Si, unable to think of anything better, went with him. The train had stopped on a switch, and seemed likely to rust fast to the rails, from the way other trains were going by in both directions. The bridge gang, under charge of a burly, red-faced young Englishman, was in the rear car, with their tools, equipments, bedding and cooking utensils. THE DEACON HAS SOME EXPERIENCES WITH THE QUADRUPED. "You are not within a mile of the truth. I know it. Look here: I believe that is Gen. Rosecrans's own cow. She's gone, and I got an order to look around for her. I've never seen her, but from the description given me I believe that's she. Who brought her here?" "Deacon, these brothers and sisters who have come here with me to-night are, like myself, deeply interested in the moral condition of the army, where we all have sons or kinsmen. Now, can't you sit right there and tell us of your observations and experiences, as a Christian man and father, from day to day, of every day that you were down there? Tell us everything, just as it happened each day, that we may be able to judge for ourselves." HAS AN ENCOUNTER WITH THE PROVOST-MARSHAL. "Wonder which one o' them is the 200th Injianny's?" said Si to Shorty. "And your mother, and Harry?" The daughter must be the girl who was talking to him now. She sat on a little stool by the fire, and had brought out some sewing. "Over at Grandturzel—can't see wot's burning from here. Git buckets and come!" These things, however, gave little concern to the worthy who commanded the Kentish division. Tyler, though an excellent blacksmith, possessed few of the qualities requisite for forming a good general. Provided there was no very sensible diminution in the number of his followers, he cared not a straw for the score or two who, after quarrelling, or perhaps fighting, withdrew in such disgust that they vowed rather to pay the full tax for ever than submit to the insolence of the rebels. One man could fight as well as another, reasoned he; and, provided he was obeyed, what mattered it by whom. Dick went and Tom came—it was sure to be all one in the end. But this burst of indignation soon passed away, and upon the suggestion of the prudent Sir Robert Hailes, he sent an evasive answer, with a command that the Commons should attend him at Windsor on the Sunday following. That it was a stratagem to gain entrance to the Tower, was the opinion of several, but, after much discussion, it was decided that the man should be admitted, and that the monk should be exhibited merely to intimidate the rebels, until the result of this promised communication should be known. HoME 女同性恋cbcb ENTER NUMBET 0017
jijin9.com.cn
jydsg.com.cn
huomi2.com.cn
gtavr.net.cn
www.liti0.com.cn
ylcn.net.cn
www.yaozu2.net.cn
nijia8.net.cn
www.nanmu5.net.cn
46webfind.com.cn