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