自学教程：C++ AZ函数代码示例

vfp_nop_bytes(struct worker *wrk, struct http_conn *htc, ssize_t bytes){	ssize_t l, wl;	struct storage *st;	AZ(wrk->busyobj->fetch_failed);	while (bytes > 0) {		st = FetchStorage(wrk, 0);		if (st == NULL)			return(-1);		l = st->space - st->len;		if (l > bytes)			l = bytes;		wl = HTC_Read(wrk, htc, st->ptr + st->len, l);		if (wl <= 0)			return (wl);		st->len += wl;		wrk->busyobj->fetch_obj->len += wl;		bytes -= wl;		if (wrk->busyobj->do_stream)			RES_StreamPoll(wrk);	}	return (1);}

static enum req_fsm_nxtcnt_miss(struct worker *wrk, struct req *req){	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);	AN(req->vcl);	CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);	VCL_miss_method(req->vcl, wrk, req, NULL, NULL);	switch (wrk->handling) {	case VCL_RET_FETCH:		wrk->stats->cache_miss++;		VBF_Fetch(wrk, req, req->objcore, req->stale_oc, VBF_NORMAL);		if (req->stale_oc != NULL)			(void)HSH_DerefObjCore(wrk, &req->stale_oc);		req->req_step = R_STP_FETCH;		return (REQ_FSM_MORE);	case VCL_RET_SYNTH:		req->req_step = R_STP_SYNTH;		break;	case VCL_RET_RESTART:		req->req_step = R_STP_RESTART;		break;	case VCL_RET_PASS:		req->req_step = R_STP_PASS;		break;	default:		WRONG("Illegal return from vcl_miss{}");	}	VRY_Clear(req);	if (req->stale_oc != NULL)		(void)HSH_DerefObjCore(wrk, &req->stale_oc);	AZ(HSH_DerefObjCore(wrk, &req->objcore));	return (REQ_FSM_MORE);}

static voidcmd_http_sendhex(CMD_ARGS){	struct http *hp;	char buf[3], *q;	uint8_t *p;	int i, j, l;	(void)cmd;	(void)vl;	CAST_OBJ_NOTNULL(hp, priv, HTTP_MAGIC);	AN(av[1]);	AZ(av[2]);	l = strlen(av[1]) / 2;	p = malloc(l);	AN(p);	q = av[1];	for (i = 0; i < l; i++) {		while (vct_issp(*q))			q++;		if (*q == '/0')			break;		memcpy(buf, q, 2);		q += 2;		buf[2] = '/0';		if (!vct_ishex(buf[0]) || !vct_ishex(buf[1]))			vtc_log(hp->vl, 0, "Illegal Hex char /"%c%c/"",			    buf[0], buf[1]);		p[i] = (uint8_t)strtoul(buf, NULL, 16);	}	vtc_hexdump(hp->vl, 4, "sendhex", (void*)p, i);	j = write(hp->fd, p, i);	assert(j == i);	free(p);}

static const char *ban_error(struct ban_proto *bp, const char *fmt, ...){	va_list ap;	CHECK_OBJ_NOTNULL(bp, BAN_PROTO_MAGIC);	AN(bp->vsb);	/* First error is sticky */	if (bp->err == NULL) {		if (fmt == ban_build_err_no_mem) {			bp->err = ban_build_err_no_mem;		} else {			/* Record the error message in the vsb */			VSB_clear(bp->vsb);			va_start(ap, fmt);			(void)VSB_vprintf(bp->vsb, fmt, ap);			va_end(ap);			AZ(VSB_finish(bp->vsb));			bp->err = VSB_data(bp->vsb);		}	}	return (bp->err);}

static voidvxp_expr_num(struct vxp *vxp, struct vex_rhs **prhs){	char *endptr;	AN(prhs);	AZ(*prhs);	if (vxp->t->tok != VAL) {		VSB_printf(vxp->sb, "Expected number got '%.*s' ", PF(vxp->t));		vxp_ErrWhere(vxp, vxp->t, -1);		return;	}	AN(vxp->t->dec);	ALLOC_OBJ(*prhs, VEX_RHS_MAGIC);	AN(*prhs);	if (strchr(vxp->t->dec, '.')) {		(*prhs)->type = VEX_FLOAT;		(*prhs)->val_float = VNUM(vxp->t->dec);		if (isnan((*prhs)->val_float)) {			VSB_printf(vxp->sb, "Floating point parse error ");			vxp_ErrWhere(vxp, vxp->t, -1);			return;		}	} else {		(*prhs)->type = VEX_INT;		(*prhs)->val_int = strtoll(vxp->t->dec, &endptr, 0);		while (isspace(*endptr))			endptr++;		if (*endptr != '/0') {			VSB_printf(vxp->sb, "Integer parse error ");			vxp_ErrWhere(vxp, vxp->t, -1);			return;		}	}	vxp_NextToken(vxp);}

intSES_Schedule(struct sess *sp){	struct sessmem *sm;	struct sesspool *pp;	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);	AZ(sp->wrk);	sm = sp->mem;	CHECK_OBJ_NOTNULL(sm, SESSMEM_MAGIC);	pp = sm->pool;	CHECK_OBJ_NOTNULL(pp, SESSPOOL_MAGIC);	AN(pp->pool);	if (Pool_Schedule(pp->pool, sp)) {		SES_Delete(sp, "dropped");		return (1);	}	return (0);}

static voidses_vsl_socket(struct sess *sp, const char *lsockname){	struct sockaddr_storage ss;	socklen_t sl;	char laddr[ADDR_BUFSIZE];	char lport[PORT_BUFSIZE];	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);	AN(lsockname);	AN(sp->local_addr);	sl = sizeof ss;	AZ(getsockname(sp->fd, (void*)&ss, &sl));	AN(VSA_Build(sp->local_addr, &ss, sl));	assert(VSA_Sane(sp->local_addr));	VTCP_name(sp->remote_addr,	    sp->addr, sizeof sp->addr, sp->port, sizeof sp->port);	VTCP_name(sp->local_addr, laddr, sizeof laddr, lport, sizeof lport);	VSL(SLT_Begin, sp->vxid, "sess");	VSL(SLT_SessOpen, sp->vxid, "%s %s %s %s %s %.6f %d",	    sp->addr, sp->port, lsockname, laddr, lport, sp->t_open, sp->fd);}

