git.sur5r.net Git - openldap/blob - servers/slapd/overlays/rwmdn.c

   1 /* rwmdn.c - massages dns */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 1999-2005 The OpenLDAP Foundation.
   6  * Portions Copyright 1999-2003 Howard Chu.
   7  * Portions Copyright 2000-2003 Pierangelo Masarati.
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted only as authorized by the OpenLDAP
  12  * Public License.
  13  *
  14  * A copy of this license is available in the file LICENSE in the
  15  * top-level directory of the distribution or, alternatively, at
  16  * <http://www.OpenLDAP.org/license.html>.
  17  */
  18 /* ACKNOWLEDGEMENTS:
  19  * This work was initially developed by Howard Chu for inclusion
  20  * in OpenLDAP Software and subsequently enhanced by Pierangelo
  21  * Masarati.
  22  */
  23
  24
  25 #include "portable.h"
  26
  27 #ifdef SLAPD_OVER_RWM
  28
  29 #include <stdio.h>
  30
  31 #include <ac/string.h>
  32 #include <ac/socket.h>
  33
  34 #include "slap.h"
  35 #include "rwm.h"
  36
  37 /* FIXME: after rewriting, we should also remap attributes ...  */
  38
  39 /*
  40  * massages "in" and normalizes it into "ndn"
  41  *
  42  * "ndn" may be untouched if no massaging occurred and its value was not null
  43  */
  44 int
  45 rwm_dn_massage_normalize(
  46         dncookie *dc,
  47         struct berval *in,
  48         struct berval *ndn )
  49 {
  50         int             rc;
  51         struct berval   mdn = BER_BVNULL;
  52
  53         /* massage and normalize a DN */
  54         rc = rwm_dn_massage( dc, in, &mdn );
  55         if ( rc != LDAP_SUCCESS ) {
  56                 return rc;
  57         }
  58
  59         if ( mdn.bv_val == in->bv_val && !BER_BVISNULL( ndn ) ) {
  60                 return rc;
  61         }
  62
  63         rc = dnNormalize( 0, NULL, NULL, &mdn, ndn, NULL );
  64
  65         if ( mdn.bv_val != in->bv_val ) {
  66                 ch_free( mdn.bv_val );
  67         }
  68
  69         return rc;
  70 }
  71
  72 /*
  73  * massages "in" and prettifies it into "pdn"
  74  *
  75  * "pdn" may be untouched if no massaging occurred and its value was not null
  76  */
  77 int
  78 rwm_dn_massage_pretty(
  79         dncookie *dc,
  80         struct berval *in,
  81         struct berval *pdn )
  82 {
  83         int             rc;
  84         struct berval   mdn = BER_BVNULL;
  85
  86         /* massage and pretty a DN */
  87         rc = rwm_dn_massage( dc, in, &mdn );
  88         if ( rc != LDAP_SUCCESS ) {
  89                 return rc;
  90         }
  91
  92         if ( mdn.bv_val == in->bv_val && !BER_BVISNULL( pdn ) ) {
  93                 return rc;
  94         }
  95
  96         rc = dnPretty( NULL, &mdn, pdn, NULL );
  97
  98         if ( mdn.bv_val != in->bv_val ) {
  99                 ch_free( mdn.bv_val );
 100         }
 101
 102         return rc;
 103 }
 104
 105 /*
 106  * massages "in" and prettifies and normalizes it into "pdn" and "ndn"
 107  *
 108  * "pdn" may be untouched if no massaging occurred and its value was not null;
 109  * "ndn" may be untouched if no massaging occurred and its value was not null;
 110  * if no massage occurred and "ndn" value was not null, it is filled
 111  * with the normaized value of "pdn", much like ndn = dnNormalize( pdn )
 112  */
 113 int
 114 rwm_dn_massage_pretty_normalize(
 115         dncookie *dc,
 116         struct berval *in,
 117         struct berval *pdn,
 118         struct berval *ndn )
 119 {
 120         int             rc;
 121         struct berval   mdn = BER_BVNULL;
 122
 123         /* massage, pretty and normalize a DN */
 124         rc = rwm_dn_massage( dc, in, &mdn );
 125         if ( rc != LDAP_SUCCESS ) {
 126                 return rc;
 127         }
 128
 129         if ( mdn.bv_val == in->bv_val && !BER_BVISNULL( pdn ) ) {
 130                 if ( BER_BVISNULL( ndn ) ) {
 131                         rc = dnNormalize( 0, NULL, NULL, &mdn, ndn, NULL );
 132                 }
 133                 return rc;
 134         }
 135
 136         rc = dnPrettyNormal( NULL, &mdn, pdn, ndn, NULL );
 137
 138         if ( mdn.bv_val != in->bv_val ) {
 139                 ch_free( mdn.bv_val );
 140         }
 141
 142         return rc;
 143 }
 144
 145 #ifdef ENABLE_REWRITE
 146 /*
 147  * massages "in" into "dn"
 148  *
 149  * "dn" may contain the value of "in" if no massage occurred
 150  */
 151 int
 152 rwm_dn_massage(
 153         dncookie *dc,
 154         struct berval *in,
 155         struct berval *dn
 156 )
 157 {
 158         int             rc = 0;
 159         struct berval   mdn;
 160         static char     *dmy = "";
 161
 162         assert( dc );
 163         assert( in );
 164         assert( dn );
 165
 166         rc = rewrite_session( dc->rwmap->rwm_rw, dc->ctx,
 167                         ( in->bv_val ? in->bv_val : dmy ),
 168                         dc->conn, &mdn.bv_val );
 169         switch ( rc ) {
 170         case REWRITE_REGEXEC_OK:
 171                 if ( !BER_BVISNULL( &mdn ) && mdn.bv_val != in->bv_val ) {
 172                         mdn.bv_len = strlen( mdn.bv_val );
 173                         *dn = mdn;
 174                 } else {
 175                         *dn = *in;
 176                 }
 177                 rc = LDAP_SUCCESS;
 178
 179                 Debug( LDAP_DEBUG_ARGS,
 180                         "[rw] %s: \"%s\" -> \"%s\"\n",
 181                         dc->ctx, in->bv_val, dn->bv_val );
 182                 break;
 183
 184         case REWRITE_REGEXEC_UNWILLING:
 185                 if ( dc->rs ) {
 186                         dc->rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
 187                         dc->rs->sr_text = "Operation not allowed";
 188                 }
 189                 rc = LDAP_UNWILLING_TO_PERFORM;
 190                 break;
 191
 192         case REWRITE_REGEXEC_ERR:
 193                 if ( dc->rs ) {
 194                         dc->rs->sr_err = LDAP_OTHER;
 195                         dc->rs->sr_text = "Rewrite error";
 196                 }
 197                 rc = LDAP_OTHER;
 198                 break;
 199         }
 200
 201         if ( mdn.bv_val == dmy ) {
 202                 BER_BVZERO( &mdn );
 203         }
 204
 205         return rc;
 206 }
 207
 208 #else /* ! ENABLE_REWRITE */
 209 /*
 210  * rwm_dn_massage
 211  *
 212  * Aliases the suffix; based on suffix_alias (servers/slapd/suffixalias.c).
 213  */
 214 int
 215 rwm_dn_massage(
 216         dncookie *dc,
 217         struct berval *in,
 218         struct berval *dn
 219 )
 220 {
 221         int             i, src, dst;
 222         struct berval   tmpin;
 223
 224         assert( dc );
 225         assert( in );
 226         assert( dn );
 227
 228         BER_BVZERO( dn );
 229
 230         if ( BER_BVISNULL( in ) ) {
 231                 return LDAP_SUCCESS;
 232         }
 233
 234         if ( dc->rwmap == NULL || dc->rwmap->rwm_suffix_massage == NULL ) {
 235                 *dn = *in;
 236                 return LDAP_SUCCESS;
 237         }
 238
 239         if ( dc->tofrom ) {
 240                 src = 0 + dc->normalized;
 241                 dst = 2 + dc->normalized;
 242
 243                 tmpin = *in;
 244
 245         } else {
 246                 int     rc;
 247
 248                 src = 2 + dc->normalized;
 249                 dst = 0 + dc->normalized;
 250
 251                 /* DN from remote server may be in arbitrary form.
 252                  * Pretty it so we can parse reliably.
 253                  */
 254                 if ( dc->normalized ) {
 255                         rc = dnNormalize( 0, NULL, NULL, in, &tmpin, NULL );
 256
 257                 } else {
 258                         rc = dnPretty( NULL, in, &tmpin, NULL );
 259                 }
 260
 261                 if ( rc != LDAP_SUCCESS ) {
 262                         return rc;
 263                 }
 264         }
 265
 266         for ( i = 0;
 267                         !BER_BVISNULL( &dc->rwmap->rwm_suffix_massage[i] );
 268                         i += 4 )
 269         {
 270                 int aliasLength = dc->rwmap->rwm_suffix_massage[i+src].bv_len;
 271                 int diff = tmpin.bv_len - aliasLength;
 272
 273                 if ( diff < 0 ) {
 274                         /* alias is longer than dn */
 275                         continue;
 276
 277                 } else if ( diff > 0 && ( !DN_SEPARATOR(tmpin.bv_val[diff-1])))
 278                 {
 279                         /* FIXME: DN_SEPARATOR() is intended to work
 280                          * on a normalized/pretty DN, so that ';'
 281                          * is never used as a DN separator */
 282                         continue;
 283                         /* At a DN Separator */
 284                 }
 285
 286                 if ( !strcmp( dc->rwmap->rwm_suffix_massage[i+src].bv_val,
 287                                         &tmpin.bv_val[diff] ) )
 288                 {
 289                         dn->bv_len = diff + dc->rwmap->rwm_suffix_massage[i+dst].bv_len;
 290                         dn->bv_val = ch_malloc( dn->bv_len + 1 );
 291                         strncpy( dn->bv_val, tmpin.bv_val, diff );
 292                         strcpy( &dn->bv_val[diff], dc->rwmap->rwm_suffix_massage[i+dst].bv_val );
 293                         Debug( LDAP_DEBUG_ARGS,
 294                                 "rwm_dn_massage:"
 295                                 " converted \"%s\" to \"%s\"\n",
 296                                 in->bv_val, dn->bv_val, 0 );
 297
 298                         break;
 299                 }
 300         }
 301
 302         if ( tmpin.bv_val != in->bv_val ) {
 303                 ch_free( tmpin.bv_val );
 304         }
 305
 306         /* Nothing matched, just return the original DN */
 307         if ( BER_BVISNULL( dn ) ) {
 308                 *dn = *in;
 309         }
 310
 311         return LDAP_SUCCESS;
 312 }
 313 #endif /* ! ENABLE_REWRITE */
 314
 315 #endif /* SLAPD_OVER_RWM */