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

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1999-2014 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 #include "ac/unistd.h"
  26 #include "ac/string.h"
  27 #include "ac/errno.h"
  28
  29 #include "ldap.h"
  30
  31 #include "ldap_pvt.h"
  32 #include "slapd-common.h"
  33
  34 /* global vars */
  35 pid_t pid;
  36
  37 /* static vars */
  38 static char progname[ BUFSIZ ];
  39 tester_t progtype;
  40
  41 /*
  42  * ignore_count[] is indexed by result code:
  43  * negative for OpenLDAP client-side errors, positive for protocol codes.
  44  */
  45 #define TESTER_CLIENT_FIRST     LDAP_REFERRAL_LIMIT_EXCEEDED /* negative */
  46 #define TESTER_SERVER_LAST      LDAP_OTHER
  47 static int ignore_base  [ -TESTER_CLIENT_FIRST + TESTER_SERVER_LAST + 1 ];
  48 #define    ignore_count (ignore_base - TESTER_CLIENT_FIRST)
  49
  50 static const struct {
  51         const char *name;
  52         int     err;
  53 } ignore_str2err[] = {
  54         { "OPERATIONS_ERROR",           LDAP_OPERATIONS_ERROR },
  55         { "PROTOCOL_ERROR",             LDAP_PROTOCOL_ERROR },
  56         { "TIMELIMIT_EXCEEDED",         LDAP_TIMELIMIT_EXCEEDED },
  57         { "SIZELIMIT_EXCEEDED",         LDAP_SIZELIMIT_EXCEEDED },
  58         { "COMPARE_FALSE",              LDAP_COMPARE_FALSE },
  59         { "COMPARE_TRUE",               LDAP_COMPARE_TRUE },
  60         { "AUTH_METHOD_NOT_SUPPORTED",  LDAP_AUTH_METHOD_NOT_SUPPORTED },
  61         { "STRONG_AUTH_NOT_SUPPORTED",  LDAP_STRONG_AUTH_NOT_SUPPORTED },
  62         { "STRONG_AUTH_REQUIRED",       LDAP_STRONG_AUTH_REQUIRED },
  63         { "STRONGER_AUTH_REQUIRED",     LDAP_STRONGER_AUTH_REQUIRED },
  64         { "PARTIAL_RESULTS",            LDAP_PARTIAL_RESULTS },
  65
  66         { "REFERRAL",                   LDAP_REFERRAL },
  67         { "ADMINLIMIT_EXCEEDED",        LDAP_ADMINLIMIT_EXCEEDED },
  68         { "UNAVAILABLE_CRITICAL_EXTENSION", LDAP_UNAVAILABLE_CRITICAL_EXTENSION },
  69         { "CONFIDENTIALITY_REQUIRED",   LDAP_CONFIDENTIALITY_REQUIRED },
  70         { "SASL_BIND_IN_PROGRESS",      LDAP_SASL_BIND_IN_PROGRESS },
  71
  72         { "NO_SUCH_ATTRIBUTE",          LDAP_NO_SUCH_ATTRIBUTE },
  73         { "UNDEFINED_TYPE",             LDAP_UNDEFINED_TYPE },
  74         { "INAPPROPRIATE_MATCHING",     LDAP_INAPPROPRIATE_MATCHING },
  75         { "CONSTRAINT_VIOLATION",       LDAP_CONSTRAINT_VIOLATION },
  76         { "TYPE_OR_VALUE_EXISTS",       LDAP_TYPE_OR_VALUE_EXISTS },
  77         { "INVALID_SYNTAX",             LDAP_INVALID_SYNTAX },
  78
  79         { "NO_SUCH_OBJECT",             LDAP_NO_SUCH_OBJECT },
  80         { "ALIAS_PROBLEM",              LDAP_ALIAS_PROBLEM },
  81         { "INVALID_DN_SYNTAX",          LDAP_INVALID_DN_SYNTAX },
  82         { "IS_LEAF",                    LDAP_IS_LEAF },
  83         { "ALIAS_DEREF_PROBLEM",        LDAP_ALIAS_DEREF_PROBLEM },
  84
  85         /* obsolete */
  86         { "PROXY_AUTHZ_FAILURE",        LDAP_X_PROXY_AUTHZ_FAILURE },
  87         { "INAPPROPRIATE_AUTH",         LDAP_INAPPROPRIATE_AUTH },
  88         { "INVALID_CREDENTIALS",        LDAP_INVALID_CREDENTIALS },
  89         { "INSUFFICIENT_ACCESS",        LDAP_INSUFFICIENT_ACCESS },
  90
  91         { "BUSY",                       LDAP_BUSY },
  92         { "UNAVAILABLE",                LDAP_UNAVAILABLE },
  93         { "UNWILLING_TO_PERFORM",       LDAP_UNWILLING_TO_PERFORM },
  94         { "LOOP_DETECT",                LDAP_LOOP_DETECT },
  95
  96         { "NAMING_VIOLATION",           LDAP_NAMING_VIOLATION },
  97         { "OBJECT_CLASS_VIOLATION",     LDAP_OBJECT_CLASS_VIOLATION },
  98         { "NOT_ALLOWED_ON_NONLEAF",     LDAP_NOT_ALLOWED_ON_NONLEAF },
  99         { "NOT_ALLOWED_ON_RDN",         LDAP_NOT_ALLOWED_ON_RDN },
 100         { "ALREADY_EXISTS",             LDAP_ALREADY_EXISTS },
 101         { "NO_OBJECT_CLASS_MODS",       LDAP_NO_OBJECT_CLASS_MODS },
 102         { "RESULTS_TOO_LARGE",          LDAP_RESULTS_TOO_LARGE },
 103         { "AFFECTS_MULTIPLE_DSAS",      LDAP_AFFECTS_MULTIPLE_DSAS },
 104
 105         { "OTHER",                      LDAP_OTHER },
 106
 107         { "SERVER_DOWN",                LDAP_SERVER_DOWN },
 108         { "LOCAL_ERROR",                LDAP_LOCAL_ERROR },
 109         { "ENCODING_ERROR",             LDAP_ENCODING_ERROR },
 110         { "DECODING_ERROR",             LDAP_DECODING_ERROR },
 111         { "TIMEOUT",                    LDAP_TIMEOUT },
 112         { "AUTH_UNKNOWN",               LDAP_AUTH_UNKNOWN },
 113         { "FILTER_ERROR",               LDAP_FILTER_ERROR },
 114         { "USER_CANCELLED",             LDAP_USER_CANCELLED },
 115         { "PARAM_ERROR",                LDAP_PARAM_ERROR },
 116         { "NO_MEMORY",                  LDAP_NO_MEMORY },
 117         { "CONNECT_ERROR",              LDAP_CONNECT_ERROR },
 118         { "NOT_SUPPORTED",              LDAP_NOT_SUPPORTED },
 119         { "CONTROL_NOT_FOUND",          LDAP_CONTROL_NOT_FOUND },
 120         { "NO_RESULTS_RETURNED",        LDAP_NO_RESULTS_RETURNED },
 121         { "MORE_RESULTS_TO_RETURN",     LDAP_MORE_RESULTS_TO_RETURN },
 122         { "CLIENT_LOOP",                LDAP_CLIENT_LOOP },
 123         { "REFERRAL_LIMIT_EXCEEDED",    LDAP_REFERRAL_LIMIT_EXCEEDED },
 124
 125         { NULL }
 126 };
 127
 128 #define UNKNOWN_ERR     (1234567890)
 129
 130 static int
 131 tester_ignore_str2err( const char *err )
 132 {
 133         int             i, ignore = 1;
 134
 135         if ( strcmp( err, "ALL" ) == 0 ) {
 136                 for ( i = 0; ignore_str2err[ i ].name != NULL; i++ ) {
 137                         ignore_count[ ignore_str2err[ i ].err ] = 1;
 138                 }
 139                 ignore_count[ LDAP_SUCCESS ] = 0;
 140
 141                 return 0;
 142         }
 143
 144         if ( err[ 0 ] == '!' ) {
 145                 ignore = 0;
 146                 err++;
 147
 148         } else if ( err[ 0 ] == '*' ) {
 149                 ignore = -1;
 150                 err++;
 151         }
 152
 153         for ( i = 0; ignore_str2err[ i ].name != NULL; i++ ) {
 154                 if ( strcmp( err, ignore_str2err[ i ].name ) == 0 ) {
 155                         int     err = ignore_str2err[ i ].err;
 156
 157                         if ( err != LDAP_SUCCESS ) {
 158                                 ignore_count[ err ] = ignore;
 159                         }
 160
 161                         return err;
 162                 }
 163         }
 164
 165         return UNKNOWN_ERR;
 166 }
 167
 168 int
 169 tester_ignore_str2errlist( const char *err )
 170 {
 171         int     i;
 172         char    **errs = ldap_str2charray( err, "," );
 173
 174         for ( i = 0; errs[ i ] != NULL; i++ ) {
 175                 /* TODO: allow <err>:<prog> to ignore <err> only when <prog> */
 176                 (void)tester_ignore_str2err( errs[ i ] );
 177         }
 178
 179         ldap_charray_free( errs );
 180
 181         return 0;
 182 }
 183
 184 int
 185 tester_ignore_err( int err )
 186 {
 187         int rc = 1;
 188
 189         if ( err && TESTER_CLIENT_FIRST <= err && err <= TESTER_SERVER_LAST ) {
 190                 rc = ignore_count[ err ];
 191                 if ( rc != 0 ) {
 192                         ignore_count[ err ] = rc + (rc > 0 ? 1 : -1);
 193                 }
 194         }
 195
 196         /* SUCCESS is always "ignored" */
 197         return rc;
 198 }
 199
 200 void
 201 tester_init( const char *pname, tester_t ptype )
 202 {
 203         pid = getpid();
 204         srand( pid );
 205         snprintf( progname, sizeof( progname ), "%s PID=%d", pname, pid );
 206         progtype = ptype;
 207 }
 208
 209 char *
 210 tester_uri( char *uri, char *host, int port )
 211 {
 212         static char     uribuf[ BUFSIZ ];
 213
 214         if ( uri != NULL ) {
 215                 return uri;
 216         }
 217
 218         snprintf( uribuf, sizeof( uribuf ), "ldap://%s:%d", host, port );
 219
 220         return uribuf;
 221 }
 222
 223 void
 224 tester_ldap_error( LDAP *ld, const char *fname, const char *msg )
 225 {
 226         int             err;
 227         char            *text = NULL;
 228         LDAPControl     **ctrls = NULL;
 229
 230         ldap_get_option( ld, LDAP_OPT_RESULT_CODE, (void *)&err );
 231         if ( err != LDAP_SUCCESS ) {
 232                 ldap_get_option( ld, LDAP_OPT_DIAGNOSTIC_MESSAGE, (void *)&text );
 233         }
 234
 235         fprintf( stderr, "%s: %s: %s (%d) %s %s\n",
 236                 progname, fname, ldap_err2string( err ), err,
 237                 text == NULL ? "" : text,
 238                 msg ? msg : "" );
 239
 240         if ( text ) {
 241                 ldap_memfree( text );
 242                 text = NULL;
 243         }
 244
 245         ldap_get_option( ld, LDAP_OPT_MATCHED_DN, (void *)&text );
 246         if ( text != NULL ) {
 247                 if ( text[ 0 ] != '\0' ) {
 248                         fprintf( stderr, "\tmatched: %s\n", text );
 249                 }
 250                 ldap_memfree( text );
 251                 text = NULL;
 252         }
 253
 254         ldap_get_option( ld, LDAP_OPT_SERVER_CONTROLS, (void *)&ctrls );
 255         if ( ctrls != NULL ) {
 256                 int     i;
 257
 258                 fprintf( stderr, "\tcontrols:\n" );
 259                 for ( i = 0; ctrls[ i ] != NULL; i++ ) {
 260                         fprintf( stderr, "\t\t%s\n", ctrls[ i ]->ldctl_oid );
 261                 }
 262                 ldap_controls_free( ctrls );
 263                 ctrls = NULL;
 264         }
 265
 266         if ( err == LDAP_REFERRAL ) {
 267                 char **refs = NULL;
 268
 269                 ldap_get_option( ld, LDAP_OPT_REFERRAL_URLS, (void *)&refs );
 270
 271                 if ( refs ) {
 272                         int     i;
 273
 274                         fprintf( stderr, "\treferral:\n" );
 275                         for ( i = 0; refs[ i ] != NULL; i++ ) {
 276                                 fprintf( stderr, "\t\t%s\n", refs[ i ] );
 277                         }
 278
 279                         ber_memvfree( (void **)refs );
 280                 }
 281         }
 282 }
 283
 284 void
 285 tester_perror( const char *fname, const char *msg )
 286 {
 287         int     save_errno = errno;
 288         char    buf[ BUFSIZ ];
 289
 290         fprintf( stderr, "%s: %s: (%d) %s %s\n",
 291                         progname, fname, save_errno,
 292                         AC_STRERROR_R( save_errno, buf, sizeof( buf ) ),
 293                         msg ? msg : "" );
 294 }
 295
 296 void
 297 tester_error( const char *msg )
 298 {
 299         fprintf( stderr, "%s: %s\n", progname, msg );
 300 }