Esempio n. 1
0
/* Allocates a new thingy from a string. */
SLPError SLPAttrAllocStr(
		const char *lang, 
		const FILE *template_h,
		const SLPBoolean strict, 
		SLPAttributes *slp_attr_h,
		const char *str
) {
	SLPError err;
	char *mangle; /* A copy of the passed in string, since attr_destringify tends to chew data. */
	
	err = SLPAttrAlloc(lang, template_h, strict, slp_attr_h);

	if (err != SLP_OK) {
		return err;
	}
	
	mangle = strdup(str);
	if (str == NULL) {
		SLPAttrFree(*slp_attr_h);
		return SLP_MEMORY_ALLOC_FAILED;
	}
	err = attr_destringify((struct xx_SLPAttributes*)*slp_attr_h, mangle, SLP_ADD);
	free(mangle);

	if (err != SLP_OK) {
		SLPAttrFree(*slp_attr_h);
	}

	return err;
}
Esempio n. 2
0
SLPBoolean attr_callback (
		SLPHandle hslp, 
		const char* attrlist, 
		SLPError errcode, 
		void* cookie 
) {
	struct hop_attr *hop = (struct hop_attr *)cookie;
	SLPAttributes attr;
	SLPBoolean result;

	assert(errcode == SLP_OK || errcode == SLP_LAST_CALL);
	
	if (errcode == SLP_OK) {
		if (SLPAttrAlloc("en", NULL, SLP_FALSE, &attr) != SLP_OK) {
			/* FIXME Ummm, should prolly tell application about the internal
			 * error.  
			 */
			return SLP_FALSE;
		}
	
		destringify(attr, attrlist);
		result = hop->cb(hslp, attr, errcode, hop->cookie);
		assert(result == SLP_TRUE || result == SLP_FALSE);
		SLPAttrFree(attr);
	} 
	else if (errcode == SLP_LAST_CALL) {
		result = hop->cb(hslp, NULL, errcode, hop->cookie);
	}
	else {
		result = hop->cb(hslp, NULL, errcode, hop->cookie);
	}

	return result;
}
Esempio n. 3
0
/*=========================================================================*/
void SLPDDatabaseEntryFree(SLPDDatabaseEntry* entry)
/* Free all resource related to the specified entry                        */
/*=========================================================================*/
{
    if(entry)
    {
        if(entry->scopelist) free(entry->scopelist);
        if(entry->srvtype) free(entry->srvtype);
        if(entry->url) free(entry->url);
        if(entry->attrlist) free(entry->attrlist);
        if(entry->partiallist) free(entry->partiallist);
#ifdef USE_PREDICATES
        if(entry->attr) SLPAttrFree(entry->attr);
#endif
        free(entry);
    }
}
Esempio n. 4
0
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);
}
Esempio n. 5
0
/*=========================================================================*/
int SLPDFilterAttributes(int attrlistlen,
                         const char* attrlist,
                         int taglistlen,
                         const char* taglist,
                         int* resultlen,
                         char** result)