static voidcmd_http_expect_close(CMD_ARGS){	struct http *hp;	struct pollfd fds[1];	char c;	int i;	(void)cmd;	(void)vl;	CAST_OBJ_NOTNULL(hp, priv, HTTP_MAGIC);	AZ(av[1]);	assert(hp->sfd >= 0);	vtc_log(vl, 4, "Expecting close (fd = %d)", hp->fd);	while (1) {		fds[0].fd = hp->fd;		fds[0].events = POLLIN | POLLHUP | POLLERR;		fds[0].revents = 0;		i = poll(fds, 1, 1000);		if (i == 0)			vtc_log(vl, 0, "Expected close: timeout");		if (i != 1 || !(fds[0].revents & POLLIN))			vtc_log(vl, 0,			    "Expected close: poll = %d, revents = 0x%x",			    i, fds[0].revents);		i = read(hp->fd, &c, 1);		if (i == 0)			break;		if (i == 1 && vct_islws(c))			continue;		vtc_log(vl, 0,		    "Expecting close: read = %d, c = 0x%02x", i, c);	}	vtc_log(vl, 4, "fd=%d EOF, as expected", hp->fd);}

voidVBP_Control(const struct backend *be, int enable){	struct vbp_target *vt;	CHECK_OBJ_NOTNULL(be, BACKEND_MAGIC);	vt = be->probe;	CHECK_OBJ_NOTNULL(vt, VBP_TARGET_MAGIC);	vbp_reset(vt);	vbp_update_backend(vt);	Lck_Lock(&vbp_mtx);	if (enable) {		assert(vt->heap_idx == BINHEAP_NOIDX);		vt->due = VTIM_real();		binheap_insert(vbp_heap, vt);		AZ(pthread_cond_signal(&vbp_cond));	} else {		assert(vt->heap_idx != BINHEAP_NOIDX);		binheap_delete(vbp_heap, vt->heap_idx);	}	Lck_Unlock(&vbp_mtx);}

struct storage *FetchStorage(const struct sess *sp, ssize_t sz){	ssize_t l;	struct storage *st;	st = VTAILQ_LAST(&sp->obj->store, storagehead);	if (st != NULL && st->len < st->space)		return (st);	l = fetchfrag;	if (l == 0)		l = sz;	if (l == 0)		l = params->fetch_chunksize * 1024LL;	st = STV_alloc(sp, l);	if (st == NULL) {		errno = ENOMEM;		return (NULL);	}	AZ(st->len);	VTAILQ_INSERT_TAIL(&sp->obj->store, st, list);	return (st);}

