/** BEGIN COPYRIGHT BLOCK * This Program is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation; version 2 of the License. * * This Program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along with * this Program; if not, write to the Free Software Foundation, Inc., 59 Temple * Place, Suite 330, Boston, MA 02111-1307 USA. * * In addition, as a special exception, Red Hat, Inc. gives You the additional * right to link the code of this Program with code not covered under the GNU * General Public License ("Non-GPL Code") and to distribute linked combinations * including the two, subject to the limitations in this paragraph. Non-GPL Code * permitted under this exception must only link to the code of this Program * through those well defined interfaces identified in the file named EXCEPTION * found in the source code files (the "Approved Interfaces"). The files of * Non-GPL Code may instantiate templates or use macros or inline functions from * the Approved Interfaces without causing the resulting work to be covered by * the GNU General Public License. Only Red Hat, Inc. may make changes or * additions to the list of Approved Interfaces. You must obey the GNU General * Public License in all respects for all of the Program code and other code used * in conjunction with the Program except the Non-GPL Code covered by this * exception. If you modify this file, you may extend this exception to your * version of the file, but you are not obligated to do so. If you do not wish to * provide this exception without modification, you must delete this exception * statement from your version and license this file solely under the GPL without * exception. * * * Copyright (C) 2001 Sun Microsystems, Inc. Used by permission. * Copyright (C) 2005 Red Hat, Inc. * All rights reserved. * END COPYRIGHT BLOCK **/ #ifdef HAVE_CONFIG_H # include #endif #ifndef _PROTO_BACK_LDBM #define _PROTO_BACK_LDBM /* * attr.c */ struct attrinfo * attrinfo_new(); void attrinfo_delete(struct attrinfo **pp); void ainfo_get( backend *be, char *type, struct attrinfo **at ); void attr_masks( backend *be, char *type, int *indexmask, int *syntaxmask ); void attr_masks_ex( backend *be, char *type, int *indexmask, int *syntaxmask, struct attrinfo **at ); void attr_index_config( backend *be, char *fname, int lineno, int argc, char **argv, int init ); int ldbm_compute_init(); void attrinfo_deletetree(ldbm_instance *inst); void attr_create_empty(backend *be,char *type,struct attrinfo **ai); /* * cache.c */ int cache_init(struct cache *cache, size_t maxsize, long maxentries, int type); void cache_clear(struct cache *cache, int type); void cache_destroy_please(struct cache *cache, int type); void cache_set_max_size(struct cache *cache, size_t bytes, int type); void cache_set_max_entries(struct cache *cache, long entries); size_t cache_get_max_size(struct cache *cache); long cache_get_max_entries(struct cache *cache); void cache_get_stats(struct cache *cache, PRUint64 *hits, PRUint64 *tries, long *entries,long *maxentries, size_t *size, size_t *maxsize); void cache_debug_hash(struct cache *cache, char **out); int cache_remove(struct cache *cache, void *e); void cache_return(struct cache *cache, void **bep); struct backentry *cache_find_dn(struct cache *cache, const char *dn, unsigned long ndnlen); struct backentry *cache_find_id(struct cache *cache, ID id); struct backentry *cache_find_uuid(struct cache *cache, const char *uuid); int cache_add(struct cache *cache, void *ptr, void **alt); int cache_add_tentative(struct cache *cache, struct backentry *e, struct backentry **alt); int cache_lock_entry(struct cache *cache, struct backentry *e); void cache_unlock_entry(struct cache *cache, struct backentry *e); int cache_replace(struct cache *cache, void *oldptr, void *newptr); Hashtable *new_hash(u_long size, u_long offset, HashFn hfn, HashTestFn tfn); int add_hash(Hashtable *ht, void *key, size_t keylen, void *entry, void **alt); int find_hash(Hashtable *ht, const void *key, size_t keylen, void **entry); int remove_hash(Hashtable *ht, const void *key, size_t keylen); struct backdn *dncache_find_id(struct cache *cache, ID id); /* * dblayer.c */ int dblayer_init(struct ldbminfo *li); int dblayer_terminate(struct ldbminfo *li); int dblayer_start(struct ldbminfo *li, int dbmode); int dblayer_flush(struct ldbminfo *li ); int dblayer_close(struct ldbminfo *li, int dbmode ); void dblayer_pre_close(struct ldbminfo *li); int dblayer_post_close(struct ldbminfo *li, int dbmode ); int dblayer_instance_close(backend *be); int dblayer_get_index_file(backend *be,struct attrinfo *a, DB** ppDB, int create); int dblayer_release_index_file(backend *be,struct attrinfo *a, DB* pDB); int dblayer_erase_index_file(backend *be, struct attrinfo *a, int no_force_chkpt); int dblayer_erase_index_file_nolock(backend *be, struct attrinfo *a, int no_force_chkpt); int dblayer_get_id2entry(backend *be, DB **ppDB); int dblayer_release_id2entry(backend *be, DB *pDB); int dblayer_get_aux_id2entry(backend *be, DB **ppDB, DB_ENV **ppEnv); int dblayer_release_aux_id2entry(backend *be, DB *pDB, DB_ENV *pEnv); int dblayer_txn_init(struct ldbminfo *li, back_txn *txn); int dblayer_txn_begin(struct ldbminfo *li,back_txnid parent_txn, back_txn *txn); int dblayer_txn_commit(struct ldbminfo *li, back_txn *txn); int dblayer_txn_abort(struct ldbminfo *li, back_txn *txn); int dblayer_read_txn_abort(struct ldbminfo *li, back_txn *txn); int dblayer_read_txn_begin(struct ldbminfo *li,back_txnid parent_txn, back_txn *txn); int dblayer_read_txn_commit(struct ldbminfo *li, back_txn *txn); size_t dblayer_get_optimal_block_size(struct ldbminfo *li); void dblayer_unlock_backend(backend *be); void dblayer_lock_backend(backend *be); int dblayer_plugin_begin(Slapi_PBlock *pb); int dblayer_plugin_commit(Slapi_PBlock *pb); int dblayer_plugin_abort(Slapi_PBlock *pb); int dblayer_memp_stat(struct ldbminfo *li, DB_MPOOL_STAT **gsp,DB_MPOOL_FSTAT ***fsp); int dblayer_memp_stat_instance(ldbm_instance *inst, DB_MPOOL_STAT **gsp, DB_MPOOL_FSTAT ***fsp); int dblayer_backup(struct ldbminfo *li, char *destination_directory, Slapi_Task *task); int dblayer_restore(struct ldbminfo *li, char* source_directory, Slapi_Task *task, char *bename); int dblayer_copy_directory(struct ldbminfo *li, Slapi_Task *task, char *instance_dir, char *destination_dir, int restore, int *cnt, int instance_dir_flag, int indexonly, int resetlsns); int dblayer_copyfile(char* source, char * destination, int overwrite, int mode); int dblayer_delete_instance_dir(backend *be); int dblayer_delete_database(struct ldbminfo *li); int dblayer_database_size(struct ldbminfo *li, unsigned int *size); int dblayer_terminate(struct ldbminfo *li); int dblayer_close_indexes(backend *be); int dblayer_open_file(backend *be, char* indexname, int create, struct attrinfo *ai, DB **ppDB); int dblayer_close_file(DB *db); void dblayer_sys_pages(size_t *pagesize, size_t *pages, size_t *procpages, size_t *availpages); int dblayer_is_cachesize_sane(size_t *cachesize); void dblayer_remember_disk_filled(struct ldbminfo *li); int dblayer_open_huge_file(const char *path, int oflag, int mode); int dblayer_instance_start(backend *be, int normal_mode); int dblayer_make_new_instance_data_dir(backend *be); int dblayer_get_instance_data_dir(backend *be); char *dblayer_strerror(int error); PRInt64 db_atol(char *str, int *err); PRInt64 db_atoi(char *str, int *err); unsigned long db_strtoul(const char *str, int *err); int dblayer_set_batch_transactions(void *arg, void *value, char *errorbuf, int phase, int apply); void *dblayer_get_batch_transactions(void *arg); int dblayer_in_import(ldbm_instance *inst); int dblayer_update_db_ext(ldbm_instance *inst, char *oldext, char *newext); void dblayer_set_recovery_required(struct ldbminfo *li); char *dblayer_get_home_dir(struct ldbminfo *li, int *dbhome); char *dblayer_get_full_inst_dir(struct ldbminfo *li, ldbm_instance *inst, char *buf, int buflen); int check_and_set_import_cache(struct ldbminfo *li); int dblayer_db_uses_locking(DB_ENV *db_env); int dblayer_db_uses_transactions(DB_ENV *db_env); int dblayer_db_uses_mpool(DB_ENV *db_env); int dblayer_db_uses_logging(DB_ENV *db_env); int dblayer_bt_compare(DB *db, const DBT *dbt1, const DBT *dbt2); int dblayer_remove_env(struct ldbminfo *li); int ldbm_back_get_info(Slapi_Backend *be, int cmd, void **info); int ldbm_back_set_info(Slapi_Backend *be, int cmd, void *info); /* * dn2entry.c */ struct backentry *dn2entry(Slapi_Backend *be, const Slapi_DN *sdn, back_txn *txn, int *err); struct backentry *dn2entry_or_ancestor(Slapi_Backend *be, const Slapi_DN *sdn, Slapi_DN *ancestor, back_txn *txn, int *err); struct backentry *dn2ancestor(Slapi_Backend *be,const Slapi_DN *sdn,Slapi_DN *ancestordn,back_txn *txn,int *err); int get_copy_of_entry(Slapi_PBlock *pb, const entry_address *addr, back_txn *txn, int plock_parameter, int must_exist); void done_with_pblock_entry(Slapi_PBlock *pb, int plock_parameter); /* * uniqueid2entry.c */ struct backentry * uniqueid2entry(backend *be, const char *uniqueid, back_txn *txn, int *err); /* * filterindex.c */ IDList * filter_candidates( Slapi_PBlock *pb, backend *be, const char *base, Slapi_Filter *f, Slapi_Filter *nextf, int range, int *err ); /* * findentry.c */ struct backentry * find_entry2modify( Slapi_PBlock *pb, Slapi_Backend *be, const entry_address *addr, back_txn *txn ); struct backentry * find_entry( Slapi_PBlock *pb, Slapi_Backend *be, const entry_address *addr, back_txn *txn ); struct backentry * find_entry2modify_only( Slapi_PBlock *pb, Slapi_Backend *be, const entry_address *addr, back_txn *txn); struct backentry * find_entry_only( Slapi_PBlock *pb, Slapi_Backend *be, const entry_address *addr, back_txn *txn); int check_entry_for_referral(Slapi_PBlock *pb, Slapi_Entry *entry, char *matched, const char *callingfn); /* * haschildren.c */ int has_children( struct ldbminfo *li, struct backentry *p, back_txn *txn, int *err ); /* * id2entry.c */ int id2entry_add( backend *be, struct backentry *e, back_txn *txn ); int id2entry_add_ext( backend *be, struct backentry *e, back_txn *txn, int encrypt ); int id2entry_delete( backend *be, struct backentry *e, back_txn *txn ); struct backentry * id2entry( backend *be, ID id, back_txn *txn, int *err ); /* * idl.c */ IDList * idl_alloc( NIDS nids ); void idl_free( IDList *idl ); NIDS idl_length(IDList *idl); int idl_is_allids(IDList *idl); int idl_append(IDList *idl, ID id); int idl_append_extend(IDList **idl, ID id); void idl_insert(IDList **idl, ID id); /* * idl_delete - delete an id from an id list. * returns 0 id deleted * 1 id deleted, first id in block has changed * 2 id deleted, block is empty * 3 id not there * 4 cannot delete from allids block */ int idl_delete( IDList **idl, ID id ); IDList * idl_allids( backend *be ); IDList * idl_fetch( backend *be, DB* db, DBT *key, DB_TXN *txn, struct attrinfo *a, int *err ); int idl_insert_key( backend *be, DB* db, DBT *key, ID id, DB_TXN *txn, struct attrinfo *a,int *disposition ); int idl_delete_key( backend *be, DB *db, DBT *key, ID id, DB_TXN *txn, struct attrinfo *a ); IDList * idl_intersection( backend *be, IDList *a, IDList *b ); IDList * idl_union( backend *be, IDList *a, IDList *b ); int idl_notin( backend *be, IDList *a, IDList *b , IDList **new_result); ID idl_firstid( IDList *idl ); ID idl_nextid( IDList *idl, ID id ); int idl_init_private(backend *be, struct attrinfo *a); int idl_release_private(struct attrinfo *a); int idl_id_is_in_idlist(IDList *idl, ID id); idl_iterator idl_iterator_init(const IDList *idl); idl_iterator idl_iterator_increment(idl_iterator *i); idl_iterator idl_iterator_decrement(idl_iterator *i); ID idl_iterator_dereference(idl_iterator i, const IDList *idl); ID idl_iterator_dereference_increment(idl_iterator *i, const IDList *idl); size_t idl_sizeof(IDList *idl); int idl_store_block(backend *be,DB *db,DBT *key,IDList *idl,DB_TXN *txn,struct attrinfo *a); void idl_set_tune(int val); int idl_get_tune(); size_t idl_get_allidslimit(struct attrinfo *a); int idl_get_idl_new(); int idl_new_compare_dups( #if 1000*DB_VERSION_MAJOR + 100*DB_VERSION_MINOR >= 3200 DB *db, #endif const DBT *a, const DBT *b ); /* * index.c */ int index_addordel_entry( backend *be, struct backentry *e, int flags, back_txn *txn ); int index_add_mods( backend *be, const LDAPMod**mods, struct backentry *olde, struct backentry *newe, back_txn *txn ); int index_addordel_string(backend *be, const char *type, const char *s, ID id, int flags, back_txn *txn); int index_addordel_values_sv( backend *be, const char *type, Slapi_Value **vals, Slapi_Value **evals, ID id, int flags, back_txn *txn ); int index_addordel_values_ext_sv( backend *be, const char *type, Slapi_Value **vals, Slapi_Value **evals, ID id, int flags, back_txn *txn,int *idl_disposition, void *buffer_handle ); int id_array_init(Id_Array *new_guy, int size); IDList* index_read( backend *be, char *type, const char* indextype, const struct berval* val, back_txn *txn, int *err ); IDList* index_read_ext( backend *be, char *type, const char* indextype, const struct berval* val, back_txn *txn, int *err, int *unindexed ); IDList* index_range_read( Slapi_PBlock *pb, backend *be, char *type, const char* indextype, int ftype, struct berval* val, struct berval* nextval, int range, back_txn *txn, int *err ); const char *encode( const struct berval* data, char buf[BUFSIZ] ); extern const char* indextype_PRESENCE; extern const char* indextype_EQUALITY; extern const char* indextype_APPROX; extern const char* indextype_SUB; int index_buffer_init(size_t size,int flags,void **h); int index_buffer_flush(void *h,backend *be, DB_TXN *txn,struct attrinfo *a); int index_buffer_terminate(void *h); char* index_index2prefix (const char* indextype); void index_free_prefix (char*); /* * instance.c */ int ldbm_instance_create(backend *be, char *name); int ldbm_instance_create_default_indexes(backend *be); int ldbm_instance_start(backend *be); int ldbm_instance_stop(backend *be); int ldbm_instance_startall(struct ldbminfo *li); int ldbm_instance_stopall(struct ldbminfo *li); ldbm_instance *ldbm_instance_find_by_name(struct ldbminfo *li, char *name); int ldbm_instance_destroy(ldbm_instance *inst); /* * ldif2ldbm.c */ int import_subcount_mother_init(import_subcount_stuff *mothers,ID parent_id, size_t count); int import_subcount_mother_count(import_subcount_stuff *mothers,ID parent_id); void import_subcount_stuff_init(import_subcount_stuff *stuff); void import_subcount_stuff_term(import_subcount_stuff *stuff); int update_subordinatecounts(backend *be,import_subcount_stuff *mothers, int isencrypted, DB_TXN *txn); void import_configure_index_buffer_size(size_t size); size_t import_get_index_buffer_size(); int ldbm_back_fetch_incl_excl(Slapi_PBlock *pb, char ***include, char ***exclude); void ldbm_back_free_incl_excl(char **include, char **exclude); int ldbm_back_ok_to_dump(const char *dn, char **include, char **exclude); int ldbm_back_wire_import(Slapi_PBlock *pb); void *factory_constructor(void *object, void *parent); void factory_destructor(void *extension, void *object, void *parent); int get_parent_rdn(DB *db, ID parentid, Slapi_RDN *srdn); /* * modify.c */ int modify_update_all(backend *be, Slapi_PBlock *pb,modify_context *mc,back_txn *txn); void modify_init(modify_context *mc,struct backentry *old_entry); int modify_apply_mods(modify_context *mc, Slapi_Mods *smods); int modify_term(modify_context *mc,backend *be); int modify_switch_entries(modify_context *mc,backend *be); /* * add.c */ void add_update_entry_operational_attributes(struct backentry *ep, ID pid); void add_update_entrydn_operational_attributes(struct backentry *ep); /* * misc.c */ void ldbm_nasty(const char* str, int c, int err); void ldbm_log_access_message(Slapi_PBlock *pblock,char *string); int return_on_disk_full(struct ldbminfo *li); int ldbm_attribute_always_indexed(const char *attrtype); void ldbm_destroy_instance_name(struct ldbminfo *li); char *compute_entry_tombstone_dn(const char *entrydn, const char *uniqueid); char *compute_entry_tombstone_rdn(const char *entryrdn, const char *uniqueid); int instance_set_busy(ldbm_instance *inst); int instance_set_busy_and_readonly(ldbm_instance *inst); void instance_set_not_busy(ldbm_instance *inst); void allinstance_set_busy(struct ldbminfo *li); void allinstance_set_not_busy(struct ldbminfo *li); int is_anyinstance_busy(struct ldbminfo *li); int ldbm_delete_dirs(char *path); int mkdir_p(char *dir, unsigned int mode); int is_fullpath(char *path); char get_sep(char *path); int get_value_from_string(const char *string, char *type, char **value); int get_values_from_string(const char *string, char *type, char ***valuearray); void normalize_dir(char *dir); /* * nextid.c */ ID next_id( backend *be ); void next_id_return( backend *be, ID id ); ID next_id_get( backend *be ); void id_internal_to_stored(ID,char*); ID id_stored_to_internal(char*); void sizeushort_internal_to_stored(size_t i,char *b); size_t sizeushort_stored_to_internal(char* b); void get_ids_from_disk(backend *be); void get_both_ids( struct ldbminfo *li, ID *nextid, ID *nextid2index ); /* * backentry.c */ struct backentry *backentry_init( Slapi_Entry *e ); struct backentry *backentry_alloc(); void backentry_free( struct backentry **bep ); struct backentry *backentry_dup( struct backentry * ); void backentry_clear_entry( struct backentry * ); char *backentry_get_ndn(const struct backentry *e); const Slapi_DN *backentry_get_sdn(const struct backentry *e); struct backdn *backdn_init( Slapi_DN *sdn, ID id, int to_remove_from_hash ); void backdn_free( struct backdn **bdn ); /* * parents.c */ int parent_update_on_childchange(modify_context *mc,int op, size_t *numofchildren); /* * perfctrs.c */ void perfctrs_wait(size_t milliseconds,perfctrs_private *priv,DB_ENV *db_env); void perfctrs_init(struct ldbminfo *li,perfctrs_private **priv); void perfctrs_terminate(perfctrs_private **priv, DB_ENV *db_env); void perfctrs_as_entry( Slapi_Entry *e, perfctrs_private *priv, DB_ENV *db_env ); /* * rmdb.c */ int ldbm_back_rmdb( Slapi_PBlock *pb ); /* * sort.c */ /* * Definitions for sort spec object */ struct sort_spec_thing { char *type; /* attribute type */ char *matchrule; /* Matching rule string */ int order; /* 0 == ascending, 1 == decending */ struct sort_spec_thing *next; /* Link to the next one */ Slapi_PBlock *mr_pb; /* For matchrule indexing */ value_compare_fn_type compare_fn; /* For non-matchrule indexing */ Slapi_Attr sattr; }; typedef struct sort_spec_thing sort_spec_thing; typedef struct sort_spec_thing sort_spec; void sort_spec_free(sort_spec *s); int sort_candidates(backend *be, int lookthrough_limit, time_t time_up, Slapi_PBlock *pb, IDList *candidates, sort_spec_thing *sort_spec, char **sort_error_type) ; int make_sort_response_control ( Slapi_PBlock *pb, int code, char *error_type); int parse_sort_spec(struct berval *sort_spec_ber, sort_spec **ps); struct berval* attr_value_lowest(struct berval **values, value_compare_fn_type compare_fn); int sort_attr_compare(struct berval ** value_a, struct berval ** value_b, value_compare_fn_type compare_fn); void sort_log_access(Slapi_PBlock *pb,sort_spec_thing *s,IDList *candidates); /* * dbsize.c */ int ldbm_db_size( Slapi_PBlock *pb ); /* * external functions */ int ldbm_back_bind( Slapi_PBlock *pb ); int ldbm_back_unbind( Slapi_PBlock *pb ); int ldbm_back_search( Slapi_PBlock *pb ); int ldbm_back_compare( Slapi_PBlock *pb ); int ldbm_back_modify( Slapi_PBlock *pb ); int ldbm_back_modrdn( Slapi_PBlock *pb ); int ldbm_back_add( Slapi_PBlock *pb ); int ldbm_back_delete( Slapi_PBlock *pb ); int ldbm_back_abandon( Slapi_PBlock *pb ); int ldbm_back_config( Slapi_PBlock *pb ); int ldbm_back_close( Slapi_PBlock *pb ); int ldbm_back_cleanup( Slapi_PBlock *pb ); void ldbm_back_instance_set_destructor(void **arg); int ldbm_back_flush( Slapi_PBlock *pb ); int ldbm_back_start( Slapi_PBlock *pb ); int ldbm_back_seq( Slapi_PBlock *pb ); int ldbm_back_ldif2ldbm( Slapi_PBlock *pb ); int ldbm_back_ldbm2ldif( Slapi_PBlock *pb ); int ldbm_back_ldbm2ldifalt( Slapi_PBlock *pb ); int ldbm_back_ldbm2index( Slapi_PBlock *pb ); int ldbm_back_upgradednformat( Slapi_PBlock *pb ); int ldbm_back_archive2ldbm( Slapi_PBlock *pb ); int ldbm_back_ldbm2archive( Slapi_PBlock *pb ); int ldbm_back_upgradedb( Slapi_PBlock *pb ); int ldbm_back_dbverify( Slapi_PBlock *pb ); int ldbm_back_next_search_entry( Slapi_PBlock *pb ); int ldbm_back_next_search_entry_ext( Slapi_PBlock *pb, int use_extension ); int ldbm_back_db_test( Slapi_PBlock *pb ); int ldbm_back_entry_release( Slapi_PBlock *pb, void *backend_info_ptr ); void ldbm_back_search_results_release( void **search_results ); int ldbm_back_init( Slapi_PBlock *pb ); void ldbm_back_prev_search_results( Slapi_PBlock *pb ); int ldbm_back_isinitialized(); /* * monitor.c */ int ldbm_back_monitor_search(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter, int *returncode, char *returntext, void *arg); int ldbm_back_monitor_instance_search(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *entryAfter, int *returncode, char *returntext, void *arg); int ldbm_back_dbmonitor_search(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *entryAfter, int *returncode, char *returntext, void *arg); /* * vlv.c */ struct vlv_request { ber_int_t beforeCount; ber_int_t afterCount; ber_tag_t tag; ber_int_t index; ber_int_t contentCount; struct berval value; }; struct vlv_response { ber_int_t targetPosition; ber_int_t contentCount; ber_int_t result; }; int vlv_init(ldbm_instance *inst); int vlv_remove_callbacks(ldbm_instance *inst); const Slapi_Entry **vlv_get_search_entries(); struct vlvIndex* vlv_find_searchname(const char * name, backend *be); struct vlvIndex* vlv_find_indexname(const char * name, backend *be); char *vlv_getindexnames(); int vlv_search_build_candidate_list(Slapi_PBlock *pb, const Slapi_DN *base, int *rc, const sort_spec* sort_control, const struct vlv_request *vlv_request_control, IDList** candidates, struct vlv_response *vlv_response_control); int vlv_update_index(struct vlvIndex* p, back_txn *txn, struct ldbminfo *li, Slapi_PBlock *pb, struct backentry* oldEntry, struct backentry* newEntry); int vlv_update_all_indexes(back_txn *txn, backend *be, Slapi_PBlock *pb, struct backentry* oldEntry, struct backentry* newEntry); int vlv_filter_candidates(backend *be, Slapi_PBlock *pb, const IDList *candidates, const Slapi_DN *base, int scope, Slapi_Filter *filter, IDList** filteredCandidates,int lookthrough_limit, time_t time_up); int vlv_trim_candidates(backend *be, const IDList *candidates, const sort_spec* sort_control, const struct vlv_request *vlv_request_control, IDList** filteredCandidates,struct vlv_response *pResponse); int vlv_parse_request_control(backend *be, struct berval *vlv_spec_ber, struct vlv_request* vlvp); int vlv_make_response_control(Slapi_PBlock *pb, const struct vlv_response* vlvp); void vlv_getindices(IFP callback_fn,void *param, backend *be); void vlv_print_access_log(Slapi_PBlock *pb,struct vlv_request* vlvi, struct vlv_response *vlvo); void vlv_grok_new_import_entry(const struct backentry *e, backend *be); IDList *vlv_find_index_by_filter(struct backend *be, const char *base, Slapi_Filter *f); int vlv_delete_search_entry(Slapi_PBlock *pb, Slapi_Entry* e, ldbm_instance *inst); void vlv_acquire_lock(backend *be); void vlv_release_lock(backend *be); int vlv_isvlv(char *filename); /* * Indexfile.c */ int indexfile_delete_all_keys(backend *be,char* type,back_txn *txn); int indexfile_primary_modifyall(backend *be, LDAPMod **mods_to_perform,char **indexes_to_update,back_txn *txn); /* * bedse.c */ #if 0 int bedse_init(); int bedse_search(Slapi_PBlock *pb); struct dse_callback *bedse_register_callback(int operation, const Slapi_DN *base, int scope, const char *filter, int (*fn)(Slapi_PBlock *,Slapi_Entry *,Slapi_Entry *,int*,char*,void *), void *fn_arg); void bedse_remove_callback(int operation, const Slapi_DN *base, int scope, const char *filter, int (*fn)(Slapi_PBlock *,Slapi_Entry *,Slapi_Entry *,int*,char*,void *)); int bedse_add_index_entry(int argc, char **argv); #endif /* * ldbm_search.c */ Slapi_Filter* create_onelevel_filter(Slapi_Filter* filter, const struct backentry *e, int managedsait, Slapi_Filter** fid2kids, Slapi_Filter** focref, Slapi_Filter** fand, Slapi_Filter** forr); Slapi_Filter* create_subtree_filter(Slapi_Filter* filter, int managedsait, Slapi_Filter** focref, Slapi_Filter** forr); IDList* subtree_candidates(Slapi_PBlock *pb, backend *be, const char *base, const struct backentry *e, Slapi_Filter *filter, int managedsait, int *allids_before_scopingp, int *err); void search_set_tune(struct ldbminfo *li,int val); int search_get_tune(struct ldbminfo *li); int compute_lookthrough_limit( Slapi_PBlock *pb, struct ldbminfo *li ); /* * matchrule.c */ int create_matchrule_indexer(Slapi_PBlock **pb,char* matchrule,char* type); int destroy_matchrule_indexer(Slapi_PBlock *pb); int matchrule_values_to_keys(Slapi_PBlock *pb,struct berval **input_values,struct berval ***output_values); int matchrule_values_to_keys_sv(Slapi_PBlock *pb,Slapi_Value **input_values, Slapi_Value ***output_values); /* * upgrade.c */ int check_db_version(struct ldbminfo *li, int *action); int check_db_inst_version(ldbm_instance *inst); int adjust_idl_switch(char *ldbmversion, struct ldbminfo *li); int ldbm_upgrade(ldbm_instance *inst, int action); int lookup_dbversion(char *dbversion, int flag); /* * init.c */ int ldbm_attribute_always_indexed(const char *attrtype); /* * dbversion.c */ int dbversion_write(struct ldbminfo *li, const char *directory, const char *dataversion, PRUint32 flags); int dbversion_read(struct ldbminfo *li, const char *directory, char **ldbmversion, char **dataversion); int dbversion_exists(struct ldbminfo *li, const char *directory); /* * config_ldbm.c */ int ldbm_config_load_dse_info(struct ldbminfo *li); void ldbm_config_setup_default(struct ldbminfo *li); void ldbm_config_internal_set(struct ldbminfo *li, char *attrname, char *value); void ldbm_instance_config_internal_set(ldbm_instance *inst, char *attrname, char *value); void ldbm_instance_config_setup_default(ldbm_instance *inst); int ldbm_instance_postadd_instance_entry_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry* entryAfter, int *returncode, char *returntext, void *arg); int ldbm_instance_add_instance_entry_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry* entryAfter, int *returncode, char *returntext, void *arg); int ldbm_instance_delete_instance_entry_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry* entryAfter, int *returncode, char *returntext, void *arg); int ldbm_instance_post_delete_instance_entry_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry* entryAfter, int *returncode, char *returntext, void *arg); /* Index config functions */ int ldbm_index_init_entry_callback(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter, int *returncode, char *returntext, void *arg); int ldbm_instance_index_config_add_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry* e, int *returncode, char *returntext, void *arg); int ldbm_instance_index_config_delete_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry* e, int *returncode, char *returntext, void *arg); int ldbm_instance_index_config_modify_callback(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *entryAfter, int *returncode, char *returntext, void *arg); /* Attribute Encryption config functions */ int ldbm_attrcrypt_init_entry_callback(Slapi_PBlock *pb, Slapi_Entry* e, Slapi_Entry* entryAfter, int *returncode, char *returntext, void *arg); int ldbm_instance_attrcrypt_config_add_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry* e, int *returncode, char *returntext, void *arg); int ldbm_instance_attrcrypt_config_delete_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry* e, int *returncode, char *returntext, void *arg); int ldbm_instance_attrcrypt_config_modify_callback(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *entryAfter, int *returncode, char *returntext, void *arg); void replace_ldbm_config_value(char *conftype, char *val, struct ldbminfo *li); /* * ancestorid.c */ int ldbm_ancestorid_create_index(backend *be); int ldbm_ancestorid_index_entry(backend *be, struct backentry *e, int flags, back_txn *txn); int ldbm_ancestorid_read(backend *be, back_txn *txn, ID id, IDList **idl); int ldbm_ancestorid_move_subtree( backend *be, const Slapi_DN *olddn, const Slapi_DN *newdn, ID id, IDList *subtree_idl, back_txn *txn ); /* * import-threads.c */ int dse_conf_backup(struct ldbminfo *li, char *destination_directory); int dse_conf_verify(struct ldbminfo *li, char *src_dir, char *bename); /* * ldbm_attrcrypt.c */ int attrcrypt_decrypt_entry(backend *be, struct backentry *e); int attrcrypt_encrypt_entry_inplace(backend *be, const struct backentry *inout); int attrcrypt_encrypt_entry(backend *be, const struct backentry *in, struct backentry **out); int attrcrypt_encrypt_index_key(backend *be, struct attrinfo *ai, const struct berval *in, struct berval **out); int attrcrypt_decrypt_index_key(backend *be, struct attrinfo *ai, const struct berval *in, struct berval **out); int attrcrypt_init(ldbm_instance *li); int attrcrypt_cleanup_private(ldbm_instance *li); /* * ldbm_usn.c */ void ldbm_usn_init(struct ldbminfo *li); int ldbm_usn_enabled(backend *be); int ldbm_set_last_usn(Slapi_Backend *be); /* * ldbm_entryrdn.c */ void entryrdn_set_switch(int val); int entryrdn_get_switch(); void entryrdn_set_noancestorid(int val); int entryrdn_get_noancestorid(); int entryrdn_compare_dups(DB *db, const DBT *a, const DBT *b); int entryrdn_index_entry(backend *be, struct backentry *e, int flags, back_txn *txn); int entryrdn_index_read(backend *be, const Slapi_DN *sdn, ID *id, back_txn *txn); int entryrdn_rename_subtree(backend *be, const Slapi_DN *oldsdn, Slapi_RDN *newsrdn, const Slapi_DN *newsupsdn, ID id, back_txn *txn); int entryrdn_get_subordinates(backend *be, const Slapi_DN *sdn, ID id, IDList **subordinates, back_txn *txn); int entryrdn_lookup_dn(backend *be, const char *rdn, ID id, char **dn, back_txn *txn); int entryrdn_get_parent(backend *be, const char *rdn, ID id, char **prdn, ID *pid, back_txn *txn); #endif