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

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1999-2008 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 Kurt Spanier 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
  33 #define LDAP_DEPRECATED 1
  34 #include <ldap.h>
  35 #include <lutil.h>
  36
  37 #define LOOPS   100
  38 #define RETRIES 0
  39
  40 static void
  41 do_search( char *uri, char *host, int port, char *manager, char *passwd,
  42                 char *sbase, char *filter, int maxloop, int maxretries, int delay );
  43
  44 static void
  45 usage( char *name )
  46 {
  47         fprintf( stderr,
  48                 "usage: %s "
  49                 "-H <uri> | ([-h <host>] -p <port>) "
  50                 "-D <manager> "
  51                 "-w <passwd> "
  52                 "-b <searchbase> "
  53                 "-f <searchfilter> "
  54                 "[-l <loops>] "
  55                 "[-r <maxretries>] "
  56                 "[-t <delay>]\n",
  57                         name );
  58         exit( EXIT_FAILURE );
  59 }
  60
  61 int
  62 main( int argc, char **argv )
  63 {
  64         int             i;
  65         char            *uri = NULL;
  66         char            *host = "localhost";
  67         int             port = -1;
  68         char            *manager = NULL;
  69         char            *passwd = NULL;
  70         char            *sbase = NULL;
  71         char            *filter  = NULL;
  72         int             loops = LOOPS;
  73         int             retries = RETRIES;
  74         int             delay = 0;
  75
  76         while ( (i = getopt( argc, argv, "b:D:f:H:h:l:p:w:r:t:" )) != EOF ) {
  77                 switch( i ) {
  78                 case 'H':               /* the server uri */
  79                         uri = strdup( optarg );
  80                         break;
  81
  82                 case 'h':               /* the servers host */
  83                         host = strdup( optarg );
  84                         break;
  85
  86                 case 'p':               /* the servers port */
  87                         if ( lutil_atoi( &port, optarg ) != 0 ) {
  88                                 usage( argv[0] );
  89                         }
  90                         break;
  91
  92                 case 'D':               /* the servers manager */
  93                         manager = strdup( optarg );
  94                         break;
  95
  96                 case 'w':               /* the server managers password */
  97                         passwd = strdup( optarg );
  98                         break;
  99
 100                 case 'b':               /* file with search base */
 101                         sbase = strdup( optarg );
 102                         break;
 103
 104                 case 'f':               /* the search request */
 105                         filter = strdup( optarg );
 106                         break;
 107
 108                 case 'l':               /* number of loops */
 109                         if ( lutil_atoi( &loops, optarg ) != 0 ) {
 110                                 usage( argv[0] );
 111                         }
 112                         break;
 113
 114                 case 'r':               /* number of retries */
 115                         if ( lutil_atoi( &retries, optarg ) != 0 ) {
 116                                 usage( argv[0] );
 117                         }
 118                         break;
 119
 120                 case 't':               /* delay in seconds */
 121                         if ( lutil_atoi( &delay, optarg ) != 0 ) {
 122                                 usage( argv[0] );
 123                         }
 124                         break;
 125
 126                 default:
 127                         usage( argv[0] );
 128                         break;
 129                 }
 130         }
 131
 132         if (( sbase == NULL ) || ( filter == NULL ) || ( port == -1 && uri == NULL ))
 133                 usage( argv[0] );
 134
 135         if ( *filter == '\0' ) {
 136
 137                 fprintf( stderr, "%s: invalid EMPTY search filter.\n",
 138                                 argv[0] );
 139                 exit( EXIT_FAILURE );
 140
 141         }
 142
 143         do_search( uri, host, port, manager, passwd, sbase, filter,
 144                         ( 10 * loops ), retries, delay );
 145         exit( EXIT_SUCCESS );
 146 }
 147
 148
 149 static void
 150 do_search( char *uri, char *host, int port, char *manager, char *passwd,
 151                 char *sbase, char *filter, int maxloop, int maxretries, int delay )
 152 {
 153         LDAP    *ld = NULL;
 154         int     i = 0, do_retry = maxretries;
 155         char    *attrs[] = { "cn", "sn", NULL };
 156         pid_t   pid = getpid();
 157         int     rc = LDAP_SUCCESS;
 158
 159 retry:;
 160         if ( uri ) {
 161                 ldap_initialize( &ld, uri );
 162         } else {
 163                 ld = ldap_init( host, port );
 164         }
 165         if ( ld == NULL ) {
 166                 perror( "ldap_init" );
 167                 exit( EXIT_FAILURE );
 168         }
 169
 170         {
 171                 int version = LDAP_VERSION3;
 172                 (void) ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION,
 173                         &version );
 174         }
 175
 176         if ( do_retry == maxretries ) {
 177                 fprintf( stderr, "PID=%ld - Search(%d): base=\"%s\", filter=\"%s\".\n",
 178                                 (long) pid, maxloop, sbase, filter );
 179         }
 180
 181         rc = ldap_bind_s( ld, manager, passwd, LDAP_AUTH_SIMPLE );
 182         if ( rc != LDAP_SUCCESS ) {
 183                 ldap_perror( ld, "ldap_bind" );
 184                 switch ( rc ) {
 185                 case LDAP_BUSY:
 186                 case LDAP_UNAVAILABLE:
 187                         if ( do_retry > 0 ) {
 188                                 do_retry--;
 189                                 if ( delay != 0 ) {
 190                                     sleep( delay );
 191                                 }
 192                                 goto retry;
 193                         }
 194                 /* fallthru */
 195                 default:
 196                         break;
 197                 }
 198                 exit( EXIT_FAILURE );
 199         }
 200
 201         for ( ; i < maxloop; i++ ) {
 202                 LDAPMessage *res;
 203
 204                 rc = ldap_search_s( ld, sbase, LDAP_SCOPE_SUBTREE,
 205                                 filter, attrs, 0, &res );
 206                 if ( rc != LDAP_SUCCESS ) {
 207                         ldap_perror( ld, "ldap_search" );
 208                         if ( rc == LDAP_BUSY && do_retry > 0 ) {
 209                                 do_retry--;
 210                                 goto retry;
 211                         }
 212                         if ( rc != LDAP_NO_SUCH_OBJECT ) break;
 213                         continue;
 214
 215                 }
 216
 217                 ldap_msgfree( res );
 218         }
 219
 220         fprintf( stderr, " PID=%ld - Search done (%d).\n", (long) pid, rc );
 221
 222         ldap_unbind( ld );
 223 }