static int
dodelete(
const char *dn,
LDAPControl **pctrls )
{
int rc;
int msgid;
printf( _("%sdeleting entry \"%s\"\n"), dont ? "!" : "", dn );
if ( !dont ) {
rc = ldap_delete_ext( ld, dn, pctrls, NULL, &msgid );
if ( rc != LDAP_SUCCESS ) {
fprintf( stderr, _("%s: delete failed: %s\n"), prog, dn );
tool_perror( "ldap_delete", rc, NULL, NULL, NULL, NULL );
goto done;
}
rc = process_response( ld, msgid, LDAP_RES_DELETE, dn );
if ( verbose && rc == LDAP_SUCCESS ) {
printf( _("delete complete\n") );
}
} else {
rc = LDAP_SUCCESS;
}
done:
putchar( '\n' );
return( rc );
}
/*
delete a record
*/
static int lldb_delete(struct lldb_context *lldb_ac)
{
struct ldb_context *ldb;
struct lldb_private *lldb = lldb_ac->lldb;
struct ldb_module *module = lldb_ac->module;
struct ldb_request *req = lldb_ac->req;
char *dnstr;
int ret;
ldb = ldb_module_get_ctx(module);
ldb_request_set_state(req, LDB_ASYNC_PENDING);
dnstr = ldb_dn_alloc_linearized(lldb_ac, req->op.del.dn);
ret = ldap_delete_ext(lldb->ldap, dnstr,
NULL,
NULL,
&lldb_ac->msgid);
if (ret != LDAP_SUCCESS) {
ldb_set_errstring(ldb, ldap_err2string(ret));
}
return lldb_ldap_to_ldb(ret);
}
/***********************************************************************
* ldap_deleteW (WLDAP32.@)
*
* Delete an entry from a directory tree (asynchronous operation).
*
* PARAMS
* ld [I] Pointer to an LDAP context.
* dn [I] DN of the entry to delete.
*
* RETURNS
* Success: Message ID of the add operation.
* Failure: An LDAP error code.
*
* NOTES
* Call ldap_result with the message ID to get the result of
* the operation. Cancel the operation by calling ldap_abandon
* with the message ID.
*/
ULONG CDECL ldap_deleteW( WLDAP32_LDAP *ld, PWCHAR dn )
{
ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
char *dnU = NULL;
int msg;
TRACE( "(%p, %s)\n", ld, debugstr_w(dn) );
if (!ld) return ~0u;
if (dn) {
dnU = strWtoU( dn );
if (!dnU) return WLDAP32_LDAP_NO_MEMORY;
}
ret = ldap_delete_ext( ld, dn ? dnU : "", NULL, NULL, &msg );
if (ret == LDAP_SUCCESS)
ret = msg;
else
ret = ~0u;
strfreeU( dnU );
#endif
return ret;
}
/*
** Delete an entry.
** @param #1 LDAP connection.
** @param #2 String with entry's DN.
** @return Boolean.
*/
static int lualdap_delete (lua_State *L) {
conn_data *conn = getconnection (L);
ldap_pchar_t dn = (ldap_pchar_t) luaL_checkstring (L, 2);
ldap_int_t rc, msgid;
rc = ldap_delete_ext (conn->ld, dn, NULL, NULL, &msgid);
return create_future (L, rc, 1, msgid, LDAP_RES_DELETE);
}
/* ARGSUSED */
int _ns_ldap_delete_ext(char *service, int flags,
char *dn, LDAPControl **serverctrls,
LDAPControl **clientctrls, int *msgidp)
{
LDAP *ld = __s_api_getLDAPconn(flags);
return (ldap_delete_ext(ld, dn, serverctrls, clientctrls, msgidp));
}
static int lua_apr_ldap_delete(lua_State *L)
{
lua_apr_ldap_object *object;
ldap_pchar_t dn;
ldap_int_t rc, msgid;
object = check_ldap_connection(L, 1);
dn = (ldap_pchar_t) luaL_checkstring(L, 2);
rc = ldap_delete_ext(object->ldap, dn, NULL, NULL, &msgid);
return create_future(L, rc, 1, msgid, LDAP_RES_DELETE);
}
int
ldap_back_delete(
Operation *op,
SlapReply *rs )
{
ldapinfo_t *li = (ldapinfo_t *)op->o_bd->be_private;
ldapconn_t *lc = NULL;
ber_int_t msgid;
LDAPControl **ctrls = NULL;
ldap_back_send_t retrying = LDAP_BACK_RETRYING;
int rc = LDAP_SUCCESS;
if ( !ldap_back_dobind( &lc, op, rs, LDAP_BACK_SENDERR ) ) {
return rs->sr_err;
}
retry:
ctrls = op->o_ctrls;
rc = ldap_back_controls_add( op, rs, lc, &ctrls );
if ( rc != LDAP_SUCCESS ) {
send_ldap_result( op, rs );
rc = rs->sr_err;
goto cleanup;
}
rs->sr_err = ldap_delete_ext( lc->lc_ld, op->o_req_dn.bv_val,
ctrls, NULL, &msgid );
rc = ldap_back_op_result( lc, op, rs, msgid,
li->li_timeout[ SLAP_OP_DELETE ],
( LDAP_BACK_SENDRESULT | retrying ) );
if ( rs->sr_err == LDAP_UNAVAILABLE && retrying ) {
retrying &= ~LDAP_BACK_RETRYING;
if ( ldap_back_retry( &lc, op, rs, LDAP_BACK_SENDERR ) ) {
/* if the identity changed, there might be need to re-authz */
(void)ldap_back_controls_free( op, rs, &ctrls );
goto retry;
}
}
ldap_pvt_thread_mutex_lock( &li->li_counter_mutex );
ldap_pvt_mp_add( li->li_ops_completed[ SLAP_OP_DELETE ], 1 );
ldap_pvt_thread_mutex_unlock( &li->li_counter_mutex );
cleanup:
(void)ldap_back_controls_free( op, rs, &ctrls );
if ( lc != NULL ) {
ldap_back_release_conn( li, lc );
}
return rc;
}
// wrappers for ldap_delete_ext
//
nsresult
nsLDAPOperation::DeleteExt(const char *base,
LDAPControl **serverctrls,
LDAPControl **clientctrls)
{
if (mMessageListener == 0) {
NS_ERROR("nsLDAPOperation::DeleteExt(): mMessageListener not set");
return NS_ERROR_NOT_INITIALIZED;
}
return TranslateLDAPErrorToNSError(ldap_delete_ext(mConnectionHandle, base,
serverctrls, clientctrls,
&mMsgID));
}
/*
* ldap_delete - initiate an ldap (and X.500) delete operation. Parameters:
*
* ld LDAP descriptor
* dn DN of the object to delete
*
* Example:
* msgid = ldap_delete( ld, dn );
*/
int
ldap_delete( LDAP *ld, LDAP_CONST char *dn )
{
int msgid;
/*
* A delete request looks like this:
* DelRequet ::= DistinguishedName,
*/
Debug( LDAP_DEBUG_TRACE, "ldap_delete\n", 0, 0, 0 );
return ldap_delete_ext( ld, dn, NULL, NULL, &msgid ) == LDAP_SUCCESS
? msgid : -1 ;
}
/*
* ldap_delete - initiate an ldap (and X.500) delete operation. Parameters:
*
* ld LDAP descriptor
* dn DN of the object to delete
*
* Example:
* msgid = ldap_delete( ld, dn );
*/
int
ldap_delete( LDAP *ld, LDAP_CONST char *dn )
{
int msgid;
/*
* A delete request looks like this:
* DelRequet ::= DistinguishedName,
*/
#ifdef NEW_LOGGING
LDAP_LOG ( OPERATION, ENTRY, "ldap_delete\n", 0,0,0 );
#else
Debug( LDAP_DEBUG_TRACE, "ldap_delete\n", 0, 0, 0 );
#endif
return ldap_delete_ext( ld, dn, NULL, NULL, &msgid ) == LDAP_SUCCESS
? msgid : -1 ;
}
int
ldap_delete_ext_s(
LDAP *ld,
LDAP_CONST char *dn,
LDAPControl **sctrls,
LDAPControl **cctrls )
{
int msgid;
int rc;
LDAPMessage *res;
rc = ldap_delete_ext( ld, dn, sctrls, cctrls, &msgid );
if( rc != LDAP_SUCCESS )
return( ld->ld_errno );
if ( ldap_result( ld, msgid, LDAP_MSG_ALL, (struct timeval *) NULL, &res ) == -1 || !res )
return( ld->ld_errno );
return( ldap_result2error( ld, res, 1 ) );
}
/***********************************************************************
* ldap_delete_extW (WLDAP32.@)
*
* Delete an entry from a directory tree (asynchronous operation).
*
* PARAMS
* ld [I] Pointer to an LDAP context.
* dn [I] DN of the entry to delete.
* serverctrls [I] Array of LDAP server controls.
* clientctrls [I] Array of LDAP client controls.
* message [O] Message ID of the delete operation.
*
* RETURNS
* Success: LDAP_SUCCESS
* Failure: An LDAP error code.
*
* NOTES
* Call ldap_result with the message ID to get the result of
* the operation. The serverctrls and clientctrls parameters are
* optional and should be set to NULL if not used.
*/
ULONG CDECL ldap_delete_extW( WLDAP32_LDAP *ld, PWCHAR dn, PLDAPControlW *serverctrls,
PLDAPControlW *clientctrls, ULONG *message )
{
ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
#ifdef HAVE_LDAP
char *dnU = NULL;
LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
int dummy;
TRACE( "(%p, %s, %p, %p, %p)\n", ld, debugstr_w(dn), serverctrls,
clientctrls, message );
ret = WLDAP32_LDAP_NO_MEMORY;
if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
if (dn) {
dnU = strWtoU( dn );
if (!dnU) goto exit;
}
if (serverctrls) {
serverctrlsU = controlarrayWtoU( serverctrls );
if (!serverctrlsU) goto exit;
}
if (clientctrls) {
clientctrlsU = controlarrayWtoU( clientctrls );
if (!clientctrlsU) goto exit;
}
ret = map_error( ldap_delete_ext( ld, dn ? dnU : "", serverctrlsU, clientctrlsU,
message ? (int *)message : &dummy ));
exit:
strfreeU( dnU );
controlarrayfreeU( serverctrlsU );
controlarrayfreeU( clientctrlsU );
#endif
return ret;
}
int
meta_back_delete( Operation *op, SlapReply *rs )
{
metainfo_t *mi = ( metainfo_t * )op->o_bd->be_private;
metatarget_t *mt;
metaconn_t *mc = NULL;
int candidate = -1;
struct berval mdn = BER_BVNULL;
dncookie dc;
int msgid;
ldap_back_send_t retrying = LDAP_BACK_RETRYING;
LDAPControl **ctrls = NULL;
mc = meta_back_getconn( op, rs, &candidate, LDAP_BACK_SENDERR );
if ( !mc || !meta_back_dobind( op, rs, mc, LDAP_BACK_SENDERR ) ) {
return rs->sr_err;
}
assert( mc->mc_conns[ candidate ].msc_ld != NULL );
ldap_pvt_thread_mutex_lock( &mc->mc_mutex );
/*
* Rewrite the compare dn, if needed
*/
mt = mi->mi_targets[ candidate ];
dc.target = mt;
dc.conn = op->o_conn;
dc.rs = rs;
dc.ctx = "deleteDN";
if ( ldap_back_dn_massage( &dc, &op->o_req_dn, &mdn ) ) {
send_ldap_result( op, rs );
goto cleanup;
}
retry:;
ctrls = op->o_ctrls;
if ( meta_back_controls_add( op, rs, mc, candidate, &ctrls ) != LDAP_SUCCESS )
{
send_ldap_result( op, rs );
goto cleanup;
}
rs->sr_err = ldap_delete_ext( mc->mc_conns[ candidate ].msc_ld,
mdn.bv_val, ctrls, NULL, &msgid );
rs->sr_err = meta_back_op_result( mc, op, rs, candidate, msgid,
mt->mt_timeout[ SLAP_OP_DELETE ], ( LDAP_BACK_SENDRESULT | retrying ) );
if ( rs->sr_err == LDAP_UNAVAILABLE && retrying ) {
retrying &= ~LDAP_BACK_RETRYING;
if ( meta_back_retry( op, rs, &mc, candidate, LDAP_BACK_SENDERR ) ) {
/* if the identity changed, there might be need to re-authz */
(void)mi->mi_ldap_extra->controls_free( op, rs, &ctrls );
goto retry;
}
}
cleanup:;
(void)mi->mi_ldap_extra->controls_free( op, rs, &ctrls );
if ( mdn.bv_val != op->o_req_dn.bv_val ) {
free( mdn.bv_val );
BER_BVZERO( &mdn );
}
if ( mc ) {
ldap_pvt_thread_mutex_unlock( &mc->mc_mutex );
meta_back_release_conn( mi, mc );
}
return rs->sr_err;
}
static int dodelete(
LDAP *ld,
const char *dn)
{
int id;
int rc, code;
char *matcheddn = NULL, *text = NULL, **refs = NULL;
LDAPControl **ctrls = NULL;
LDAPMessage *res;
int subentries = 0;
if ( verbose ) {
printf( _("%sdeleting entry \"%s\"\n"),
(dont ? "!" : ""), dn );
}
if ( dont ) {
return LDAP_SUCCESS;
}
/* If prune is on, remove a whole subtree. Delete the children of the
* DN recursively, then the DN requested.
*/
if ( prune ) {
retry:;
deletechildren( ld, dn, subentries );
}
rc = ldap_delete_ext( ld, dn, NULL, NULL, &id );
if ( rc != LDAP_SUCCESS ) {
fprintf( stderr, "%s: ldap_delete_ext: %s (%d)\n",
prog, ldap_err2string( rc ), rc );
return rc;
}
for ( ; ; ) {
struct timeval tv;
if ( tool_check_abandon( ld, id ) ) {
return LDAP_CANCELLED;
}
tv.tv_sec = 0;
tv.tv_usec = 100000;
rc = ldap_result( ld, LDAP_RES_ANY, LDAP_MSG_ALL, &tv, &res );
if ( rc < 0 ) {
tool_perror( "ldap_result", rc, NULL, NULL, NULL, NULL );
return rc;
}
if ( rc != 0 ) {
break;
}
}
rc = ldap_parse_result( ld, res, &code, &matcheddn, &text, &refs, &ctrls, 1 );
switch ( rc ) {
case LDAP_SUCCESS:
break;
case LDAP_NOT_ALLOWED_ON_NONLEAF:
if ( prune && !subentries ) {
subentries = 1;
goto retry;
}
/* fallthru */
default:
fprintf( stderr, "%s: ldap_parse_result: %s (%d)\n",
prog, ldap_err2string( rc ), rc );
return rc;
}
if( code != LDAP_SUCCESS ) {
tool_perror( "ldap_delete", code, NULL, matcheddn, text, refs );
} else if ( verbose &&
((matcheddn && *matcheddn) || (text && *text) || (refs && *refs) ))
{
printf( _("Delete Result: %s (%d)\n"),
ldap_err2string( code ), code );
if( text && *text ) {
printf( _("Additional info: %s\n"), text );
}
if( matcheddn && *matcheddn ) {
printf( _("Matched DN: %s\n"), matcheddn );
}
if( refs ) {
int i;
for( i=0; refs[i]; i++ ) {
printf(_("Referral: %s\n"), refs[i] );
}
}
}
if (ctrls) {
tool_print_ctrls( ld, ctrls );
ldap_controls_free( ctrls );
}
ber_memfree( text );
ber_memfree( matcheddn );
ber_memvfree( (void **) refs );
return code;
}