struct vsb *VEP_Finish(struct vep_state *vep){	ssize_t l, lcb;	CHECK_OBJ_NOTNULL(vep, VEP_MAGIC);	if (vep->include_src)		VSB_destroy(&vep->include_src);	if (vep->attr_vsb)		VSB_destroy(&vep->attr_vsb);	if (vep->state != VEP_START &&	    vep->state != VEP_BOM &&	    vep->state != VEP_TESTXML &&	    vep->state != VEP_NOTXML &&	    vep->state != VEP_NEXTTAG) {		vep_error(vep, "VEP ended inside a tag");	}	if (vep->o_pending)		vep_mark_common(vep, vep->ver_p, vep->last_mark);	if (vep->o_wait > 0) {		lcb = vep->cb(vep->vc, vep->cb_priv, 0, VGZ_ALIGN);		vep_emit_common(vep, lcb - vep->o_last, vep->last_mark);	}	// NB: We don't account for PAD+SUM+LEN in gzip'ed objects	(void)vep->cb(vep->vc, vep->cb_priv, 0, VGZ_FINISH);	AZ(VSB_finish(vep->vsb));	l = VSB_len(vep->vsb);	if (vep->esi_found && l > 0)		return (vep->vsb);	VSB_destroy(&vep->vsb);	return (NULL);}

static voidvcc_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 voidinit_macro(void){	AZ(pthread_mutex_init(&macro_mtx, NULL));}

pan_ic(const char *func, const char *file, int line, const char *cond,    int err, enum vas_e kind){	const char *q;	struct req *req;	struct busyobj *bo;	AZ(pthread_mutex_lock(&panicstr_mtx)); /* Won't be released,						  we're going to die						  anyway */	switch(kind) {	case VAS_WRONG:		VSB_printf(pan_vsp,		    "Wrong turn at %s:%d:/n%s/n", file, line, cond);		break;	case VAS_VCL:		VSB_printf(pan_vsp,		    "Panic from VCL:/n  %s/n", cond);		break;	case VAS_MISSING:		VSB_printf(pan_vsp,		    "Missing errorhandling code in %s(), %s line %d:/n"		    "  Condition(%s) not true.",		    func, file, line, cond);		break;	case VAS_INCOMPLETE:		VSB_printf(pan_vsp,		    "Incomplete code in %s(), %s line %d:/n",		    func, file, line);		break;	default:	case VAS_ASSERT:		VSB_printf(pan_vsp,		    "Assert error in %s(), %s line %d:/n"		    "  Condition(%s) not true./n",		    func, file, line, cond);		break;	}	if (err)		VSB_printf(pan_vsp, "errno = %d (%s)/n", err, strerror(err));	q = THR_GetName();	if (q != NULL)		VSB_printf(pan_vsp, "thread = (%s)/n", q);	VSB_printf(pan_vsp, "ident = %s,%s/n",	    VSB_data(vident) + 1, WAIT_GetName());	pan_backtrace();	if (!FEATURE(FEATURE_SHORT_PANIC)) {		req = THR_GetRequest();		if (req != NULL) {			pan_req(req);			VSL_Flush(req->vsl, 0);		}		bo = THR_GetBusyobj();		if (bo != NULL) {			pan_busyobj(bo);			VSL_Flush(bo->vsl, 0);		}	}	VSB_printf(pan_vsp, "/n");	VSB_bcat(pan_vsp, "", 1);	/* NUL termination */	if (FEATURE(FEATURE_NO_COREDUMP))		exit(4);	else		abort();}

static void *mpl_guard(void *priv){	struct mempool *mpl;	struct memitem *mi = NULL;	double mpl_slp __state_variable__(mpl_slp);	double last = 0;	CAST_OBJ_NOTNULL(mpl, priv, MEMPOOL_MAGIC);	mpl_slp = 0.15;	// random	while (1) {		VTIM_sleep(mpl_slp);		mpl_slp = 0.814;	// random		mpl->t_now = VTIM_real();		if (mi != NULL && (mpl->n_pool > mpl->param->max_pool ||		    mi->size < *mpl->cur_size)) {			FREE_OBJ(mi);			mi = NULL;		}		if (mi == NULL && mpl->n_pool < mpl->param->min_pool)			mi = mpl_alloc(mpl);		if (mpl->n_pool < mpl->param->min_pool && mi != NULL) {			/* can do */		} else if (mpl->n_pool > mpl->param->max_pool && mi == NULL) {			/* can do */		} else if (!VTAILQ_EMPTY(&mpl->surplus)) {			/* can do */		} else if (last + .1 * mpl->param->max_age < mpl->t_now) {			/* should do */		} else if (mpl->self_destruct) {			/* can do */		} else {			continue;	/* nothing to do */		}		mpl_slp = 0.314;	// random		if (Lck_Trylock(&mpl->mtx))			continue;		if (mpl->self_destruct) {			AZ(mpl->live);			while (1) {				if (mi == NULL) {					mi = VTAILQ_FIRST(&mpl->list);					if (mi != NULL) {						mpl->vsc->pool = --mpl->n_pool;						VTAILQ_REMOVE(&mpl->list,						    mi, list);					}				}				if (mi == NULL) {					mi = VTAILQ_FIRST(&mpl->surplus);					if (mi != NULL)						VTAILQ_REMOVE(&mpl->surplus,						    mi, list);				}				if (mi == NULL)					break;				FREE_OBJ(mi);				mi = NULL;			}			VSM_Free(mpl->vsc);			Lck_Unlock(&mpl->mtx);			Lck_Delete(&mpl->mtx);			FREE_OBJ(mpl);			break;		}		if (mpl->n_pool < mpl->param->min_pool &&		    mi != NULL && mi->size >= *mpl->cur_size) {			CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);			mpl->vsc->pool = ++mpl->n_pool;			mi->touched = mpl->t_now;			VTAILQ_INSERT_HEAD(&mpl->list, mi, list);			mi = NULL;			mpl_slp = .01;	// random		}		if (mpl->n_pool > mpl->param->max_pool && mi == NULL) {			mi = VTAILQ_FIRST(&mpl->list);			CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);			mpl->vsc->pool = --mpl->n_pool;			mpl->vsc->surplus++;			VTAILQ_REMOVE(&mpl->list, mi, list);			mpl_slp = .01;	// random		}		if (mi == NULL) {			mi = VTAILQ_FIRST(&mpl->surplus);			if (mi != NULL) {				CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);				VTAILQ_REMOVE(&mpl->surplus, mi, list);				mpl_slp = .01;	// random			}		}		if (mi == NULL && mpl->n_pool > mpl->param->min_pool) {//.........这里部分代码省略.........

static voidved_stripgzip(struct req *req, struct busyobj *bo){	ssize_t start, last, stop, lpad;	ssize_t l;	char *p;	uint32_t icrc;	uint32_t ilen;	uint64_t olen;	uint8_t *dbits;	uint8_t *pp;	uint8_t tailbuf[8];	enum objiter_status ois;	void *oi;	void *sp;	ssize_t sl, ll, dl;	struct ecx *ecx;	struct req *preq;	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);	CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);	CAST_OBJ_NOTNULL(ecx, req->transport_priv, ECX_MAGIC);	preq = ecx->preq;	if (bo != NULL)		VBO_waitstate(bo, BOS_FINISHED);	AN(ObjCheckFlag(req->wrk, req->objcore, OF_GZIPED));	/*	 * This is the interesting case: Deliver all the deflate	 * blocks, stripping the "LAST" bit of the last one and	 * padding it, as necessary, to a byte boundary.	 */	p = ObjGetattr(req->wrk, req->objcore, OA_GZIPBITS, &l);	AN(p);	assert(l == 32);	start = vbe64dec(p);	last = vbe64dec(p + 8);	stop = vbe64dec(p + 16);	olen = ObjGetLen(req->wrk, req->objcore);	assert(start > 0 && start < olen * 8);	assert(last > 0 && last < olen * 8);	assert(stop > 0 && stop < olen * 8);	assert(last >= start);	assert(last < stop);	/* The start bit must be byte aligned. */	AZ(start & 7);	/*	 * XXX: optimize for the case where the 'last'	 * XXX: bit is in a empty copy block	 */	memset(tailbuf, 0xdd, sizeof tailbuf);	dbits = WS_Alloc(req->ws, 8);	AN(dbits);	ll = 0;	oi = ObjIterBegin(req->wrk, req->objcore);	do {		ois = ObjIter(req->objcore, oi, &sp, &sl);		pp = sp;		if (sl > 0) {			/* Skip over the GZIP header */			dl = start / 8 - ll;			if (dl > 0) {				/* Before start, skip */				if (dl > sl)					dl = sl;				ll += dl;				sl -= dl;				pp += dl;			}		}		if (sl > 0) {			/* The main body of the object */			dl = last / 8 - ll;			if (dl > 0) {				if (dl > sl)					dl = sl;				if (ved_bytes(req, preq, VDP_NULL, pp, dl))					break;				ll += dl;				sl -= dl;				pp += dl;			}		}		if (sl > 0 && ll == last / 8) {			/* Remove the "LAST" bit */			dbits[0] = *pp;			dbits[0] &= ~(1U << (last & 7));			if (ved_bytes(req, preq, VDP_NULL, dbits, 1))				break;			ll++;			sl--;			pp++;		}		if (sl > 0) {//.........这里部分代码省略.........

voidVBF_Fetch(struct worker *wrk, struct req *req, struct objcore *oc,    struct objcore *oldoc, enum vbf_fetch_mode_e mode){	struct boc *boc;	struct busyobj *bo;	const char *how;	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);	CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);	AN(oc->flags & OC_F_BUSY);	CHECK_OBJ_ORNULL(oldoc, OBJCORE_MAGIC);	bo = VBO_GetBusyObj(wrk, req);	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);	boc = HSH_RefBoc(oc);	CHECK_OBJ_NOTNULL(boc, BOC_MAGIC);	switch (mode) {	case VBF_PASS:		how = "pass";		bo->do_pass = 1;		break;	case VBF_NORMAL:		how = "fetch";		break;	case VBF_BACKGROUND:		how = "bgfetch";		bo->is_bgfetch = 1;		break;	default:		WRONG("Wrong fetch mode");	}	VSLb(bo->vsl, SLT_Begin, "bereq %u %s", VXID(req->vsl->wid), how);	VSLb(req->vsl, SLT_Link, "bereq %u %s", VXID(bo->vsl->wid), how);	THR_SetBusyobj(bo);	bo->sp = req->sp;	SES_Ref(bo->sp);	AN(bo->vcl);	oc->boc->vary = req->vary_b;	req->vary_b = NULL;	HSH_Ref(oc);	AZ(bo->fetch_objcore);	bo->fetch_objcore = oc;	AZ(bo->stale_oc);	if (oldoc != NULL) {		assert(oldoc->refcnt > 0);		HSH_Ref(oldoc);		bo->stale_oc = oldoc;	}	AZ(bo->req);	bo->req = req;	bo->fetch_task.priv = bo;	bo->fetch_task.func = vbf_fetch_thread;	if (Pool_Task(wrk->pool, &bo->fetch_task, TASK_QUEUE_BO)) {		wrk->stats->fetch_no_thread++;		(void)vbf_stp_fail(req->wrk, bo);		if (bo->stale_oc != NULL)			(void)HSH_DerefObjCore(wrk, &bo->stale_oc, 0);		HSH_DerefBoc(wrk, oc);		SES_Rel(bo->sp);		VBO_ReleaseBusyObj(wrk, &bo);	} else {		bo = NULL; /* ref transferred to fetch thread */		if (mode == VBF_BACKGROUND) {			ObjWaitState(oc, BOS_REQ_DONE);			(void)VRB_Ignore(req);		} else {			ObjWaitState(oc, BOS_STREAM);			if (oc->boc->state == BOS_FAILED) {				AN((oc->flags & OC_F_FAILED));			} else {				AZ(oc->flags & OC_F_BUSY);			}		}	}	AZ(bo);	VSLb_ts_req(req, "Fetch", W_TIM_real(wrk));	assert(oc->boc == boc);	HSH_DerefBoc(wrk, oc);	if (mode == VBF_BACKGROUND)		(void)HSH_DerefObjCore(wrk, &oc, HSH_RUSH_POLICY);	THR_SetBusyobj(NULL);}

