ruby-ldap 0.9.18 → 0.9.19

data/test/openldap_tests/progs/slapd-addel.c

@@ -0,0 +1,435 @@
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 1999-2016 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was initially developed by Kurt Spanier for inclusion
+ * in OpenLDAP Software.
+ */
+ 
+#include "portable.h"
+
+#include <stdio.h>
+
+#include "ac/stdlib.h"
+
+#include "ac/ctype.h"
+#include "ac/param.h"
+#include "ac/socket.h"
+#include "ac/string.h"
+#include "ac/unistd.h"
+#include "ac/wait.h"
+
+#include "ldap.h"
+#include "lutil.h"
+
+#include "slapd-common.h"
+
+#define LOOPS	100
+#define RETRIES	0
+
+static char *
+get_add_entry( char *filename, LDAPMod ***mods );
+
+static void
+do_addel( char *uri, char *manager, struct berval *passwd,
+	char *dn, LDAPMod **attrs, int maxloop, int maxretries, int delay,
+	int friendly, int chaserefs );
+
+static void
+usage( char *name )
+{
+        fprintf( stderr,
+		"usage: %s "
+		"-H <uri> | ([-h <host>] -p <port>) "
+		"-D <manager> "
+		"-w <passwd> "
+		"-f <addfile> "
+		"[-i <ignore>] "
+		"[-l <loops>] "
+		"[-L <outerloops>] "
+		"[-r <maxretries>] "
+		"[-t <delay>] "
+		"[-F] "
+		"[-C]\n",
+			name );
+	exit( EXIT_FAILURE );
+}
+
+int
+main( int argc, char **argv )
+{
+	int		i;
+	char		*host = "localhost";
+	char		*uri = NULL;
+	int		port = -1;
+	char		*manager = NULL;
+	struct berval	passwd = { 0, NULL };
+	char		*filename = NULL;
+	char		*entry = NULL;
+	int		loops = LOOPS;
+	int		outerloops = 1;
+	int		retries = RETRIES;
+	int		delay = 0;
+	int		friendly = 0;
+	int		chaserefs = 0;
+	LDAPMod		**attrs = NULL;
+
+	tester_init( "slapd-addel", TESTER_ADDEL );
+
+	while ( ( i = getopt( argc, argv, "CD:Ff:H:h:i:L:l:p:r:t:w:" ) ) != EOF )
+	{
+		switch ( i ) {
+		case 'C':
+			chaserefs++;
+			break;
+
+		case 'F':
+			friendly++;
+			break;
+			
+		case 'H':		/* the server's URI */
+			uri = strdup( optarg );
+			break;
+
+		case 'h':		/* the servers host */
+			host = strdup( optarg );
+			break;
+
+		case 'i':
+			/* ignored (!) by now */
+			break;
+
+		case 'p':		/* the servers port */
+			if ( lutil_atoi( &port, optarg ) != 0 ) {
+				usage( argv[0] );
+			}
+			break;
+
+		case 'D':		/* the servers manager */
+			manager = strdup( optarg );
+			break;
+
+		case 'w':		/* the server managers password */
+			passwd.bv_val = strdup( optarg );
+			passwd.bv_len = strlen( optarg );
+			memset( optarg, '*', passwd.bv_len );
+			break;
+
+		case 'f':		/* file with entry search request */
+			filename = strdup( optarg );
+			break;
+
+		case 'l':		/* the number of loops */
+			if ( lutil_atoi( &loops, optarg ) != 0 ) {
+				usage( argv[0] );
+			}
+			break;
+
+		case 'L':		/* the number of outerloops */
+			if ( lutil_atoi( &outerloops, optarg ) != 0 ) {
+				usage( argv[0] );
+			}
+			break;
+
+		case 'r':		/* number of retries */
+			if ( lutil_atoi( &retries, optarg ) != 0 ) {
+				usage( argv[0] );
+			}
+			break;
+
+		case 't':		/* delay in seconds */
+			if ( lutil_atoi( &delay, optarg ) != 0 ) {
+				usage( argv[0] );
+			}
+			break;
+
+		default:
+			usage( argv[0] );
+			break;
+		}
+	}
+
+	if (( filename == NULL ) || ( port == -1 && uri == NULL ) ||
+				( manager == NULL ) || ( passwd.bv_val == NULL ))
+		usage( argv[0] );
+
+	entry = get_add_entry( filename, &attrs );
+	if (( entry == NULL ) || ( *entry == '\0' )) {
+
+		fprintf( stderr, "%s: invalid entry DN in file \"%s\".\n",
+				argv[0], filename );
+		exit( EXIT_FAILURE );
+
+	}
+
+	if (( attrs == NULL ) || ( *attrs == '\0' )) {
+
+		fprintf( stderr, "%s: invalid attrs in file \"%s\".\n",
+				argv[0], filename );
+		exit( EXIT_FAILURE );
+
+	}
+
+	uri = tester_uri( uri, host, port );
+
+	for ( i = 0; i < outerloops; i++ ) {
+		do_addel( uri, manager, &passwd, entry, attrs,
+				loops, retries, delay, friendly, chaserefs );
+	}
+
+	exit( EXIT_SUCCESS );
+}
+
+
+static void
+addmodifyop( LDAPMod ***pmodsp, int modop, char *attr, char *value, int vlen )
+{
+    LDAPMod		**pmods;
+    int			i, j;
+    struct berval	*bvp;
+
+    pmods = *pmodsp;
+    modop |= LDAP_MOD_BVALUES;
+
+    i = 0;
+    if ( pmods != NULL ) {
+		for ( ; pmods[ i ] != NULL; ++i ) {
+	    	if ( strcasecmp( pmods[ i ]->mod_type, attr ) == 0 &&
+		    	pmods[ i ]->mod_op == modop ) {
+				break;
+	    	}
+		}
+    }
+
+    if ( pmods == NULL || pmods[ i ] == NULL ) {
+		if (( pmods = (LDAPMod **)realloc( pmods, (i + 2) *
+			sizeof( LDAPMod * ))) == NULL ) {
+	    		tester_perror( "realloc", NULL );
+	    		exit( EXIT_FAILURE );
+		}
+		*pmodsp = pmods;
+		pmods[ i + 1 ] = NULL;
+		if (( pmods[ i ] = (LDAPMod *)calloc( 1, sizeof( LDAPMod )))
+			== NULL ) {
+	    		tester_perror( "calloc", NULL );
+	    		exit( EXIT_FAILURE );
+		}
+		pmods[ i ]->mod_op = modop;
+		if (( pmods[ i ]->mod_type = strdup( attr )) == NULL ) {
+	    	tester_perror( "strdup", NULL );
+	    	exit( EXIT_FAILURE );
+		}
+    }
+
+    if ( value != NULL ) {
+		j = 0;
+		if ( pmods[ i ]->mod_bvalues != NULL ) {
+	    	for ( ; pmods[ i ]->mod_bvalues[ j ] != NULL; ++j ) {
+				;
+	    	}
+		}
+		if (( pmods[ i ]->mod_bvalues =
+			(struct berval **)ber_memrealloc( pmods[ i ]->mod_bvalues,
+			(j + 2) * sizeof( struct berval * ))) == NULL ) {
+	    		tester_perror( "ber_memrealloc", NULL );
+	    		exit( EXIT_FAILURE );
+		}
+		pmods[ i ]->mod_bvalues[ j + 1 ] = NULL;
+		if (( bvp = (struct berval *)ber_memalloc( sizeof( struct berval )))
+			== NULL ) {
+	    		tester_perror( "ber_memalloc", NULL );
+	    		exit( EXIT_FAILURE );
+		}
+		pmods[ i ]->mod_bvalues[ j ] = bvp;
+
+	    bvp->bv_len = vlen;
+	    if (( bvp->bv_val = (char *)malloc( vlen + 1 )) == NULL ) {
+			tester_perror( "malloc", NULL );
+			exit( EXIT_FAILURE );
+	    }
+	    AC_MEMCPY( bvp->bv_val, value, vlen );
+	    bvp->bv_val[ vlen ] = '\0';
+    }
+}
+
+
+static char *
+get_add_entry( char *filename, LDAPMod ***mods )
+{
+	FILE    *fp;
+	char    *entry = NULL;
+
+	if ( (fp = fopen( filename, "r" )) != NULL ) {
+		char  line[BUFSIZ];
+
+		if ( fgets( line, BUFSIZ, fp )) {
+			char *nl;
+
+			if (( nl = strchr( line, '\r' )) || ( nl = strchr( line, '\n' )))
+				*nl = '\0';
+			nl = line;
+			if ( !strncasecmp( nl, "dn: ", 4 ))
+				nl += 4;
+			entry = strdup( nl );
+
+		}
+
+		while ( fgets( line, BUFSIZ, fp )) {
+			char	*nl;
+			char	*value;
+
+			if (( nl = strchr( line, '\r' )) || ( nl = strchr( line, '\n' )))
+				*nl = '\0';
+
+			if ( *line == '\0' ) break;
+			if ( !( value = strchr( line, ':' ))) break;
+
+			*value++ = '\0'; 
+			while ( *value && isspace( (unsigned char) *value ))
+				value++;
+
+			addmodifyop( mods, LDAP_MOD_ADD, line, value, strlen( value ));
+
+		}
+		fclose( fp );
+	}
+
+	return( entry );
+}
+
+
+static void
+do_addel(
+	char *uri,
+	char *manager,
+	struct berval *passwd,
+	char *entry,
+	LDAPMod **attrs,
+	int maxloop,
+	int maxretries,
+	int delay,
+	int friendly,
+	int chaserefs )
+{
+	LDAP	*ld = NULL;
+	int  	i = 0, do_retry = maxretries;
+	int	rc = LDAP_SUCCESS;
+	int	version = LDAP_VERSION3;
+
+retry:;
+	ldap_initialize( &ld, uri );
+	if ( ld == NULL ) {
+		tester_perror( "ldap_initialize", NULL );
+		exit( EXIT_FAILURE );
+	}
+
+	(void) ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION, &version );
+	(void) ldap_set_option( ld, LDAP_OPT_REFERRALS,
+		chaserefs ? LDAP_OPT_ON : LDAP_OPT_OFF );
+
+	if ( do_retry == maxretries ) {
+		fprintf( stderr, "PID=%ld - Add/Delete(%d): entry=\"%s\".\n",
+			(long) pid, maxloop, entry );
+	}
+
+	rc = ldap_sasl_bind_s( ld, manager, LDAP_SASL_SIMPLE, passwd, NULL, NULL, NULL );
+	if ( rc != LDAP_SUCCESS ) {
+		tester_ldap_error( ld, "ldap_sasl_bind_s", NULL );
+		switch ( rc ) {
+		case LDAP_BUSY:
+		case LDAP_UNAVAILABLE:
+			if ( do_retry > 0 ) {
+				do_retry--;
+				if ( delay != 0 ) {
+				    sleep( delay );
+				}
+				goto retry;
+			}
+		/* fallthru */
+		default:
+			break;
+		}
+		exit( EXIT_FAILURE );
+	}
+
+	for ( ; i < maxloop; i++ ) {
+
+		/* add the entry */
+		rc = ldap_add_ext_s( ld, entry, attrs, NULL, NULL );
+		if ( rc != LDAP_SUCCESS ) {
+			tester_ldap_error( ld, "ldap_add_ext_s", NULL );
+			switch ( rc ) {
+			case LDAP_ALREADY_EXISTS:
+				/* NOTE: this likely means
+				 * the delete failed
+				 * during the previous round... */
+				if ( !friendly ) {
+					goto done;
+				}
+				break;
+
+			case LDAP_BUSY:
+			case LDAP_UNAVAILABLE:
+				if ( do_retry > 0 ) {
+					do_retry--;
+					goto retry;
+				}
+				/* fall thru */
+
+			default:
+				goto done;
+			}
+		}
+
+#if 0
+		/* wait a second for the add to really complete */
+		/* This masks some race conditions though. */
+		sleep( 1 );
+#endif
+
+		/* now delete the entry again */
+		rc = ldap_delete_ext_s( ld, entry, NULL, NULL );
+		if ( rc != LDAP_SUCCESS ) {
+			tester_ldap_error( ld, "ldap_delete_ext_s", NULL );
+			switch ( rc ) {
+			case LDAP_NO_SUCH_OBJECT:
+				/* NOTE: this likely means
+				 * the add failed
+				 * during the previous round... */
+				if ( !friendly ) {
+					goto done;
+				}
+				break;
+
+			case LDAP_BUSY:
+			case LDAP_UNAVAILABLE:
+				if ( do_retry > 0 ) {
+					do_retry--;
+					goto retry;
+				}
+				/* fall thru */
+
+			default:
+				goto done;
+			}
+		}
+	}
+
+done:;
+	fprintf( stderr, "  PID=%ld - Add/Delete done (%d).\n", (long) pid, rc );
+
+	ldap_unbind_ext( ld, NULL, NULL );
+}
+
+

