static int
mb_put_acl(mbchain_t *mbp, i_ntacl_t *acl)
{
i_ntace_t **acep;
uint16_t acl_len, *acl_len_p;
int i, cnt0, error;
cnt0 = mbp->mb_count;
ERRCHK(mb_put_uint8(mbp, acl->acl_revision));
ERRCHK(mb_put_uint8(mbp, 0)); /* pad1 */
acl_len_p = mb_reserve(mbp, sizeof (*acl_len_p));
if (acl_len_p == NULL) {
error = ENOMEM;
goto errout;
}
ERRCHK(mb_put_uint16le(mbp, acl->acl_acecount));
ERRCHK(mb_put_uint16le(mbp, 0)); /* pad2 */
acep = &acl->acl_acevec[0];
for (i = 0; i < acl->acl_acecount; i++) {
ERRCHK(mb_put_ace(mbp, *acep));
acep++;
}
/* Fill in acl_len_p */
acl_len = mbp->mb_count - cnt0;
*acl_len_p = htoles(acl_len);
/* Success! */
return (0);
errout:
return (error);
}
static void
vcc_ParseVcl(struct vcc *tl)
{
struct token *tok;
assert(vcc_IdIs(tl->t, "vcl"));
vcc_NextToken(tl);
tok = tl->t;
tok->src->syntax = vcc_DoubleVal(tl);
ERRCHK(tl);
if (tl->t->e - tok->b > 4) {
VSB_printf(tl->sb,
"Don't play silly buggers with VCL version numbers\n");
vcc_ErrWhere2(tl, tok, tl->t);
ERRCHK(tl);
}
if (tl->syntax != 0.0 && tok->src->syntax > tl->syntax) {
VSB_printf(tl->sb,
"VCL version %.1f higher than"
" the top level version %.1f\n",
tok->src->syntax, tl->syntax);
vcc_ErrWhere2(tl, tok, tl->t);
ERRCHK(tl);
}
ExpectErr(tl, ';');
vcc_NextToken(tl);
}
static void
vcc_expr0(struct vcc *tl, struct expr **e, enum var_type fmt)
{
struct expr *e2;
struct token *tk;
*e = NULL;
vcc_expr_cand(tl, e, fmt);
ERRCHK(tl);
if ((*e)->fmt != BOOL || tl->t->tok != T_COR)
return;
*e = vcc_expr_edit(BOOL, "(\v+\n\v1", *e, NULL);
while (tl->t->tok == T_COR) {
vcc_NextToken(tl);
tk = tl->t;
vcc_expr_cand(tl, &e2, fmt);
ERRCHK(tl);
if (e2->fmt != BOOL) {
VSB_printf(tl->sb,
"'||' must be followed by BOOL, found ");
VSB_printf(tl->sb, "%s.\n", vcc_Type(e2->fmt));
vcc_ErrWhere2(tl, tk, tl->t);
return;
}
*e = vcc_expr_edit(BOOL, "\v1\v-\n||\v+\n\v2", *e, e2);
}
*e = vcc_expr_edit(BOOL, "\v1\v-\n)", *e, NULL);
}
/*===========================================================================*
*
* Bitio_New
*
* Create a new bit bucket; filePtr is a pointer to the open file the
* bits should ultimately be written to.
*
* RETURNS: pointer to the resulting bit bucket
*
* SIDE EFFECTS: none
*
*===========================================================================*/
BitBucket *
Bitio_New(FILE * const filePtr) {
BitBucket *bbPtr;
bbPtr = (BitBucket *) malloc(sizeof(BitBucket));
ERRCHK(bbPtr, "malloc");
bbPtr->firstPtr = bbPtr->lastPtr = malloc(sizeof(struct bitBucket));
ERRCHK(bbPtr->firstPtr, "malloc");
bbPtr->totalbits = 0;
bbPtr->cumulativeBits = 0;
bbPtr->bitsWritten = 0;
bbPtr->filePtr = filePtr;
bbPtr->firstPtr->nextPtr = NULL;
bbPtr->firstPtr->bitsleft = MAXBITS_PER_BUCKET;
bbPtr->firstPtr->bitsleftcur = 32;
bbPtr->firstPtr->currword = 0;
memset((char *)bbPtr->firstPtr->bits, 0,
sizeof(uint32) * WORDS_PER_BUCKET);
return bbPtr;
}
static int
mb_put_sid(mbchain_t *mbp, i_ntsid_t *sid)
{
uint32_t *subauthp;
int error, i;
if (sid == NULL)
return (EINVAL);
ERRCHK(mb_put_uint8(mbp, sid->sid_revision));
ERRCHK(mb_put_uint8(mbp, sid->sid_subauthcount));
ERRCHK(mb_put_mem(mbp, sid->sid_authority, 6, MB_MSYSTEM));
subauthp = &sid->sid_subauthvec[0];
for (i = 0; i < sid->sid_subauthcount; i++) {
ERRCHK(mb_put_uint32le(mbp, *subauthp));
subauthp++;
}
/* Success! */
return (0);
errout:
return (error);
}
void
vcc_Expr(struct vcc *tl, enum var_type fmt)
{
struct expr *e;
struct token *t1;
assert(fmt != VOID);
t1 = tl->t;
vcc_expr0(tl, &e, fmt);
ERRCHK(tl);
e->t1 = t1;
if (fmt == STRING || fmt == STRING_LIST) {
vcc_expr_tostring(tl, &e, fmt);
ERRCHK(tl);
}
if (!tl->err && fmt != e->fmt) {
VSB_printf(tl->sb, "Expression has type %s, expected %s\n",
vcc_Type(e->fmt), vcc_Type(fmt));
tl->err = 1;
}
if (!tl->err) {
if (e->fmt == STRING_LIST) {
e = vcc_expr_edit(STRING_LIST,
"\v+\n\v1,\nvrt_magic_string_end\v-", e, NULL);
}
vcc_expr_fmt(tl->fb, tl->indent, e);
VSB_putc(tl->fb, '\n');
} else {
if (t1 != tl->t)
vcc_ErrWhere2(tl, t1, tl->t);
}
vcc_delete_expr(e);
}
static void
vcc_Compound(struct vcc *tl)
{
int i;
SkipToken(tl, '{');
Fb(tl, 1, "{\n");
tl->indent += INDENT;
C(tl, ";");
while (1) {
ERRCHK(tl);
switch (tl->t->tok) {
case '{':
vcc_Compound(tl);
break;
case '}':
vcc_NextToken(tl);
tl->indent -= INDENT;
Fb(tl, 1, "}\n");
return;
case CSRC:
if (tl->allow_inline_c) {
Fb(tl, 1, "%.*s\n",
(int) (tl->t->e - (tl->t->b + 2)),
tl->t->b + 1);
vcc_NextToken(tl);
} else {
VSB_printf(tl->sb,
"Inline-C not allowed\n");
vcc_ErrWhere(tl, tl->t);
}
break;
case EOI:
VSB_printf(tl->sb,
"End of input while in compound statement\n");
tl->err = 1;
return;
case ID:
if (vcc_IdIs(tl->t, "if")) {
vcc_IfStmt(tl);
break;
} else {
i = vcc_ParseAction(tl);
ERRCHK(tl);
if (i) {
SkipToken(tl, ';');
break;
}
}
/* FALLTHROUGH */
default:
/* We deliberately do not mention inline C */
VSB_printf(tl->sb,
"Expected an action, 'if', '{' or '}'\n");
vcc_ErrWhere(tl, tl->t);
return;
}
}
}
void
vcc_ParseLeastBusyDirector(struct tokenlist *tl, const struct token *t_policy,
const struct token *t_dir)
{
struct token *t_field, *t_be;
int nbh, nelem;
struct fld_spec *fs;
const char *first;
fs = vcc_FldSpec(tl, "!backend", NULL);
Fc(tl, 0, "\nstatic const struct vrt_dir_least_busy_entry "
"vdrre_%.*s[] = {\n", PF(t_dir));
for (nelem = 0; tl->t->tok != '}'; nelem++) { /* List of members */
first = "";
t_be = tl->t;
vcc_ResetFldSpec(fs);
nbh = -1;
ExpectErr(tl, '{');
vcc_NextToken(tl);
Fc(tl, 0, "\t{");
while (tl->t->tok != '}') { /* Member fields */
vcc_IsField(tl, &t_field, fs);
ERRCHK(tl);
if (vcc_IdIs(t_field, "backend")) {
vcc_ParseBackendHost(tl, &nbh,
t_dir, t_policy, nelem);
Fc(tl, 0, "%s .host = &bh_%d", first, nbh);
ERRCHK(tl);
} else {
ErrInternal(tl);
}
first = ", ";
}
vcc_FieldsOk(tl, fs);
if (tl->err) {
vsb_printf(tl->sb,
"\nIn member host specification starting at:\n");
vcc_ErrWhere(tl, t_be);
return;
}
Fc(tl, 0, " },\n");
vcc_NextToken(tl);
}
Fc(tl, 0, "};\n");
Fc(tl, 0,
"\nstatic const struct vrt_dir_least_busy vdrr_%.*s = {\n",
PF(t_dir));
Fc(tl, 0, "\t.name = \"%.*s\",\n", PF(t_dir));
Fc(tl, 0, "\t.nmember = %d,\n", nelem);
Fc(tl, 0, "\t.members = vdrre_%.*s,\n", PF(t_dir));
Fc(tl, 0, "};\n");
Fi(tl, 0, "\tVRT_init_dir_least_busy("
"cli, &VGC_backend_%.*s , &vdrr_%.*s);\n", PF(t_dir), PF(t_dir));
Ff(tl, 0, "\tVRT_fini_dir(cli, VGC_backend_%.*s);\n", PF(t_dir));
}
void
vcc_ParseRoundRobinDirector(struct vcc *tl)
{
struct token *t_field, *t_be;
int nelem;
struct fld_spec *fs;
const char *first;
char *p;
fs = vcc_FldSpec(tl, "!backend", NULL);
Fc(tl, 0, "\nstatic const struct vrt_dir_round_robin_entry "
"vdrre_%.*s[] = {\n", PF(tl->t_dir));
for (nelem = 0; tl->t->tok != '}'; nelem++) { /* List of members */
first = "";
t_be = tl->t;
vcc_ResetFldSpec(fs);
SkipToken(tl, '{');
Fc(tl, 0, "\t{");
while (tl->t->tok != '}') { /* Member fields */
vcc_IsField(tl, &t_field, fs);
ERRCHK(tl);
if (vcc_IdIs(t_field, "backend")) {
vcc_ParseBackendHost(tl, nelem, &p);
ERRCHK(tl);
AN(p);
Fc(tl, 0, "%s .host = VGC_backend_%s",
first, p);
} else {
ErrInternal(tl);
}
first = ", ";
}
vcc_FieldsOk(tl, fs);
if (tl->err) {
VSB_printf(tl->sb,
"\nIn member host specification starting at:\n");
vcc_ErrWhere(tl, t_be);
return;
}
Fc(tl, 0, " },\n");
vcc_NextToken(tl);
}
Fc(tl, 0, "};\n");
Fc(tl, 0,
"\nstatic const struct vrt_dir_round_robin vgc_dir_priv_%.*s = {\n",
PF(tl->t_dir));
Fc(tl, 0, "\t.name = \"%.*s\",\n", PF(tl->t_dir));
Fc(tl, 0, "\t.nmember = %d,\n", nelem);
Fc(tl, 0, "\t.members = vdrre_%.*s,\n", PF(tl->t_dir));
Fc(tl, 0, "};\n");
}
static void
parse_return(struct vcc *tl)
{
unsigned hand;
const char *h;
vcc_NextToken(tl);
ExpectErr(tl, '(');
vcc_NextToken(tl);
ExpectErr(tl, ID);
hand = VCL_RET_MAX;
h = NULL;
#define VCL_RET_MAC(l, U, B) \
if (vcc_IdIs(tl->t, #l)) { \
hand = VCL_RET_ ## U; \
h = #U; \
}
#include "tbl/vcl_returns.h"
#undef VCL_RET_MAC
if (h == NULL) {
VSB_printf(tl->sb, "Expected return action name.\n");
vcc_ErrWhere(tl, tl->t);
ERRCHK(tl);
}
assert(hand < VCL_RET_MAX);
vcc_ProcAction(tl->curproc, hand, tl->t);
vcc_NextToken(tl);
if (tl->t->tok == '(') {
if (hand == VCL_RET_SYNTH)
parse_return_synth(tl);
else if (hand == VCL_RET_VCL)
parse_return_vcl(tl);
else if (hand == VCL_RET_PASS)
parse_return_pass(tl);
else {
VSB_printf(tl->sb, "Arguments not allowed.\n");
vcc_ErrWhere(tl, tl->t);
}
} else {
if (hand == VCL_RET_SYNTH || hand == VCL_RET_VCL) {
VSB_printf(tl->sb, "Missing argument.\n");
vcc_ErrWhere(tl, tl->t);
}
}
ERRCHK(tl);
Fb(tl, 1, "VRT_handling(ctx, VCL_RET_%s);\n", h);
Fb(tl, 1, "return (1);\n");
ExpectErr(tl, ')');
vcc_NextToken(tl);
}
void
vcc_ParseBackend(struct vcc *tl)
{
struct token *t_first, *t_be;
struct symbol *sym;
const char *dn;
tl->ndirector++;
t_first = tl->t;
SkipToken(tl, ID); /* ID: backend */
vcc_ExpectVid(tl, "backend"); /* ID: name */
ERRCHK(tl);
t_be = tl->t;
if (vcc_IdIs(tl->t, "default")) {
if (tl->first_director != NULL) {
tl->first_director->noref = 0;
tl->first_director = NULL;
tl->default_director = NULL;
}
if (tl->default_director != NULL) {
VSB_printf(tl->sb,
"Only one default director possible.\n");
vcc_ErrWhere(tl, t_first);
return;
}
vcc_NextToken(tl);
dn = "vgc_backend_default";
tl->default_director = dn;
} else {
sym = VCC_HandleSymbol(tl, BACKEND, "vgc_backend");
ERRCHK(tl);
dn = sym->rname;
if (tl->default_director == NULL) {
tl->first_director = sym;
tl->default_director = dn;
sym->noref = 1;
}
}
Fh(tl, 0, "\nstatic VCL_BACKEND %s;\n", dn);
vcc_ParseHostDef(tl, t_be, dn);
if (tl->err) {
VSB_printf(tl->sb,
"\nIn %.*s specification starting at:\n", PF(t_first));
vcc_ErrWhere(tl, t_first);
return;
}
}
static int
mb_put_ace(mbchain_t *mbp, i_ntace_t *ace)
{
int cnt0, error;
uint16_t ace_len, *ace_len_p;
if (ace == NULL)
return (EINVAL);
cnt0 = mbp->mb_count;
/*
* Put the (fixed-size) ACE header
* Will fill in the length later.
*/
ERRCHK(mb_put_uint8(mbp, ace->ace_hdr.ace_type));
ERRCHK(mb_put_uint8(mbp, ace->ace_hdr.ace_flags));
ace_len_p = mb_reserve(mbp, sizeof (*ace_len_p));
if (ace_len_p == NULL) {
error = ENOMEM;
goto errout;
}
switch (ace->ace_hdr.ace_type) {
case ACCESS_ALLOWED_ACE_TYPE:
case ACCESS_DENIED_ACE_TYPE:
case SYSTEM_AUDIT_ACE_TYPE:
case SYSTEM_ALARM_ACE_TYPE:
/* Put type-specific data. */
ERRCHK(mb_put_uint32le(mbp, ace->ace_v2.ace_rights));
ERRCHK(mb_put_sid(mbp, ace->ace_v2.ace_sid));
break;
/* other types todo */
default:
error = EIO;
goto errout;
}
/* Fill in the (OtW) ACE length. */
ace_len = mbp->mb_count - cnt0;
*ace_len_p = htoles(ace_len);
/* Success! */
return (0);
errout:
return (error);
}
static void
parse_set(struct vcc *tl)
{
const struct var *vp;
const struct arith *ap;
enum var_type fmt;
vcc_NextToken(tl);
ExpectErr(tl, ID);
vp = vcc_FindVar(tl, tl->t, 1, "cannot be set");
ERRCHK(tl);
assert(vp != NULL);
Fb(tl, 1, "%s", vp->lname);
vcc_NextToken(tl);
fmt = vp->fmt;
for (ap = arith; ap->type != VOID; ap++) {
if (ap->type != fmt)
continue;
if (ap->oper != tl->t->tok)
continue;
if (ap->oper != '=')
Fb(tl, 0, "%s %c ", vp->rname, *tl->t->b);
vcc_NextToken(tl);
fmt = ap->want;
break;
}
if (ap->type == VOID)
SkipToken(tl, ap->oper);
if (fmt == STRING) {
vcc_Expr(tl, STRING_LIST);
} else {
vcc_Expr(tl, fmt);
}
Fb(tl, 1, ");\n");
}
static void
vxp_expr(struct vxp *vxp, struct vex **pvex)
{
vxp_expr_or(vxp, pvex);
ERRCHK(vxp);
ExpectErr(vxp, EOI);
}
static void
parse_return(struct tokenlist *tl)
{
int retval = 0;
vcc_NextToken(tl);
ExpectErr(tl, '(');
vcc_NextToken(tl);
ExpectErr(tl, ID);
#define VCL_RET_MAC(l, U) \
do { \
if (vcc_IdIs(tl->t, #l)) { \
Fb(tl, 1, "VRT_done(sp, VCL_RET_" #U ");\n"); \
vcc_ProcAction(tl->curproc, VCL_RET_##U, tl->t);\
retval = 1; \
} \
} while (0);
#include "vcl_returns.h"
#undef VCL_RET_MAC
if (!retval) {
vsb_printf(tl->sb, "Expected return action name.\n");
vcc_ErrWhere(tl, tl->t);
ERRCHK(tl);
}
vcc_NextToken(tl);
ExpectErr(tl, ')');
vcc_NextToken(tl);
}
static void
vcc_ByteVal(struct vcc *tl, double *d)
{
double v, sc;
v = vcc_DoubleVal(tl);
ERRCHK(tl);
if (tl->t->tok != ID) {
VSB_printf(tl->sb, "Expected BYTES unit (B, KB, MB...) got ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb, "\n");
vcc_ErrWhere(tl, tl->t);
return;
}
if (vcc_IdIs(tl->t, "B"))
sc = 1.;
else if (vcc_IdIs(tl->t, "KB"))
sc = 1024.;
else if (vcc_IdIs(tl->t, "MB"))
sc = 1024. * 1024.;
else if (vcc_IdIs(tl->t, "GB"))
sc = 1024. * 1024. * 1024.;
else if (vcc_IdIs(tl->t, "TB"))
sc = 1024. * 1024. * 1024. * 1024.;
else {
VSB_printf(tl->sb, "Unknown BYTES unit ");
vcc_ErrToken(tl, tl->t);
VSB_printf(tl->sb,
". Legal are 'B', 'KB', 'MB', 'GB' and 'TB'\n");
vcc_ErrWhere(tl, tl->t);
return;
}
vcc_NextToken(tl);
*d = v * sc;
}
static void
Emit_Sockaddr(struct vcc *tl, const struct token *t_host,
const struct token *t_port)
{
const char *ipv4, *ipv4a, *ipv6, *ipv6a, *pa;
char buf[256];
AN(t_host->dec);
if (t_port != NULL)
bprintf(buf, "%s %s", t_host->dec, t_port->dec);
else
bprintf(buf, "%s", t_host->dec);
Resolve_Sockaddr(tl, buf, "80",
&ipv4, &ipv4a, &ipv6, &ipv6a, &pa, 2, t_host, "Backend host");
ERRCHK(tl);
if (ipv4 != NULL) {
Fb(tl, 0, "\t.ipv4_suckaddr = (const struct suckaddr *)%s,\n",
ipv4);
Fb(tl, 0, "\t.ipv4_addr = \"%s\",\n", ipv4a);
}
if (ipv6 != NULL) {
Fb(tl, 0, "\t.ipv6_suckaddr = (const struct suckaddr *)%s,\n",
ipv6);
Fb(tl, 0, "\t.ipv6_addr = \"%s\",\n", ipv6a);
}
Fb(tl, 0, "\t.port = \"%s\",\n", pa);
Fb(tl, 0, "\t.path = (void *) 0,\n");
}
void
vcc_ParseBackend(struct vcc *tl)
{
struct token *t_first, *t_be;
struct symbol *sym;
char vgcname[MAX_BACKEND_NAME + 20];
t_first = tl->t;
vcc_NextToken(tl); /* ID: backend */
vcc_ExpectCid(tl); /* ID: name */
ERRCHK(tl);
if (tl->t->e - tl->t->b > MAX_BACKEND_NAME) {
VSB_printf(tl->sb,
"Name of %.*s too long (max %d, is %zu):\n",
PF(t_first), MAX_BACKEND_NAME,
(size_t)(tl->t->e - tl->t->b));
vcc_ErrWhere(tl, tl->t);
return;
}
t_be = tl->t;
vcc_NextToken(tl);
sprintf(vgcname, "vgc_backend_%.*s", PF(t_be));
Fh(tl, 0, "\nstatic struct director *%s;\n", vgcname);
sym = VCC_HandleSymbol(tl, t_be, BACKEND, "%s", vgcname);
ERRCHK(tl);
vcc_ParseHostDef(tl, t_be, vgcname);
ERRCHK(tl);
if (tl->err) {
VSB_printf(tl->sb,
"\nIn %.*s specification starting at:\n", PF(t_first));
vcc_ErrWhere(tl, t_first);
return;
}
if (tl->default_director == NULL || vcc_IdIs(t_be, "default")) {
tl->default_director = sym->rname;
tl->t_default_director = t_be;
}
}
void get_bind (int server_type)
{
uuid_t obj_uuid;
unsigned32 status;
rpc_ns_handle_t imp_ctxt;
char *obj_uuid_string;
char *entry_name;
rpc_binding_handle_t *binding_handle;
if (server_type == 1) {
printf ( "Obtaining phone server's binding handle\n" );
obj_uuid_string = PHON_OBJ_UUID;
entry_name = PHON_ENTRY_NAME;
binding_handle = &phon_bh;
} else {
printf ( "Obtaining address server's binding handle\n" );
obj_uuid_string = ADDR_OBJ_UUID;
entry_name = ADDR_ENTRY_NAME;
binding_handle = &addr_bh;
} /* endif */
/* Create object UUID for phone directory from string. */
uuid_from_string ( obj_uuid_string, &obj_uuid, &status );
ERRCHK ( status );
/* Set up context to import the bindings of the phone server. */
rpc_ns_binding_import_begin ( rpc_c_ns_syntax_dce, entry_name,
look_v1_0_c_ifspec, &obj_uuid,
&imp_ctxt, &status );
ERRCHK ( status );
/* Get the first binding handle of the phone server. */
rpc_ns_binding_import_next ( imp_ctxt, binding_handle, &status );
ERRCHK ( status );
/* Release the context. */
rpc_ns_binding_import_done ( &imp_ctxt, &status );
ERRCHK ( status );
if (server_type == 1) {
printf ( "Phone server's binding done\n" );
} else {
printf ( "Address server's binding done\n" );
} /* endif */
}
/*===========================================================================*
*
* Bitio_Write
*
* Writes 'nbits' bits from 'bits' into the given bit bucket
* 'nbits' must be between 0 and 32
*
* RETURNS: nothing
*
* SIDE EFFECTS: if the number of bits in the bit bucket surpasses
* MAX_BITS, then that many bits are flushed to the
* appropriate output file
*
*===========================================================================*/
void
Bitio_Write(BitBucket * const bbPtr,
uint32 const bits_arg,
int const nbits) {
register struct bitBucket *lastPtr, *newPtr;
register int delta;
uint32 bits;
bits=bits_arg;
assert(nbits <= 32 && nbits >= 0);
/*
* Clear top bits if not part of data, necessary due to down and
* dirty calls of Bitio_Write with unecessary top bits set.
*/
bits &= lower_mask[nbits];
bits = bits & lower_mask[nbits];
bbPtr->totalbits += nbits;
bbPtr->cumulativeBits += nbits;
lastPtr = bbPtr->lastPtr;
delta = nbits - lastPtr->bitsleft;
if (delta >= 0) {
/*
* there's not enough room in the current bucket, so we're
* going to have to allocate another bucket
*/
newPtr = lastPtr->nextPtr = (struct bitBucket *)
malloc(sizeof(struct bitBucket));
ERRCHK(newPtr, "malloc");
newPtr->nextPtr = NULL;
newPtr->bitsleft = MAXBITS_PER_BUCKET;
newPtr->bitsleftcur = 32;
newPtr->currword = 0;
memset((char *)newPtr->bits, 0, sizeof(uint32) * WORDS_PER_BUCKET);
bbPtr->lastPtr = newPtr;
assert(lastPtr->currword == WORDS_PER_BUCKET - 1);
lastPtr->bits[WORDS_PER_BUCKET - 1] |= (bits >> delta);
lastPtr->bitsleft = 0;
lastPtr->bitsleftcur = 0;
/* lastPtr->currword++; */
if (!delta) {
if ( bbPtr->totalbits > MAX_BITS ) {
Dump(bbPtr);
}
}
assert(delta <= 32);
newPtr->bits[0] = (bits & lower_mask[delta]) << (32 - delta);
newPtr->bitsleft -= delta;
newPtr->bitsleftcur -= delta;
} else {
static void
parse_synthetic(struct vcc *tl)
{
vcc_NextToken(tl);
ExpectErr(tl, '(');
ERRCHK(tl);
vcc_NextToken(tl);
Fb(tl, 1, "VRT_synth_page(ctx, ");
vcc_Expr(tl, STRING_LIST);
ERRCHK(tl);
Fb(tl, 0, ");\n");
ExpectErr(tl, ')');
vcc_NextToken(tl);
ERRCHK(tl);
}
static void
vcc_ParseVcl(struct vcc *tl)
{
double ver;
struct token *tok;
assert(vcc_IdIs(tl->t, "vcl"));
vcc_NextToken(tl);
tok = tl->t;
ver = vcc_DoubleVal(tl);
ERRCHK(tl);
if (ver != 4.0) {
VSB_printf(tl->sb, "VCL version %.1f not supported.\n", ver);
vcc_ErrWhere(tl, tok);
ERRCHK(tl);
}
ExpectErr(tl, ';');
vcc_NextToken(tl);
}
static void
parse_panic(struct vcc *tl)
{
vcc_NextToken(tl);
Fb(tl, 1, "VRT_panic(sp, ");
vcc_Expr(tl, STRING);
ERRCHK(tl);
Fb(tl, 0, ", vrt_magic_string_end);\n");
}
SBMA_EXTERN int
lock_init(pthread_mutex_t * const lock)
{
int retval;
pthread_mutexattr_t attr;
retval = pthread_mutexattr_init(&attr);
ERRCHK(RETURN, 0 != retval);
/* FIXME Does this need to be a recursive lock? */
retval = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
ERRCHK(RETURN, 0 != retval);
retval = pthread_mutex_init(lock, &attr);
ERRCHK(RETURN, 0 != retval);
RETURN:
return retval;
}
static void
vcc_ParseSimpleDirector(struct vcc *tl)
{
struct host *h;
char vgcname[BUFSIZ];
h = TlAlloc(tl, sizeof *h);
h->name = tl->t_dir;
vcc_DefBackend(tl, tl->t_dir);
ERRCHK(tl);
sprintf(vgcname, "_%.*s", PF(h->name));
h->vgcname = TlAlloc(tl, strlen(vgcname) + 1);
strcpy(h->vgcname, vgcname);
vcc_ParseHostDef(tl, -1, vgcname);
ERRCHK(tl);
VTAILQ_INSERT_TAIL(&tl->hosts, h, list);
}
static void
parse_unset(struct vcc *tl)
{
const struct var *vp;
vcc_NextToken(tl);
ExpectErr(tl, ID);
vp = vcc_FindVar(tl, tl->t, 1, "cannot be unset");
ERRCHK(tl);
assert(vp != NULL);
if (vp->fmt != STRING || vp->http == NULL) {
VSB_printf(tl->sb,
"Only http header variables can be unset.\n");
vcc_ErrWhere(tl, tl->t);
return;
}
ERRCHK(tl);
Fb(tl, 1, "%s0);\n", vp->lname);
vcc_NextToken(tl);
}
void
vcc_TimeVal(struct vcc *tl, double *d)
{
double v, sc;
v = vcc_DoubleVal(tl);
ERRCHK(tl);
ExpectErr(tl, ID);
sc = vcc_TimeUnit(tl);
*d = v * sc;
}
static void
parse_unset(struct tokenlist *tl)
{
struct var *vp;
vcc_NextToken(tl);
ExpectErr(tl, VAR);
vp = vcc_FindVar(tl, tl->t, vcc_vars);
ERRCHK(tl);
assert(vp != NULL);
if (vp->fmt != STRING || vp->hdr == NULL) {
vsb_printf(tl->sb, "Only http header lines can be unset.\n");
vcc_ErrWhere(tl, tl->t);
return;
}
check_writebit(tl, vp);
ERRCHK(tl);
Fb(tl, 1, "%s0);\n", vp->lname);
vcc_NextToken(tl);
}
SBMA_EXTERN int
lock_free(pthread_mutex_t * const lock)
{
int retval;
retval = pthread_mutex_destroy(lock);
ERRCHK(RETURN, 0 != retval);
RETURN:
return retval;
}
static void
vcc_Conditional(struct vcc *tl)
{
SkipToken(tl, '(');
Fb(tl, 0, "(\n");
L(tl, vcc_Expr(tl, BOOL));
ERRCHK(tl);
Fb(tl, 1, ")\n");
SkipToken(tl, ')');
}
