/* Stores an escaped value into an attribute. Determines type of attribute at
* the same time.
*
* tag must be null terminated.
* val must be of length len.
* policy will only be respected where it can be (ints, strings, and opaques).
*
* the contents of tag are NOT verified.
*
* Returns:
* SLP_PARAMETER_BAD - Syntax error in the value.
* SLP_MEMORY_ALLOC_FAILED
*/
SLPError SLPAttrStore(struct xx_SLPAttributes *slp_attr,
const char *tag,
const char *val,
size_t len,
SLPInsertionPolicy policy
) {
int i; /* Index into val. */
SLPBoolean is_str; /* Flag used for checking if given is string. */
char *unescaped;
size_t unescaped_len; /* Length of the unescaped text. */
/***** Check opaque. *****/
if (strncmp(val, OPAQUE_PREFIX, OPAQUE_PREFIX_LEN) == 0) {
/*** Verify length (ie, that it is the multiple of the size of an
* escaped character). ***/
if (len % ESCAPED_LEN != 0) {
return SLP_PARAMETER_BAD;
}
unescaped_len = (len / ESCAPED_LEN) - 1; /* -1 to drop the OPAQUE_PREFIX. */
/*** Verify that every character has been escaped. ***/
/* TODO */
/***** Unescape the value. *****/
unescaped = (char *)malloc(unescaped_len);
if (unescaped == NULL) {
return SLP_MEMORY_ALLOC_FAILED; /* FIXME: Real error code. */
}
if (unescape_into(unescaped, (char *)(val + OPAQUE_PREFIX_LEN), len - OPAQUE_PREFIX_LEN) != NULL) {
SLPError err;
err = SLPAttrSet_opaque((SLPAttributes)slp_attr, tag, unescaped, (len - OPAQUE_PREFIX_LEN) / 3, policy);
free(unescaped);/* FIXME This should be put into the val, and free()'d in val_destroy(). */
return err;
}
return SLP_PARAMETER_BAD; /* FIXME Verify. Is this really a bad parameter?*/
}
/***** Check boolean. *****/
if ((BOOL_TRUE_STR_LEN == len) && (strncmp(val, BOOL_TRUE_STR, len) == 0) ) {
return SLPAttrSet_bool((SLPAttributes)slp_attr, tag, SLP_TRUE);
}
if ((BOOL_FALSE_STR_LEN == len) && strncmp(val, BOOL_FALSE_STR, len) == 0) {
return SLPAttrSet_bool((SLPAttributes)slp_attr, tag, SLP_FALSE);
}
/***** Check integer *****/
if (*val == '-' || isdigit((int)*val)) {
/*** Verify. ***/
SLPBoolean is_int = SLP_TRUE; /* Flag true if the attr is an int. */
for (i = 1; i < len; i++) { /* We start at 1 since first char has already been checked. */
if (!isdigit((int)val[i])) {
is_int = SLP_FALSE;
break;
}
}
/*** Handle the int-ness. ***/
if (is_int == SLP_TRUE) {
char *end; /* To verify that the correct length was read. */
SLPError err;
err = SLPAttrSet_int((SLPAttributes)slp_attr, tag, strtol(val, &end, 10), policy);
assert(end == val + len);
return err;
}
}
/***** Check string. *****/
is_str = SLP_TRUE;
for(i = 0; i < len; i++) {
if (IS_RESERVED(val[i]) && (val[i] != '\\')) {
is_str = SLP_FALSE;
break;
}
}
if (is_str == SLP_TRUE) {
unescaped_len = find_unescaped_size(val, len);
unescaped = (char *)malloc( unescaped_len + 1 );
if (unescape_into(unescaped, val, len) != NULL) {
SLPError err;
unescaped[unescaped_len] = '\0';
err = SLPAttrSet_str((SLPAttributes)slp_attr, tag, unescaped, policy);
free(unescaped); /* FIXME This should be put into the val, and free()'d in val_destroy(). */
return err;
}
return SLP_PARAMETER_BAD;
}
/* We don't bother checking for a keyword attribute since it can't have a
* value.
*/
return SLP_PARAMETER_BAD; /* Could not determine type. */
}
void test_predicate() {
char *str;
int ierr;
SLPAttributes slp_attr;
SLPError err;
/******************** Test int stuff. *********************/
err = SLPAttrAlloc("en", NULL, SLP_FALSE, &slp_attr);
assert(err == SLP_OK);
SLPAttrSet_int(slp_attr, "int", (int)23, SLP_ADD);
SLPAttrSet_int(slp_attr, "int", (int)25, SLP_ADD);
SLPAttrSet_int(slp_attr, "int", (int)27, SLP_ADD);
/* Test equals. */
str = "(&(&(int=23)(int=25))(int=26))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* False. */
str = "(&(&(int=24)(int=25))(int=26))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* False. */
str = "(&(&(int=24)(int=28))(int=26))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* False. */
str = "(&(&(int=23)(int=25))(int=27))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* True. */
/* Test greater. */
str = "(int>=29)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f. */
str = "(int>=26)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* T. */
str = "(int>=24)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t. */
str = "(int>=22)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t. */
/* Test lesser. */
str = "(int<=22)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(int<=23)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
SLPAttrFree(slp_attr);
/* Simple equality. */
err = SLPAttrAllocStr("en", NULL, SLP_FALSE, &slp_attr, "(a=1)");
assert(err == SLP_OK);
str = "(a=1)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
SLPAttrFree(slp_attr);
/******************** Test opaque stuff. *********************/
err = SLPAttrAlloc("en", NULL, SLP_FALSE, &slp_attr);
assert(err == SLP_OK);
err = SLPAttrSet_str(slp_attr, "op", "\\00\\12\\24\\36", SLP_REPLACE);
assert(err == SLP_OK);
/* Test less (single-valued). */
str = "(op<=\\00\\12\\10\\43)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(op<=\\00\\12\\24\\36)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(op<=\\00\\12\\24\\36\\12)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(op>=\\00\\12\\24\\36)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
SLPAttrFree(slp_attr);
/******************** Test string stuff. *********************/
err = SLPAttrAlloc("en", NULL, SLP_FALSE, &slp_attr);
assert(err == SLP_OK);
err = SLPAttrSet_str(slp_attr, "str", "string", SLP_REPLACE);
assert(err == SLP_OK);
/* Test less (single-valued). */
str = "(str<=a)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(str<=string)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(str<=strinx)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
/* Test greater (single-valued). */
str = "(str>=a)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(str>=string)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(str>=strinx)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
/* Test equal (single valued). */
str = "(str=a)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(str=*ing)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(str=stri*)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(str=*tri*)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(str=\\73*)"; /* s* */
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(str=\\73\\74\\72\\69*)"; /* stri* */
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(str=*\\73\\74\\72\\69*)"; /* *stri* */
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(str=s*t*r*i*n*g)"; /* s*t*r*i* */
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(str=s*t*r*i*ng)"; /* s*t*r*i* */
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(str=\\73\\74\\72\\69ng)"; /* s*t*r*i* */
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(str=s*tring)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(str=\\73*\\74ring)"; /* s*t*r*i* */
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
/* TODO Test escaped '*'s. */
/* TODO Test multivalued. */
SLPAttrFree(slp_attr);
/******************** Test boolean stuff. *********************/
err = SLPAttrAlloc("en", NULL, SLP_FALSE, &slp_attr);
assert(err == SLP_OK);
err = SLPAttrSet_bool(slp_attr, "bool", SLP_TRUE);
assert(err == SLP_OK);
/* Test equal. */
str = "(bool=true)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(bool=false)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
/* Test bad strings. */
str = "(bool=falsew)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(bool=*false)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(bool=truee)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(bool= true)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
SLPAttrFree(slp_attr);
/******************** Test keyword stuff. *********************/
err = SLPAttrAlloc("en", NULL, SLP_FALSE, &slp_attr);
assert(err == SLP_OK);
err = SLPAttrSet_keyw(slp_attr, "keyw");
assert(err == SLP_OK);
/* Test present. */
str = "(keyw=*)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(keyw=sd)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(keyw<=adf)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
SLPAttrFree(slp_attr);
/********************* Test boolean operators. *********************/
err = SLPAttrAlloc("en", NULL, SLP_FALSE, &slp_attr);
assert(err == SLP_OK);
err = SLPAttrSet_keyw(slp_attr, "keyw");
assert(err == SLP_OK);
str = "(keyw=*)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
/* Test not. */
str = "(!(keyw=*))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(!(!(keyw=*)))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(!(!(!(keyw=*))))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(!(!(!(!(keyw=*)))))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
/* Build up to testing binary ops. */
err = SLPAttrSet_bool(slp_attr, "bool", SLP_TRUE);
assert(err == SLP_OK);
/* Test and. */
str = "(&(keyw=*)(bool=true))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(&(keyw=*)(bool=false))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(&(keyw=*)(!(bool=false)))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(&(keywx=*)(bool=true))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(&(!(keywx=*))(bool=true))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(&(lkeyw=*)(bool=false))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(&(!(lkeyw=*))(!(bool=false)))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(&(&(keyw=*)(bool=true))(&(keyw=*)(bool=true)))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
str = "(&(&(!(keyw=*))(bool=true))(&(keyw=*)(bool=true)))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(!(&(&(!(keyw=*))(bool=true))(&(keyw=*)(bool=true))))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr == 0); /* t */
/* Test sytax errors. */
/* No preceeding bracket. */
str = "asdf=log";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr < 0);
/* No trailing bracket. */
str = "(asdf=log";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr < 0);
/* Unbalanced brackets. */
str = "(asdf=log))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr < 0);
str = "((asdf=log)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr < 0);
/* Missing operators. */
str = "(asdflog)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr < 0);
/* Check that the leaf operator isn't causing the problem. */
str = "(asdflog=q)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0);
/* Missing logical unary. */
str = "((asdflog=q))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr < 0);
/* Missing logical binary. */
str = "((asdflog=q)(asdflog=q))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr < 0);
/* Missing operands and operator. */
str = "()";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr < 0);
/* Missing unary operands. */
str = "(!)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr < 0);
/* Missing binary operands. */
str = "(&)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr < 0);
/* Missing binary operands. */
str = "(=)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr < 0);
/* Missing binary operands. I _guess_ this is legal... */
str = "(thingy=)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > -1);
/* Trailing trash. */
str = "(&(a=b)(c=d))";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > -1);
/* Check that the following test will not be short circuited. */
str = "(a=b)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr > 0); /* f */
str = "(|(a=b)(c=d)w)";
ierr = SLPDPredicateTest( str, slp_attr);
assert(ierr < 0);
SLPAttrFree(slp_attr);
/* Check multiple (more than two) subexpressions. */
err = SLPAttrAlloc("en", NULL, SLP_FALSE, &slp_attr);
assert(err == SLP_OK);
err = SLPAttrSet_int(slp_attr, "x", 1, SLP_ADD);
assert(err == SLP_OK);
str = "(&(x=1)(!(x=1)))";
ierr = SLPDPredicateTest((SLPDPredicate)str, slp_attr);
assert(ierr > 0); /* f */
str = "(&(x=1))";
ierr = SLPDPredicateTest((SLPDPredicate)str, slp_attr);
assert(ierr == 0); /* t */
str = "(&(x=1)(x=1)(x=1))";
ierr = SLPDPredicateTest((SLPDPredicate)str, slp_attr);
assert(ierr == 0); /* t */
SLPAttrFree(slp_attr);
}