vbf_fetch_thread(struct worker *wrk, void *priv){	struct busyobj *bo;	enum fetch_step stp;	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);	CAST_OBJ_NOTNULL(bo, priv, BUSYOBJ_MAGIC);	CHECK_OBJ_NOTNULL(bo->req, REQ_MAGIC);	CHECK_OBJ_NOTNULL(bo->fetch_objcore, OBJCORE_MAGIC);	THR_SetBusyobj(bo);	stp = F_STP_MKBEREQ;	assert(isnan(bo->t_first));	assert(isnan(bo->t_prev));	VSLb_ts_busyobj(bo, "Start", W_TIM_real(wrk));	bo->wrk = wrk;	wrk->vsl = bo->vsl;#if 0	if (bo->stale_oc != NULL) {		CHECK_OBJ_NOTNULL(bo->stale_oc, OBJCORE_MAGIC);		/* We don't want the oc/stevedore ops in fetching thread */		if (!ObjCheckFlag(wrk, bo->stale_oc, OF_IMSCAND))			(void)HSH_DerefObjCore(wrk, &bo->stale_oc, 0);	}#endif	while (stp != F_STP_DONE) {		CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);		assert(bo->fetch_objcore->boc->refcount >= 1);		switch (stp) {#define FETCH_STEP(l, U, arg)						/		case F_STP_##U:						/			stp = vbf_stp_##l arg;				/			break;#include "tbl/steps.h"		default:			WRONG("Illegal fetch_step");		}	}	assert(bo->director_state == DIR_S_NULL);	http_Teardown(bo->bereq);	http_Teardown(bo->beresp);	if (bo->fetch_objcore->boc->state == BOS_FINISHED) {		AZ(bo->fetch_objcore->flags & OC_F_FAILED);		VSLb(bo->vsl, SLT_Length, "%ju",		    (uintmax_t)ObjGetLen(bo->wrk, bo->fetch_objcore));	}	// AZ(bo->fetch_objcore->boc);	// XXX	if (bo->stale_oc != NULL)		(void)HSH_DerefObjCore(wrk, &bo->stale_oc, 0);	wrk->vsl = NULL;	HSH_DerefBoc(wrk, bo->fetch_objcore);	SES_Rel(bo->sp);	VBO_ReleaseBusyObj(wrk, &bo);	THR_SetBusyobj(NULL);}

