/* 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); }