X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;ds=sidebyside;f=servers%2Fslapd%2Fslap.h;h=3527503339674dbdf0cdea66d1710d7b85680df9;hb=3492452a5b808aae97b8072a7a49f15e3a9a199d;hp=bb41efc677427e85eaa3e763dc0e1084c30afa32;hpb=42f8426b5b9766b9cdd7c8e3affef1e9c1940192;p=openldap diff --git a/servers/slapd/slap.h b/servers/slapd/slap.h index bb41efc677..3527503339 100644 --- a/servers/slapd/slap.h +++ b/servers/slapd/slap.h @@ -476,7 +476,7 @@ typedef struct slap_matching_rule { #define SLAP_MR_ORDERING 0x0200U #define SLAP_MR_SUBSTR 0x0400U #define SLAP_MR_EXT 0x0800U /* implicitly extensible */ -#define SLAP_MR_ORDERED_INDEX 0x1000U +#define SLAP_MR_ORDERED_INDEX 0x1000U #ifdef LDAP_COMP_MATCH #define SLAP_MR_COMPONENT 0x2000U #endif @@ -848,6 +848,7 @@ struct slap_internal_schema { AttributeDescription *si_ad_distinguishedName; AttributeDescription *si_ad_name; AttributeDescription *si_ad_cn; + AttributeDescription *si_ad_uid; AttributeDescription *si_ad_userPassword; AttributeDescription *si_ad_labeledURI; #ifdef SLAPD_AUTHPASSWD @@ -1028,6 +1029,13 @@ typedef struct slap_valuesreturnfilter { struct slap_valuesreturnfilter *vrf_next; } ValuesReturnFilter; +#ifdef LDAP_COMP_MATCH +typedef struct slap_component_data { + void* cd_mem_op;/* nibble memory handler */ + void* cd_tree; /* component tree */ +} ComponentData; +#endif + /* * represents an attribute (description + values) */ @@ -1035,13 +1043,13 @@ typedef struct slap_attr { AttributeDescription *a_desc; BerVarray a_vals; /* preserved values */ BerVarray a_nvals; /* normalized values */ +#ifdef LDAP_COMP_MATCH + ComponentData *a_comp_data; /* component values */ +#endif struct slap_attr *a_next; unsigned a_flags; #define SLAP_ATTR_IXADD 0x1U #define SLAP_ATTR_IXDEL 0x2U -#ifdef LDAP_COMP_MATCH - void* a_component_values; /* component values */ -#endif } Attribute; @@ -1136,6 +1144,9 @@ typedef enum slap_style_e { ACL_STYLE_SUBTREE, ACL_STYLE_CHILDREN, ACL_STYLE_ATTROF, + ACL_STYLE_ANONYMOUS, + ACL_STYLE_USERS, + ACL_STYLE_SELF, ACL_STYLE_IP, ACL_STYLE_PATH } slap_style_t; @@ -1153,6 +1164,43 @@ typedef struct slap_authz_info { slap_ssf_t sai_sasl_ssf; /* SASL SSF */ } AuthorizationInformation; + +#ifdef LDAP_DEVEL +#define SLAP_DYNACL +#endif /* LDAP_DEVEL */ + +#ifdef SLAP_DYNACL +struct slap_op; + +/* + * "dynamic" ACL infrastructure (for ACIs and more) + */ +typedef int (*slap_dynacl_parse)( const char *fname, int lineno, slap_style_t, const char *, void **privp ); +typedef int (*slap_dynacl_print)( void *priv ); +typedef int (*slap_dynacl_mask)( + void *priv, + struct slap_op *op, + Entry *e, + AttributeDescription *desc, + struct berval *val, + int nmatch, + regmatch_t *matches, + slap_access_t *grant, + slap_access_t *deny ); +typedef int (*slap_dynacl_destroy)( void *priv ); + +typedef struct slap_dynacl_t { + char *da_name; + slap_dynacl_parse da_parse; + slap_dynacl_print da_print; + slap_dynacl_mask da_mask; + slap_dynacl_destroy da_destroy; + + void *da_private; + struct slap_dynacl_t *da_next; +} slap_dynacl_t; +#endif /* SLAP_DYNACL */ + /* the "by" part */ typedef struct slap_access { slap_control_t a_type; @@ -1242,9 +1290,13 @@ typedef struct slap_access { slap_style_t a_set_style; struct berval a_set_pat; +#ifdef SLAP_DYNACL + slap_dynacl_t *a_dynacl; +#else /* ! SLAP_DYNACL */ #ifdef SLAPD_ACI_ENABLED AttributeDescription *a_aci_at; #endif +#endif /* SLAP_DYNACL */ /* ACL Groups */ slap_style_t a_group_style; @@ -1448,7 +1500,6 @@ typedef struct syncinfo_s { int si_manageDSAit; int si_slimit; int si_tlimit; - struct berval si_syncUUID_ndn; int si_refreshDelete; int si_refreshPresent; Avlnode *si_presentlist; @@ -1521,6 +1572,7 @@ struct slap_backend_db { #define SLAP_DBFLAG_GLUE_INSTANCE 0x0010U /* a glue backend */ #define SLAP_DBFLAG_GLUE_SUBORDINATE 0x0020U /* child of a glue hierarchy */ #define SLAP_DBFLAG_GLUE_LINKED 0x0040U /* child is connected to parent */ +#define SLAP_DBFLAG_OVERLAY 0x0080U /* this db struct is an overlay */ #define SLAP_DBFLAG_SHADOW 0x8000U /* a shadow */ #define SLAP_DBFLAG_SYNC_SHADOW 0x1000U /* a sync shadow */ #define SLAP_DBFLAG_SLURP_SHADOW 0x2000U /* a slurp shadow */ @@ -1528,6 +1580,7 @@ struct slap_backend_db { #define SLAP_DBFLAGS(be) ((be)->be_flags) #define SLAP_NOLASTMOD(be) (SLAP_DBFLAGS(be) & SLAP_DBFLAG_NOLASTMOD) #define SLAP_LASTMOD(be) (!SLAP_NOLASTMOD(be)) +#define SLAP_ISOVERLAY(be) (SLAP_DBFLAGS(be) & SLAP_DBFLAG_OVERLAY) #define SLAP_NO_SCHEMA_CHECK(be) \ (SLAP_DBFLAGS(be) & SLAP_DBFLAG_NO_SCHEMA_CHECK) #define SLAP_GLUE_INSTANCE(be) \ @@ -1616,7 +1669,6 @@ struct slap_backend_db { struct be_pcl *be_pending_csn_list; ldap_pvt_thread_mutex_t be_pcl_mutex; ldap_pvt_thread_mutex_t *be_pcl_mutexp; - struct berval be_context_csn; LDAP_STAILQ_HEAD( be_si, syncinfo_s ) be_syncinfo; /* For syncrepl */ char *be_realm; @@ -1693,13 +1745,22 @@ typedef struct req_abandon_s { ber_int_t rs_msgid; } req_abandon_s; +#ifdef LDAP_DEVEL +#define SLAP_EXOP_HIDE 0x0000 +#else +#define SLAP_EXOP_HIDE 0x8000 +#endif +#define SLAP_EXOP_WRITES 0x0001 /* Exop does writes */ + typedef struct req_extended_s { struct berval rs_reqoid; + int rs_flags; struct berval *rs_reqdata; } req_extended_s; typedef struct req_pwdexop_s { struct berval rs_reqoid; + int rs_flags; struct berval rs_old; struct berval rs_new; Modifications *rs_mods; @@ -1992,6 +2053,7 @@ typedef struct slap_overinfo { typedef unsigned long PagedResultsCookie; typedef struct slap_paged_state { Backend *ps_be; + ber_int_t ps_size; PagedResultsCookie ps_cookie; int ps_count; } PagedResultsState; @@ -2003,11 +2065,12 @@ typedef struct slap_paged_state { #define LDAP_PSEARCH_BY_SCOPEOUT 0x05 #define LDAP_PSEARCH_BY_PREDELETE 0x06 -struct psid_entry { +struct psid_entry { /* DELETE ME */ struct slap_op *ps_op; LDAP_LIST_ENTRY(psid_entry) ps_link; }; +#if 0 /* DELETE ME */ struct slog_entry { struct berval sl_uuid; struct berval sl_name; @@ -2022,9 +2085,10 @@ struct slap_session_entry { struct berval se_spec; LDAP_LIST_ENTRY( slap_session_entry ) se_link; }; +#endif struct slap_csn_entry { - struct berval *ce_csn; + struct berval ce_csn; unsigned long ce_opid; unsigned long ce_connid; #define SLAP_CSN_PENDING 1 @@ -2056,21 +2120,82 @@ typedef struct slap_gacl { char ga_ndn[1]; } GroupAssertion; +#ifndef SLAP_MAX_CIDS +#define SLAP_MAX_CIDS 32 /* Maximum number of supported controls */ +#endif + +struct slap_control_ids { + int sc_assert; + int sc_preRead; + int sc_postRead; + int sc_proxyAuthz; + int sc_manageDSAit; + int sc_modifyIncrement; + int sc_noOp; + int sc_pagedResults; + int sc_valuesReturnFilter; + int sc_permissiveModify; + int sc_domainScope; + int sc_treeDelete; + int sc_searchOptions; + int sc_subentries; + int sc_LDAPsync; +}; + /* * represents an operation pending from an ldap client */ +typedef struct slap_op_header { + unsigned long oh_opid; /* id of this operation */ + unsigned long oh_connid; /* id of conn initiating this op */ + struct slap_conn *oh_conn; /* connection spawning this op */ + + ber_int_t oh_msgid; /* msgid of the request */ + ber_int_t oh_protocol; /* version of the LDAP protocol used by client */ + + ldap_pvt_thread_t oh_tid; /* thread handling this op */ + + void *oh_threadctx; /* thread pool thread context */ + void *oh_tmpmemctx; /* slab malloc context */ + BerMemoryFunctions *oh_tmpmfuncs; + + char oh_log_prefix[sizeof("conn=18446744073709551615 op=18446744073709551615")]; + +#ifdef LDAP_SLAPI + void *oh_pb; /* NS-SLAPI plugin */ + void *oh_extensions; /* NS-SLAPI plugin */ +#endif +} Opheader; + typedef struct slap_op { - unsigned long o_opid; /* id of this operation */ - unsigned long o_connid; /* id of conn initiating this op */ - char o_log_prefix[sizeof("conn=18446744073709551615 op=18446744073709551615")]; - struct slap_conn *o_conn; /* connection spawning this op */ - BackendDB *o_bd; /* backend DB processing this op */ + Opheader *o_hdr; + +#define o_opid o_hdr->oh_opid +#define o_connid o_hdr->oh_connid +#define o_conn o_hdr->oh_conn +#define o_msgid o_hdr->oh_msgid +#define o_protocol o_hdr->oh_protocol +#define o_tid o_hdr->oh_tid +#define o_threadctx o_hdr->oh_threadctx +#define o_tmpmemctx o_hdr->oh_tmpmemctx +#define o_tmpmfuncs o_hdr->oh_tmpmfuncs + +#define o_tmpalloc o_tmpmfuncs->bmf_malloc +#define o_tmpcalloc o_tmpmfuncs->bmf_calloc +#define o_tmprealloc o_tmpmfuncs->bmf_realloc +#define o_tmpfree o_tmpmfuncs->bmf_free + +#define o_log_prefix o_hdr->oh_log_prefix + +#ifdef LDAP_SLAPI +#define o_pb o_hdr->oh_pb +#define o_extensions o_hdr->oh_extensions +#endif - ber_int_t o_msgid; /* msgid of the request */ - ber_int_t o_protocol; /* version of the LDAP protocol used by client */ ber_tag_t o_tag; /* tag of the request */ time_t o_time; /* time op was initiated */ + BackendDB *o_bd; /* backend DB processing this op */ struct berval o_req_dn; /* DN of target of request */ struct berval o_req_ndn; @@ -2131,10 +2256,8 @@ typedef struct slap_op { #define orm_increment oq_modify.rs_increment #define ore_reqoid oq_extended.rs_reqoid +#define ore_flags oq_extended.rs_flags #define ore_reqdata oq_extended.rs_reqdata - - ldap_pvt_thread_t o_tid; /* thread handling this op */ - volatile sig_atomic_t o_abandon; /* abandon flag */ volatile sig_atomic_t o_cancel; /* cancel flag */ #define SLAP_CANCEL_NONE 0x00 @@ -2146,63 +2269,81 @@ typedef struct slap_op { char o_do_not_cache; /* don't cache groups from this op */ char o_is_auth_check; /* authorization in progress */ -#define SLAP_IGNORED_CONTROL -1 -#define SLAP_NO_CONTROL 0 -#define SLAP_NONCRITICAL_CONTROL 1 -#define SLAP_CRITICAL_CONTROL 2 - char o_managedsait; -#define get_manageDSAit(op) ((int)(op)->o_managedsait) +#define SLAP_CONTROL_NONE 0 +#define SLAP_CONTROL_IGNORED 1 +#define SLAP_CONTROL_NONCRITICAL 2 +#define SLAP_CONTROL_CRITICAL 3 +#define SLAP_CONTROL_MASK 3 + +/* spare bits for simple flags */ +#define SLAP_CONTROL_SHIFT 4 /* shift to reach data bits */ +#define SLAP_CONTROL_DATA0 0x10 +#define SLAP_CONTROL_DATA1 0x20 +#define SLAP_CONTROL_DATA2 0x40 +#define SLAP_CONTROL_DATA3 0x80 + + +#define _SCM(x) ((x) & SLAP_CONTROL_MASK) + + char o_ctrlflag[SLAP_MAX_CIDS]; /* per-control flags */ + void **o_controls; /* per-control state */ + +#define o_managedsait o_ctrlflag[slap_cids.sc_manageDSAit] +#define get_manageDSAit(op) _SCM((op)->o_managedsait) - char o_noop; - char o_proxy_authz; +#define o_noop o_ctrlflag[slap_cids.sc_noOp] +#define o_proxy_authz o_ctrlflag[slap_cids.sc_proxyAuthz] +#define o_subentries o_ctrlflag[slap_cids.sc_subentries] - char o_subentries; -#define get_subentries(op) ((int)(op)->o_subentries) - char o_subentries_visibility; -#define get_subentries_visibility(op) ((int)(op)->o_subentries_visibility) +#define get_subentries(op) _SCM((op)->o_subentries) +#define o_subentries_visibility o_ctrlflag[slap_cids.sc_subentries] - char o_assert; +#define set_subentries_visibility(op) ((op)->o_subentries |= SLAP_CONTROL_DATA0) +#define get_subentries_visibility(op) (((op)->o_subentries & SLAP_CONTROL_DATA0) != 0) + +#define o_assert o_ctrlflag[slap_cids.sc_assert] #define get_assert(op) ((int)(op)->o_assert) +#define o_assertion o_controls[slap_cids.sc_assert] +#define get_assertion(op) ((op)->o_assertion) - char o_valuesreturnfilter; +#define o_valuesreturnfilter o_ctrlflag[slap_cids.sc_valuesReturnFilter] +#define o_vrFilter o_controls[slap_cids.sc_valuesReturnFilter] #ifdef LDAP_CONTROL_X_PERMISSIVE_MODIFY - char o_permissive_modify; +#define o_permissive_modify o_ctrlflag[slap_cids.sc_permissiveModify] #define get_permissiveModify(op) ((int)(op)->o_permissive_modify) #else #define get_permissiveModify(op) (0) #endif #ifdef LDAP_CONTROL_X_DOMAIN_SCOPE - char o_domain_scope; +#define o_domain_scope o_ctrlflag[slap_cids.sc_domainScope] #define get_domainScope(op) ((int)(op)->o_domain_scope) #else #define get_domainScope(op) (0) #endif #ifdef LDAP_CONTROL_X_TREE_DELETE - char o_tree_delete; +#define o_tree_delete o_ctrlflag[slap_cids.sc_treeDelete] #define get_treeDelete(op) ((int)(op)->o_tree_delete) #else #define get_treeDelete(op) (0) #endif - char o_preread; - char o_postread; - AttributeName *o_preread_attrs; - AttributeName *o_postread_attrs; +#define o_preread o_ctrlflag[slap_cids.sc_preRead] +#define o_postread o_ctrlflag[slap_cids.sc_postRead] + +#define o_preread_attrs o_controls[slap_cids.sc_preRead] +#define o_postread_attrs o_controls[slap_cids.sc_postRead] + +#define o_pagedresults o_ctrlflag[slap_cids.sc_pagedResults] +#define o_pagedresults_state o_controls[slap_cids.sc_pagedResults] + +#define o_sync o_ctrlflag[slap_cids.sc_LDAPsync] - char o_pagedresults; #define get_pagedresults(op) ((int)(op)->o_pagedresults) - ber_int_t o_pagedresults_size; - PagedResultsState o_pagedresults_state; - - char o_sync; - char o_sync_mode; -#define SLAP_SYNC_NONE LDAP_SYNC_NONE -#define SLAP_SYNC_REFRESH LDAP_SYNC_REFRESH_ONLY -#define SLAP_SYNC_PERSIST LDAP_SYNC_RESERVED -#define SLAP_SYNC_REFRESH_AND_PERSIST LDAP_SYNC_REFRESH_AND_PERSIST + +#ifdef BDB_PSEARCH struct sync_cookie o_sync_state; int o_sync_rhint; struct berval o_sync_cid; @@ -2223,6 +2364,7 @@ typedef struct slap_op { Avlnode *o_psearch_finished; struct pc_entry *o_ps_send_wait; ldap_pvt_thread_mutex_t o_pcmutex; +#endif AuthorizationInformation o_authz; @@ -2231,30 +2373,15 @@ typedef struct slap_op { slap_callback *o_callback; /* callback pointers */ LDAPControl **o_ctrls; /* controls */ - void *o_threadctx; /* thread pool thread context */ - void *o_tmpmemctx; /* slab malloc context */ - BerMemoryFunctions *o_tmpmfuncs; -#define o_tmpalloc o_tmpmfuncs->bmf_malloc -#define o_tmpcalloc o_tmpmfuncs->bmf_calloc -#define o_tmprealloc o_tmpmfuncs->bmf_realloc -#define o_tmpfree o_tmpmfuncs->bmf_free void *o_private; /* anything the backend needs */ LDAP_STAILQ_ENTRY(slap_op) o_next; /* next operation in list */ - Filter *o_assertion; /* Assert control filter */ -#define get_assertion(op) ((op)->o_assertion) - - ValuesReturnFilter *o_vrFilter; /* ValuesReturnFilter */ - int o_nocaching; int o_delete_glue_parent; -#ifdef LDAP_SLAPI - void *o_pb; /* NS-SLAPI plugin */ - void *o_extensions; /* NS-SLAPI plugin */ -#endif } Operation; +#define OPERATION_BUFFER_SIZE (sizeof(Operation)+sizeof(Opheader)+SLAP_MAX_CIDS*sizeof(void *)) #define send_ldap_error( op, rs, err, text ) do { \ (rs)->sr_err = err; (rs)->sr_text = text; \ @@ -2277,15 +2404,15 @@ typedef void (SEND_LDAP_INTERMEDIATE)( struct slap_op *op, struct slap_rep *rs); #define send_ldap_result( op, rs ) \ - (op->o_conn->c_send_ldap_result)( op, rs ) + ((op)->o_conn->c_send_ldap_result)( op, rs ) #define send_search_entry( op, rs ) \ - (op->o_conn->c_send_search_entry)( op, rs ) + ((op)->o_conn->c_send_search_entry)( op, rs ) #define send_search_reference( op, rs ) \ - (op->o_conn->c_send_search_reference)( op, rs ) + ((op)->o_conn->c_send_search_reference)( op, rs ) #define send_ldap_extended( op, rs ) \ - (op->o_conn->c_send_ldap_extended)( op, rs ) + ((op)->o_conn->c_send_ldap_extended)( op, rs ) #define send_ldap_intermediate( op, rs ) \ - (op->o_conn->c_send_ldap_intermediate)( op, rs ) + ((op)->o_conn->c_send_ldap_intermediate)( op, rs ) typedef struct slap_listener Listener; @@ -2501,6 +2628,11 @@ typedef int (SLAP_CTRL_PARSE_FN) LDAP_P(( LDAPControl *ctrl )); #define SLAP_SLAB_SIZE (1024*1024) +#define SLAP_SLAB_STACK 1 +#define SLAP_SLAB_SOBLOCK 64 + +#define SLAP_ZONE_ALLOC 1 +#undef SLAP_ZONE_ALLOC #if defined(LDAP_DEVEL) && defined(ENABLE_REWRITE) /* use librewrite for sasl-regexp */ @@ -2548,7 +2680,7 @@ typedef int (SLAP_CTRL_PARSE_FN) LDAP_P(( #define LDAP_COMP_FILTER_ITEM ((ber_tag_t) 0xa3U) #define LDAP_COMP_FILTER_UNDEFINED ((ber_tag_t) 0xa4U) -typedef struct slap_component_id{ +typedef struct slap_component_id { int ci_type; struct slap_component_id *ci_next; @@ -2557,6 +2689,7 @@ typedef struct slap_component_id{ ber_int_t ci_from_beginning; ber_int_t ci_count; ber_int_t ci_from_end; + ber_int_t ci_content; BerValue ci_select_value; char ci_all; } ci_val; @@ -2574,7 +2707,7 @@ typedef struct slap_component_assertion { ber_int_t ca_use_def; MatchingRule *ca_ma_rule; struct berval ca_ma_value; - void* ca_component_values; + ComponentData ca_comp_data; /* componentized assertion */ struct slap_component_filter *ca_cf; MatchingRuleAssertion *ca_mra; } ComponentAssertion; @@ -2602,16 +2735,19 @@ typedef struct slap_component_assertion_value { char* cav_ptr; char* cav_end; } ComponentAssertionValue; -/* + +#if 0 typedef int encoder_func LDAP_P(( void* b, - void* comp));*/ + void* comp)); +#endif struct slap_component_syntax_info; typedef int gser_decoder_func LDAP_P(( + void* mem_op, void* b, - struct slap_component_syntax_info* comp_syn_info, + struct slap_component_syntax_info** comp_syn_info, int* len, int mode)); @@ -2619,6 +2755,7 @@ typedef int comp_free_func LDAP_P(( void* b)); typedef int ber_decoder_func LDAP_P(( + void* mem_op, void* b, int tag, int elmtLen, @@ -2627,12 +2764,14 @@ typedef int ber_decoder_func LDAP_P(( int mode)); typedef int ber_tag_decoder_func LDAP_P(( + void* mem_op, void* b, struct slap_component_syntax_info* comp_syn_info, int* len, int mode)); typedef void* extract_component_from_id_func LDAP_P(( + void* mem_op, ComponentReference* cr, void* comp )); @@ -2641,8 +2780,15 @@ typedef void* convert_attr_to_comp_func LDAP_P (( Syntax* syn, struct berval* bv )); +typedef void* alloc_nibble_func LDAP_P (( + int initial_size, + int increment_size )); + +typedef void free_nibble_func LDAP_P (( + void* nm )); + struct slap_component_syntax_info; -typedef int convert_assert_to_comp_func LDAP_P (( +typedef void* convert_assert_to_comp_func LDAP_P (( struct slap_component_syntax_info* csi_attr, struct berval* bv, struct slap_component_syntax_info** csi, @@ -2654,7 +2800,16 @@ typedef int convert_asn_to_ldap_func LDAP_P (( struct berval *bv )); typedef void free_component_func LDAP_P (( - struct slap_component_syntax_info* csi )); + void* mem_op)); + +typedef int test_component_func LDAP_P (( + void* attr_mem_op, + void* assert_mem_op, + struct slap_component_syntax_info* csi, + struct slap_component_assertion* ca)); + +typedef void* test_membership_func LDAP_P (( + void* in )); typedef int allcomponent_matching_func LDAP_P(( char* oid, @@ -2665,6 +2820,7 @@ typedef struct slap_component_desc{ int cd_tag; int cd_type; int cd_type_id; + int cd_compref_type; gser_decoder_func *cd_gser_decoder; ber_decoder_func *cd_ber_decoder; comp_free_func *cd_free; @@ -2680,6 +2836,70 @@ typedef struct slap_component_syntax_info { } ComponentSyntaxInfo; #endif + +/* slab heap data structures */ + +struct slab_object { + void *so_ptr; + int so_blockhead; + LDAP_LIST_ENTRY(slab_object) so_link; +}; + +struct slab_heap { + void *sh_base; + void *sh_last; + void *sh_end; + int sh_stack; + int sh_maxorder; + unsigned char **sh_map; + LDAP_LIST_HEAD( sh_freelist, slab_object ) *sh_free; + LDAP_LIST_HEAD( sh_so, slab_object ) sh_sopool; +}; + +#ifdef SLAP_ZONE_ALLOC +#define SLAP_ZONE_SIZE 0x80000 /* 512KB */ +#define SLAP_ZONE_SHIFT 19 +#define SLAP_ZONE_INITSIZE 0x800000 /* 8MB */ +#define SLAP_ZONE_DELTA 0x800000 /* 8MB */ +#define SLAP_ZONE_ZOBLOCK 256 + +struct zone_object { + void *zo_ptr; + int zo_siz; + int zo_idx; + int zo_blockhead; + LDAP_LIST_ENTRY(zone_object) zo_link; +}; + +struct zone_heap { + int zh_fd; + int zh_zonesize; + int zh_zoneorder; + int zh_numzones; + int zh_maxzones; + int zh_deltazones; + void **zh_zones; + Avlnode *zh_zonetree; + unsigned char ***zh_maps; + unsigned long *zh_seqno; + LDAP_LIST_HEAD( zh_freelist, zone_object ) *zh_free; + LDAP_LIST_HEAD( zh_so, zone_object ) zh_zopool; + ldap_pvt_thread_mutex_t zh_mutex; +}; +#endif + +#define SLAP_BACKEND_INIT_MODULE(b) \ + int \ + init_module( int argc, char *argv[] ) \ + { \ + BackendInfo bi; \ + memset( &bi, '\0', sizeof( bi ) ); \ + bi.bi_type = #b ; \ + bi.bi_init = b ## _back_initialize; \ + backend_add( &bi ); \ + return 0; \ + } + LDAP_END_DECL #include "proto-slap.h"