static enum fetch_stepvbf_stp_fetch(struct worker *wrk, struct busyobj *bo){	const char *p;	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);	CHECK_OBJ_NOTNULL(bo->fetch_objcore, OBJCORE_MAGIC);	assert(wrk->handling == VCL_RET_DELIVER);	if (vbf_figure_out_vfp(bo)) {		(bo)->htc->doclose = SC_OVERLOAD;		VDI_Finish((bo)->wrk, bo);		return (F_STP_ERROR);	}	if (bo->fetch_objcore->flags & OC_F_PRIVATE)		AN(bo->uncacheable);	bo->fetch_objcore->boc->len_so_far = 0;	if (VFP_Open(bo->vfc)) {		(void)VFP_Error(bo->vfc, "Fetch pipeline failed to open");		bo->htc->doclose = SC_RX_BODY;		VDI_Finish(bo->wrk, bo);		return (F_STP_ERROR);	}	if (vbf_beresp2obj(bo)) {		(void)VFP_Error(bo->vfc, "Could not get storage");		bo->htc->doclose = SC_RX_BODY;		VFP_Close(bo->vfc);		VDI_Finish(bo->wrk, bo);		return (F_STP_ERROR);	}	if (bo->do_esi)		ObjSetFlag(bo->wrk, bo->fetch_objcore, OF_ESIPROC, 1);	if (bo->do_gzip || (bo->is_gzip && !bo->do_gunzip))		ObjSetFlag(bo->wrk, bo->fetch_objcore, OF_GZIPED, 1);	if (bo->do_gzip || bo->do_gunzip)		ObjSetFlag(bo->wrk, bo->fetch_objcore, OF_CHGGZIP, 1);	if (!(bo->fetch_objcore->flags & OC_F_PASS) &&	    http_IsStatus(bo->beresp, 200) && (	      http_GetHdr(bo->beresp, H_Last_Modified, &p) ||	      http_GetHdr(bo->beresp, H_ETag, &p)))		ObjSetFlag(bo->wrk, bo->fetch_objcore, OF_IMSCAND, 1);	if (bo->htc->body_status != BS_NONE &&	    VDI_GetBody(bo->wrk, bo) != 0) {		(void)VFP_Error(bo->vfc,		    "GetBody failed - workspace_backend overflow?");		VFP_Close(bo->vfc);		bo->htc->doclose = SC_OVERLOAD;		VDI_Finish(bo->wrk, bo);		return (F_STP_ERROR);	}	assert(bo->fetch_objcore->boc->refcount >= 1);	assert(bo->fetch_objcore->boc->state == BOS_REQ_DONE);	if (bo->do_stream) {		ObjSetState(wrk, bo->fetch_objcore, BOS_PREP_STREAM);		HSH_Unbusy(wrk, bo->fetch_objcore);		ObjSetState(wrk, bo->fetch_objcore, BOS_STREAM);	}	VSLb(bo->vsl, SLT_Fetch_Body, "%u %s %s",	    bo->htc->body_status, body_status_2str(bo->htc->body_status),	    bo->do_stream ? "stream" : "-");	if (bo->htc->body_status != BS_NONE) {		assert(bo->htc->body_status != BS_ERROR);		return (F_STP_FETCHBODY);	}	AZ(bo->vfc->failed);	return (F_STP_FETCHEND);}

