git.sur5r.net Git - openldap/blob - tests/progs/slapd-auth.c

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 2006-2017 The OpenLDAP Foundation.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted only as authorized by the OpenLDAP
   9  * Public License.
  10  *
  11  * A copy of this license is available in file LICENSE in the
  12  * top-level directory of the distribution or, alternatively, at
  13  * <http://www.OpenLDAP.org/license.html>.
  14  */
  15 /* ACKNOWLEDGEMENTS:
  16  * This work was initially developed by Howard Chu for inclusion
  17  * in OpenLDAP Software.
  18  */
  19
  20 #include "portable.h"
  21
  22 #include <stdio.h>
  23
  24 #include <ac/stdlib.h>
  25
  26 #include <ac/ctype.h>
  27 #include <ac/param.h>
  28 #include <ac/socket.h>
  29 #include <ac/string.h>
  30 #include <ac/unistd.h>
  31 #include <ac/wait.h>
  32 #include <ac/time.h>
  33 #include <ac/signal.h>
  34
  35 #include <ldap.h>
  36 #include <ldap_pvt_thread.h>
  37 #include <lutil.h>
  38
  39 static int
  40 do_time( );
  41
  42 /* This program is a simplified version of SLAMD's WeightedAuthRate jobclass.
  43  * It doesn't offer as much configurability, but it's a good starting point.
  44  * When run without the -R option it will behave as a Standard AuthRate job.
  45  * Eventually this will grow into a set of C-based load generators for the SLAMD
  46  * framework. This code is anywhere from 2 to 10 times more efficient than the
  47  * original Java code, allowing servers to be fully loaded without requiring
  48  * anywhere near as much load-generation hardware.
  49  */
  50 static void
  51 usage( char *name )
  52 {
  53         fprintf( stderr, "usage: %s -H <uri> -b <baseDN> -w <passwd> -t <seconds> -r lo:hi\n\t"
  54                 "[-R %:lo:hi] [-f <filter-template>] [-n <threads>] [-D <bindDN>] [-i <seconds>]\n",
  55                         name );
  56         exit( EXIT_FAILURE );
  57 }
  58
  59 static char *filter = "(uid=user.%d)";
  60
  61 static char hname[1024];
  62 static char *uri = "ldap:///";
  63 static char     *base;
  64 static char     *pass;
  65 static char *binder;
  66
  67 static int tdur, r1per, r1lo, r1hi, r2per, r2lo, r2hi;
  68 static int threads = 1;
  69
  70 static int interval = 30;
  71
  72 static volatile int *r1binds, *r2binds;
  73 static int *r1old, *r2old;
  74 static volatile int finish;
  75
  76 int
  77 main( int argc, char **argv )
  78 {
  79         int             i;
  80
  81         while ( (i = getopt( argc, argv, "b:D:H:w:f:n:i:t:r:R:" )) != EOF ) {
  82                 switch( i ) {
  83                         case 'b':               /* base DN of a tree of user DNs */
  84                                 base = strdup( optarg );
  85                                 break;
  86
  87                         case 'D':
  88                                 binder = strdup( optarg );
  89                                 break;
  90
  91                         case 'H':               /* the server uri */
  92                                 uri = strdup( optarg );
  93                                 break;
  94
  95                         case 'w':
  96                                 pass = strdup( optarg );
  97                                 break;
  98
  99                         case 't':               /* the duration to run */
 100                                 if ( lutil_atoi( &tdur, optarg ) != 0 ) {
 101                                         usage( argv[0] );
 102                                 }
 103                                 break;
 104
 105                         case 'i':               /* the time interval */
 106                                 if ( lutil_atoi( &interval, optarg ) != 0 ) {
 107                                         usage( argv[0] );
 108                                 }
 109                                 break;
 110
 111                         case 'r':               /* the uid range */
 112                                 if ( sscanf(optarg, "%d:%d", &r1lo, &r1hi) != 2 ) {
 113                                         usage( argv[0] );
 114                                 }
 115                                 break;
 116
 117                         case 'R':               /* percentage:2nd uid range */
 118                                 if ( sscanf(optarg, "%d:%d:%d", &r2per, &r2lo, &r2hi) != 3 ) {
 119                                         usage( argv[0] );
 120                                 }
 121                                 break;
 122
 123                         case 'f':
 124                                 filter = optarg;
 125                                 break;
 126
 127                         case 'n':
 128                                 if ( lutil_atoi( &threads, optarg ) != 0 || threads < 1 ) {
 129                                         usage( argv[0] );
 130                                 }
 131                                 break;
 132
 133                         default:
 134                                 usage( argv[0] );
 135                                 break;
 136                 }
 137         }
 138
 139         if ( tdur == 0 || r1hi <= r1lo )
 140                 usage( argv[0] );
 141
 142         r1per = 100 - r2per;
 143         if ( r1per < 1 )
 144                 usage( argv[0] );
 145
 146         r1binds = calloc( threads*4, sizeof( int ));
 147         r2binds = r1binds + threads;
 148         r1old = (int *)r2binds + threads;
 149         r2old = r1old + threads;
 150
 151         do_time( );
 152
 153         exit( EXIT_SUCCESS );
 154 }
 155
 156 static void *
 157 my_task( void *my_num )
 158 {
 159         LDAP    *ld = NULL, *sld = NULL;
 160         ber_int_t msgid;
 161         LDAPMessage *res, *msg;
 162         char *attrs[] = { "1.1", NULL };
 163         int     rc = LDAP_SUCCESS;
 164         int             tid = *(int *)my_num;
 165
 166         ldap_initialize( &ld, uri );
 167         if ( ld == NULL ) {
 168                 perror( "ldap_initialize" );
 169                 return NULL;
 170         }
 171
 172         {
 173                 int version = LDAP_VERSION3;
 174                 (void) ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION,
 175                         &version );
 176         }
 177         (void) ldap_set_option( ld, LDAP_OPT_REFERRALS, LDAP_OPT_OFF );
 178
 179         ldap_initialize( &sld, uri );
 180         if ( sld == NULL ) {
 181                 perror( "ldap_initialize" );
 182                 return NULL;
 183         }
 184
 185         {
 186                 int version = LDAP_VERSION3;
 187                 (void) ldap_set_option( sld, LDAP_OPT_PROTOCOL_VERSION,
 188                         &version );
 189         }
 190         (void) ldap_set_option( sld, LDAP_OPT_REFERRALS, LDAP_OPT_OFF );
 191         if ( binder ) {
 192                 rc = ldap_bind_s( sld, binder, pass, LDAP_AUTH_SIMPLE );
 193                 if ( rc != LDAP_SUCCESS ) {
 194                         ldap_perror( sld, "ldap_bind" );
 195                 }
 196         }
 197
 198         r1binds[tid] = 0;
 199
 200         for (;;) {
 201                 char dn[BUFSIZ], *ptr, fstr[256];
 202                 int j, isr1;
 203
 204                 if ( finish )
 205                         break;
 206
 207                 j = rand() % 100;
 208                 if ( j < r1per ) {
 209                         j = rand() % r1hi;
 210                         isr1 = 1;
 211                 } else {
 212                         j = rand() % (r2hi - r2lo + 1 );
 213                         j += r2lo;
 214                         isr1 = 0;
 215                 }
 216                 sprintf(fstr, filter, j);
 217
 218                 rc = ldap_search_ext( sld, base, LDAP_SCOPE_SUB,
 219                         fstr, attrs, 0, NULL, NULL, 0, 0, &msgid );
 220                 if ( rc != LDAP_SUCCESS ) {
 221                         ldap_perror( sld, "ldap_search_ex" );
 222                         return NULL;
 223                 }
 224
 225                 while (( rc=ldap_result( sld, LDAP_RES_ANY, LDAP_MSG_ONE, NULL, &res )) >0){
 226                         BerElement *ber;
 227                         struct berval bv;
 228                         char *ptr;
 229                         int done = 0;
 230
 231                         for (msg = ldap_first_message( sld, res ); msg;
 232                                 msg = ldap_next_message( sld, msg )) {
 233                                 switch ( ldap_msgtype( msg )) {
 234                                 case LDAP_RES_SEARCH_ENTRY:
 235                                         rc = ldap_get_dn_ber( sld, msg, &ber, &bv );
 236                                         strcpy(dn, bv.bv_val );
 237                                         ber_free( ber, 0 );
 238                                         break;
 239                                 case LDAP_RES_SEARCH_RESULT:
 240                                         done = 1;
 241                                         break;
 242                                 }
 243                                 if ( done )
 244                                         break;
 245                         }
 246                         ldap_msgfree( res );
 247                         if ( done ) break;
 248                 }
 249
 250                 rc = ldap_bind_s( ld, dn, pass, LDAP_AUTH_SIMPLE );
 251                 if ( rc != LDAP_SUCCESS ) {
 252                         ldap_perror( ld, "ldap_bind" );
 253                 }
 254                 if ( isr1 )
 255                         r1binds[tid]++;
 256                 else
 257                         r2binds[tid]++;
 258         }
 259
 260         ldap_unbind( sld );
 261         ldap_unbind( ld );
 262
 263         return NULL;
 264 }
 265
 266 static int
 267 do_time( )
 268 {
 269         struct timeval tv;
 270         time_t now, prevt, start;
 271
 272         int r1new, r2new;
 273         int dt, dr1, dr2, rr1, rr2;
 274         int dr10, dr20;
 275         int i;
 276
 277         gethostname(hname, sizeof(hname));
 278         printf("%s(tid)\tdeltaT\tauth1\tauth2\trate1\trate2\tRate1+2\n", hname);
 279         srand(getpid());
 280
 281         prevt = start = time(0L);
 282
 283         for ( i = 0; i<threads; i++ ) {
 284                 ldap_pvt_thread_t thr;
 285                 r1binds[i] = i;
 286                 ldap_pvt_thread_create( &thr, 1, my_task, (void *)&r1binds[i] );
 287         }
 288
 289         for (;;) {
 290                 tv.tv_sec = interval;
 291                 tv.tv_usec = 0;
 292
 293                 select(0, NULL, NULL, NULL, &tv);
 294
 295                 now = time(0L);
 296
 297                 dt = now - prevt;
 298                 prevt = now;
 299
 300                 dr10 = 0;
 301                 dr20 = 0;
 302
 303                 for ( i = 0; i < threads; i++ ) {
 304                         r1new = r1binds[i];
 305                         r2new = r2binds[i];
 306
 307                         dr1 = r1new - r1old[i];
 308                         dr2 = r2new - r2old[i];
 309                         rr1 = dr1 / dt;
 310                         rr2 = dr2 / dt;
 311
 312                         printf("%s(%d)\t%d\t%d\t%d\t%d\t%d\t%d\n",
 313                                 hname, i, dt, dr1, dr2, rr1, rr2, rr1 + rr2);
 314
 315                         dr10 += dr1;
 316                         dr20 += dr2;
 317
 318                         r1old[i] = r1new;
 319                         r2old[i] = r2new;
 320                 }
 321                 if ( i > 1 ) {
 322                         rr1 = dr10 / dt;
 323                         rr2 = dr20 / dt;
 324
 325                         printf("%s(sum)\t%d\t%d\t%d\t%d\t%d\t%d\n",
 326                                 hname, 0, dr10, dr20, rr1, rr2, rr1 + rr2);
 327                 }
 328
 329                 if ( now - start >= tdur ) {
 330                         finish = 1;
 331                         break;
 332                 }
 333         }
 334         return 0;
 335 }