1 /*
2 * Copyright (c) 2001 by Sun Microsystems, Inc.
3 * All rights reserved.
4 */
5
6 #pragma ident "%Z%%M% %I% %E% SMI"
7
8 /*
9 * The contents of this file are subject to the Netscape Public
10 * License Version 1.1 (the "License"); you may not use this file
11 * except in compliance with the License. You may obtain a copy of
12 * the License at http://www.mozilla.org/NPL/
13 *
14 * Software distributed under the License is distributed on an "AS
15 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
16 * implied. See the License for the specific language governing
17 * rights and limitations under the License.
18 *
19 * The Original Code is Mozilla Communicator client code, released
20 * March 31, 1998.
21 *
22 * The Initial Developer of the Original Code is Netscape
23 * Communications Corporation. Portions created by Netscape are
24 * Copyright (C) 1998-1999 Netscape Communications Corporation. All
25 * Rights Reserved.
26 *
27 * Contributor(s):
28 */
29 /*
30 * Copyright (c) 1990 Regents of the University of Michigan.
31 * All rights reserved.
32 */
33 /*
34 * ufn.c
35 */
36
37 #if 0
38 #ifndef lint
39 static char copyright[] = "@(#) Copyright (c) 1993 Regents of the University of Michigan.\nAll rights reserved.\n";
40 #endif
41 #endif
42
43 #include "ldap-int.h"
44
45 typedef int (LDAP_CALL *cancelptype)( void *cancelparm );
46
47 static int ldap_ufn_search_ctx( LDAP *ld, char **ufncomp, int ncomp,
48 char *prefix, char **attrs, int attrsonly,
49 LDAPMessage **res, LDAP_CANCELPROC_CALLBACK *cancelproc, void *cancelparm,
50 char *tag1, char *tag2, char *tag3 );
51 static LDAPMessage *ldap_msg_merge( LDAP *ld, LDAPMessage *a, LDAPMessage *b );
52 static LDAPMessage *ldap_ufn_expand( LDAP *ld,
53 LDAP_CANCELPROC_CALLBACK *cancelproc, void *cancelparm, char **dns,
54 char *filter, int scope, char **attrs, int aonly, int *err );
55
56 /*
57 * ldap_ufn_search_ctx - do user friendly searching; provide cancel feature;
58 * specify ldapfilter.conf tags for each phase of search
59 *
60 * ld LDAP descriptor
61 * ufncomp the exploded user friendly name to look for
62 * ncomp number of elements in ufncomp
63 * prefix where to start searching
64 * attrs list of attribute types to return for matches
65 * attrsonly 1 => attributes only 0 => attributes and values
66 * res will contain the result of the search
67 * cancelproc routine that returns non-zero if operation should be
68 * cancelled. This can be NULL. If it is non-NULL, the
69 * routine will be called periodically.
70 * cancelparm void * that is passed to cancelproc
71 * tag[123] the ldapfilter.conf tag that will be used in phases
72 * 1, 2, and 3 of the search, respectively
73 *
74 * Example:
75 * char *attrs[] = { "mail", "title", 0 };
76 * char *ufncomp[] = { "howes", "umich", "us", 0 }
77 * LDAPMessage *res;
78 * error = ldap_ufn_search_ctx( ld, ufncomp, 3, NULL, attrs, attrsonly,
79 * &res, acancelproc, along, "ufn first",
80 * "ufn intermediate", "ufn last" );
81 */
82
83 static int
ldap_ufn_search_ctx(LDAP * ld,char ** ufncomp,int ncomp,char * prefix,char ** attrs,int attrsonly,LDAPMessage ** res,LDAP_CANCELPROC_CALLBACK * cancelproc,void * cancelparm,char * tag1,char * tag2,char * tag3)84 ldap_ufn_search_ctx(
85 LDAP *ld,
86 char **ufncomp,
87 int ncomp,
88 char *prefix,
89 char **attrs,
90 int attrsonly,
91 LDAPMessage **res,
92 LDAP_CANCELPROC_CALLBACK *cancelproc,
93 void *cancelparm,
94 char *tag1,
95 char *tag2,
96 char *tag3
97 )
98 {
99 char *dn, *ftag = NULL;
100 char **dns = NULL;
101 int max, i, err, scope = 0, phase, tries;
102 LDAPFiltInfo *fi;
103 LDAPMessage *tmpcand;
104 LDAPMessage *candidates;
105 static char *objattrs[] = { "objectClass", NULL };
106
107 /*
108 * look up ufn components from most to least significant.
109 * there are 3 phases.
110 * phase 1 search the root for orgs or countries
111 * phase 2 search for orgs
112 * phase 3 search for a person
113 * in phases 1 and 2, we are building a list of candidate DNs,
114 * below which we will search for the final component of the ufn.
115 * for each component we try the filters listed in the
116 * filterconfig file, first one-level (except the last compoment),
117 * then subtree. if any of them produce any results, we go on to
118 * the next component.
119 */
120
121 *res = NULL;
122 candidates = NULL;
123 phase = 1;
124 for ( ncomp--; ncomp != -1; ncomp-- ) {
125 if ( *ufncomp[ncomp] == '"' ) {
126 char *quote;
127
128 if ( (quote = strrchr( ufncomp[ncomp], '"' )) != NULL )
129 *quote = '\0';
130 strcpy( ufncomp[ncomp], ufncomp[ncomp] + 1 );
131 }
132 if ( ncomp == 0 )
133 phase = 3;
134
135 switch ( phase ) {
136 case 1:
137 ftag = tag1;
138 scope = LDAP_SCOPE_ONELEVEL;
139 break;
140 case 2:
141 ftag = tag2;
142 scope = LDAP_SCOPE_ONELEVEL;
143 break;
144 case 3:
145 ftag = tag3;
146 scope = LDAP_SCOPE_SUBTREE;
147 break;
148 }
149
150 /*
151 * construct an array of DN's to search below from the
152 * list of candidates.
153 */
154
155 if ( candidates == NULL ) {
156 if ( prefix != NULL ) {
157 if ( (dns = (char **)NSLDAPI_MALLOC(
158 sizeof(char *) * 2 )) == NULL ) {
159 err = LDAP_NO_MEMORY;
160 LDAP_SET_LDERRNO( ld, err, NULL, NULL );
161 return( err );
162 }
163 dns[0] = nsldapi_strdup( prefix );
164 dns[1] = NULL;
165 } else {
166 dns = NULL;
167 }
168 } else {
169 i = 0, max = 0;
170 for ( tmpcand = candidates; tmpcand != NULL &&
171 tmpcand->lm_msgtype != LDAP_RES_SEARCH_RESULT;
172 tmpcand = tmpcand->lm_chain )
173 {
174 if ( (dn = ldap_get_dn( ld, tmpcand )) == NULL )
175 continue;
176
177 if ( dns == NULL ) {
178 if ( (dns = (char **)NSLDAPI_MALLOC(
179 sizeof(char *) * 8 )) == NULL ) {
180 err = LDAP_NO_MEMORY;
181 LDAP_SET_LDERRNO( ld, err,
182 NULL, NULL );
183 return( err );
184 }
185 max = 8;
186 } else if ( i >= max ) {
187 if ( (dns = (char **)NSLDAPI_REALLOC(
188 dns, sizeof(char *) * 2 * max ))
189 == NULL ) {
190 err = LDAP_NO_MEMORY;
191 LDAP_SET_LDERRNO( ld, err,
192 NULL, NULL );
193 return( err );
194 }
195 max *= 2;
196 }
197 dns[i++] = dn;
198 dns[i] = NULL;
199 }
200 ldap_msgfree( candidates );
201 candidates = NULL;
202 }
203 tries = 0;
204 tryagain:
205 tries++;
206 for ( fi = ldap_getfirstfilter( ld->ld_filtd, ftag,
207 ufncomp[ncomp] ); fi != NULL;
208 fi = ldap_getnextfilter( ld->ld_filtd ) )
209 {
210 if ( (candidates = ldap_ufn_expand( ld, cancelproc,
211 cancelparm, dns, fi->lfi_filter, scope,
212 phase == 3 ? attrs : objattrs,
213 phase == 3 ? attrsonly : 1, &err )) != NULL )
214 {
215 break;
216 }
217
218 if ( err == -1 || err == LDAP_USER_CANCELLED ) {
219 if ( dns != NULL ) {
220 ldap_value_free( dns );
221 dns = NULL;
222 }
223 return( err );
224 }
225 }
226
227 if ( candidates == NULL ) {
228 if ( tries < 2 && phase != 3 ) {
229 scope = LDAP_SCOPE_SUBTREE;
230 goto tryagain;
231 } else {
232 if ( dns != NULL ) {
233 ldap_value_free( dns );
234 dns = NULL;
235 }
236 return( err );
237 }
238 }
239
240 /* go on to the next component */
241 if ( phase == 1 )
242 phase++;
243 if ( dns != NULL ) {
244 ldap_value_free( dns );
245 dns = NULL;
246 }
247 }
248 *res = candidates;
249
250 return( err );
251 }
252
253 int
254 LDAP_CALL
ldap_ufn_search_ct(LDAP * ld,char * ufn,char ** attrs,int attrsonly,LDAPMessage ** res,LDAP_CANCELPROC_CALLBACK * cancelproc,void * cancelparm,char * tag1,char * tag2,char * tag3)255 ldap_ufn_search_ct( LDAP *ld, char *ufn, char **attrs, int attrsonly,
256 LDAPMessage **res, LDAP_CANCELPROC_CALLBACK *cancelproc, void *cancelparm,
257 char *tag1, char *tag2, char *tag3 )
258 {
259 char **ufncomp, **prefixcomp;
260 char *pbuf;
261 int ncomp, pcomp, i, err = 0;
262
263 /* getfilter stuff must be inited before we are called */
264 if ( ld->ld_filtd == NULL ) {
265 err = LDAP_PARAM_ERROR;
266 LDAP_SET_LDERRNO( ld, err, NULL, NULL );
267 return( err );
268 }
269
270 /* call ldap_explode_dn() to break the ufn into its components */
271 if ( (ufncomp = ldap_explode_dn( ufn, 0 )) == NULL ) {
272 err = LDAP_LOCAL_ERROR;
273 LDAP_SET_LDERRNO( ld, err, NULL, NULL );
274 return( err );
275 }
276 for ( ncomp = 0; ufncomp[ncomp] != NULL; ncomp++ )
277 ; /* NULL */
278
279 /* more than two components => try it fully qualified first */
280 if ( ncomp > 2 || ld->ld_ufnprefix == NULL ) {
281 err = ldap_ufn_search_ctx( ld, ufncomp, ncomp, NULL, attrs,
282 attrsonly, res, cancelproc, cancelparm, tag1, tag2, tag3 );
283
284 if ( ldap_count_entries( ld, *res ) > 0 ) {
285 ldap_value_free( ufncomp );
286 return( err );
287 } else {
288 ldap_msgfree( *res );
289 *res = NULL;
290 }
291 }
292
293 if ( ld->ld_ufnprefix == NULL ) {
294 ldap_value_free( ufncomp );
295 return( err );
296 }
297
298 /* if that failed, or < 2 components, use the prefix */
299 if ( (prefixcomp = ldap_explode_dn( ld->ld_ufnprefix, 0 )) == NULL ) {
300 ldap_value_free( ufncomp );
301 err = LDAP_LOCAL_ERROR;
302 LDAP_SET_LDERRNO( ld, err, NULL, NULL );
303 return( err );
304 }
305 for ( pcomp = 0; prefixcomp[pcomp] != NULL; pcomp++ )
306 ; /* NULL */
307 if ( (pbuf = (char *)NSLDAPI_MALLOC( strlen( ld->ld_ufnprefix ) + 1 ))
308 == NULL ) {
309 ldap_value_free( ufncomp );
310 ldap_value_free( prefixcomp );
311 err = LDAP_NO_MEMORY;
312 LDAP_SET_LDERRNO( ld, err, NULL, NULL );
313 return( err );
314 }
315
316 for ( i = 0; i < pcomp; i++ ) {
317 int j;
318
319 *pbuf = '\0';
320 for ( j = i; j < pcomp; j++ ) {
321 strcat( pbuf, prefixcomp[j] );
322 if ( j + 1 < pcomp )
323 strcat( pbuf, "," );
324 }
325 err = ldap_ufn_search_ctx( ld, ufncomp, ncomp, pbuf, attrs,
326 attrsonly, res, cancelproc, cancelparm, tag1, tag2, tag3 );
327
328 if ( ldap_count_entries( ld, *res ) > 0 ) {
329 break;
330 } else {
331 ldap_msgfree( *res );
332 *res = NULL;
333 }
334 }
335
336 ldap_value_free( ufncomp );
337 ldap_value_free( prefixcomp );
338 NSLDAPI_FREE( pbuf );
339
340 return( err );
341 }
342
343 /*
344 * same as ldap_ufn_search_ct, except without the ability to specify
345 * ldapfilter.conf tags.
346 */
347 int
348 LDAP_CALL
ldap_ufn_search_c(LDAP * ld,char * ufn,char ** attrs,int attrsonly,LDAPMessage ** res,LDAP_CANCELPROC_CALLBACK * cancelproc,void * cancelparm)349 ldap_ufn_search_c( LDAP *ld, char *ufn, char **attrs, int attrsonly,
350 LDAPMessage **res, LDAP_CANCELPROC_CALLBACK *cancelproc, void *cancelparm )
351 {
352 return( ldap_ufn_search_ct( ld, ufn, attrs, attrsonly, res, cancelproc,
353 cancelparm, "ufn first", "ufn intermediate", "ufn last" ) );
354 }
355
356 /*
357 * same as ldap_ufn_search_c without the cancel function
358 */
359 int
360 LDAP_CALL
ldap_ufn_search_s(LDAP * ld,char * ufn,char ** attrs,int attrsonly,LDAPMessage ** res)361 ldap_ufn_search_s( LDAP *ld, char *ufn, char **attrs, int attrsonly,
362 LDAPMessage **res )
363 {
364 struct timeval tv;
365
366 tv.tv_sec = ld->ld_timelimit;
367
368 return( ldap_ufn_search_ct( ld, ufn, attrs, attrsonly, res,
369 ld->ld_timelimit ? ldap_ufn_timeout : NULL,
370 ld->ld_timelimit ? (void *) &tv : NULL,
371 "ufn first", "ufn intermediate", "ufn last" ) );
372 }
373
374
375 /*
376 * ldap_msg_merge - merge two ldap search result chains. the more
377 * serious of the two error result codes is kept.
378 */
379
380 static LDAPMessage *
ldap_msg_merge(LDAP * ld,LDAPMessage * a,LDAPMessage * b)381 ldap_msg_merge( LDAP *ld, LDAPMessage *a, LDAPMessage *b )
382 {
383 LDAPMessage *end, *aprev, *aend, *bprev, *bend;
384
385 if ( a == NULL )
386 return( b );
387
388 if ( b == NULL )
389 return( a );
390
391 /* find the ends of the a and b chains */
392 aprev = NULL;
393 for ( aend = a; aend->lm_chain != NULL; aend = aend->lm_chain )
394 aprev = aend;
395 bprev = NULL;
396 for ( bend = b; bend->lm_chain != NULL; bend = bend->lm_chain )
397 bprev = bend;
398
399 /* keep result a */
400 if ( ldap_result2error( ld, aend, 0 ) != LDAP_SUCCESS ) {
401 /* remove result b */
402 ldap_msgfree( bend );
403 if ( bprev != NULL )
404 bprev->lm_chain = NULL;
405 else
406 b = NULL;
407 end = aend;
408 if ( aprev != NULL )
409 aprev->lm_chain = NULL;
410 else
411 a = NULL;
412 /* keep result b */
413 } else {
414 /* remove result a */
415 ldap_msgfree( aend );
416 if ( aprev != NULL )
417 aprev->lm_chain = NULL;
418 else
419 a = NULL;
420 end = bend;
421 if ( bprev != NULL )
422 bprev->lm_chain = NULL;
423 else
424 b = NULL;
425 }
426
427 if ( (a == NULL && b == NULL) || (a == NULL && bprev == NULL) ||
428 (b == NULL && aprev == NULL) )
429 return( end );
430
431 if ( a == NULL ) {
432 bprev->lm_chain = end;
433 return( b );
434 } else if ( b == NULL ) {
435 aprev->lm_chain = end;
436 return( a );
437 } else {
438 bprev->lm_chain = end;
439 aprev->lm_chain = b;
440 return( a );
441 }
442 }
443
444 static LDAPMessage *
ldap_ufn_expand(LDAP * ld,LDAP_CANCELPROC_CALLBACK * cancelproc,void * cancelparm,char ** dns,char * filter,int scope,char ** attrs,int aonly,int * err)445 ldap_ufn_expand( LDAP *ld, LDAP_CANCELPROC_CALLBACK *cancelproc,
446 void *cancelparm, char **dns, char *filter, int scope,
447 char **attrs, int aonly, int *err )
448 {
449 LDAPMessage *tmpcand, *tmpres;
450 char *dn;
451 int i, msgid;
452 struct timeval tv;
453
454 /* search for this component below the current candidates */
455 tmpcand = NULL;
456 i = 0;
457 do {
458 if ( dns != NULL )
459 dn = dns[i];
460 else
461 dn = "";
462
463 if (( msgid = ldap_search( ld, dn, scope, filter, attrs,
464 aonly )) == -1 ) {
465 ldap_msgfree( tmpcand );
466 *err = LDAP_GET_LDERRNO( ld, NULL, NULL );
467 return( NULL );
468 }
469
470 tv.tv_sec = 0;
471 tv.tv_usec = 100000; /* 1/10 of a second */
472
473 do {
474 *err = ldap_result( ld, msgid, 1, &tv, &tmpres );
475 if ( *err == 0 && cancelproc != NULL &&
476 (*cancelproc)( cancelparm ) != 0 ) {
477 ldap_abandon( ld, msgid );
478 *err = LDAP_USER_CANCELLED;
479 LDAP_SET_LDERRNO( ld, *err, NULL, NULL );
480 }
481 } while ( *err == 0 );
482
483 if ( *err == LDAP_USER_CANCELLED || *err < 0 ||
484 ( *err = ldap_result2error( ld, tmpres, 0 )) == -1 ) {
485 ldap_msgfree( tmpcand );
486 return( NULL );
487 }
488
489 tmpcand = ldap_msg_merge( ld, tmpcand, tmpres );
490
491 i++;
492 } while ( dns != NULL && dns[i] != NULL );
493
494 if ( ldap_count_entries( ld, tmpcand ) > 0 ) {
495 return( tmpcand );
496 } else {
497 ldap_msgfree( tmpcand );
498 return( NULL );
499 }
500 }
501
502 /*
503 * ldap_ufn_setfilter - set the filter config file used in ufn searching
504 */
505
506 LDAPFiltDesc *
507 LDAP_CALL
ldap_ufn_setfilter(LDAP * ld,char * fname)508 ldap_ufn_setfilter( LDAP *ld, char *fname )
509 {
510 if ( ld->ld_filtd != NULL )
511 ldap_getfilter_free( ld->ld_filtd );
512
513 return( ld->ld_filtd = ldap_init_getfilter( fname ) );
514 }
515
516 void
517 LDAP_CALL
ldap_ufn_setprefix(LDAP * ld,char * prefix)518 ldap_ufn_setprefix( LDAP *ld, char *prefix )
519 {
520 if ( ld->ld_ufnprefix != NULL )
521 NSLDAPI_FREE( ld->ld_ufnprefix );
522
523 ld->ld_ufnprefix = nsldapi_strdup( prefix );
524 }
525
526 int
527 LDAP_C
ldap_ufn_timeout(void * tvparam)528 ldap_ufn_timeout( void *tvparam )
529 {
530 struct timeval *tv;
531
532 tv = (struct timeval *)tvparam;
533
534 if ( tv->tv_sec != 0 ) {
535 tv->tv_usec = tv->tv_sec * 1000000; /* sec => micro sec */
536 tv->tv_sec = 0;
537 }
538 tv->tv_usec -= 100000; /* 1/10 of a second */
539
540 return( tv->tv_usec <= 0 ? 1 : 0 );
541 }
542