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