Commit 763c0de5 authored by Kurt Zeilenga's avatar Kurt Zeilenga
Browse files

Rework filter code

Misc cleanup / lint removal
parent f6be5028
......@@ -149,6 +149,33 @@ Package=<4>
Begin Project Dependency
Project_Dep_Name ucgendat
End Project Dependency
Begin Project Dependency
Project_Dep_Name dntest
End Project Dependency
Begin Project Dependency
Project_Dep_Name ftest
End Project Dependency
}}}
###############################################################################
Project: "dntest"=..\libraries\libldap\dntest.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name liblber
End Project Dependency
Begin Project Dependency
Project_Dep_Name libldap
End Project Dependency
Begin Project Dependency
Project_Dep_Name liblutil
End Project Dependency
}}}
###############################################################################
......@@ -183,6 +210,27 @@ Package=<4>
###############################################################################
Project: "ftest"=..\libraries\libldap\ftest.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name liblber
End Project Dependency
Begin Project Dependency
Project_Dep_Name libldap
End Project Dependency
Begin Project Dependency
Project_Dep_Name liblutil
End Project Dependency
}}}
###############################################################################
Project: "ldapdelete"=..\clients\tools\ldapdelete.dsp - Package Owner=<4>
Package=<5>
......
......@@ -17,7 +17,6 @@
#ifndef _LDAP_PVT_H
#define _LDAP_PVT_H 1
#include <ldap_cdefs.h>
#include <lber.h> /* get ber_slen_t */
LDAP_BEGIN_DECL
......@@ -107,6 +106,7 @@ LDAP_F (void) ldap_pvt_hex_unescape LDAP_P(( char *s ));
* these macros assume 'x' is an ASCII x
* and assume the "C" locale
*/
#define LDAP_ASCII(c) ((c) < 0x80)
#define LDAP_SPACE(c) ((c) == ' ' || (c) == '\t' || (c) == '\n')
#define LDAP_DIGIT(c) ((c) >= '0' && (c) <= '9')
#define LDAP_LOWER(c) ((c) >= 'a' && (c) <= 'z')
......@@ -114,6 +114,12 @@ LDAP_F (void) ldap_pvt_hex_unescape LDAP_P(( char *s ));
#define LDAP_ALPHA(c) (LDAP_LOWER(c) || LDAP_UPPER(c))
#define LDAP_ALNUM(c) (LDAP_ALPHA(c) || LDAP_DIGIT(c))
#define LDAP_LDH(c) (LDAP_ALNUM(c) || (c) == '-')
#define LDAP_HEXLOWER(c) ((c) >= 'a' && (c) <= 'f')
#define LDAP_HEXUPPER(c) ((c) >= 'A' && (c) <= 'F')
#define LDAP_HEX(c) (LDAP_DIGIT(c) || \
LDAP_HEXLOWER(c) || LDAP_HEXUPPER(c))
#ifdef HAVE_CYRUS_SASL
/* cyrus.c */
......
......@@ -18,7 +18,6 @@
#ifndef _LDAP_PVT_UC_H
#define _LDAP_PVT_UC_H 1
#include <ldap_cdefs.h>
#include <lber.h> /* get ber_slen_t */
#ifdef _MSC_VER
......@@ -79,13 +78,12 @@ LDAP_F (char*) ldap_utf8_strtok( char* sp, const char* sep, char **last);
LDAP_V (const char) ldap_utf8_lentab[128];
#define LDAP_UTF8_ISASCII(p) ( *(unsigned char *)(p) ^ 0x80 )
#define LDAP_UTF8_ISSPACE(p) ( *(p) == ' ' || (*(p) >= '\t' && *(p) <= '\r') )
#define LDAP_UTF8_CHARLEN(p) ( LDAP_UTF8_ISASCII(p) \
? 1 : ldap_utf8_lentab[*(unsigned char *)(p) ^ 0x80] )
#define LDAP_UTF8_OFFSET(p) ( LDAP_UTF8_ISASCII(p) \
? 1 : ldap_utf8_offset((p)) )
#define LDAP_UTF8_COPY(d,s) ( LDAP_UTF8_ISASCII(s) \
#define LDAP_UTF8_COPY(d,s) ( LDAP_UTF8_ISASCII(s) \
? (*(d) = *(s), 1) : ldap_utf8_copy((d),(s)) )
#define LDAP_UTF8_NEXT(p) ( LDAP_UTF8_ISASCII(p) \
......@@ -123,17 +121,17 @@ LDAP_LUNICODE_F(void) ucstr2upper(
ldap_unicode_t *,
ber_len_t );
#define UTF8_CASEFOLD 1
#define UTF8_NOCASEFOLD 0
#define LDAP_UTF8_CASEFOLD 0x1U
#define LDAP_UTF8_NOCASEFOLD 0x0U
LDAP_LUNICODE_F(char *) UTF8normalize(
struct berval *,
char );
unsigned );
LDAP_LUNICODE_F(int) UTF8normcmp(
const char *,
const char *,
char );
unsigned );
LDAP_END_DECL
......
......@@ -704,9 +704,7 @@ ber_scanf ( BerElement *ber,
}
}
breakout:
va_end( ap );
if ( rc == LBER_DEFAULT ) {
/*
* Error. Reclaim malloced memory that was given to the caller.
......
......@@ -219,10 +219,6 @@ SOURCE=.\options.c
# End Source File
# Begin Source File
SOURCE="..\..\include\queue-compat.h"
# End Source File
# Begin Source File
SOURCE=.\sockbuf.c
# End Source File
# End Target
......
......@@ -36,7 +36,7 @@
* attr and value) are supplied. The msgid of the response is returned.
*
* Example:
* struct berval bvalue = { "secret", strlen("secret") };
* struct berval bvalue = { "secret", sizeof("secret")-1 };
* rc = ldap_compare( ld, "c=us@cn=bob",
* "userPassword", &bvalue,
* sctrl, cctrl, &msgid )
......
......@@ -161,7 +161,7 @@ sb_sasl_drop_packet ( Sockbuf_Buf *sec_buf_in, int debuglevel )
len = sec_buf_in->buf_ptr - sec_buf_in->buf_end;
if ( len > 0 )
memmove( sec_buf_in->buf_base, sec_buf_in->buf_base +
AC_MEMCPY( sec_buf_in->buf_base, sec_buf_in->buf_base +
sec_buf_in->buf_end, len );
if ( len >= 4 ) {
......
......@@ -354,25 +354,21 @@ ldap_dn_normalize( const char *dnin, unsigned fin, char **dnout, unsigned fout )
*/
#define LDAP_DN_ASCII_SPACE(c) \
( (c) == ' ' || (c) == '\t' || (c) == '\n' || (c) == '\r' )
#define LDAP_DN_ASCII_LOWER(c) ( (c) >= 'a' && (c) <= 'z' )
#define LDAP_DN_ASCII_UPPER(c) ( (c) >= 'A' && (c) <= 'Z' )
#define LDAP_DN_ASCII_ALPHA(c) \
( LDAP_DN_ASCII_LOWER(c) || LDAP_DN_ASCII_UPPER(c) )
#define LDAP_DN_ASCII_DIGIT(c) ( (c) >= '0' && (c) <= '9' )
#define LDAP_DN_ASCII_LCASE_HEXALPHA(c) ( (c) >= 'a' && (c) <= 'f' )
#define LDAP_DN_ASCII_UCASE_HEXALPHA(c) ( (c) >= 'A' && (c) <= 'F' )
#define LDAP_DN_ASCII_HEXDIGIT(c) \
( LDAP_DN_ASCII_DIGIT(c) \
|| LDAP_DN_ASCII_LCASE_HEXALPHA(c) \
|| LDAP_DN_ASCII_UCASE_HEXALPHA(c) )
#define LDAP_DN_ASCII_ALNUM(c) \
( LDAP_DN_ASCII_ALPHA(c) || LDAP_DN_ASCII_DIGIT(c) )
#define LDAP_DN_ASCII_LOWER(c) LDAP_LOWER(c)
#define LDAP_DN_ASCII_UPPER(c) LDAP_UPPER(c)
#define LDAP_DN_ASCII_ALPHA(c) LDAP_ALPHA(c)
#define LDAP_DN_ASCII_DIGIT(c) LDAP_DIGIT(c)
#define LDAP_DN_ASCII_LCASE_HEXALPHA(c) LDAP_HEXLOWER(c)
#define LDAP_DN_ASCII_UCASE_HEXALPHA(c) LDAP_HEXUPPER(c)
#define LDAP_DN_ASCII_HEXDIGIT(c) LDAP_HEX(c)
#define LDAP_DN_ASCII_ALNUM(c) LDAP_ALNUM(c)
#define LDAP_DN_ASCII_PRINTABLE(c) ( (c) >= ' ' && (c) <= '~' )
/* attribute type */
#define LDAP_DN_OID_LEADCHAR(c) ( LDAP_DN_ASCII_DIGIT(c) )
#define LDAP_DN_DESC_LEADCHAR(c) ( LDAP_DN_ASCII_ALPHA(c) )
#define LDAP_DN_DESC_CHAR(c) ( LDAP_DN_ASCII_ALNUM(c) || (c) == '-' )
#define LDAP_DN_OID_LEADCHAR(c) LDAP_DIGIT(c)
#define LDAP_DN_DESC_LEADCHAR(c) LDAP_ALPHA(c)
#define LDAP_DN_DESC_CHAR(c) LDAP_LDH(c)
#define LDAP_DN_LANG_SEP(c) ( (c) == ';' )
#define LDAP_DN_ATTRDESC_CHAR(c) \
( LDAP_DN_DESC_CHAR(c) || LDAP_DN_LANG_SEP(c) )
......@@ -655,7 +651,6 @@ ldap_str2dn( const char *str, LDAPDN **dn, unsigned flags )
}
for ( ; p[ 0 ]; p++ ) {
LDAPDN *dn;
int err;
err = ldap_str2rdn( p, &newRDN, &p, flags );
......@@ -3060,7 +3055,8 @@ got_funcs:
}
Debug( LDAP_DEBUG_TRACE, "<= ldap_dn2bv(%s,%u)=%d\n", bv->bv_val, flags, rc );
Debug( LDAP_DEBUG_TRACE, "<= ldap_dn2bv(%s,%u)=%d\n",
bv->bv_val, flags, rc );
return_results:;
return( rc );
}
......
......@@ -183,6 +183,10 @@ SOURCE=.\extended.c
# End Source File
# Begin Source File
SOURCE=.\filter.c
# End Source File
# Begin Source File
SOURCE=.\free.c
# End Source File
# Begin Source File
......
......@@ -22,43 +22,6 @@
#include "ldap-int.h"
static int ldap_is_attr_oid LDAP_P((
const char *attr ));
static int ldap_is_attr_desc LDAP_P((
const char *attr ));
static int hex2value LDAP_P((
int c ));
static char *find_right_paren LDAP_P((
char *s ));
static char *put_complex_filter LDAP_P((
BerElement *ber,
char *str,
ber_tag_t tag,
int not ));
int ldap_int_put_filter LDAP_P((
BerElement *ber,
char *str ));
#define put_filter(b,s) ldap_int_put_filter((b),(s))
static int put_simple_filter LDAP_P((
BerElement *ber,
char *str ));
static int put_substring_filter LDAP_P((
BerElement *ber,
char *type,
char *str ));
static int put_filter_list LDAP_P((
BerElement *ber,
char *str,
ber_tag_t tag ));
/*
* ldap_search_ext - initiate an ldap search operation.
......@@ -334,7 +297,7 @@ ldap_build_search_req(
} else {
filter = LDAP_STRDUP( "(objectclass=*)" );
}
err = put_filter( ber, filter );
err = ldap_int_put_filter( ber, filter );
LDAP_FREE( filter );
if ( err == -1 ) {
......@@ -364,583 +327,6 @@ ldap_build_search_req(
return( ber );
}
static int ldap_is_attr_oid ( const char *attr )
{
int i, c, digit=0;
for( i = 0; (c = attr[i]) != 0; i++ ) {
if( c >= '0' && c <= '9' ) {
digit=1;
} else if ( c != '.' ) {
/* not digit nor '.' */
return 0;
} else if ( !digit ) {
/* '.' but prev not digit */
return 0;
} else {
/* '.' */
digit = 0;
}
}
return digit;
}
static int ldap_is_attr_desc ( const char *attr )
{
/* cheap attribute description check */
int i, c;
for( i = 0; (c = attr[i]) != 0; i++ ) {
if (( c >= '0' && c <= '9' )
|| ( c >= 'A' && c <= 'Z' )
|| ( c >= 'a' && c <= 'z' )
|| ( c == '.' || c == '-' )
|| ( c == ';' )) continue;
return 0;
}
return i > 0;
}
static char *
find_right_paren( char *s )
{
int balance, escape;
balance = 1;
escape = 0;
while ( *s && balance ) {
if ( escape == 0 ) {
if ( *s == '(' )
balance++;
else if ( *s == ')' )
balance--;
}
if ( *s == '\\' && ! escape )
escape = 1;
else
escape = 0;
if ( balance )
s++;
}
return( *s ? s : NULL );
}
static int hex2value( int c )
{
if( c >= '0' && c <= '9' ) {
return c - '0';
}
if( c >= 'A' && c <= 'F' ) {
return c + (10 - (int) 'A');
}
if( c >= 'a' && c <= 'f' ) {
return c + (10 - (int) 'a');
}
return -1;
}
char *
ldap_pvt_find_wildcard( const char *s )
{
for( ; *s != '\0' ; s++ ) {
switch( *s ) {
case '*': /* found wildcard */
return (char *) s;
case '\\':
s++; /* skip over escape */
if ( *s == '\0' )
return NULL; /* escape at end of string */
}
}
return NULL;
}
/* unescape filter value */
/* support both LDAP v2 and v3 escapes */
/* output can include nul characters! */
ber_slen_t
ldap_pvt_filter_value_unescape( char *fval )
{
ber_slen_t r, v;
int v1, v2;
for( r=v=0; fval[v] != '\0'; v++ ) {
switch( fval[v] ) {
case '\\':
/* escape */
v++;
if ( fval[v] == '\0' ) {
/* escape at end of string */
return -1;
}
if (( v1 = hex2value( fval[v] )) >= 0 ) {
/* LDAPv3 escape */
if (( v2 = hex2value( fval[v+1] )) < 0 ) {
/* must be two digit code */
return -1;
}
fval[r++] = v1 * 16 + v2;
v++;
} else {
/* LDAPv2 escape */
switch( fval[v] ) {
case '(':
case ')':
case '*':
case '\\':
fval[r++] = fval[v];
break;
default:
/* illegal escape */
return -1;
}
}
break;
default:
fval[r++] = fval[v];
}
}
fval[r] = '\0';
return r;
}
static char *
put_complex_filter( BerElement *ber, char *str, ber_tag_t tag, int not )
{
char *next;
/*
* We have (x(filter)...) with str sitting on
* the x. We have to find the paren matching
* the one before the x and put the intervening
* filters by calling put_filter_list().
*/
/* put explicit tag */
if ( ber_printf( ber, "t{" /*}*/, tag ) == -1 )
return( NULL );
str++;
if ( (next = find_right_paren( str )) == NULL )
return( NULL );
*next = '\0';
if ( put_filter_list( ber, str, tag ) == -1 )
return( NULL );
*next++ = ')';
/* flush explicit tagged thang */
if ( ber_printf( ber, /*{*/ "N}" ) == -1 )
return( NULL );
return( next );
}
int
ldap_int_put_filter( BerElement *ber, char *str )
{
char *next;
int parens, balance, escape;
/*
* A Filter looks like this:
* Filter ::= CHOICE {
* and [0] SET OF Filter,
* or [1] SET OF Filter,
* not [2] Filter,
* equalityMatch [3] AttributeValueAssertion,
* substrings [4] SubstringFilter,
* greaterOrEqual [5] AttributeValueAssertion,
* lessOrEqual [6] AttributeValueAssertion,
* present [7] AttributeType,
* approxMatch [8] AttributeValueAssertion,
* extensibleMatch [9] MatchingRuleAssertion -- LDAPv3
* }
*
* SubstringFilter ::= SEQUENCE {
* type AttributeType,
* SEQUENCE OF CHOICE {
* initial [0] IA5String,
* any [1] IA5String,
* final [2] IA5String
* }
* }
*
* MatchingRuleAssertion ::= SEQUENCE { -- LDAPv3
* matchingRule [1] MatchingRuleId OPTIONAL,
* type [2] AttributeDescription OPTIONAL,
* matchValue [3] AssertionValue,
* dnAttributes [4] BOOLEAN DEFAULT FALSE }
*
* Note: tags in a choice are always explicit
*/
Debug( LDAP_DEBUG_TRACE, "put_filter \"%s\"\n", str, 0, 0 );
parens = 0;
while ( *str ) {
switch ( *str ) {
case '(':
str++;
parens++;
/* skip spaces */
while( LDAP_SPACE( *str ) ) str++;
switch ( *str ) {
case '&':
Debug( LDAP_DEBUG_TRACE, "put_filter: AND\n",
0, 0, 0 );
if ( (str = put_complex_filter( ber, str,
LDAP_FILTER_AND, 0 )) == NULL )
return( -1 );
parens--;
break;
case '|':
Debug( LDAP_DEBUG_TRACE, "put_filter: OR\n",
0, 0, 0 );
if ( (str = put_complex_filter( ber, str,
LDAP_FILTER_OR, 0 )) == NULL )
return( -1 );
parens--;
break;
case '!':
Debug( LDAP_DEBUG_TRACE, "put_filter: NOT\n",
0, 0, 0 );
if ( (str = put_complex_filter( ber, str,
LDAP_FILTER_NOT, 1 )) == NULL )
return( -1 );
parens--;
break;
default:
Debug( LDAP_DEBUG_TRACE, "put_filter: simple\n",
0, 0, 0 );
balance = 1;
escape = 0;
next = str;
while ( *next && balance ) {
if ( escape == 0 ) {
if ( *next == '(' )
balance++;
else if ( *next == ')' )
balance--;
}
if ( *next == '\\' && ! escape )
escape = 1;
else
escape = 0;
if ( balance )
next++;
}
if ( balance != 0 )
return( -1 );
*next = '\0';
if ( put_simple_filter( ber, str ) == -1 ) {
return( -1 );
}
*next++ = ')';
str = next;
parens--;
break;
}
break;
case ')':
Debug( LDAP_DEBUG_TRACE, "put_filter: end\n", 0, 0,
0 );
if ( ber_printf( ber, /*[*/ "]" ) == -1 )
return( -1 );
str++;
parens--;
break;
case ' ':
str++;
break;
default: /* assume it's a simple type=value filter */
Debug( LDAP_DEBUG_TRACE, "put_filter: default\n", 0, 0,
0 );
next = strchr( str, '\0' );