void init_boards(void) {
int i, j , fatal_error = 0;
char buf[100];
for (i = 0; i < INDEX_SIZE; i++) {
msg_storage[i] = 0;
msg_storage_taken[i] = 0;
}
for (i = 0; i < NUM_OF_BOARDS; i++) {
if ((RNUM(i) = real_object(VNUM(i))) == -1) {
sprintf(buf, "Fatal board error: board vnum %d does not exist!", VNUM(i));
log(buf);
fatal_error = 1;
}
num_of_msgs[i] = 0;
for(j = 0; j < MAX_BOARD_MESSAGES; j++) {
memset(&(msg_index[i][j]), '\0', sizeof(struct board_msginfo));
msg_index[i][j].slot_num = -1;
}
Board_load_board(i);
}
if (fatal_error)
exit(0);
}
void
vtc_expect(struct vtclog *vl,
const char *olhs, const char *lhs,
const char *cmp,
const char *orhs, const char *rhs)
{
vre_t *vre;
const char *error;
int erroroffset;
int i, j, retval = -1;
double fl, fr;
j = lhs == NULL || rhs == NULL;
if (lhs == NULL)
lhs = "<undef>";
if (rhs == NULL)
rhs = "<undef>";
if (!strcmp(cmp, "~") || !strcmp(cmp, "!~")) {
vre = VRE_compile(rhs, 0, &error, &erroroffset);
if (vre == NULL)
vtc_fatal(vl, "REGEXP error: %s (@%d) (%s)",
error, erroroffset, rhs);
i = VRE_exec(vre, lhs, strlen(lhs), 0, 0, NULL, 0, 0);
retval = (i >= 0 && *cmp == '~') || (i < 0 && *cmp == '!');
VRE_free(&vre);
} else if (!strcmp(cmp, "==")) {
retval = strcmp(lhs, rhs) == 0;
} else if (!strcmp(cmp, "!=")) {
retval = strcmp(lhs, rhs) != 0;
} else if (j) {
// fail inequality comparisons if either side is undef'ed
retval = 0;
} else {
fl = VNUM(lhs);
fr = VNUM(rhs);
if (!strcmp(cmp, "<"))
retval = isless(fl, fr);
else if (!strcmp(cmp, ">"))
retval = isgreater(fl, fr);
else if (!strcmp(cmp, "<="))
retval = islessequal(fl, fr);
else if (!strcmp(cmp, ">="))
retval = isgreaterequal(fl, fr);
}
if (retval == -1)
vtc_fatal(vl,
"EXPECT %s (%s) %s %s (%s) test not implemented",
olhs, lhs, cmp, orhs, rhs);
else if (retval == 0)
vtc_fatal(vl, "EXPECT %s (%s) %s \"%s\" failed",
olhs, lhs, cmp, rhs);
else
vtc_log(vl, 4, "EXPECT %s (%s) %s \"%s\" match",
olhs, lhs, cmp, rhs);
}
int
main(int argc, char *argv[])
{
int ec = 0;
struct test_case *tc;
uintmax_t val;
const char **p;
const char *e;
double d1, d2;
(void)argc;
for (p = vec; *p != NULL; p++) {
e = *p;
d1 = VNUM(e + 1);
if (*e == 'N') {
if (!isnan(d1)) {
ec++;
printf("VNUM(%s) not NAN (%g)\n", e + 1, d1);
}
} else {
d2 = atof(e + 1);
if (isnan(d1)) {
printf("VNUM(%s) is NAN (%g)\n", e + 1, d1);
ec++;
} else if (fabs((d1 - d2) / d2) > 1e-15) {
printf("VNUM(%s) differs from atof() (%g)\n",
e + 1, d1);
ec++;
}
}
}
for (tc = test_cases; tc->str; ++tc) {
e = VNUM_2bytes(tc->str, &val, tc->rel);
if (e != tc->err) {
printf("%s: VNUM_2bytes(\"%s\", %ju) (%s) != (%s)\n",
*argv, tc->str, tc->rel, tc->err, e);
++ec;
} else if (e == NULL && val != tc->val) {
printf("%s: VNUM_2bytes(\"%s\", %ju) %ju != %ju (%s)\n",
*argv, tc->str, tc->rel, val, tc->val, e);
++ec;
}
}
if (!isnan(VNUM_duration(NULL))) {
printf("%s: VNUM_Duration(NULL) fail\n", *argv);
++ec;
}
d1 = VNUM_duration(" 365.24219d ");
if (d1 < 31556925.2159 || d1 > 31556925.2161) {
printf("%s: VNUM_Duration() wrong: %g\n", *argv, d1);
++ec;
}
/* TODO: test invalid strings */
if (!ec)
printf("OK\n");
return (ec > 0);
}
static int
tweak_generic_double(struct vsb *vsb, volatile double *dest,
const char *arg, const char *min, const char *max, const char *fmt)
{
double u, minv = 0, maxv = 0;
if (arg != NULL) {
if (min != NULL) {
minv = VNUM(min);
if (isnan(minv)) {
VSB_printf(vsb, "Illegal Min: %s\n", min);
return (-1);
}
}
if (max != NULL) {
maxv = VNUM(max);
if (isnan(maxv)) {
VSB_printf(vsb, "Illegal Max: %s\n", max);
return (-1);
}
}
u = VNUM(arg);
if (isnan(u)) {
VSB_printf(vsb, "Not a number(%s)\n", arg);
return (-1);
}
if (min != NULL && u < minv) {
VSB_printf(vsb,
"Must be greater or equal to %s\n", min);
return (-1);
}
if (max != NULL && u > maxv) {
VSB_printf(vsb,
"Must be less than or equal to %s\n", max);
return (-1);
}
*dest = u;
} else
VSB_printf(vsb, fmt, *dest);
return (0);
}
void
cmd_delay(CMD_ARGS)
{
double f;
(void)priv;
(void)cmd;
if (av == NULL)
return;
AN(av[1]);
AZ(av[2]);
f = VNUM(av[1]);
vtc_log(vl, 3, "delaying %g second(s)", f);
VTIM_sleep(f);
}
static void
cmd_http_timeout(CMD_ARGS)
{
struct http *hp;
double d;
(void)cmd;
(void)vl;
CAST_OBJ_NOTNULL(hp, priv, HTTP_MAGIC);
AN(av[1]);
AZ(av[2]);
d = VNUM(av[1]);
if (isnan(d))
vtc_log(vl, 0, "timeout is not a number (%s)", av[1]);
hp->timeout = (int)(d * 1000.0);
}
vmod_real(VRT_CTX, VCL_STRING p, VCL_REAL d)
{
double r;
CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
if (p == NULL)
return (d);
r = VNUM(p);
if (isnan(r))
return (d);
return (r);
}
int
VSL_Arg(struct VSL_data *vsl, int opt, const char *arg)
{
int i;
char *p;
double d;
long l;
CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
/* If first option is 'i', set all bits for supression */
if ((opt == 'i' || opt == 'I') && !(vsl->flags & F_SEEN_ixIX))
for (i = 0; i < SLT__MAX; i++)
vbit_set(vsl->vbm_supress, i);
switch (opt) {
case 'b': vsl->b_opt = 1; return (1);
case 'c': vsl->c_opt = 1; return (1);
case 'C':
/* Caseless regular expressions */
vsl->C_opt = 1;
return (1);
case 'i': case 'x': return (vsl_ix_arg(vsl, opt, arg));
case 'I': case 'X': return (vsl_IX_arg(vsl, opt, arg));
case 'L':
l = strtol(arg, &p, 0);
while (isspace(*p))
p++;
if (*p != '\0')
return (vsl_diag(vsl, "-L: Syntax error"));
if (l < 0 || l > INT_MAX)
return (vsl_diag(vsl, "-L: Range error"));
vsl->L_opt = (int)l;
return (1);
case 'T':
d = VNUM(arg);
if (!isnan(d))
return (vsl_diag(vsl, "-T: Syntax error"));
if (d < 0.)
return (vsl_diag(vsl, "-T: Range error"));
vsl->T_opt = d;
return (1);
case 'v': vsl->v_opt = 1; return (1);
default:
return (0);
}
}
static void
vxp_expr_num(struct vxp *vxp, struct vex_rhs **prhs, int vxid)
{
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;
}
}
if (vxid && (*prhs)->type != VEX_INT) {
VSB_printf(vxp->sb, "Expected integer got '%.*s' ",
PF(vxp->t));
vxp_ErrWhere(vxp, vxp->t, 0);
return;
}
vxp_NextToken(vxp);
}
static void
cmd_http_expect(CMD_ARGS)
{
struct http *hp;
const char *lhs, *clhs;
char *cmp;
const char *rhs, *crhs;
vre_t *vre;
const char *error;
int erroroffset;
int i, retval = -1;
(void)cmd;
(void)vl;
CAST_OBJ_NOTNULL(hp, priv, HTTP_MAGIC);
AZ(strcmp(av[0], "expect"));
av++;
AN(av[0]);
AN(av[1]);
AN(av[2]);
AZ(av[3]);
lhs = cmd_var_resolve(hp, av[0]);
cmp = av[1];
rhs = cmd_var_resolve(hp, av[2]);
clhs = lhs ? lhs : "<undef>";
crhs = rhs ? rhs : "<undef>";
if (!strcmp(cmp, "~") || !strcmp(cmp, "!~")) {
vre = VRE_compile(crhs, 0, &error, &erroroffset);
if (vre == NULL)
vtc_log(hp->vl, 0, "REGEXP error: %s (@%d) (%s)",
error, erroroffset, crhs);
i = VRE_exec(vre, clhs, strlen(clhs), 0, 0, NULL, 0, 0);
retval = (i >= 0 && *cmp == '~') || (i < 0 && *cmp == '!');
VRE_free(&vre);
} else if (!strcmp(cmp, "==")) {
retval = strcmp(clhs, crhs) == 0;
} else if (!strcmp(cmp, "!=")) {
retval = strcmp(clhs, crhs) != 0;
} else if (lhs == NULL || rhs == NULL) {
// fail inequality comparisons if either side is undef'ed
retval = 0;
} else if (!strcmp(cmp, "<")) {
retval = isless(VNUM(lhs), VNUM(rhs));
} else if (!strcmp(cmp, ">")) {
retval = isgreater(VNUM(lhs), VNUM(rhs));
} else if (!strcmp(cmp, "<=")) {
retval = islessequal(VNUM(lhs), VNUM(rhs));
} else if (!strcmp(cmp, ">=")) {
retval = isgreaterequal(VNUM(lhs), VNUM(rhs));
}
if (retval == -1)
vtc_log(hp->vl, 0,
"EXPECT %s (%s) %s %s (%s) test not implemented",
av[0], clhs, av[1], av[2], crhs);
else
vtc_log(hp->vl, retval ? 4 : 0, "EXPECT %s (%s) %s \"%s\" %s",
av[0], clhs, cmp, crhs, retval ? "match" : "failed");
}
int
VUT_Arg(int opt, const char *arg)
{
int i;
char *p;
switch (opt) {
case 'd':
/* Head */
VUT.d_opt = 1;
return (1);
case 'D':
/* Daemon mode */
VUT.D_opt = 1;
return (1);
case 'g':
/* Grouping */
return (VUT_g_Arg(arg));
case 'k':
/* Log transaction limit */
VUT.k_arg = (int)strtol(arg, &p, 10);
if (*p != '\0' || VUT.k_arg <= 0)
VUT_Error(1, "-k: Invalid number '%s'", arg);
return (1);
case 'n':
/* Varnish instance name */
REPLACE(VUT.n_arg, arg);
return (1);
case 'N':
/* Varnish stale VSM file */
REPLACE(VUT.N_arg, arg);
return (1);
case 'P':
/* PID file */
REPLACE(VUT.P_arg, arg);
return (1);
case 'q':
/* Query to use */
REPLACE(VUT.q_arg, arg);
return (1);
case 'r':
/* Binary file input */
REPLACE(VUT.r_arg, arg);
return (1);
case 't':
/* VSM connect timeout */
if (!strcasecmp("off", arg))
VUT.t_arg = -1.;
else {
VUT.t_arg = VNUM(arg);
if (isnan(VUT.t_arg))
VUT_Error(1, "-t: Syntax error");
if (VUT.t_arg < 0.)
VUT_Error(1, "-t: Range error");
}
return (1);
case 'V':
/* Print version number and exit */
VCS_Message(VUT.progname);
exit(0);
default:
AN(VUT.vsl);
i = VSL_Arg(VUT.vsl, opt, arg);
if (i < 0)
VUT_Error(1, "%s", VSL_Error(VUT.vsl));
return (i);
}
}
int
main(int argc, char * const *argv)
{
const char *T_arg = NULL;
const char *S_arg = NULL;
const char *n_arg = NULL;
int opt, sock;
/*
* By default linux::getopt(3) mangles the argv order, such that
* varnishadm -n bla param.set foo -bar
* gets interpreted as
* varnishadm -n bla -bar param.set foo
* The '+' stops that from happening
* See #1496
*/
while ((opt = getopt(argc, argv, "+n:S:T:t:")) != -1) {
switch (opt) {
case 'n':
n_arg = optarg;
break;
case 'S':
S_arg = optarg;
break;
case 'T':
T_arg = optarg;
break;
case 't':
timeout = VNUM(optarg);
if (isnan(timeout))
usage();
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (n_arg != NULL) {
if (T_arg != NULL || S_arg != NULL) {
usage();
}
sock = n_arg_sock(n_arg);
} else if (T_arg == NULL) {
sock = n_arg_sock("");
} else {
assert(T_arg != NULL);
sock = cli_sock(T_arg, S_arg);
}
if (sock < 0)
exit(2);
if (argc > 0)
do_args(sock, argc, argv);
else {
if (isatty(0)) {
interactive(sock);
} else {
pass(sock);
}
}
exit(0);
}
int
main(int argc, char * const *argv)
{
struct VSM_data *vd;
double t_arg = 5.0, t_start = NAN;
int once = 0, xml = 0, json = 0, f_list = 0, curses = 0;
signed char opt;
int i;
VUT_Init(progname, argc, argv, &vopt_spec);
vd = VSM_New();
AN(vd);
while ((opt = getopt(argc, argv, vopt_spec.vopt_optstring)) != -1) {
switch (opt) {
case '1':
once = 1;
break;
case 'h':
/* Usage help */
usage(0);
case 'l':
f_list = 1;
break;
case 't':
if (!strcasecmp(optarg, "off"))
t_arg = -1.;
else {
t_arg = VNUM(optarg);
if (isnan(t_arg))
VUT_Error(1, "-t: Syntax error");
if (t_arg < 0.)
VUT_Error(1, "-t: Range error");
}
break;
case 'V':
VCS_Message("varnishstat");
exit(0);
case 'x':
xml = 1;
break;
case 'j':
json = 1;
break;
default:
i = VSC_Arg(vd, opt, optarg);
if (i < 0)
VUT_Error(1, "%s", VSM_Error(vd));
if (!i)
usage(1);
}
}
if (optind != argc)
usage(1);
if (!(xml || json || once || f_list))
curses = 1;
while (1) {
i = VSM_Open(vd);
if (!i)
break;
if (isnan(t_start) && t_arg > 0.) {
fprintf(stderr, "Can't open log -"
" retrying for %.0f seconds\n", t_arg);
t_start = VTIM_real();
}
if (t_arg <= 0.)
break;
if (VTIM_real() - t_start > t_arg)
break;
VSM_ResetError(vd);
VTIM_sleep(0.5);
}
if (curses) {
if (i && t_arg >= 0.)
VUT_Error(1, "%s", VSM_Error(vd));
do_curses(vd, 1.0);
exit(0);
}
if (i)
VUT_Error(1, "%s", VSM_Error(vd));
if (xml)
do_xml(vd);
else if (json)
do_json(vd);
else if (once)
do_once(vd);
else if (f_list)
list_fields(vd);
else
assert(0);
exit(0);
}
