static void
vcc_ByteVal(struct vcc *tl, double *d)
{
double v, sc;
v = vcc_DoubleVal(tl);
ERRCHK(tl);
if (tl->t->tok != ID) {
VSB_printf(tl->sb, "Expected BYTES unit (B, KB, MB...) got ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, "\n");
vcc_ErrWhere(tl, tl->t);
return;
}
if (vcc_IdIs(tl->t, "B"))
sc = 1.;
else if (vcc_IdIs(tl->t, "KB"))
sc = 1024.;
else if (vcc_IdIs(tl->t, "MB"))
sc = 1024. * 1024.;
else if (vcc_IdIs(tl->t, "GB"))
sc = 1024. * 1024. * 1024.;
else if (vcc_IdIs(tl->t, "TB"))
sc = 1024. * 1024. * 1024. * 1024.;
else {
VSB_printf(tl->sb, "Unknown BYTES unit ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb,
". Legal are 'B', 'KB', 'MB', 'GB' and 'TB'\n");
vcc_ErrWhere(tl, tl->t);
return;
}
vcc_NextToken(tl);
*d = v * sc;
}
static double
vcc_TimeUnit(struct vcc *tl)
{
double sc = 1.0;
assert(tl->t->tok == ID);
if (vcc_IdIs(tl->t, "ms"))
sc = 1e-3;
else if (vcc_IdIs(tl->t, "s"))
sc = 1.0;
else if (vcc_IdIs(tl->t, "m"))
sc = 60.0;
else if (vcc_IdIs(tl->t, "h"))
sc = 60.0 * 60.0;
else if (vcc_IdIs(tl->t, "d"))
sc = 60.0 * 60.0 * 24.0;
else if (vcc_IdIs(tl->t, "w"))
sc = 60.0 * 60.0 * 24.0 * 7.0;
else {
VSB_printf(tl->sb, "Unknown time unit ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, ". Legal are 's', 'm', 'h' and 'd'\n");
vcc_ErrWhere(tl, tl->t);
return (1.0);
}
vcc_NextToken(tl);
return (sc);
}
static void
illegal_assignment(const struct tokenlist *tl, const char *type)
{
vsb_printf(tl->sb, "Invalid assignment operator ");
vcc_ErrToken(tl, tl->t);
vsb_printf(tl->sb,
" only '=' is legal for %s\n", type);
}
void
vcc__Expect(struct tokenlist *tl, unsigned tok, int line)
{
if (tl->t->tok == tok)
return;
vsb_printf(tl->sb, "Expected %s got ", vcl_tnames[tok]);
vcc_ErrToken(tl, tl->t);
vsb_printf(tl->sb, "\n(program line %u), at\n", line);
vcc_ErrWhere(tl, tl->t);
}
const struct var *
vcc_FindVar(struct vcc *tl, const struct token *t, int wr_access,
const char *use)
{
const struct var *v;
const struct symbol *sym;
AN(tl->vars);
sym = VCC_FindSymbol(tl, t, SYM_VAR);
if (sym != NULL) {
v = sym->var;
AN(v);
if (wr_access && v->w_methods == 0) {
VSB_printf(tl->sb, "Variable ");
vcc_ErrToken(tl, t);
VSB_printf(tl->sb, " is read only.");
VSB_cat(tl->sb, "\nAt: ");
vcc_ErrWhere(tl, t);
return (NULL);
} else if (wr_access) {
vcc_AddUses(tl, t, v->w_methods, use);
} else if (v->r_methods == 0) {
VSB_printf(tl->sb, "Variable ");
vcc_ErrToken(tl, t);
VSB_printf(tl->sb, " is write only.");
VSB_cat(tl->sb, "\nAt: ");
vcc_ErrWhere(tl, t);
return (NULL);
} else {
vcc_AddUses(tl, t, v->r_methods, use);
}
assert(v->fmt != HEADER);
return (v);
}
VSB_printf(tl->sb, "Unknown variable ");
vcc_ErrToken(tl, t);
VSB_cat(tl->sb, "\nAt: ");
vcc_ErrWhere(tl, t);
return (NULL);
}
const char *
vcc_default_probe(struct vcc *tl)
{
if (tl->default_probe != NULL)
return (tl->default_probe);
VSB_printf(tl->sb, "No default probe defined\n");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " at\n");
vcc_ErrWhere(tl, tl->t);
return ("");
}
void
vcc_Parse(struct vcc *tl)
{
struct toplev *tp;
while (tl->t->tok != EOI) {
ERRCHK(tl);
switch (tl->t->tok) {
case CSRC:
if (tl->allow_inline_c) {
Fc(tl, 0, "%.*s\n",
(int) (tl->t->e - (tl->t->b + 4)),
tl->t->b + 2);
vcc_NextToken(tl);
} else {
VSB_printf(tl->sb,
"Inline-C not allowed\n");
vcc_ErrWhere(tl, tl->t);
}
break;
case EOI:
break;
case ID:
for (tp = toplev; tp->name != NULL; tp++) {
if (!vcc_IdIs(tl->t, tp->name))
continue;
tp->func(tl);
break;
}
if (tp->name != NULL)
break;
/* FALLTHROUGH */
default:
/* We deliberately do not mention inline-C */
VSB_printf(tl->sb, "Expected one of\n\t");
for (tp = toplev; tp->name != NULL; tp++) {
if (tp[1].name == NULL)
VSB_printf(tl->sb, " or ");
VSB_printf(tl->sb, "'%s'", tp->name);
if (tp[1].name != NULL)
VSB_printf(tl->sb, ", ");
}
VSB_printf(tl->sb, "\nFound: ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " at\n");
vcc_ErrWhere(tl, tl->t);
return;
}
}
}
void
vcc_ExpectCid(struct tokenlist *tl)
{
ExpectErr(tl, ID);
ERRCHK(tl);
if (vcc_isCid(tl->t))
return;
vsb_printf(tl->sb, "Identifier ");
vcc_ErrToken(tl, tl->t);
vsb_printf(tl->sb,
" contains illegal characters, use [0-9a-zA-Z_] only.\n");
vcc_ErrWhere(tl, tl->t);
}
static void
vcc_ParseHostDef(struct vcc *tl, int serial, const char *vgcname)
{
struct token *t_field;
struct token *t_host = NULL;
struct token *t_port = NULL;
struct token *t_hosthdr = NULL;
unsigned saint = UINT_MAX;
struct fld_spec *fs;
struct vsb *vsb;
unsigned u;
double t;
Fh(tl, 1, "\n#define VGC_backend_%s %d\n", vgcname, tl->ndirector);
fs = vcc_FldSpec(tl,
"!host",
"?port",
"?host_header",
"?connect_timeout",
"?first_byte_timeout",
"?between_bytes_timeout",
"?probe",
"?max_connections",
"?saintmode_threshold",
NULL);
SkipToken(tl, '{');
vsb = VSB_new_auto();
AN(vsb);
tl->fb = vsb;
Fb(tl, 0, "\nstatic const struct vrt_backend vgc_dir_priv_%s = {\n",
vgcname);
Fb(tl, 0, "\t.vcl_name = \"%.*s", PF(tl->t_dir));
if (serial >= 0)
Fb(tl, 0, "[%d]", serial);
Fb(tl, 0, "\",\n");
/* Check for old syntax */
if (tl->t->tok == ID && vcc_IdIs(tl->t, "set")) {
VSB_printf(tl->sb,
"NB: Backend Syntax has changed:\n"
"Remove \"set\" and \"backend\" in front"
" of backend fields.\n" );
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " at ");
vcc_ErrWhere(tl, tl->t);
return;
}
while (tl->t->tok != '}') {
vcc_IsField(tl, &t_field, fs);
ERRCHK(tl);
if (vcc_IdIs(t_field, "host")) {
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, "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, &t);
ERRCHK(tl);
Fb(tl, 0, "%g,\n", t);
SkipToken(tl, ';');
} else if (vcc_IdIs(t_field, "first_byte_timeout")) {
Fb(tl, 0, "\t.first_byte_timeout = ");
vcc_Duration(tl, &t);
ERRCHK(tl);
Fb(tl, 0, "%g,\n", t);
SkipToken(tl, ';');
} else if (vcc_IdIs(t_field, "between_bytes_timeout")) {
Fb(tl, 0, "\t.between_bytes_timeout = ");
vcc_Duration(tl, &t);
ERRCHK(tl);
Fb(tl, 0, "%g,\n", t);
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, "saintmode_threshold")) {
u = vcc_UintVal(tl);
/* UINT_MAX == magic number to mark as unset, so
* not allowed here.
*/
if (u == UINT_MAX) {
VSB_printf(tl->sb,
"Value outside allowed range: ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " at\n");
vcc_ErrWhere(tl, tl->t);
}
ERRCHK(tl);
saint = u;
SkipToken(tl, ';');
} else if (vcc_IdIs(t_field, "probe") && tl->t->tok == '{') {
Fb(tl, 0, "\t.probe = &vgc_probe__%d,\n", tl->nprobe);
vcc_ParseProbeSpec(tl);
ERRCHK(tl);
} else if (vcc_IdIs(t_field, "probe") && tl->t->tok == ID) {
Fb(tl, 0, "\t.probe = &vgc_probe_%.*s,\n", PF(tl->t));
vcc_AddRef(tl, tl->t, SYM_PROBE);
vcc_NextToken(tl);
SkipToken(tl, ';');
} else if (vcc_IdIs(t_field, "probe")) {
VSB_printf(tl->sb,
"Expected '{' or name of probe.");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " at\n");
vcc_ErrWhere(tl, tl->t);
return;
} else {
ErrInternal(tl);
return;
}
}
vcc_FieldsOk(tl, fs);
ERRCHK(tl);
/* Check that the hostname makes sense */
assert(t_host != NULL);
if (t_port != NULL)
Emit_Sockaddr(tl, t_host, t_port->dec);
else
Emit_Sockaddr(tl, t_host, "80");
ERRCHK(tl);
ExpectErr(tl, '}');
/* We have parsed it all, emit the ident string */
/* Emit the hosthdr field, fall back to .host if not specified */
Fb(tl, 0, "\t.hosthdr = ");
if (t_hosthdr != NULL)
EncToken(tl->fb, t_hosthdr);
else
EncToken(tl->fb, t_host);
Fb(tl, 0, ",\n");
Fb(tl, 0, "\t.saintmode_threshold = %d,\n",saint);
/* Close the struct */
Fb(tl, 0, "};\n");
vcc_NextToken(tl);
tl->fb = NULL;
AZ(VSB_finish(vsb));
Fh(tl, 0, "%s", VSB_data(vsb));
VSB_delete(vsb);
Fi(tl, 0, "\tVRT_init_dir(cli, VCL_conf.director, \"simple\",\n"
"\t VGC_backend_%s, &vgc_dir_priv_%s);\n", vgcname, vgcname);
Ff(tl, 0, "\tVRT_fini_dir(cli, VGCDIR(%s));\n", vgcname);
tl->ndirector++;
}
static void
vcc_expr_cmp(struct vcc *tl, struct expr **e, enum var_type fmt)
{
struct expr *e2;
const struct cmps *cp;
char buf[256];
char *re;
const char *not;
struct token *tk;
*e = NULL;
vcc_expr_add(tl, e, fmt);
ERRCHK(tl);
if ((*e)->fmt == BOOL)
return;
tk = tl->t;
for (cp = vcc_cmps; cp->fmt != VOID; cp++)
if ((*e)->fmt == cp->fmt && tl->t->tok == cp->token)
break;
if (cp->fmt != VOID) {
vcc_NextToken(tl);
vcc_expr_add(tl, &e2, (*e)->fmt);
ERRCHK(tl);
if (e2->fmt != (*e)->fmt) { /* XXX */
VSB_printf(tl->sb, "Comparison of different types: ");
VSB_printf(tl->sb, "%s ", vcc_Type((*e)->fmt));
vcc_ErrToken(tl, tk);
VSB_printf(tl->sb, " %s\n", vcc_Type(e2->fmt));
vcc_ErrWhere(tl, tk);
return;
}
*e = vcc_expr_edit(BOOL, cp->emit, *e, e2);
return;
}
if ((*e)->fmt == STRING &&
(tl->t->tok == '~' || tl->t->tok == T_NOMATCH)) {
not = tl->t->tok == '~' ? "" : "!";
vcc_NextToken(tl);
ExpectErr(tl, CSTR);
re = vcc_regexp(tl);
ERRCHK(tl);
vcc_NextToken(tl);
bprintf(buf, "%sVRT_re_match(\v1, %s)", not, re);
*e = vcc_expr_edit(BOOL, buf, *e, NULL);
return;
}
if ((*e)->fmt == IP &&
(tl->t->tok == '~' || tl->t->tok == T_NOMATCH)) {
not = tl->t->tok == '~' ? "" : "!";
vcc_NextToken(tl);
ExpectErr(tl, ID);
vcc_AddRef(tl, tl->t, SYM_ACL);
bprintf(buf, "%smatch_acl_named_%.*s(sp, \v1)", not, PF(tl->t));
vcc_NextToken(tl);
*e = vcc_expr_edit(BOOL, buf, *e, NULL);
return;
}
if ((*e)->fmt == IP && (tl->t->tok == T_EQ || tl->t->tok == T_NEQ)) {
vcc_Acl_Hack(tl, buf);
*e = vcc_expr_edit(BOOL, buf, *e, NULL);
return;
}
if ((*e)->fmt == BACKEND &&
(tl->t->tok == T_EQ || tl->t->tok == T_NEQ)) {
vcc_NextToken(tl);
ExpectErr(tl, ID);
vcc_AddRef(tl, tl->t, SYM_BACKEND);
bprintf(buf, "(\v1 %.*s VGCDIR(_%.*s))", PF(tk), PF(tl->t));
vcc_NextToken(tl);
*e = vcc_expr_edit(BOOL, buf, *e, NULL);
return;
}
switch (tl->t->tok) {
case T_EQ:
case T_NEQ:
case '<':
case T_LEQ:
case '>':
case T_GEQ:
case '~':
case T_NOMATCH:
VSB_printf(tl->sb, "Operator %.*s not possible on %s\n",
PF(tl->t), vcc_Type((*e)->fmt));
vcc_ErrWhere(tl, tl->t);
return;
default:
break;
}
if (fmt == BOOL && (*e)->fmt == STRING) {
*e = vcc_expr_edit(BOOL, "(\v1 != 0)", *e, NULL);
return;
}
}
static void
vcc_expr4(struct vcc *tl, struct expr **e, enum var_type fmt)
{
struct expr *e1, *e2;
const struct symbol *sym;
double d;
*e = NULL;
if (tl->t->tok == '(') {
SkipToken(tl, '(');
vcc_expr0(tl, &e2, fmt);
ERRCHK(tl);
SkipToken(tl, ')');
*e = vcc_expr_edit(e2->fmt, "(\v1)", e2, NULL);
return;
}
switch(tl->t->tok) {
case ID:
/*
* XXX: what if var and func/proc had same name ?
* XXX: look for SYM_VAR first for consistency ?
*/
sym = VCC_FindSymbol(tl, tl->t, SYM_NONE);
if (sym == NULL || sym->eval == NULL) {
VSB_printf(tl->sb, "Symbol not found: ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " (expected type %s):\n",
vcc_Type(fmt));
vcc_ErrWhere(tl, tl->t);
return;
}
AN(sym);
switch(sym->kind) {
case SYM_VAR:
case SYM_FUNC:
case SYM_BACKEND:
AN(sym->eval);
AZ(*e);
sym->eval(tl, e, sym);
return;
default:
break;
}
VSB_printf(tl->sb,
"Symbol type (%s) can not be used in expression.\n",
VCC_SymKind(tl, sym));
vcc_ErrWhere(tl, tl->t);
return;
case CSTR:
assert(fmt != VOID);
e1 = vcc_new_expr();
EncToken(e1->vsb, tl->t);
e1->fmt = STRING;
e1->t1 = tl->t;
e1->constant = 1;
vcc_NextToken(tl);
AZ(VSB_finish(e1->vsb));
*e = e1;
break;
case CNUM:
/*
* XXX: %g may not have enough decimals by default
* XXX: but %a is ugly, isn't it ?
*/
assert(fmt != VOID);
if (fmt == DURATION) {
vcc_RTimeVal(tl, &d);
ERRCHK(tl);
e1 = vcc_mk_expr(DURATION, "%g", d);
} else if (fmt == BYTES) {
vcc_ByteVal(tl, &d);
ERRCHK(tl);
e1 = vcc_mk_expr(BYTES, "%.1f", d);
ERRCHK(tl);
} else if (fmt == REAL) {
e1 = vcc_mk_expr(REAL, "%g", vcc_DoubleVal(tl));
ERRCHK(tl);
} else {
e1 = vcc_mk_expr(INT, "%.*s", PF(tl->t));
vcc_NextToken(tl);
}
e1->constant = 1;
*e = e1;
break;
default:
VSB_printf(tl->sb, "Unknown token ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " when looking for %s\n\n", vcc_Type(fmt));
vcc_ErrWhere(tl, tl->t);
break;
}
}
static void
vcc_ParseProbeSpec(struct vcc *tl, const struct symbol *sym, char **name)
{
struct fld_spec *fs;
struct token *t_field;
struct token *t_did = NULL, *t_window = NULL, *t_threshold = NULL;
struct token *t_initial = NULL;
struct vsb *vsb;
char *retval;
unsigned window, threshold, initial, status;
double t;
fs = vcc_FldSpec(tl,
"?url",
"?request",
"?expected_response",
"?timeout",
"?interval",
"?window",
"?threshold",
"?initial",
NULL);
SkipToken(tl, '{');
vsb = VSB_new_auto();
AN(vsb);
if (sym != NULL)
VSB_cat(vsb, sym->rname);
else
VSB_printf(vsb, "vgc_probe__%d", tl->nprobe++);
AZ(VSB_finish(vsb));
retval = TlDup(tl, VSB_data(vsb));
AN(retval);
VSB_destroy(&vsb);
if (name != NULL)
*name = retval;
window = 0;
threshold = 0;
initial = 0;
status = 0;
Fh(tl, 0, "static const struct vrt_backend_probe %s[] = {{\n", retval);
Fh(tl, 0, "\t.magic = VRT_BACKEND_PROBE_MAGIC,\n");
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_printf(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 {
vcc_ErrToken(tl, t_field);
vcc_ErrWhere(tl, t_field);
ErrInternal(tl);
return;
}
SkipToken(tl, ';');
}
if (t_threshold != NULL || t_window != NULL) {
if (t_threshold == NULL && t_window != NULL) {
VSB_printf(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_printf(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_printf(tl->sb, "Window must be 64 or less.\n");
vcc_ErrWhere(tl, t_window);
return;
}
if (threshold > window ) {
VSB_printf(tl->sb,
"Threshold can not 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, "}};\n");
SkipToken(tl, '}');
}
static void
vcc_ParseHostDef(struct vcc *tl, const struct token *t_be, const char *vgcname)
{
struct token *t_field;
struct token *t_val;
struct token *t_host = NULL;
struct token *t_port = NULL;
struct token *t_path = NULL;
struct token *t_hosthdr = NULL;
struct symbol *pb;
struct token *t_did = NULL;
struct fld_spec *fs;
struct inifin *ifp;
struct vsb *vsb;
char *p;
unsigned u;
double t;
fs = vcc_FldSpec(tl,
"?host",
"?port",
"?path",
"?host_header",
"?connect_timeout",
"?first_byte_timeout",
"?between_bytes_timeout",
"?probe",
"?max_connections",
"?proxy_header",
NULL);
SkipToken(tl, '{');
vsb = VSB_new_auto();
AN(vsb);
tl->fb = vsb;
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.vcl_name = \"%.*s", PF(t_be));
Fb(tl, 0, "\",\n");
/* Check for old syntax */
if (tl->t->tok == ID && vcc_IdIs(tl->t, "set")) {
VSB_printf(tl->sb,
"NB: Backend Syntax has changed:\n"
"Remove \"set\" and \"backend\" in front"
" of backend fields.\n" );
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " at ");
vcc_ErrWhere(tl, tl->t);
return;
}
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_printf(tl->sb,
"Unix socket backends only supported"
" in VCL4.1 and higher.\n");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " at ");
vcc_ErrWhere(tl, tl->t);
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, &t);
ERRCHK(tl);
Fb(tl, 0, "%g,\n", t);
SkipToken(tl, ';');
} else if (vcc_IdIs(t_field, "first_byte_timeout")) {
Fb(tl, 0, "\t.first_byte_timeout = ");
vcc_Duration(tl, &t);
ERRCHK(tl);
Fb(tl, 0, "%g,\n", t);
SkipToken(tl, ';');
} else if (vcc_IdIs(t_field, "between_bytes_timeout")) {
Fb(tl, 0, "\t.between_bytes_timeout = ");
vcc_Duration(tl, &t);
ERRCHK(tl);
Fb(tl, 0, "%g,\n", t);
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_printf(tl->sb,
".proxy_header must be 1 or 2\n");
vcc_ErrWhere(tl, t_val);
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);
ERRCHK(tl);
} else if (vcc_IdIs(t_field, "probe") && tl->t->tok == ID) {
if (vcc_IdIs(tl->t, "default")) {
vcc_NextToken(tl);
(void)vcc_default_probe(tl);
} else {
pb = VCC_SymbolGet(tl, SYM_PROBE,
"Probe not found", XREF_REF);
ERRCHK(tl);
AN(pb);
Fb(tl, 0, "\t.probe = %s,\n", pb->rname);
}
SkipToken(tl, ';');
} else if (vcc_IdIs(t_field, "probe")) {
VSB_printf(tl->sb,
"Expected '{' or name of probe, got ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " at\n");
vcc_ErrWhere(tl, tl->t);
return;
} else {
ErrInternal(tl);
return;
}
}
vcc_FieldsOk(tl, fs);
ERRCHK(tl);
if (t_host == NULL && t_path == NULL) {
VSB_printf(tl->sb, "Expected .host or .path.\n");
vcc_ErrWhere(tl, t_be);
return;
}
assert(t_host != NULL || t_path != NULL);
if (t_host != NULL)
/* Check that the hostname makes sense */
Emit_Sockaddr(tl, t_host, t_port);
else
/* Check that the path can be a legal UDS */
Emit_UDS_Path(tl, t_path, "Backend path");
ERRCHK(tl);
ExpectErr(tl, '}');
/* We have parsed it all, emit the ident string */
/* 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");
/* Close the struct */
Fb(tl, 0, "};\n");
vcc_NextToken(tl);
tl->fb = NULL;
AZ(VSB_finish(vsb));
Fh(tl, 0, "%s", VSB_data(vsb));
VSB_destroy(&vsb);
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);",
vgcname, vgcname);
VSB_printf(ifp->fin, "\t\tVRT_delete_backend(ctx, &%s);", vgcname);
}
void
vcc_Parse(struct vcc *tl)
{
struct toplev *tp;
struct token *tok;
AZ(tl->indent);
if (tl->t->tok != ID || !vcc_IdIs(tl->t, "vcl")) {
VSB_printf(tl->sb,
"VCL version declaration missing\n"
"Update your VCL to Version 4 syntax, and add\n"
"\tvcl 4.0;\n"
"on the first line of the VCL files.\n"
);
vcc_ErrWhere(tl, tl->t);
ERRCHK(tl);
}
tok = tl->t;
vcc_ParseVcl(tl);
if (tok->src->syntax != 4.0) {
VSB_printf(tl->sb, "VCL version %.1f not supported.\n",
tok->src->syntax);
vcc_ErrWhere2(tl, tok, tl->t);
ERRCHK(tl);
}
tl->syntax = tl->t->src->syntax;
ERRCHK(tl);
while (tl->t->tok != EOI) {
ERRCHK(tl);
switch (tl->t->tok) {
case CSRC:
if (tl->allow_inline_c) {
Fc(tl, 0, "%.*s\n",
(int) (tl->t->e - (tl->t->b + 4)),
tl->t->b + 2);
vcc_NextToken(tl);
} else {
VSB_printf(tl->sb,
"Inline-C not allowed\n");
vcc_ErrWhere(tl, tl->t);
}
break;
case EOI:
break;
case ID:
for (tp = toplev; tp->name != NULL; tp++) {
if (!vcc_IdIs(tl->t, tp->name))
continue;
tp->func(tl);
break;
}
if (tp->name != NULL)
break;
/* FALLTHROUGH */
default:
/* We deliberately do not mention inline-C */
VSB_printf(tl->sb, "Expected one of\n\t");
for (tp = toplev; tp->name != NULL; tp++) {
if (tp[1].name == NULL)
VSB_printf(tl->sb, " or ");
VSB_printf(tl->sb, "'%s'", tp->name);
if (tp[1].name != NULL)
VSB_printf(tl->sb, ", ");
}
VSB_printf(tl->sb, "\nFound: ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " at\n");
vcc_ErrWhere(tl, tl->t);
return;
}
}
AZ(tl->indent);
}
void
vcc_ParseImport(struct vcc *tl)
{
void *hdl;
char fn[1024], *fnp, *fnpx;
char buf[256];
struct token *mod, *t1;
struct inifin *ifp;
const char * const *spec;
struct symbol *sym;
struct symbol *msym;
const struct symbol *osym;
const char *p;
// int *modlen;
const struct vmod_data *vmd;
t1 = tl->t;
SkipToken(tl, ID); /* "import" */
ExpectErr(tl, ID);
mod = tl->t;
vcc_NextToken(tl);
osym = VCC_SymbolTok(tl, NULL, mod, SYM_NONE, 0);
if (osym != NULL && osym->kind != SYM_VMOD) {
VSB_printf(tl->sb, "Module %.*s conflicts with other symbol.\n",
PF(mod));
vcc_ErrWhere2(tl, t1, tl->t);
return;
}
if (osym != NULL) {
VSB_printf(tl->sb, "Module %.*s already imported.\n",
PF(mod));
vcc_ErrWhere2(tl, t1, tl->t);
VSB_printf(tl->sb, "Previous import was here:\n");
vcc_ErrWhere2(tl, osym->def_b, osym->def_e);
return;
}
bprintf(fn, "%.*s", PF(mod));
msym = VCC_Symbol(tl, NULL, fn, NULL, SYM_VMOD, 1);
ERRCHK(tl);
AN(msym);
msym->def_b = t1;
msym->def_e = tl->t;
if (tl->t->tok == ID) {
if (!vcc_IdIs(tl->t, "from")) {
VSB_printf(tl->sb, "Expected 'from path ...'\n");
vcc_ErrWhere(tl, tl->t);
return;
}
vcc_NextToken(tl);
if (!tl->unsafe_path && strchr(tl->t->dec, '/')) {
VSB_printf(tl->sb,
"'import ... from path ...' is unsafe.\nAt:");
vcc_ErrToken(tl, tl->t);
vcc_ErrWhere(tl, tl->t);
return;
}
ExpectErr(tl, CSTR);
p = strrchr(tl->t->dec, '/');
if (p != NULL && p[1] == '\0')
bprintf(fn, "%slibvmod_%.*s.so", tl->t->dec, PF(mod));
else
bprintf(fn, "%s", tl->t->dec);
vcc_NextToken(tl);
} else {
bprintf(fn, "libvmod_%.*s.so", PF(mod));
}
SkipToken(tl, ';');
if (VFIL_searchpath(tl->vmod_path,
vcc_path_dlopen, &hdl, fn, &fnpx)) {
VSB_printf(tl->sb, "Could not load VMOD %.*s\n", PF(mod));
VSB_printf(tl->sb, "\tFile name: %s\n",
fnpx != NULL ? fnpx : fn);
VSB_printf(tl->sb, "\tdlerror: %s\n", dlerror());
vcc_ErrWhere(tl, mod);
free(fnpx);
return;
}
AN(fnpx);
fnp = TlDup(tl, fnpx);
free(fnpx);
bprintf(buf, "Vmod_%.*s_Data", PF(mod));
vmd = dlsym(hdl, buf);
if (vmd == NULL) {
VSB_printf(tl->sb, "Malformed VMOD %.*s\n", PF(mod));
VSB_printf(tl->sb, "\tFile name: %s\n", fnp);
VSB_printf(tl->sb, "\t(no Vmod_Data symbol)\n");
vcc_ErrWhere(tl, mod);
return;
}
if (strcmp(VCS_Branch, "master") == 0 &&
strcmp(vmd->abi, VMOD_ABI_Version) != 0) {
VSB_printf(tl->sb, "Incompatible VMOD %.*s\n", PF(mod));
VSB_printf(tl->sb, "\tFile name: %s\n", fnp);
VSB_printf(tl->sb, "\tABI mismatch, expected <%s>, got <%s>\n",
VMOD_ABI_Version, vmd->abi);
vcc_ErrWhere(tl, mod);
return;
}
if (vmd->vrt_major != VRT_MAJOR_VERSION ||
vmd->vrt_minor > VRT_MINOR_VERSION) {
VSB_printf(tl->sb, "Incompatible VMOD %.*s\n", PF(mod));
VSB_printf(tl->sb, "\tFile name: %s\n", fnp);
VSB_printf(tl->sb, "\tVMOD version %u.%u\n",
vmd->vrt_major, vmd->vrt_minor);
VSB_printf(tl->sb, "\tvarnishd version %u.%u\n",
VRT_MAJOR_VERSION, VRT_MINOR_VERSION);
vcc_ErrWhere(tl, mod);
return;
}
if (vmd->name == NULL ||
vmd->func == NULL ||
vmd->func_len <= 0 ||
vmd->proto == NULL ||
vmd->abi == NULL) {
VSB_printf(tl->sb, "Mangled VMOD %.*s\n", PF(mod));
VSB_printf(tl->sb, "\tFile name: %s\n", fnp);
VSB_printf(tl->sb, "\tInconsistent metadata\n");
vcc_ErrWhere(tl, mod);
return;
}
if (!vcc_IdIs(mod, vmd->name)) {
VSB_printf(tl->sb, "Wrong VMOD file %.*s\n", PF(mod));
VSB_printf(tl->sb, "\tFile name: %s\n", fnp);
VSB_printf(tl->sb, "\tContains vmod \"%s\"\n", vmd->name);
vcc_ErrWhere(tl, mod);
return;
}
ifp = New_IniFin(tl);
VSB_printf(ifp->ini, "\tif (VRT_Vmod_Init(&VGC_vmod_%.*s,\n", PF(mod));
VSB_printf(ifp->ini, "\t &Vmod_%.*s_Func,\n", PF(mod));
VSB_printf(ifp->ini, "\t sizeof(Vmod_%.*s_Func),\n", PF(mod));
VSB_printf(ifp->ini, "\t \"%.*s\",\n", PF(mod));
VSB_printf(ifp->ini, "\t ");
VSB_quote(ifp->ini, fnp, -1, VSB_QUOTE_CSTR);
VSB_printf(ifp->ini, ",\n");
AN(vmd);
AN(vmd->file_id);
VSB_printf(ifp->ini, "\t \"%s\",\n", vmd->file_id);
VSB_printf(ifp->ini, "\t ctx))\n");
VSB_printf(ifp->ini, "\t\treturn(1);");
/* XXX: zero the function pointer structure ?*/
VSB_printf(ifp->fin, "\t\tVRT_priv_fini(&vmod_priv_%.*s);", PF(mod));
VSB_printf(ifp->fin, "\n\t\tVRT_Vmod_Fini(&VGC_vmod_%.*s);", PF(mod));
ifp = NULL;
spec = vmd->spec;
for (; *spec != NULL; spec++) {
p = *spec;
if (!strcmp(p, "$OBJ")) {
p += strlen(p) + 1;
sym = VCC_Symbol(tl, NULL, p, NULL, SYM_OBJECT, 1);
XXXAN(sym);
sym->extra = p;
sym->vmod = msym->name;
} else if (!strcmp(p, "$EVENT")) {
p += strlen(p) + 1;
if (ifp == NULL)
ifp = New_IniFin(tl);
VSB_printf(ifp->ini,
"\tif (%s(ctx, &vmod_priv_%.*s, VCL_EVENT_LOAD))\n"
"\t\treturn(1);",
p, PF(mod));
VSB_printf(ifp->fin,
"\t\t(void)%s(ctx, &vmod_priv_%.*s,\n"
"\t\t VCL_EVENT_DISCARD);\n", p, PF(mod));
VSB_printf(ifp->event, "\t%s(ctx, &vmod_priv_%.*s, ev)",
p, PF(mod));
} else if (!strcmp(p, "$FUNC")) {
p += strlen(p) + 1;
sym = VCC_Symbol(tl, NULL, p, NULL, SYM_FUNC, 1);
ERRCHK(tl);
AN(sym);
sym->vmod = msym->name;
sym->eval = vcc_Eval_SymFunc;
p += strlen(p) + 1;
sym->eval_priv = p;
sym->fmt = VCC_Type(p);
AN(sym->fmt);
} else {
VSB_printf(tl->sb, "Internal spec error (%s)\n", p);
vcc_ErrWhere(tl, mod);
return;
}
}
Fh(tl, 0, "\n/* --- BEGIN VMOD %.*s --- */\n\n", PF(mod));
Fh(tl, 0, "static struct vmod *VGC_vmod_%.*s;\n", PF(mod));
Fh(tl, 0, "static struct vmod_priv vmod_priv_%.*s;\n", PF(mod));
Fh(tl, 0, "\n%s\n", vmd->proto);
Fh(tl, 0, "\n/* --- END VMOD %.*s --- */\n\n", PF(mod));
}
void
vcc_ParseNew(struct vcc *tl)
{
struct symbol *sy1, *sy2, *sy3;
struct inifin *ifp;
const char *p, *s_obj;
char buf1[128];
char buf2[128];
vcc_NextToken(tl);
ExpectErr(tl, ID);
vcc_ExpectCid(tl, "VCL object");
ERRCHK(tl);
sy1 = VCC_HandleSymbol(tl, tl->t, INSTANCE, "XXX");
ERRCHK(tl);
/* We allow implicit use of VMOD objects: Pretend it's ref'ed */
sy1->nref++;
vcc_NextToken(tl);
ExpectErr(tl, '=');
vcc_NextToken(tl);
ExpectErr(tl, ID);
sy2 = VCC_SymbolTok(tl, NULL, tl->t, SYM_OBJECT, 0);
if (sy2 == NULL) {
VSB_printf(tl->sb, "Symbol not found: ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " at ");
vcc_ErrWhere(tl, tl->t);
return;
}
vcc_NextToken(tl);
p = sy2->extra;
s_obj = p;
p += strlen(p) + 1;
Fh(tl, 0, "static %s *vo_%s;\n\n", p, sy1->name);
p += strlen(p) + 1;
bprintf(buf1, ", &vo_%s, \"%s\"", sy1->name, sy1->name);
vcc_Eval_Func(tl, p, buf1, sy2);
ExpectErr(tl, ';');
while (p[0] != '\0' || p[1] != '\0' || p[2] != '\0')
p++;
p += 3;
ifp = New_IniFin(tl);
p += strlen(p) + 1;
VSB_printf(ifp->fin, "\t\t%s(&vo_%s);", p, sy1->name);
while (p[0] != '\0' || p[1] != '\0' || p[2] != '\0')
p++;
p += 3;
/* Instantiate symbols for the methods */
bprintf(buf1, ", vo_%s", sy1->name);
while (*p != '\0') {
p += strlen(s_obj);
bprintf(buf2, "%s%s", sy1->name, p);
sy3 = VCC_Symbol(tl, NULL, buf2, NULL, SYM_FUNC, 1);
AN(sy3);
sy3->eval = vcc_Eval_SymFunc;
p += strlen(p) + 1;
sy3->eval_priv = p;
sy3->fmt = VCC_Type(p);
sy3->extra = TlDup(tl, buf1);
while (p[0] != '\0' || p[1] != '\0' || p[2] != '\0')
p++;
p += 3;
}
sy1->def_e = tl->t;
}
void
vcc_ParseImport(struct vcc *tl)
{
void *hdl;
char fn[1024];
char buf[256];
struct token *mod, *t1;
const char *modname;
const char *proto;
const char *abi;
const char **spec;
struct symbol *sym;
const struct symbol *osym;
const char *p;
// int *modlen;
t1 = tl->t;
SkipToken(tl, ID); /* "import" */
ExpectErr(tl, ID);
mod = tl->t;
vcc_NextToken(tl);
osym = VCC_FindSymbol(tl, mod, SYM_NONE);
if (osym != NULL && osym->kind != SYM_VMOD) {
VSB_printf(tl->sb, "Module %.*s conflics with other symbol.\n",
PF(mod));
vcc_ErrWhere2(tl, t1, tl->t);
return;
}
if (osym != NULL) {
VSB_printf(tl->sb, "Module %.*s already imported.\n",
PF(mod));
vcc_ErrWhere2(tl, t1, tl->t);
VSB_printf(tl->sb, "Previous import was here:\n");
vcc_ErrWhere2(tl, osym->def_b, osym->def_e);
return;
}
bprintf(fn, "%.*s", PF(mod));
sym = VCC_AddSymbolStr(tl, fn, SYM_VMOD);
ERRCHK(tl);
AN(sym);
sym->def_b = t1;
sym->def_e = tl->t;
if (tl->t->tok == ID) {
if (!tl->unsafe_path) {
VSB_printf(tl->sb,
"'import ... from path...'"
" not allowed.\nAt:");
vcc_ErrToken(tl, tl->t);
vcc_ErrWhere(tl, tl->t);
return;
}
if (!vcc_IdIs(tl->t, "from")) {
VSB_printf(tl->sb, "Expected 'from path...'\n");
vcc_ErrWhere(tl, tl->t);
return;
}
vcc_NextToken(tl);
ExpectErr(tl, CSTR);
bprintf(fn, "%s", tl->t->dec);
vcc_NextToken(tl);
} else {
bprintf(fn, "%s/libvmod_%.*s.so", tl->vmod_dir, PF(mod));
}
Fh(tl, 0, "static void *VGC_vmod_%.*s;\n", PF(mod));
Fi(tl, 0, "\tif (VRT_Vmod_Init(&VGC_vmod_%.*s,\n", PF(mod));
Fi(tl, 0, "\t &Vmod_%.*s_Func,\n", PF(mod));
Fi(tl, 0, "\t sizeof(Vmod_%.*s_Func),\n", PF(mod));
Fi(tl, 0, "\t \"%.*s\",\n", PF(mod));
Fi(tl, 0, "\t ");
EncString(tl->fi, fn, NULL, 0);
Fi(tl, 0, ",\n\t ");
Fi(tl, 0, "cli))\n");
Fi(tl, 0, "\t\treturn(1);\n");
SkipToken(tl, ';');
hdl = dlopen(fn, RTLD_NOW | RTLD_LOCAL);
if (hdl == NULL) {
VSB_printf(tl->sb, "Could not load module %.*s\n\t%s\n\t%s\n",
PF(mod), fn, dlerror());
vcc_ErrWhere(tl, mod);
return;
}
bprintf(buf, "Vmod_%.*s_Name", PF(mod));
modname = dlsym(hdl, buf);
if (modname == NULL) {
VSB_printf(tl->sb, "Could not load module %.*s\n\t%s\n\t%s\n",
PF(mod), fn, "Symbol Vmod_Name not found");
vcc_ErrWhere(tl, mod);
return;
}
if (!vcc_IdIs(mod, modname)) {
VSB_printf(tl->sb, "Could not load module %.*s\n\t%s\n",
PF(mod), fn);
VSB_printf(tl->sb, "\tModule has wrong name: <%s>\n", modname);
vcc_ErrWhere(tl, mod);
return;
}
bprintf(buf, "Vmod_%.*s_ABI", PF(mod));
abi = dlsym(hdl, buf);
if (abi == NULL || strcmp(abi, VMOD_ABI_Version) != 0) {
VSB_printf(tl->sb, "Could not load module %.*s\n\t%s\n",
PF(mod), fn);
VSB_printf(tl->sb, "\tABI mismatch, expected <%s>, got <%s>\n",
VMOD_ABI_Version, abi);
vcc_ErrWhere(tl, mod);
return;
}
bprintf(buf, "Vmod_%.*s_Proto", PF(mod));
proto = dlsym(hdl, buf);
if (proto == NULL) {
VSB_printf(tl->sb, "Could not load module %.*s\n\t%s\n\t%s\n",
PF(mod), fn, "Symbol Vmod_Proto not found");
vcc_ErrWhere(tl, mod);
return;
}
bprintf(buf, "Vmod_%.*s_Spec", PF(mod));
spec = dlsym(hdl, buf);
if (spec == NULL) {
VSB_printf(tl->sb, "Could not load module %.*s\n\t%s\n\t%s\n",
PF(mod), fn, "Symbol Vmod_Spec not found");
vcc_ErrWhere(tl, mod);
return;
}
Fh(tl, 0, "static struct vmod_priv vmod_priv_%.*s;\n", PF(mod));
for (; *spec != NULL; spec++) {
p = *spec;
if (!strcmp(p, "OBJ")) {
p += strlen(p) + 1;
sym = VCC_AddSymbolStr(tl, p, SYM_OBJECT);
XXXAN(sym);
sym->args = p;
} else if (!strcmp(p, "INIT")) {
p += strlen(p) + 1;
Fi(tl, 0, "\t%s(&vmod_priv_%.*s, &VCL_conf);\n",
p, PF(mod));
} else {
sym = VCC_AddSymbolStr(tl, p, SYM_FUNC);
ERRCHK(tl);
AN(sym);
sym->eval = vcc_Eval_SymFunc;
p += strlen(p) + 1;
sym->cfunc = p;
p += strlen(p) + 1;
sym->args = p;
/* Functions which return VOID are procedures */
if (!memcmp(p, "VOID\0", 5))
sym->kind = SYM_PROC;
}
}
Fh(tl, 0, "\n%s\n", proto);
/* XXX: zero the function pointer structure ?*/
Ff(tl, 0, "\tvmod_priv_fini(&vmod_priv_%.*s);\n", PF(mod));
Ff(tl, 0, "\tVRT_Vmod_Fini(&VGC_vmod_%.*s);\n", PF(mod));
}
static void
vcc_ParseHostDef(struct vcc *tl, const struct token *t_be, const char *vgcname)
{
struct token *t_field;
struct token *t_val;
struct token *t_host = NULL;
struct token *t_port = NULL;
struct token *t_hosthdr = NULL;
struct fld_spec *fs;
struct inifin *ifp;
struct vsb *vsb;
char *p;
unsigned u;
double t;
fs = vcc_FldSpec(tl,
"!host",
"?port",
"?host_header",
"?connect_timeout",
"?first_byte_timeout",
"?between_bytes_timeout",
"?probe",
"?max_connections",
"?proxy_header",
NULL);
SkipToken(tl, '{');
vsb = VSB_new_auto();
AN(vsb);
tl->fb = vsb;
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.vcl_name = \"%.*s", PF(t_be));
Fb(tl, 0, "\",\n");
/* Check for old syntax */
if (tl->t->tok == ID && vcc_IdIs(tl->t, "set")) {
VSB_printf(tl->sb,
"NB: Backend Syntax has changed:\n"
"Remove \"set\" and \"backend\" in front"
" of backend fields.\n" );
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " at ");
vcc_ErrWhere(tl, tl->t);
return;
}
while (tl->t->tok != '}') {
vcc_IsField(tl, &t_field, fs);
ERRCHK(tl);
if (vcc_IdIs(t_field, "host")) {
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, "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, &t);
ERRCHK(tl);
Fb(tl, 0, "%g,\n", t);
SkipToken(tl, ';');
} else if (vcc_IdIs(t_field, "first_byte_timeout")) {
Fb(tl, 0, "\t.first_byte_timeout = ");
vcc_Duration(tl, &t);
ERRCHK(tl);
Fb(tl, 0, "%g,\n", t);
SkipToken(tl, ';');
} else if (vcc_IdIs(t_field, "between_bytes_timeout")) {
Fb(tl, 0, "\t.between_bytes_timeout = ");
vcc_Duration(tl, &t);
ERRCHK(tl);
Fb(tl, 0, "%g,\n", t);
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_printf(tl->sb,
".proxy_header must be 1 or 2\n");
vcc_ErrWhere(tl, t_val);
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);
ERRCHK(tl);
} else if (vcc_IdIs(t_field, "probe") && tl->t->tok == ID) {
if (VCC_FindSymbol(tl, tl->t, SYM_PROBE) == NULL) {
VSB_printf(tl->sb, "Probe %.*s not found\n",
PF(tl->t));
vcc_ErrWhere(tl, tl->t);
return;
}
Fb(tl, 0, "\t.probe = &vgc_probe_%.*s,\n", PF(tl->t));
vcc_AddRef(tl, tl->t, SYM_PROBE);
vcc_NextToken(tl);
SkipToken(tl, ';');
} else if (vcc_IdIs(t_field, "probe")) {
VSB_printf(tl->sb,
"Expected '{' or name of probe, got ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " at\n");
vcc_ErrWhere(tl, tl->t);
return;
} else {
ErrInternal(tl);
return;
}
}
vcc_FieldsOk(tl, fs);
ERRCHK(tl);
/* Check that the hostname makes sense */
assert(t_host != NULL);
Emit_Sockaddr(tl, t_host, t_port);
ERRCHK(tl);
ExpectErr(tl, '}');
/* We have parsed it all, emit the ident string */
/* Emit the hosthdr field, fall back to .host if not specified */
Fb(tl, 0, "\t.hosthdr = ");
if (t_hosthdr != NULL)
EncToken(tl->fb, t_hosthdr);
else
EncToken(tl->fb, t_host);
Fb(tl, 0, ",\n");
/* Close the struct */
Fb(tl, 0, "};\n");
vcc_NextToken(tl);
tl->fb = NULL;
AZ(VSB_finish(vsb));
Fh(tl, 0, "%s", VSB_data(vsb));
VSB_destroy(&vsb);
ifp = New_IniFin(tl);
VSB_printf(ifp->ini,
"\t%s =\n\t VRT_new_backend(ctx, &vgc_dir_priv_%s);",
vgcname, vgcname);
}
static void
parse_new(struct vcc *tl)
{
struct symbol *sy1, *sy2, *sy3;
struct inifin *ifp;
const char *p, *s_obj, *s_init, *s_struct, *s_fini;
char buf1[128];
char buf2[128];
vcc_NextToken(tl);
ExpectErr(tl, ID);
if (!vcc_isCid(tl->t)) {
VSB_printf(tl->sb,
"Names of VCL objects cannot contain '-'\n");
vcc_ErrWhere(tl, tl->t);
return;
}
sy1 = VCC_FindSymbol(tl, tl->t, SYM_NONE);
if (sy1 != NULL) {
VSB_printf(tl->sb, "Object name '%.*s' already used.\n",
PF(tl->t));
VSB_printf(tl->sb, "First usage:\n");
AN(sy1->def_b);
if (sy1->def_e != NULL)
vcc_ErrWhere2(tl, sy1->def_b, sy1->def_e);
else
vcc_ErrWhere(tl, sy1->def_b);
VSB_printf(tl->sb, "Redefinition:\n");
vcc_ErrWhere(tl, tl->t);
return;
}
sy1 = VCC_AddSymbolTok(tl, tl->t, SYM_NONE); // XXX: NONE ?
XXXAN(sy1);
sy1->def_b = tl->t;
vcc_NextToken(tl);
ExpectErr(tl, '=');
vcc_NextToken(tl);
ExpectErr(tl, ID);
sy2 = VCC_FindSymbol(tl, tl->t, SYM_OBJECT);
if (sy2 == NULL) {
VSB_printf(tl->sb, "Symbol not found: ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, " at ");
vcc_ErrWhere(tl, tl->t);
return;
}
XXXAN(sy2);
/*lint -save -e448 */
/* Split the first three args */
p = sy2->args;
s_obj = p;
p += strlen(p) + 1;
s_init = p;
while (p[0] != '\0' || p[1] != '\0')
p++;
p += 2;
s_struct = p;
p += strlen(p) + 1;
s_fini = p + strlen(p) + 1;
while (p[0] != '\0' || p[1] != '\0')
p++;
p += 2;
Fh(tl, 0, "static %s *vo_%s;\n\n", s_struct, sy1->name);
vcc_NextToken(tl);
bprintf(buf1, ", &vo_%s, \"%s\"", sy1->name, sy1->name);
vcc_Eval_Func(tl, s_init, buf1, "ASDF", s_init + strlen(s_init) + 1);
ifp = New_IniFin(tl);
VSB_printf(ifp->fin, "\t%s(&vo_%s);", s_fini, sy1->name);
ExpectErr(tl, ';');
bprintf(buf1, ", vo_%s", sy1->name);
/* Split the methods from the args */
while (*p != '\0') {
p += strlen(s_obj);
bprintf(buf2, "%s%s", sy1->name, p);
sy3 = VCC_AddSymbolStr(tl, buf2, SYM_FUNC);
AN(sy3);
sy3->eval = vcc_Eval_SymFunc;
p += strlen(p) + 1;
sy3->cfunc = p;
p += strlen(p) + 1;
/* Functions which return VOID are procedures */
if (!memcmp(p, "VOID\0", 5))
sy3->kind = SYM_PROC;
sy3->args = p;
sy3->extra = TlDup(tl, buf1);
while (p[0] != '\0' || p[1] != '\0') {
if (!memcmp(p, "ENUM\0", 5)) {
/* XXX: Special case for ENUM that has
it's own \0\0 end marker. Not exactly
elegant, we should consider
alternatives here. Maybe runlength
encode the entire block? */
p += strlen(p) + 1;
while (p[0] != '\0' || p[1] != '\0')
p++;
}
p++;
}
p += 2;
}
sy1->def_e = tl->t;
/*lint -restore */
}