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

   1 #include "portable.h"
   2
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5
   6 #include <ac/string.h>
   7 #include <ac/ctype.h>
   8 #include <ac/socket.h>
   9 #include <ac/unistd.h>
  10 #include <ac/wait.h>
  11
  12 #include <sys/param.h>
  13
  14 #include "lber.h"
  15 #include "ldap.h"
  16
  17 #define LOOPS   100
  18
  19 static char *
  20 get_add_entry( char *filename, LDAPMod ***mods );
  21
  22 static void
  23 do_addel( char *host, int port, char *manager, char *passwd,
  24         char *dn, LDAPMod **attrs, int maxloop );
  25
  26 static void
  27 usage( char *name )
  28 {
  29         fprintf( stderr, "usage: %s [-h <host>] -p port -D <managerDN> -w <passwd> -f <addfile> [-l <loops>]\n",
  30                         name );
  31         exit( 1 );
  32 }
  33
  34 int
  35 main( int argc, char **argv )
  36 {
  37         int             i, j;
  38         char        *host = "localhost";
  39         int                     port = -1;
  40         char            *manager = NULL;
  41         char            *passwd = NULL;
  42         char            *filename = NULL;
  43         char            *entry = NULL;
  44         int                     loops = LOOPS;
  45         LDAPMod     **attrs = NULL;
  46
  47         while ( (i = getopt( argc, argv, "h:p:D:w:f:l:" )) != EOF ) {
  48                 switch( i ) {
  49                         case 'h':               /* the servers host */
  50                                 host = strdup( optarg );
  51                         break;
  52
  53                         case 'p':               /* the servers port */
  54                                 port = atoi( optarg );
  55                                 break;
  56
  57                         case 'D':               /* the servers manager */
  58                                 manager = strdup( optarg );
  59                         break;
  60
  61                         case 'w':               /* the server managers password */
  62                                 passwd = strdup( optarg );
  63                         break;
  64
  65                         case 'f':               /* file with entry search request */
  66                                 filename = strdup( optarg );
  67                                 break;
  68
  69                         case 'l':               /* the number of loops */
  70                                 loops = atoi( optarg );
  71                                 break;
  72
  73                         default:
  74                                 usage( argv[0] );
  75                                 break;
  76                 }
  77         }
  78
  79         if (( filename == NULL ) || ( port == -1 ) ||
  80                                 ( manager == NULL ) || ( passwd == NULL ))
  81                 usage( argv[0] );
  82
  83         entry = get_add_entry( filename, &attrs );
  84         if (( entry == NULL ) || ( *entry == '\0' )) {
  85
  86                 fprintf( stderr, "%s: invalid entry DN in file \"%s\".\n",
  87                                 argv[0], filename );
  88                 exit( 1 );
  89
  90         }
  91
  92         if (( attrs == NULL ) || ( *attrs == '\0' )) {
  93
  94                 fprintf( stderr, "%s: invalid attrs in file \"%s\".\n",
  95                                 argv[0], filename );
  96                 exit( 1 );
  97
  98         }
  99
 100         do_addel( host, port, manager, passwd, entry, attrs, loops );
 101
 102         exit( 0 );
 103 }
 104
 105
 106 #define safe_realloc( ptr, size )   ( ptr == NULL ? malloc( size ) : \
 107                                 realloc( ptr, size ))
 108
 109
 110 static void
 111 addmodifyop( LDAPMod ***pmodsp, int modop, char *attr, char *value, int vlen )
 112 {
 113     LDAPMod             **pmods;
 114     int                 i, j;
 115     struct berval       *bvp;
 116
 117     pmods = *pmodsp;
 118     modop |= LDAP_MOD_BVALUES;
 119
 120     i = 0;
 121     if ( pmods != NULL ) {
 122                 for ( ; pmods[ i ] != NULL; ++i ) {
 123                 if ( strcasecmp( pmods[ i ]->mod_type, attr ) == 0 &&
 124                         pmods[ i ]->mod_op == modop ) {
 125                                 break;
 126                 }
 127                 }
 128     }
 129
 130     if ( pmods == NULL || pmods[ i ] == NULL ) {
 131                 if (( pmods = (LDAPMod **)safe_realloc( pmods, (i + 2) *
 132                         sizeof( LDAPMod * ))) == NULL ) {
 133                         perror( "safe_realloc" );
 134                         exit( 1 );
 135                 }
 136                 *pmodsp = pmods;
 137                 pmods[ i + 1 ] = NULL;
 138                 if (( pmods[ i ] = (LDAPMod *)calloc( 1, sizeof( LDAPMod )))
 139                         == NULL ) {
 140                         perror( "calloc" );
 141                         exit( 1 );
 142                 }
 143                 pmods[ i ]->mod_op = modop;
 144                 if (( pmods[ i ]->mod_type = strdup( attr )) == NULL ) {
 145                 perror( "strdup" );
 146                 exit( 1 );
 147                 }
 148     }
 149
 150     if ( value != NULL ) {
 151                 j = 0;
 152                 if ( pmods[ i ]->mod_bvalues != NULL ) {
 153                 for ( ; pmods[ i ]->mod_bvalues[ j ] != NULL; ++j ) {
 154                                 ;
 155                 }
 156                 }
 157                 if (( pmods[ i ]->mod_bvalues =
 158                         (struct berval **)safe_realloc( pmods[ i ]->mod_bvalues,
 159                         (j + 2) * sizeof( struct berval * ))) == NULL ) {
 160                         perror( "safe_realloc" );
 161                         exit( 1 );
 162                 }
 163                 pmods[ i ]->mod_bvalues[ j + 1 ] = NULL;
 164                 if (( bvp = (struct berval *)malloc( sizeof( struct berval )))
 165                         == NULL ) {
 166                         perror( "malloc" );
 167                         exit( 1 );
 168                 }
 169                 pmods[ i ]->mod_bvalues[ j ] = bvp;
 170
 171             bvp->bv_len = vlen;
 172             if (( bvp->bv_val = (char *)malloc( vlen + 1 )) == NULL ) {
 173                         perror( "malloc" );
 174                         exit( 1 );
 175             }
 176             SAFEMEMCPY( bvp->bv_val, value, vlen );
 177             bvp->bv_val[ vlen ] = '\0';
 178     }
 179 }
 180
 181
 182 static char *
 183 get_add_entry( char *filename, LDAPMod ***mods )
 184 {
 185         FILE    *fp;
 186         char    *entry = NULL;
 187
 188         if ( fp = fopen( filename, "r" )) {
 189                 char  line[BUFSIZ];
 190
 191                 if ( fgets( line, BUFSIZ, fp )) {
 192                         char *nl;
 193
 194                         if (( nl = strchr( line, '\r' )) || ( nl = strchr( line, '\n' )))
 195                                 *nl = '\0';
 196                         entry = strdup( line );
 197
 198                 }
 199
 200                 while ( fgets( line, BUFSIZ, fp )) {
 201                         char    *nl;
 202                         char    *value;
 203
 204                         if (( nl = strchr( line, '\r' )) || ( nl = strchr( line, '\n' )))
 205                                 *nl = '\0';
 206
 207                         if ( *line == '\0' ) break;
 208                         if ( !( value = strchr( line, ':' ))) break;
 209
 210                         *value++ = '\0';
 211                         while ( *value && isspace( (unsigned char) *value ))
 212                                 value++;
 213
 214                         addmodifyop( mods, LDAP_MOD_ADD, line, value, strlen( value ));
 215
 216                 }
 217                 fclose( fp );
 218         }
 219
 220         return( entry );
 221 }
 222
 223
 224 static void
 225 do_addel(
 226         char *host,
 227         int port,
 228         char *manager,
 229         char *passwd,
 230         char *entry,
 231         LDAPMod **attrs,
 232         int maxloop
 233 )
 234 {
 235         LDAP    *ld;
 236         int     i;
 237         pid_t   pid = getpid();
 238
 239         if (( ld = ldap_init( host, port )) == NULL ) {
 240                 perror( "ldap_init" );
 241                 exit( 1 );
 242         }
 243
 244         if ( ldap_bind_s( ld, manager, passwd, LDAP_AUTH_SIMPLE )
 245                                 != LDAP_SUCCESS ) {
 246                 ldap_perror( ld, "ldap_bind" );
 247                  exit( 1 );
 248         }
 249
 250
 251         fprintf( stderr, "PID=%ld - Add/Delete(%d): entry=\"%s\".\n",
 252                                         (long) pid, maxloop, entry );
 253
 254         for ( i = 0; i < maxloop; i++ ) {
 255
 256                 /* add the entry */
 257                 if ( ldap_add_s( ld, entry, attrs ) != LDAP_SUCCESS ) {
 258
 259                         ldap_perror( ld, "ldap_add" );
 260                         break;
 261
 262                 }
 263
 264                 /* wait a second for the add to really complete */
 265                 sleep( 1 );
 266
 267                 /* now delete the entry again */
 268                 if ( ldap_delete_s( ld, entry ) != LDAP_SUCCESS ) {
 269
 270                         ldap_perror( ld, "ldap_delete" );
 271                         break;
 272
 273                 }
 274
 275         }
 276
 277         fprintf( stderr, " PID=%ld - Add/Delete done.\n", (long) pid );
 278
 279         ldap_unbind( ld );
 280 }
 281
 282