2 * Copyright (c) 1990 Regents of the University of Michigan.
5 * Redistribution and use in source and binary forms are permitted
6 * provided that this notice is preserved and that due credit is given
7 * to the University of Michigan at Ann Arbor. The name of the University
8 * may not be used to endorse or promote products derived from this
9 * software without specific prior written permission. This software
10 * is provided ``as is'' without express or implied warranty.
17 #include <ac/socket.h>
18 #include <ac/string.h>
20 #include <quipu/commonarg.h>
21 #include <quipu/attrvalue.h>
22 #include <quipu/ds_error.h>
23 #include <quipu/ds_search.h>
24 #include <quipu/dap2.h>
25 #include <quipu/dua.h>
32 static get_filter_list();
33 static get_substring_filter();
37 extern int ldap_compat;
38 #define SEARCHRESTAG (ldap_compat == 20 ? OLD_LDAP_RES_SEARCH_RESULT : LDAP_RES_SEARCH_RESULT)
40 #define SEARCHRESTAG LDAP_RES_SEARCH_RESULT
52 int sizelimit, timelimit;
55 struct ds_search_arg sa;
56 static CommonArgs common = default_common_args;
57 extern DN ldap_str2dn();
59 Debug( LDAP_DEBUG_TRACE, "do_search\n", 0, 0, 0 );
62 * Parse the search request. It looks like this:
63 * SearchRequest := [APPLICATION 3] SEQUENCE {
64 * baseObject DistinguishedName,
70 * derefAliases ENUMERATED {
71 * neverDerefaliases (0),
72 * derefInSearching (1),
73 * derefFindingBaseObj (2),
74 * alwaysDerefAliases (3)
76 * sizelimit INTEGER (0 .. 65535),
77 * timelimit INTEGER (0 .. 65535),
80 * attributes SEQUENCE OF AttributeType
84 #if ISODEPACKAGE == IC
86 DAS_SearchArgument_INIT( &sa );
90 if ( ber_scanf( ber, "{aiiiib", &base, &sa.sra_subset, &deref,
91 &sizelimit, &timelimit, &attrsonly ) == LBER_ERROR ) {
92 send_ldap_msgresult( clientsb, SEARCHRESTAG, m,
93 LDAP_PROTOCOL_ERROR, NULL, "" );
97 sa.sra_baseobject = ldap_str2dn( base );
98 if ( sa.sra_baseobject == NULLDN && *base != '\0' ) {
100 send_ldap_msgresult( clientsb, SEARCHRESTAG, m,
101 LDAP_INVALID_DN_SYNTAX, NULL, "" );
106 sa.sra_common = common; /* struct copy */
107 sa.sra_searchaliases = (deref == LDAP_DEREF_SEARCHING ||
108 deref == LDAP_DEREF_ALWAYS);
109 if ( deref == LDAP_DEREF_NEVER || deref == LDAP_DEREF_SEARCHING )
110 sa.sra_common.ca_servicecontrol.svc_options |=
111 SVC_OPT_DONTDEREFERENCEALIAS;
113 sa.sra_common.ca_servicecontrol.svc_sizelimit = (sizelimit == 0 ?
114 SVC_NOSIZELIMIT : sizelimit);
116 sa.sra_common.ca_servicecontrol.svc_timelimit = (timelimit == 0 ?
117 SVC_NOTIMELIMIT : timelimit);
119 sa.sra_eis.eis_infotypes = (attrsonly ? EIS_ATTRIBUTETYPESONLY :
120 EIS_ATTRIBUTESANDVALUES);
123 if ( (err = get_filter( ber, &sa.sra_filter )) != 0 ) {
124 send_ldap_msgresult( clientsb, SEARCHRESTAG, m,
125 err, NULL, "Bad search filter" );
130 if ( ldap_debug & LDAP_DEBUG_ARGS ) {
133 ps = ps_alloc( std_open );
134 std_setup( ps, stderr );
135 ps_print( ps, "Filter: " );
136 fi_print( ps, sa.sra_filter, EDBOUT );
137 ps_print( ps, "\n" );
142 /* attrs to return */
144 if ( ber_scanf( ber, "{v}}", &attrs ) == LBER_ERROR ) {
145 send_ldap_msgresult( clientsb, SEARCHRESTAG, m,
146 LDAP_PROTOCOL_ERROR, NULL, "" );
149 sa.sra_eis.eis_select = NULLATTR;
150 if ( attrs == NULL ) {
151 sa.sra_eis.eis_allattributes = 1;
156 sa.sra_eis.eis_allattributes = 0;
157 for ( i = 0; attrs[i] != NULL; i++ ) {
160 if ( (type = AttrT_new( attrs[i] )) == NULLAttrT ) {
161 Debug( LDAP_DEBUG_TRACE, "unknown attr (%s)\n",
166 as = as_comp_alloc();
167 as->attr_type = type;
168 as->attr_acl = NULLACL_INFO;
169 as->attr_link = NULLATTR;
170 as->attr_value = NULLAV;
172 sa.sra_eis.eis_select = as_merge( as,
173 sa.sra_eis.eis_select );
176 /* complain only if we know about none of the attrs */
177 if ( sa.sra_eis.eis_select == NULLATTR ) {
178 send_ldap_msgresult( clientsb, SEARCHRESTAG,
179 m, LDAP_UNDEFINED_TYPE, NULL, attrs[0] );
180 charlist_free( attrs );
184 charlist_free( attrs );
187 rc = initiate_dap_operation( OP_SEARCH, m, &sa );
189 #ifdef LDAP_CONNECTIONLESS
191 m->m_searchbase = sa.sra_baseobject;
193 #endif /* LDAP_CONNECTIONLESS */
194 dn_free( sa.sra_baseobject );
196 filter_free( sa.sra_filter );
197 as_free( sa.sra_eis.eis_select );
200 send_ldap_msgresult( clientsb, SEARCHRESTAG, m,
208 static get_filter( BerElement *ber, Filter *filt )
210 unsigned long tag, len;
215 Debug( LDAP_DEBUG_TRACE, "get_filter\n", 0, 0, 0 );
218 * A filter looks like this coming in:
219 * Filter ::= CHOICE {
220 * and [0] SET OF Filter,
221 * or [1] SET OF Filter,
223 * equalityMatch [3] AttributeValueAssertion,
224 * substrings [4] SubstringFilter,
225 * greaterOrEqual [5] AttributeValueAssertion,
226 * lessOrEqual [6] AttributeValueAssertion,
227 * present [7] AttributeType,,
228 * approxMatch [8] AttributeValueAssertion
231 * SubstringFilter ::= SEQUENCE {
232 * type AttributeType,
233 * SEQUENCE OF CHOICE {
234 * initial [0] IA5String,
236 * final [2] IA5String
243 f->flt_next = NULLFILTER;
246 switch (tag = ber_peek_tag( ber, &len )) {
248 case OLD_LDAP_FILTER_EQUALITY:
250 case LDAP_FILTER_EQUALITY:
251 Debug( LDAP_DEBUG_ARGS, "EQUALITY\n", 0, 0, 0 );
252 f->flt_type = FILTER_ITEM;
253 f->FUITEM.fi_type = FILTERITEM_EQUALITY;
255 if ( ldap_compat == 30 )
256 (void) ber_skip_tag( ber, &len );
259 if ( (err = get_ava( ber, &f->FUITEM.UNAVA )) != 0 ) {
266 case OLD_LDAP_FILTER_SUBSTRINGS:
268 case LDAP_FILTER_SUBSTRINGS:
269 Debug( LDAP_DEBUG_ARGS, "SUBSTRINGS\n", 0, 0, 0 );
270 err = get_substring_filter( ber, f );
274 case OLD_LDAP_FILTER_GE:
277 Debug( LDAP_DEBUG_ARGS, "GE\n", 0, 0, 0 );
278 f->flt_type = FILTER_ITEM;
279 f->FUITEM.fi_type = FILTERITEM_GREATEROREQUAL;
281 if ( ldap_compat == 30 )
282 (void) ber_skip_tag( ber, &len );
284 if ( (err = get_ava( ber, &f->FUITEM.UNAVA )) != 0 ) {
291 case OLD_LDAP_FILTER_LE:
294 Debug( LDAP_DEBUG_ARGS, "LE\n", 0, 0, 0 );
295 f->flt_type = FILTER_ITEM;
296 f->FUITEM.fi_type = FILTERITEM_LESSOREQUAL;
298 if ( ldap_compat == 30 )
299 (void) ber_skip_tag( ber, &len );
302 if ( (err = get_ava( ber, &f->FUITEM.UNAVA )) != 0 ) {
309 case OLD_LDAP_FILTER_PRESENT:
312 case LDAP_FILTER_PRESENT_30:
314 case LDAP_FILTER_PRESENT:
315 Debug( LDAP_DEBUG_ARGS, "PRESENT\n", 0, 0, 0 );
316 f->flt_type = FILTER_ITEM;
317 f->FUITEM.fi_type = FILTERITEM_PRESENT;
318 len = sizeof(typestr);
320 if ( ldap_compat == 30 )
321 (void) ber_skip_tag( ber, &len );
324 if ( ber_scanf( ber, "s", typestr, &len ) == LBER_ERROR )
325 return( LDAP_PROTOCOL_ERROR );
326 if ( (f->FUITEM.UNTYPE = str2AttrT( typestr )) == NULLAttrT )
327 return( LDAP_UNDEFINED_TYPE );
331 case OLD_LDAP_FILTER_APPROX:
333 case LDAP_FILTER_APPROX:
334 Debug( LDAP_DEBUG_ARGS, "APPROX\n", 0, 0, 0 );
335 f->flt_type = FILTER_ITEM;
336 f->FUITEM.fi_type = FILTERITEM_APPROX;
338 if ( ldap_compat == 30 )
339 (void) ber_skip_tag( ber, &len );
342 if ( (err = get_ava( ber, &f->FUITEM.UNAVA )) != 0 ) {
349 case OLD_LDAP_FILTER_AND:
351 case LDAP_FILTER_AND:
352 Debug( LDAP_DEBUG_ARGS, "AND\n", 0, 0, 0 );
353 f->flt_type = FILTER_AND;
354 err = get_filter_list( ber, f );
358 case OLD_LDAP_FILTER_OR:
361 Debug( LDAP_DEBUG_ARGS, "OR\n", 0, 0, 0 );
362 f->flt_type = FILTER_OR;
363 err = get_filter_list( ber, f );
367 case OLD_LDAP_FILTER_NOT:
369 case LDAP_FILTER_NOT:
370 Debug( LDAP_DEBUG_ARGS, "NOT\n", 0, 0, 0 );
371 f->flt_type = FILTER_NOT;
372 (void) ber_skip_tag( ber, &len );
373 err = get_filter( ber, &f->FUFILT );
377 Debug( LDAP_DEBUG_ANY, "unknown filter type %d\n", tag, 0, 0 );
379 return( LDAP_PROTOCOL_ERROR );
383 Debug( LDAP_DEBUG_TRACE, "end get_filter\n", 0, 0, 0 );
387 static get_filter_list( BerElement *ber, Filter f )
391 unsigned long tag, len;
394 Debug( LDAP_DEBUG_TRACE, "get_filter_list\n", 0, 0, 0 );
397 if ( ldap_compat == 30 )
398 (void) ber_skip_tag( ber, &len );
400 f->FUFILT = tail = NULLFILTER;
401 for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT;
402 tag = ber_next_element( ber, &len, last ) ) {
403 if ( (err = get_filter( ber, &new )) != 0 )
406 if ( f->FUFILT == NULLFILTER ) {
409 tail->flt_next = new;
414 Debug( LDAP_DEBUG_TRACE, "end get_filter_list\n", 0, 0, 0 );
418 static get_substring_filter( BerElement *ber, Filter f )
420 unsigned long tag, len;
424 AttributeValue value;
425 extern short ldap_dn_syntax;
427 Debug( LDAP_DEBUG_TRACE, "get_substring_filter\n", 0, 0, 0 );
430 if ( ldap_compat == 30 )
431 (void) ber_skip_tag( ber, &len );
434 f->flt_type = FILTER_ITEM;
435 f->FUITEM.fi_type = FILTERITEM_SUBSTRINGS;
436 len = sizeof(typestr);
437 if ( ber_scanf( ber, "{s", typestr, &len ) == LBER_ERROR ) {
438 return( LDAP_PROTOCOL_ERROR );
440 if ( (type = str2AttrT( typestr )) == NULLAttrT ) {
441 return( LDAP_UNDEFINED_TYPE );
443 f->FUITEM.UNSUB.fi_sub_type = type;
444 f->FUITEM.UNSUB.fi_sub_initial = NULLAV;
445 f->FUITEM.UNSUB.fi_sub_any = NULLAV;
446 f->FUITEM.UNSUB.fi_sub_final = NULLAV;
447 for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT;
448 tag = ber_next_element( ber, &len, last ) ) {
449 AV_Sequence avs, any_end;
452 if ( ldap_compat == 30 ) {
453 if ( ber_scanf( ber, "{a}", &valstr ) == LBER_ERROR ) {
454 return( LDAP_PROTOCOL_ERROR );
458 if ( ber_scanf( ber, "a", &valstr ) == LBER_ERROR ) {
459 return( LDAP_PROTOCOL_ERROR );
462 value = ldap_str2AttrV( valstr, type->oa_syntax );
465 if ( value == NULLAttrV ) {
466 return( LDAP_INVALID_SYNTAX );
469 if ( (avs = avs_comp_new( value )) == NULLAV )
470 return( LDAP_OPERATIONS_ERROR );
474 case OLD_LDAP_SUBSTRING_INITIAL:
477 case LDAP_SUBSTRING_INITIAL_30:
479 case LDAP_SUBSTRING_INITIAL:
480 Debug( LDAP_DEBUG_ARGS, " INITIAL\n", 0, 0, 0 );
481 if ( f->FUITEM.UNSUB.fi_sub_initial != NULLAV
482 && f->FUITEM.UNSUB.fi_sub_initial->avseq_next
484 return( LDAP_PROTOCOL_ERROR );
486 f->FUITEM.UNSUB.fi_sub_initial = avs;
490 case OLD_LDAP_SUBSTRING_ANY:
493 case LDAP_SUBSTRING_ANY_30:
495 case LDAP_SUBSTRING_ANY:
496 Debug( LDAP_DEBUG_ARGS, " ANY\n", 0, 0, 0 );
498 if (f->FUITEM.UNSUB.fi_sub_any != NULLAV) {
499 any_end->avseq_next = avs;
501 f->FUITEM.UNSUB.fi_sub_any = avs;
508 case OLD_LDAP_SUBSTRING_FINAL:
511 case LDAP_SUBSTRING_FINAL_30:
513 case LDAP_SUBSTRING_FINAL:
514 Debug( LDAP_DEBUG_ARGS, " FINAL\n", 0, 0, 0 );
515 if ( f->FUITEM.UNSUB.fi_sub_final != NULLAV
516 && f->FUITEM.UNSUB.fi_sub_final->avseq_next
518 return( LDAP_PROTOCOL_ERROR );
520 f->FUITEM.UNSUB.fi_sub_final = avs;
524 Debug( LDAP_DEBUG_ARGS, " unknown type\n", tag, 0, 0 );
525 return( LDAP_PROTOCOL_ERROR );
529 Debug( LDAP_DEBUG_TRACE, "end get_substring_filter\n", 0, 0, 0 );
537 struct ds_search_result *sr
544 Debug( LDAP_DEBUG_TRACE, "search_result\n", 0, 0, 0 );
548 if ( ! sr->srr_correlated ) {
549 Debug( LDAP_DEBUG_ARGS, "correlating results\n", 0, 0, 0 );
550 correlate_search_results( sr );
553 #ifdef LDAP_CONNECTIONLESS
555 if ((ber = der_alloc()) == NULLBER ) {
556 send_ldap_msgresult( sb, SEARCHRESTAG, m,
557 LDAP_OPERATIONS_ERROR, NULL, "der_alloc" );
560 if ( ber_printf( ber, "t{is{", LBER_SEQUENCE, m->m_msgid,
562 send_ldap_msgresult( sb, SEARCHRESTAG, m,
563 LDAP_OPERATIONS_ERROR, NULL, "ber_printf" );
569 for ( e = sr->CSR_entries; e != NULLENTRYINFO; e = e->ent_next ) {
570 Debug( LDAP_DEBUG_ARGS, "\tentry:\n", 0, 0, 0 );
572 #ifdef LDAP_CONNECTIONLESS
574 #endif /* LDAP_CONNECTIONLESS */
576 if ( (ber = der_alloc()) == NULLBER ) {
577 send_ldap_msgresult( sb, SEARCHRESTAG, m,
578 LDAP_OPERATIONS_ERROR, NULL, "der_alloc" );
583 if ( version == 1 ) {
584 if ( ber_printf( ber, "t{it{", OLD_LBER_SEQUENCE,
585 m->m_msgid, OLD_LDAP_RES_SEARCH_ENTRY ) == -1 ) {
586 send_ldap_msgresult( sb, SEARCHRESTAG, m,
587 LDAP_OPERATIONS_ERROR, NULL, "ber_printf" );
593 if ( ldap_compat == 30 ) {
594 if ( ber_printf( ber, "{it{{", m->m_msgid,
595 LDAP_RES_SEARCH_ENTRY ) == -1 ) {
596 send_ldap_msgresult( sb, SEARCHRESTAG, m,
597 LDAP_OPERATIONS_ERROR, NULL, "ber_printf" );
602 #ifdef LDAP_CONNECTIONLESS
604 rc = ber_printf( ber, "t{", LDAP_RES_SEARCH_ENTRY );
606 #endif /* LDAP_CONNECTIONLESS */
607 rc = ber_printf( ber, "{it{", m->m_msgid,
608 LDAP_RES_SEARCH_ENTRY );
611 send_ldap_msgresult( sb, SEARCHRESTAG, m,
612 LDAP_OPERATIONS_ERROR, NULL, "ber_printf" );
616 #ifdef LDAP_CONNECTIONLESS
618 rc = encode_dn( ber, e->ent_dn, m->m_searchbase );
619 #endif /* LDAP_CONNECTIONLESS */
621 rc = encode_dn( ber, e->ent_dn, NULLDN );
624 send_ldap_msgresult( sb, SEARCHRESTAG, m,
625 LDAP_OPERATIONS_ERROR, NULL, "encode_dn" );
629 if ( encode_attrs( ber, e->ent_attr ) == -1 ) {
630 send_ldap_msgresult( sb, SEARCHRESTAG, m,
631 LDAP_OPERATIONS_ERROR, NULL, "encode_attrs" );
636 if ( version == 1 ) {
637 if ( ber_printf( ber, "}}" ) == -1 ) {
638 send_ldap_msgresult( sb, SEARCHRESTAG, m,
639 LDAP_OPERATIONS_ERROR, NULL,
646 if ( ldap_compat == 30 ) {
647 if ( ber_printf( ber, "}}}" ) == -1 ) {
648 send_ldap_msgresult( sb, SEARCHRESTAG, m,
649 LDAP_OPERATIONS_ERROR, NULL,
655 #ifdef LDAP_CONNECTIONLESS
657 rc = ber_printf( ber, "}" );
659 #endif /* LDAP_CONNECTIONLESS */
660 rc = ber_printf( ber, "}}" );
663 send_ldap_msgresult( sb, SEARCHRESTAG, m,
664 LDAP_OPERATIONS_ERROR, NULL, "ber_printf 2" );
669 if ( ldap_debug & LDAP_DEBUG_BER )
670 trace_ber( 0, ber->ber_ptr - ber->ber_buf,
671 ber->ber_buf, stderr, 0, 0 );
674 #ifdef LDAP_CONNECTIONLESS
677 (void) ber_flush( sb, ber, 1 );
680 switch ( sr->CSR_limitproblem ) {
681 case LSR_NOLIMITPROBLEM:
684 case LSR_TIMELIMITEXCEEDED:
685 rc = LDAP_TIMELIMIT_EXCEEDED;
687 case LSR_SIZELIMITEXCEEDED:
688 case LSR_ADMINSIZEEXCEEDED:
689 rc = LDAP_SIZELIMIT_EXCEEDED;
693 Debug( LDAP_DEBUG_ARGS, "\tresult:\n", 0, 0, 0 );
695 #ifdef LDAP_CONNECTIONLESS
697 if ( ber_printf( ber, "t{ess}}}", SEARCHRESTAG, rc, "", "" )
699 send_ldap_msgresult( sb, SEARCHRESTAG, m,
700 LDAP_OPERATIONS_ERROR, NULL, "ber_printf" );
703 SAFEMEMCPY( (char *)sb->sb_useaddr, &m->m_clientaddr,
704 sizeof( struct sockaddr ));
705 if ( ber_flush( sb, ber, 1 ) != 0 ) {
706 send_ldap_msgresult( sb, SEARCHRESTAG, m,
707 LDAP_RESULTS_TOO_LARGE, NULL, "ber_flush" );
711 send_ldap_msgresult( sb, SEARCHRESTAG, m, rc, NULL, "" );