X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fsasl.c;h=ca6e7c9ce8069a7a6e67c8fff23cec86415fa050;hb=3b2cef17eb8537b3095c78448b785995f3ea148b;hp=1daf41355611b9b3337ab1d22a14377a5a927f69;hpb=a54900be42f1afc9f27879d69fbc070a7c153d8c;p=openldap diff --git a/servers/slapd/sasl.c b/servers/slapd/sasl.c index 1daf413556..ca6e7c9ce8 100644 --- a/servers/slapd/sasl.c +++ b/servers/slapd/sasl.c @@ -1,7 +1,7 @@ /* $OpenLDAP$ */ /* This work is part of OpenLDAP Software . * - * Copyright 1998-2004 The OpenLDAP Foundation. + * Copyright 1998-2010 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -16,6 +16,10 @@ #include "portable.h" #include +#ifdef HAVE_LIMITS_H +#include +#endif + #include #include @@ -24,25 +28,20 @@ #include "slap.h" -#include +#ifdef ENABLE_REWRITE +#include +#endif #ifdef HAVE_CYRUS_SASL # ifdef HAVE_SASL_SASL_H # include -# else -# include -# endif - -# if SASL_VERSION_MAJOR >= 2 -# ifdef HAVE_SASL_SASL_H # include # else +# include # include # endif -# define SASL_CONST const -# else -# define SASL_CONST -# endif + +# define SASL_CONST const #define SASL_VERSION_FULL ((SASL_VERSION_MAJOR << 16) |\ (SASL_VERSION_MINOR << 8) | SASL_VERSION_STEP) @@ -60,181 +59,33 @@ typedef struct sasl_ctx { #endif -#include "ldap_pvt.h" -#include "lber_pvt.h" #include static struct berval ext_bv = BER_BVC( "EXTERNAL" ); -int slap_sasl_config( int cargc, char **cargv, char *line, - const char *fname, int lineno ) -{ - /* set SASL proxy authorization policy */ - if ( !strcasecmp( cargv[0], "authz-policy" ) || - !strcasecmp( cargv[0], "sasl-authz-policy" )) - { - if ( cargc != 2 ) { -#ifdef NEW_LOGGING - LDAP_LOG( CONFIG, CRIT, - "%s: line %d: missing policy in" - " \"%s \" line\n", - cargv[0], fname, lineno ); -#else - Debug( LDAP_DEBUG_ANY, - "%s: line %d: missing policy in" - " \"%s \" line\n", - cargv[0], fname, lineno ); -#endif - - return( 1 ); - } - if ( slap_sasl_setpolicy( cargv[1] ) ) { -#ifdef NEW_LOGGING - LDAP_LOG( CONFIG, CRIT, "%s: line %d: " - "unable to parse value \"%s\" in \"authz-policy " - "\" line.\n", - fname, lineno, cargv[1] ); -#else - Debug( LDAP_DEBUG_ANY, "%s: line %d: " - "unable to parse value \"%s\" in \"authz-policy " - "\" line.\n", - fname, lineno, cargv[1] ); -#endif - return( 1 ); - } - - } else if ( !strcasecmp( cargv[0], "authz-regexp" ) || - !strcasecmp( cargv[0], "sasl-regexp" ) || - !strcasecmp( cargv[0], "saslregexp" ) ) - { - int rc; - if ( cargc != 3 ) { -#ifdef NEW_LOGGING - LDAP_LOG( CONFIG, CRIT, - "%s: line %d: need 2 args in " - "\"authz-regexp \"\n", - fname, lineno, 0 ); -#else - Debug( LDAP_DEBUG_ANY, - "%s: line %d: need 2 args in " - "\"authz-regexp \"\n", - fname, lineno, 0 ); -#endif - - return( 1 ); - } - rc = slap_sasl_regexp_config( cargv[1], cargv[2] ); - if ( rc ) { - return rc; - } +char *slap_sasl_auxprops; #ifdef HAVE_CYRUS_SASL - /* set SASL host */ - } else if ( strcasecmp( cargv[0], "sasl-host" ) == 0 ) { - if ( cargc < 2 ) { -#ifdef NEW_LOGGING - LDAP_LOG( CONFIG, CRIT, - "%s: line %d: missing host in \"sasl-host \" line\n", - fname, lineno, 0 ); -#else - Debug( LDAP_DEBUG_ANY, - "%s: line %d: missing host in \"sasl-host \" line\n", - fname, lineno, 0 ); -#endif - - return( 1 ); - } - - if ( global_host != NULL ) { -#ifdef NEW_LOGGING - LDAP_LOG( CONFIG, CRIT, - "%s: line %d: already set sasl-host!\n", - fname, lineno, 0 ); -#else - Debug( LDAP_DEBUG_ANY, - "%s: line %d: already set sasl-host!\n", - fname, lineno, 0 ); -#endif - - return 1; - - } else { - global_host = ch_strdup( cargv[1] ); - } - - /* set SASL realm */ - } else if ( strcasecmp( cargv[0], "sasl-realm" ) == 0 ) { - if ( cargc < 2 ) { -#ifdef NEW_LOGGING - LDAP_LOG( CONFIG, CRIT, "%s: line %d: " - "missing realm in \"sasl-realm \" line.\n", - fname, lineno, 0 ); -#else - Debug( LDAP_DEBUG_ANY, "%s: line %d: " - "missing realm in \"sasl-realm \" line.\n", - fname, lineno, 0 ); -#endif - - return( 1 ); - } - - if ( global_realm != NULL ) { -#ifdef NEW_LOGGING - LDAP_LOG( CONFIG, CRIT, - "%s: line %d: already set sasl-realm!\n", - fname, lineno, 0 ); -#else - Debug( LDAP_DEBUG_ANY, - "%s: line %d: already set sasl-realm!\n", - fname, lineno, 0 ); -#endif - - return 1; - - } else { - global_realm = ch_strdup( cargv[1] ); - } - - /* SASL security properties */ - } else if ( strcasecmp( cargv[0], "sasl-secprops" ) == 0 ) { - char *txt; - - if ( cargc < 2 ) { -#ifdef NEW_LOGGING - LDAP_LOG( CONFIG, CRIT, "%s: line %d: " - "missing flags in \"sasl-secprops \" line\n", - fname, lineno, 0 ); -#else - Debug( LDAP_DEBUG_ANY, "%s: line %d: " - "missing flags in \"sasl-secprops \" line\n", - fname, lineno, 0 ); -#endif - return 1; - } - - txt = slap_sasl_secprops( cargv[1] ); - if ( txt != NULL ) { -#ifdef NEW_LOGGING - LDAP_LOG( CONFIG, CRIT, - "%s: line %d sasl-secprops: %s\n", - fname, lineno, txt ); -#else - Debug( LDAP_DEBUG_ANY, - "%s: line %d: sasl-secprops: %s\n", - fname, lineno, txt ); -#endif - - return 1; - } -#endif /* HAVE_CYRUS_SASL */ - } - - return LDAP_SUCCESS; +/* Just use our internal auxprop by default */ +static int +slap_sasl_getopt( + void *context, + const char *plugin_name, + const char *option, + const char **result, + unsigned *len) +{ + if ( strcmp( option, "auxprop_plugin" )) { + return SASL_FAIL; + } + if ( slap_sasl_auxprops ) + *result = slap_sasl_auxprops; + else + *result = "slapd"; + return SASL_OK; } -#ifdef HAVE_CYRUS_SASL - int slap_sasl_log( void *context, @@ -250,7 +101,6 @@ slap_sasl_log( } switch (priority) { -#if SASL_VERSION_MAJOR >= 2 case SASL_LOG_NONE: level = LDAP_DEBUG_NONE; label = "None"; @@ -283,49 +133,36 @@ slap_sasl_log( level = LDAP_DEBUG_TRACE; label = "Password Trace"; break; -#else - case SASL_LOG_ERR: - level = LDAP_DEBUG_ANY; - label = "Error"; - break; - case SASL_LOG_WARNING: - level = LDAP_DEBUG_TRACE; - label = "Warning"; - break; - case SASL_LOG_INFO: - level = LDAP_DEBUG_TRACE; - label = "Info"; - break; -#endif default: return SASL_BADPARAM; } -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ENTRY, - "SASL [conn=%ld] %s: %s\n", conn ? conn->c_connid : -1, label, message); -#else Debug( level, "SASL [conn=%ld] %s: %s\n", - conn ? conn->c_connid: -1, + conn ? (long) conn->c_connid: -1L, label, message ); -#endif return SASL_OK; } - -#if SASL_VERSION_MAJOR >= 2 static const char *slap_propnames[] = { - "*slapConn", "*slapAuthcDN", "*slapAuthzDN", NULL }; + "*slapConn", "*slapAuthcDNlen", "*slapAuthcDN", + "*slapAuthzDNlen", "*slapAuthzDN", NULL }; -static Filter generic_filter = { LDAP_FILTER_PRESENT }; +#ifdef SLAP_AUXPROP_DONTUSECOPY +int slap_dontUseCopy_ignore; +BerVarray slap_dontUseCopy_propnames; +#endif /* SLAP_AUXPROP_DONTUSECOPY */ + +static Filter generic_filter = { LDAP_FILTER_PRESENT, { 0 }, NULL }; static struct berval generic_filterstr = BER_BVC("(objectclass=*)"); -#define PROP_CONN 0 -#define PROP_AUTHC 1 -#define PROP_AUTHZ 2 -#define PROP_COUNT 3 /* Number of properties we used */ +#define SLAP_SASL_PROP_CONN 0 +#define SLAP_SASL_PROP_AUTHCLEN 1 +#define SLAP_SASL_PROP_AUTHC 2 +#define SLAP_SASL_PROP_AUTHZLEN 3 +#define SLAP_SASL_PROP_AUTHZ 4 +#define SLAP_SASL_PROP_COUNT 5 /* Number of properties we used */ typedef struct lookup_info { int flags; @@ -335,6 +172,8 @@ typedef struct lookup_info { static slap_response sasl_ap_lookup; +static struct berval sc_cleartext = BER_BVC("{CLEARTEXT}"); + static int sasl_ap_lookup( Operation *op, SlapReply *rs ) { @@ -343,10 +182,12 @@ sasl_ap_lookup( Operation *op, SlapReply *rs ) Attribute *a; const char *text; int rc, i; - slap_callback *tmp = op->o_callback; - lookup_info *sl = tmp->sc_private; + lookup_info *sl = (lookup_info *)op->o_callback->sc_private; - if (rs->sr_type != REP_SEARCH) return 0; + /* return the actual error code, + * to allow caller to handle specific errors + */ + if (rs->sr_type != REP_SEARCH) return rs->sr_err; for( i = 0; sl->list[i].name; i++ ) { const char *name = sl->list[i].name; @@ -355,7 +196,7 @@ sasl_ap_lookup( Operation *op, SlapReply *rs ) if ( sl->flags & SASL_AUXPROP_AUTHZID ) continue; /* Skip our private properties */ if ( !strcmp( name, slap_propnames[0] )) { - i += PROP_COUNT-1; + i += SLAP_SASL_PROP_COUNT - 1; continue; } name++; @@ -368,15 +209,18 @@ sasl_ap_lookup( Operation *op, SlapReply *rs ) ad = NULL; rc = slap_str2ad( name, &ad, &text ); if ( rc != LDAP_SUCCESS ) { -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, DETAIL1, - "slap_auxprop: str2ad(%s): %s\n", name, text, 0 ); -#else Debug( LDAP_DEBUG_TRACE, - "slap_auxprop: str2ad(%s): %s\n", name, text, 0 ); -#endif + "slap_ap_lookup: str2ad(%s): %s\n", name, text, 0 ); continue; } + + /* If it's the rootdn and a rootpw was present, we already set + * it so don't override it here. + */ + if ( ad == slap_schema.si_ad_userPassword && sl->list[i].values && + be_isroot_dn( op->o_bd, &op->o_req_ndn )) + continue; + a = attr_find( rs->sr_entry->e_attrs, ad ); if ( !a ) continue; if ( ! access_allowed( op, rs->sr_entry, ad, NULL, ACL_AUTH, NULL ) ) { @@ -387,6 +231,34 @@ sasl_ap_lookup( Operation *op, SlapReply *rs ) sl->list[i].name ); } for ( bv = a->a_vals; bv->bv_val; bv++ ) { + /* ITS#3846 don't give hashed passwords to SASL */ + if ( ad == slap_schema.si_ad_userPassword && + bv->bv_val[0] == '{' /*}*/ ) + { + if ( lutil_passwd_scheme( bv->bv_val ) ) { + /* If it's not a recognized scheme, just assume it's + * a cleartext password that happened to include brackets. + * + * If it's a recognized scheme, skip this value, unless the + * scheme is {CLEARTEXT}. In that case, skip over the + * scheme name and use the remainder. If there is nothing + * past the scheme name, skip this value. + */ +#ifdef SLAPD_CLEARTEXT + if ( !strncasecmp( bv->bv_val, sc_cleartext.bv_val, + sc_cleartext.bv_len )) { + struct berval cbv; + cbv.bv_len = bv->bv_len - sc_cleartext.bv_len; + if ( cbv.bv_len > 0 ) { + cbv.bv_val = bv->bv_val + sc_cleartext.bv_len; + sl->sparams->utils->prop_set( sl->sparams->propctx, + sl->list[i].name, cbv.bv_val, cbv.bv_len ); + } + } +#endif + continue; + } + } sl->sparams->utils->prop_set( sl->sparams->propctx, sl->list[i].name, bv->bv_val, bv->bv_len ); } @@ -394,7 +266,11 @@ sasl_ap_lookup( Operation *op, SlapReply *rs ) return LDAP_SUCCESS; } +#if SASL_VERSION_FULL >= 0x020118 +static int +#else static void +#endif slap_auxprop_lookup( void *glob_context, sasl_server_params_t *sparams, @@ -402,10 +278,16 @@ slap_auxprop_lookup( const char *user, unsigned ulen) { - Operation op = {0}; + OperationBuffer opbuf = {{ NULL }}; + Operation *op = (Operation *)&opbuf; int i, doit = 0; Connection *conn = NULL; lookup_info sl; + int rc = LDAP_SUCCESS; +#ifdef SLAP_AUXPROP_DONTUSECOPY + int dontUseCopy = 0; + BackendDB *dontUseCopy_bd = NULL; +#endif /* SLAP_AUXPROP_DONTUSECOPY */ sl.list = sparams->utils->prop_get( sparams->propctx ); sl.sparams = sparams; @@ -414,25 +296,47 @@ slap_auxprop_lookup( /* Find our DN and conn first */ for( i = 0; sl.list[i].name; i++ ) { if ( sl.list[i].name[0] == '*' ) { - if ( !strcmp( sl.list[i].name, slap_propnames[PROP_CONN] ) ) { + if ( !strcmp( sl.list[i].name, slap_propnames[SLAP_SASL_PROP_CONN] ) ) { if ( sl.list[i].values && sl.list[i].values[0] ) AC_MEMCPY( &conn, sl.list[i].values[0], sizeof( conn ) ); continue; } - if ( (flags & SASL_AUXPROP_AUTHZID) && - !strcmp( sl.list[i].name, slap_propnames[PROP_AUTHZ] ) ) { + if ( flags & SASL_AUXPROP_AUTHZID ) { + if ( !strcmp( sl.list[i].name, slap_propnames[SLAP_SASL_PROP_AUTHZLEN] )) { + if ( sl.list[i].values && sl.list[i].values[0] ) + AC_MEMCPY( &op->o_req_ndn.bv_len, sl.list[i].values[0], + sizeof( op->o_req_ndn.bv_len ) ); + } else if ( !strcmp( sl.list[i].name, slap_propnames[SLAP_SASL_PROP_AUTHZ] )) { + if ( sl.list[i].values ) + op->o_req_ndn.bv_val = (char *)sl.list[i].values[0]; + break; + } + } + if ( !strcmp( sl.list[i].name, slap_propnames[SLAP_SASL_PROP_AUTHCLEN] )) { if ( sl.list[i].values && sl.list[i].values[0] ) - AC_MEMCPY( &op.o_req_ndn, sl.list[i].values[0], sizeof( struct berval ) ); - break; - } - if ( !strcmp( sl.list[i].name, slap_propnames[PROP_AUTHC] ) ) { - if ( sl.list[i].values && sl.list[i].values[0] ) { - AC_MEMCPY( &op.o_req_ndn, sl.list[i].values[0], sizeof( struct berval ) ); + AC_MEMCPY( &op->o_req_ndn.bv_len, sl.list[i].values[0], + sizeof( op->o_req_ndn.bv_len ) ); + } else if ( !strcmp( sl.list[i].name, slap_propnames[SLAP_SASL_PROP_AUTHC] ) ) { + if ( sl.list[i].values ) { + op->o_req_ndn.bv_val = (char *)sl.list[i].values[0]; if ( !(flags & SASL_AUXPROP_AUTHZID) ) break; } } +#ifdef SLAP_AUXPROP_DONTUSECOPY + if ( slap_dontUseCopy_propnames != NULL ) { + int j; + struct berval bv; + ber_str2bv( &sl.list[i].name[1], 0, 1, &bv ); + for ( j = 0; !BER_BVISNULL( &slap_dontUseCopy_propnames[ j ]); j++ ) { + if ( bvmatch( &bv, &slap_dontUseCopy_propnames[ j ] ) ) { + dontUseCopy = 1; + break; + } + } + } +#endif /* SLAP_AUXPROP_DONTUSECOPY */ } } @@ -444,7 +348,7 @@ slap_auxprop_lookup( if ( flags & SASL_AUXPROP_AUTHZID ) continue; /* Skip our private properties */ if ( !strcmp( name, slap_propnames[0] )) { - i += PROP_COUNT-1; + i += SLAP_SASL_PROP_COUNT - 1; continue; } name++; @@ -463,32 +367,135 @@ slap_auxprop_lookup( cb.sc_private = &sl; - op.o_bd = select_backend( &op.o_req_ndn, 0, 1 ); + op->o_bd = select_backend( &op->o_req_ndn, 1 ); + + if ( op->o_bd ) { + /* For rootdn, see if we can use the rootpw */ + if ( be_isroot_dn( op->o_bd, &op->o_req_ndn ) && + !BER_BVISEMPTY( &op->o_bd->be_rootpw )) { + struct berval cbv = BER_BVNULL; + + /* If there's a recognized scheme, see if it's CLEARTEXT */ + if ( lutil_passwd_scheme( op->o_bd->be_rootpw.bv_val )) { + if ( !strncasecmp( op->o_bd->be_rootpw.bv_val, + sc_cleartext.bv_val, sc_cleartext.bv_len )) { + + /* If it's CLEARTEXT, skip past scheme spec */ + cbv.bv_len = op->o_bd->be_rootpw.bv_len - + sc_cleartext.bv_len; + if ( cbv.bv_len ) { + cbv.bv_val = op->o_bd->be_rootpw.bv_val + + sc_cleartext.bv_len; + } + } + /* No scheme, use the whole value */ + } else { + cbv = op->o_bd->be_rootpw; + } + if ( !BER_BVISEMPTY( &cbv )) { + for( i = 0; sl.list[i].name; i++ ) { + const char *name = sl.list[i].name; + + if ( name[0] == '*' ) { + if ( flags & SASL_AUXPROP_AUTHZID ) continue; + name++; + } else if ( !(flags & SASL_AUXPROP_AUTHZID ) ) + continue; + + if ( !strcasecmp(name,"userPassword") ) { + sl.sparams->utils->prop_set( sl.sparams->propctx, + sl.list[i].name, cbv.bv_val, cbv.bv_len ); + break; + } + } + } + } - if ( op.o_bd && op.o_bd->be_search ) { - SlapReply rs = {REP_RESULT}; - op.o_tag = LDAP_REQ_SEARCH; - op.o_protocol = LDAP_VERSION3; - op.o_ndn = conn->c_ndn; - op.o_callback = &cb; - op.o_time = slap_get_time(); - op.o_do_not_cache = 1; - op.o_is_auth_check = 1; - op.o_threadctx = conn->c_sasl_bindop->o_threadctx; - op.o_tmpmemctx = conn->c_sasl_bindop->o_tmpmemctx; - op.o_tmpmfuncs = conn->c_sasl_bindop->o_tmpmfuncs; - op.o_conn = conn; - op.o_connid = conn->c_connid; - op.o_req_dn = op.o_req_ndn; - op.ors_scope = LDAP_SCOPE_BASE; - op.ors_deref = LDAP_DEREF_NEVER; - op.ors_slimit = 1; - op.ors_filter = &generic_filter; - op.ors_filterstr = generic_filterstr; +#ifdef SLAP_AUXPROP_DONTUSECOPY + if ( SLAP_SHADOW( op->o_bd ) && dontUseCopy ) { + dontUseCopy_bd = op->o_bd; + op->o_bd = frontendDB; + } - op.o_bd->be_search( &op, &rs ); +retry_dontUseCopy:; +#endif /* SLAP_AUXPROP_DONTUSECOPY */ + + if ( op->o_bd->be_search ) { + SlapReply rs = {REP_RESULT}; +#ifdef SLAP_AUXPROP_DONTUSECOPY + LDAPControl **save_ctrls = NULL, c; + int save_dontUseCopy; +#endif /* SLAP_AUXPROP_DONTUSECOPY */ + + op->o_hdr = conn->c_sasl_bindop->o_hdr; + op->o_controls = opbuf.ob_controls; + op->o_tag = LDAP_REQ_SEARCH; + op->o_dn = conn->c_ndn; + op->o_ndn = conn->c_ndn; + op->o_callback = &cb; + slap_op_time( &op->o_time, &op->o_tincr ); + op->o_do_not_cache = 1; + op->o_is_auth_check = 1; + op->o_req_dn = op->o_req_ndn; + op->ors_scope = LDAP_SCOPE_BASE; + op->ors_deref = LDAP_DEREF_NEVER; + op->ors_tlimit = SLAP_NO_LIMIT; + op->ors_slimit = 1; + op->ors_filter = &generic_filter; + op->ors_filterstr = generic_filterstr; + op->o_authz = conn->c_authz; + /* FIXME: we want all attributes, right? */ + op->ors_attrs = NULL; + +#ifdef SLAP_AUXPROP_DONTUSECOPY + if ( dontUseCopy ) { + save_dontUseCopy = op->o_dontUseCopy; + if ( !op->o_dontUseCopy ) { + int cnt = 0; + save_ctrls = op->o_ctrls; + if ( op->o_ctrls ) { + for ( ; op->o_ctrls[ cnt ]; cnt++ ) + ; + } + op->o_ctrls = op->o_tmpcalloc( sizeof(LDAPControl *), cnt + 2, op->o_tmpmemctx ); + if ( cnt ) { + for ( cnt = 0; save_ctrls[ cnt ]; cnt++ ) { + op->o_ctrls[ cnt ] = save_ctrls[ cnt ]; + } + } + c.ldctl_oid = LDAP_CONTROL_DONTUSECOPY; + c.ldctl_iscritical = 1; + BER_BVZERO( &c.ldctl_value ); + op->o_ctrls[ cnt ] = &c; + } + op->o_dontUseCopy = SLAP_CONTROL_CRITICAL; + } +#endif /* SLAP_AUXPROP_DONTUSECOPY */ + + rc = op->o_bd->be_search( op, &rs ); + +#ifdef SLAP_AUXPROP_DONTUSECOPY + if ( dontUseCopy ) { + if ( save_ctrls != op->o_ctrls ) { + op->o_tmpfree( op->o_ctrls, op->o_tmpmemctx ); + op->o_ctrls = save_ctrls; + op->o_dontUseCopy = save_dontUseCopy; + } + + if ( rs.sr_err == LDAP_UNAVAILABLE && slap_dontUseCopy_ignore ) + { + op->o_bd = dontUseCopy_bd; + dontUseCopy = 0; + goto retry_dontUseCopy; + } + } +#endif /* SLAP_AUXPROP_DONTUSECOPY */ + } } } +#if SASL_VERSION_FULL >= 0x020118 + return rc != LDAP_SUCCESS ? SASL_FAIL : SASL_OK; +#endif } #if SASL_VERSION_FULL >= 0x020110 @@ -501,8 +508,10 @@ slap_auxprop_store( unsigned ulen) { Operation op = {0}; + Opheader oph; SlapReply rs = {REP_RESULT}; - int rc, i, j; + int rc, i; + unsigned j; Connection *conn = NULL; const struct propval *pr; Modifications *modlist = NULL, **modtail = &modlist, *mod; @@ -510,6 +519,10 @@ slap_auxprop_store( char textbuf[SLAP_TEXT_BUFLEN]; const char *text; size_t textlen = sizeof(textbuf); +#ifdef SLAP_AUXPROP_DONTUSECOPY + int dontUseCopy = 0; + BackendDB *dontUseCopy_bd = NULL; +#endif /* SLAP_AUXPROP_DONTUSECOPY */ /* just checking if we are enabled */ if (!prctx) return SASL_OK; @@ -521,24 +534,47 @@ slap_auxprop_store( /* Find our DN and conn first */ for( i = 0; pr[i].name; i++ ) { if ( pr[i].name[0] == '*' ) { - if ( !strcmp( pr[i].name, slap_propnames[PROP_CONN] ) ) { + if ( !strcmp( pr[i].name, slap_propnames[SLAP_SASL_PROP_CONN] ) ) { if ( pr[i].values && pr[i].values[0] ) AC_MEMCPY( &conn, pr[i].values[0], sizeof( conn ) ); continue; } - if ( !strcmp( pr[i].name, slap_propnames[PROP_AUTHC] ) ) { - if ( pr[i].values && pr[i].values[0] ) { - AC_MEMCPY( &op.o_req_ndn, pr[i].values[0], sizeof( struct berval ) ); + if ( !strcmp( pr[i].name, slap_propnames[SLAP_SASL_PROP_AUTHCLEN] )) { + if ( pr[i].values && pr[i].values[0] ) + AC_MEMCPY( &op.o_req_ndn.bv_len, pr[i].values[0], + sizeof( op.o_req_ndn.bv_len ) ); + } else if ( !strcmp( pr[i].name, slap_propnames[SLAP_SASL_PROP_AUTHC] ) ) { + if ( pr[i].values ) + op.o_req_ndn.bv_val = (char *)pr[i].values[0]; + } +#ifdef SLAP_AUXPROP_DONTUSECOPY + { + struct berval bv; + ber_str2bv( &pr[i].name[1], 0, 1, &bv ); + for ( j = 0; !BER_BVISNULL( &slap_dontUseCopy_propnames[ j ] ); j++ ) { + if ( bvmatch( &bv, &slap_dontUseCopy_propnames[ j ] ) ) { + dontUseCopy = 1; + break; + } } } +#endif /* SLAP_AUXPROP_DONTUSECOPY */ } } if (!conn || !op.o_req_ndn.bv_val) return SASL_BADPARAM; - op.o_bd = select_backend( &op.o_req_ndn, 0, 1 ); + op.o_bd = select_backend( &op.o_req_ndn, 1 ); if ( !op.o_bd || !op.o_bd->be_modify ) return SASL_FAIL; - + +#ifdef SLAP_AUXPROP_DONTUSECOPY + if ( SLAP_SHADOW( op.o_bd ) && dontUseCopy ) { + dontUseCopy_bd = op.o_bd; + op.o_bd = frontendDB; + op.o_dontUseCopy = SLAP_CONTROL_CRITICAL; + } +#endif /* SLAP_AUXPROP_DONTUSECOPY */ + pr = sparams->utils->prop_get( prctx ); if (!pr) return SASL_BADPARAM; @@ -548,7 +584,9 @@ slap_auxprop_store( for (i=0; pr[i].name; i++) { mod = (Modifications *)ch_malloc( sizeof(Modifications) ); mod->sml_op = LDAP_MOD_REPLACE; + mod->sml_flags = 0; ber_str2bv( pr[i].name, 0, 0, &mod->sml_type ); + mod->sml_numvals = pr[i].nvalues; mod->sml_values = (struct berval *)ch_malloc( (pr[i].nvalues + 1) * sizeof(struct berval)); for (j=0; jc_sasl_bindop->o_threadctx; - op.o_tmpmemctx = conn->c_sasl_bindop->o_tmpmemctx; - op.o_tmpmfuncs = conn->c_sasl_bindop->o_tmpmfuncs; - op.o_conn = conn; - op.o_connid = conn->c_connid; - op.o_req_dn = op.o_req_ndn; - op.orm_modlist = modlist; - - rc = op.o_bd->be_modify( &op, &rs ); - } - slap_mods_free( modlist ); - return rc ? SASL_FAIL : SASL_OK; + if ( rc == LDAP_SUCCESS ) { + if ( conn->c_sasl_bindop ) { + op.o_hdr = conn->c_sasl_bindop->o_hdr; + } else { + op.o_hdr = &oph; + memset( &oph, 0, sizeof(oph) ); + operation_fake_init( conn, &op, ldap_pvt_thread_pool_context(), 0 ); + } + op.o_tag = LDAP_REQ_MODIFY; + op.o_ndn = op.o_req_ndn; + op.o_callback = &cb; + slap_op_time( &op.o_time, &op.o_tincr ); + op.o_do_not_cache = 1; + op.o_is_auth_check = 1; + op.o_req_dn = op.o_req_ndn; + op.orm_modlist = modlist; + +retry_dontUseCopy:; + rc = op.o_bd->be_modify( &op, &rs ); + +#ifdef SLAP_AUXPROP_DONTUSECOPY + if ( dontUseCopy && + rs.sr_err == LDAP_UNAVAILABLE && + slap_dontUseCopy_ignore ) + { + op.o_bd = dontUseCopy_bd; + op.o_dontUseCopy = SLAP_CONTROL_NONE; + dontUseCopy = 0; + goto retry_dontUseCopy; + } +#endif /* SLAP_AUXPROP_DONTUSECOPY */ + } + } + slap_mods_free( modlist, 1 ); + return rc != LDAP_SUCCESS ? SASL_FAIL : SASL_OK; } #endif /* SASL_VERSION_FULL >= 2.1.16 */ @@ -644,7 +696,7 @@ slap_sasl_canonicalize( { Connection *conn = (Connection *)context; struct propctx *props = sasl_auxprop_getctx( sconn ); - struct propval auxvals[3]; + struct propval auxvals[ SLAP_SASL_PROP_COUNT ] = { { 0 } }; struct berval dn; int rc, which; const char *names[2]; @@ -652,18 +704,10 @@ slap_sasl_canonicalize( *out_len = 0; -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ENTRY, - "slap_sasl_canonicalize: conn %d %s=\"%s\"\n", - conn ? conn->c_connid : -1, - (flags & SASL_CU_AUTHID) ? "authcid" : "authzid", - in ? in : ""); -#else Debug( LDAP_DEBUG_ARGS, "SASL Canonicalize [conn=%ld]: %s=\"%s\"\n", - conn ? conn->c_connid : -1, + conn ? (long) conn->c_connid : -1L, (flags & SASL_CU_AUTHID) ? "authcid" : "authzid", in ? in : ""); -#endif /* If name is too big, just truncate. We don't care, we're * using DNs, not the usernames. @@ -685,13 +729,13 @@ slap_sasl_canonicalize( prop_request( props, slap_propnames ); if ( flags & SASL_CU_AUTHID ) - which = PROP_AUTHC; + which = SLAP_SASL_PROP_AUTHCLEN; else - which = PROP_AUTHZ; + which = SLAP_SASL_PROP_AUTHZLEN; /* Need to store the Connection for auxprop_lookup */ - if ( !auxvals[PROP_CONN].values ) { - names[0] = slap_propnames[PROP_CONN]; + if ( !auxvals[SLAP_SASL_PROP_CONN].values ) { + names[0] = slap_propnames[SLAP_SASL_PROP_CONN]; names[1] = NULL; prop_set( props, names[0], (char *)&conn, sizeof( conn ) ); } @@ -715,8 +759,9 @@ slap_sasl_canonicalize( * it does authzID before the authcID. If we see that authzID * has already been done, don't do anything special with authcID. */ - if ( flags == SASL_CU_AUTHID && !auxvals[PROP_AUTHZ].values ) { + if ( flags == SASL_CU_AUTHID && !auxvals[SLAP_SASL_PROP_AUTHZ].values ) { conn->c_sasl_dn.bv_val = (char *) in; + conn->c_sasl_dn.bv_len = 0; } else if ( flags == SASL_CU_AUTHZID && conn->c_sasl_dn.bv_val ) { rc = strcmp( in, conn->c_sasl_dn.bv_val ); conn->c_sasl_dn.bv_val = NULL; @@ -731,23 +776,23 @@ slap_sasl_canonicalize( if ( rc != LDAP_SUCCESS ) { sasl_seterror( sconn, 0, ldap_err2string( rc ) ); return SASL_NOAUTHZ; - } + } names[0] = slap_propnames[which]; names[1] = NULL; + prop_set( props, names[0], (char *)&dn.bv_len, sizeof( dn.bv_len ) ); + + which++; + names[0] = slap_propnames[which]; + prop_set( props, names[0], dn.bv_val, dn.bv_len ); - prop_set( props, names[0], (char *)&dn, sizeof( dn ) ); - -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ENTRY, - "slap_sasl_canonicalize: conn %d %s=\"%s\"\n", - conn ? conn->c_connid : -1, names[0]+1, - dn.bv_val ? dn.bv_val : "" ); -#else Debug( LDAP_DEBUG_ARGS, "SASL Canonicalize [conn=%ld]: %s=\"%s\"\n", - conn ? conn->c_connid : -1, names[0]+1, + conn ? (long) conn->c_connid : -1L, names[0]+1, dn.bv_val ? dn.bv_val : "" ); -#endif + + /* Not needed any more, SASL has copied it */ + if ( conn && conn->c_sasl_bindop ) + conn->c_sasl_bindop->o_tmpfree( dn.bv_val, conn->c_sasl_bindop->o_tmpmemctx ); done: AC_MEMCPY( out, in, inlen ); @@ -771,29 +816,26 @@ slap_sasl_authorize( struct propctx *props) { Connection *conn = (Connection *)context; - struct propval auxvals[3]; - struct berval authcDN, authzDN; + /* actually: + * (SLAP_SASL_PROP_COUNT - 1) because we skip "conn", + * + 1 for NULL termination? + */ + struct propval auxvals[ SLAP_SASL_PROP_COUNT ] = { { 0 } }; + struct berval authcDN, authzDN = BER_BVNULL; int rc; /* Simple Binds don't support proxy authorization, ignore it */ if ( !conn->c_sasl_bindop || conn->c_sasl_bindop->orb_method != LDAP_AUTH_SASL ) return SASL_OK; -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ENTRY, - "slap_sasl_authorize: conn %d authcid=\"%s\" authzid=\"%s\"\n", - conn ? conn->c_connid : -1, auth_identity, requested_user); -#else Debug( LDAP_DEBUG_ARGS, "SASL proxy authorize [conn=%ld]: " "authcid=\"%s\" authzid=\"%s\"\n", - conn ? conn->c_connid : -1, auth_identity, requested_user ); -#endif + conn ? (long) conn->c_connid : -1L, auth_identity, requested_user ); if ( conn->c_sasl_dn.bv_val ) { - ch_free( conn->c_sasl_dn.bv_val ); BER_BVZERO( &conn->c_sasl_dn ); } - /* Skip PROP_CONN */ + /* Skip SLAP_SASL_PROP_CONN */ prop_getnames( props, slap_propnames+1, auxvals ); /* Should not happen */ @@ -802,185 +844,64 @@ slap_sasl_authorize( return SASL_NOAUTHZ; } - AC_MEMCPY( &authcDN, auxvals[0].values[0], sizeof(authcDN) ); + AC_MEMCPY( &authcDN.bv_len, auxvals[0].values[0], sizeof(authcDN.bv_len) ); + authcDN.bv_val = auxvals[1].values ? (char *)auxvals[1].values[0] : NULL; + conn->c_sasl_dn = authcDN; /* Nothing to do if no authzID was given */ - if ( !auxvals[1].name || !auxvals[1].values ) { - conn->c_sasl_dn = authcDN; + if ( !auxvals[2].name || !auxvals[2].values ) { goto ok; } - AC_MEMCPY( &authzDN, auxvals[1].values[0], sizeof(authzDN) ); + AC_MEMCPY( &authzDN.bv_len, auxvals[2].values[0], sizeof(authzDN.bv_len) ); + authzDN.bv_val = auxvals[3].values ? (char *)auxvals[3].values[0] : NULL; rc = slap_sasl_authorized( conn->c_sasl_bindop, &authcDN, &authzDN ); - ch_free( authcDN.bv_val ); if ( rc != LDAP_SUCCESS ) { -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, INFO, - "slap_sasl_authorize: conn %ld " - "proxy authorization disallowed (%d)\n", - (long)(conn ? conn->c_connid : -1), rc, 0 ); -#else Debug( LDAP_DEBUG_TRACE, "SASL Proxy Authorize [conn=%ld]: " "proxy authorization disallowed (%d)\n", - (long) (conn ? conn->c_connid : -1), rc, 0 ); -#endif + conn ? (long) conn->c_connid : -1L, rc, 0 ); sasl_seterror( sconn, 0, "not authorized" ); - ch_free( authzDN.bv_val ); return SASL_NOAUTHZ; } - conn->c_sasl_dn = authzDN; + /* FIXME: we need yet another dup because slap_sasl_getdn() + * is using the bind operation slab */ + ber_dupbv( &conn->c_sasl_authz_dn, &authzDN ); + ok: if (conn->c_sasl_bindop) { Statslog( LDAP_DEBUG_STATS, - "conn=%lu op=%lu BIND authcid=\"%s\"\n", - conn->c_connid, conn->c_sasl_bindop->o_opid, - auth_identity, 0, 0); + "%s BIND authcid=\"%s\" authzid=\"%s\"\n", + conn->c_sasl_bindop->o_log_prefix, + auth_identity, requested_user, 0, 0 ); } -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ENTRY, - "slap_sasl_authorize: conn %d proxy authorization allowed\n", - (long)(conn ? conn->c_connid : -1), 0, 0 ); -#else Debug( LDAP_DEBUG_TRACE, "SASL Authorize [conn=%ld]: " - " proxy authorization allowed\n", - (long) (conn ? conn->c_connid : -1), 0, 0 ); -#endif + " proxy authorization allowed authzDN=\"%s\"\n", + conn ? (long) conn->c_connid : -1L, + authzDN.bv_val ? authzDN.bv_val : "", 0 ); return SASL_OK; } -#else -static int -slap_sasl_authorize( - void *context, - char *authcid, - char *authzid, - const char **user, - const char **errstr) -{ - struct berval authcDN, authzDN; - int rc; - Connection *conn = context; - char *realm; - struct berval bvauthcid, bvauthzid; - - *user = NULL; - if ( conn->c_sasl_dn.bv_val ) { - ch_free( conn->c_sasl_dn.bv_val ); - BER_BVZERO( &conn->c_sasl_dn ); - } - -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ENTRY, - "slap_sasl_authorize: conn %d authcid=\"%s\" authzid=\"%s\"\n", - conn ? conn->c_connid : -1, authcid ? authcid : "", - authzid ? authzid : "" ); -#else - Debug( LDAP_DEBUG_ARGS, "SASL Authorize [conn=%ld]: " - "authcid=\"%s\" authzid=\"%s\"\n", - (long) (conn ? conn->c_connid : -1), - authcid ? authcid : "", - authzid ? authzid : "" ); -#endif - - /* Figure out how much data we have for the dn */ - rc = sasl_getprop( conn->c_sasl_authctx, SASL_REALM, (void **)&realm ); - if( rc != SASL_OK && rc != SASL_NOTDONE ) { -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ERR, - "slap_sasl_authorize: getprop(REALM) failed.\n", 0, 0, 0 ); -#else - Debug(LDAP_DEBUG_TRACE, - "authorize: getprop(REALM) failed!\n", 0,0,0); -#endif - *errstr = "Could not extract realm"; - return SASL_NOAUTHZ; - } - - /* Convert the identities to DN's. If no authzid was given, client will - be bound as the DN matching their username */ - bvauthcid.bv_val = authcid; - bvauthcid.bv_len = authcid ? strlen( authcid ) : 0; - rc = slap_sasl_getdn( conn, NULL, &bvauthcid, realm, - &authcDN, SLAP_GETDN_AUTHCID ); - if( rc != LDAP_SUCCESS ) { - *errstr = ldap_err2string( rc ); - return SASL_NOAUTHZ; - } - if( ( authzid == NULL ) || !strcmp( authcid, authzid ) ) { -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ENTRY, - "slap_sasl_authorize: conn %d Using authcDN=%s\n", - conn ? conn->c_connid : -1, authcDN.bv_val, 0 ); -#else - Debug( LDAP_DEBUG_TRACE, "SASL Authorize [conn=%ld]: " - "Using authcDN=%s\n", (long) (conn ? conn->c_connid : -1), authcDN.bv_val,0 ); -#endif - - conn->c_sasl_dn = authcDN; - goto ok; - } - - bvauthzid.bv_val = authzid; - bvauthzid.bv_len = authzid ? strlen( authzid ) : 0; - rc = slap_sasl_getdn( conn, NULL, &bvauthzid, realm, - &authzDN, SLAP_GETDN_AUTHZID ); - if( rc != LDAP_SUCCESS ) { - ch_free( authcDN.bv_val ); - *errstr = ldap_err2string( rc ); - return SASL_NOAUTHZ; - } - - rc = slap_sasl_authorized(conn->c_sasl_bindop, &authcDN, &authzDN ); - ch_free( authcDN.bv_val ); - if( rc ) { -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, INFO, - "slap_sasl_authorize: conn %ld " - "proxy authorization disallowed (%d)\n", - (long)(conn ? conn->c_connid : -1), rc, 0 ); -#else - Debug( LDAP_DEBUG_TRACE, "SASL Authorize [conn=%ld]: " - "proxy authorization disallowed (%d)\n", - (long) (conn ? conn->c_connid : -1), rc, 0 ); -#endif - - *errstr = "not authorized"; - ch_free( authzDN.bv_val ); - return SASL_NOAUTHZ; - } - conn->c_sasl_dn = authzDN; - -ok: -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, RESULTS, - "slap_sasl_authorize: conn %d proxy authorization allowed\n", - (long)(conn ? conn->c_connid : -1 ), 0, 0 ); -#else - Debug( LDAP_DEBUG_TRACE, "SASL Authorize [conn=%ld]: " - " authorization allowed\n", - (long) (conn ? conn->c_connid : -1), 0, 0 ); -#endif - - if (conn->c_sasl_bindop) { - Statslog( LDAP_DEBUG_STATS, - "conn=%lu op=%lu BIND authcid=\"%s\"\n", - conn->c_connid, conn->c_sasl_bindop->o_opid, - authcid, 0, 0); - } - - *errstr = NULL; - return SASL_OK; -} -#endif /* SASL_VERSION_MAJOR >= 2 */ static int slap_sasl_err2ldap( int saslerr ) { int rc; + /* map SASL errors to LDAP resultCode returned by: + * sasl_server_new() + * SASL_OK, SASL_NOMEM + * sasl_server_step() + * SASL_OK, SASL_CONTINUE, SASL_TRANS, SASL_BADPARAM, SASL_BADPROT, + * ... + * sasl_server_start() + * + SASL_NOMECH + * sasl_setprop() + * SASL_OK, SASL_BADPARAM + */ + switch (saslerr) { case SASL_OK: rc = LDAP_SUCCESS; @@ -989,8 +910,6 @@ slap_sasl_err2ldap( int saslerr ) rc = LDAP_SASL_BIND_IN_PROGRESS; break; case SASL_FAIL: - rc = LDAP_OTHER; - break; case SASL_NOMEM: rc = LDAP_OTHER; break; @@ -998,6 +917,9 @@ slap_sasl_err2ldap( int saslerr ) rc = LDAP_AUTH_METHOD_NOT_SUPPORTED; break; case SASL_BADAUTH: + case SASL_NOUSER: + case SASL_TRANS: + case SASL_EXPIRED: rc = LDAP_INVALID_CREDENTIALS; break; case SASL_NOAUTHZ: @@ -1007,6 +929,13 @@ slap_sasl_err2ldap( int saslerr ) case SASL_ENCRYPT: rc = LDAP_INAPPROPRIATE_AUTH; break; + case SASL_UNAVAIL: + case SASL_TRYAGAIN: + rc = LDAP_UNAVAILABLE; + break; + case SASL_DISABLED: + rc = LDAP_UNWILLING_TO_PERFORM; + break; default: rc = LDAP_OTHER; break; @@ -1014,6 +943,283 @@ slap_sasl_err2ldap( int saslerr ) return rc; } + +#ifdef SLAPD_SPASSWD + +static struct berval sasl_pwscheme = BER_BVC("{SASL}"); + +static int chk_sasl( + const struct berval *sc, + const struct berval * passwd, + const struct berval * cred, + const char **text ) +{ + unsigned int i; + int rtn; + void *ctx, *sconn = NULL; + + for( i=0; ibv_len; i++) { + if(cred->bv_val[i] == '\0') { + return LUTIL_PASSWD_ERR; /* NUL character in password */ + } + } + + if( cred->bv_val[i] != '\0' ) { + return LUTIL_PASSWD_ERR; /* cred must behave like a string */ + } + + for( i=0; ibv_len; i++) { + if(passwd->bv_val[i] == '\0') { + return LUTIL_PASSWD_ERR; /* NUL character in password */ + } + } + + if( passwd->bv_val[i] != '\0' ) { + return LUTIL_PASSWD_ERR; /* passwd must behave like a string */ + } + + rtn = LUTIL_PASSWD_ERR; + + ctx = ldap_pvt_thread_pool_context(); + ldap_pvt_thread_pool_getkey( ctx, (void *)slap_sasl_bind, &sconn, NULL ); + + if( sconn != NULL ) { + int sc; + sc = sasl_checkpass( sconn, + passwd->bv_val, passwd->bv_len, + cred->bv_val, cred->bv_len ); + rtn = ( sc != SASL_OK ) ? LUTIL_PASSWD_ERR : LUTIL_PASSWD_OK; + } + + return rtn; +} +#endif /* SLAPD_SPASSWD */ + +#endif /* HAVE_CYRUS_SASL */ + +#ifdef ENABLE_REWRITE + +typedef struct slapd_map_data { + struct berval base; + struct berval filter; + AttributeName attrs[2]; + int scope; +} slapd_map_data; + +static void * +slapd_rw_config( const char *fname, int lineno, int argc, char **argv ) +{ + slapd_map_data *ret = NULL; + LDAPURLDesc *lud = NULL; + char *uri; + AttributeDescription *ad = NULL; + int rc, flen = 0; + struct berval dn, ndn; + + if ( argc != 1 ) { + Debug( LDAP_DEBUG_ANY, + "[%s:%d] slapd map needs URI\n", + fname, lineno, 0 ); + return NULL; + } + + uri = argv[0]; + if ( strncasecmp( uri, "uri=", STRLENOF( "uri=" ) ) == 0 ) { + uri += STRLENOF( "uri=" ); + } + + if ( ldap_url_parse( uri, &lud ) != LDAP_URL_SUCCESS ) { + Debug( LDAP_DEBUG_ANY, + "[%s:%d] illegal URI '%s'\n", + fname, lineno, uri ); + return NULL; + } + + if ( strcasecmp( lud->lud_scheme, "ldap" )) { + Debug( LDAP_DEBUG_ANY, + "[%s:%d] illegal URI scheme '%s'\n", + fname, lineno, lud->lud_scheme ); + goto done; + } + + if (( lud->lud_host && lud->lud_host[0] ) || lud->lud_exts + || !lud->lud_dn ) { + Debug( LDAP_DEBUG_ANY, + "[%s:%d] illegal URI '%s'\n", + fname, lineno, uri ); + goto done; + } + + if ( lud->lud_attrs ) { + if ( lud->lud_attrs[1] ) { + Debug( LDAP_DEBUG_ANY, + "[%s:%d] only one attribute allowed in URI\n", + fname, lineno, 0 ); + goto done; + } + if ( strcasecmp( lud->lud_attrs[0], "dn" ) && + strcasecmp( lud->lud_attrs[0], "entryDN" )) { + const char *text; + rc = slap_str2ad( lud->lud_attrs[0], &ad, &text ); + if ( rc ) + goto done; + } + } + ber_str2bv( lud->lud_dn, 0, 0, &dn ); + if ( dnNormalize( 0, NULL, NULL, &dn, &ndn, NULL )) + goto done; + + if ( lud->lud_filter ) { + flen = strlen( lud->lud_filter ) + 1; + } + ret = ch_malloc( sizeof( slapd_map_data ) + flen ); + ret->base = ndn; + if ( flen ) { + ret->filter.bv_val = (char *)(ret+1); + ret->filter.bv_len = flen - 1; + strcpy( ret->filter.bv_val, lud->lud_filter ); + } else { + BER_BVZERO( &ret->filter ); + } + ret->scope = lud->lud_scope; + if ( ad ) { + ret->attrs[0].an_name = ad->ad_cname; + } else { + BER_BVZERO( &ret->attrs[0].an_name ); + } + ret->attrs[0].an_desc = ad; + BER_BVZERO( &ret->attrs[1].an_name ); +done: + ldap_free_urldesc( lud ); + return ret; +} + +struct slapd_rw_info { + slapd_map_data *si_data; + struct berval si_val; +}; + +static int +slapd_rw_cb( Operation *op, SlapReply *rs ) +{ + if ( rs->sr_type == REP_SEARCH ) { + struct slapd_rw_info *si = op->o_callback->sc_private; + + if ( si->si_data->attrs[0].an_desc ) { + Attribute *a; + + a = attr_find( rs->sr_entry->e_attrs, + si->si_data->attrs[0].an_desc ); + if ( a ) { + ber_dupbv( &si->si_val, a->a_vals ); + } + } else { + ber_dupbv( &si->si_val, &rs->sr_entry->e_name ); + } + } + return LDAP_SUCCESS; +} + +static int +slapd_rw_apply( void *private, const char *filter, struct berval *val ) +{ + slapd_map_data *sl = private; + slap_callback cb = { NULL }; + Connection conn = {0}; + OperationBuffer opbuf; + Operation *op; + void *thrctx; + SlapReply rs = {REP_RESULT}; + struct slapd_rw_info si; + char *ptr; + int rc; + + thrctx = ldap_pvt_thread_pool_context(); + connection_fake_init2( &conn, &opbuf, thrctx, 0 ); + op = &opbuf.ob_op; + + op->o_tag = LDAP_REQ_SEARCH; + op->o_req_dn = op->o_req_ndn = sl->base; + op->o_bd = select_backend( &op->o_req_ndn, 1 ); + if ( !op->o_bd ) { + return REWRITE_ERR; + } + si.si_data = sl; + BER_BVZERO( &si.si_val ); + op->ors_scope = sl->scope; + op->ors_deref = LDAP_DEREF_NEVER; + op->ors_slimit = 1; + op->ors_tlimit = SLAP_NO_LIMIT; + if ( sl->attrs[0].an_desc ) { + op->ors_attrs = sl->attrs; + } else { + op->ors_attrs = slap_anlist_no_attrs; + } + if ( filter ) { + rc = strlen( filter ); + } else { + rc = 0; + } + rc += sl->filter.bv_len; + ptr = op->ors_filterstr.bv_val = op->o_tmpalloc( rc + 1, op->o_tmpmemctx ); + if ( sl->filter.bv_len ) { + ptr = lutil_strcopy( ptr, sl->filter.bv_val ); + } else { + *ptr = '\0'; + } + if ( filter ) { + strcpy( ptr, filter ); + } + op->ors_filter = str2filter_x( op, op->ors_filterstr.bv_val ); + if ( !op->ors_filter ) { + op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx ); + return REWRITE_ERR; + } + + op->ors_attrsonly = 0; + op->o_dn = op->o_bd->be_rootdn; + op->o_ndn = op->o_bd->be_rootndn; + op->o_do_not_cache = 1; + + cb.sc_response = slapd_rw_cb; + cb.sc_private = &si; + op->o_callback = &cb; + + rc = op->o_bd->be_search( op, &rs ); + if ( rc == LDAP_SUCCESS && !BER_BVISNULL( &si.si_val )) { + *val = si.si_val; + rc = REWRITE_SUCCESS; + } else { + if ( !BER_BVISNULL( &si.si_val )) { + ch_free( si.si_val.bv_val ); + } + rc = REWRITE_ERR; + } + filter_free_x( op, op->ors_filter, 1 ); + op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx ); + return rc; +} + +static int +slapd_rw_destroy( void *private ) +{ + slapd_map_data *md = private; + + assert( private != NULL ); + + ch_free( md->base.bv_val ); + ch_free( md->filter.bv_val ); + ch_free( md ); + + return 0; +} + +static const rewrite_mapper slapd_mapper = { + "slapd", + slapd_rw_config, + slapd_rw_apply, + slapd_rw_destroy +}; #endif int slap_sasl_init( void ) @@ -1022,9 +1228,16 @@ int slap_sasl_init( void ) int rc; static sasl_callback_t server_callbacks[] = { { SASL_CB_LOG, &slap_sasl_log, NULL }, + { SASL_CB_GETOPT, &slap_sasl_getopt, NULL }, { SASL_CB_LIST_END, NULL, NULL } }; +#endif +#ifdef ENABLE_REWRITE + rewrite_mapper_register( &slapd_mapper ); +#endif + +#ifdef HAVE_CYRUS_SASL #ifdef HAVE_SASL_VERSION /* stringify the version number, sasl.h doesn't do it for us */ #define VSTR0(maj, min, pat) #maj "." #min "." #pat @@ -1039,66 +1252,45 @@ int slap_sasl_init( void ) char version[sizeof("xxx.xxx.xxxxx")]; sprintf( version, "%u.%d.%d", (unsigned)rc >> 24, (rc >> 16) & 0xff, rc & 0xffff ); -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, INFO, - "slap_sasl_init: SASL library version mismatch:" - " expected " SASL_VERSION_STRING "," - " got %s\n", version, 0, 0 ); -#else - Debug( LDAP_DEBUG_ANY, - "slap_sasl_init: SASL library version mismatch:" - " expected " SASL_VERSION_STRING "," - " got %s\n", version, 0, 0 ); -#endif + Debug( LDAP_DEBUG_ANY, "slap_sasl_init: SASL library version mismatch:" + " expected %s, got %s\n", + SASL_VERSION_STRING, version, 0 ); return -1; } #endif - /* SASL 2 does its own memory management internally */ -#if SASL_VERSION_MAJOR < 2 - sasl_set_alloc( - ber_memalloc, - ber_memcalloc, - ber_memrealloc, - ber_memfree ); -#endif - sasl_set_mutex( ldap_pvt_sasl_mutex_new, ldap_pvt_sasl_mutex_lock, ldap_pvt_sasl_mutex_unlock, ldap_pvt_sasl_mutex_dispose ); -#if SASL_VERSION_MAJOR >= 2 generic_filter.f_desc = slap_schema.si_ad_objectClass; - sasl_auxprop_add_plugin( "slapd", slap_auxprop_init ); -#endif + rc = sasl_auxprop_add_plugin( "slapd", slap_auxprop_init ); + if( rc != SASL_OK ) { + Debug( LDAP_DEBUG_ANY, "slap_sasl_init: auxprop add plugin failed\n", + 0, 0, 0 ); + return -1; + } + /* should provide callbacks for logging */ /* server name should be configurable */ rc = sasl_server_init( server_callbacks, "slapd" ); if( rc != SASL_OK ) { -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, INFO, "slap_sasl_init: init failed.\n", 0, 0, 0 ); -#else - Debug( LDAP_DEBUG_ANY, "sasl_server_init failed\n", + Debug( LDAP_DEBUG_ANY, "slap_sasl_init: server init failed\n", 0, 0, 0 ); -#endif -#if SASL_VERSION_MAJOR < 2 - /* A no-op used to make sure we linked with Cyrus 1.5 */ - sasl_client_auth( NULL, NULL, NULL, 0, NULL, NULL ); -#endif return -1; } -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, INFO, "slap_sasl_init: initialized!\n", 0, 0, 0 ); -#else +#ifdef SLAPD_SPASSWD + lutil_passwd_add( &sasl_pwscheme, chk_sasl, NULL ); +#endif + Debug( LDAP_DEBUG_TRACE, "slap_sasl_init: initialized!\n", 0, 0, 0 ); -#endif /* default security properties */ memset( &sasl_secprops, '\0', sizeof(sasl_secprops) ); @@ -1114,13 +1306,54 @@ int slap_sasl_destroy( void ) { #ifdef HAVE_CYRUS_SASL sasl_done(); + +#ifdef SLAP_AUXPROP_DONTUSECOPY + if ( slap_dontUseCopy_propnames ) { + ber_bvarray_free( slap_dontUseCopy_propnames ); + slap_dontUseCopy_propnames = NULL; + } +#endif /* SLAP_AUXPROP_DONTUSECOPY */ #endif - free( global_host ); - global_host = NULL; + free( sasl_host ); + sasl_host = NULL; return 0; } +static char * +slap_sasl_peer2ipport( struct berval *peer ) +{ + int isv6 = 0; + char *ipport, *p, + *addr = &peer->bv_val[ STRLENOF( "IP=" ) ]; + ber_len_t plen = peer->bv_len - STRLENOF( "IP=" ); + + /* IPv6? */ + if ( addr[0] == '[' ) { + isv6 = 1; + plen--; + } + ipport = ch_strdup( &addr[isv6] ); + + /* Convert IPv6/IPv4 addresses to address;port syntax. */ + p = strrchr( ipport, ':' ); + if ( p != NULL ) { + *p = ';'; + if ( isv6 ) { + assert( p[-1] == ']' ); + AC_MEMCPY( &p[-1], p, plen - ( p - ipport ) + 1 ); + } + + } else if ( isv6 ) { + /* trim ']' */ + plen--; + assert( addr[plen] == ']' ); + addr[plen] = '\0'; + } + + return ipport; +} + int slap_sasl_open( Connection *conn, int reopen ) { int sc = LDAP_SUCCESS; @@ -1129,10 +1362,7 @@ int slap_sasl_open( Connection *conn, int reopen ) sasl_conn_t *ctx = NULL; sasl_callback_t *session_callbacks; - -#if SASL_VERSION_MAJOR >= 2 char *ipremoteport = NULL, *iplocalport = NULL; -#endif assert( conn->c_sasl_authctx == NULL ); @@ -1140,19 +1370,10 @@ int slap_sasl_open( Connection *conn, int reopen ) assert( conn->c_sasl_extra == NULL ); session_callbacks = -#if SASL_VERSION_MAJOR >= 2 SLAP_CALLOC( 5, sizeof(sasl_callback_t)); -#else - SLAP_CALLOC( 3, sizeof(sasl_callback_t)); -#endif if( session_callbacks == NULL ) { -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ERR, - "slap_sasl_open: SLAP_MALLOC failed", 0, 0, 0 ); -#else Debug( LDAP_DEBUG_ANY, "slap_sasl_open: SLAP_MALLOC failed", 0, 0, 0 ); -#endif return -1; } conn->c_sasl_extra = session_callbacks; @@ -1165,11 +1386,9 @@ int slap_sasl_open( Connection *conn, int reopen ) session_callbacks[cb].proc = &slap_sasl_authorize; session_callbacks[cb++].context = conn; -#if SASL_VERSION_MAJOR >= 2 session_callbacks[cb].id = SASL_CB_CANON_USER; session_callbacks[cb].proc = &slap_sasl_canonicalize; session_callbacks[cb++].context = conn; -#endif session_callbacks[cb].id = SASL_CB_LIST_END; session_callbacks[cb].proc = NULL; @@ -1180,39 +1399,20 @@ int slap_sasl_open( Connection *conn, int reopen ) conn->c_sasl_layers = 0; - if( global_host == NULL ) { - global_host = ldap_pvt_get_fqdn( NULL ); - } - /* create new SASL context */ -#if SASL_VERSION_MAJOR >= 2 if ( conn->c_sock_name.bv_len != 0 && - strncmp( conn->c_sock_name.bv_val, "IP=", 3 ) == 0) { - char *p; - - iplocalport = ch_strdup( conn->c_sock_name.bv_val + 3 ); - /* Convert IPv6 addresses to address;port syntax. */ - p = strrchr( iplocalport, ' ' ); - /* Convert IPv4 addresses to address;port syntax. */ - if ( p == NULL ) p = strchr( iplocalport, ':' ); - if ( p != NULL ) { - *p = ';'; - } + strncmp( conn->c_sock_name.bv_val, "IP=", STRLENOF( "IP=" ) ) == 0 ) + { + iplocalport = slap_sasl_peer2ipport( &conn->c_sock_name ); } + if ( conn->c_peer_name.bv_len != 0 && - strncmp( conn->c_peer_name.bv_val, "IP=", 3 ) == 0) { - char *p; - - ipremoteport = ch_strdup( conn->c_peer_name.bv_val + 3 ); - /* Convert IPv6 addresses to address;port syntax. */ - p = strrchr( ipremoteport, ' ' ); - /* Convert IPv4 addresses to address;port syntax. */ - if ( p == NULL ) p = strchr( ipremoteport, ':' ); - if ( p != NULL ) { - *p = ';'; - } + strncmp( conn->c_peer_name.bv_val, "IP=", STRLENOF( "IP=" ) ) == 0 ) + { + ipremoteport = slap_sasl_peer2ipport( &conn->c_peer_name ); } - sc = sasl_server_new( "ldap", global_host, global_realm, + + sc = sasl_server_new( "ldap", sasl_host, global_realm, iplocalport, ipremoteport, session_callbacks, SASL_SUCCESS_DATA, &ctx ); if ( iplocalport != NULL ) { ch_free( iplocalport ); @@ -1220,19 +1420,10 @@ int slap_sasl_open( Connection *conn, int reopen ) if ( ipremoteport != NULL ) { ch_free( ipremoteport ); } -#else - sc = sasl_server_new( "ldap", global_host, global_realm, - session_callbacks, SASL_SECURITY_LAYER, &ctx ); -#endif if( sc != SASL_OK ) { -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ERR, - "slap_sasl_open: sasl_server_new failed: %d\n", sc, 0, 0 ); -#else Debug( LDAP_DEBUG_ANY, "sasl_server_new failed: %d\n", sc, 0, 0 ); -#endif return -1; } @@ -1244,13 +1435,8 @@ int slap_sasl_open( Connection *conn, int reopen ) SASL_SEC_PROPS, &sasl_secprops ); if( sc != SASL_OK ) { -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ERR, - "slap_sasl_open: sasl_setprop failed: %d \n", sc, 0, 0 ); -#else Debug( LDAP_DEBUG_ANY, "sasl_setprop failed: %d\n", sc, 0, 0 ); -#endif slap_sasl_close( conn ); return -1; @@ -1278,15 +1464,16 @@ int slap_sasl_external( slap_ssf_t ssf, struct berval *auth_id ) { -#if SASL_VERSION_MAJOR >= 2 +#ifdef HAVE_CYRUS_SASL int sc; sasl_conn_t *ctx = conn->c_sasl_authctx; + sasl_ssf_t sasl_ssf = ssf; if ( ctx == NULL ) { return LDAP_UNAVAILABLE; } - sc = sasl_setprop( ctx, SASL_SSF_EXTERNAL, &ssf ); + sc = sasl_setprop( ctx, SASL_SSF_EXTERNAL, &sasl_ssf ); if ( sc != SASL_OK ) { return LDAP_OTHER; @@ -1298,26 +1485,6 @@ int slap_sasl_external( if ( sc != SASL_OK ) { return LDAP_OTHER; } - -#elif defined(HAVE_CYRUS_SASL) - int sc; - sasl_conn_t *ctx = conn->c_sasl_authctx; - sasl_external_properties_t extprops; - - if ( ctx == NULL ) { - return LDAP_UNAVAILABLE; - } - - memset( &extprops, '\0', sizeof(extprops) ); - extprops.ssf = ssf; - extprops.auth_id = auth_id ? auth_id->bv_val : NULL; - - sc = sasl_setprop( ctx, SASL_SSF_EXTERNAL, - (void *) &extprops ); - - if ( sc != SASL_OK ) { - return LDAP_OTHER; - } #elif defined(SLAP_BUILTIN_SASL) /* built-in SASL implementation */ SASL_CTX *ctx = conn->c_sasl_authctx; @@ -1358,22 +1525,13 @@ char ** slap_sasl_mechs( Connection *conn ) &mechstr, NULL, NULL ); if( sc != SASL_OK ) { -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ERR, - "slap_sasl_mechs: sasl_listmech failed: %d\n", sc, 0, 0 ); -#else Debug( LDAP_DEBUG_ANY, "slap_sasl_listmech failed: %d\n", sc, 0, 0 ); -#endif return NULL; } mechs = ldap_str2charray( mechstr, "," ); - -#if SASL_VERSION_MAJOR < 2 - ch_free( mechstr ); -#endif } #elif defined(SLAP_BUILTIN_SASL) /* builtin SASL implementation */ @@ -1432,21 +1590,12 @@ int slap_sasl_bind( Operation *op, SlapReply *rs ) unsigned reslen = 0; int sc; -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ENTRY, - "sasl_bind: dn=\"%s\" mech=%s datalen=%ld\n", - op->o_req_dn.bv_len ? op->o_req_dn.bv_val : "", - op->o_conn->c_sasl_bind_in_progress ? "" : - op->o_conn->c_sasl_bind_mech.bv_val, - op->orb_cred.bv_len ); -#else Debug(LDAP_DEBUG_ARGS, "==> sasl_bind: dn=\"%s\" mech=%s datalen=%ld\n", op->o_req_dn.bv_len ? op->o_req_dn.bv_val : "", op->o_conn->c_sasl_bind_in_progress ? "" : op->o_conn->c_sasl_bind_mech.bv_val, op->orb_cred.bv_len ); -#endif if( ctx == NULL ) { send_ldap_error( op, rs, LDAP_UNAVAILABLE, @@ -1454,28 +1603,19 @@ int slap_sasl_bind( Operation *op, SlapReply *rs ) return rs->sr_err; } -#if SASL_VERSION_MAJOR >= 2 #define START( ctx, mech, cred, clen, resp, rlen, err ) \ sasl_server_start( ctx, mech, cred, clen, resp, rlen ) #define STEP( ctx, cred, clen, resp, rlen, err ) \ sasl_server_step( ctx, cred, clen, resp, rlen ) -#else -#define START( ctx, mech, cred, clen, resp, rlen, err ) \ - sasl_server_start( ctx, mech, cred, clen, resp, rlen, err ) -#define STEP( ctx, cred, clen, resp, rlen, err ) \ - sasl_server_step( ctx, cred, clen, resp, rlen, err ) -#endif if ( !op->o_conn->c_sasl_bind_in_progress ) { /* If we already authenticated once, must use a new context */ if ( op->o_conn->c_sasl_done ) { - slap_ssf_t ssf = 0; + sasl_ssf_t ssf = 0; const char *authid = NULL; -#if SASL_VERSION_MAJOR >= 2 sasl_getprop( ctx, SASL_SSF_EXTERNAL, (void *)&ssf ); sasl_getprop( ctx, SASL_AUTH_EXTERNAL, (void *)&authid ); if ( authid ) authid = ch_strdup( authid ); -#endif if ( ctx != op->o_conn->c_sasl_sockctx ) { sasl_dispose( &ctx ); } @@ -1483,13 +1623,11 @@ int slap_sasl_bind( Operation *op, SlapReply *rs ) slap_sasl_open( op->o_conn, 1 ); ctx = op->o_conn->c_sasl_authctx; -#if SASL_VERSION_MAJOR >= 2 if ( authid ) { sasl_setprop( ctx, SASL_SSF_EXTERNAL, &ssf ); sasl_setprop( ctx, SASL_AUTH_EXTERNAL, authid ); ch_free( (char *)authid ); } -#endif } sc = START( ctx, op->o_conn->c_sasl_bind_mech.bv_val, @@ -1507,7 +1645,7 @@ int slap_sasl_bind( Operation *op, SlapReply *rs ) if ( sc == SASL_OK ) { sasl_ssf_t *ssf = NULL; - op->orb_edn = op->o_conn->c_sasl_dn; + ber_dupbv_x( &op->orb_edn, &op->o_conn->c_sasl_dn, op->o_tmpmemctx ); BER_BVZERO( &op->o_conn->c_sasl_dn ); op->o_conn->c_sasl_done = 1; @@ -1538,7 +1676,7 @@ int slap_sasl_bind( Operation *op, SlapReply *rs ) } /* Must send response using old security layer */ - if (response.bv_len) rs->sr_sasldata = &response; + rs->sr_sasldata = (response.bv_len ? &response : NULL); send_ldap_sasl( op, rs ); /* Now dispose of the old security layer. @@ -1552,28 +1690,18 @@ int slap_sasl_bind( Operation *op, SlapReply *rs ) } } else if ( sc == SASL_CONTINUE ) { rs->sr_err = LDAP_SASL_BIND_IN_PROGRESS, + rs->sr_text = sasl_errdetail( ctx ); rs->sr_sasldata = &response; send_ldap_sasl( op, rs ); } else { -#if SASL_VERSION_MAJOR >= 2 + BER_BVZERO( &op->o_conn->c_sasl_dn ); rs->sr_text = sasl_errdetail( ctx ); -#endif rs->sr_err = slap_sasl_err2ldap( sc ), send_ldap_result( op, rs ); } -#if SASL_VERSION_MAJOR < 2 - if( response.bv_len ) { - ch_free( response.bv_val ); - } -#endif - -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, RESULTS, "slap_sasl_bind: rc=%d\n", rs->sr_err, 0, 0 ); -#else Debug(LDAP_DEBUG_TRACE, "<== slap_sasl_bind: rc=%d\n", rs->sr_err, 0, 0); -#endif #elif defined(SLAP_BUILTIN_SASL) /* built-in SASL implementation */ @@ -1621,6 +1749,13 @@ char* slap_sasl_secprops( const char *in ) #endif } +void slap_sasl_secprops_unparse( struct berval *bv ) +{ +#ifdef HAVE_CYRUS_SASL + ldap_pvt_sasl_secprops_unparse( &sasl_secprops, bv ); +#endif +} + #ifdef HAVE_CYRUS_SASL int slap_sasl_setpass( Operation *op, SlapReply *rs ) @@ -1632,7 +1767,7 @@ slap_sasl_setpass( Operation *op, SlapReply *rs ) assert( ber_bvcmp( &slap_EXOP_MODIFY_PASSWD, &op->ore_reqoid ) == 0 ); rs->sr_err = sasl_getprop( op->o_conn->c_sasl_authctx, SASL_USERNAME, - (SASL_CONST void **)&id.bv_val ); + (SASL_CONST void **)(char *)&id.bv_val ); if( rs->sr_err != SASL_OK ) { rs->sr_text = "unable to retrieve SASL username"; @@ -1640,14 +1775,8 @@ slap_sasl_setpass( Operation *op, SlapReply *rs ) goto done; } -#ifdef NEW_LOGGING - LDAP_LOG( BACKEND, ENTRY, - "slap_sasl_setpass: \"%s\"\n", - id.bv_val ? id.bv_val : "", 0, 0); -#else Debug( LDAP_DEBUG_ARGS, "==> slap_sasl_setpass: \"%s\"\n", id.bv_val ? id.bv_val : "", 0, 0 ); -#endif rs->sr_err = slap_passwd_parse( op->ore_reqdata, NULL, &old, &new, &rs->sr_text ); @@ -1668,16 +1797,11 @@ slap_sasl_setpass( Operation *op, SlapReply *rs ) rs->sr_rspdata = slap_passwd_return( &new ); } -#if SASL_VERSION_MAJOR < 2 - rs->sr_err = sasl_setpass( op->o_conn->c_sasl_authctx, - id.bv_val, new.bv_val, new.bv_len, 0, &rs->sr_text ); -#else rs->sr_err = sasl_setpass( op->o_conn->c_sasl_authctx, id.bv_val, new.bv_val, new.bv_len, old.bv_val, old.bv_len, 0 ); if( rs->sr_err != SASL_OK ) { rs->sr_text = sasl_errdetail( op->o_conn->c_sasl_authctx ); } -#endif switch(rs->sr_err) { case SASL_OK: rs->sr_err = LDAP_SUCCESS; @@ -1716,25 +1840,19 @@ int slap_sasl_getdn( Connection *conn, Operation *op, struct berval *id, int rc, is_dn = SET_NONE, do_norm = 1; struct berval dn2, *mech; - assert( conn ); - assert( id ); + assert( conn != NULL ); + assert( id != NULL ); -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ENTRY, - "slap_sasl_getdn: conn %d id=%s [len=%d]\n", + Debug( LDAP_DEBUG_ARGS, "slap_sasl_getdn: conn %lu id=%s [len=%lu]\n", conn->c_connid, BER_BVISNULL( id ) ? "NULL" : ( BER_BVISEMPTY( id ) ? "" : id->bv_val ), - BER_BVISNULL( id ) ? 0 : ( BER_BVISEMPTY( id ) ? 0 : id->bv_len ) ); -#else - Debug( LDAP_DEBUG_ARGS, "slap_sasl_getdn: conn %d id=%s [len=%d]\n", - conn->c_connid, - BER_BVISNULL( id ) ? "NULL" : ( BER_BVISEMPTY( id ) ? "" : id->bv_val ), - BER_BVISNULL( id ) ? 0 : ( BER_BVISEMPTY( id ) ? 0 : id->bv_len ) ); -#endif + BER_BVISNULL( id ) ? 0 : ( BER_BVISEMPTY( id ) ? 0 : + (unsigned long) id->bv_len ) ); if ( !op ) { op = conn->c_sasl_bindop; } + assert( op != NULL ); BER_BVZERO( dn ); @@ -1799,54 +1917,66 @@ int slap_sasl_getdn( Connection *conn, Operation *op, struct berval *id, /* Username strings */ if( is_dn == SET_U ) { - char *p; - struct berval realm = BER_BVNULL, c1 = *dn; - ber_len_t len; - - len = dn->bv_len + STRLENOF( "uid=" ) + STRLENOF( ",cn=auth" ); - - if( user_realm && *user_realm ) { - ber_str2bv( user_realm, 0, 0, &realm ); - len += realm.bv_len + STRLENOF( ",cn=" ); + /* ITS#3419: values may need escape */ + LDAPRDN DN[ 5 ]; + LDAPAVA *RDNs[ 4 ][ 2 ]; + LDAPAVA AVAs[ 4 ]; + int irdn; + + irdn = 0; + DN[ irdn ] = RDNs[ irdn ]; + RDNs[ irdn ][ 0 ] = &AVAs[ irdn ]; + AVAs[ irdn ].la_attr = slap_schema.si_ad_uid->ad_cname; + AVAs[ irdn ].la_value = *dn; + AVAs[ irdn ].la_flags = LDAP_AVA_NULL; + AVAs[ irdn ].la_private = NULL; + RDNs[ irdn ][ 1 ] = NULL; + + if ( user_realm && *user_realm ) { + irdn++; + DN[ irdn ] = RDNs[ irdn ]; + RDNs[ irdn ][ 0 ] = &AVAs[ irdn ]; + AVAs[ irdn ].la_attr = slap_schema.si_ad_cn->ad_cname; + ber_str2bv( user_realm, 0, 0, &AVAs[ irdn ].la_value ); + AVAs[ irdn ].la_flags = LDAP_AVA_NULL; + AVAs[ irdn ].la_private = NULL; + RDNs[ irdn ][ 1 ] = NULL; } - if( mech->bv_len ) { - len += mech->bv_len + STRLENOF( ",cn=" ); + if ( !BER_BVISNULL( mech ) ) { + irdn++; + DN[ irdn ] = RDNs[ irdn ]; + RDNs[ irdn ][ 0 ] = &AVAs[ irdn ]; + AVAs[ irdn ].la_attr = slap_schema.si_ad_cn->ad_cname; + AVAs[ irdn ].la_value = *mech; + AVAs[ irdn ].la_flags = LDAP_AVA_NULL; + AVAs[ irdn ].la_private = NULL; + RDNs[ irdn ][ 1 ] = NULL; } - /* Build the new dn */ - dn->bv_val = sl_malloc( len + 1, op->o_tmpmemctx ); - if( dn->bv_val == NULL ) { -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ERR, - "slap_sasl_getdn: SLAP_MALLOC failed", 0, 0, 0 ); -#else - Debug( LDAP_DEBUG_ANY, - "slap_sasl_getdn: SLAP_MALLOC failed", 0, 0, 0 ); -#endif - return LDAP_OTHER; - } - p = lutil_strcopy( dn->bv_val, "uid=" ); - p = lutil_strncopy( p, c1.bv_val, c1.bv_len ); + irdn++; + DN[ irdn ] = RDNs[ irdn ]; + RDNs[ irdn ][ 0 ] = &AVAs[ irdn ]; + AVAs[ irdn ].la_attr = slap_schema.si_ad_cn->ad_cname; + BER_BVSTR( &AVAs[ irdn ].la_value, "auth" ); + AVAs[ irdn ].la_flags = LDAP_AVA_NULL; + AVAs[ irdn ].la_private = NULL; + RDNs[ irdn ][ 1 ] = NULL; - if( realm.bv_len ) { - p = lutil_strcopy( p, ",cn=" ); - p = lutil_strncopy( p, realm.bv_val, realm.bv_len ); - } + irdn++; + DN[ irdn ] = NULL; - if( mech->bv_len ) { - p = lutil_strcopy( p, ",cn=" ); - p = lutil_strcopy( p, mech->bv_val ); + rc = ldap_dn2bv_x( DN, dn, LDAP_DN_FORMAT_LDAPV3, + op->o_tmpmemctx ); + if ( rc != LDAP_SUCCESS ) { + BER_BVZERO( dn ); + return rc; } - p = lutil_strcopy( p, ",cn=auth" ); - dn->bv_len = p - dn->bv_val; -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ENTRY, - "slap_sasl_getdn: u:id converted to %s.\n", dn->bv_val, 0, 0 ); -#else - Debug( LDAP_DEBUG_TRACE, "slap_sasl_getdn: u:id converted to %s\n", dn->bv_val,0,0 ); -#endif + Debug( LDAP_DEBUG_TRACE, + "slap_sasl_getdn: u:id converted to %s\n", + dn->bv_val, 0, 0 ); + } else { /* Dup the DN in any case, so we don't risk @@ -1861,7 +1991,7 @@ int slap_sasl_getdn( Connection *conn, Operation *op, struct berval *id, rc = dnNormalize( 0, NULL, NULL, dn, &dn2, op->o_tmpmemctx ); /* User DNs were constructed above and must be freed now */ - sl_free( dn->bv_val, op->o_tmpmemctx ); + slap_sl_free( dn->bv_val, op->o_tmpmemctx ); if ( rc != LDAP_SUCCESS ) { BER_BVZERO( dn ); @@ -1873,15 +2003,11 @@ int slap_sasl_getdn( Connection *conn, Operation *op, struct berval *id, /* Run thru regexp */ slap_sasl2dn( op, dn, &dn2, flags ); if( !BER_BVISNULL( &dn2 ) ) { - sl_free( dn->bv_val, op->o_tmpmemctx ); + slap_sl_free( dn->bv_val, op->o_tmpmemctx ); *dn = dn2; -#ifdef NEW_LOGGING - LDAP_LOG( TRANSPORT, ENTRY, - "slap_sasl_getdn: dn:id converted to %s.\n", dn->bv_val, 0, 0 ); -#else - Debug( LDAP_DEBUG_TRACE, "getdn: dn:id converted to %s\n", + Debug( LDAP_DEBUG_TRACE, + "slap_sasl_getdn: dn:id converted to %s\n", dn->bv_val, 0, 0 ); -#endif } return( LDAP_SUCCESS );