/* Copies attributes from the specified attribute list to a result string  */
/* according to the taglist as described by section 10.4. of RFC 2608      */
/*                                                                         */
/* version    (IN) SLP version of the predicate string (should always be   */
/*                 2 since we don't handle SLPv1 predicates yet)           */
/*                                                                         */
/* attrlistlen  (IN) length of attrlist                                    */
/*                                                                         */
/* attr         (IN) attribute list to test                                */
/*                                                                         */
/* predicatelen (IN) length of the predicate string                        */
/*                                                                         */
/* predicate    (IN) the predicate string                                  */
/*                                                                         */
/* Returns: Zero on success.  Nonzero on failure                           */
/*=========================================================================*/
{
    SLPAttributes   attr;
    FilterResult    err;
    char            attrnull;
    char            tagnull;
    
    *result = 0;
    *resultlen = 0;
    
    /* TRICKY: Temporarily NULL terminate the attribute list     */
    /*         and the tag string.  We can do this because       */
    /*         there is room in the corresponding SLPv2 SRVREG   */
    /*         and ATTRRQST messages.  Basically we are squashing */
    /*         the authcount and the spi string length.  Don't   */
    /*         worry, we fix things up later and it is MUCH      */
    /*         faster than a malloc() for a new buffer 1 byte    */
    /*         longer!                                           */
    tagnull = taglist[taglistlen];
    ((char*)taglist)[taglistlen] = 0;
    attrnull = attrlist[attrlistlen];
    ((char*)attrlist)[attrlistlen] = 0;


    /* Generate an SLPAttr from the comma delimited list */
    err = 1;
    if(SLPAttrAlloc("en", NULL, SLP_FALSE, &attr) == 0)
    {
        if(SLPAttrFreshen(attr, attrlist) == 0)
        {
            err = SLPAttrSerialize(attr,
                                   taglist,
                                   result,
                                   *resultlen,
                                   resultlen,
                                   SLP_FALSE);
        }
        
        SLPAttrFree(attr);
    }

    /* SLPAttrSerialize counts the NULL terminator which we don't care about*/
    *resultlen -=1; 

    /* Un null terminate */
    ((char*)taglist)[taglistlen] = tagnull;
    ((char*)attrlist)[attrlistlen] = attrnull;

    return (*resultlen == 0);
}
Esempio n. 6
0
/*=========================================================================*/
int SLPDPredicateTest(int version,
                      int attrlistlen,
                      const char* attrlist,
                      int predicatelen,
                      const char* predicate)
/* Determine whether the specified attribute list satisfies                */
/* the specified predicate                                                 */
/*                                                                         */
/* version    (IN) SLP version of the predicate string (should always be   */
/*                 2 since we don't handle SLPv1 predicates yet)           */
/*                                                                         */
/* attrlistlen  (IN) length of attrlist                                    */
/*                                                                         */
/* attr         (IN) attribute list to test                                */
/*                                                                         */
/* predicatelen (IN) length of the predicate string                        */
/*                                                                         */
/* predicate    (IN) the predicate string                                  */
/*                                                                         */
/* Returns: Boolean value.  Zero of test fails.  Non-zero if test fails    */
/*          or if there is a parse error in the predicate string           */
/*=========================================================================*/
{
    SLPAttributes   attr;
    const char      *end; /* Pointer to the end of the parsed attribute string. */
    FilterResult    err;
    char            attrnull;
    char            prednull;
    int             result = 0;

    /* An NULL or empty string is always true. */
    if(predicate == 0 || *(char *)predicate == 0)
    {
        return 1;
    }

    /*  We don't handle SLPv1 predicates yet.  We'll say they all match */
    if(version != 2)
    {
        return 1;
    }

    /* TRICKY: Temporarily NULL terminate the attribute list     */
    /*         and the predicate string.  We can do this because */
    /*         there is room in the corresponding SLPv2 SRVREG   */
    /*         and SRVRQST messages.  Basically we are squashing */
    /*         the authcount and the spi string length.  Don't   */
    /*         worry, we fix things up later and it is MUCH      */
    /*         faster than a malloc() for a new buffer 1 byte    */
    /*         longer!                                           */
    prednull = predicate[predicatelen];
    ((char*)predicate)[predicatelen] = 0;
    attrnull = attrlist[attrlistlen];
    ((char*)attrlist)[attrlistlen] = 0;
    
    /* Generate an SLPAttr from the comma delimited list */
    if(SLPAttrAlloc("en", NULL, SLP_FALSE, &attr) == 0)
    {
        if(SLPAttrFreshen(attr, attrlist) == 0)
        {
            err = filter(predicate, &end, attr, SLPD_ATTR_RECURSION_DEPTH);
            
            /* Check for trailing trash data. */
            if((err == FR_EVAL_TRUE || err == FR_EVAL_FALSE) && *end != 0)
            {
                result = 0;
            }
            else if(err == FR_EVAL_TRUE)
            {
                result = 1;
            }
        }
        
        SLPAttrFree(attr);
    }

    /* Un null terminate */
    ((char*)predicate)[predicatelen] = prednull;
    ((char*)attrlist)[attrlistlen] = attrnull;

    return result;
}