Home | History | Annotate | Line # | Download | only in progs 
      1 /*	$NetBSD: slapd-mtread.c,v 1.4 2025/09/05 21:16:33 christos Exp $	*/
      2 
      3 /* $OpenLDAP$ */
      4 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
      5  *
      6  * Copyright 1999-2024 The OpenLDAP Foundation.
      7  * All rights reserved.
      8  *
      9  * Redistribution and use in source and binary forms, with or without
     10  * modification, are permitted only as authorized by the OpenLDAP
     11  * Public License.
     12  *
     13  * A copy of this license is available in file LICENSE in the
     14  * top-level directory of the distribution or, alternatively, at
     15  * <http://www.OpenLDAP.org/license.html>.
     16  */
     17 /* ACKNOWLEDGEMENTS:
     18  * This work was initially developed by Kurt Spanier for inclusion
     19  * in OpenLDAP Software.
     20  */
     21 
     22 /*
     23  * This tool is a MT reader.  It behaves like slapd-read however
     24  * with one or more threads simultaneously using the same connection.
     25  * If -M is enabled, then M threads will also perform write operations.
     26  */
     27 
     28 #include <sys/cdefs.h>
     29 __RCSID("$NetBSD: slapd-mtread.c,v 1.4 2025/09/05 21:16:33 christos Exp $");
     30 
     31 #include "portable.h"
     32 
     33 /* Requires libldap with threads */
     34 #ifndef NO_THREADS
     35 
     36 #include <stdio.h>
     37 #include "ldap_pvt_thread.h"
     38 
     39 #include "ac/stdlib.h"
     40 
     41 #include "ac/ctype.h"
     42 #include "ac/param.h"
     43 #include "ac/socket.h"
     44 #include "ac/string.h"
     45 #include "ac/unistd.h"
     46 #include "ac/wait.h"
     47 
     48 #include "ldap.h"
     49 #include "lutil.h"
     50 
     51 #include "ldap_pvt.h"
     52 
     53 #include "slapd-common.h"
     54 
     55 #define MAXCONN	512
     56 #define LOOPS	100
     57 #define RETRIES	0
     58 #define DEFAULT_BASE	"ou=people,dc=example,dc=com"
     59 
     60 static void
     61 do_read( LDAP *ld, char *entry,
     62 	char **attrs, int noattrs, int nobind, int maxloop,
     63 	int force, int idx );
     64 
     65 static void
     66 do_random( LDAP *ld,
     67 	char *sbase, char *filter, char **attrs, int noattrs, int nobind,
     68 	int force, int idx );
     69 
     70 static void
     71 do_random2( LDAP *ld,
     72 	char *sbase, char *filter, char **attrs, int noattrs, int nobind,
     73 	int force, int idx );
     74 
     75 static void *
     76 do_onethread( void *arg );
     77 
     78 static void *
     79 do_onerwthread( void *arg );
     80 
     81 #define MAX_THREAD	1024
     82 /* Use same array for readers and writers, offset writers by MAX_THREAD */
     83 int	rt_pass[MAX_THREAD*2];
     84 int	rt_fail[MAX_THREAD*2];
     85 int	*rwt_pass = rt_pass + MAX_THREAD;
     86 int	*rwt_fail = rt_fail + MAX_THREAD;
     87 ldap_pvt_thread_t	rtid[MAX_THREAD*2], *rwtid = rtid + MAX_THREAD;
     88 
     89 /*
     90  * Shared globals (command line args)
     91  */
     92 LDAP		*ld = NULL;
     93 struct tester_conn_args	*config;
     94 char		*entry = NULL;
     95 char		*filter  = NULL;
     96 int		force = 0;
     97 char		*srchattrs[] = { "1.1", NULL };
     98 char		**attrs = srchattrs;
     99 int		noattrs = 0;
    100 int		nobind = 0;
    101 int		threads = 1;
    102 int		rwthreads = 0;
    103 int		verbose = 0;
    104 
    105 int		noconns = 1;
    106 LDAP		**lds = NULL;
    107 
    108 static void
    109 thread_error(int idx, char *string)
    110 {
    111 	char		thrstr[BUFSIZ];
    112 
    113 	snprintf(thrstr, BUFSIZ, "error on tidx: %d: %s", idx, string);
    114 	tester_error( thrstr );
    115 }
    116 
    117 static void
    118 thread_output(int idx, char *string)
    119 {
    120 	char		thrstr[BUFSIZ];
    121 
    122 	snprintf(thrstr, BUFSIZ, "tidx: %d says: %s", idx, string);
    123 	tester_error( thrstr );
    124 }
    125 
    126 static void
    127 thread_verbose(int idx, char *string)
    128 {
    129 	char		thrstr[BUFSIZ];
    130 
    131 	if (!verbose)
    132 		return;
    133 	snprintf(thrstr, BUFSIZ, "tidx: %d says: %s", idx, string);
    134 	tester_error( thrstr );
    135 }
    136 
    137 static void
    138 usage( char *name, char opt )
    139 {
    140 	if ( opt ) {
    141 		fprintf( stderr, "%s: unable to handle option \'%c\'\n\n",
    142 			name, opt );
    143 	}
    144 
    145 	fprintf( stderr, "usage: %s " TESTER_COMMON_HELP
    146 		"-e <entry> "
    147 		"[-A] "
    148 		"[-F] "
    149 		"[-N] "
    150 		"[-v] "
    151 		"[-c connections] "
    152 		"[-f filter] "
    153 		"[-m threads] "
    154 		"[-M threads] "
    155 		"[-T <attrs>] "
    156 		"[<attrs>] "
    157 		"\n",
    158 		name );
    159 	exit( EXIT_FAILURE );
    160 }
    161 
    162 int
    163 main( int argc, char **argv )
    164 {
    165 	int		i;
    166 	char		*uri = NULL;
    167 	char		*manager = NULL;
    168 	struct berval	passwd = { 0, NULL };
    169 	char		outstr[BUFSIZ];
    170 	int		ptpass;
    171 	int		testfail = 0;
    172 
    173 	config = tester_init( "slapd-mtread", TESTER_READ );
    174 
    175 	/* by default, tolerate referrals and no such object */
    176 	tester_ignore_str2errlist( "REFERRAL,NO_SUCH_OBJECT" );
    177 
    178 	while ( (i = getopt( argc, argv, TESTER_COMMON_OPTS "Ac:e:Ff:M:m:NT:v" )) != EOF ) {
    179 		switch ( i ) {
    180 		case 'A':
    181 			noattrs++;
    182 			break;
    183 
    184 		case 'N':
    185 			nobind = TESTER_INIT_ONLY;
    186 			break;
    187 
    188 		case 'v':
    189 			verbose++;
    190 			break;
    191 
    192 		case 'c':		/* the number of connections */
    193 			if ( lutil_atoi( &noconns, optarg ) != 0 ) {
    194 				usage( argv[0], i );
    195 			}
    196 			break;
    197 
    198 		case 'e':		/* DN to search for */
    199 			entry = optarg;
    200 			break;
    201 
    202 		case 'f':		/* the search request */
    203 			filter = optarg;
    204 			break;
    205 
    206 		case 'F':
    207 			force++;
    208 			break;
    209 
    210 		case 'M':		/* the number of R/W threads */
    211 			if ( lutil_atoi( &rwthreads, optarg ) != 0 ) {
    212 				usage( argv[0], i );
    213 			}
    214 			if (rwthreads > MAX_THREAD)
    215 				rwthreads = MAX_THREAD;
    216 			break;
    217 
    218 		case 'm':		/* the number of threads */
    219 			if ( lutil_atoi( &threads, optarg ) != 0 ) {
    220 				usage( argv[0], i );
    221 			}
    222 			if (threads > MAX_THREAD)
    223 				threads = MAX_THREAD;
    224 			break;
    225 
    226 		case 'T':
    227 			attrs = ldap_str2charray( optarg, "," );
    228 			if ( attrs == NULL ) {
    229 				usage( argv[0], i );
    230 			}
    231 			break;
    232 
    233 		default:
    234 			if ( tester_config_opt( config, i, optarg ) == LDAP_SUCCESS ) {
    235 				break;
    236 			}
    237 			usage( argv[0], i );
    238 			break;
    239 		}
    240 	}
    241 
    242 	if ( entry == NULL )
    243 		usage( argv[0], 0 );
    244 
    245 	if ( *entry == '\0' ) {
    246 		fprintf( stderr, "%s: invalid EMPTY entry DN.\n",
    247 				argv[0] );
    248 		exit( EXIT_FAILURE );
    249 	}
    250 
    251 	if ( argv[optind] != NULL ) {
    252 		attrs = &argv[optind];
    253 	}
    254 
    255 	if (noconns < 1)
    256 		noconns = 1;
    257 	if (noconns > MAXCONN)
    258 		noconns = MAXCONN;
    259 	lds = (LDAP **) calloc( sizeof(LDAP *), noconns);
    260 	if (lds == NULL) {
    261 		fprintf( stderr, "%s: Memory error: calloc noconns.\n",
    262 				argv[0] );
    263 		exit( EXIT_FAILURE );
    264 	}
    265 
    266 	tester_config_finish( config );
    267 	ldap_pvt_thread_initialize();
    268 
    269 	for (i = 0; i < noconns; i++) {
    270 		tester_init_ld( &lds[i], config, nobind );
    271 	}
    272 
    273 	snprintf(outstr, BUFSIZ, "MT Test Start: conns: %d (%s)", noconns, uri);
    274 	tester_error(outstr);
    275 	snprintf(outstr, BUFSIZ, "Threads: RO: %d RW: %d", threads, rwthreads);
    276 	tester_error(outstr);
    277 
    278 	/* Set up read only threads */
    279 	for ( i = 0; i < threads; i++ ) {
    280 		ldap_pvt_thread_create( &rtid[i], 0, do_onethread, &rtid[i]);
    281 		snprintf(outstr, BUFSIZ, "Created RO thread %d", i);
    282 		thread_verbose(-1, outstr);
    283 	}
    284 	/* Set up read/write threads */
    285 	for ( i = 0; i < rwthreads; i++ ) {
    286 		ldap_pvt_thread_create( &rwtid[i], 0, do_onerwthread, &rwtid[i]);
    287 		snprintf(outstr, BUFSIZ, "Created RW thread %d", i + MAX_THREAD);
    288 		thread_verbose(-1, outstr);
    289 	}
    290 
    291 	ptpass =  config->outerloops * config->loops;
    292 
    293 	/* wait for read only threads to complete */
    294 	for ( i = 0; i < threads; i++ )
    295 		ldap_pvt_thread_join(rtid[i], NULL);
    296 	/* wait for read/write threads to complete */
    297 	for ( i = 0; i < rwthreads; i++ )
    298 		ldap_pvt_thread_join(rwtid[i], NULL);
    299 
    300 	for(i = 0; i < noconns; i++) {
    301 		if ( lds[i] != NULL ) {
    302 			ldap_unbind_ext( lds[i], NULL, NULL );
    303 		}
    304 	}
    305 	free( lds );
    306 
    307 	for ( i = 0; i < threads; i++ ) {
    308 		snprintf(outstr, BUFSIZ, "RO thread %d pass=%d fail=%d", i,
    309 			rt_pass[i], rt_fail[i]);
    310 		tester_error(outstr);
    311 		if (rt_fail[i] != 0 || rt_pass[i] != ptpass) {
    312 			snprintf(outstr, BUFSIZ, "FAIL RO thread %d", i);
    313 			tester_error(outstr);
    314 			testfail++;
    315 		}
    316 	}
    317 	for ( i = 0; i < rwthreads; i++ ) {
    318 		snprintf(outstr, BUFSIZ, "RW thread %d pass=%d fail=%d", i + MAX_THREAD,
    319 			rwt_pass[i], rwt_fail[i]);
    320 		tester_error(outstr);
    321 		if (rwt_fail[i] != 0 || rwt_pass[i] != ptpass) {
    322 			snprintf(outstr, BUFSIZ, "FAIL RW thread %d", i);
    323 			tester_error(outstr);
    324 			testfail++;
    325 		}
    326 	}
    327 	snprintf(outstr, BUFSIZ, "MT Test complete" );
    328 	tester_error(outstr);
    329 
    330 	if (testfail)
    331 		exit( EXIT_FAILURE );
    332 	exit( EXIT_SUCCESS );
    333 }
    334 
    335 static void *
    336 do_onethread( void *arg )
    337 {
    338 	int		i, j, thisconn;
    339 	LDAP		**mlds;
    340 	char		thrstr[BUFSIZ];
    341 	int		rc, refcnt = 0;
    342 	int		idx = (ldap_pvt_thread_t *)arg - rtid;
    343 
    344 	mlds = (LDAP **) calloc( sizeof(LDAP *), noconns);
    345 	if (mlds == NULL) {
    346 		thread_error( idx, "Memory error: thread calloc for noconns" );
    347 		exit( EXIT_FAILURE );
    348 	}
    349 
    350 	for ( j = 0; j < config->outerloops; j++ ) {
    351 		for(i = 0; i < noconns; i++) {
    352 			mlds[i] = ldap_dup(lds[i]);
    353 			if (mlds[i] == NULL) {
    354 				thread_error( idx, "ldap_dup error" );
    355 			}
    356 		}
    357 		rc = ldap_get_option(mlds[0], LDAP_OPT_SESSION_REFCNT, &refcnt);
    358 		snprintf(thrstr, BUFSIZ,
    359 			"RO Thread conns: %d refcnt: %d (rc = %d)",
    360 			noconns, refcnt, rc);
    361 		thread_verbose(idx, thrstr);
    362 
    363 		thisconn = (idx + j) % noconns;
    364 		if (thisconn < 0 || thisconn >= noconns)
    365 			thisconn = 0;
    366 		if (mlds[thisconn] == NULL) {
    367 			thread_error( idx, "(failed to dup)");
    368 			tester_perror( "ldap_dup", "(failed to dup)" );
    369 			exit( EXIT_FAILURE );
    370 		}
    371 		snprintf(thrstr, BUFSIZ, "Using conn %d", thisconn);
    372 		thread_verbose(idx, thrstr);
    373 		if ( filter != NULL ) {
    374 			if (strchr(filter, '['))
    375 				do_random2( mlds[thisconn], entry, filter, attrs,
    376 					noattrs, nobind, force, idx );
    377 			else
    378 				do_random( mlds[thisconn], entry, filter, attrs,
    379 					noattrs, nobind, force, idx );
    380 
    381 		} else {
    382 			do_read( mlds[thisconn], entry, attrs, noattrs,
    383 				nobind, config->loops, force, idx );
    384 		}
    385 		for(i = 0; i < noconns; i++) {
    386 			(void) ldap_destroy(mlds[i]);
    387 			mlds[i] = NULL;
    388 		}
    389 	}
    390 	free( mlds );
    391 	return( NULL );
    392 }
    393 
    394 static void *
    395 do_onerwthread( void *arg )
    396 {
    397 	int		i, j, thisconn;
    398 	LDAP		**mlds, *ld;
    399 	char		thrstr[BUFSIZ];
    400 	char		dn[256], uids[32], cns[32], *base;
    401 	LDAPMod		*attrp[5], attrs[4];
    402 	char		*oc_vals[] = { "top", "OpenLDAPperson", NULL };
    403 	char		*cn_vals[] = { NULL, NULL };
    404 	char		*sn_vals[] = { NULL, NULL };
    405 	char		*uid_vals[] = { NULL, NULL };
    406 	int		ret;
    407 	int		adds = 0;
    408 	int		dels = 0;
    409 	int		rc, refcnt = 0;
    410 	int		idx = (ldap_pvt_thread_t *)arg - rtid;
    411 
    412 	mlds = (LDAP **) calloc( sizeof(LDAP *), noconns);
    413 	if (mlds == NULL) {
    414 		thread_error( idx, "Memory error: thread calloc for noconns" );
    415 		exit( EXIT_FAILURE );
    416 	}
    417 
    418 	snprintf(uids, sizeof(uids), "rwtest%04d", idx);
    419 	snprintf(cns, sizeof(cns), "rwtest%04d", idx);
    420 	/* add setup */
    421 	for (i = 0; i < 4; i++) {
    422 		attrp[i] = &attrs[i];
    423 		attrs[i].mod_op = 0;
    424 	}
    425 	attrp[4] = NULL;
    426 	attrs[0].mod_type = "objectClass";
    427 	attrs[0].mod_values = oc_vals;
    428 	attrs[1].mod_type = "cn";
    429 	attrs[1].mod_values = cn_vals;
    430 	cn_vals[0] = &cns[0];
    431 	attrs[2].mod_type = "sn";
    432 	attrs[2].mod_values = sn_vals;
    433 	sn_vals[0] = &cns[0];
    434 	attrs[3].mod_type = "uid";
    435 	attrs[3].mod_values = uid_vals;
    436 	uid_vals[0] = &uids[0];
    437 
    438 	for ( j = 0; j < config->outerloops; j++ ) {
    439 		for(i = 0; i < noconns; i++) {
    440 			mlds[i] = ldap_dup(lds[i]);
    441 			if (mlds[i] == NULL) {
    442 				thread_error( idx, "ldap_dup error" );
    443 			}
    444 		}
    445 		rc = ldap_get_option(mlds[0], LDAP_OPT_SESSION_REFCNT, &refcnt);
    446 		snprintf(thrstr, BUFSIZ,
    447 			"RW Thread conns: %d refcnt: %d (rc = %d)",
    448 			noconns, refcnt, rc);
    449 		thread_verbose(idx, thrstr);
    450 
    451 		thisconn = (idx + j) % noconns;
    452 		if (thisconn < 0 || thisconn >= noconns)
    453 			thisconn = 0;
    454 		if (mlds[thisconn] == NULL) {
    455 			thread_error( idx, "(failed to dup)");
    456 			tester_perror( "ldap_dup", "(failed to dup)" );
    457 			exit( EXIT_FAILURE );
    458 		}
    459 		snprintf(thrstr, BUFSIZ, "START RW Thread using conn %d", thisconn);
    460 		thread_verbose(idx, thrstr);
    461 
    462 		ld = mlds[thisconn];
    463 		if (entry != NULL)
    464 			base = entry;
    465 		else
    466 			base = DEFAULT_BASE;
    467 		snprintf(dn, 256, "cn=%s,%s", cns, base);
    468 
    469 		adds = 0;
    470 		dels = 0;
    471 		for (i = 0; i < config->loops; i++) {
    472 			ret = ldap_add_ext_s(ld, dn, &attrp[0], NULL, NULL);
    473 			if (ret == LDAP_SUCCESS) {
    474 				adds++;
    475 				ret = ldap_delete_ext_s(ld, dn, NULL, NULL);
    476 				if (ret == LDAP_SUCCESS) {
    477 					dels++;
    478 					rt_pass[idx]++;
    479 				} else {
    480 					thread_output(idx, ldap_err2string(ret));
    481 					rt_fail[idx]++;
    482 				}
    483 			} else {
    484 				thread_output(idx, ldap_err2string(ret));
    485 				rt_fail[idx]++;
    486 			}
    487 		}
    488 
    489 		snprintf(thrstr, BUFSIZ,
    490 			"INNER STOP RW Thread using conn %d (%d/%d)",
    491 			thisconn, adds, dels);
    492 		thread_verbose(idx, thrstr);
    493 
    494 		for(i = 0; i < noconns; i++) {
    495 			(void) ldap_destroy(mlds[i]);
    496 			mlds[i] = NULL;
    497 		}
    498 	}
    499 
    500 	free( mlds );
    501 	return( NULL );
    502 }
    503 
    504 static void
    505 do_random( LDAP *ld,
    506 	char *sbase, char *filter, char **srchattrs, int noattrs, int nobind,
    507 	int force, int idx )
    508 {
    509 	int  	i = 0, do_retry = config->retries;
    510 	char	*attrs[ 2 ];
    511 	int     rc = LDAP_SUCCESS;
    512 	int	nvalues = 0;
    513 	char	**values = NULL;
    514 	LDAPMessage *res = NULL, *e = NULL;
    515 	char	thrstr[BUFSIZ];
    516 
    517 	attrs[ 0 ] = LDAP_NO_ATTRS;
    518 	attrs[ 1 ] = NULL;
    519 
    520 	snprintf( thrstr, BUFSIZ,
    521 			"Read(%d): base=\"%s\", filter=\"%s\".\n",
    522 			config->loops, sbase, filter );
    523 	thread_verbose( idx, thrstr );
    524 
    525 	rc = ldap_search_ext_s( ld, sbase, LDAP_SCOPE_SUBTREE,
    526 		filter, attrs, 0, NULL, NULL, NULL, LDAP_NO_LIMIT, &res );
    527 	switch ( rc ) {
    528 	case LDAP_SIZELIMIT_EXCEEDED:
    529 	case LDAP_TIMELIMIT_EXCEEDED:
    530 	case LDAP_SUCCESS:
    531 		nvalues = ldap_count_entries( ld, res );
    532 		if ( nvalues == 0 ) {
    533 			if ( rc ) {
    534 				tester_ldap_error( ld, "ldap_search_ext_s", NULL );
    535 			}
    536 			ldap_msgfree( res );
    537 			break;
    538 		}
    539 
    540 		values = malloc( ( nvalues + 1 ) * sizeof( char * ) );
    541 		if (values == NULL) {
    542 			thread_error( idx, "(failed to malloc)");
    543 			exit( EXIT_FAILURE );
    544 		}
    545 		for ( i = 0, e = ldap_first_entry( ld, res ); e != NULL; i++, e = ldap_next_entry( ld, e ) )
    546 		{
    547 			values[ i ] = ldap_get_dn( ld, e );
    548 		}
    549 		values[ i ] = NULL;
    550 
    551 		ldap_msgfree( res );
    552 
    553 		if ( do_retry == config->retries ) {
    554 			snprintf( thrstr, BUFSIZ,
    555 				"Read base=\"%s\" filter=\"%s\" got %d values.\n",
    556 				sbase, filter, nvalues );
    557 			thread_verbose( idx, thrstr );
    558 		}
    559 
    560 		for ( i = 0; i < config->loops; i++ ) {
    561 			int	r = ((double)nvalues)*rand()/(RAND_MAX + 1.0);
    562 
    563 			do_read( ld, values[ r ],
    564 				srchattrs, noattrs, nobind, 1, force, idx );
    565 		}
    566 		for( i = 0; i < nvalues; i++) {
    567 			if (values[i] != NULL)
    568 				ldap_memfree( values[i] );
    569 		}
    570 		free( values );
    571 		break;
    572 
    573 	default:
    574 		tester_ldap_error( ld, "ldap_search_ext_s", NULL );
    575 		ldap_msgfree( res );
    576 		break;
    577 	}
    578 
    579 	snprintf( thrstr, BUFSIZ, "Search done (%d).\n", rc );
    580 	thread_verbose( idx, thrstr );
    581 }
    582 
    583 /* substitute a generated int into the filter */
    584 static void
    585 do_random2( LDAP *ld,
    586 	char *sbase, char *filter, char **srchattrs, int noattrs, int nobind,
    587 	int force, int idx )
    588 {
    589 	int  	i = 0, do_retry = config->retries;
    590 	int     rc = LDAP_SUCCESS;
    591 	int		lo, hi, range;
    592 	int	flen;
    593 	LDAPMessage *res = NULL;
    594 	char	*ptr, *ftail;
    595 	char	thrstr[BUFSIZ];
    596 	char	fbuf[BUFSIZ];
    597 
    598 	snprintf( thrstr, BUFSIZ,
    599 			"Read(%d): base=\"%s\", filter=\"%s\".\n",
    600 			config->loops, sbase, filter );
    601 	thread_verbose( idx, thrstr );
    602 
    603 	ptr = strchr(filter, '[');
    604 	if (!ptr)
    605 		return;
    606 	ftail = strchr(filter, ']');
    607 	if (!ftail || ftail < ptr)
    608 		return;
    609 
    610 	sscanf(ptr, "[%d-%d]", &lo, &hi);
    611 	range = hi - lo + 1;
    612 
    613 	flen = ptr - filter;
    614 	ftail++;
    615 
    616 	for ( i = 0; i < config->loops; i++ ) {
    617 		int	r = ((double)range)*rand()/(RAND_MAX + 1.0);
    618 		sprintf(fbuf, "%.*s%d%s", flen, filter, r, ftail);
    619 
    620 		rc = ldap_search_ext_s( ld, sbase, LDAP_SCOPE_SUBTREE,
    621 				fbuf, srchattrs, noattrs, NULL, NULL, NULL,
    622 				LDAP_NO_LIMIT, &res );
    623 		if ( res != NULL ) {
    624 			ldap_msgfree( res );
    625 		}
    626 		if ( rc == 0 ) {
    627 			rt_pass[idx]++;
    628 		} else {
    629 			int		first = tester_ignore_err( rc );
    630 			char		buf[ BUFSIZ ];
    631 
    632 			rt_fail[idx]++;
    633 			snprintf( buf, sizeof( buf ), "ldap_search_ext_s(%s)", entry );
    634 
    635 			/* if ignore.. */
    636 			if ( first ) {
    637 				/* only log if first occurrence */
    638 				if ( ( force < 2 && first > 0 ) || abs(first) == 1 ) {
    639 					tester_ldap_error( ld, buf, NULL );
    640 				}
    641 				continue;
    642 			}
    643 
    644 			/* busy needs special handling */
    645 			tester_ldap_error( ld, buf, NULL );
    646 			if ( rc == LDAP_BUSY && do_retry > 0 ) {
    647 				do_retry--;
    648 				continue;
    649 			}
    650 			break;
    651 		}
    652 	}
    653 
    654 	snprintf( thrstr, BUFSIZ, "Search done (%d).\n", rc );
    655 	thread_verbose( idx, thrstr );
    656 }
    657 
    658 static void
    659 do_read( LDAP *ld, char *entry,
    660 	char **attrs, int noattrs, int nobind, int maxloop,
    661 	int force, int idx )
    662 {
    663 	int  	i = 0, do_retry = config->retries;
    664 	int     rc = LDAP_SUCCESS;
    665 	char	thrstr[BUFSIZ];
    666 
    667 retry:;
    668 	if ( do_retry == config->retries ) {
    669 		snprintf( thrstr, BUFSIZ, "Read(%d): entry=\"%s\".\n",
    670 			maxloop, entry );
    671 		thread_verbose( idx, thrstr );
    672 	}
    673 
    674 	snprintf(thrstr, BUFSIZ, "LD %p cnt: %d (retried %d) (%s)", \
    675 		 (void *) ld, maxloop, (do_retry - config->retries), entry);
    676 	thread_verbose( idx, thrstr );
    677 
    678 	for ( ; i < maxloop; i++ ) {
    679 		LDAPMessage *res = NULL;
    680 
    681 		rc = ldap_search_ext_s( ld, entry, LDAP_SCOPE_BASE,
    682 				NULL, attrs, noattrs, NULL, NULL, NULL,
    683 				LDAP_NO_LIMIT, &res );
    684 		if ( res != NULL ) {
    685 			ldap_msgfree( res );
    686 		}
    687 
    688 		if ( rc == 0 ) {
    689 			rt_pass[idx]++;
    690 		} else {
    691 			int		first = tester_ignore_err( rc );
    692 			char		buf[ BUFSIZ ];
    693 
    694 			rt_fail[idx]++;
    695 			snprintf( buf, sizeof( buf ), "ldap_search_ext_s(%s)", entry );
    696 
    697 			/* if ignore.. */
    698 			if ( first ) {
    699 				/* only log if first occurrence */
    700 				if ( ( force < 2 && first > 0 ) || abs(first) == 1 ) {
    701 					tester_ldap_error( ld, buf, NULL );
    702 				}
    703 				continue;
    704 			}
    705 
    706 			/* busy needs special handling */
    707 			tester_ldap_error( ld, buf, NULL );
    708 			if ( rc == LDAP_BUSY && do_retry > 0 ) {
    709 				do_retry--;
    710 				goto retry;
    711 			}
    712 			break;
    713 		}
    714 	}
    715 }
    716 
    717 #else /* NO_THREADS */
    718 
    719 #include <stdio.h>
    720 #include <stdlib.h>
    721 
    722 int
    723 main( int argc, char **argv )
    724 {
    725 	fprintf( stderr, "%s: not available when configured --without-threads\n", argv[0] );
    726 	exit( EXIT_FAILURE );
    727 }
    728 
    729 #endif /* NO_THREADS */
    730