static enum req_fsm_nxt
cnt_synth(struct worker *wrk, struct req *req)
{
char date[40];
struct http *h;
double now;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
wrk->stats.s_synth++;
now = W_TIM_real(wrk);
VSLb_ts_req(req, "Process", now);
if (req->err_code < 100 || req->err_code > 999)
req->err_code = 501;
HTTP_Setup(req->resp, req->ws, req->vsl, SLT_RespMethod);
h = req->resp;
VTIM_format(now, date);
http_PrintfHeader(h, "Date: %s", date);
http_SetHeader(h, "Server: Varnish");
http_PrintfHeader(req->resp, "X-Varnish: %u", VXID(req->vsl->wid));
http_PutResponse(h, "HTTP/1.1", req->err_code, req->err_reason);
AZ(req->synth_body);
req->synth_body = VSB_new_auto();
AN(req->synth_body);
VCL_synth_method(req->vcl, wrk, req, NULL, req->http->ws);
http_Unset(h, H_Content_Length);
AZ(VSB_finish(req->synth_body));
if (wrk->handling == VCL_RET_RESTART) {
HTTP_Setup(h, req->ws, req->vsl, SLT_RespMethod);
VSB_delete(req->synth_body);
req->synth_body = NULL;
req->req_step = R_STP_RESTART;
return (REQ_FSM_MORE);
}
assert(wrk->handling == VCL_RET_DELIVER);
if (http_HdrIs(req->resp, H_Connection, "close"))
req->doclose = SC_RESP_CLOSE;
V1D_Deliver_Synth(req);
VSLb_ts_req(req, "Resp", W_TIM_real(wrk));
VSB_delete(req->synth_body);
req->synth_body = NULL;
req->err_code = 0;
req->err_reason = NULL;
return (REQ_FSM_DONE);
}
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_delete(vsb);
VCLI_SetResult(cli, CLIS_COMMS);
VCLI_Out(cli, "CLI communication error");
MGT_Child_Cli_Fail();
return;
}
VSB_delete(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);
}
struct vsb *
VEP_Finish(const struct sess *sp)
{
struct vep_state *vep;
ssize_t l, lcb;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
vep = sp->wrk->vep;
CHECK_OBJ_NOTNULL(vep, VEP_MAGIC);
if (vep->o_pending)
vep_mark_common(vep, vep->ver_p, vep->last_mark);
if (vep->o_wait > 0) {
lcb = vep->cb(vep->sp, 0, VGZ_ALIGN);
vep_emit_common(vep, lcb - vep->o_last, vep->last_mark);
}
(void)vep->cb(vep->sp, 0, VGZ_FINISH);
sp->wrk->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);
}
vfp_esi_end(struct sess *sp)
{
struct vsb *vsb;
struct vef_priv *vef;
ssize_t l;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
AN(sp->wrk->vep);
vsb = VEP_Finish(sp);
if (vsb != NULL) {
l = VSB_len(vsb);
assert(l > 0);
/* XXX: This is a huge waste of storage... */
sp->obj->esidata = STV_alloc(sp, l);
XXXAN(sp->obj->esidata);
memcpy(sp->obj->esidata->ptr, VSB_data(vsb), l);
sp->obj->esidata->len = l;
VSB_delete(vsb);
}
if (sp->wrk->vgz_rx != NULL)
VGZ_Destroy(&sp->wrk->vgz_rx);
if (sp->wrk->vef_priv != NULL) {
vef = sp->wrk->vef_priv;
CHECK_OBJ_NOTNULL(vef, VEF_MAGIC);
sp->wrk->vef_priv = NULL;
VGZ_UpdateObj(vef->vgz, sp->obj);
VGZ_Destroy(&vef->vgz);
XXXAZ(vef->error);
FREE_OBJ(vef);
}
return (0);
}
Marg_connect(const struct vev *e, int what)
{
struct vsb *vsb;
struct m_addr *ma;
assert(e == M_conn);
(void)what;
M_fd = VTCP_connected(M_fd);
if (M_fd < 0) {
MGT_complain(C_INFO, "Could not connect to CLI-master: %m");
ma = VTAILQ_FIRST(&m_addr_list);
AN(ma);
VTAILQ_REMOVE(&m_addr_list, ma, list);
VTAILQ_INSERT_TAIL(&m_addr_list, ma, list);
if (M_poll < 10)
M_poll++;
return (1);
}
vsb = sock_id("master", M_fd);
mgt_cli_setup(M_fd, M_fd, 0, VSB_data(vsb), Marg_closer, NULL);
VSB_delete(vsb);
M_poll = 1;
return (1);
}
int
http_process(struct vtclog *vl, const char *spec, int sock, int *sfd)
{
struct http *hp;
char *s, *q;
int retval;
(void)sfd;
ALLOC_OBJ(hp, HTTP_MAGIC);
AN(hp);
hp->fd = sock;
hp->timeout = 15000;
hp->nrxbuf = 2048*1024;
hp->vsb = VSB_new_auto();
hp->rxbuf = malloc(hp->nrxbuf); /* XXX */
hp->sfd = sfd;
hp->vl = vl;
hp->gziplevel = 0;
hp->gzipresidual = -1;
AN(hp->rxbuf);
AN(hp->vsb);
s = strdup(spec);
q = strchr(s, '\0');
assert(q > s);
AN(s);
parse_string(s, http_cmds, hp, vl);
retval = hp->fd;
VSB_delete(hp->vsb);
free(hp->rxbuf);
free(hp);
return (retval);
}
struct vsb *
VEP_Finish(const struct worker *wrk)
{
struct vep_state *vep;
ssize_t l, lcb;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(wrk->busyobj, BUSYOBJ_MAGIC);
vep = wrk->busyobj->vep;
CHECK_OBJ_NOTNULL(vep, VEP_MAGIC);
if (vep->o_pending)
vep_mark_common(vep, vep->ver_p, vep->last_mark);
if (vep->o_wait > 0) {
lcb = vep->cb(vep->wrk, 0, VGZ_ALIGN);
vep_emit_common(vep, lcb - vep->o_last, vep->last_mark);
}
(void)vep->cb(vep->wrk, 0, VGZ_FINISH);
wrk->busyobj->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);
}
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);
}
void
mgt_sandbox_init(void)
{
struct passwd *pwd;
struct group *grp;
struct vsb *sb;
unsigned subs;
/* Pick a sandbox */
#ifdef HAVE_SETPPRIV
mgt_sandbox = mgt_sandbox_solaris;
#else
mgt_sandbox = mgt_sandbox_unix;
#endif
/* Test it */
sb = VSB_new_auto();
subs = VSUB_run(sb, run_sandbox_test, NULL, "SANDBOX-test", 10);
VSB_delete(sb);
if (subs) {
MGT_complain(C_SECURITY,
"Platform-specific sandbox failed - sandboxing disabled");
MGT_complain(C_SECURITY,
"Varnish runs with elevated privileges");
mgt_sandbox = mgt_sandbox_null;
}
MCF_AddParams(mgt_parspec_sandbox);
/*
* If we have nobody/nogroup, use them as defaults for sandboxes,
* else fall back to whoever we run as.
*/
if (getpwnam("nobody") != NULL) {
MCF_SetDefault("user", "nobody");
} else {
pwd = getpwuid(getuid());
if (pwd == NULL)
ARGV_ERR("Neither user 'nobody' or my uid (%jd)"
" found in password database.\n",
(intmax_t)getuid());
MCF_SetDefault("user", pwd->pw_name);
}
endpwent();
if (getgrnam("nogroup") != NULL) {
MCF_SetDefault("group", "nogroup");
} else {
grp = getgrgid(getgid());
if (grp == NULL)
ARGV_ERR("Neither group 'nogroup' or my gid (%jd)"
" found in password database.\n",
(intmax_t)getgid());
MCF_SetDefault("group", grp->gr_name);
}
endgrent();
}
void
BAN_Abandon(struct ban_proto *bp)
{
CHECK_OBJ_NOTNULL(bp, BAN_PROTO_MAGIC);
VSB_delete(bp->vsb);
FREE_OBJ(bp);
}
static void
vcc_delete_expr(struct expr *e)
{
if (e == NULL)
return;
CHECK_OBJ_NOTNULL(e, EXPR_MAGIC);
VSB_delete(e->vsb);
FREE_OBJ(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 int
Marg_poker(const struct vev *e, int what)
{
struct vsb *vsb;
int s, k;
socklen_t l;
(void)what; /* XXX: ??? */
if (e == M_conn) {
/* Our connect(2) returned, check result */
l = sizeof k;
AZ(getsockopt(M_fd, SOL_SOCKET, SO_ERROR, &k, &l));
if (k) {
errno = k;
syslog(LOG_INFO, "Could not connect to CLI-master: %m");
(void)close(M_fd);
M_fd = -1;
/* Try next address */
if (++M_nxt >= M_nta) {
M_nxt = 0;
if (M_poll < 10)
M_poll *= 2;
}
return (1);
}
vsb = sock_id("master", M_fd);
mgt_cli_setup(M_fd, M_fd, 0, VSB_data(vsb), Marg_closer, NULL);
VSB_delete(vsb);
M_poll = 1;
return (1);
}
assert(e == M_poker);
M_poker->timeout = M_poll; /* XXX nasty ? */
if (M_fd >= 0)
return (0);
/* Try to connect asynchronously */
s = VSS_connect(M_ta[M_nxt], 1);
if (s < 0)
return (0);
mgt_got_fd(s);
M_conn = vev_new();
AN(M_conn);
M_conn->callback = Marg_poker;
M_conn->name = "-M connector";
M_conn->fd_flags = EV_WR;
M_conn->fd = s;
M_fd = s;
AZ(vev_add(mgt_evb, M_conn));
return (0);
}
void
vtc_logclose(struct vtclog *vl)
{
CHECK_OBJ_NOTNULL(vl, VTCLOG_MAGIC);
if (pthread_getspecific(log_key) == vl)
AZ(pthread_setspecific(log_key, NULL));
VSB_delete(vl->vsb);
AZ(pthread_mutex_destroy(&vl->mtx));
FREE_OBJ(vl);
}
void
VSL_ResetError(struct VSL_data *vsl)
{
CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
if (vsl->diag == NULL)
return;
VSB_delete(vsl->diag);
vsl->diag = NULL;
}
char *
mgt_VccCompile(struct cli *cli, const char *vclname, const char *vclsrc,
int C_flag)
{
struct vcc_priv vp;
struct vsb *sb;
unsigned status;
AN(cli);
sb = VSB_new_auto();
XXXAN(sb);
INIT_OBJ(&vp, VCC_PRIV_MAGIC);
vp.src = vclsrc;
VSB_printf(sb, "./vcl_%s.c", vclname);
AZ(VSB_finish(sb));
vp.srcfile = strdup(VSB_data(sb));
AN(vp.srcfile);
VSB_clear(sb);
VSB_printf(sb, "./vcl_%s.so", vclname);
AZ(VSB_finish(sb));
vp.libfile = strdup(VSB_data(sb));
AN(vp.srcfile);
VSB_clear(sb);
status = mgt_vcc_compile(&vp, sb, C_flag);
AZ(VSB_finish(sb));
if (VSB_len(sb) > 0)
VCLI_Out(cli, "%s", VSB_data(sb));
VSB_delete(sb);
(void)unlink(vp.srcfile);
free(vp.srcfile);
if (status || C_flag) {
(void)unlink(vp.libfile);
free(vp.libfile);
if (!C_flag) {
VCLI_Out(cli, "VCL compilation failed");
VCLI_SetResult(cli, CLIS_PARAM);
}
return(NULL);
}
VCLI_Out(cli, "VCL compiled.\n");
return (vp.libfile);
}
vfp_esi_end(struct busyobj *bo)
{
struct vsb *vsb;
struct vef_priv *vef;
ssize_t l;
int retval = 0;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
AN(bo->vep);
if (bo->state == BOS_FAILED)
retval = -1;
if (bo->vgz_rx != NULL && VGZ_Destroy(&bo->vgz_rx) != VGZ_END)
retval = VFP_Error(bo, "Gunzip+ESI Failed at the very end");
vsb = VEP_Finish(bo);
if (vsb != NULL) {
if (!retval) {
l = VSB_len(vsb);
assert(l > 0);
/* XXX: This is a huge waste of storage... */
bo->fetch_obj->esidata = STV_alloc(bo, l);
if (bo->fetch_obj->esidata != NULL) {
memcpy(bo->fetch_obj->esidata->ptr,
VSB_data(vsb), l);
bo->fetch_obj->esidata->len = l;
} else {
retval = VFP_Error(bo,
"Could not allocate storage for esidata");
}
}
VSB_delete(vsb);
}
vef = bo->vef_priv;
bo->vef_priv = NULL;
CHECK_OBJ_NOTNULL(vef, VEF_MAGIC);
if (vef->vgz != NULL) {
VGZ_UpdateObj(vef->vgz, bo->fetch_obj);
if (VGZ_Destroy(&vef->vgz) != VGZ_END)
retval = VFP_Error(bo,
"ESI+Gzip Failed at the very end");
}
if (vef->ibuf != NULL)
free(vef->ibuf);
if (vef->ibuf2 != NULL)
free(vef->ibuf2);
FREE_OBJ(vef);
return (retval);
}
int
main(int argc, char **argv)
{
struct vsb *vsb;
struct vex *vex;
char *q_arg = NULL;
char opt;
while ((opt = getopt(argc, argv, "q:")) != -1) {
switch (opt) {
case 'q':
REPLACE(q_arg, optarg);
break;
default:
usage();
}
}
if (q_arg == NULL || optind != argc)
usage();
vsb = VSB_new_auto();
AN(vsb);
vex = vex_New(q_arg, vsb);
if (vex == NULL) {
VSB_finish(vsb);
fprintf(stderr, "Error:\n%s", VSB_data(vsb));
VSB_delete(vsb);
free(q_arg);
exit(1);
}
VSB_delete(vsb);
vex_Free(&vex);
AZ(vex);
free(q_arg);
return (0);
}
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);
}
vfp_esi_end(struct worker *wrk)
{
struct vsb *vsb;
struct vef_priv *vef;
struct busyobj *bo;
ssize_t l;
int retval;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
bo = wrk->busyobj;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
AN(bo->vep);
retval = bo->fetch_failed;
if (bo->vgz_rx != NULL && VGZ_Destroy(&bo->vgz_rx, -1) != VGZ_END)
retval = FetchError(wrk, "Gunzip+ESI Failed at the very end");
vsb = VEP_Finish(wrk);
if (vsb != NULL) {
if (!retval) {
l = VSB_len(vsb);
assert(l > 0);
/* XXX: This is a huge waste of storage... */
bo->fetch_obj->esidata = STV_alloc(wrk, l);
if (bo->fetch_obj->esidata != NULL) {
memcpy(bo->fetch_obj->esidata->ptr,
VSB_data(vsb), l);
bo->fetch_obj->esidata->len = l;
} else {
retval = FetchError(wrk,
"Could not allocate storage for esidata");
}
}
VSB_delete(vsb);
}
vef = bo->vef_priv;
if (vef != NULL) {
CHECK_OBJ_NOTNULL(vef, VEF_MAGIC);
bo->vef_priv = NULL;
VGZ_UpdateObj(vef->vgz, bo->fetch_obj);
if (VGZ_Destroy(&vef->vgz, -1) != VGZ_END)
retval = FetchError(wrk,
"ESI+Gzip Failed at the very end");
FREE_OBJ(vef);
}
return (retval);
}
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);
}
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 void
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);
sb = VSB_new_auto();
AN(sb);
for (p = mgt_cc_cmd, pct = 0; *p; ++p) {
if (pct) {
switch (*p) {
case 's':
VSB_cat(sb, vp->srcfile);
break;
case 'o':
VSB_cat(sb, vp->libfile);
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(077);
(void)execl("/bin/sh", "/bin/sh", "-c", VSB_data(sb), (char*)0);
VSB_delete(sb); // For flexelint
}
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);
}
int
http_process(struct vtclog *vl, const char *spec, int sock, int *sfd)
{
struct http *hp;
int retval;
(void)sfd;
ALLOC_OBJ(hp, HTTP_MAGIC);
AN(hp);
hp->fd = sock;
hp->timeout = vtc_maxdur * 1000 / 2;
hp->nrxbuf = 2048*1024;
hp->rxbuf = malloc(hp->nrxbuf); /* XXX */
AN(hp->rxbuf);
hp->vsb = VSB_new_auto();
AN(hp->vsb);
hp->sfd = sfd;
hp->rem_ip = malloc(VTCP_ADDRBUFSIZE);
AN(hp->rem_ip);
hp->rem_port = malloc(VTCP_PORTBUFSIZE);
AN(hp->rem_port);
hp->vl = vl;
hp->gziplevel = 0;
hp->gzipresidual = -1;
VTCP_hisname(sock, hp->rem_ip, VTCP_ADDRBUFSIZE, hp->rem_port, VTCP_PORTBUFSIZE);
parse_string(spec, http_cmds, hp, vl);
retval = hp->fd;
VSB_delete(hp->vsb);
free(hp->rxbuf);
free(hp->rem_ip);
free(hp->rem_port);
free(hp);
return (retval);
}
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_delete(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);
}
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);
}
