Beispiel #1
0
const char *
vcc_regexp(struct vcc *tl)
{
	char buf[BUFSIZ], *p;
	vre_t *t;
	const char *error;
	int erroroffset;
	struct inifin *ifp;

	Expect(tl, CSTR);
	if (tl->err)
		return (NULL);
	t = VRE_compile(tl->t->dec, 0, &error, &erroroffset);
	if (t == NULL) {
		VSB_printf(tl->sb,
		    "Regexp compilation error:\n\n%s\n\n", error);
		vcc_ErrWhere(tl, tl->t);
		return (NULL);
	}
	VRE_free(&t);
	bprintf(buf, "VGC_re_%u", tl->unique++);
	p = TlAlloc(tl, strlen(buf) + 1);
	strcpy(p, buf);

	Fh(tl, 0, "static void *%s;\n", buf);
	ifp = New_IniFin(tl);
	VSB_printf(ifp->ini, "\tVRT_re_init(&%s, ",buf);
	EncToken(ifp->ini, tl->t);
	VSB_printf(ifp->ini, ");");
	VSB_printf(ifp->fin, "\t\tVRT_re_fini(%s);", buf);
	vcc_NextToken(tl);
	return (p);
}
Beispiel #2
0
static void
vxp_expr_regex(struct vxp *vxp, struct vex_rhs **prhs)
{
	const char *errptr;
	int erroff;

	/* XXX: Caseless option */

	AN(prhs);
	AZ(*prhs);
	if (vxp->t->tok != VAL) {
		VSB_printf(vxp->sb, "Expected regular expression got '%.*s' ",
		    PF(vxp->t));
		vxp_ErrWhere(vxp, vxp->t, -1);
		return;
	}
	AN(vxp->t->dec);
	ALLOC_OBJ(*prhs, VEX_RHS_MAGIC);
	AN(*prhs);
	(*prhs)->type = VEX_REGEX;
	(*prhs)->val_string = strdup(vxp->t->dec);
	(*prhs)->val_regex = VRE_compile(vxp->t->dec, vxp->vre_options,
	    &errptr, &erroff);
	if ((*prhs)->val_regex == NULL) {
		AN(errptr);
		VSB_printf(vxp->sb, "Regular expression error: %s ", errptr);
		vxp_ErrWhere(vxp, vxp->t, erroff);
		return;
	}
	vxp_NextToken(vxp);
}
Beispiel #3
0
static void
cmd_http_expect(CMD_ARGS)
{
    struct http *hp;
    const char *lhs;
    char *cmp;
    const char *rhs;
    vre_t *vre;
    const char *error;
    int erroroffset;
    int i;

    (void)cmd;
    (void)vl;
    CAST_OBJ_NOTNULL(hp, priv, HTTP_MAGIC);
    assert(!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]);
    if (!strcmp(cmp, "==")) {
        if (strcmp(lhs, rhs))
            vtc_log(hp->vl, 0, "EXPECT %s (%s) %s %s (%s) failed",
                    av[0], lhs, av[1], av[2], rhs);
        else
            vtc_log(hp->vl, 4, "EXPECT %s (%s) %s %s (%s) match",
                    av[0], lhs, av[1], av[2], rhs);
    } else if (!strcmp(cmp, "!=")) {
        if (!strcmp(lhs, rhs))
            vtc_log(hp->vl, 0, "EXPECT %s (%s) %s %s (%s) failed",
                    av[0], lhs, av[1], av[2], rhs);
        else
            vtc_log(hp->vl, 4, "EXPECT %s (%s) %s %s (%s) match",
                    av[0], lhs, av[1], av[2], rhs);
    } else if (!strcmp(cmp, "~") || !strcmp(cmp, "!~")) {
        vre = VRE_compile(rhs, 0, &error, &erroroffset);
        if (vre == NULL)
            vtc_log(hp->vl, 0, "REGEXP error: %s (@%d) (%s)",
                    error, erroroffset, rhs);
        i = VRE_exec(vre, lhs, strlen(lhs), 0, 0, NULL, 0, 0);
        if ((i >= 0 && *cmp == '~') || (i < 0 && *cmp == '!'))
            vtc_log(hp->vl, 4, "EXPECT %s (%s) %s \"%s\" match",
                    av[0], lhs, cmp, rhs);
        else
            vtc_log(hp->vl, 0, "EXPECT %s (%s) %s \"%s\" failed",
                    av[0], lhs, cmp, rhs);
        VRE_free(&vre);
    } else {
        vtc_log(hp->vl, 0,
                "EXPECT %s (%s) %s %s (%s) test not implemented",
                av[0], lhs, av[1], av[2], rhs);
    }
}
Beispiel #4
0
static int
vsl_IX_arg(struct VSL_data *vsl, int opt, const char *arg)
{
	int i, l, off;
	const char *b, *e, *err;
	vre_t *vre;
	struct vslf *vslf;
	struct vbitmap *tags = NULL;

	CHECK_OBJ_NOTNULL(vsl, VSL_MAGIC);
	vsl->flags |= F_SEEN_ixIX;

	b = arg;
	e = strchr(b, ':');
	if (e) {
		tags = vbit_init(SLT__MAX);
		AN(tags);
		l = e - b;
		i = VSL_List2Tags(b, l, vsl_vbm_bitset, tags);
		if (i < 0)
			vbit_destroy(tags);
		if (i == -1)
			return (vsl_diag(vsl,
				"-%c: \"%*.*s\" matches zero tags",
				(char)opt, l, l, b));
		else if (i == -2)
			return (vsl_diag(vsl,
				"-%c: \"%*.*s\" is ambiguous",
				(char)opt, l, l, b));
		else if (i <= -3)
			return (vsl_diag(vsl,
				"-%c: Syntax error in \"%*.*s\"",
				(char)opt, l, l, b));
		b = e + 1;
	}

	vre = VRE_compile(b, vsl->C_opt ? VRE_CASELESS : 0, &err, &off);
	if (vre == NULL) {
		if (tags)
			vbit_destroy(tags);
		return (vsl_diag(vsl, "-%c: Regex error at position %d (%s)\n",
			(char)opt, off, err));
	}

	ALLOC_OBJ(vslf, VSLF_MAGIC);
	AN(vslf);
	vslf->tags = tags;
	vslf->vre = vre;

	if (opt == 'I')
		VTAILQ_INSERT_TAIL(&vsl->vslf_select, vslf, list);
	else {
		assert(opt == 'X');
		VTAILQ_INSERT_TAIL(&vsl->vslf_suppress, vslf, list);
	}

	return (1);
}
Beispiel #5
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);
}
static void *
compile_regex(const char *regex)
{
	void *re;
	const char *error;
	int error_offset;

	re = VRE_compile(regex, 0, &error, &error_offset);
	return re;
}
void
VRT_re_init(void **rep, const char *re)
{
	vre_t *t;
	const char *error;
	int erroroffset;

	/* This was already check-compiled by the VCL compiler */
	t = VRE_compile(re, 0, &error, &erroroffset);
	AN(t);
	*rep = t;
}
Beispiel #8
0
static int
vsl_IX_arg(struct VSL_data *vd, const char *opt, int arg)
{
	vre_t **rp;
	const char *error;
	int erroroffset;

	CHECK_OBJ_NOTNULL(vd, VSL_MAGIC);
	if (arg == 'I')
		rp = &vd->regincl;
	else
		rp = &vd->regexcl;
	if (*rp != NULL) {
		fprintf(stderr, "Option %c can only be given once", arg);
		return (-1);
	}
	*rp = VRE_compile(opt, vd->regflags, &error, &erroroffset);
	if (*rp == NULL) {
		fprintf(stderr, "Illegal regex: %s\n", error);
		return (-1);
	}
	return (1);
}
Beispiel #9
0
struct vslq_query *
vslq_newquery(struct VSL_data *vsl, enum VSL_grouping_e grouping,
    const char *querystring)
{
	struct vslq_query *query;
	const char *error;
	int pos;
	vre_t *regex;

	(void)grouping;
	AN(querystring);
	regex = VRE_compile(querystring, 0, &error, &pos);
	if (regex == NULL) {
		vsl_diag(vsl, "failed to compile regex at pos %d: %s",
		    pos, error);
		return (NULL);
	}

	ALLOC_OBJ(query, VSLQ_QUERY_MAGIC);
	if (query != NULL)
		query->regex = regex;
	return (query);
}
Beispiel #10
0
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");
}