search.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* Copyright 2001-2002 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* The contents of this file are subject to the Netscape Public
* License Version 1.1 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code is Mozilla Communicator client code, released
* March 31, 1998.
*
* The Initial Developer of the Original Code is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998-1999 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
*/
/*
* Copyright (c) 1990 Regents of the University of Michigan.
* All rights reserved.
*/
/*
* search.c
*/
#if 0
#ifndef lint
static char copyright[] = "@(#) Copyright (c) 1990 Regents of the University of Michigan.\nAll rights reserved.\n";
#endif
#endif
#include "ldap-int.h"
int defaultvalue );
static char *find_right_paren( char *s );
static int unescape_filterval( char *str );
static int hexchar2int( char c );
static int is_valid_attr( char *a );
char *str );
LDAPMessage **res );
/*
* ldap_search - initiate an ldap search operation. Parameters:
*
* ld LDAP descriptor
* base DN of the base object
* scope the search scope - one of LDAP_SCOPE_BASE,
* LDAP_SCOPE_ONELEVEL, LDAP_SCOPE_SUBTREE
* filter a string containing the search filter
* (e.g., "(|(cn=bob)(sn=bob))")
* attrs list of attribute types to return for matches
* attrsonly 1 => attributes only 0 => attributes and values
*
* Example:
* char *attrs[] = { "mail", "title", 0 };
* msgid = ldap_search( ld, "c=us@o=UM", LDAP_SCOPE_SUBTREE, "cn~=bob",
* attrs, attrsonly );
*/
int
const char *base,
int scope,
const char *filter,
char **attrs,
int attrsonly
)
{
int msgid;
return( msgid );
} else {
return( -1 ); /* error is in ld handle */
}
}
/*
* LDAPv3 extended search.
* Returns an LDAP error code.
*/
int
const char *base,
int scope,
const char *filter,
char **attrs,
int attrsonly,
int sizelimit,
int *msgidp
)
{
/*
* It is an error to pass in a zero'd timeval.
*/
}
return( LDAP_PARAM_ERROR );
}
}
/*
* Like ldap_search_ext() except an integer timelimit is passed instead of
* using the overloaded struct timeval *timeoutp.
*/
static int
const char *base,
int scope,
const char *filter,
char **attrs,
int attrsonly,
int timelimit, /* -1 means use ld->ld_timelimit */
int sizelimit, /* -1 means use ld->ld_sizelimit */
int *msgidp
)
{
unsigned long key; /* XXXmcs: memcache */
if ( !NSLDAPI_VALID_LDAP_POINTER( ld )) {
return( LDAP_PARAM_ERROR );
}
base = "";
}
filter = "(objectclass=*)";
}
|| ( sizelimit < -1 )) {
return( LDAP_PARAM_ERROR );
}
/*
* XXXmcs: should use cache function pointers to hook in memcache
*/
return LDAP_SUCCESS;
}
/* check the cache */
return( LDAP_SUCCESS );
}
}
/* caching off or did not find it in the cache - check the net */
return( rc );
}
/* send the message */
/*
* XXXmcs: should use cache function pointers to hook in memcache
*/
}
}
/*
* Convert a non-NULL timeoutp to a value in seconds that is appropriate to
* send in an LDAP search request. If timeoutp is NULL, return defaultvalue.
*/
static int
{
int timelimit;
} else {
/*
* both tv_sec and tv_usec are less than one (zero?) so
* to maintain compatiblity with our "zero means no limit"
* convention we pass no limit to the server.
*/
timelimit = 0; /* no limit */
}
return( timelimit );
}
/* returns an LDAP error code and also sets it in ld */
int
const char *base,
int scope,
const char *filter,
char **attrs,
int attrsonly,
int timelimit, /* if -1, ld->ld_timelimit is used */
int sizelimit, /* if -1, ld->ld_sizelimit is used */
int msgid,
)
{
int err;
char *fdup;
/*
* Create the search request. It looks like this:
* SearchRequest := [APPLICATION 3] SEQUENCE {
* baseObject DistinguishedName,
* scope ENUMERATED {
* baseObject (0),
* singleLevel (1),
* wholeSubtree (2)
* },
* derefAliases ENUMERATED {
* neverDerefaliases (0),
* derefInSearching (1),
* derefFindingBaseObj (2),
* alwaysDerefAliases (3)
* },
* sizelimit INTEGER (0 .. 65535),
* timelimit INTEGER (0 .. 65535),
* attrsOnly BOOLEAN,
* filter Filter,
* attributes SEQUENCE OF AttributeType
* }
* wrapped in an ldap message.
*/
/* create a message to send */
!= LDAP_SUCCESS ) {
return( err );
}
base = "";
}
if ( sizelimit == -1 ) {
}
if ( timelimit == -1 ) {
}
#ifdef CLDAP
} else {
#endif /* CLDAP */
#ifdef CLDAP
}
#endif /* CLDAP */
if ( err == -1 ) {
return( LDAP_ENCODING_ERROR );
}
return( LDAP_NO_MEMORY );
}
NSLDAPI_FREE( fdup );
if ( err == -1 ) {
return( LDAP_FILTER_ERROR );
}
return( LDAP_ENCODING_ERROR );
}
!= LDAP_SUCCESS ) {
return( err );
}
return( LDAP_SUCCESS );
}
static char *
find_right_paren( char *s )
{
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 char *
char *str,
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 */
return( NULL );
str++;
return( NULL );
*next = '\0';
return( NULL );
*next++ = ')';
/* flush explicit tagged thang */
return( NULL );
return( next );
}
int
{
char *next;
/*
* 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
* }
*
* SubstringFilter ::= SEQUENCE {
* type AttributeType,
* SEQUENCE OF CHOICE {
* initial [0] IA5String,
* any [1] IA5String,
* final [2] IA5String
* }
* }
* Note: tags in a choice are always explicit
*/
parens = 0;
while ( *str ) {
switch ( *str ) {
case '(':
str++;
parens++;
switch ( *str ) {
case '&':
0, 0, 0 );
LDAP_FILTER_AND, 0 )) == NULL )
return( -1 );
parens--;
break;
case '|':
0, 0, 0 );
LDAP_FILTER_OR, 0 )) == NULL )
return( -1 );
parens--;
break;
case '!':
0, 0, 0 );
return( -1 );
parens--;
break;
default:
"put_filter: simple\n", 0, 0, 0 );
balance = 1;
escape = 0;
if ( escape == 0 ) {
if ( *next == '(' )
balance++;
else if ( *next == ')' )
balance--;
}
escape = 1;
else
escape = 0;
if ( balance )
next++;
}
if ( balance != 0 )
return( -1 );
*next = '\0';
return( -1 );
}
*next++ = ')';
parens--;
break;
}
break;
case ')':
0 );
return( -1 );
str++;
parens--;
break;
case ' ':
str++;
break;
default: /* assume it's a simple type=value filter */
0 );
return( -1 );
}
break;
}
}
return( parens ? -1 : 0 );
}
/*
* Put a list of filters like this "(filter1)(filter2)..."
*/
static int
{
char *next;
char save;
while ( *str ) {
str++;
if ( *str == '\0' )
break;
return( -1 );
/* now we have "(filter)" with str pointing to it */
*next = '\0';
return( -1 );
}
return( 0 );
}
/*
* is_valid_attr - returns 1 if a is a syntactically valid left-hand side
* of a filter expression, 0 otherwise. A valid string may contain only
* letters, numbers, hyphens, semi-colons, colons and periods. examples:
* cn
* cn;lang-fr
* 1.2.3.4;binary;dynamic
* mail;dynamic
* cn:dn:1.2.3.4
*
* For compatibility with older servers, we also allow underscores in
* attribute types, even through they are not allowed by the LDAPv3 RFCs.
*/
static int
is_valid_attr( char *a )
{
for ( ; *a; a++ ) {
if ( !isascii( *a ) ) {
return( 0 );
} else if ( !isalnum( *a ) ) {
switch ( *a ) {
case '-':
case '.':
case ';':
case ':':
case '_':
break; /* valid */
default:
return( 0 );
}
}
}
return( 1 );
}
static char *
find_star( char *s )
{
for ( ; *s; ++s ) {
switch ( *s ) {
case '*': return s;
case '\\':
++s;
default: break;
}
}
return NULL;
}
static int
{
char *value;
char *oid; /* for v3 extended filter */
int dnattr; /* for v3 extended filter */
return( rc );
}
goto free_and_return;
}
value = s + 1;
*s-- = '\0';
filterop = *s;
filterop == ':' ) {
*s = '\0';
}
if ( ! is_valid_attr( str ) ) {
goto free_and_return;
}
switch ( filterop ) {
case '<':
break;
case '>':
break;
case '~':
break;
case ':': /* extended filter - v3 only */
/*
* extended filter looks like this:
*
* [type][':dn'][':'oid]':='value
*
* where one of type or :oid is required.
*
*/
goto free_and_return;
}
dnattr = 1;
*s2 = '\0';
} else {
dnattr = 0;
*s2 = '\0';
dnattr = 1;
} else {
goto free_and_return;
}
*s3 = '\0';
}
}
goto free_and_return;
}
oid )) == -1 ) {
goto free_and_return;
}
}
if ( *str != '\0' ) {
goto free_and_return;
}
}
goto free_and_return;
}
rc = 0;
goto free_and_return;
/* break; */
default:
} else {
goto free_and_return;
}
break;
}
if ( ftype == LDAP_FILTER_PRESENT ) {
}
if ( rc != -1 ) {
rc = 0;
}
NSLDAPI_FREE( str );
return( rc );
}
/*
* Undo in place both LDAPv2 (RFC-1960) and LDAPv3 (hexadecimal) escape
* sequences within the null-terminated string 'val'. The resulting value
* may contain null characters.
*
* If 'val' contains invalid escape sequences we return -1.
* Otherwise the length of the unescaped value is returned.
*/
static int
unescape_filterval( char *val )
{
char *s, *d;
escape = 0;
for ( s = d = val; *s; s++ ) {
if ( escape ) {
/*
* first try LDAPv3 escape (hexadecimal) sequence
*/
if (( ival = hexchar2int( *s )) < 0 ) {
if ( firstdigit ) {
/*
* LDAPv2 (RFC1960) escape sequence
*/
*d++ = *s;
escape = 0;
} else {
return(-1);
}
}
if ( firstdigit ) {
*d = ( ival<<4 );
firstdigit = 0;
} else {
*d++ |= ival;
escape = 0;
}
} else if ( *s != '\\' ) {
*d++ = *s;
escape = 0;
} else {
escape = 1;
firstdigit = 1;
}
}
return( d - val );
}
/*
* convert character 'c' that represents a hexadecimal digit to an integer.
* if 'c' is not a hexidecimal digit [0-9A-Fa-f], -1 is returned.
* otherwise the converted value is returned.
*/
static int
hexchar2int( char c )
{
if ( c >= '0' && c <= '9' ) {
return( c - '0' );
}
if ( c >= 'A' && c <= 'F' ) {
return( c - 'A' + 10 );
}
if ( c >= 'a' && c <= 'f' ) {
return( c - 'a' + 10 );
}
return( -1 );
}
static int
{
int len;
val, 0 );
return( -1 );
}
*nextstar++ = '\0';
}
if ( gotstar == 0 ) {
} else {
}
if ( *val != '\0' ) {
return( -1 );
}
}
gotstar = 1;
}
return( -1 );
}
return( 0 );
}
int
const char *base,
int scope,
const char *filter,
char **attrs,
int attrsonly,
)
{
}
int
const char *base,
int scope,
const char *filter,
char **attrs,
int attrsonly,
)
{
}
int LDAP_CALL
const char *base,
int scope,
const char *filter,
char **attrs,
int attrsonly,
int sizelimit,
)
{
}
static int
const char *base,
int scope,
const char *filter,
char **attrs,
int attrsonly,
struct timeval *localtimeoutp,
int timelimit, /* -1 means use ld->ld_timelimit */
int sizelimit, /* -1 means use ld->ld_sizelimit */
)
{
/*
* It is an error to pass in a zero'd timeval.
*/
localtimeoutp->tv_usec == 0 ) {
}
}
return( LDAP_PARAM_ERROR );
}
!= LDAP_SUCCESS ) {
}
return( err );
}
/*
* Error. ldap_result() sets *res to NULL for us.
*/
}
err = LDAP_TIMEOUT;
}
return( err );
}
}