git.sur5r.net Git - openldap/blob - servers/slapd/back-ldap/extended.c

   1 /* extended.c - ldap backend extended routines */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 2003-2005 The OpenLDAP Foundation.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16 /* ACKNOWLEDGEMENTS:
  17  * This work was initially developed by the Howard Chu for inclusion
  18  * in OpenLDAP Software and subsequently enhanced by Pierangelo
  19  * Masarati.
  20  */
  21
  22 #include "portable.h"
  23
  24 #include <stdio.h>
  25 #include <ac/string.h>
  26
  27 #include "slap.h"
  28 #include "back-ldap.h"
  29 #include "lber_pvt.h"
  30
  31 BI_op_extended ldap_back_exop_passwd;
  32
  33 static struct exop {
  34         struct berval   *oid;
  35         BI_op_extended  *extended;
  36 } exop_table[] = {
  37         { (struct berval *)&slap_EXOP_MODIFY_PASSWD, ldap_back_exop_passwd },
  38         { NULL, NULL }
  39 };
  40
  41 int
  42 ldap_back_extended(
  43                 Operation       *op,
  44                 SlapReply       *rs )
  45 {
  46         int     i;
  47
  48         for ( i = 0; exop_table[i].extended != NULL; i++ ) {
  49                 if ( bvmatch( exop_table[i].oid, &op->oq_extended.rs_reqoid ) )
  50                 {
  51                         struct ldapconn *lc;
  52                         LDAPControl     **oldctrls = NULL;
  53                         int             rc;
  54
  55                         /* FIXME: this needs to be called here, so it is
  56                          * called twice; maybe we could avoid the
  57                          * ldap_back_dobind() call inside each extended()
  58                          * call ... */
  59                         lc = ldap_back_getconn( op, rs, LDAP_BACK_SENDERR );
  60                         if ( !lc || !ldap_back_dobind( lc, op, rs, LDAP_BACK_SENDERR ) ) {
  61                                 return -1;
  62                         }
  63
  64                         oldctrls = op->o_ctrls;
  65                         if ( ldap_back_proxy_authz_ctrl( lc, op, rs,
  66                                                 &op->o_ctrls ) )
  67                         {
  68                                 op->o_ctrls = oldctrls;
  69                                 send_ldap_result( op, rs );
  70                                 rs->sr_text = NULL;
  71                                 rc = rs->sr_err;
  72                                 goto done;
  73                         }
  74
  75                         rc = ( *exop_table[i].extended )( op, rs );
  76
  77                         if ( op->o_ctrls && op->o_ctrls != oldctrls ) {
  78                                 free( op->o_ctrls[ 0 ] );
  79                                 free( op->o_ctrls );
  80                         }
  81                         op->o_ctrls = oldctrls;
  82
  83 done:;
  84                         if ( lc != NULL ) {
  85                                 ldap_back_release_conn( op, rs, lc );
  86                         }
  87
  88                         return rc;
  89                 }
  90         }
  91
  92         rs->sr_text = "not supported within naming context";
  93         return LDAP_UNWILLING_TO_PERFORM;
  94 }
  95
  96 int
  97 ldap_back_exop_passwd(
  98                 Operation       *op,
  99                 SlapReply       *rs )
 100 {
 101         struct ldapconn *lc;
 102         req_pwdexop_s   *qpw = &op->oq_pwdexop;
 103         LDAPMessage     *res;
 104         ber_int_t       msgid;
 105         int             rc, isproxy;
 106         int             do_retry = 1;
 107
 108         lc = ldap_back_getconn( op, rs, LDAP_BACK_SENDERR );
 109         if ( !lc || !ldap_back_dobind( lc, op, rs, LDAP_BACK_SENDERR ) ) {
 110                 return -1;
 111         }
 112
 113         isproxy = ber_bvcmp( &op->o_req_ndn, &op->o_ndn );
 114
 115         Debug( LDAP_DEBUG_ARGS, "==> ldap_back_exop_passwd(\"%s\")%s\n",
 116                 op->o_req_dn.bv_val, isproxy ? " (proxy)" : "", 0 );
 117
 118 retry:
 119         rc = ldap_passwd( lc->lc_ld, isproxy ? &op->o_req_dn : NULL,
 120                 qpw->rs_old.bv_val ? &qpw->rs_old : NULL,
 121                 qpw->rs_new.bv_val ? &qpw->rs_new : NULL,
 122                 op->o_ctrls, NULL, &msgid );
 123
 124         if ( rc == LDAP_SUCCESS ) {
 125                 if ( ldap_result( lc->lc_ld, msgid, 1, NULL, &res ) == -1 ) {
 126                         ldap_get_option( lc->lc_ld, LDAP_OPT_ERROR_NUMBER, &rc );
 127                         ldap_back_freeconn( op, lc );
 128                         lc = NULL;
 129
 130                 } else {
 131                         /* sigh. parse twice, because parse_passwd
 132                          * doesn't give us the err / match / msg info.
 133                          */
 134                         rc = ldap_parse_result( lc->lc_ld, res, &rs->sr_err,
 135                                         (char **)&rs->sr_matched,
 136                                         (char **)&rs->sr_text,
 137                                         NULL, NULL, 0 );
 138                         if ( rc == LDAP_SUCCESS ) {
 139                                 if ( rs->sr_err == LDAP_SUCCESS ) {
 140                                         struct berval   newpw;
 141
 142                                         rc = ldap_parse_passwd( lc->lc_ld, res,
 143                                                         &newpw);
 144                                         if ( rc == LDAP_SUCCESS &&
 145                                                         !BER_BVISNULL( &newpw ) )
 146                                         {
 147                                                 rs->sr_type = REP_EXTENDED;
 148                                                 rs->sr_rspdata = slap_passwd_return( &newpw );
 149                                                 free( newpw.bv_val );
 150                                         }
 151
 152                                 } else {
 153                                         rc = rs->sr_err;
 154                                 }
 155                         }
 156                         ldap_msgfree( res );
 157                 }
 158         }
 159         if ( rc != LDAP_SUCCESS ) {
 160                 rs->sr_err = slap_map_api2result( rs );
 161                 if ( rs->sr_err == LDAP_UNAVAILABLE && do_retry ) {
 162                         do_retry = 0;
 163                         if ( ldap_back_retry( lc, op, rs, LDAP_BACK_SENDERR ) ) {
 164                                 goto retry;
 165                         }
 166                 }
 167                 send_ldap_result( op, rs );
 168                 if ( rs->sr_matched ) {
 169                         free( (char *)rs->sr_matched );
 170                 }
 171                 if ( rs->sr_text ) {
 172                         free( (char *)rs->sr_text );
 173                 }
 174                 rs->sr_matched = NULL;
 175                 rs->sr_text = NULL;
 176                 rc = -1;
 177         }
 178
 179         if ( lc != NULL ) {
 180                 ldap_back_release_conn( op, rs, lc );
 181         }
 182
 183         return rc;
 184 }