//lint -e{818}
void
vtc_log(struct vtclog *vl, int lvl, const char *fmt, ...)
{
double tx;
CHECK_OBJ_NOTNULL(vl, VTCLOG_MAGIC);
tx = VTIM_mono() - t0;
AZ(pthread_mutex_lock(&vl->mtx));
vl->act = 1;
assert(lvl < (int)NLEAD);
VSB_clear(vl->vsb);
VSB_printf(vl->vsb, "%s %-4s %4.1f ",
lead[lvl < 0 ? 1: lvl], vl->id, tx);
va_list ap;
va_start(ap, fmt);
(void)VSB_vprintf(vl->vsb, fmt, ap);
va_end(ap);
VSB_putc(vl->vsb, '\n');
AZ(VSB_finish(vl->vsb));
vtc_log_emit(vl, lvl);
VSB_clear(vl->vsb);
vl->act = 0;
AZ(pthread_mutex_unlock(&vl->mtx));
if (lvl > 0)
return;
if (lvl == 0)
vtc_error = 1;
if (pthread_self() != vtc_thread)
pthread_exit(NULL);
}
static void
vsmw_delseg(struct vsmw *vsmw, struct vsmwseg *seg, int fixidx)
{
char *t = NULL;
ssize_t s;
int fd;
CHECK_OBJ_NOTNULL(vsmw, VSMW_MAGIC);
CHECK_OBJ_NOTNULL(seg, VSMWSEG_MAGIC);
VTAILQ_REMOVE(&vsmw->segs, seg, list);
REPLACE(seg->class, NULL);
REPLACE(seg->id, NULL);
FREE_OBJ(seg);
if (fixidx) {
vsmw_mkent(vsmw, vsmw->idx);
REPLACE(t, VSB_data(vsmw->vsb));
AN(t);
fd = openat(vsmw->vdirfd,
t, O_WRONLY|O_CREAT|O_EXCL, vsmw->mode);
assert(fd >= 0);
vsmw_idx_head(vsmw, fd);
VSB_clear(vsmw->vsb);
VTAILQ_FOREACH(seg, &vsmw->segs, list)
vsmw_fmt_index(vsmw, seg);
AZ(VSB_finish(vsmw->vsb));
s = write(fd, VSB_data(vsmw->vsb), VSB_len(vsmw->vsb));
assert(s == VSB_len(vsmw->vsb));
AZ(close(fd));
AZ(renameat(vsmw->vdirfd, t, vsmw->vdirfd, vsmw->idx));
REPLACE(t, NULL);
}
}
struct vsb *
vtc_hex_to_bin(struct vtclog *vl, const char *arg)
{
struct vsb *vsb;
unsigned sh = 4;
unsigned c, b = 0;
vsb = VSB_new_auto();
AN(vsb);
for (; *arg != '\0'; arg++) {
if (vct_issp(*arg) || *arg == '\n')
continue;
c = (uint8_t)*arg;
if (c >= '0' && c <= '9')
b |= (c - 48U) << sh;
else if (c >= 'A' && c <= 'F')
b |= (c - 55U) << sh;
else if (c >= 'a' && c <= 'f')
b |= (c - 87U) << sh;
else
vtc_fatal(vl,"Illegal hex string");
sh = 4 - sh;
if (sh == 4) {
VSB_putc(vsb, b);
b = 0;
}
}
if (sh != 4)
VSB_putc(vsb, b);
AZ(VSB_finish(vsb));
return (vsb);
}
struct vsb *
VEP_Finish(struct busyobj *bo)
{
struct vep_state *vep;
ssize_t l, lcb;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
vep = bo->vep;
CHECK_OBJ_NOTNULL(vep, VEP_MAGIC);
assert(vep->bo == bo);
if (vep->o_pending)
vep_mark_common(vep, vep->ver_p, vep->last_mark);
if (vep->o_wait > 0) {
lcb = vep->cb(vep->bo, 0, VGZ_ALIGN);
vep_emit_common(vep, lcb - vep->o_last, vep->last_mark);
}
(void)vep->cb(vep->bo, 0, VGZ_FINISH);
bo->vep = NULL;
AZ(VSB_finish(vep->vsb));
l = VSB_len(vep->vsb);
if (vep->esi_found && l > 0)
return (vep->vsb);
VSB_delete(vep->vsb);
return (NULL);
}
static struct expr *
vcc_expr_edit(enum var_type fmt, const char *p, struct expr *e1,
struct expr *e2)
{
struct expr *e;
int nl = 1;
e = vcc_new_expr();
while (*p != '\0') {
if (*p == '\n') {
if (!nl)
VSB_putc(e->vsb, *p);
nl = 1;
p++;
continue;
}
nl = 0;
if (*p != '\v') {
VSB_putc(e->vsb, *p);
p++;
continue;
}
assert(*p == '\v');
p++;
switch(*p) {
case '+': VSB_cat(e->vsb, "\v+"); break;
case '-': VSB_cat(e->vsb, "\v-"); break;
case '1':
case '2':
if (*p == '1')
VSB_cat(e->vsb, VSB_data(e1->vsb));
else {
AN(e2);
VSB_cat(e->vsb, VSB_data(e2->vsb));
}
break;
default:
assert(__LINE__ == 0);
}
p++;
}
AZ(VSB_finish(e->vsb));
if (e1 != NULL)
e->t1 = e1->t1;
else if (e2 != NULL)
e->t1 = e2->t1;
if (e2 != NULL)
e->t2 = e2->t1;
else if (e1 != NULL)
e->t1 = e1->t1;
if ((e1 == NULL || e1->constant) && (e2 == NULL || e2->constant))
e->constant = 1;
vcc_delete_expr(e1);
vcc_delete_expr(e2);
e->fmt = fmt;
return (e);
}
int
vtc_send_proxy(int fd, int version, const struct suckaddr *sac,
const struct suckaddr *sas)
{
struct vsb *vsb;
char hc[VTCP_ADDRBUFSIZE];
char pc[VTCP_PORTBUFSIZE];
char hs[VTCP_ADDRBUFSIZE];
char ps[VTCP_PORTBUFSIZE];
int i, len;
int proto;
AN(sac);
AN(sas);
assert(version == 1 || version == 2);
vsb = VSB_new_auto();
AN(vsb);
proto = VSA_Get_Proto(sas);
assert(proto == PF_INET6 || proto == PF_INET);
if (version == 1) {
VSB_bcat(vsb, vpx1_sig, sizeof(vpx1_sig));
if (proto == PF_INET6)
VSB_printf(vsb, " TCP6 ");
else if (proto == PF_INET)
VSB_printf(vsb, " TCP4 ");
VTCP_name(sac, hc, sizeof(hc), pc, sizeof(pc));
VTCP_name(sas, hs, sizeof(hs), ps, sizeof(ps));
VSB_printf(vsb, "%s %s %s %s\r\n", hc, hs, pc, ps);
} else if (version == 2) {
VSB_bcat(vsb, vpx2_sig, sizeof(vpx2_sig));
VSB_putc(vsb, 0x21);
if (proto == PF_INET6) {
VSB_putc(vsb, 0x21);
VSB_putc(vsb, 0x00);
VSB_putc(vsb, 0x24);
} else if (proto == PF_INET) {
VSB_putc(vsb, 0x11);
VSB_putc(vsb, 0x00);
VSB_putc(vsb, 0x0c);
}
vpx_enc_addr(vsb, proto, sac);
vpx_enc_addr(vsb, proto, sas);
vpx_enc_port(vsb, sac);
vpx_enc_port(vsb, sas);
} else
WRONG("Wrong proxy version");
AZ(VSB_finish(vsb));
len = VSB_len(vsb);
i = write(fd, VSB_data(vsb), len);
VSB_delete(vsb);
return (i != len);
}
static void
h_order_finish(struct vlog_priv_t *vlog, int fd)
{
assert(VSB_finish(vlog->ob[fd]) == 0);
if (VSB_len(vlog->ob[fd]) > 1 && VSL_Matched(vlog->vd, vlog->bitmap[fd])) {
VSB_printf(vlog->answer,"%s", VSB_data(vlog->ob[fd]));
}
vlog->bitmap[fd] = 0;
VSB_clear(vlog->ob[fd]);
}
//lint -e{818}
void
vtc_hexdump(struct vtclog *vl, int lvl, const char *pfx,
const unsigned char *str, int len)
{
int nl = 1;
unsigned l;
double tx;
CHECK_OBJ_NOTNULL(vl, VTCLOG_MAGIC);
tx = VTIM_mono() - t0;
assert(len >= 0);
assert(lvl >= 0);
assert(lvl < NLEAD);
AZ(pthread_mutex_lock(&vl->mtx));
vl->act = 1;
VSB_clear(vl->vsb);
if (pfx == NULL)
pfx = "";
if (str == NULL)
VSB_printf(vl->vsb, "%s %-4s %4.1f %s| (null)",
lead[lvl], vl->id, tx, pfx);
else {
for (l = 0; l < len; l++, str++) {
if (l > 512) {
VSB_printf(vl->vsb, "...");
break;
}
if (nl) {
VSB_printf(vl->vsb, "%s %-4s %4.1f %s| ",
lead[lvl], vl->id, tx, pfx);
nl = 0;
}
VSB_printf(vl->vsb, " %02x", *str);
if ((l & 0xf) == 0xf) {
VSB_printf(vl->vsb, "\n");
nl = 1;
}
}
}
if (!nl)
VSB_printf(vl->vsb, "\n");
AZ(VSB_finish(vl->vsb));
vtc_log_emit(vl, lvl);
VSB_clear(vl->vsb);
vl->act = 0;
AZ(pthread_mutex_unlock(&vl->mtx));
if (lvl == 0) {
vtc_error = 1;
if (pthread_self() != vtc_thread)
pthread_exit(NULL);
}
}
static void
http_write(const struct http *hp, int lvl, const char *pfx)
{
int l;
AZ(VSB_finish(hp->vsb));
vtc_dump(hp->vl, lvl, pfx, VSB_data(hp->vsb), VSB_len(hp->vsb));
l = write(hp->fd, VSB_data(hp->vsb), VSB_len(hp->vsb));
if (l != VSB_len(hp->vsb))
vtc_log(hp->vl, hp->fatal, "Write failed: (%d vs %d) %s",
l, VSB_len(hp->vsb), strerror(errno));
}
static void
varnish_vclbackend(struct varnish *v, const char *vcl)
{
struct vsb *vsb, *vsb2;
enum VCLI_status_e u;
if (v->cli_fd < 0)
varnish_launch(v);
if (vtc_error)
return;
vsb = VSB_new_auto();
AN(vsb);
vsb2 = VSB_new_auto();
AN(vsb2);
cmd_server_genvcl(vsb2);
AZ(VSB_finish(vsb2));
VSB_printf(vsb, "vcl.inline vcl%d << %s\n%s\n%s\n%s\n",
++v->vcl_nbr, NONSENSE, VSB_data(vsb2), vcl, NONSENSE);
AZ(VSB_finish(vsb));
u = varnish_ask_cli(v, VSB_data(vsb), NULL);
if (u != CLIS_OK) {
VSB_delete(vsb);
VSB_delete(vsb2);
vtc_log(v->vl, 0, "FAIL VCL does not compile");
return;
}
VSB_clear(vsb);
VSB_printf(vsb, "vcl.use vcl%d", v->vcl_nbr);
AZ(VSB_finish(vsb));
u = varnish_ask_cli(v, VSB_data(vsb), NULL);
assert(u == CLIS_OK);
VSB_delete(vsb);
VSB_delete(vsb2);
}
static struct expr *
vcc_mk_expr(enum var_type fmt, const char *str, ...)
{
va_list ap;
struct expr *e;
e = vcc_new_expr();
e->fmt = fmt;
va_start(ap, str);
VSB_vprintf(e->vsb, str, ap);
va_end(ap);
AZ(VSB_finish(e->vsb));
return (e);
}
static void
mcf_askchild(struct cli *cli, const char * const *av, void *priv)
{
int i;
char *q;
unsigned u;
struct vsb *vsb;
(void)priv;
/*
* Command not recognized in master, try cacher if it is
* running.
*/
if (cli_o <= 0) {
if (!strcmp(av[1], "help")) {
if (av[2] == NULL || strcmp(av[2], "-j"))
VCLI_Out(cli,
"No help from child, (not running).\n");
return;
}
VCLI_SetResult(cli, CLIS_UNKNOWN);
VCLI_Out(cli,
"Unknown request in manager process "
"(child not running).\n"
"Type 'help' for more info.");
return;
}
vsb = VSB_new_auto();
for (i = 1; av[i] != NULL; i++) {
VSB_quote(vsb, av[i], strlen(av[i]), 0);
VSB_putc(vsb, ' ');
}
VSB_putc(vsb, '\n');
AZ(VSB_finish(vsb));
i = write(cli_o, VSB_data(vsb), VSB_len(vsb));
if (i != VSB_len(vsb)) {
VSB_destroy(&vsb);
VCLI_SetResult(cli, CLIS_COMMS);
VCLI_Out(cli, "CLI communication error");
MGT_Child_Cli_Fail();
return;
}
VSB_destroy(&vsb);
if (VCLI_ReadResult(cli_i, &u, &q, mgt_param.cli_timeout))
MGT_Child_Cli_Fail();
VCLI_SetResult(cli, u);
VCLI_Out(cli, "%s", q);
free(q);
}
static void
varnish_vcl(struct varnish *v, const char *vcl, enum VCLI_status_e expect)
{
struct vsb *vsb;
enum VCLI_status_e u;
if (v->cli_fd < 0)
varnish_launch(v);
if (vtc_error)
return;
vsb = VSB_new_auto();
AN(vsb);
VSB_printf(vsb, "vcl.inline vcl%d << %s\n%s\n%s\n",
++v->vcl_nbr, NONSENSE, vcl, NONSENSE);
AZ(VSB_finish(vsb));
u = varnish_ask_cli(v, VSB_data(vsb), NULL);
if (u != expect) {
VSB_delete(vsb);
vtc_log(v->vl, 0,
"VCL compilation got %u expected %u",
u, expect);
return;
}
if (u == CLIS_OK) {
VSB_clear(vsb);
VSB_printf(vsb, "vcl.use vcl%d", v->vcl_nbr);
AZ(VSB_finish(vsb));
u = varnish_ask_cli(v, VSB_data(vsb), NULL);
assert(u == CLIS_OK);
} else {
vtc_log(v->vl, 2, "VCL compilation failed (as expected)");
}
VSB_delete(vsb);
}
run_vcc(void *priv)
{
struct vsb *csrc;
struct vsb *sb = NULL;
struct vcc_priv *vp;
int fd, i, l;
struct vcc *vcc;
struct stevedore *stv;
VJ_subproc(JAIL_SUBPROC_VCC);
CAST_OBJ_NOTNULL(vp, priv, VCC_PRIV_MAGIC);
AZ(chdir(vp->dir));
vcc = VCC_New();
AN(vcc);
VCC_Builtin_VCL(vcc, builtin_vcl);
VCC_VCL_path(vcc, mgt_vcl_path);
VCC_VMOD_path(vcc, mgt_vmod_path);
VCC_Err_Unref(vcc, mgt_vcc_err_unref);
VCC_Allow_InlineC(vcc, mgt_vcc_allow_inline_c);
VCC_Unsafe_Path(vcc, mgt_vcc_unsafe_path);
STV_Foreach(stv)
VCC_Predef(vcc, "VCL_STEVEDORE", stv->ident);
mgt_vcl_export_labels(vcc);
csrc = VCC_Compile(vcc, &sb, vp->vclsrc, vp->vclsrcfile);
AZ(VSB_finish(sb));
if (VSB_len(sb))
printf("%s", VSB_data(sb));
VSB_destroy(&sb);
if (csrc == NULL)
exit(2);
fd = open(VGC_SRC, O_WRONLY|O_TRUNC|O_CREAT, 0600);
if (fd < 0) {
fprintf(stderr, "VCC cannot open %s", vp->csrcfile);
exit(2);
}
l = VSB_len(csrc);
i = write(fd, VSB_data(csrc), l);
if (i != l) {
fprintf(stderr, "VCC cannot write %s", vp->csrcfile);
exit(2);
}
closefd(&fd);
VSB_destroy(&csrc);
exit(0);
}
void
mgt_cli_telnet(const char *T_arg)
{
struct vss_addr **ta;
int i, n, sock, good;
struct telnet *tn;
char *p;
struct vsb *vsb;
char abuf[VTCP_ADDRBUFSIZE];
char pbuf[VTCP_PORTBUFSIZE];
n = VSS_resolve(T_arg, NULL, &ta);
if (n == 0) {
REPORT(LOG_ERR, "-T %s Could not be resolved\n", T_arg);
exit(2);
}
good = 0;
vsb = VSB_new_auto();
XXXAN(vsb);
for (i = 0; i < n; ++i) {
sock = VSS_listen(ta[i], 10);
if (sock < 0)
continue;
VTCP_myname(sock, abuf, sizeof abuf, pbuf, sizeof pbuf);
VSB_printf(vsb, "%s %s\n", abuf, pbuf);
good++;
tn = telnet_new(sock);
tn->ev = vev_new();
XXXAN(tn->ev);
tn->ev->fd = sock;
tn->ev->fd_flags = POLLIN;
tn->ev->callback = telnet_accept;
AZ(vev_add(mgt_evb, tn->ev));
free(ta[i]);
ta[i] = NULL;
}
free(ta);
if (good == 0) {
REPORT(LOG_ERR, "-T %s could not be listened on.", T_arg);
exit(2);
}
AZ(VSB_finish(vsb));
/* Save in shmem */
p = VSM_Alloc(VSB_len(vsb) + 1, "Arg", "-T", "");
AN(p);
strcpy(p, VSB_data(vsb));
VSB_delete(vsb);
}
static struct vsb *
sock_id(const char *pfx, int fd)
{
struct vsb *vsb;
char abuf1[VTCP_ADDRBUFSIZE], abuf2[VTCP_ADDRBUFSIZE];
char pbuf1[VTCP_PORTBUFSIZE], pbuf2[VTCP_PORTBUFSIZE];
vsb = VSB_new_auto();
AN(vsb);
VTCP_myname(fd, abuf1, sizeof abuf1, pbuf1, sizeof pbuf1);
VTCP_hisname(fd, abuf2, sizeof abuf2, pbuf2, sizeof pbuf2);
VSB_printf(vsb, "%s %s %s %s %s", pfx, abuf2, pbuf2, abuf1, pbuf1);
AZ(VSB_finish(vsb));
return (vsb);
}
static void
vsmw_addseg(struct vsmw *vsmw, struct vsmwseg *seg)
{
int fd;
ssize_t s;
VTAILQ_INSERT_TAIL(&vsmw->segs, seg, list);
fd = openat(vsmw->vdirfd, vsmw->idx, O_APPEND | O_WRONLY);
assert(fd >= 0);
VSB_clear(vsmw->vsb);
vsmw_fmt_index(vsmw, seg);
AZ(VSB_finish(vsmw->vsb));
s = write(fd, VSB_data(vsmw->vsb), VSB_len(vsmw->vsb));
assert(s == VSB_len(vsmw->vsb));
AZ(close(fd));
}
run_cc(void *priv)
{
struct vcc_priv *vp;
struct vsb *sb;
int pct;
char *p;
VJ_subproc(JAIL_SUBPROC_CC);
CAST_OBJ_NOTNULL(vp, priv, VCC_PRIV_MAGIC);
AZ(chdir(vp->dir));
sb = VSB_new_auto();
AN(sb);
for (p = mgt_cc_cmd, pct = 0; *p; ++p) {
if (pct) {
switch (*p) {
case 's':
VSB_cat(sb, VGC_SRC);
break;
case 'o':
VSB_cat(sb, VGC_LIB);
break;
case '%':
VSB_putc(sb, '%');
break;
default:
VSB_putc(sb, '%');
VSB_putc(sb, *p);
break;
}
pct = 0;
} else if (*p == '%') {
pct = 1;
} else {
VSB_putc(sb, *p);
}
}
if (pct)
VSB_putc(sb, '%');
AZ(VSB_finish(sb));
(void)umask(027);
(void)execl("/bin/sh", "/bin/sh", "-c", VSB_data(sb), (char*)0);
VSB_destroy(&sb); // For flexelint
}
static void
clean_order(struct vlog_priv_t *vlog)
{
unsigned u;
for (u = 0; u < 65536; u++) {
if (vlog->ob[u] == NULL)
continue;
assert(VSB_finish(vlog->ob[u]) == 0);
if (VSB_len(vlog->ob[u]) > 1 && VSL_Matched(vlog->vd, vlog->bitmap[u])) {
VSB_printf(vlog->answer,"%s\n", VSB_data(vlog->ob[u]));
}
vlog->flg[u] = 0;
vlog->bitmap[u] = 0;
VSB_clear(vlog->ob[u]);
}
}
int
mgt_cli_askchild(unsigned *status, char **resp, const char *fmt, ...)
{
int i, j;
va_list ap;
unsigned u;
if (cli_buf == NULL) {
cli_buf = VSB_new_auto();
AN(cli_buf);
} else {
VSB_clear(cli_buf);
}
if (resp != NULL)
*resp = NULL;
if (status != NULL)
*status = 0;
if (cli_i < 0 || cli_o < 0) {
if (status != NULL)
*status = CLIS_CANT;
return (CLIS_CANT);
}
va_start(ap, fmt);
AZ(VSB_vprintf(cli_buf, fmt, ap));
va_end(ap);
AZ(VSB_finish(cli_buf));
i = VSB_len(cli_buf);
assert(i > 0 && VSB_data(cli_buf)[i - 1] == '\n');
j = write(cli_o, VSB_data(cli_buf), i);
if (j != i) {
if (status != NULL)
*status = CLIS_COMMS;
if (resp != NULL)
*resp = strdup("CLI communication error");
MCH_Cli_Fail();
return (CLIS_COMMS);
}
if (VCLI_ReadResult(cli_i, &u, resp, mgt_param.cli_timeout))
MCH_Cli_Fail();
if (status != NULL)
*status = u;
return (u == CLIS_OK ? 0 : u);
}
int
vsl_diag(struct VSL_data *vsl, const char *fmt, ...)
{
va_list ap;
CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
AN(fmt);
if (vsl->diag == NULL)
vsl->diag = VSB_new_auto();
AN(vsl->diag);
VSB_clear(vsl->diag);
va_start(ap, fmt);
VSB_vprintf(vsl->diag, fmt, ap);
va_end(ap);
AZ(VSB_finish(vsl->diag));
return (-1);
}
static void
mgt_panic_record(pid_t r)
{
char time_str[30];
if (child_panic != NULL)
VSB_delete(child_panic);
child_panic = VSB_new_auto();
AN(child_panic);
VTIM_format(VTIM_real(), time_str);
VSB_printf(child_panic, "Last panic at: %s\n", time_str);
VSB_quote(child_panic, heritage.panic_str,
strnlen(heritage.panic_str, heritage.panic_str_len),
VSB_QUOTE_NONL);
AZ(VSB_finish(child_panic));
MGT_complain(C_ERR, "Child (%jd) %s",
(intmax_t)r, VSB_data(child_panic));
}
static void
cmd_err_shell(CMD_ARGS)
{
(void)priv;
(void)cmd;
struct vsb *vsb;
FILE *fp;
int r, c;
if (av == NULL)
return;
AN(av[1]);
AN(av[2]);
AZ(av[3]);
vsb = VSB_new_auto();
AN(vsb);
vtc_dump(vl, 4, "cmd", av[2], -1);
fp = popen(av[2], "r");
if (fp == NULL)
vtc_log(vl, 0, "popen fails: %s", strerror(errno));
do {
c = getc(fp);
if (c != EOF)
VSB_putc(vsb, c);
} while (c != EOF);
r = pclose(fp);
vtc_log(vl, 4, "Status = %d", WEXITSTATUS(r));
if (WIFSIGNALED(r))
vtc_log(vl, 4, "Signal = %d", WTERMSIG(r));
if (WEXITSTATUS(r) == 0) {
vtc_log(vl, 0,
"expected error from shell");
}
AZ(VSB_finish(vsb));
vtc_dump(vl, 4, "stdout", VSB_data(vsb), VSB_len(vsb));
if (strstr(VSB_data(vsb), av[1]) == NULL)
vtc_log(vl, 0,
"Did not find expected string: (\"%s\")", av[1]);
else
vtc_log(vl, 4,
"Found expected string: (\"%s\")", av[1]);
VSB_delete(vsb);
}
static struct expr *
vcc_expr_edit(enum var_type fmt, const char *p, struct expr *e1,
struct expr *e2)
{
struct expr *e;
int nl = 1;
AN(e1);
e = vcc_new_expr();
while (*p != '\0') {
if (*p != '\v') {
if (*p != '\n' || !nl)
VSB_putc(e->vsb, *p);
nl = (*p == '\n');
p++;
continue;
}
assert(*p == '\v');
switch(*++p) {
case '+': VSB_cat(e->vsb, "\v+"); break;
case '-': VSB_cat(e->vsb, "\v-"); break;
case '1':
VSB_cat(e->vsb, VSB_data(e1->vsb));
break;
case '2':
AN(e2);
VSB_cat(e->vsb, VSB_data(e2->vsb));
break;
default:
WRONG("Illegal edit in VCC expression");
}
p++;
}
AZ(VSB_finish(e->vsb));
e->t1 = e1->t1;
e->t2 = e1->t2;
if (e2 != NULL)
e->t2 = e2->t2;
vcc_delete_expr(e1);
vcc_delete_expr(e2);
e->fmt = fmt;
return (e);
}
static void
vsmw_mkent(const struct vsmw *vsmw, const char *pfx)
{
int fd;
uint64_t rn;
AN(pfx);
while (1) {
VSB_clear(vsmw->vsb);
VSB_printf(vsmw->vsb, "_.%s", pfx);
AZ(VRND_RandomCrypto(&rn, sizeof rn));
VSB_printf(vsmw->vsb, ".%016jx", (uintmax_t)rn);
AZ(VSB_finish(vsmw->vsb));
fd = openat(vsmw->vdirfd, VSB_data(vsmw->vsb), O_RDONLY);
if (fd < 0 && errno == ENOENT)
return;
if (fd >= 0)
AZ(close(fd));
}
}
static struct varnish *
varnish_new(const char *name)
{
struct varnish *v;
struct vsb *vsb;
char buf[1024];
AN(name);
ALLOC_OBJ(v, VARNISH_MAGIC);
AN(v);
REPLACE(v->name, name);
v->vl = vtc_logopen(name);
AN(v->vl);
bprintf(buf, "${tmpdir}/%s", name);
vsb = macro_expand(v->vl, buf);
AN(vsb);
v->workdir = strdup(VSB_data(vsb));
AN(v->workdir);
VSB_delete(vsb);
bprintf(buf, "rm -rf %s ; mkdir -p %s ; echo ' %ld' > %s/_S",
v->workdir, v->workdir, random(), v->workdir);
AZ(system(buf));
if (*v->name != 'v')
vtc_log(v->vl, 0, "Varnish name must start with 'v'");
v->args = VSB_new_auto();
v->storage = VSB_new_auto();
VSB_printf(v->storage, "-sfile,%s,10M", v->workdir);
AZ(VSB_finish(v->storage));
v->cli_fd = -1;
VTAILQ_INSERT_TAIL(&varnishes, v, list);
return (v);
}
void
mgt_cli_telnet(const char *T_arg)
{
int error;
const char *err;
struct vsb *vsb;
AN(T_arg);
vsb = VSB_new_auto();
AN(vsb);
error = VSS_resolver(T_arg, NULL, mct_callback, vsb, &err);
if (err != NULL)
ARGV_ERR("Could resolve -T argument to address\n\t%s\n", err);
AZ(error);
AZ(VSB_finish(vsb));
if (VSB_len(vsb) == 0)
ARGV_ERR("-T %s could not be listened on.", T_arg);
/* Save in shmem */
mgt_SHM_static_alloc(VSB_data(vsb), VSB_len(vsb) + 1, "Arg", "-T", "");
VSB_destroy(&vsb);
}
static void backends_json(struct http_request *request,
struct vbackends_priv_t *vbackends)
{
struct vsb *json;
struct ipc_ret_t vret;
ipc_run(vbackends->vadmin, &vret, "backend.list");
if (vret.status == 200) {
json = VSB_new_auto();
assert(json);
vbackends_show_json(json, vret.answer);
AZ(VSB_finish(json));
struct http_response *resp = http_mkresp(request->connection,
200, VSB_data(json));
http_add_header(resp,"Content-Type","application/json");
send_response(resp);
VSB_delete(json);
http_free_resp(resp);
} else
http_reply(request->connection, 500, vret.answer);
free(vret.answer);
}
void
mgt_cli_setup(int fdi, int fdo, int verbose, const char *ident,
mgt_cli_close_f *closefunc, void *priv)
{
struct cli *cli;
struct vev *ev;
(void)ident;
(void)verbose;
if (cls == NULL)
mgt_cli_init_cls();
cli = VCLS_AddFd(cls, fdi, fdo, closefunc, priv);
cli->ident = strdup(ident);
/* Deal with TELNET options */
if (fdi != 0)
VLU_SetTelnet(cli->vlu, fdo);
if (fdi != 0 && secret_file != NULL) {
cli->auth = MCF_NOAUTH;
mgt_cli_challenge(cli);
} else {
cli->auth = MCF_AUTH;
mcf_banner(cli, NULL, NULL);
}
AZ(VSB_finish(cli->sb));
(void)VCLI_WriteResult(fdo, cli->result, VSB_data(cli->sb));
ev = vev_new();
AN(ev);
ev->name = cli->ident;
ev->fd = fdi;
ev->fd_flags = EV_RD;
ev->callback = mgt_cli_callback2;
ev->priv = cli;
AZ(vev_add(mgt_evb, ev));
}
static void
run_vcc(void *priv)
{
char *csrc;
struct vsb *sb;
struct vcc_priv *vp;
int fd, i, l;
CAST_OBJ_NOTNULL(vp, priv, VCC_PRIV_MAGIC);
VJ_subproc(JAIL_SUBPROC_VCC);
sb = VSB_new_auto();
XXXAN(sb);
VCC_VCL_dir(vcc, mgt_vcl_dir);
VCC_VMOD_dir(vcc, mgt_vmod_dir);
VCC_Err_Unref(vcc, mgt_vcc_err_unref);
VCC_Allow_InlineC(vcc, mgt_vcc_allow_inline_c);
VCC_Unsafe_Path(vcc, mgt_vcc_unsafe_path);
csrc = VCC_Compile(vcc, sb, vp->src);
AZ(VSB_finish(sb));
if (VSB_len(sb))
printf("%s", VSB_data(sb));
VSB_delete(sb);
if (csrc == NULL)
exit(2);
fd = open(vp->srcfile, O_WRONLY|O_TRUNC|O_CREAT, 0600);
if (fd < 0) {
fprintf(stderr, "Cannot open %s", vp->srcfile);
exit(2);
}
l = strlen(csrc);
i = write(fd, csrc, l);
if (i != l) {
fprintf(stderr, "Cannot write %s", vp->srcfile);
exit(2);
}
AZ(close(fd));
free(csrc);
exit(0);
}