data/test/openldap_tests/progs/slapd-auth.c

@@ -0,0 +1,335 @@
+/* $OpenLDAP$ */
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2006-2016 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
+ */
+/* ACKNOWLEDGEMENTS:
+ * This work was initially developed by Howard Chu for inclusion
+ * in OpenLDAP Software.
+ */
+
+#include "portable.h"
+
+#include <stdio.h>
+
+#include <ac/stdlib.h>
+
+#include <ac/ctype.h>
+#include <ac/param.h>
+#include <ac/socket.h>
+#include <ac/string.h>
+#include <ac/unistd.h>
+#include <ac/wait.h>
+#include <ac/time.h>
+#include <ac/signal.h>
+
+#include <ldap.h>
+#include <ldap_pvt_thread.h>
+#include <lutil.h>
+
+static int
+do_time( );
+
+/* This program is a simplified version of SLAMD's WeightedAuthRate jobclass.
+ * It doesn't offer as much configurability, but it's a good starting point.
+ * When run without the -R option it will behave as a Standard AuthRate job.
+ * Eventually this will grow into a set of C-based load generators for the SLAMD
+ * framework. This code is anywhere from 2 to 10 times more efficient than the
+ * original Java code, allowing servers to be fully loaded without requiring
+ * anywhere near as much load-generation hardware.
+ */
+static void
+usage( char *name )
+{
+	fprintf( stderr, "usage: %s -H <uri> -b <baseDN> -w <passwd> -t <seconds> -r lo:hi\n\t"
+		"[-R %:lo:hi] [-f <filter-template>] [-n <threads>] [-D <bindDN>] [-i <seconds>]\n",
+			name );
+	exit( EXIT_FAILURE );
+}
+
+static char *filter = "(uid=user.%d)";
+
+static char hname[1024];
+static char *uri = "ldap:///";
+static char	*base;
+static char	*pass;
+static char *binder;
+
+static int tdur, r1per, r1lo, r1hi, r2per, r2lo, r2hi;
+static int threads = 1;
+
+static int interval = 30;
+
+static volatile int *r1binds, *r2binds;
+static int *r1old, *r2old;
+static volatile int finish;
+
+int
+main( int argc, char **argv )
+{
+	int		i;
+
+	while ( (i = getopt( argc, argv, "b:D:H:w:f:n:i:t:r:R:" )) != EOF ) {
+		switch( i ) {
+			case 'b':		/* base DN of a tree of user DNs */
+				base = strdup( optarg );
+				break;
+
+			case 'D':
+				binder = strdup( optarg );
+				break;
+
+			case 'H':		/* the server uri */
+				uri = strdup( optarg );
+				break;
+
+			case 'w':
+				pass = strdup( optarg );
+				break;
+
+			case 't':		/* the duration to run */
+				if ( lutil_atoi( &tdur, optarg ) != 0 ) {
+					usage( argv[0] );
+				}
+				break;
+
+			case 'i':		/* the time interval */
+				if ( lutil_atoi( &interval, optarg ) != 0 ) {
+					usage( argv[0] );
+				}
+				break;
+
+			case 'r':		/* the uid range */
+				if ( sscanf(optarg, "%d:%d", &r1lo, &r1hi) != 2 ) {
+					usage( argv[0] );
+				}
+				break;
+
+			case 'R':		/* percentage:2nd uid range */
+				if ( sscanf(optarg, "%d:%d:%d", &r2per, &r2lo, &r2hi) != 3 ) {
+					usage( argv[0] );
+				}
+				break;
+
+			case 'f':
+				filter = optarg;
+				break;
+
+			case 'n':
+				if ( lutil_atoi( &threads, optarg ) != 0 || threads < 1 ) {
+					usage( argv[0] );
+				}
+				break;
+				
+			default:
+				usage( argv[0] );
+				break;
+		}
+	}
+
+	if ( tdur == 0 || r1hi <= r1lo )
+		usage( argv[0] );
+
+	r1per = 100 - r2per;
+	if ( r1per < 1 )
+		usage( argv[0] );
+
+	r1binds = calloc( threads*4, sizeof( int ));
+	r2binds = r1binds + threads;
+	r1old = (int *)r2binds + threads;
+	r2old = r1old + threads;
+
+	do_time( );
+
+	exit( EXIT_SUCCESS );
+}
+
+static void *
+my_task( void *my_num )
+{
+	LDAP	*ld = NULL, *sld = NULL;
+	ber_int_t msgid;
+	LDAPMessage *res, *msg;
+	char *attrs[] = { "1.1", NULL };
+	int     rc = LDAP_SUCCESS;
+	int		tid = *(int *)my_num;
+
+	ldap_initialize( &ld, uri );
+	if ( ld == NULL ) {
+		perror( "ldap_initialize" );
+		return NULL;
+	}
+
+	{
+		int version = LDAP_VERSION3;
+		(void) ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION,
+			&version ); 
+	}
+	(void) ldap_set_option( ld, LDAP_OPT_REFERRALS, LDAP_OPT_OFF );
+
+	ldap_initialize( &sld, uri );
+	if ( sld == NULL ) {
+		perror( "ldap_initialize" );
+		return NULL;
+	}
+
+	{
+		int version = LDAP_VERSION3;
+		(void) ldap_set_option( sld, LDAP_OPT_PROTOCOL_VERSION,
+			&version ); 
+	}
+	(void) ldap_set_option( sld, LDAP_OPT_REFERRALS, LDAP_OPT_OFF );
+	if ( binder ) {
+		rc = ldap_bind_s( sld, binder, pass, LDAP_AUTH_SIMPLE );
+		if ( rc != LDAP_SUCCESS ) {
+			ldap_perror( sld, "ldap_bind" );
+		}
+	}
+
+	r1binds[tid] = 0;
+
+	for (;;) {
+		char dn[BUFSIZ], *ptr, fstr[256];
+		int j, isr1;
+		
+		if ( finish )
+			break;
+
+		j = rand() % 100;
+		if ( j < r1per ) {
+			j = rand() % r1hi;
+			isr1 = 1;
+		} else {
+			j = rand() % (r2hi - r2lo + 1 );
+			j += r2lo;
+			isr1 = 0;
+		}
+		sprintf(fstr, filter, j);
+
+		rc = ldap_search_ext( sld, base, LDAP_SCOPE_SUB,
+			fstr, attrs, 0, NULL, NULL, 0, 0, &msgid );
+		if ( rc != LDAP_SUCCESS ) {
+			ldap_perror( sld, "ldap_search_ex" );
+			return NULL;
+		}
+
+		while (( rc=ldap_result( sld, LDAP_RES_ANY, LDAP_MSG_ONE, NULL, &res )) >0){
+			BerElement *ber;
+			struct berval bv;
+			char *ptr;
+			int done = 0;
+
+			for (msg = ldap_first_message( sld, res ); msg;
+				msg = ldap_next_message( sld, msg )) {
+				switch ( ldap_msgtype( msg )) {
+				case LDAP_RES_SEARCH_ENTRY:
+					rc = ldap_get_dn_ber( sld, msg, &ber, &bv );
+					strcpy(dn, bv.bv_val );
+					ber_free( ber, 0 );
+					break;
+				case LDAP_RES_SEARCH_RESULT:
+					done = 1;
+					break;
+				}
+				if ( done )
+					break;
+			}
+			ldap_msgfree( res );
+			if ( done ) break;
+		}
+
+		rc = ldap_bind_s( ld, dn, pass, LDAP_AUTH_SIMPLE );
+		if ( rc != LDAP_SUCCESS ) {
+			ldap_perror( ld, "ldap_bind" );
+		}
+		if ( isr1 )
+			r1binds[tid]++;
+		else
+			r2binds[tid]++;
+	}
+
+	ldap_unbind( sld );
+	ldap_unbind( ld );
+
+	return NULL;
+}
+
+static int
+do_time( )
+{
+	struct timeval tv;
+	time_t now, prevt, start;
+
+	int r1new, r2new;
+	int dt, dr1, dr2, rr1, rr2;
+	int dr10, dr20;
+	int i;
+
+	gethostname(hname, sizeof(hname));
+	printf("%s(tid)\tdeltaT\tauth1\tauth2\trate1\trate2\tRate1+2\n", hname);
+	srand(getpid());
+
+	prevt = start = time(0L);
+
+	for ( i = 0; i<threads; i++ ) {
+		ldap_pvt_thread_t thr;
+		r1binds[i] = i;
+		ldap_pvt_thread_create( &thr, 1, my_task, (void *)&r1binds[i] );
+	}
+
+	for (;;) {
+		tv.tv_sec = interval;
+		tv.tv_usec = 0;
+
+		select(0, NULL, NULL, NULL, &tv);
+
+		now = time(0L);
+
+		dt = now - prevt;
+		prevt = now;
+
+		dr10 = 0;
+		dr20 = 0;
+
+		for ( i = 0; i < threads; i++ ) {
+			r1new = r1binds[i];
+			r2new = r2binds[i];
+
+			dr1 = r1new - r1old[i];
+			dr2 = r2new - r2old[i];
+			rr1 = dr1 / dt;
+			rr2 = dr2 / dt;
+
+			printf("%s(%d)\t%d\t%d\t%d\t%d\t%d\t%d\n",
+				hname, i, dt, dr1, dr2, rr1, rr2, rr1 + rr2);
+
+			dr10 += dr1;
+			dr20 += dr2;
+
+			r1old[i] = r1new;
+			r2old[i] = r2new;
+		}
+		if ( i > 1 ) {
+			rr1 = dr10 / dt;
+			rr2 = dr20 / dt;
+			
+			printf("%s(sum)\t%d\t%d\t%d\t%d\t%d\t%d\n",
+				hname, 0, dr10, dr20, rr1, rr2, rr1 + rr2);
+		}
+
+		if ( now - start >= tdur ) {
+			finish = 1;
+			break;
+		}
+	}
+	return 0;
+}