static enum fetch_stepvbf_stp_startfetch(struct worker *wrk, struct busyobj *bo){	int i;	double now;	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);	AZ(bo->storage);	bo->storage = bo->do_pass ? stv_transient : STV_next();	if (bo->retries > 0)		http_Unset(bo->bereq, "/012X-Varnish:");	http_PrintfHeader(bo->bereq, "X-Varnish: %u", VXID(bo->vsl->wid));	VCL_backend_fetch_method(bo->vcl, wrk, NULL, bo, NULL);	bo->uncacheable = bo->do_pass;	if (wrk->handling == VCL_RET_ABANDON || wrk->handling == VCL_RET_FAIL)		return (F_STP_FAIL);	assert (wrk->handling == VCL_RET_FETCH);	HTTP_Setup(bo->beresp, bo->ws, bo->vsl, SLT_BerespMethod);	assert(bo->fetch_objcore->boc->state <= BOS_REQ_DONE);	AZ(bo->htc);	VFP_Setup(bo->vfc, wrk);	bo->vfc->oc = bo->fetch_objcore;	bo->vfc->resp = bo->beresp;	bo->vfc->req = bo->bereq;	i = VDI_GetHdr(wrk, bo);	now = W_TIM_real(wrk);	VSLb_ts_busyobj(bo, "Beresp", now);	if (i) {		assert(bo->director_state == DIR_S_NULL);		return (F_STP_ERROR);	}	http_VSL_log(bo->beresp);	if (bo->htc->body_status == BS_ERROR) {		bo->htc->doclose = SC_RX_BODY;		VDI_Finish(bo->wrk, bo);		VSLb(bo->vsl, SLT_Error, "Body cannot be fetched");		assert(bo->director_state == DIR_S_NULL);		return (F_STP_ERROR);	}	if (!http_GetHdr(bo->beresp, H_Date, NULL)) {		/*		 * RFC 2616 14.18 Date: The Date general-header field		 * represents the date and time at which the message was		 * originated, having the same semantics as orig-date in		 * RFC 822. ... A received message that does not have a		 * Date header field MUST be assigned one by the recipient		 * if the message will be cached by that recipient or		 * gatewayed via a protocol which requires a Date.		 *		 * If we didn't get a Date header, we assign one here.		 */		http_TimeHeader(bo->beresp, "Date: ", now);	}	/*	 * These two headers can be spread over multiple actual headers	 * and we rely on their content outside of VCL, so collect them	 * into one line here.	 */	http_CollectHdr(bo->beresp, H_Cache_Control);	http_CollectHdr(bo->beresp, H_Vary);	if (bo->fetch_objcore->flags & OC_F_PRIVATE) {		/* private objects have negative TTL */		bo->fetch_objcore->t_origin = now;		bo->fetch_objcore->ttl = -1.;		bo->fetch_objcore->grace = 0;		bo->fetch_objcore->keep = 0;	} else {		/* What does RFC2616 think about TTL ? */		RFC2616_Ttl(bo, now,		    &bo->fetch_objcore->t_origin,		    &bo->fetch_objcore->ttl,		    &bo->fetch_objcore->grace,		    &bo->fetch_objcore->keep		    );	}	AZ(bo->do_esi);	AZ(bo->was_304);	if (http_IsStatus(bo->beresp, 304)) {		if (bo->stale_oc != NULL &&//.........这里部分代码省略.........

static enum fetch_stepvbf_stp_fetchbody(struct worker *wrk, struct busyobj *bo){	ssize_t l;	uint8_t *ptr;	enum vfp_status vfps = VFP_ERROR;	ssize_t est;	struct vfp_ctx *vfc;	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);	vfc = bo->vfc;	CHECK_OBJ_NOTNULL(vfc, VFP_CTX_MAGIC);	AN(vfc->vfp_nxt);	est = bo->htc->content_length;	if (est < 0)		est = 0;	do {		if (vfc->oc->flags & OC_F_ABANDON) {			/*			 * A pass object and delivery was terminated			 * We don't fail the fetch, in order for hit-for-pass			 * objects to be created.			 */			AN(vfc->oc->flags & OC_F_PASS);			VSLb(wrk->vsl, SLT_Debug,			    "Fetch: Pass delivery abandoned");			bo->htc->doclose = SC_RX_BODY;			break;		}		AZ(vfc->failed);		l = est;		assert(l >= 0);		if (VFP_GetStorage(vfc, &l, &ptr) != VFP_OK) {			bo->htc->doclose = SC_RX_BODY;			break;		}		AZ(vfc->failed);		vfps = VFP_Suck(vfc, ptr, &l);		if (l > 0 && vfps != VFP_ERROR) {			bo->acct.beresp_bodybytes += l;			VFP_Extend(vfc, l);			if (est >= l)				est -= l;			else				est = 0;		}	} while (vfps == VFP_OK);	if (vfc->failed) {		(void)VFP_Error(vfc, "Fetch pipeline failed to process");		bo->htc->doclose = SC_RX_BODY;		VFP_Close(vfc);		VDI_Finish(wrk, bo);		if (!bo->do_stream) {			assert(bo->fetch_objcore->boc->state < BOS_STREAM);			// XXX: doclose = ?			return (F_STP_ERROR);		} else {			wrk->stats->fetch_failed++;			return (F_STP_FAIL);		}	}	ObjTrimStore(wrk, vfc->oc);	return (F_STP_FETCHEND);}

static voidvxp_expr_lhs(struct vxp *vxp, struct vex_lhs **plhs){	char *p;	int i;	AN(plhs);	AZ(*plhs);	ALLOC_OBJ(*plhs, VEX_LHS_MAGIC);	AN(*plhs);	(*plhs)->tags = vbit_init(SLT__MAX);	(*plhs)->level = -1;	if (vxp->t->tok == '{') {		/* Transaction level limits */		vxp_NextToken(vxp);		if (vxp->t->tok != VAL) {			VSB_printf(vxp->sb, "Expected integer got '%.*s' ",			    PF(vxp->t));			vxp_ErrWhere(vxp, vxp->t, -1);			return;		}		(*plhs)->level = (int)strtol(vxp->t->dec, &p, 0);		if ((*plhs)->level < 0) {			VSB_printf(vxp->sb, "Expected positive integer ");			vxp_ErrWhere(vxp, vxp->t, -1);			return;		}		if (*p == '-') {			(*plhs)->level_pm = -1;			p++;		} else if (*p == '+') {			(*plhs)->level_pm = 1;			p++;		}		if (*p) {			VSB_printf(vxp->sb, "Syntax error in level limit ");			vxp_ErrWhere(vxp, vxp->t, -1);			return;		}		vxp_NextToken(vxp);		ExpectErr(vxp, '}');		vxp_NextToken(vxp);	}	while (1) {		/* The tags this expression applies to */		if (vxp->t->tok != VAL) {			VSB_printf(vxp->sb, "Expected VSL tag name got '%.*s' ",			    PF(vxp->t));			vxp_ErrWhere(vxp, vxp->t, -1);			return;		}		i = VSL_Glob2Tags(vxp->t->dec, -1, vsl_vbm_bitset,		    (*plhs)->tags);		if (i == -1) {			VSB_printf(vxp->sb, "Tag name matches zero tags ");			vxp_ErrWhere(vxp, vxp->t, -1);			return;		}		if (i == -2) {			VSB_printf(vxp->sb, "Tag name is ambiguous ");			vxp_ErrWhere(vxp, vxp->t, -1);			return;		}		if (i == -3) {			VSB_printf(vxp->sb, "Syntax error in tag name ");			vxp_ErrWhere(vxp, vxp->t, -1);			return;		}		assert(i > 0);		vxp_NextToken(vxp);		if (vxp->t->tok != ',')			break;		vxp_NextToken(vxp);	}	if (vxp->t->tok == ':') {		/* Record prefix */		vxp_NextToken(vxp);		if (vxp->t->tok != VAL) {			VSB_printf(vxp->sb, "Expected string got '%.*s' ",			    PF(vxp->t));			vxp_ErrWhere(vxp, vxp->t, -1);			return;		}		AN(vxp->t->dec);		(*plhs)->prefix = strdup(vxp->t->dec);		AN((*plhs)->prefix);		(*plhs)->prefixlen = strlen((*plhs)->prefix);		vxp_NextToken(vxp);	}	if (vxp->t->tok == '[') {		/* LHS field [] */		vxp_NextToken(vxp);		if (vxp->t->tok != VAL) {			VSB_printf(vxp->sb, "Expected integer got '%.*s' ",			    PF(vxp->t));			vxp_ErrWhere(vxp, vxp->t, -1);//.........这里部分代码省略.........

static enum fetch_stepvbf_stp_error(struct worker *wrk, struct busyobj *bo){	ssize_t l, ll, o;	double now;	uint8_t *ptr;	struct vsb *synth_body;	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);	CHECK_OBJ_NOTNULL(bo, BUSYOBJ_MAGIC);	CHECK_OBJ_NOTNULL(bo->fetch_objcore, OBJCORE_MAGIC);	AN(bo->fetch_objcore->flags & OC_F_BUSY);	assert(bo->director_state == DIR_S_NULL);	wrk->stats->fetch_failed++;	now = W_TIM_real(wrk);	VSLb_ts_busyobj(bo, "Error", now);	if (bo->fetch_objcore->stobj->stevedore != NULL)		ObjFreeObj(bo->wrk, bo->fetch_objcore);	if (bo->storage == NULL)		bo->storage = STV_next();	// XXX: reset all beresp flags ?	HTTP_Setup(bo->beresp, bo->ws, bo->vsl, SLT_BerespMethod);	http_PutResponse(bo->beresp, "HTTP/1.1", 503, "Backend fetch failed");	http_TimeHeader(bo->beresp, "Date: ", now);	http_SetHeader(bo->beresp, "Server: Varnish");	bo->fetch_objcore->t_origin = now;	if (!VTAILQ_EMPTY(&bo->fetch_objcore->objhead->waitinglist)) {		/*		 * If there is a waitinglist, it means that there is no		 * grace-able object, so cache the error return for a		 * short time, so the waiting list can drain, rather than		 * each objcore on the waiting list sequentially attempt		 * to fetch from the backend.		 */		bo->fetch_objcore->ttl = 1;		bo->fetch_objcore->grace = 5;		bo->fetch_objcore->keep = 5;	} else {		bo->fetch_objcore->ttl = 0;		bo->fetch_objcore->grace = 0;		bo->fetch_objcore->keep = 0;	}	synth_body = VSB_new_auto();	AN(synth_body);	VCL_backend_error_method(bo->vcl, wrk, NULL, bo, synth_body);	AZ(VSB_finish(synth_body));	if (wrk->handling == VCL_RET_ABANDON || wrk->handling == VCL_RET_FAIL) {		VSB_destroy(&synth_body);		return (F_STP_FAIL);	}	if (wrk->handling == VCL_RET_RETRY) {		VSB_destroy(&synth_body);		if (bo->retries++ < cache_param->max_retries)			return (F_STP_RETRY);		VSLb(bo->vsl, SLT_VCL_Error, "Too many retries, failing");		return (F_STP_FAIL);	}	assert(wrk->handling == VCL_RET_DELIVER);	assert(bo->vfc->wrk == bo->wrk);	assert(bo->vfc->oc == bo->fetch_objcore);	assert(bo->vfc->resp == bo->beresp);	assert(bo->vfc->req == bo->bereq);	if (vbf_beresp2obj(bo)) {		(void)VFP_Error(bo->vfc, "Could not get storage");		VSB_destroy(&synth_body);		return (F_STP_FAIL);	}	ll = VSB_len(synth_body);	o = 0;	while (ll > 0) {		l = ll;		if (VFP_GetStorage(bo->vfc, &l, &ptr) != VFP_OK)			break;		if (l > ll)			l = ll;		memcpy(ptr, VSB_data(synth_body) + o, l);		VFP_Extend(bo->vfc, l);		ll -= l;		o += l;	}	AZ(ObjSetU64(wrk, bo->fetch_objcore, OA_LEN, o));	VSB_destroy(&synth_body);	HSH_Unbusy(wrk, bo->fetch_objcore);	ObjSetState(wrk, bo->fetch_objcore, BOS_FINISHED);//.........这里部分代码省略.........

static voidvca_ports_init(void){	AZ(pthread_create(&vca_ports_thread, NULL, vca_main, NULL));}

static intvbf_beresp2obj(struct busyobj *bo){	unsigned l, l2;	const char *b;	uint8_t *bp;	struct vsb *vary = NULL;	int varyl = 0;	l = 0;	/* Create Vary instructions */	if (!(bo->fetch_objcore->flags & OC_F_PRIVATE)) {		varyl = VRY_Create(bo, &vary);		if (varyl > 0) {			AN(vary);			assert(varyl == VSB_len(vary));			l += PRNDUP((intptr_t)varyl);		} else if (varyl < 0) {			/*			 * Vary parse error			 * Complain about it, and make this a pass.			 */			VSLb(bo->vsl, SLT_Error,			    "Illegal 'Vary' header from backend, "			    "making this a pass.");			bo->uncacheable = 1;			AZ(vary);		} else			/* No vary */			AZ(vary);	}	l2 = http_EstimateWS(bo->beresp,	    bo->uncacheable ? HTTPH_A_PASS : HTTPH_A_INS);	l += l2;	if (bo->uncacheable)		bo->fetch_objcore->flags |= OC_F_PASS;	if (!vbf_allocobj(bo, l)) {		if (vary != NULL)			VSB_destroy(&vary);		AZ(vary);		return (-1);	}	if (vary != NULL) {		AN(ObjSetAttr(bo->wrk, bo->fetch_objcore, OA_VARY, varyl,			VSB_data(vary)));		VSB_destroy(&vary);	}	AZ(ObjSetU32(bo->wrk, bo->fetch_objcore, OA_VXID, VXID(bo->vsl->wid)));	/* for HTTP_Encode() VSLH call */	bo->beresp->logtag = SLT_ObjMethod;	/* Filter into object */	bp = ObjSetAttr(bo->wrk, bo->fetch_objcore, OA_HEADERS, l2, NULL);	AN(bp);	HTTP_Encode(bo->beresp, bp, l2,	    bo->uncacheable ? HTTPH_A_PASS : HTTPH_A_INS);	if (http_GetHdr(bo->beresp, H_Last_Modified, &b))		AZ(ObjSetDouble(bo->wrk, bo->fetch_objcore, OA_LASTMODIFIED,		    VTIM_parse(b)));	else		AZ(ObjSetDouble(bo->wrk, bo->fetch_objcore, OA_LASTMODIFIED,		    floor(bo->fetch_objcore->t_origin)));	return (0);}

voidchild_main(void){	setbuf(stdout, NULL);	setbuf(stderr, NULL);	printf("Child starts/n");	cache_param = heritage.param;	AZ(pthread_key_create(&req_key, NULL));	AZ(pthread_key_create(&bo_key, NULL));	AZ(pthread_key_create(&name_key, NULL));	THR_SetName("cache-main");	VSM_Init();	/* First, LCK needs it. */	LCK_Init();	/* Second, locking */	Lck_New(&vxid_lock, lck_vxid);	CLI_Init();	PAN_Init();	VFP_Init();	VCL_Init();	HTTP_Init();	VBO_Init();	VBP_Init();	VBE_InitCfg();	Pool_Init();	V1P_Init();	EXP_Init();	HSH_Init(heritage.hash);	BAN_Init();	VCA_Init();	SMP_Init();	STV_open();	VMOD_Init();	BAN_Compile();	VRND_Seed();	srand48(random());	CLI_AddFuncs(debug_cmds);	/* Wait for persistent storage to load if asked to */	if (FEATURE(FEATURE_WAIT_SILO))		SMP_Ready();	CLI_Run();	BAN_Shutdown();	STV_close();	printf("Child dies/n");}

VDP_ESI(struct req *req, enum vdp_action act, void **priv,    const void *ptr, ssize_t len){	uint8_t *q, *r;	ssize_t l = 0;	uint32_t icrc = 0;	uint8_t tailbuf[8 + 5];	const uint8_t *pp;	struct ecx *ecx, *pecx;	int retval = 0;	if (act == VDP_INIT) {		AZ(*priv);		ALLOC_OBJ(ecx, ECX_MAGIC);		AN(ecx);		ecx->preq = req;		*priv = ecx;		return (0);	}	CAST_OBJ_NOTNULL(ecx, *priv, ECX_MAGIC);	if (act == VDP_FINI) {		FREE_OBJ(ecx);		*priv = NULL;		return (0);	}	pp = ptr;	while (1) {		switch (ecx->state) {		case 0:			ecx->p = ObjGetattr(req->wrk, req->objcore,			    OA_ESIDATA, &l);			AN(ecx->p);			assert(l > 0);			ecx->e = ecx->p + l;			if (*ecx->p == VEC_GZ) {				ecx->isgzip = 1;				ecx->p++;			}			if (req->esi_level == 0) {				/*				 * Only the top level document gets to				 * decide this.				 */				if (ecx->isgzip) {					assert(sizeof gzip_hdr == 10);					/* Send out the gzip header */					retval = VDP_bytes(req, VDP_NULL,					    gzip_hdr, 10);					ecx->l_crc = 0;					ecx->crc = crc32(0L, Z_NULL, 0);				}			}			ecx->state = 1;			break;		case 1:			if (ecx->p >= ecx->e) {				ecx->state = 2;				break;			}			switch (*ecx->p) {			case VEC_V1:			case VEC_V2:			case VEC_V8:				ecx->l = ved_decode_len(req, &ecx->p);				if (ecx->l < 0)					return (-1);				if (ecx->isgzip) {					assert(*ecx->p == VEC_C1 ||					    *ecx->p == VEC_C2 ||					    *ecx->p == VEC_C8);					l = ved_decode_len(req, &ecx->p);					if (l < 0)						return (-1);					icrc = vbe32dec(ecx->p);					ecx->p += 4;					if (ecx->isgzip) {						ecx->crc = crc32_combine(						    ecx->crc, icrc, l);						ecx->l_crc += l;					}				}				ecx->state = 3;				break;			case VEC_S1:			case VEC_S2:			case VEC_S8:				ecx->l = ved_decode_len(req, &ecx->p);				if (ecx->l < 0)					return (-1);				Debug("SKIP1(%d)/n", (int)ecx->l);				ecx->state = 4;				break;			case VEC_INCL:				ecx->p++;				q = (void*)strchr((const char*)ecx->p, '/0');				AN(q);//.........这里部分代码省略.........

voidTHR_SetBusyobj(const struct busyobj *bo){	AZ(pthread_setspecific(bo_key, bo));}

static voidved_include(struct req *preq, const char *src, const char *host,    struct ecx *ecx){	struct worker *wrk;	struct req *req;	enum req_fsm_nxt s;	struct transport xp;	CHECK_OBJ_NOTNULL(preq, REQ_MAGIC);	CHECK_OBJ_NOTNULL(ecx, ECX_MAGIC);	wrk = preq->wrk;	if (preq->esi_level >= cache_param->max_esi_depth)		return;	req = Req_New(wrk, preq->sp);	req->req_body_status = REQ_BODY_NONE;	AZ(req->vsl->wid);	req->vsl->wid = VXID_Get(wrk, VSL_CLIENTMARKER);	VSLb(req->vsl, SLT_Begin, "req %u esi", VXID(preq->vsl->wid));	VSLb(preq->vsl, SLT_Link, "req %u esi", VXID(req->vsl->wid));	req->esi_level = preq->esi_level + 1;	if (preq->esi_level == 0)		assert(preq->top == preq);	else		CHECK_OBJ_NOTNULL(preq->top, REQ_MAGIC);	req->top = preq->top;	HTTP_Copy(req->http0, preq->http0);	req->http0->ws = req->ws;	req->http0->vsl = req->vsl;	req->http0->logtag = SLT_ReqMethod;	req->http0->conds = 0;	http_SetH(req->http0, HTTP_HDR_URL, src);	if (host != NULL && *host != '/0')  {		http_Unset(req->http0, H_Host);		http_SetHeader(req->http0, host);	}	http_ForceField(req->http0, HTTP_HDR_METHOD, "GET");	http_ForceField(req->http0, HTTP_HDR_PROTO, "HTTP/1.1");	/* Don't allow conditionalss, we can't use a 304 */	http_Unset(req->http0, H_If_Modified_Since);	http_Unset(req->http0, H_If_None_Match);	/* Don't allow Range */	http_Unset(req->http0, H_Range);	/* Set Accept-Encoding according to what we want */	http_Unset(req->http0, H_Accept_Encoding);	if (ecx->isgzip)		http_ForceHeader(req->http0, H_Accept_Encoding, "gzip");	/* Client content already taken care of */	http_Unset(req->http0, H_Content_Length);	/* Reset request to status before we started messing with it */	HTTP_Copy(req->http, req->http0);	req->vcl = preq->vcl;	preq->vcl = NULL;	req->wrk = preq->wrk;	/*	 * XXX: We should decide if we should cache the director	 * XXX: or not (for session/backend coupling).  Until then	 * XXX: make sure we don't trip up the check in vcl_recv.	 */	req->req_step = R_STP_RECV;	req->t_req = preq->t_req;	assert(isnan(req->t_first));	assert(isnan(req->t_prev));	INIT_OBJ(&xp, TRANSPORT_MAGIC);	xp.deliver = VED_Deliver;	req->transport = &xp;	req->transport_priv = ecx;	THR_SetRequest(req);	VSLb_ts_req(req, "Start", W_TIM_real(wrk));	req->ws_req = WS_Snapshot(req->ws);	while (1) {		req->wrk = wrk;		s = CNT_Request(wrk, req);		if (s == REQ_FSM_DONE)			break;		DSL(DBG_WAITINGLIST, req->vsl->wid,		    "loop waiting for ESI (%d)", (int)s);		assert(s == REQ_FSM_DISEMBARK);		AZ(req->wrk);		(void)usleep(10000);//.........这里部分代码省略.........

voidTHR_SetRequest(const struct req *req){	AZ(pthread_setspecific(req_key, req));}