/* Precreate an objhead and object for later use */
static void
hsh_prealloc(struct worker *wrk)
{
struct objhead *oh;
struct waitinglist *wl;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
if (wrk->nobjcore == NULL)
wrk->nobjcore = HSH_NewObjCore(wrk);
CHECK_OBJ_NOTNULL(wrk->nobjcore, OBJCORE_MAGIC);
if (wrk->nobjhead == NULL) {
ALLOC_OBJ(oh, OBJHEAD_MAGIC);
XXXAN(oh);
oh->refcnt = 1;
VTAILQ_INIT(&oh->objcs);
Lck_New(&oh->mtx, lck_objhdr);
wrk->nobjhead = oh;
wrk->stats.n_objecthead++;
}
CHECK_OBJ_NOTNULL(wrk->nobjhead, OBJHEAD_MAGIC);
if (wrk->nwaitinglist == NULL) {
ALLOC_OBJ(wl, WAITINGLIST_MAGIC);
XXXAN(wl);
VTAILQ_INIT(&wl->list);
wrk->nwaitinglist = wl;
wrk->stats.n_waitinglist++;
}
CHECK_OBJ_NOTNULL(wrk->nwaitinglist, WAITINGLIST_MAGIC);
if (hash->prep != NULL)
hash->prep(wrk);
}
void
MGT_Run(void)
{
struct sigaction sac;
struct vev *e;
int i;
mgt_uptime_t0 = VTIM_real();
e = vev_new();
XXXAN(e);
e->callback = mgt_uptime;
e->timeout = 1.0;
e->name = "mgt_uptime";
AZ(vev_add(mgt_evb, e));
e = vev_new();
XXXAN(e);
e->sig = SIGTERM;
e->callback = mgt_sigint;
e->name = "mgt_sigterm";
AZ(vev_add(mgt_evb, e));
e = vev_new();
XXXAN(e);
e->sig = SIGINT;
e->callback = mgt_sigint;
e->name = "mgt_sigint";
AZ(vev_add(mgt_evb, e));
#ifdef HAVE_SETPROCTITLE
setproctitle("Varnish-Mgr %s", heritage.name);
#endif
memset(&sac, 0, sizeof sac);
sac.sa_handler = SIG_IGN;
sac.sa_flags = SA_RESTART;
AZ(sigaction(SIGPIPE, &sac, NULL));
AZ(sigaction(SIGHUP, &sac, NULL));
if (!d_flag && !mgt_has_vcl())
MGT_complain(C_ERR, "No VCL loaded yet");
else if (!d_flag) {
mgt_launch_child(NULL);
if (child_state != CH_RUNNING) {
// XXX correct? or 0?
exit_status = 2;
return;
}
}
mgt_SHM_Commit();
i = vev_schedule(mgt_evb);
if (i != 0)
MGT_complain(C_ERR, "vev_schedule() = %d", i);
MGT_complain(C_INFO, "manager dies");
}
static void
dyn_dir_init(VRT_CTX, struct xyzzy_debug_dyn *dyn,
VCL_STRING addr, VCL_STRING port, VCL_PROBE probe)
{
struct addrinfo hints, *res = NULL;
struct suckaddr *sa;
VCL_BACKEND dir, dir2;
struct vrt_backend vrt;
CHECK_OBJ_NOTNULL(dyn, VMOD_DEBUG_DYN_MAGIC);
XXXAN(addr);
XXXAN(port);
INIT_OBJ(&vrt, VRT_BACKEND_MAGIC);
vrt.port = port;
vrt.vcl_name = dyn->vcl_name;
vrt.hosthdr = addr;
vrt.probe = probe;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
AZ(getaddrinfo(addr, port, &hints, &res));
XXXAZ(res->ai_next);
sa = VSA_Malloc(res->ai_addr, res->ai_addrlen);
AN(sa);
if (VSA_Get_Proto(sa) == AF_INET) {
vrt.ipv4_addr = addr;
vrt.ipv4_suckaddr = sa;
} else if (VSA_Get_Proto(sa) == AF_INET6) {
vrt.ipv6_addr = addr;
vrt.ipv6_suckaddr = sa;
} else
WRONG("Wrong proto family");
freeaddrinfo(res);
dir = VRT_new_backend(ctx, &vrt);
AN(dir);
/*
* NB: A real dynamic backend should not replace the previous
* instance if the new one is identical. We do it here because
* the d* tests requires a replacement.
*/
AZ(pthread_mutex_lock(&dyn->mtx));
dir2 = dyn->dir;
dyn->dir = dir;
AZ(pthread_mutex_unlock(&dyn->mtx));
if (dir2 != NULL)
VRT_delete_backend(ctx, &dir2);
free(sa);
}
/*
* For a given host and port, return a list of struct vss_addr, which
* contains all the information necessary to open and bind a socket. One
* vss_addr is returned for each distinct address returned by
* getaddrinfo().
*
* The value pointed to by the tap parameter receives a pointer to an
* array of pointers to struct vss_addr. The caller is responsible for
* freeing each individual struct vss_addr as well as the array.
*
* The return value is the number of addresses resoved, or zero.
*
* If the addr argument contains a port specification, that takes
* precedence over the port argument.
*
* XXX: We need a function to free the allocated addresses.
*/
int
VSS_resolve(const char *addr, const char *port, struct vss_addr ***vap)
{
struct addrinfo hints, *res0, *res;
struct vss_addr **va;
int i, ret;
long int ptst;
char *adp, *hop;
*vap = NULL;
memset(&hints, 0, sizeof hints);
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
ret = VSS_parse(addr, &hop, &adp);
if (ret)
return (0);
if (adp == NULL)
ret = getaddrinfo(addr, port, &hints, &res0);
else {
ptst = strtol(adp,NULL,10);
if (ptst < 0 || ptst > 65535)
return(0);
ret = getaddrinfo(hop, adp, &hints, &res0);
}
free(hop);
free(adp);
if (ret != 0)
return (0);
XXXAN(res0);
for (res = res0, i = 0; res != NULL; res = res->ai_next, ++i)
/* nothing */ ;
if (i == 0) {
freeaddrinfo(res0);
return (0);
}
va = calloc(i, sizeof *va);
XXXAN(va);
*vap = va;
for (res = res0, i = 0; res != NULL; res = res->ai_next, ++i) {
va[i] = calloc(1, sizeof(**va));
XXXAN(va[i]);
va[i]->va_family = res->ai_family;
va[i]->va_socktype = res->ai_socktype;
va[i]->va_protocol = res->ai_protocol;
va[i]->va_addrlen = res->ai_addrlen;
xxxassert(va[i]->va_addrlen <= sizeof va[i]->va_addr);
memcpy(&va[i]->va_addr, res->ai_addr, va[i]->va_addrlen);
}
freeaddrinfo(res0);
return (i);
}
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);
}
/* Precreate an objhead and object for later use */
static void
hsh_prealloc(struct worker *wrk)
{
struct waitinglist *wl;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
if (wrk->nobjcore == NULL)
wrk->nobjcore = hsh_NewObjCore(wrk);
CHECK_OBJ_NOTNULL(wrk->nobjcore, OBJCORE_MAGIC);
if (wrk->nobjhead == NULL) {
wrk->nobjhead = hsh_newobjhead();
wrk->stats->n_objecthead++;
}
CHECK_OBJ_NOTNULL(wrk->nobjhead, OBJHEAD_MAGIC);
if (wrk->nwaitinglist == NULL) {
ALLOC_OBJ(wl, WAITINGLIST_MAGIC);
XXXAN(wl);
VTAILQ_INIT(&wl->list);
wrk->nwaitinglist = wl;
wrk->stats->n_waitinglist++;
}
CHECK_OBJ_NOTNULL(wrk->nwaitinglist, WAITINGLIST_MAGIC);
if (hash->prep != NULL)
hash->prep(wrk);
}
void
VRT_init_dir(struct cli *cli, struct director **bp, int idx, const void *priv)
{
const struct vrt_backend *t;
struct vdi_simple *vs;
ASSERT_CLI();
(void)cli;
t = priv;
ALLOC_OBJ(vs, VDI_SIMPLE_MAGIC);
XXXAN(vs);
vs->dir.magic = DIRECTOR_MAGIC;
vs->dir.priv = vs;
vs->dir.name = "simple";
REPLACE(vs->dir.vcl_name, t->vcl_name);
vs->dir.getfd = vdi_simple_getfd;
vs->dir.healthy = vdi_simple_healthy;
vs->vrt = t;
vs->backend = VBE_AddBackend(cli, t);
if (vs->vrt->probe != NULL)
VBP_Insert(vs->backend, vs->vrt->probe, vs->vrt->hosthdr);
bp[idx] = &vs->dir;
}
char *
VRT_IP_string(const struct sess *sp, const struct sockaddr_storage *sa)
{
char *p;
const struct sockaddr_in *si4;
const struct sockaddr_in6 *si6;
const void *addr;
int len;
switch (sa->ss_family) {
case AF_INET:
len = INET_ADDRSTRLEN;
si4 = (const void *)sa;
addr = &(si4->sin_addr);
break;
case AF_INET6:
len = INET6_ADDRSTRLEN;
si6 = (const void *)sa;
addr = &(si6->sin6_addr);
break;
default:
INCOMPL();
}
XXXAN(len);
AN(p = WS_Alloc(sp->http->ws, len));
AN(inet_ntop(sa->ss_family, addr, p, len));
return (p);
}
VCL_VOID vmod_mqueue__init(const struct vrt_ctx *ctx, struct vmod_msgsend_mqueue **qp, const char *vcl_name, VCL_STRING queue_name)
{
void *queue;
struct vmod_msgsend_mqueue *q;
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
AN(qp);
AZ(*qp);
if (NULL == (queue = queue_init())) {
if (NULL != ctx->vsl) {
VSLb(ctx->vsl, SLT_Error, "Can't init queue");
}
}
if (QUEUE_ERR_OK != queue_open(queue, queue_name, QUEUE_FL_SENDER)) {
if (NULL != ctx->vsl) {
VSLb(ctx->vsl, SLT_Error, "Can't open queue '%s'", queue_name);
}
queue_close(&queue);
}
XXXAN(queue);
ALLOC_OBJ(q, VMOD_MSGSEND_OBJ_MAGIC);
AN(q);
*qp = q;
q->queue = queue;
q->queue_name = queue_name;
AN(*qp);
}
void
VBP_Insert(struct backend *b, const struct vrt_backend_probe *vp,
struct tcp_pool *tp)
{
struct vbp_target *vt;
CHECK_OBJ_NOTNULL(b, BACKEND_MAGIC);
CHECK_OBJ_NOTNULL(vp, VRT_BACKEND_PROBE_MAGIC);
AZ(b->probe);
ALLOC_OBJ(vt, VBP_TARGET_MAGIC);
XXXAN(vt);
vt->tcp_pool = tp;
VTP_AddRef(vt->tcp_pool);
vt->backend = b;
b->probe = vt;
vbp_set_defaults(vt, vp);
vbp_build_req(vt, vp, b);
vbp_reset(vt);
VBP_Update_Backend(vt);
}
static struct storage *
smu_alloc(const struct stevedore *st, size_t size)
{
struct smu *smu;
Lck_Lock(&smu_mtx);
VSC_C_main->sma_nreq++;
if (VSC_C_main->sma_nbytes + size > smu_max)
size = 0;
else {
VSC_C_main->sma_nobj++;
VSC_C_main->sma_nbytes += size;
VSC_C_main->sma_balloc += size;
}
Lck_Unlock(&smu_mtx);
if (size == 0)
return (NULL);
smu = umem_zalloc(sizeof *smu, UMEM_DEFAULT);
if (smu == NULL)
return (NULL);
smu->sz = size;
smu->s.priv = smu;
smu->s.ptr = umem_alloc(size, UMEM_DEFAULT);
XXXAN(smu->s.ptr);
smu->s.len = 0;
smu->s.space = size;
smu->s.fd = -1;
smu->s.stevedore = st;
smu->s.magic = STORAGE_MAGIC;
return (&smu->s);
}
VCL_VOID
xyzzy_dyn__init(VRT_CTX, struct xyzzy_debug_dyn **dynp,
const char *vcl_name, VCL_STRING addr, VCL_STRING port, VCL_PROBE probe)
{
struct xyzzy_debug_dyn *dyn;
ASSERT_CLI();
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
AN(dynp);
AZ(*dynp);
AN(vcl_name);
if (*addr == '\0' || *port == '\0') {
AN(ctx->handling);
AZ(*ctx->handling);
VRT_fail(ctx, "Missing dynamic backend address or port");
return;
}
ALLOC_OBJ(dyn, VMOD_DEBUG_DYN_MAGIC);
AN(dyn);
REPLACE(dyn->vcl_name, vcl_name);
AZ(pthread_mutex_init(&dyn->mtx, NULL));
dyn_dir_init(ctx, dyn, addr, port, probe);
XXXAN(dyn->dir);
*dynp = dyn;
}
static void
v1d_WriteDirObj(struct req *req)
{
enum objiter_status ois;
ssize_t len;
struct objiter *oi;
void *ptr;
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
oi = ObjIterBegin(req->wrk, req->obj);
XXXAN(oi);
do {
ois = ObjIter(oi, &ptr, &len);
switch(ois) {
case OIS_DONE:
AZ(len);
break;
case OIS_ERROR:
break;
case OIS_DATA:
case OIS_STREAM:
if (VDP_bytes(req,
ois == OIS_DATA ? VDP_NULL : VDP_FLUSH, ptr, len))
ois = OIS_ERROR;
break;
default:
WRONG("Wrong OIS value");
}
} while (ois == OIS_DATA || ois == OIS_STREAM);
(void)VDP_bytes(req, VDP_FINISH, NULL, 0);
ObjIterEnd(&oi);
}
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);
}
char *
VRT_IP_string(const struct vrt_ctx *ctx, const struct sockaddr_storage *sa)
{
char *p;
const struct sockaddr_in *si4;
const struct sockaddr_in6 *si6;
const void *addr;
int len;
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
switch (sa->ss_family) {
case AF_INET:
len = INET_ADDRSTRLEN;
si4 = (const void *)sa;
addr = &(si4->sin_addr);
break;
case AF_INET6:
len = INET6_ADDRSTRLEN;
si6 = (const void *)sa;
addr = &(si6->sin6_addr);
break;
default:
INCOMPL();
}
XXXAN(len);
AN(p = WS_Alloc(ctx->ws, len));
AN(inet_ntop(sa->ss_family, addr, p, len));
return (p);
}
struct suckaddr *
VSA_Clone(const struct suckaddr *sua)
{
struct suckaddr *sua2;
struct sockaddr_un *suds;
assert(VSA_Sane(sua));
sua2 = calloc(1, vsa_suckaddr_len);
XXXAN(sua2);
memcpy(sua2, sua, vsa_suckaddr_len);
if (sua->sa_family == PF_UNIX && sua->sa.sau != NULL) {
suds = calloc(1, sizeof(struct sockaddr_un));
XXXAN(suds);
memcpy(suds, sua->sa.sau, sizeof(struct sockaddr_un));
sua2->sa.sau = suds;
}
return (sua2);
}
static void
vrt_init(struct cli *cli, struct director **bp, int idx,
const void *priv, enum crit_e criteria)
{
const struct vrt_dir_random *t;
struct vdi_random *vs;
const struct vrt_dir_random_entry *te;
struct vdi_random_host *vh;
int i;
ASSERT_CLI();
(void)cli;
t = priv;
ALLOC_OBJ(vs, VDI_RANDOM_MAGIC);
XXXAN(vs);
vs->hosts = calloc(sizeof *vh, t->nmember);
XXXAN(vs->hosts);
vs->dir.magic = DIRECTOR_MAGIC;
vs->dir.priv = vs;
vs->dir.name = "random";
REPLACE(vs->dir.vcl_name, t->name);
vs->dir.getfd = vdi_random_getfd;
vs->dir.fini = vdi_random_fini;
vs->dir.healthy = vdi_random_healthy;
vs->criteria = criteria;
vs->retries = t->retries;
if (vs->retries == 0)
vs->retries = t->nmember;
vh = vs->hosts;
te = t->members;
vs->tot_weight = 0.;
for (i = 0; i < t->nmember; i++, vh++, te++) {
assert(te->weight > 0.0);
vh->weight = te->weight;
vs->tot_weight += vh->weight;
vh->backend = bp[te->host];
AN(vh->backend);
}
vs->nhosts = t->nmember;
bp[idx] = &vs->dir;
}
/* Precreate an objhead and object for later use */
void
HSH_Prealloc(const struct sess *sp)
{
struct worker *wrk;
struct objhead *oh;
struct objcore *oc;
struct waitinglist *wl;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
CHECK_OBJ_NOTNULL(sp->wrk, WORKER_MAGIC);
wrk = sp->wrk;
if (wrk->nobjcore == NULL) {
ALLOC_OBJ(oc, OBJCORE_MAGIC);
XXXAN(oc);
wrk->nobjcore = oc;
wrk->stats.n_objectcore++;
oc->flags |= OC_F_BUSY;
}
CHECK_OBJ_NOTNULL(wrk->nobjcore, OBJCORE_MAGIC);
if (wrk->nobjhead == NULL) {
ALLOC_OBJ(oh, OBJHEAD_MAGIC);
XXXAN(oh);
oh->refcnt = 1;
VTAILQ_INIT(&oh->objcs);
Lck_New(&oh->mtx, lck_objhdr);
wrk->nobjhead = oh;
wrk->stats.n_objecthead++;
}
CHECK_OBJ_NOTNULL(wrk->nobjhead, OBJHEAD_MAGIC);
if (wrk->nwaitinglist == NULL) {
ALLOC_OBJ(wl, WAITINGLIST_MAGIC);
XXXAN(wl);
VTAILQ_INIT(&wl->list);
wrk->nwaitinglist = wl;
wrk->stats.n_waitinglist++;
}
CHECK_OBJ_NOTNULL(wrk->nwaitinglist, WAITINGLIST_MAGIC);
if (hash->prep != NULL)
hash->prep(sp);
}
vfp_esi_begin(struct busyobj *bo, size_t estimate)
{
struct vef_priv *vef;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
(void)estimate;
ALLOC_OBJ(vef, VEF_MAGIC);
XXXAN(vef);
AZ(bo->vef_priv);
bo->vef_priv = vef;
AZ(bo->vgz_rx);
if (bo->is_gzip && bo->do_gunzip) {
bo->vgz_rx = VGZ_NewUngzip(bo->vsl, "U F E");
VEP_Init(bo, NULL);
vef->ibuf_sz = cache_param->gzip_buffer;
} else if (bo->is_gunzip && bo->do_gzip) {
vef->vgz = VGZ_NewGzip(bo->vsl, "G F E");
VEP_Init(bo, vfp_vep_callback);
vef->ibuf_sz = cache_param->gzip_buffer;
} else if (bo->is_gzip) {
bo->vgz_rx = VGZ_NewUngzip(bo->vsl, "U F E");
vef->vgz = VGZ_NewGzip(bo->vsl, "G F E");
VEP_Init(bo, vfp_vep_callback);
vef->ibuf_sz = cache_param->gzip_buffer;
vef->ibuf2_sz = cache_param->gzip_buffer;
} else {
VEP_Init(bo, NULL);
}
if (vef->ibuf_sz > 0) {
vef->ibuf = calloc(1L, vef->ibuf_sz);
XXXAN(vef->ibuf);
vef->ibuf_i = vef->ibuf;
vef->ibuf_o = vef->ibuf;
}
if (vef->ibuf2_sz > 0) {
vef->ibuf2 = calloc(1L, vef->ibuf2_sz);
XXXAN(vef->ibuf2);
}
AN(bo->vep);
}
static struct objcore *
hsh_NewObjCore(struct worker *wrk)
{
struct objcore *oc;
ALLOC_OBJ(oc, OBJCORE_MAGIC);
XXXAN(oc);
wrk->stats->n_objectcore++;
oc->flags |= OC_F_BUSY | OC_F_INCOMPLETE;
return (oc);
}
struct objcore *
HSH_NewObjCore(struct worker *wrk)
{
struct objcore *oc;
ALLOC_OBJ(oc, OBJCORE_MAGIC);
XXXAN(oc);
wrk->stats.n_objectcore++;
oc->flags |= OC_F_BUSY;
return (oc);
}
struct suckaddr *
VSA_Clone(const struct suckaddr *sua)
{
struct suckaddr *sua2;
assert(VSA_Sane(sua));
sua2 = calloc(1, vsa_suckaddr_len);
XXXAN(sua2);
memcpy(sua2, sua, vsa_suckaddr_len);
return (sua2);
}
static struct vbc *
vbe_NewConn(void)
{
struct vbc *vc;
vc = MPL_Get(vbcpool, NULL);
XXXAN(vc);
vc->magic = VBC_MAGIC;
vc->fd = -1;
return (vc);
}
static struct objhead *
hsh_newobjhead(void)
{
struct objhead *oh;
ALLOC_OBJ(oh, OBJHEAD_MAGIC);
XXXAN(oh);
oh->refcnt = 1;
VTAILQ_INIT(&oh->objcs);
Lck_New(&oh->mtx, lck_objhdr);
return (oh);
}
int
VSS_parse(const char *str, char **addr, char **port)
{
const char *p;
*addr = *port = NULL;
if (str[0] == '[') {
/* IPv6 address of the form [::1]:80 */
if ((p = strchr(str, ']')) == NULL ||
p == str + 1 ||
(p[1] != '\0' && p[1] != ':'))
return (-1);
*addr = strdup(str + 1);
XXXAN(*addr);
(*addr)[p - (str + 1)] = '\0';
if (p[1] == ':') {
*port = strdup(p + 2);
XXXAN(*port);
}
} else {
/* IPv4 address of the form 127.0.0.1:80, or non-numeric */
p = strchr(str, ' ');
if (p == NULL)
p = strchr(str, ':');
if (p == NULL) {
*addr = strdup(str);
XXXAN(*addr);
} else {
if (p > str) {
*addr = strdup(str);
XXXAN(*addr);
(*addr)[p - str] = '\0';
}
*port = strdup(p + 1);
XXXAN(*port);
}
}
return (0);
}
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);
}
static void
vrt_init_dir(struct cli *cli, struct director **bp, int idx,
const void *priv, enum mode_e mode)
{
const struct vrt_dir_round_robin *t;
struct vdi_round_robin *vs;
const struct vrt_dir_round_robin_entry *te;
struct vdi_round_robin_host *vh;
int i;
ASSERT_CLI();
(void)cli;
t = priv;
ALLOC_OBJ(vs, VDI_ROUND_ROBIN_MAGIC);
XXXAN(vs);
vs->hosts = calloc(sizeof *vh, t->nmember);
XXXAN(vs->hosts);
vs->dir.magic = DIRECTOR_MAGIC;
vs->dir.priv = vs;
vs->dir.name = "round_robin";
REPLACE(vs->dir.vcl_name, t->name);
vs->dir.getfd = vdi_round_robin_getfd;
vs->dir.fini = vdi_round_robin_fini;
vs->dir.healthy = vdi_round_robin_healthy;
vs->mode = mode;
vh = vs->hosts;
te = t->members;
for (i = 0; i < t->nmember; i++, vh++, te++) {
vh->backend = bp[te->host];
AN (vh->backend);
}
vs->nhosts = t->nmember;
vs->next_host = 0;
bp[idx] = &vs->dir;
}
static struct busyobj *
vbo_New(void)
{
struct busyobj *bo;
unsigned sz;
bo = MPL_Get(vbopool, &sz);
XXXAN(bo);
bo->magic = BUSYOBJ_MAGIC;
bo->end = (char *)bo + sz;
Lck_New(&bo->mtx, lck_busyobj);
AZ(pthread_cond_init(&bo->cond, NULL));
return (bo);
}
static struct replay_thread *
thread_get(int fd, void *(*thread_main)(void *))
{
assert(fd != 0);
if (fd >= nthreads) {
struct replay_thread **newthreads = threads;
size_t newnthreads = nthreads;
while (fd >= newnthreads)
newnthreads += newnthreads + 1;
newthreads = realloc(newthreads,
newnthreads * sizeof *newthreads);
XXXAN(newthreads != NULL);
memset(newthreads + nthreads, 0,
(newnthreads - nthreads) * sizeof *newthreads);
threads = newthreads;
nthreads = newnthreads;
}
if (threads[fd] == NULL) {
threads[fd] = malloc(sizeof *threads[fd]);
assert(threads[fd] != NULL);
threads[fd]->sock = -1;
thread_clear(threads[fd]);
mailbox_create(&threads[fd]->mbox);
if (pthread_create(&threads[fd]->thread_id, &thread_attr,
thread_main, threads[fd]) != 0) {
thread_log(0, errno, "pthread_create()");
mailbox_destroy(&threads[fd]->mbox);
freez(threads[fd]);
threads[fd] = THREAD_FAIL;
} else {
threads[fd]->fd = fd;
thread_log(0, 0, "thread %p:%d started",
(void *)threads[fd]->thread_id, fd);
}
}
if (threads[fd] == THREAD_FAIL)
return (NULL);
return (threads[fd]);
}
vfp_esi_gzip_init(struct busyobj *bo, struct vfp_entry *vfe)
{
struct vef_priv *vef;
CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);
CHECK_OBJ_NOTNULL(vfe, VFP_ENTRY_MAGIC);
ALLOC_OBJ(vef, VEF_MAGIC);
if (vef == NULL)
return (VFP_ERROR);
vef->vgz = VGZ_NewGzip(bo->vsl, "G F E");
vef->vep = VEP_Init(bo, vfp_vep_callback, vef);
vef->ibuf_sz = cache_param->gzip_buffer;
vef->ibuf = calloc(1L, vef->ibuf_sz);
if (vef->ibuf == NULL)
return (vfp_esi_end(bo, vef, VFP_ERROR));
XXXAN(vef->ibuf);
vef->ibuf_i = vef->ibuf;
vef->ibuf_o = vef->ibuf;
vfe->priv1 = vef;
return (VFP_OK);
}
