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

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6 /*
   7  * OpenLDAP 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, LDAP_DN_FORMAT_LDAPV3 };
  35         char            *strin, *str, *str2, 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         f2 = 1;
 118
 119         rc = ldap_str2dn( strin, &dn, flags[ 0 ] );
 120
 121         if ( rc == LDAP_SUCCESS ) {
 122                 int i;
 123                 for ( i = 0; dn[ i ]; i++ ) {
 124                         LDAPRDN         *rdn = dn[ i ][ 0 ];
 125                         char            *rstr;
 126
 127                         if ( ldap_rdn2str( rdn, &rstr, flags[ f2 ] ) ) {
 128                                 fprintf( stdout, "\tldap_rdn2str() failed\n" );
 129                                 continue;
 130                         }
 131
 132                         fprintf( stdout, "\tldap_rdn2str() = \"%s\"\n", rstr );
 133                         ldap_memfree( rstr );
 134                 }
 135         }
 136
 137         if ( rc == LDAP_SUCCESS &&
 138                         ldap_dn2str( dn, &str, flags[ f2 ] ) == LDAP_SUCCESS ) {
 139                 char    **values, *tmp, *tmp2;
 140                 int     n;
 141
 142                 fprintf( stdout, "\nldap_dn2str(ldap_str2dn(\"%s\"))\n"
 143                                 "\t= \"%s\"\n", strin, str );
 144
 145                 switch ( flags[ f2 ] & LDAP_DN_FORMAT_MASK ) {
 146                 case LDAP_DN_FORMAT_UFN:
 147                 case LDAP_DN_FORMAT_AD_CANONICAL:
 148                         return( 0 );
 149
 150                 case LDAP_DN_FORMAT_LDAPV3:
 151                 case LDAP_DN_FORMAT_LDAPV2:
 152                         tmp = ldap_dn2ufn( strin );
 153                         fprintf( stdout, "\nldap_dn2ufn(\"%s\")\n"
 154                                         "\t= \"%s\"\n", strin, tmp );
 155                         ldap_memfree( tmp );
 156                         tmp = ldap_dn2dcedn( strin );
 157                         fprintf( stdout, "\nldap_dn2dcedn(\"%s\")\n"
 158                                         "\t= \"%s\"\n", strin, tmp );
 159                         tmp2 = ldap_dcedn2dn( tmp );
 160                         fprintf( stdout, "\nldap_dcedn2dn(\"%s\")\n"
 161                                         "\t= \"%s\"\n", tmp, tmp2 );
 162                         ldap_memfree( tmp );
 163                         ldap_memfree( tmp2 );
 164                         tmp = ldap_dn2ad_canonical( strin );
 165                         fprintf( stdout, "\nldap_dn2ad_canonical(\"%s\")\n"
 166                                         "\t= \"%s\"\n", strin, tmp );
 167                         ldap_memfree( tmp );
 168
 169                         fprintf( stdout, "\nldap_explode_dn(\"%s\"):\n", str );
 170                         values = ldap_explode_dn( str, 0 );
 171                         for ( n = 0; values && values[ n ]; n++ ) {
 172                                 char    **vv;
 173                                 int     nn;
 174
 175                                 fprintf( stdout, "\t\"%s\"\n", values[ n ] );
 176
 177                                 fprintf( stdout, "\tldap_explode_rdn(\"%s\")\n",
 178                                                 values[ n ] );
 179                                 vv = ldap_explode_rdn( values[ n ], 0 );
 180                                 for ( nn = 0; vv && vv[ nn ]; nn++ ) {
 181                                         fprintf( stdout, "\t\t'%s'\n",
 182                                                         vv[ nn ] );
 183                                 }
 184                                 LDAP_VFREE( vv );
 185
 186                                 fprintf( stdout, "\tldap_explode_rdn(\"%s\")"
 187                                                " (no types)\n", values[ n ] );
 188                                 vv = ldap_explode_rdn( values[ n ], 1 );
 189                                 for ( nn = 0; vv && vv[ nn ]; nn++ ) {
 190                                         fprintf( stdout, "\t\t\t\"%s\"\n",
 191                                                         vv[ nn ] );
 192                                 }
 193                                 LDAP_VFREE( vv );
 194
 195                         }
 196                         LDAP_VFREE( values );
 197
 198                         fprintf( stdout, "\nldap_explode_dn(\"%s\")"
 199                                         " (no types):\n", str );
 200                         values = ldap_explode_dn( str, 1 );
 201                         for ( n = 0; values && values[ n ]; n++ ) {
 202                                 fprintf( stdout, "\t\"%s\"\n", values[ n ] );
 203                         }
 204                         LDAP_VFREE( values );
 205
 206                         break;
 207                 }
 208
 209                 rc = ldap_str2dn( str, &dn2, flags[ f2 ] );
 210                 if ( rc == LDAP_SUCCESS &&
 211                                 ldap_dn2str( dn2, &str2, flags[ f2 ] )
 212                                 == LDAP_SUCCESS ) {
 213                         int     iRDN;
 214
 215                         fprintf( stdout, "\n\"%s\"\n\t == \"%s\" ? %s\n",
 216                                 str, str2,
 217                                 strcmp( str, str2 ) == 0 ? "yes" : "no" );
 218
 219                         for ( iRDN = 0; dn[ iRDN ] && dn2[ iRDN ]; iRDN++ ) {
 220                                 LDAPRDN         *r = dn[ iRDN ][ 0 ];
 221                                 LDAPRDN         *r2 = dn2[ iRDN ][ 0 ];
 222                                 int             iAVA;
 223
 224                                 for ( iAVA = 0; r[ iAVA ] && r[ iAVA ]; iAVA++ ) {
 225                                         LDAPAVA         *a = r[ iAVA ][ 0 ];
 226                                         LDAPAVA         *a2 = r2[ iAVA ][ 0 ];
 227
 228                                         if ( a->la_attr->bv_len != a2->la_attr->bv_len
 229                                                         || memcmp( a->la_attr->bv_val, a2->la_attr->bv_val, a->la_attr->bv_len )
 230                                                         || a->la_flags != a2->la_flags
 231                                                         || a->la_value->bv_len != a2->la_value->bv_len
 232                                                         || memcmp( a->la_value->bv_val, a2->la_value->bv_val, a->la_value->bv_len ) ) {
 233                                                 fprintf( stdout, "mismatch\n" );
 234
 235                                         }
 236                                 }
 237                         }
 238
 239                         ldapava_free_dn( dn2 );
 240                         ldap_memfree( str2 );
 241                 }
 242                 ldap_memfree( str );
 243         }
 244         ldapava_free_dn( dn );
 245
 246         /* note: dn is not freed */
 247
 248         return( 0 );
 249 }
 250