git.sur5r.net Git - openldap/blob - libraries/libldap/dntest.c

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6 /*
   7  * OpenLDAP DN API Test
   8  *      Written by: Pierangelo Masarati <ando@OpenLDAP.org>
   9  *
  10  * This program is designed to test the ldap_str2dn/ldap_dn2str
  11  * functions
  12  */
  13 #include "portable.h"
  14
  15 #include <ac/stdlib.h>
  16 #include <ac/string.h>
  17 #include <ac/unistd.h>
  18
  19 #include <stdio.h>
  20
  21 #include <ldap.h>
  22
  23 #include "ldap-int.h"
  24
  25 #include "ldif.h"
  26 #include "lutil.h"
  27 #include "lutil_ldap.h"
  28 #include "ldap_defaults.h"
  29
  30 int
  31 main( int argc, char *argv[] )
  32 {
  33         int             rc, i, debug = 0, f2 = 0;
  34         unsigned        flags[ 2 ] = { 0U, 0 };
  35         char            *strin, *str = NULL, buf[ 1024 ];
  36         LDAPDN          *dn, *dn2 = NULL;
  37
  38         while ( 1 ) {
  39                 int opt = getopt( argc, argv, "d:" );
  40
  41                 if ( opt == EOF ) {
  42                         break;
  43                 }
  44
  45                 switch ( opt ) {
  46                 case 'd':
  47                         debug = atoi( optarg );
  48                         break;
  49                 }
  50         }
  51
  52         optind--;
  53         argc -= optind;
  54         argv += optind;
  55
  56         if ( argc < 2 ) {
  57                 fprintf( stderr, "usage: dntest <dn> [flags-in[,...]] [flags-out[,...]]\n\n" );
  58                 fprintf( stderr, "\tflags-in:   V3,V2,DCE,<flags>\n" );
  59                 fprintf( stderr, "\tflags-out:  V3,V2,UFN,DCE,AD,<flags>\n\n" );
  60                 fprintf( stderr, "\t<flags>: PRETTY,PEDANTIC,NOSPACES,NOONESPACE\n\n" );
  61                 return( 0 );
  62         }
  63
  64         if ( ber_set_option( NULL, LBER_OPT_DEBUG_LEVEL, &debug ) != LBER_OPT_SUCCESS ) {
  65                 fprintf( stderr, "Could not set LBER_OPT_DEBUG_LEVEL %d\n", debug );
  66         }
  67         if ( ldap_set_option( NULL, LDAP_OPT_DEBUG_LEVEL, &debug ) != LDAP_OPT_SUCCESS ) {
  68                 fprintf( stderr, "Could not set LDAP_OPT_DEBUG_LEVEL %d\n", debug );
  69         }
  70
  71         if ( strcmp( argv[ 1 ], "-" ) == 0 ) {
  72                 size_t len;
  73
  74                 fgets( buf, sizeof( buf ), stdin );
  75                 len = strlen( buf ) - 1;
  76                 if ( len >= 0 && buf[ len ] == '\n' ) {
  77                         buf[ len ] = '\0';
  78                 }
  79                 strin = buf;
  80         } else {
  81                 strin = argv[ 1 ];
  82         }
  83
  84         if ( argc >= 3 ) {
  85                 for ( i = 0; i < argc - 2; i++ ) {
  86                         char *s, *e;
  87                         for ( s = argv[ 2 + i ]; s; s = e ) {
  88                                 e = strchr( s, ',' );
  89                                 if ( e != NULL ) {
  90                                         e[ 0 ] = '\0';
  91                                         e++;
  92                                 }
  93
  94                                 if ( !strcasecmp( s, "V3" ) ) {
  95                                         flags[ i ] |= LDAP_DN_FORMAT_LDAPV3;
  96                                 } else if ( !strcasecmp( s, "V2" ) ) {
  97                                         flags[ i ] |= LDAP_DN_FORMAT_LDAPV2;
  98                                 } else if ( !strcasecmp( s, "DCE" ) ) {
  99                                         flags[ i ] |= LDAP_DN_FORMAT_DCE;
 100                                 } else if ( !strcasecmp( s, "UFN" ) ) {
 101                                         flags[ i ] |= LDAP_DN_FORMAT_UFN;
 102                                 } else if ( !strcasecmp( s, "AD" ) ) {
 103                                         flags[ i ] |= LDAP_DN_FORMAT_AD_CANONICAL;
 104                                 } else if ( !strcasecmp( s, "PRETTY" ) ) {
 105                                         flags[ i ] |= LDAP_DN_PRETTY;
 106                                 } else if ( !strcasecmp( s, "PEDANTIC" ) ) {
 107                                         flags[ i ] |= LDAP_DN_PEDANTIC;
 108                                 } else if ( !strcasecmp( s, "NOSPACES" ) ) {
 109                                         flags[ i ] |= LDAP_DN_P_NOLEADTRAILSPACES;
 110                                 } else if ( !strcasecmp( s, "NOONESPACE" ) ) {
 111                                         flags[ i ] |= LDAP_DN_P_NOSPACEAFTERRDN;
 112                                 }
 113                         }
 114                 }
 115         }
 116
 117         if ( flags[ 1 ] == 0 )
 118                 flags[ 1 ] = LDAP_DN_FORMAT_LDAPV3;
 119
 120         f2 = 1;
 121
 122         rc = ldap_str2dn( strin, &dn, flags[ 0 ] );
 123
 124         if ( rc == LDAP_SUCCESS ) {
 125                 int i;
 126                 if ( dn ) {
 127                         for ( i = 0; dn[ 0 ][ i ]; i++ ) {
 128                                 LDAPRDN         *rdn = dn[ 0 ][ i ];
 129                                 char            *rstr = NULL;
 130
 131                                 if ( ldap_rdn2str( rdn, &rstr, flags[ f2 ] ) ) {
 132                                         fprintf( stdout, "\tldap_rdn2str() failed\n" );
 133                                         continue;
 134                                 }
 135
 136                                 fprintf( stdout, "\tldap_rdn2str() = \"%s\"\n", rstr );
 137                                 ldap_memfree( rstr );
 138                         }
 139                 } else {
 140                         fprintf( stdout, "\tempty DN\n" );
 141                 }
 142         }
 143
 144         str = NULL;
 145         if ( rc == LDAP_SUCCESS &&
 146                 ldap_dn2str( dn, &str, flags[ f2 ] ) == LDAP_SUCCESS )
 147         {
 148                 char    **values, *tmp, *tmp2, *str2 = NULL;
 149                 int     n;
 150
 151                 fprintf( stdout, "\nldap_dn2str(ldap_str2dn(\"%s\"))\n"
 152                                 "\t= \"%s\"\n", strin, str );
 153
 154                 switch ( flags[ f2 ] & LDAP_DN_FORMAT_MASK ) {
 155                 case LDAP_DN_FORMAT_UFN:
 156                 case LDAP_DN_FORMAT_AD_CANONICAL:
 157                         return( 0 );
 158
 159                 case LDAP_DN_FORMAT_LDAPV3:
 160                 case LDAP_DN_FORMAT_LDAPV2:
 161                         tmp = ldap_dn2ufn( strin );
 162                         fprintf( stdout, "\nldap_dn2ufn(\"%s\")\n"
 163                                         "\t= \"%s\"\n", strin, tmp );
 164                         ldap_memfree( tmp );
 165
 166                         tmp = ldap_dn2dcedn( strin );
 167                         fprintf( stdout, "\nldap_dn2dcedn(\"%s\")\n"
 168                                         "\t= \"%s\"\n", strin, tmp );
 169                         tmp2 = ldap_dcedn2dn( tmp );
 170                         fprintf( stdout, "\nldap_dcedn2dn(\"%s\")\n"
 171                                         "\t= \"%s\"\n", tmp, tmp2 );
 172                         ldap_memfree( tmp );
 173                         ldap_memfree( tmp2 );
 174
 175                         tmp = ldap_dn2ad_canonical( strin );
 176                         fprintf( stdout, "\nldap_dn2ad_canonical(\"%s\")\n"
 177                                         "\t= \"%s\"\n", strin, tmp );
 178                         ldap_memfree( tmp );
 179
 180                         fprintf( stdout, "\nldap_explode_dn(\"%s\"):\n", str );
 181                         values = ldap_explode_dn( str, 0 );
 182                         for ( n = 0; values && values[ n ]; n++ ) {
 183                                 char    **vv;
 184                                 int     nn;
 185
 186                                 fprintf( stdout, "\t\"%s\"\n", values[ n ] );
 187
 188                                 fprintf( stdout, "\tldap_explode_rdn(\"%s\")\n",
 189                                                 values[ n ] );
 190                                 vv = ldap_explode_rdn( values[ n ], 0 );
 191                                 for ( nn = 0; vv && vv[ nn ]; nn++ ) {
 192                                         fprintf( stdout, "\t\t'%s'\n",
 193                                                         vv[ nn ] );
 194                                 }
 195                                 LDAP_VFREE( vv );
 196
 197                                 fprintf( stdout, "\tldap_explode_rdn(\"%s\")"
 198                                                " (no types)\n", values[ n ] );
 199                                 vv = ldap_explode_rdn( values[ n ], 1 );
 200                                 for ( nn = 0; vv && vv[ nn ]; nn++ ) {
 201                                         fprintf( stdout, "\t\t\t\"%s\"\n",
 202                                                         vv[ nn ] );
 203                                 }
 204                                 LDAP_VFREE( vv );
 205
 206                         }
 207                         LDAP_VFREE( values );
 208
 209                         fprintf( stdout, "\nldap_explode_dn(\"%s\")"
 210                                         " (no types):\n", str );
 211                         values = ldap_explode_dn( str, 1 );
 212                         for ( n = 0; values && values[ n ]; n++ ) {
 213                                 fprintf( stdout, "\t\"%s\"\n", values[ n ] );
 214                         }
 215                         LDAP_VFREE( values );
 216
 217                         break;
 218                 }
 219
 220                 dn2 = NULL;
 221                 rc = ldap_str2dn( str, &dn2, flags[ f2 ] );
 222                 str2 = NULL;
 223                 if ( rc == LDAP_SUCCESS &&
 224                                 ldap_dn2str( dn2, &str2, flags[ f2 ] )
 225                                 == LDAP_SUCCESS ) {
 226                         int     iRDN;
 227
 228                         fprintf( stdout, "\n\"%s\"\n\t == \"%s\" ? %s\n",
 229                                 str, str2,
 230                                 strcmp( str, str2 ) == 0 ? "yes" : "no" );
 231
 232                         if( dn != NULL && dn2 == NULL ) {
 233                                 fprintf( stdout, "dn mismatch\n" );
 234                         } else if (( dn != NULL ) && (dn2 != NULL))
 235                                 for ( iRDN = 0; dn[ 0 ][ iRDN ] && dn2[ 0 ][ iRDN ]; iRDN++ )
 236                         {
 237                                 LDAPRDN         *r = dn[ 0 ][ iRDN ];
 238                                 LDAPRDN         *r2 = dn2[ 0 ][ iRDN ];
 239                                 int             iAVA;
 240
 241                                 for ( iAVA = 0; r[ 0 ][ iAVA ] && r2[ 0 ][ iAVA ]; iAVA++ ) {
 242                                         LDAPAVA         *a = r[ 0 ][ iAVA ];
 243                                         LDAPAVA         *a2 = r2[ 0 ][ iAVA ];
 244
 245                                         if ( a->la_attr.bv_len != a2->la_attr.bv_len ) {
 246                                                 fprintf( stdout, "ava(%d), rdn(%d) attr len mismatch (%ld->%ld)\n",
 247                                                                 iAVA + 1, iRDN + 1,
 248                                                                 a->la_attr.bv_len, a2->la_attr.bv_len );
 249                                         } else if ( memcmp( a->la_attr.bv_val, a2->la_attr.bv_val, a->la_attr.bv_len ) ) {
 250                                                 fprintf( stdout, "ava(%d), rdn(%d) attr mismatch\n",
 251                                                                 iAVA + 1, iRDN + 1 );
 252                                         } else if ( a->la_flags != a2->la_flags ) {
 253                                                 fprintf( stdout, "ava(%d), rdn(%d) flag mismatch (%x->%x)\n",
 254                                                                 iAVA + 1, iRDN + 1, a->la_flags, a2->la_flags );
 255                                         } else if ( a->la_value.bv_len != a2->la_value.bv_len ) {
 256                                                 fprintf( stdout, "ava(%d), rdn(%d) value len mismatch (%ld->%ld)\n",
 257                                                                 iAVA + 1, iRDN + 1,
 258                                                                 a->la_value.bv_len, a2->la_value.bv_len );
 259                                         } else if ( memcmp( a->la_value.bv_val, a2->la_value.bv_val, a->la_value.bv_len ) ) {
 260                                                 fprintf( stdout, "ava(%d), rdn(%d) value mismatch\n",
 261                                                                 iAVA + 1, iRDN + 1 );
 262                                         }
 263                                 }
 264                         }
 265
 266                         ldap_dnfree( dn2 );
 267                         ldap_memfree( str2 );
 268                 }
 269                 ldap_memfree( str );
 270         }
 271         ldap_dnfree( dn );
 272
 273         /* note: dn is not freed */
 274
 275         return( 0 );
 276 }
 277