예제 #1
0
파일: vre.c 프로젝트: ONode/Varnish-Cache
vre_t *
VRE_compile(const char *pattern, int options,
    const char **errptr, int *erroffset)
{
	vre_t *v;
	*errptr = NULL; *erroffset = 0;

	ALLOC_OBJ(v, VRE_MAGIC);
	if (v == NULL) {
		*errptr = "Out of memory for VRE";
		return (NULL);
	}
	v->re = pcre_compile(pattern, options, errptr, erroffset, NULL);
	if (v->re == NULL) {
		VRE_free(&v);
		return (NULL);
	}
	v->re_extra = pcre_study(v->re, VRE_STUDY_JIT_COMPILE, errptr);
	if (*errptr != NULL) {
		VRE_free(&v);
		return (NULL);
	}
	if (v->re_extra == NULL) {
		/* allocate our own */
		v->re_extra = calloc(1, sizeof(pcre_extra));
		v->my_extra = 1;
		if (v->re_extra == NULL) {
			*errptr = "Out of memory for pcre_extra";
			VRE_free(&v);
			return (NULL);
		}
	}
	return (v);
}
예제 #2
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);
}
예제 #3
0
void
vex_Free(struct vex **pvex)
{

	if ((*pvex)->lhs != NULL) {
		if ((*pvex)->lhs->tags != NULL)
			vbit_destroy((*pvex)->lhs->tags);
		if ((*pvex)->lhs->prefix != NULL)
			free((*pvex)->lhs->prefix);
		FREE_OBJ((*pvex)->lhs);
	}
	if ((*pvex)->rhs != NULL) {
		if ((*pvex)->rhs->val_string)
			free((*pvex)->rhs->val_string);
		if ((*pvex)->rhs->val_regex)
			VRE_free(&(*pvex)->rhs->val_regex);
		FREE_OBJ((*pvex)->rhs);
	}
	if ((*pvex)->a != NULL) {
		vex_Free(&(*pvex)->a);
		AZ((*pvex)->a);
	}
	if ((*pvex)->b != NULL) {
		vex_Free(&(*pvex)->b);
		AZ((*pvex)->b);
	}
	FREE_OBJ(*pvex);
	*pvex = NULL;
}
예제 #4
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);
    }
}
예제 #5
0
void
VRT_re_fini(void *rep)
{
	vre_t *vv;

	vv = rep;
	if (rep != NULL)
		VRE_free(&vv);
}
예제 #6
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);
}
예제 #7
0
static void
vsl_IX_free(vslf_list *list)
{
	struct vslf *vslf;

	while (!VTAILQ_EMPTY(list)) {
		vslf = VTAILQ_FIRST(list);
		CHECK_OBJ_NOTNULL(vslf, VSLF_MAGIC);
		VTAILQ_REMOVE(list, vslf, list);
		AN(vslf->vre);
		VRE_free(&vslf->vre);
		AZ(vslf->vre);
	}
}
예제 #8
0
파일: vsl.c 프로젝트: Gavin-v/varnish-cache
static void
vsl_IX_free(vslf_list *filters)
{
	struct vslf *vslf;

	while (!VTAILQ_EMPTY(filters)) {
		vslf = VTAILQ_FIRST(filters);
		CHECK_OBJ_NOTNULL(vslf, VSLF_MAGIC);
		VTAILQ_REMOVE(filters, vslf, list);
		if (vslf->tags)
			vbit_destroy(vslf->tags);
		AN(vslf->vre);
		VRE_free(&vslf->vre);
		AZ(vslf->vre);
	}
}
예제 #9
0
void
vslq_deletequery(struct vslq_query **pquery)
{
	struct vslq_query *query;

	AN(pquery);
	query = *pquery;
	*pquery = NULL;
	CHECK_OBJ_NOTNULL(query, VSLQ_QUERY_MAGIC);

	AN(query->regex);
	VRE_free(&query->regex);
	AZ(query->regex);

	FREE_OBJ(query);
}
예제 #10
0
vre_t *
VRE_compile(const char *pattern, int options,
		    const char **errptr, int *erroffset)
{
	vre_t *v;
	*errptr = NULL; *erroffset = 0;

	ALLOC_OBJ(v, VRE_MAGIC);
	if (v == NULL)
		return (NULL);
	v->re = pcre_compile(pattern, options, errptr, erroffset, NULL);
	if (v->re == NULL) {
		VRE_free(&v);
		return (NULL);
	}
	return (v);
}
예제 #11
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");
}