?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / lib / libldap5 / sources / ldap / common / request.c
blobc931497adae6fe5af66d8fff70d7f7237f83f8c2
1 /*
2 * Copyright 2001-2003 Sun Microsystems, Inc. All rights reserved.
3 * Use is subject to license terms.
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) 1995 Regents of the University of Michigan.
31 * All rights reserved.
32 */
33 /*
34 * request.c - sending of ldap requests; handling of referrals
35 */
36
37 #if 0
38 #ifndef lint
39 static char copyright[] = "@(#) Copyright (c) 1995 Regents of the University of Michigan.\nAll rights reserved.\n";
40 #endif
41 #endif
42
43 #include "ldap-int.h"
44
45 static LDAPConn *find_connection( LDAP *ld, LDAPServer *srv, int any );
46 static void use_connection( LDAP *ld, LDAPConn *lc );
47 static void free_servers( LDAPServer *srvlist );
48 static int chase_one_referral( LDAP *ld, LDAPRequest *lr, LDAPRequest *origreq,
49 char *refurl, char *desc, int *unknownp );
50 static int re_encode_request( LDAP *ld, BerElement *origber,
51 int msgid, LDAPURLDesc *ludp, BerElement **berp );
52
53 #ifdef LDAP_DNS
54 static LDAPServer *dn2servers( LDAP *ld, char *dn );
55 #endif /* LDAP_DNS */
56
57
58 /* returns an LDAP error code and also sets error inside LDAP * */
59 int
60 nsldapi_alloc_ber_with_options( LDAP *ld, BerElement **berp )
61 {
62 int err;
63
64 LDAP_MUTEX_LOCK( ld, LDAP_OPTION_LOCK );
65 if (( *berp = ber_alloc_t( ld->ld_lberoptions )) == NULLBER ) {
66 err = LDAP_NO_MEMORY;
67 LDAP_SET_LDERRNO( ld, err, NULL, NULL );
68 } else {
69 err = LDAP_SUCCESS;
70 #ifdef STR_TRANSLATION
71 nsldapi_set_ber_options( ld, *berp );
72 #endif /* STR_TRANSLATION */
73 }
74 LDAP_MUTEX_UNLOCK( ld, LDAP_OPTION_LOCK );
75
76 return( err );
77 }
78
79
80 void
81 nsldapi_set_ber_options( LDAP *ld, BerElement *ber )
82 {
83 ber->ber_options = ld->ld_lberoptions;
84 #ifdef STR_TRANSLATION
85 if (( ld->ld_lberoptions & LBER_OPT_TRANSLATE_STRINGS ) != 0 ) {
86 ber_set_string_translators( ber,
87 ld->ld_lber_encode_translate_proc,
88 ld->ld_lber_decode_translate_proc );
89 }
90 #endif /* STR_TRANSLATION */
91 }
92
93
94 /* returns the message id of the request or -1 if an error occurs */
95 int
96 nsldapi_send_initial_request( LDAP *ld, int msgid, unsigned long msgtype,
97 char *dn, BerElement *ber )
98 {
99 LDAPServer *servers;
100
101 LDAPDebug( LDAP_DEBUG_TRACE, "nsldapi_send_initial_request\n", 0,0,0 );
102
103 #ifdef LDAP_DNS
104 LDAP_MUTEX_LOCK( ld, LDAP_OPTION_LOCK );
105 if (( ld->ld_options & LDAP_BITOPT_DNS ) != 0 && ldap_is_dns_dn( dn )) {
106 if (( servers = dn2servers( ld, dn )) == NULL ) {
107 ber_free( ber, 1 );
108 LDAP_MUTEX_UNLOCK( ld, LDAP_OPTION_LOCK );
109 return( -1 );
110 }
111
112 #ifdef LDAP_DEBUG
113 if ( ldap_debug & LDAP_DEBUG_TRACE ) {
114 LDAPServer *srv;
115 char msg[256];
116
117 for ( srv = servers; srv != NULL;
118 srv = srv->lsrv_next ) {
119 sprintf( msg,
120 "LDAP server %s: dn %s, port %d\n",
121 srv->lsrv_host, ( srv->lsrv_dn == NULL ) ?
122 "(default)" : srv->lsrv_dn,
123 srv->lsrv_port );
124 ber_err_print( msg );
125 }
126 }
127 #endif /* LDAP_DEBUG */
128 } else {
129 #endif /* LDAP_DNS */
130 /*
131 * use of DNS is turned off or this is an LDAP DN...
132 * use our default connection
133 */
134 servers = NULL;
135 #ifdef LDAP_DNS
136 }
137 LDAP_MUTEX_UNLOCK( ld, LDAP_OPTION_LOCK );
138 #endif /* LDAP_DNS */
139
140 return( nsldapi_send_server_request( ld, ber, msgid, NULL,
141 servers, NULL, ( msgtype == LDAP_REQ_BIND ) ? dn : NULL, 0 ));
142 }
143
144
145 /* returns the message id of the request or -1 if an error occurs */
146 int
147 nsldapi_send_server_request(
148 LDAP *ld, /* session handle */
149 BerElement *ber, /* message to send */
150 int msgid, /* ID of message to send */
151 LDAPRequest *parentreq, /* non-NULL for referred requests */
152 LDAPServer *srvlist, /* servers to connect to (NULL for default) */
153 LDAPConn *lc, /* connection to use (NULL for default) */
154 char *bindreqdn, /* non-NULL for bind requests */
155 int bind /* perform a bind after opening new conn.? */
156 )
157 {
158 LDAPRequest *lr;
159 int err;
160 int incparent; /* did we bump parent's ref count? */
161
162 LDAPDebug( LDAP_DEBUG_TRACE, "nsldapi_send_server_request\n", 0, 0, 0 );
163
164 incparent = 0;
165 LDAP_MUTEX_LOCK( ld, LDAP_CONN_LOCK );
166 if ( lc == NULL ) {
167 if ( srvlist == NULL ) {
168 if ( ld->ld_defconn == NULL ) {
169 LDAP_MUTEX_LOCK( ld, LDAP_OPTION_LOCK );
170 if ( bindreqdn == NULL && ( ld->ld_options
171 & LDAP_BITOPT_RECONNECT ) != 0 ) {
172 LDAP_SET_LDERRNO( ld, LDAP_SERVER_DOWN,
173 NULL, NULL );
174 ber_free( ber, 1 );
175 LDAP_MUTEX_UNLOCK( ld, LDAP_OPTION_LOCK );
176 LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK );
177 return( -1 );
178 }
179 LDAP_MUTEX_UNLOCK( ld, LDAP_OPTION_LOCK );
180
181 if ( nsldapi_open_ldap_defconn( ld ) < 0 ) {
182 ber_free( ber, 1 );
183 LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK );
184 return( -1 );
185 }
186 }
187 lc = ld->ld_defconn;
188 } else {
189 if (( lc = find_connection( ld, srvlist, 1 )) ==
190 NULL ) {
191 if ( bind && (parentreq != NULL) ) {
192 /* Remember the bind in the parent */
193 incparent = 1;
194 ++parentreq->lr_outrefcnt;
195 }
196
197 lc = nsldapi_new_connection( ld, &srvlist, 0,
198 1, bind );
199 }
200 free_servers( srvlist );
201 }
202 }
203
204
205 /*
206 * the logic here is:
207 * if
208 * 1. no connections exists,
209 * or
210 * 2. if the connection is either not in the connected
211 * or connecting state in an async io model
212 * or
213 * 3. the connection is notin a connected state with normal (non async io)
214 */
215 if ( lc == NULL
216 || ( (ld->ld_options & LDAP_BITOPT_ASYNC
217 && lc->lconn_status != LDAP_CONNST_CONNECTING
218 && lc->lconn_status != LDAP_CONNST_CONNECTED)
219 || (!(ld->ld_options & LDAP_BITOPT_ASYNC )
220 && lc->lconn_status != LDAP_CONNST_CONNECTED) ) ) {
221
222 ber_free( ber, 1 );
223 if ( lc != NULL ) {
224 LDAP_SET_LDERRNO( ld, LDAP_SERVER_DOWN, NULL, NULL );
225 }
226 if ( incparent ) {
227 /* Forget about the bind */
228 --parentreq->lr_outrefcnt;
229 }
230 LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK );
231 return( -1 );
232 }
233
234 use_connection( ld, lc );
235 if (( lr = (LDAPRequest *)NSLDAPI_CALLOC( 1, sizeof( LDAPRequest ))) ==
236 NULL || ( bindreqdn != NULL && ( bindreqdn =
237 nsldapi_strdup( bindreqdn )) == NULL )) {
238 if ( lr != NULL ) {
239 NSLDAPI_FREE( lr );
240 }
241 LDAP_SET_LDERRNO( ld, LDAP_NO_MEMORY, NULL, NULL );
242 nsldapi_free_connection( ld, lc, NULL, NULL, 0, 0 );
243 ber_free( ber, 1 );
244 if ( incparent ) {
245 /* Forget about the bind */
246 --parentreq->lr_outrefcnt;
247 }
248 LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK );
249 return( -1 );
250 }
251 lr->lr_binddn = bindreqdn;
252 lr->lr_msgid = msgid;
253 lr->lr_status = LDAP_REQST_INPROGRESS;
254 lr->lr_res_errno = LDAP_SUCCESS; /* optimistic */
255 lr->lr_ber = ber;
256 lr->lr_conn = lc;
257
258 if ( parentreq != NULL ) { /* sub-request */
259 if ( !incparent ) {
260 /* Increment if we didn't do it before the bind */
261 ++parentreq->lr_outrefcnt;
262 }
263 lr->lr_origid = parentreq->lr_origid;
264 lr->lr_parentcnt = parentreq->lr_parentcnt + 1;
265 lr->lr_parent = parentreq;
266 if ( parentreq->lr_child != NULL ) {
267 lr->lr_sibling = parentreq->lr_child;
268 }
269 parentreq->lr_child = lr;
270 } else { /* original request */
271 lr->lr_origid = lr->lr_msgid;
272 }
273
274 LDAP_MUTEX_LOCK( ld, LDAP_REQ_LOCK );
275 if (( lr->lr_next = ld->ld_requests ) != NULL ) {
276 lr->lr_next->lr_prev = lr;
277 }
278 ld->ld_requests = lr;
279 lr->lr_prev = NULL;
280
281 if (( err = nsldapi_ber_flush( ld, lc->lconn_sb, ber, 0, 1 )) != 0 ) {
282
283 /* need to continue write later */
284 if (ld->ld_options & LDAP_BITOPT_ASYNC && err == -2 ) {
285 lr->lr_status = LDAP_REQST_WRITING;
286 nsldapi_iostatus_interest_write( ld, lc->lconn_sb );
287 } else {
288
289 LDAP_SET_LDERRNO( ld, LDAP_SERVER_DOWN, NULL, NULL );
290 nsldapi_free_request( ld, lr, 0 );
291 nsldapi_free_connection( ld, lc, NULL, NULL, 0, 0 );
292 LDAP_MUTEX_UNLOCK( ld, LDAP_REQ_LOCK );
293 LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK );
294 return( -1 );
295 }
296
297 } else {
298 if ( parentreq == NULL ) {
299 ber->ber_end = ber->ber_ptr;
300 ber->ber_ptr = ber->ber_buf;
301 }
302
303 /* sent -- waiting for a response */
304 if (ld->ld_options & LDAP_BITOPT_ASYNC) {
305 lc->lconn_status = LDAP_CONNST_CONNECTED;
306 }
307
308 nsldapi_iostatus_interest_read( ld, lc->lconn_sb );
309 }
310 LDAP_MUTEX_UNLOCK( ld, LDAP_REQ_LOCK );
311 LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK );
312
313 LDAP_SET_LDERRNO( ld, LDAP_SUCCESS, NULL, NULL );
314 return( msgid );
315 }
316
317
318 /*
319 * returns -1 if a fatal error occurs. If async is non-zero and the flush
320 * would block, -2 is returned.
321 */
322 int
323 nsldapi_ber_flush( LDAP *ld, Sockbuf *sb, BerElement *ber, int freeit,
324 int async )
325 {
326 int terrno;
327
328 for ( ;; ) {
329 /*
330 * ber_flush() doesn't set errno on EOF, so we pre-set it to
331 * zero to avoid getting tricked by leftover "EAGAIN" errors
332 */
333 LDAP_SET_ERRNO( ld, 0 );
334
335 if ( ber_flush( sb, ber, freeit ) == 0 ) {
336 return( 0 ); /* success */
337 }
338
339 terrno = LDAP_GET_ERRNO( ld );
340
341 if (ld->ld_options & LDAP_BITOPT_ASYNC) {
342 if ( terrno != 0 && !NSLDAPI_ERRNO_IO_INPROGRESS( terrno )) {
343 nsldapi_connection_lost_nolock( ld, sb );
344 return( -1 ); /* fatal error */
345 }
346 }
347 else if ( !NSLDAPI_ERRNO_IO_INPROGRESS( terrno )) {
348
349 nsldapi_connection_lost_nolock( ld, sb );
350 return( -1 ); /* fatal error */
351 }
352
353 if ( async ) {
354 return( -2 ); /* would block */
355 }
356 }
357 }
358
359 LDAPConn *
360 nsldapi_new_connection( LDAP *ld, LDAPServer **srvlistp, int use_ldsb,
361 int connect, int bind )
362 {
363 int rc;
364
365 LDAPConn *lc;
366 LDAPServer *prevsrv, *srv;
367 Sockbuf *sb = NULL;
368
369 /*
370 * make a new LDAP server connection
371 */
372 if (( lc = (LDAPConn *)NSLDAPI_CALLOC( 1, sizeof( LDAPConn ))) == NULL
373 || ( !use_ldsb && ( sb = ber_sockbuf_alloc()) == NULL )) {
374 if ( lc != NULL ) {
375 NSLDAPI_FREE( (char *)lc );
376 }
377 LDAP_SET_LDERRNO( ld, LDAP_NO_MEMORY, NULL, NULL );
378 return( NULL );
379 }
380
381 LDAP_MUTEX_LOCK( ld, LDAP_OPTION_LOCK );
382 if ( !use_ldsb ) {
383 /*
384 * we have allocated a new sockbuf
385 * set I/O routines to match those in default LDAP sockbuf
386 */
387 IFP sb_fn;
388 struct lber_x_ext_io_fns extiofns;
389
390 extiofns.lbextiofn_size = LBER_X_EXTIO_FNS_SIZE;
391
392 if ( ber_sockbuf_get_option( ld->ld_sbp,
393 LBER_SOCKBUF_OPT_EXT_IO_FNS, &extiofns ) == 0 ) {
394 ber_sockbuf_set_option( sb,
395 LBER_SOCKBUF_OPT_EXT_IO_FNS, &extiofns );
396 }
397 if ( ber_sockbuf_get_option( ld->ld_sbp,
398 LBER_SOCKBUF_OPT_READ_FN, (void *)&sb_fn ) == 0
399 && sb_fn != NULL ) {
400 ber_sockbuf_set_option( sb, LBER_SOCKBUF_OPT_READ_FN,
401 (void *)sb_fn );
402 }
403 if ( ber_sockbuf_get_option( ld->ld_sbp,
404 LBER_SOCKBUF_OPT_WRITE_FN, (void *)&sb_fn ) == 0
405 && sb_fn != NULL ) {
406 ber_sockbuf_set_option( sb, LBER_SOCKBUF_OPT_WRITE_FN,
407 (void *)sb_fn );
408 }
409 }
410
411 lc->lconn_sb = ( use_ldsb ) ? ld->ld_sbp : sb;
412 lc->lconn_version = ld->ld_version; /* inherited */
413 LDAP_MUTEX_UNLOCK( ld, LDAP_OPTION_LOCK );
414
415 if ( connect ) {
416 prevsrv = NULL;
417 /*
418 * save the return code for later
419 */
420 for ( srv = *srvlistp; srv != NULL; srv = srv->lsrv_next ) {
421 rc = nsldapi_connect_to_host( ld, lc->lconn_sb,
422 srv->lsrv_host, srv->lsrv_port,
423 ( srv->lsrv_options & LDAP_SRV_OPT_SECURE ) != 0,
424 &lc->lconn_krbinstance );
425 if (rc != -1) {
426 break;
427 }
428 prevsrv = srv;
429 }
430
431 if ( srv == NULL ) {
432 if ( !use_ldsb ) {
433 NSLDAPI_FREE( (char *)lc->lconn_sb );
434 }
435 NSLDAPI_FREE( (char *)lc );
436 /* nsldapi_open_ldap_connection has already set ld_errno */
437 return( NULL );
438 }
439
440 if ( prevsrv == NULL ) {
441 *srvlistp = srv->lsrv_next;
442 } else {
443 prevsrv->lsrv_next = srv->lsrv_next;
444 }
445 lc->lconn_server = srv;
446 }
447
448 if (ld->ld_options & LDAP_BITOPT_ASYNC && rc == -2)
449 {
450 lc->lconn_status = LDAP_CONNST_CONNECTING;
451 }
452 else {
453 lc->lconn_status = LDAP_CONNST_CONNECTED;
454 }
455
456 lc->lconn_next = ld->ld_conns;
457 ld->ld_conns = lc;
458
459 /*
460 * XXX for now, we always do a synchronous bind. This will have
461 * to change in the long run...
462 */
463 if ( bind ) {
464 int err, lderr, freepasswd, authmethod;
465 char *binddn, *passwd;
466 LDAPConn *savedefconn;
467
468 freepasswd = err = 0;
469
470 if ( ld->ld_rebind_fn == NULL ) {
471 binddn = passwd = "";
472 authmethod = LDAP_AUTH_SIMPLE;
473 } else {
474 if (( lderr = (*ld->ld_rebind_fn)( ld, &binddn, &passwd,
475 &authmethod, 0, ld->ld_rebind_arg ))
476 == LDAP_SUCCESS ) {
477 freepasswd = 1;
478 } else {
479 LDAP_SET_LDERRNO( ld, lderr, NULL, NULL );
480 err = -1;
481 }
482 }
483
484
485 if ( err == 0 ) {
486 savedefconn = ld->ld_defconn;
487 ld->ld_defconn = lc;
488 ++lc->lconn_refcnt; /* avoid premature free */
489
490 /*
491 * when binding, we will back down as low as LDAPv2
492 * if we get back "protocol error" from bind attempts
493 */
494 for ( ;; ) {
495 /* LDAP_MUTEX_UNLOCK(ld, LDAP_CONN_LOCK); */
496 if (( lderr = ldap_bind_s( ld, binddn, passwd,
497 authmethod )) == LDAP_SUCCESS ) {
498 /* LDAP_MUTEX_LOCK(ld, LDAP_CONN_LOCK); */
499 break;
500 }
501 /* LDAP_MUTEX_LOCK(ld, LDAP_CONN_LOCK); */
502 if ( lc->lconn_version <= LDAP_VERSION2
503 || lderr != LDAP_PROTOCOL_ERROR ) {
504 err = -1;
505 break;
506 }
507 --lc->lconn_version; /* try lower version */
508 }
509 --lc->lconn_refcnt;
510 ld->ld_defconn = savedefconn;
511 }
512
513 if ( freepasswd ) {
514 (*ld->ld_rebind_fn)( ld, &binddn, &passwd,
515 &authmethod, 1, ld->ld_rebind_arg );
516 }
517
518 if ( err != 0 ) {
519 nsldapi_free_connection( ld, lc, NULL, NULL, 1, 0 );
520 lc = NULL;
521 }
522 }
523
524 return( lc );
525 }
526
527
528 #define LDAP_CONN_SAMEHOST( h1, h2 ) \
529 (( (h1) == NULL && (h2) == NULL ) || \
530 ( (h1) != NULL && (h2) != NULL && strcasecmp( (h1), (h2) ) == 0 ))
531
532 static LDAPConn *
533 find_connection( LDAP *ld, LDAPServer *srv, int any )
534 /*
535 * return an existing connection (if any) to the server srv
536 * if "any" is non-zero, check for any server in the "srv" chain
537 */
538 {
539 LDAPConn *lc;
540 LDAPServer *ls;
541
542 for ( lc = ld->ld_conns; lc != NULL; lc = lc->lconn_next ) {
543 for ( ls = srv; ls != NULL; ls = ls->lsrv_next ) {
544 if ( LDAP_CONN_SAMEHOST( ls->lsrv_host,
545 lc->lconn_server->lsrv_host )
546 && ls->lsrv_port == lc->lconn_server->lsrv_port
547 && ls->lsrv_options ==
548 lc->lconn_server->lsrv_options ) {
549 return( lc );
550 }
551 if ( !any ) {
552 break;
553 }
554 }
555 }
556
557 return( NULL );
558 }
559
560
561
562 static void
563 use_connection( LDAP *ld, LDAPConn *lc )
564 {
565 ++lc->lconn_refcnt;
566 lc->lconn_lastused = time( 0 );
567 }
568
569
570 void
571 nsldapi_free_connection( LDAP *ld, LDAPConn *lc, LDAPControl **serverctrls,
572 LDAPControl **clientctrls, int force, int unbind )
573 {
574 LDAPConn *tmplc, *prevlc;
575
576 LDAPDebug( LDAP_DEBUG_TRACE, "nsldapi_free_connection\n", 0, 0, 0 );
577
578 if ( force || --lc->lconn_refcnt <= 0 ) {
579 if ( lc->lconn_status == LDAP_CONNST_CONNECTED ) {
580 nsldapi_iostatus_interest_clear( ld, lc->lconn_sb );
581 if ( unbind ) {
582 nsldapi_send_unbind( ld, lc->lconn_sb,
583 serverctrls, clientctrls );
584 }
585 }
586 nsldapi_close_connection( ld, lc->lconn_sb );
587 prevlc = NULL;
588 for ( tmplc = ld->ld_conns; tmplc != NULL;
589 tmplc = tmplc->lconn_next ) {
590 if ( tmplc == lc ) {
591 if ( prevlc == NULL ) {
592 ld->ld_conns = tmplc->lconn_next;
593 } else {
594 prevlc->lconn_next = tmplc->lconn_next;
595 }
596 break;
597 }
598 prevlc = tmplc;
599 }
600 free_servers( lc->lconn_server );
601 if ( lc->lconn_krbinstance != NULL ) {
602 NSLDAPI_FREE( lc->lconn_krbinstance );
603 }
604 /*
605 * if this is the default connection (lc->lconn_sb==ld->ld_sbp)
606 * we do not free the Sockbuf here since it will be freed
607 * later inside ldap_unbind().
608 */
609 if ( lc->lconn_sb != ld->ld_sbp ) {
610 ber_sockbuf_free( lc->lconn_sb );
611 lc->lconn_sb = NULL;
612 }
613 if ( lc->lconn_ber != NULLBER ) {
614 ber_free( lc->lconn_ber, 1 );
615 }
616 if ( lc->lconn_binddn != NULL ) {
617 NSLDAPI_FREE( lc->lconn_binddn );
618 }
619 NSLDAPI_FREE( lc );
620 LDAPDebug( LDAP_DEBUG_TRACE, "nsldapi_free_connection: actually freed\n",
621 0, 0, 0 );
622 } else {
623 lc->lconn_lastused = time( 0 );
624 LDAPDebug( LDAP_DEBUG_TRACE, "nsldapi_free_connection: refcnt %d\n",
625 lc->lconn_refcnt, 0, 0 );
626 }
627 }
628
629
630 #ifdef LDAP_DEBUG
631 void
632 nsldapi_dump_connection( LDAP *ld, LDAPConn *lconns, int all )
633 {
634 LDAPConn *lc;
635 char msg[256];
636 /* CTIME for this platform doesn't use this. */
637 #if !defined(SUNOS4) && !defined(_WIN32) && !defined(LINUX)
638 char buf[26];
639 #endif
640
641 sprintf( msg, "** Connection%s:\n", all ? "s" : "" );
642 ber_err_print( msg );
643 for ( lc = lconns; lc != NULL; lc = lc->lconn_next ) {
644 if ( lc->lconn_server != NULL ) {
645 sprintf( msg, "* host: %s port: %d secure: %s%s\n",
646 ( lc->lconn_server->lsrv_host == NULL ) ? "(null)"
647 : lc->lconn_server->lsrv_host,
648 lc->lconn_server->lsrv_port,
649 ( lc->lconn_server->lsrv_options &
650 LDAP_SRV_OPT_SECURE ) ? "Yes" :
651 "No", ( lc->lconn_sb == ld->ld_sbp ) ?
652 " (default)" : "" );
653 ber_err_print( msg );
654 }
655 sprintf( msg, " refcnt: %d status: %s\n", lc->lconn_refcnt,
656 ( lc->lconn_status == LDAP_CONNST_NEEDSOCKET ) ?
657 "NeedSocket" : ( lc->lconn_status ==
658 LDAP_CONNST_CONNECTING ) ? "Connecting" :
659 ( lc->lconn_status == LDAP_CONNST_DEAD ) ? "Dead" :
660 "Connected" );
661 ber_err_print( msg );
662 sprintf( msg, " last used: %s",
663 NSLDAPI_CTIME( (time_t *) &lc->lconn_lastused, buf,
664 sizeof(buf) ));
665 ber_err_print( msg );
666 if ( lc->lconn_ber != NULLBER ) {
667 ber_err_print( " partial response has been received:\n" );
668 ber_dump( lc->lconn_ber, 1 );
669 }
670 ber_err_print( "\n" );
671
672 if ( !all ) {
673 break;
674 }
675 }
676 }
677
678
679 void
680 nsldapi_dump_requests_and_responses( LDAP *ld )
681 {
682 LDAPRequest *lr;
683 LDAPMessage *lm, *l;
684 char msg[256];
685
686 ber_err_print( "** Outstanding Requests:\n" );
687 LDAP_MUTEX_LOCK( ld, LDAP_REQ_LOCK );
688 if (( lr = ld->ld_requests ) == NULL ) {
689 ber_err_print( " Empty\n" );
690 }
691 for ( ; lr != NULL; lr = lr->lr_next ) {
692 sprintf( msg, " * msgid %d, origid %d, status %s\n",
693 lr->lr_msgid, lr->lr_origid, ( lr->lr_status ==
694 LDAP_REQST_INPROGRESS ) ? "InProgress" :
695 ( lr->lr_status == LDAP_REQST_CHASINGREFS ) ? "ChasingRefs" :
696 ( lr->lr_status == LDAP_REQST_NOTCONNECTED ) ? "NotConnected" :
697 ( lr->lr_status == LDAP_REQST_CONNDEAD ) ? "Dead" :
698 "Writing" );
699 ber_err_print( msg );
700 sprintf( msg, " outstanding referrals %d, parent count %d\n",
701 lr->lr_outrefcnt, lr->lr_parentcnt );
702 ber_err_print( msg );
703 if ( lr->lr_binddn != NULL ) {
704 sprintf( msg, " pending bind DN: <%s>\n", lr->lr_binddn );
705 ber_err_print( msg );
706 }
707 }
708 LDAP_MUTEX_UNLOCK( ld, LDAP_REQ_LOCK );
709
710 ber_err_print( "** Response Queue:\n" );
711 LDAP_MUTEX_LOCK( ld, LDAP_RESP_LOCK );
712 if (( lm = ld->ld_responses ) == NULLMSG ) {
713 ber_err_print( " Empty\n" );
714 }
715 for ( ; lm != NULLMSG; lm = lm->lm_next ) {
716 sprintf( msg, " * msgid %d, type %d\n",
717 lm->lm_msgid, lm->lm_msgtype );
718 ber_err_print( msg );
719 if (( l = lm->lm_chain ) != NULL ) {
720 ber_err_print( " chained responses:\n" );
721 for ( ; l != NULLMSG; l = l->lm_chain ) {
722 sprintf( msg,
723 " * msgid %d, type %d\n",
724 l->lm_msgid, l->lm_msgtype );
725 ber_err_print( msg );
726 }
727 }
728 }
729 LDAP_MUTEX_UNLOCK( ld, LDAP_RESP_LOCK );
730 }
731 #endif /* LDAP_DEBUG */
732
733
734 void
735 nsldapi_free_request( LDAP *ld, LDAPRequest *lr, int free_conn )
736 {
737 LDAPRequest *tmplr, *nextlr;
738
739 LDAPDebug( LDAP_DEBUG_TRACE,
740 "nsldapi_free_request 0x%x (origid %d, msgid %d)\n",
741 lr, lr->lr_origid, lr->lr_msgid );
742
743 if ( lr->lr_parent != NULL ) {
744 --lr->lr_parent->lr_outrefcnt;
745 }
746
747 /* free all of our spawned referrals (child requests) */
748 for ( tmplr = lr->lr_child; tmplr != NULL; tmplr = nextlr ) {
749 nextlr = tmplr->lr_sibling;
750 nsldapi_free_request( ld, tmplr, free_conn );
751 }
752
753 if ( free_conn ) {
754 nsldapi_free_connection( ld, lr->lr_conn, NULL, NULL, 0, 1 );
755 }
756
757 if ( lr->lr_prev == NULL ) {
758 ld->ld_requests = lr->lr_next;
759 } else {
760 lr->lr_prev->lr_next = lr->lr_next;
761 }
762
763 if ( lr->lr_next != NULL ) {
764 lr->lr_next->lr_prev = lr->lr_prev;
765 }
766
767 if ( lr->lr_ber != NULL ) {
768 ber_free( lr->lr_ber, 1 );
769 }
770
771 if ( lr->lr_res_error != NULL ) {
772 NSLDAPI_FREE( lr->lr_res_error );
773 }
774
775 if ( lr->lr_res_matched != NULL ) {
776 NSLDAPI_FREE( lr->lr_res_matched );
777 }
778
779 if ( lr->lr_binddn != NULL ) {
780 NSLDAPI_FREE( lr->lr_binddn );
781 }
782 NSLDAPI_FREE( lr );
783 }
784
785
786 static void
787 free_servers( LDAPServer *srvlist )
788 {
789 LDAPServer *nextsrv;
790
791 while ( srvlist != NULL ) {
792 nextsrv = srvlist->lsrv_next;
793 if ( srvlist->lsrv_dn != NULL ) {
794 NSLDAPI_FREE( srvlist->lsrv_dn );
795 }
796 if ( srvlist->lsrv_host != NULL ) {
797 NSLDAPI_FREE( srvlist->lsrv_host );
798 }
799 NSLDAPI_FREE( srvlist );
800 srvlist = nextsrv;
801 }
802 }
803
804
805 /*
806 * Initiate chasing of LDAPv2+ (Umich extension) referrals.
807 *
808 * Returns an LDAP error code.
809 *
810 * Note that *hadrefp will be set to 1 if one or more referrals were found in
811 * "*errstrp" (even if we can't chase them) and zero if none were found.
812 *
813 * XXX merging of errors in this routine needs to be improved.
814 */
815 int
816 nsldapi_chase_v2_referrals( LDAP *ld, LDAPRequest *lr, char **errstrp,
817 int *totalcountp, int *chasingcountp )
818 {
819 char *p, *ref, *unfollowed;
820 LDAPRequest *origreq;
821 int rc, tmprc, len, unknown;
822
823 LDAPDebug( LDAP_DEBUG_TRACE, "nsldapi_chase_v2_referrals\n", 0, 0, 0 );
824
825 *totalcountp = *chasingcountp = 0;
826
827 if ( *errstrp == NULL ) {
828 return( LDAP_SUCCESS );
829 }
830
831 len = strlen( *errstrp );
832 for ( p = *errstrp; len >= LDAP_REF_STR_LEN; ++p, --len ) {
833 if (( *p == 'R' || *p == 'r' ) && strncasecmp( p,
834 LDAP_REF_STR, LDAP_REF_STR_LEN ) == 0 ) {
835 *p = '\0';
836 p += LDAP_REF_STR_LEN;
837 break;
838 }
839 }
840
841 if ( len < LDAP_REF_STR_LEN ) {
842 return( LDAP_SUCCESS );
843 }
844
845 if ( lr->lr_parentcnt >= ld->ld_refhoplimit ) {
846 LDAPDebug( LDAP_DEBUG_TRACE,
847 "more than %d referral hops (dropping)\n",
848 ld->ld_refhoplimit, 0, 0 );
849 return( LDAP_REFERRAL_LIMIT_EXCEEDED );
850 }
851
852 /* find original request */
853 for ( origreq = lr; origreq->lr_parent != NULL;
854 origreq = origreq->lr_parent ) {
855 ;
856 }
857
858 unfollowed = NULL;
859 rc = LDAP_SUCCESS;
860
861 /* parse out & follow referrals */
862 for ( ref = p; rc == LDAP_SUCCESS && ref != NULL; ref = p ) {
863 if (( p = strchr( ref, '\n' )) != NULL ) {
864 *p++ = '\0';
865 } else {
866 p = NULL;
867 }
868
869 ++*totalcountp;
870
871 rc = chase_one_referral( ld, lr, origreq, ref, "v2 referral",
872 &unknown );
873
874 if ( rc != LDAP_SUCCESS || unknown ) {
875 if (( tmprc = nsldapi_append_referral( ld, &unfollowed,
876 ref )) != LDAP_SUCCESS ) {
877 rc = tmprc;
878 }
879 } else {
880 ++*chasingcountp;
881 }
882 }
883
884 NSLDAPI_FREE( *errstrp );
885 *errstrp = unfollowed;
886
887 return( rc );
888 }
889
890
891 /* returns an LDAP error code */
892 int
893 nsldapi_chase_v3_refs( LDAP *ld, LDAPRequest *lr, char **v3refs,
894 int is_reference, int *totalcountp, int *chasingcountp )
895 {
896 int i, rc, unknown;
897 LDAPRequest *origreq;
898
899 *totalcountp = *chasingcountp = 0;
900
901 if ( v3refs == NULL || v3refs[0] == NULL ) {
902 return( LDAP_SUCCESS );
903 }
904
905 *totalcountp = 1;
906
907 if ( lr->lr_parentcnt >= ld->ld_refhoplimit ) {
908 LDAPDebug( LDAP_DEBUG_TRACE,
909 "more than %d referral hops (dropping)\n",
910 ld->ld_refhoplimit, 0, 0 );
911 return( LDAP_REFERRAL_LIMIT_EXCEEDED );
912 }
913
914 /* find original request */
915 for ( origreq = lr; origreq->lr_parent != NULL;
916 origreq = origreq->lr_parent ) {
917 ;
918 }
919
920 /*
921 * in LDAPv3, we just need to follow one referral in the set.
922 * we dp this by stopping as soon as we succeed in initiating a
923 * chase on any referral (basically this means we were able to connect
924 * to the server and bind).
925 */
926 for ( i = 0; v3refs[i] != NULL; ++i ) {
927 rc = chase_one_referral( ld, lr, origreq, v3refs[i],
928 is_reference ? "v3 reference" : "v3 referral", &unknown );
929 if ( rc == LDAP_SUCCESS && !unknown ) {
930 *chasingcountp = 1;
931 break;
932 }
933 }
934
935 /* XXXmcs: should we save unfollowed referrals somewhere? */
936
937 return( rc ); /* last error is as good as any other I guess... */
938 }
939
940 /*
941 * returns an LDAP error code
942 *
943 * XXXmcs: this function used to have #ifdef LDAP_DNS code in it but I
944 * removed it when I improved the parsing (we don't define LDAP_DNS
945 * here at Netscape).
946 */
947 static int
948 chase_one_referral( LDAP *ld, LDAPRequest *lr, LDAPRequest *origreq,
949 char *refurl, char *desc, int *unknownp )
950 {
951 int rc, tmprc, secure, msgid;
952 LDAPServer *srv;
953 BerElement *ber;
954 LDAPURLDesc *ludp;
955
956 *unknownp = 0;
957 ludp = NULLLDAPURLDESC;
958
959 if ( nsldapi_url_parse( refurl, &ludp, 0 ) != 0 ) {
960 LDAPDebug( LDAP_DEBUG_TRACE,
961 "ignoring unknown %s <%s>\n", desc, refurl, 0 );
962 *unknownp = 1;
963 rc = LDAP_SUCCESS;
964 goto cleanup_and_return;
965 }
966
967 secure = (( ludp->lud_options & LDAP_URL_OPT_SECURE ) != 0 );
968
969 /* XXXmcs: can't tell if secure is supported by connect callback */
970 if ( secure && ld->ld_extconnect_fn == NULL ) {
971 LDAPDebug( LDAP_DEBUG_TRACE,
972 "ignoring LDAPS %s <%s>\n", desc, refurl, 0 );
973 *unknownp = 1;
974 rc = LDAP_SUCCESS;
975 goto cleanup_and_return;
976 }
977
978 LDAPDebug( LDAP_DEBUG_TRACE, "chasing LDAP%s %s: <%s>\n",
979 secure ? "S" : "", desc, refurl );
980
981 LDAP_MUTEX_LOCK( ld, LDAP_MSGID_LOCK );
982 msgid = ++ld->ld_msgid;
983 LDAP_MUTEX_UNLOCK( ld, LDAP_MSGID_LOCK );
984
985 if (( tmprc = re_encode_request( ld, origreq->lr_ber, msgid,
986 ludp, &ber )) != LDAP_SUCCESS ) {
987 rc = tmprc;
988 goto cleanup_and_return;
989 }
990
991 if (( srv = (LDAPServer *)NSLDAPI_CALLOC( 1, sizeof( LDAPServer )))
992 == NULL ) {
993 ber_free( ber, 1 );
994 rc = LDAP_NO_MEMORY;
995 goto cleanup_and_return;
996 }
997
998 if (ludp->lud_host == NULL && ld->ld_defhost == NULL) {
999 srv->lsrv_host = NULL;
1000 } else {
1001 if (ludp->lud_host == NULL) {
1002 srv->lsrv_host =
1003 nsldapi_strdup( origreq->lr_conn->lconn_server->lsrv_host );
1004 LDAPDebug(LDAP_DEBUG_TRACE,
1005 "chase_one_referral: using hostname '%s' from original "
1006 "request on new request\n",
1007 srv->lsrv_host, 0, 0);
1008 } else {
1009 srv->lsrv_host = nsldapi_strdup(ludp->lud_host);
1010 LDAPDebug(LDAP_DEBUG_TRACE,
1011 "chase_one_referral: using hostname '%s' as specified "
1012 "on new request\n",
1013 srv->lsrv_host, 0, 0);
1014 }
1015
1016 if (srv->lsrv_host == NULL) {
1017 NSLDAPI_FREE((char *)srv);
1018 ber_free(ber, 1);
1019 rc = LDAP_NO_MEMORY;
1020 goto cleanup_and_return;
1021 }
1022 }
1023
1024 /*
1025 * According to our reading of RFCs 2255 and 1738, the
1026 * following algorithm applies:
1027 * - no hostport (no host, no port) provided in LDAP URL, use those
1028 * of previous request
1029 * - no port but a host, use default LDAP port
1030 * - else use given hostport
1031 */
1032 if (ludp->lud_port == 0 && ludp->lud_host == NULL) {
1033 srv->lsrv_port = origreq->lr_conn->lconn_server->lsrv_port;
1034 LDAPDebug(LDAP_DEBUG_TRACE,
1035 "chase_one_referral: using port (%d) from original "
1036 "request on new request\n",
1037 srv->lsrv_port, 0, 0);
1038 } else if (ludp->lud_port == 0 && ludp->lud_host != NULL) {
1039 srv->lsrv_port = (secure) ? LDAPS_PORT : LDAP_PORT;
1040 LDAPDebug(LDAP_DEBUG_TRACE,
1041 "chase_one_referral: using default port (%d) \n",
1042 srv->lsrv_port, 0, 0);
1043 } else {
1044 srv->lsrv_port = ludp->lud_port;
1045 LDAPDebug(LDAP_DEBUG_TRACE,
1046 "chase_one_referral: using port (%d) as specified on "
1047 "new request\n",
1048 srv->lsrv_port, 0, 0);
1049 }
1050
1051 if ( secure ) {
1052 srv->lsrv_options |= LDAP_SRV_OPT_SECURE;
1053 }
1054
1055 if ( nsldapi_send_server_request( ld, ber, msgid,
1056 lr, srv, NULL, NULL, 1 ) < 0 ) {
1057 rc = LDAP_GET_LDERRNO( ld, NULL, NULL );
1058 LDAPDebug( LDAP_DEBUG_ANY, "Unable to chase %s %s (%s)\n",
1059 desc, refurl, ldap_err2string( rc ));
1060 } else {
1061 rc = LDAP_SUCCESS;
1062 }
1063
1064 cleanup_and_return:
1065 if ( ludp != NULLLDAPURLDESC ) {
1066 ldap_free_urldesc( ludp );
1067 }
1068
1069 return( rc );
1070 }
1071
1072
1073 /* returns an LDAP error code */
1074 int
1075 nsldapi_append_referral( LDAP *ld, char **referralsp, char *s )
1076 {
1077 int first;
1078
1079 if ( *referralsp == NULL ) {
1080 first = 1;
1081 *referralsp = (char *)NSLDAPI_MALLOC( strlen( s ) +
1082 LDAP_REF_STR_LEN + 1 );
1083 } else {
1084 first = 0;
1085 *referralsp = (char *)NSLDAPI_REALLOC( *referralsp,
1086 strlen( *referralsp ) + strlen( s ) + 2 );
1087 }
1088
1089 if ( *referralsp == NULL ) {
1090 return( LDAP_NO_MEMORY );
1091 }
1092
1093 if ( first ) {
1094 strcpy( *referralsp, LDAP_REF_STR );
1095 } else {
1096 strcat( *referralsp, "\n" );
1097 }
1098 strcat( *referralsp, s );
1099
1100 return( LDAP_SUCCESS );
1101 }
1102
1103
1104
1105 /* returns an LDAP error code */
1106 static int
1107 re_encode_request( LDAP *ld, BerElement *origber, int msgid, LDAPURLDesc *ludp,
1108 BerElement **berp )
1109 {
1110 /*
1111 * XXX this routine knows way too much about how the lber library works!
1112 */
1113 ber_uint_t along;
1114 ber_tag_t tag;
1115 ber_int_t ver;
1116 int rc;
1117 BerElement *ber;
1118 struct berelement tmpber;
1119 char *dn, *orig_dn;
1120
1121 LDAPDebug( LDAP_DEBUG_TRACE,
1122 "re_encode_request: new msgid %d, new dn <%s>\n",
1123 msgid, ( ludp->lud_dn == NULL ) ? "NONE" : ludp->lud_dn, 0 );
1124
1125 tmpber = *origber;
1126
1127 /*
1128 * All LDAP requests are sequences that start with a message id. For
1129 * everything except delete requests, this is followed by a sequence
1130 * that is tagged with the operation code. For deletes, there is just
1131 * a DN that is tagged with the operation code.
1132 */
1133
1134 /* skip past msgid and get operation tag */
1135 if ( ber_scanf( &tmpber, "{it", &along, &tag ) == LBER_ERROR ) {
1136 return( LDAP_DECODING_ERROR );
1137 }
1138
1139 /*
1140 * XXXmcs: we don't support scope or filters in search referrals yet,
1141 * so if either were present we return an error which is probably
1142 * better than just ignoring the extra info.
1143 */
1144 if ( tag == LDAP_REQ_SEARCH &&
1145 ( ludp->lud_scope != -1 || ludp->lud_filter != NULL )) {
1146 return( LDAP_LOCAL_ERROR );
1147 }
1148
1149 if ( tag == LDAP_REQ_BIND ) {
1150 /* bind requests have a version number before the DN */
1151 rc = ber_scanf( &tmpber, "{ia", &ver, &orig_dn );
1152 } else if ( tag == LDAP_REQ_DELETE ) {
1153 /* delete requests DNs are not within a sequence */
1154 rc = ber_scanf( &tmpber, "a", &orig_dn );
1155 } else {
1156 rc = ber_scanf( &tmpber, "{a", &orig_dn );
1157 }
1158
1159 if ( rc == LBER_ERROR ) {
1160 return( LDAP_DECODING_ERROR );
1161 }
1162
1163 if ( ludp->lud_dn == NULL ) {
1164 dn = orig_dn;
1165 } else {
1166 dn = ludp->lud_dn;
1167 NSLDAPI_FREE( orig_dn );
1168 orig_dn = NULL;
1169 }
1170
1171 /* allocate and build the new request */
1172 if (( rc = nsldapi_alloc_ber_with_options( ld, &ber ))
1173 != LDAP_SUCCESS ) {
1174 if ( orig_dn != NULL ) {
1175 NSLDAPI_FREE( orig_dn );
1176 }
1177 return( rc );
1178 }
1179
1180 if ( tag == LDAP_REQ_BIND ) {
1181 rc = ber_printf( ber, "{it{is", msgid, tag,
1182 (int)ver /* XXX lossy cast */, dn );
1183 } else if ( tag == LDAP_REQ_DELETE ) {
1184 rc = ber_printf( ber, "{its}", msgid, tag, dn );
1185 } else {
1186 rc = ber_printf( ber, "{it{s", msgid, tag, dn );
1187 }
1188
1189 if ( orig_dn != NULL ) {
1190 NSLDAPI_FREE( orig_dn );
1191 }
1192 /*
1193 * can't use "dn" or "orig_dn" from this point on (they've been freed)
1194 */
1195
1196 if ( rc == -1 ) {
1197 ber_free( ber, 1 );
1198 return( LDAP_ENCODING_ERROR );
1199 }
1200
1201 if ( tag != LDAP_REQ_DELETE &&
1202 ( ber_write( ber, tmpber.ber_ptr, ( tmpber.ber_end -
1203 tmpber.ber_ptr ), 0 ) != ( tmpber.ber_end - tmpber.ber_ptr )
1204 || ber_printf( ber, "}}" ) == -1 )) {
1205 ber_free( ber, 1 );
1206 return( LDAP_ENCODING_ERROR );
1207 }
1208
1209 #ifdef LDAP_DEBUG
1210 if ( ldap_debug & LDAP_DEBUG_PACKETS ) {
1211 LDAPDebug( LDAP_DEBUG_ANY, "re_encode_request new request is:\n",
1212 0, 0, 0 );
1213 ber_dump( ber, 0 );
1214 }
1215 #endif /* LDAP_DEBUG */
1216
1217 *berp = ber;
1218 return( LDAP_SUCCESS );
1219 }
1220
1221
1222 LDAPRequest *
1223 nsldapi_find_request_by_msgid( LDAP *ld, int msgid )
1224 {
1225 LDAPRequest *lr;
1226
1227 for ( lr = ld->ld_requests; lr != NULL; lr = lr->lr_next ) {
1228 if ( msgid == lr->lr_msgid ) {
1229 break;
1230 }
1231 }
1232
1233 return( lr );
1234 }
1235
1236
1237 /*
1238 * nsldapi_connection_lost_nolock() resets "ld" to a non-connected, known
1239 * state. It should be called whenever a fatal error occurs on the
1240 * Sockbuf "sb." sb == NULL means we don't know specifically where
1241 * the problem was so we assume all connections are bad.
1242 */
1243 void
1244 nsldapi_connection_lost_nolock( LDAP *ld, Sockbuf *sb )
1245 {
1246 LDAPRequest *lr;
1247
1248 /*
1249 * change status of all pending requests that are associated with "sb
1250 * to "connection dead."
1251 * also change the connection status to "dead" and remove it from
1252 * the list of sockets we are interested in.
1253 */
1254 for ( lr = ld->ld_requests; lr != NULL; lr = lr->lr_next ) {
1255 if ( sb == NULL ||
1256 ( lr->lr_conn != NULL && lr->lr_conn->lconn_sb == sb )) {
1257 lr->lr_status = LDAP_REQST_CONNDEAD;
1258 if ( lr->lr_conn != NULL ) {
1259 lr->lr_conn->lconn_status = LDAP_CONNST_DEAD;
1260 nsldapi_iostatus_interest_clear( ld,
1261 lr->lr_conn->lconn_sb );
1262 }
1263 }
1264 }
1265 }
1266
1267
1268 #ifdef LDAP_DNS
1269 static LDAPServer *
1270 dn2servers( LDAP *ld, char *dn ) /* dn can also be a domain.... */
1271 {
1272 char *p, *domain, *host, *server_dn, **dxs;
1273 int i, port;
1274 LDAPServer *srvlist, *prevsrv, *srv;
1275
1276 if (( domain = strrchr( dn, '@' )) != NULL ) {
1277 ++domain;
1278 } else {
1279 domain = dn;
1280 }
1281
1282 if (( dxs = nsldapi_getdxbyname( domain )) == NULL ) {
1283 LDAP_SET_LDERRNO( ld, LDAP_NO_MEMORY, NULL, NULL );
1284 return( NULL );
1285 }
1286
1287 srvlist = NULL;
1288
1289 for ( i = 0; dxs[ i ] != NULL; ++i ) {
1290 port = LDAP_PORT;
1291 server_dn = NULL;
1292 if ( strchr( dxs[ i ], ':' ) == NULL ) {
1293 host = dxs[ i ];
1294 } else if ( strlen( dxs[ i ] ) >= 7 &&
1295 strncmp( dxs[ i ], "ldap://", 7 ) == 0 ) {
1296 host = dxs[ i ] + 7;
1297 if (( p = strchr( host, ':' )) == NULL ) {
1298 p = host;
1299 } else {
1300 *p++ = '\0';
1301 port = atoi( p );
1302 }
1303 if (( p = strchr( p, '/' )) != NULL ) {
1304 server_dn = ++p;
1305 if ( *server_dn == '\0' ) {
1306 server_dn = NULL;
1307 }
1308 }
1309 } else {
1310 host = NULL;
1311 }
1312
1313 if ( host != NULL ) { /* found a server we can use */
1314 if (( srv = (LDAPServer *)NSLDAPI_CALLOC( 1,
1315 sizeof( LDAPServer ))) == NULL ) {
1316 free_servers( srvlist );
1317 srvlist = NULL;
1318 break; /* exit loop & return */
1319 }
1320
1321 /* add to end of list of servers */
1322 if ( srvlist == NULL ) {
1323 srvlist = srv;
1324 } else {
1325 prevsrv->lsrv_next = srv;
1326 }
1327 prevsrv = srv;
1328
1329 /* copy in info. */
1330 if (( srv->lsrv_host = nsldapi_strdup( host )) == NULL
1331 || ( server_dn != NULL && ( srv->lsrv_dn =
1332 nsldapi_strdup( server_dn )) == NULL )) {
1333 free_servers( srvlist );
1334 srvlist = NULL;
1335 break; /* exit loop & return */
1336 }
1337 srv->lsrv_port = port;
1338 }
1339 }
1340
1341 ldap_value_free( dxs );
1342
1343 if ( srvlist == NULL ) {
1344 LDAP_SET_LDERRNO( ld, LDAP_SERVER_DOWN, NULL, NULL );
1345 }
1346
1347 return( srvlist );
1348 }
1349 #endif /* LDAP_DNS */
unleashed repo fork