#include <ldap_schema.h>
#include "lber_pvt.h"
+#include "ldap_pvt.h"
#include "ldap_pvt_thread.h"
#include "ldap_queue.h"
LDAP_BEGIN_DECL
+
/*
* SLAPD Memory allocation macros
*
#define OID_CHAR(c) ( OID_LEADCHAR(c) || OID_SEPARATOR(c) )
#define ATTR_LEADCHAR(c) ( DESC_LEADCHAR(c) || OID_LEADCHAR(c) )
-#define ATTR_CHAR(c) ( DESC_CHAR((c)) || (c) == '.' )
+#define ATTR_CHAR(c) ( DESC_CHAR((c)) || OID_SEPARATOR(c) )
-#define AD_LEADCHAR(c) ( ATTR_CHAR(c) )
+#define AD_LEADCHAR(c) ( ATTR_LEADCHAR(c) )
#define AD_CHAR(c) ( ATTR_CHAR(c) || (c) == ';' )
#define SLAP_NUMERIC(c) ( ASCII_DIGIT(c) || ASCII_SPACE(c) )
| SLAP_INDEX_SUBSTR_ANY \
| SLAP_INDEX_SUBSTR_FINAL )
-/* constants for initial/final substrings indices */
-#ifndef SLAP_INDEX_SUBSTR_IF_MINLEN
-# define SLAP_INDEX_SUBSTR_IF_MINLEN 2
-#endif
-#ifndef SLAP_INDEX_SUBSTR_IF_MAXLEN
-# define SLAP_INDEX_SUBSTR_IF_MAXLEN 4
-#endif
+/* defaults for initial/final substring indices */
+#define SLAP_INDEX_SUBSTR_IF_MINLEN_DEFAULT 2
+#define SLAP_INDEX_SUBSTR_IF_MAXLEN_DEFAULT 4
-/* constants for any substrings indices */
-#ifndef SLAP_INDEX_SUBSTR_ANY_LEN
-# define SLAP_INDEX_SUBSTR_ANY_LEN 4
-#endif
-#ifndef SLAP_INDEX_SUBSTR_ANY_STEP
-# define SLAP_INDEX_SUBSTR_ANY_STEP 2
-#endif
+/* defaults for any substring indices */
+#define SLAP_INDEX_SUBSTR_ANY_LEN_DEFAULT 4
+#define SLAP_INDEX_SUBSTR_ANY_STEP_DEFAULT 2
#define SLAP_INDEX_FLAGS 0xF000UL
#define SLAP_INDEX_NOSUBTYPES 0x1000UL /* don't use index w/ subtypes */
struct berval * out,
void *memctx));
+#ifdef LDAP_DEVEL
+#define LDAP_COMP_MATCH
+#endif
+
+#ifdef LDAP_COMP_MATCH
+typedef void* slap_component_transform_func LDAP_P((
+ struct berval * in ));
+struct ComponentDesc;
+#endif
+
typedef struct slap_syntax {
LDAPSyntax ssyn_syn;
#define ssyn_oid ssyn_syn.syn_oid
slap_syntax_transform_func *ssyn_ber2str;
slap_syntax_transform_func *ssyn_str2ber;
#endif
+#ifdef LDAP_COMP_MATCH
+ slap_component_transform_func *ssyn_attr2comp;
+ struct ComponentDesc* ssync_comp_syntax;
+#endif
LDAP_SLIST_ENTRY(slap_syntax) ssyn_next;
} Syntax;
#define SLAP_MR_ORDERING 0x0200U
#define SLAP_MR_SUBSTR 0x0400U
#define SLAP_MR_EXT 0x0800U /* implicitly extensible */
+#define SLAP_MR_ORDERED_INDEX 0x1000U
+#ifdef LDAP_COMP_MATCH
+#define SLAP_MR_COMPONENT 0x2000U
+#endif
#define SLAP_MR_EQUALITY_APPROX ( SLAP_MR_EQUALITY | 0x0010U )
#else
#define SLAP_AT_HIDE 0x8000U /* hide attribute */
#endif
+#define SLAP_AT_DYNAMIC 0x0400U /* dynamically generated */
+
slap_mask_t sat_flags;
LDAP_SLIST_ENTRY(slap_attribute_type) sat_next;
AttributeDescription *si_ad_subschemaSubentry;
AttributeDescription *si_ad_collectiveSubentries;
AttributeDescription *si_ad_collectiveExclusions;
+ AttributeDescription *si_ad_entryDN;
AttributeDescription *si_ad_entryUUID;
AttributeDescription *si_ad_entryCSN;
AttributeDescription *si_ad_namingCSN;
- AttributeDescription *si_ad_superiorUUID;
AttributeDescription *si_ad_dseType;
AttributeDescription *si_ad_syncreplCookie;
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
/* Matching Rules */
MatchingRule *si_mr_distinguishedNameMatch;
+ MatchingRule *si_mr_dnSubtreeMatch;
+ MatchingRule *si_mr_dnOneLevelMatch;
+ MatchingRule *si_mr_dnSubordinateMatch;
+ MatchingRule *si_mr_dnSuperiorMatch;
MatchingRule *si_mr_caseExactMatch;
MatchingRule *si_mr_caseExactSubstringsMatch;
MatchingRule *si_mr_caseExactIA5Match;
struct berval sa_final;
} SubstringsAssertion;
+#ifdef LDAP_COMP_MATCH
+struct slap_component_filter;
+#endif
+
typedef struct slap_mr_assertion {
MatchingRule *ma_rule; /* optional */
struct berval ma_rule_text; /* optional */
AttributeDescription *ma_desc; /* optional */
int ma_dnattrs; /* boolean */
struct berval ma_value; /* required */
+#ifdef LDAP_COMP_MATCH
+ struct slap_component_filter* ma_cf; /* component filter */
+#endif
} MatchingRuleAssertion;
/*
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)
*/
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
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;
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;
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;
LDAP_SLAPD_V (int) nBackendDB;
LDAP_SLAPD_V (BackendInfo *) backendInfo;
LDAP_SLAPD_V (BackendDB *) backendDB;
+LDAP_SLAPD_V (BackendDB *) frontendDB;
LDAP_SLAPD_V (int) slapMode;
#define SLAP_UNDEFINED_MODE 0x0000
/* Note: this is different from LDAP_NO_LIMIT (0); slapd internal use only */
#define SLAP_NO_LIMIT -1
+#define SLAP_MAX_LIMIT 2147483647
struct slap_limits {
unsigned lm_flags; /* type of pattern */
char *si_authcId;
char *si_authzId;
int si_schemachecking;
- Filter *si_filter;
struct berval si_filterstr;
struct berval si_base;
int si_scope;
int si_attrsonly;
- char **si_attrs;
+ AttributeName *si_anlist;
+ AttributeName *si_exanlist;
+ char **si_attrs;
+ int si_allattrs;
+ int si_allopattrs;
+ char **si_exattrs;
int si_type;
time_t si_interval;
+ time_t *si_retryinterval;
+ int *si_retrynum_init;
+ int *si_retrynum;
struct sync_cookie si_syncCookie;
int si_manageDSAit;
int si_slimit;
int si_tlimit;
- struct berval si_syncUUID_ndn;
+ int si_refreshDelete;
+ int si_refreshPresent;
Avlnode *si_presentlist;
LDAP *si_ld;
LDAP_LIST_HEAD(np, nonpresent_entry) si_nonpresentlist;
#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 */
#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) \
BerVarray be_update_refs; /* where to refer modifying clients to */
struct be_pcl *be_pending_csn_list;
ldap_pvt_thread_mutex_t be_pcl_mutex;
- struct berval be_context_csn;
- ldap_pvt_thread_mutex_t be_context_csn_mutex;
+ ldap_pvt_thread_mutex_t *be_pcl_mutexp;
LDAP_STAILQ_HEAD( be_si, syncinfo_s ) be_syncinfo; /* For syncrepl */
char *be_realm;
struct berval rb_cred;
struct berval rb_edn;
slap_ssf_t rb_ssf;
+ struct berval rb_tmp_mech; /* FIXME: temporary */
} req_bind_s;
typedef struct req_search_s {
AttributeName *rs_attrs;
Filter *rs_filter;
struct berval rs_filterstr;
+ int rs_post_search_id;
} req_search_s;
typedef struct req_compare_s {
typedef struct req_modify_s {
Modifications *rs_modlist;
+ int rs_increment; /* FIXME: temporary */
} req_modify_s;
typedef struct req_modrdn_s {
typedef struct req_add_s {
Entry *rs_e;
+ Modifications *rs_modlist; /* FIXME: temporary */
} req_add_s;
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;
typedef struct rep_search_s {
Entry *r_entry;
+ slap_mask_t r_attr_flags;
+#define SLAP_ATTRS_UNDEFINED (0x00U)
+#define SLAP_OPATTRS_NO (0x01U)
+#define SLAP_OPATTRS_YES (0x02U)
+#define SLAP_USERATTRS_NO (0x10U)
+#define SLAP_USERATTRS_YES (0x20U)
+#define SLAP_OPATTRS_MASK(f) ((f) & (SLAP_OPATTRS_NO|SLAP_OPATTRS_YES))
+#define SLAP_OPATTRS(f) (((f) & SLAP_OPATTRS_YES) == SLAP_OPATTRS_YES)
+#define SLAP_USERATTRS_MASK(f) ((f) & (SLAP_USERATTRS_NO|SLAP_USERATTRS_YES))
+#define SLAP_USERATTRS(f) \
+ (((f) & SLAP_USERATTRS_YES) == SLAP_USERATTRS_YES)
+
+ Attribute *r_operational_attrs;
AttributeName *r_attrs;
int r_nentries;
BerVarray r_v2ref;
/* short hands for response members */
#define sr_attrs sr_un.sru_search.r_attrs
#define sr_entry sr_un.sru_search.r_entry
+#define sr_operational_attrs sr_un.sru_search.r_operational_attrs
+#define sr_attr_flags sr_un.sru_search.r_attr_flags
#define sr_v2ref sr_un.sru_search.r_v2ref
#define sr_nentries sr_un.sru_search.r_nentries
#define sr_rspoid sr_un.sru_extended.r_rspoid
LDAP_P(( struct slap_op *op, Entry *e, int rw ));
typedef int (BI_entry_get_rw) LDAP_P(( struct slap_op *op, struct berval *ndn,
ObjectClass *oc, AttributeDescription *at, int rw, Entry **e ));
-typedef int (BI_operational) LDAP_P(( struct slap_op *op, struct slap_rep *rs,
- int opattrs, Attribute **ap ));
+typedef int (BI_operational) LDAP_P(( struct slap_op *op, struct slap_rep *rs ));
typedef int (BI_has_subordinates) LDAP_P(( struct slap_op *op,
Entry *e, int *hasSubs ));
BI_op_extended *bi_extended;
/* Auxilary Functions */
+ BI_operational *bi_operational;
BI_chk_referrals *bi_chk_referrals;
BI_entry_get_rw *bi_entry_get_rw;
BI_entry_release_rw *bi_entry_release_rw;
- BI_operational *bi_operational;
BI_has_subordinates *bi_has_subordinates;
BI_connection_init *bi_connection_init;
BI_connection_destroy *bi_connection_destroy;
/* hooks for slap tools */
- BI_tool_entry_open *bi_tool_entry_open;
- BI_tool_entry_close *bi_tool_entry_close;
- BI_tool_entry_first *bi_tool_entry_first;
- BI_tool_entry_next *bi_tool_entry_next;
- BI_tool_entry_get *bi_tool_entry_get;
- BI_tool_entry_put *bi_tool_entry_put;
+ BI_tool_entry_open *bi_tool_entry_open;
+ BI_tool_entry_close *bi_tool_entry_close;
+ BI_tool_entry_first *bi_tool_entry_first;
+ BI_tool_entry_next *bi_tool_entry_next;
+ BI_tool_entry_get *bi_tool_entry_get;
+ BI_tool_entry_put *bi_tool_entry_put;
BI_tool_entry_reindex *bi_tool_entry_reindex;
- BI_tool_sync *bi_tool_sync;
- BI_tool_dn2id_get *bi_tool_dn2id_get;
+ BI_tool_sync *bi_tool_sync;
+ BI_tool_dn2id_get *bi_tool_dn2id_get;
BI_tool_id2entry_get *bi_tool_id2entry_get;
BI_tool_entry_modify *bi_tool_entry_modify;
} slap_overinfo;
/* Should successive callbacks in a chain be processed? */
+#define SLAP_CB_FREEME 0x4000
#define SLAP_CB_CONTINUE 0x8000
/*
typedef unsigned long PagedResultsCookie;
typedef struct slap_paged_state {
Backend *ps_be;
+ ber_int_t ps_size;
PagedResultsCookie ps_cookie;
int ps_count;
} PagedResultsState;
#define LDAP_PSEARCH_BY_PREMODIFY 0x03
#define LDAP_PSEARCH_BY_MODIFY 0x04
#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;
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
LDAP_TAILQ_ENTRY (slap_csn_entry) ce_csn_link;
};
+struct pc_entry {
+ ID pc_id;
+ int pc_sent;
+ struct berval pc_csn;
+ struct berval pc_entryUUID;
+ struct berval pc_ename;
+ struct berval pc_enname;
+ LDAP_TAILQ_ENTRY( pc_entry ) pc_link;
+};
+
/*
* Caches the result of a backend_group check for ACL evaluation
*/
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 */
- 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;
#define orb_cred oq_bind.rb_cred
#define orb_edn oq_bind.rb_edn
#define orb_ssf oq_bind.rb_ssf
+#define orb_tmp_mech oq_bind.rb_tmp_mech
#define ors_scope oq_search.rs_scope
#define ors_deref oq_search.rs_deref
#define ors_attrs oq_search.rs_attrs
#define ors_filter oq_search.rs_filter
#define ors_filterstr oq_search.rs_filterstr
+#define ors_post_search_id oq_search.rs_post_search_id
#define orr_newrdn oq_modrdn.rs_newrdn
#define orr_nnewrdn oq_modrdn.rs_nnewrdn
#define orc_ava oq_compare.rs_ava
#define ora_e oq_add.rs_e
+#define ora_modlist oq_add.rs_modlist
#define orn_msgid oq_abandon.rs_msgid
#define orm_modlist oq_modify.rs_modlist
+#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
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)
+
+#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_noop;
- char o_proxy_authz;
+#define get_subentries(op) _SCM((op)->o_subentries)
+#define o_subentries_visibility 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 set_subentries_visibility(op) ((op)->o_subentries |= SLAP_CONTROL_DATA0)
+#define get_subentries_visibility(op) (((op)->o_subentries & SLAP_CONTROL_DATA0) != 0)
- char o_assert;
+#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;
LDAP_LIST_ENTRY(slap_op) o_ps_link;
LDAP_LIST_HEAD(pe, psid_entry) o_pm_list;
+ int o_refresh_in_progress;
+ LDAP_TAILQ_HEAD(pc_pre, pc_entry) o_ps_pre_candidates;
+ LDAP_TAILQ_HEAD(pc_post, pc_entry) o_ps_post_candidates;
+ Avlnode *o_psearch_finished;
+ struct pc_entry *o_ps_send_wait;
+ ldap_pvt_thread_mutex_t o_pcmutex;
+#endif
+
AuthorizationInformation o_authz;
BerElement *o_ber; /* ber of the request */
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; \
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;
};
#endif /* SLAPD_MONITOR */
+typedef struct slap_counters_t {
+ ldap_pvt_thread_mutex_t sc_sent_mutex;
+ ldap_pvt_mp_t sc_bytes;
+ ldap_pvt_mp_t sc_pdu;
+ ldap_pvt_mp_t sc_entries;
+ ldap_pvt_mp_t sc_refs;
+
+ ldap_pvt_thread_mutex_t sc_ops_mutex;
+ ldap_pvt_mp_t sc_ops_completed;
+ ldap_pvt_mp_t sc_ops_initiated;
+#ifdef SLAPD_MONITOR
+ ldap_pvt_mp_t sc_ops_completed_[SLAP_OP_LAST];
+ ldap_pvt_mp_t sc_ops_initiated_[SLAP_OP_LAST];
+#endif /* SLAPD_MONITOR */
+} slap_counters_t;
+
/*
* Better know these all around slapd
*/
LDAPControl *ctrl ));
#define SLAP_SLAB_SIZE (1024*1024)
+#define SLAP_SLAB_STACK 1
+#define SLAP_SLAB_SOBLOCK 64
#if defined(LDAP_DEVEL) && defined(ENABLE_REWRITE)
/* use librewrite for sasl-regexp */
#define SLAP_AUTH_REWRITE 1
#endif /* LDAP_DEVEL && ENABLE_REWRITE */
+#ifdef LDAP_COMP_MATCH
+/*
+ * Extensible Filter Definition
+ *
+ * MatchingRuleAssertion := SEQUENCE {
+ * matchingRule [1] MatchingRuleId OPTIONAL,
+ * type [2] AttributeDescription OPTIONAL,
+ * matchValue [3] AssertionValue,
+ * dnAttributes [4] BOOLEAN DEFAULT FALSE }
+ *
+ * Following ComponentFilter is contained in matchValue
+ *
+ * ComponentAssertion ::= SEQUENCE {
+ * component ComponentReference (SIZE(1..MAX)) OPTIONAL
+ * useDefaultValues BOOLEAN DEFAULT TRUE,
+ * rule MATCHING-RULE.&id,
+ * value MATCHING-RULE.&AssertionType }
+ *
+ * ComponentFilter ::= CHOICE {
+ * item [0] ComponentAssertion,
+ * and [1] SEQUENCE OF ComponentFilter,
+ * or [2] SEQUENCE OF ComponentFilter,
+ * not [3] ComponentFilter }
+ */
+
+#define LDAP_COMPREF_IDENTIFIER ((ber_tag_t) 0x80U)
+#define LDAP_COMPREF_FROM_BEGINNING ((ber_tag_t) 0x81U)
+#define LDAP_COMPREF_COUNT ((ber_tag_t) 0x82U)
+#define LDAP_COMPREF_FROM_END ((ber_tag_t) 0x83U)
+#define LDAP_COMPREF_CONTENT ((ber_tag_t) 0x84U)
+#define LDAP_COMPREF_SELECT ((ber_tag_t) 0x85U)
+#define LDAP_COMPREF_ALL ((ber_tag_t) 0x86U)
+#define LDAP_COMPREF_DEFINED ((ber_tag_t) 0x87U)
+#define LDAP_COMPREF_UNDEFINED ((ber_tag_t) 0x88U)
+
+#define LDAP_COMP_FILTER_AND ((ber_tag_t) 0xa0U)
+#define LDAP_COMP_FILTER_OR ((ber_tag_t) 0xa1U)
+#define LDAP_COMP_FILTER_NOT ((ber_tag_t) 0xa2U)
+#define LDAP_COMP_FILTER_ITEM ((ber_tag_t) 0xa3U)
+#define LDAP_COMP_FILTER_UNDEFINED ((ber_tag_t) 0xa4U)
+
+typedef struct slap_component_id {
+ int ci_type;
+ struct slap_component_id *ci_next;
+
+ union comp_id_value{
+ BerValue ci_identifier;
+ 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;
+} ComponentId;
+
+typedef struct slap_component_reference {
+ ComponentId *cr_list;
+ ComponentId *cr_curr;
+ struct berval cr_string;
+ int cr_len;
+} ComponentReference;
+
+typedef struct slap_component_assertion {
+ ComponentReference *ca_comp_ref;
+ ber_int_t ca_use_def;
+ MatchingRule *ca_ma_rule;
+ struct berval ca_ma_value;
+ ComponentData ca_comp_data; /* componentized assertion */
+ struct slap_component_filter *ca_cf;
+ MatchingRuleAssertion *ca_mra;
+} ComponentAssertion;
+
+typedef struct slap_component_filter {
+ ber_tag_t cf_choice;
+ union cf_un_u {
+ ber_int_t cf_un_result;
+ ComponentAssertion *cf_un_ca;
+ struct slap_component_filter *cf_un_complex;
+ } cf_un;
+
+#define cf_ca cf_un.cf_un_ca
+#define cf_result cf_un.cf_un_result
+#define cf_and cf_un.cf_un_complex
+#define cf_or cf_un.cf_un_complex
+#define cf_not cf_un.cf_un_complex
+#define cf_any cf_un.cf_un_complex
+
+ struct slap_component_filter *cf_next;
+} ComponentFilter;
+
+typedef struct slap_component_assertion_value {
+ char* cav_buf;
+ char* cav_ptr;
+ char* cav_end;
+} ComponentAssertionValue;
+
+#if 0
+typedef int encoder_func LDAP_P((
+ void* b,
+ 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,
+ int* len,
+ int mode));
+
+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,
+ struct slap_component_syntax_info* comp_syn_info,
+ int* len,
+ 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 ));
+
+typedef void* convert_attr_to_comp_func LDAP_P ((
+ Attribute* a,
+ 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 void* convert_assert_to_comp_func LDAP_P ((
+ struct slap_component_syntax_info* csi_attr,
+ struct berval* bv,
+ struct slap_component_syntax_info** csi,
+ int* len,
+ int mode ));
+
+typedef int convert_asn_to_ldap_func LDAP_P ((
+ struct slap_component_syntax_info* csi,
+ struct berval *bv ));
+
+typedef void free_component_func LDAP_P ((
+ void* mem_op));
+
+typedef int test_component_func LDAP_P ((
+ void* mem_op,
+ struct slap_component_syntax_info* csi,
+ struct slap_component_assertion* ca));
+
+typedef int allcomponent_matching_func LDAP_P((
+ char* oid,
+ struct slap_component_syntax_info* comp1,
+ struct slap_component_syntax_info* comp));
+
+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;
+ extract_component_from_id_func* cd_extract_i;
+ slap_syntax_validate_func *cd_validate;
+ slap_syntax_transform_func *cd_pretty;
+ allcomponent_matching_func *cd_all_match;
+} ComponentDesc;
+
+typedef struct slap_component_syntax_info {
+ Syntax* csi_syntax;
+ ComponentDesc* csi_comp_desc;
+} 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;
+};
+
+#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"