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; }