X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fslap.h;h=38f0a4ca6b97745be11056d4b13b73f5fab85fc5;hb=9184d038ead9aeabff5b7c0bb2ed0d1e6bc95c8c;hp=29b8d6e72311abed8f9346696121d46f206262c1;hpb=1a14def9031cbaf92865c8b265b2f9155305d537;p=openldap diff --git a/servers/slapd/slap.h b/servers/slapd/slap.h index 29b8d6e723..38f0a4ca6b 100644 --- a/servers/slapd/slap.h +++ b/servers/slapd/slap.h @@ -37,6 +37,7 @@ #ifdef LDAP_DEVEL #define SLAP_EXTENDED_SCHEMA 1 +#define LDAP_CACHING #endif LDAP_BEGIN_DECL @@ -74,11 +75,18 @@ LDAP_BEGIN_DECL #define MAXREMATCHES (100) -#define SLAP_MAX_WORKER_THREADS (32) +#define SLAP_MAX_WORKER_THREADS (16) + +#ifdef LDAP_SYNCREPL +#define SLAP_MAX_SYNCREPL_THREADS (8) +#endif #define SLAP_SB_MAX_INCOMING_DEFAULT ((1<<18) - 1) #define SLAP_SB_MAX_INCOMING_AUTH ((1<<24) - 1) +#define SLAP_CONN_MAX_PENDING_DEFAULT 100 +#define SLAP_CONN_MAX_PENDING_AUTH 1000 + #define SLAP_TEXT_BUFLEN (256) /* psuedo error code indicating abandoned operation */ @@ -288,7 +296,8 @@ typedef int slap_syntax_validate_func LDAP_P(( typedef int slap_syntax_transform_func LDAP_P(( struct slap_syntax *syntax, struct berval * in, - struct berval * out)); + struct berval * out, + void *memctx)); typedef struct slap_syntax { LDAPSyntax ssyn_syn; @@ -315,7 +324,6 @@ typedef struct slap_syntax { #define SLAP_SYNTAX_HIDE 0x8000U /* hide (do not publish) */ slap_syntax_validate_func *ssyn_validate; - slap_syntax_transform_func *ssyn_normalize; slap_syntax_transform_func *ssyn_pretty; #ifdef SLAPD_BINARY_CONVERSION @@ -337,7 +345,6 @@ typedef struct slap_syntax_defs_rec { char *sd_desc; int sd_flags; slap_syntax_validate_func *sd_validate; - slap_syntax_transform_func *sd_normalize; slap_syntax_transform_func *sd_pretty; #ifdef SLAPD_BINARY_CONVERSION slap_syntax_transform_func *sd_ber2str; @@ -348,7 +355,8 @@ typedef struct slap_syntax_defs_rec { /* X -> Y Converter */ typedef int slap_mr_convert_func LDAP_P(( struct berval * in, - struct berval * out )); + struct berval * out, + void *memctx )); /* Normalizer */ typedef int slap_mr_normalize_func LDAP_P(( @@ -356,7 +364,8 @@ typedef int slap_mr_normalize_func LDAP_P(( struct slap_syntax *syntax, /* NULL if in is asserted value */ struct slap_matching_rule *mr, struct berval * in, - struct berval * out )); + struct berval * out, + void *memctx )); /* Match (compare) function */ typedef int slap_mr_match_func LDAP_P(( @@ -375,7 +384,8 @@ typedef int slap_mr_indexer_func LDAP_P(( struct slap_matching_rule *mr, struct berval *prefix, BerVarray values, - BerVarray *keys )); + BerVarray *keys, + void *memctx )); /* Filter index function */ typedef int slap_mr_filter_func LDAP_P(( @@ -385,7 +395,8 @@ typedef int slap_mr_filter_func LDAP_P(( struct slap_matching_rule *mr, struct berval *prefix, void * assertValue, - BerVarray *keys )); + BerVarray *keys, + void *memctx )); typedef struct slap_matching_rule_use MatchingRuleUse; @@ -409,46 +420,64 @@ typedef struct slap_matching_rule { #define SLAP_MR_HIDE 0x8000U -#define SLAP_MR_TYPE_MASK 0x0F00U -#define SLAP_MR_SUBTYPE_MASK 0x00F0U -#define SLAP_MR_USAGE 0x000FU +#define SLAP_MR_TYPE_MASK 0xF000U +#define SLAP_MR_SUBTYPE_MASK 0x0F00U +#define SLAP_MR_USAGE 0x00FFU #define SLAP_MR_NONE 0x0000U -#define SLAP_MR_EQUALITY 0x0100U -#define SLAP_MR_ORDERING 0x0200U -#define SLAP_MR_SUBSTR 0x0400U -#define SLAP_MR_EXT 0x0800U /* implicitly extensible */ +#define SLAP_MR_EQUALITY 0x1000U +#define SLAP_MR_ORDERING 0x2000U +#define SLAP_MR_SUBSTR 0x4000U +#define SLAP_MR_EXT 0x8000U /* implicitly extensible */ -#define SLAP_MR_EQUALITY_APPROX ( SLAP_MR_EQUALITY | 0x0010U ) -#define SLAP_MR_DN_FOLD 0x0008U +#define SLAP_MR_EQUALITY_APPROX ( SLAP_MR_EQUALITY | 0x0100U ) + +#define SLAP_MR_SUBSTR_INITIAL ( SLAP_MR_SUBSTR | 0x0100U ) +#define SLAP_MR_SUBSTR_ANY ( SLAP_MR_SUBSTR | 0x0200U ) +#define SLAP_MR_SUBSTR_FINAL ( SLAP_MR_SUBSTR | 0x0400U ) -#define SLAP_MR_SUBSTR_INITIAL ( SLAP_MR_SUBSTR | 0x0010U ) -#define SLAP_MR_SUBSTR_ANY ( SLAP_MR_SUBSTR | 0x0020U ) -#define SLAP_MR_SUBSTR_FINAL ( SLAP_MR_SUBSTR | 0x0040U ) /* - * normally the provided value is expected to conform to - * assertion syntax specified in the matching rule, however - * at times (such as during individual value modification), - * the provided value is expected to conform to the - * attribute's value syntax. + * The asserted value, depending on the particular usage, + * is expected to conform to either the assertion syntax + * or the attribute syntax. In some cases, the syntax of + * the value is known. If so, these flags indicate which + * syntax the value is expected to conform to. If not, + * neither of these flags is set (until the syntax of the + * provided value is determined). If the value is of the + * attribute syntax, the flag is changed once a value of + * the assertion syntax is derived from the provided value. */ -#define SLAP_MR_ASSERTION_SYNTAX_MATCH 0x0000U -#define SLAP_MR_VALUE_SYNTAX_MATCH 0x0001U -#define SLAP_MR_VALUE_SYNTAX_CONVERTED_MATCH 0x0003U -#define SLAP_MR_VALUE_NORMALIZED_MATCH 0x0004U +#define SLAP_MR_VALUE_OF_ASSERTION_SYNTAX 0x0001U +#define SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX 0x0002U -#define SLAP_IS_MR_ASSERTION_SYNTAX_MATCH( usage ) \ - (!((usage) & SLAP_MR_VALUE_SYNTAX_MATCH)) -#define SLAP_IS_MR_VALUE_SYNTAX_MATCH( usage ) \ - ((usage) & SLAP_MR_VALUE_SYNTAX_MATCH) +#define SLAP_MR_IS_VALUE_OF_ATTRIBUTE_SYNTAX( usage ) \ + ((usage) & SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX ) +#define SLAP_MR_IS_VALUE_OF_ASSERTION_SYNTAX( usage ) \ + ((usage) & SLAP_MR_VALUE_OF_ASSERTION_SYNTAX ) + +/* either or both the asserted value or attribute value + * may be provided in normalized form + */ +#define SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH 0x0010U +#define SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH 0x0020U -#define SLAP_IS_MR_VALUE_SYNTAX_CONVERTED_MATCH( usage ) \ - (((usage) & SLAP_MR_VALUE_SYNTAX_CONVERTED_MATCH) \ - == SLAP_MR_VALUE_SYNTAX_CONVERTED_MATCH) -#define SLAP_IS_MR_VALUE_SYNTAX_NONCONVERTED_MATCH( usage ) \ - (((usage) & SLAP_MR_VALUE_SYNTAX_CONVERTED_MATCH) \ - == SLAP_MR_VALUE_SYNTAX_MATCH) +#define SLAP_IS_MR_ASSERTION_SYNTAX_MATCH( usage ) \ + (!((usage) & SLAP_MR_ATTRIBUTE_SYNTAX_MATCH)) +#define SLAP_IS_MR_ATTRIBUTE_SYNTAX_MATCH( usage ) \ + ((usage) & SLAP_MR_ATTRIBUTE_SYNTAX_MATCH) + +#define SLAP_IS_MR_ATTRIBUTE_SYNTAX_CONVERTED_MATCH( usage ) \ + (((usage) & SLAP_MR_ATTRIBUTE_SYNTAX_CONVERTED_MATCH) \ + == SLAP_MR_ATTRIBUTE_SYNTAX_CONVERTED_MATCH) +#define SLAP_IS_MR_ATTRIBUTE_SYNTAX_NONCONVERTED_MATCH( usage ) \ + (((usage) & SLAP_MR_ATTRIBUTE_SYNTAX_CONVERTED_MATCH) \ + == SLAP_MR_ATTRIBUTE_SYNTAX_MATCH) + +#define SLAP_IS_MR_ASSERTED_VALUE_NORMALIZED_MATCH( usage ) \ + ((usage) & SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH ) +#define SLAP_IS_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH( usage ) \ + ((usage) & SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH ) Syntax *smr_syntax; slap_mr_convert_func *smr_convert; @@ -464,7 +493,15 @@ typedef struct slap_matching_rule { */ Syntax **smr_compat_syntaxes; + /* + * For equality rules, refers to an associated approximate rule. + * For non-equality rules, refers to an associated equality rule. + */ struct slap_matching_rule *smr_associated; + +#define SLAP_MR_ASSOCIATED(mr,amr) (((mr) == (amr)) || \ + ((mr)->smr_associated == (amr))) + LDAP_SLIST_ENTRY(slap_matching_rule)smr_next; #define smr_oid smr_mrule.mr_oid @@ -502,6 +539,8 @@ typedef struct slap_mrule_defs_rec { slap_mr_indexer_func * mrd_indexer; slap_mr_filter_func * mrd_filter; + /* For equality rule, this may refer to an associated approximate rule */ + /* For non-equality rule, this may refer to an associated equality rule */ char * mrd_associated; } slap_mrule_defs_rec; @@ -660,10 +699,15 @@ struct slap_internal_schema { ObjectClass *si_oc_rootdse; ObjectClass *si_oc_subentry; ObjectClass *si_oc_subschema; - ObjectClass *si_oc_monitor; ObjectClass *si_oc_collectiveAttributeSubentry; ObjectClass *si_oc_dynamicObject; +#ifdef LDAP_SYNCREPL + ObjectClass *si_oc_glue; + ObjectClass *si_oc_syncConsumerSubentry; + ObjectClass *si_oc_syncProviderSubentry; +#endif + /* objectClass attribute descriptions */ AttributeDescription *si_ad_objectClass; @@ -679,8 +723,19 @@ struct slap_internal_schema { AttributeDescription *si_ad_collectiveExclusions; AttributeDescription *si_ad_entryUUID; AttributeDescription *si_ad_entryCSN; + AttributeDescription *si_ad_namingCSN; AttributeDescription *si_ad_superiorUUID; +#ifdef LDAP_CACHING + /* LDAP cache specific operational attribute */ + AttributeDescription *si_ad_queryid; +#endif /* LDAP_CACHING */ + +#ifdef LDAP_SYNCREPL + AttributeDescription *si_ad_dseType; + AttributeDescription *si_ad_syncreplCookie; +#endif + /* root DSE attribute descriptions */ AttributeDescription *si_ad_altServer; AttributeDescription *si_ad_namingContexts; @@ -735,18 +790,24 @@ struct slap_internal_schema { #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND AttributeDescription *si_ad_krbName; #endif - + /* Undefined Attribute Type */ AttributeType *si_at_undefined; /* Matching Rules */ MatchingRule *si_mr_distinguishedNameMatch; + MatchingRule *si_mr_caseExactMatch; + MatchingRule *si_mr_caseExactSubstringsMatch; + MatchingRule *si_mr_caseExactIA5Match; MatchingRule *si_mr_integerMatch; + MatchingRule *si_mr_integerFirstComponentMatch; + MatchingRule *si_mr_objectIdentifierFirstComponentMatch; /* Syntaxes */ - Syntax *si_syn_octetString; + Syntax *si_syn_directoryString; Syntax *si_syn_distinguishedName; Syntax *si_syn_integer; + Syntax *si_syn_octetString; }; typedef struct slap_attr_assertion { @@ -882,8 +943,9 @@ typedef struct slap_valuesreturnfilter { */ typedef struct slap_attr { AttributeDescription *a_desc; - BerVarray a_vals; - struct slap_attr *a_next; + BerVarray a_vals; /* preserved values */ + BerVarray a_nvals; /* normalized values */ + struct slap_attr *a_next; unsigned a_flags; #define SLAP_ATTR_IXADD 0x1U #define SLAP_ATTR_IXDEL 0x2U @@ -931,7 +993,9 @@ typedef struct slap_mod { int sm_op; AttributeDescription *sm_desc; struct berval sm_type; - BerVarray sm_bvalues; + BerVarray sm_values; +#define sm_bvalues sm_values + BerVarray sm_nvalues; } Modification; typedef struct slap_mod_list { @@ -939,7 +1003,9 @@ typedef struct slap_mod_list { #define sml_op sml_mod.sm_op #define sml_desc sml_mod.sm_desc #define sml_type sml_mod.sm_type -#define sml_bvalues sml_mod.sm_bvalues +#define sml_bvalues sml_mod.sm_values +#define sml_values sml_mod.sm_values +#define sml_nvalues sml_mod.sm_nvalues struct slap_mod_list *sml_next; } Modifications; @@ -949,7 +1015,7 @@ typedef struct slap_ldap_modlist { #define ml_op ml_mod.mod_op #define ml_type ml_mod.mod_type #define ml_values ml_mod.mod_values -#define ml_bvalues ml_mod.mod_bvalues +#define ml_bvalues ml_mod.mod_values } LDAPModList; /* @@ -1133,15 +1199,6 @@ typedef struct slap_acl_state { #define ACL_STATE_INIT { ACL_STATE_NOT_RECORDED, NULL, NULL, 0UL, \ { { 0, 0 } }, 0, NULL, 0, 0, NULL } -/* - * replog moddn param structure - */ -struct slap_replog_moddn { - struct berval *newrdn; - int deloldrdn; - struct berval *newsup; -}; - /* * Backend-info * represents a backend @@ -1162,6 +1219,8 @@ LDAP_SLAPD_V (int) slapMode; #define SLAP_MODE 0x0003 #define SLAP_TRUNCATE_MODE 0x0100 +#define SLAP_TOOL_READMAIN 0x0200 +#define SLAP_TOOL_READONLY 0x0400 struct slap_replica_info { char *ri_host; /* supersedes be_replica */ @@ -1211,6 +1270,99 @@ typedef BackendDB Backend; #define nbackends nBackendDB #define backends backendDB +#ifdef LDAP_SYNCREPL + +struct nonpresent_entry { + struct berval *dn; + struct berval *ndn; + LDAP_LIST_ENTRY(nonpresent_entry) np_link; +}; + + /* + * syncinfo structure for syncrepl + */ +typedef struct syncinfo_s { + struct slap_conn *conn; + struct slap_backend_db *be; + struct slap_entry *e; + void *ctx; + int id; + char *masteruri; + struct berval *master_bv; + char *mastername; + int masterport; + int type; + struct berval updatedn; + char *binddn; + int bindmethod; + char *passwd; + char *secprops; + char *realm; + char *authcId; + char *authzId; + char *srvtab; + char *saslmech; + time_t interval; + char *base; + int scope; + int deref; + int slimit; + int tlimit; + Filter *filter; + char *filterstr; + char **attrs; + int attrsonly; +#define LASTMOD_REQ 0 +#define LASTMOD_GEN 1 +#define LASTMOD_NO 2 + int lastmod; + /* TLS flags */ +#define TLS_OFF 0 +#define TLS_ON 1 +#define TLS_CRITICAL 2 + int tls; + int found; + struct berval *syncUUID; + struct berval *syncUUID_ndn; + struct berval *syncCookie; + Avlnode *presentlist; + LDAP_LIST_HEAD(np, nonpresent_entry) nonpresentlist; +} syncinfo_t; + +#define IDSTR "id" +#define MASTERSTR "master" +#define SUFFIXSTR "suffix" +#define UPDATEDNSTR "updatedn" +#define BINDDNSTR "binddn" +#define BINDMETHSTR "bindmethod" +#define SIMPLESTR "simple" +#define SASLSTR "sasl" +#define CREDSTR "credentials" +#define OLDAUTHCSTR "bindprincipal" +#define AUTHCSTR "authcID" +#define AUTHZSTR "authzID" +#define SRVTABSTR "srvtab" +#define SASLMECHSTR "saslmech" +#define REALMSTR "realm" +#define SECPROPSSTR "secprops" +#define TLSSTR "tls" +#define TLSCRITICALSTR "critical" + +#define FILTERSTR "filter" +#define SEARCHBASESTR "searchbase" +#define SCOPESTR "scope" +#define ATTRSSTR "attrs" +#define ATTRSONLYSTR "attrsonly" +#define TYPESTR "type" +#define INTERVALSTR "interval" +#define COOKIESTR "cookie" +#define LASTMODSTR "lastmod" +#define LMREQSTR "req" +#define LMGENSTR "gen" +#define LMNOSTR "no" + +#endif /* LDAP_SYNCREPL */ + struct slap_backend_db { BackendInfo *bd_info; /* pointer to shared backend info */ @@ -1231,6 +1383,7 @@ struct slap_backend_db { #define be_extended bd_info->bi_extended +#define be_fetch bd_info->bi_entry_get_rw #define be_release bd_info->bi_entry_release_rw #define be_chk_referrals bd_info->bi_chk_referrals #define be_group bd_info->bi_acl_group @@ -1271,6 +1424,10 @@ struct slap_backend_db { #define SLAP_BFLAG_DYNAMIC 0x2000U slap_mask_t be_flags; #define SLAP_LASTMOD(be) (!((be)->be_flags & SLAP_BFLAG_NOLASTMOD)) +#define SLAP_GLUE_INSTANCE(be) ((be)->be_flags & SLAP_BFLAG_GLUE_INSTANCE) +#define SLAP_GLUE_SUBORDINATE(be) \ + ((be)->be_flags & SLAP_BFLAG_GLUE_SUBORDINATE) +#define SLAP_GLUE_LINKED(be) ((be)->be_flags & SLAP_BFLAG_GLUE_LINKED) #define SLAP_ALIASES(be) ((be)->be_flags & SLAP_BFLAG_ALIASES) #define SLAP_REFERRALS(be) ((be)->be_flags & SLAP_BFLAG_REFERRALS) #define SLAP_SUBENTRIES(be) ((be)->be_flags & SLAP_BFLAG_SUBENTRIES) @@ -1346,6 +1503,9 @@ struct slap_backend_db { void *be_private; /* anything the backend database needs */ void *be_pb; /* Netscape plugin */ +#ifdef LDAP_SYNCREPL + syncinfo_t *syncinfo; /* For syncrepl */ +#endif }; struct slap_conn; @@ -1368,88 +1528,119 @@ typedef int (BI_db_open) LDAP_P((Backend *bd)); typedef int (BI_db_close) LDAP_P((Backend *bd)); typedef int (BI_db_destroy) LDAP_P((Backend *bd)); -typedef int (BI_op_bind) LDAP_P(( BackendDB *bd, - struct slap_conn *c, struct slap_op *o, - struct berval *dn, struct berval *ndn, int method, - struct berval *cred, struct berval *edn )); -typedef int (BI_op_unbind) LDAP_P((BackendDB *bd, - struct slap_conn *c, struct slap_op *o )); -typedef int (BI_op_search) LDAP_P((BackendDB *bd, - struct slap_conn *c, struct slap_op *o, - struct berval *base, struct berval *nbase, - int scope, int deref, - int slimit, int tlimit, - Filter *f, struct berval *filterstr, - AttributeName *attrs, int attrsonly)); -typedef int (BI_op_compare)LDAP_P((BackendDB *bd, - struct slap_conn *c, struct slap_op *o, - struct berval *dn, struct berval *ndn, - AttributeAssertion *ava)); -typedef int (BI_op_modify) LDAP_P((BackendDB *bd, - struct slap_conn *c, struct slap_op *o, - struct berval *dn, struct berval *ndn, - Modifications *m)); -typedef int (BI_op_modrdn) LDAP_P((BackendDB *bd, - struct slap_conn *c, struct slap_op *o, - struct berval *dn, struct berval *ndn, - struct berval *newrdn, struct berval *nnewrdn, - int deleteoldrdn, - struct berval *newSup, struct berval *nnewSup )); -typedef int (BI_op_add) LDAP_P((BackendDB *bd, - struct slap_conn *c, struct slap_op *o, - Entry *e)); -typedef int (BI_op_delete) LDAP_P((BackendDB *bd, - struct slap_conn *c, struct slap_op *o, - struct berval *dn, struct berval *ndn)); -typedef int (BI_op_abandon) LDAP_P((BackendDB *bd, - struct slap_conn *c, struct slap_op *o, - ber_int_t msgid)); -typedef int (BI_op_cancel) LDAP_P((BackendDB *bd, - struct slap_conn *c, struct slap_op *o, - ber_int_t msgid)); - -typedef int (BI_op_extended) LDAP_P(( - BackendDB *be, - struct slap_conn *conn, - struct slap_op *op, - const char *reqoid, - struct berval * reqdata, - char **rspoid, - struct berval ** rspdata, - LDAPControl *** rspctrls, - const char ** text, - BerVarray *refs )); - -typedef int (BI_entry_release_rw) LDAP_P((BackendDB *bd, - struct slap_conn *c, struct slap_op *o, - Entry *e, int rw)); - -typedef int (BI_chk_referrals) LDAP_P((BackendDB *bd, - struct slap_conn *c, struct slap_op *o, - struct berval *dn, struct berval *ndn, - const char **text )); - -typedef int (BI_acl_group) LDAP_P((Backend *bd, - struct slap_conn *c, struct slap_op *o, - Entry *e, - struct berval *bdn, - struct berval *edn, - ObjectClass *group_oc, - AttributeDescription *group_at )); - -typedef int (BI_acl_attribute) LDAP_P((Backend *bd, - struct slap_conn *c, struct slap_op *o, - Entry *e, struct berval *edn, - AttributeDescription *entry_at, - BerVarray *vals )); - -typedef int (BI_operational) LDAP_P((Backend *bd, - struct slap_conn *c, struct slap_op *o, - Entry *e, AttributeName *attrs, int opattrs, Attribute **a )); - -typedef int (BI_has_subordinates) LDAP_P((Backend *bd, - struct slap_conn *c, struct slap_op *o, - Entry *e, int *has_subordinates )); +typedef struct req_bind_s { + int rb_method; + struct berval rb_cred; + struct berval rb_edn; + slap_ssf_t rb_ssf; +} req_bind_s; + +typedef struct req_search_s { + int rs_scope; + int rs_deref; + int rs_slimit; + int rs_tlimit; + int rs_attrsonly; + AttributeName *rs_attrs; + Filter *rs_filter; + struct berval rs_filterstr; +} req_search_s; + +typedef struct req_compare_s { + AttributeAssertion *rs_ava; +} req_compare_s; + +typedef struct req_modify_s { + Modifications *rs_modlist; +} req_modify_s; + +typedef struct req_modrdn_s { + struct berval rs_newrdn; + struct berval rs_nnewrdn; + struct berval *rs_newSup; + struct berval *rs_nnewSup; + int rs_deleteoldrdn; +} req_modrdn_s; + +typedef struct req_add_s { + Entry *rs_e; +} req_add_s; + +typedef struct req_abandon_s { + ber_int_t rs_msgid; +} req_abandon_s; + +typedef struct req_extended_s { + struct berval rs_reqoid; + struct berval *rs_reqdata; +} req_extended_s; + +typedef enum slap_reply_e { + REP_RESULT, + REP_SASL, + REP_EXTENDED, + REP_SEARCH, + REP_SEARCHREF +} slap_reply_t; + +typedef struct rep_sasl_s { + struct berval *r_sasldata; +} rep_sasl_s; + +typedef struct rep_extended_s { + const char *r_rspoid; + struct berval *r_rspdata; +} rep_extended_s; + +typedef struct rep_search_s { + Entry *r_entry; + AttributeName *r_attrs; + int r_nentries; + BerVarray r_v2ref; +} rep_search_s; + +typedef struct slap_rep { + slap_reply_t sr_type; + ber_tag_t sr_tag; + ber_int_t sr_msgid; + ber_int_t sr_err; + const char *sr_matched; + const char *sr_text; + BerVarray sr_ref; + LDAPControl **sr_ctrls; + union sr_u { + rep_sasl_s sru_sasl; + rep_extended_s sru_extended; + rep_search_s sru_search; + } sr_un; +} SlapReply; + +/* 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_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 +#define sr_rspdata sr_un.sru_extended.r_rspdata +#define sr_sasldata sr_un.sru_sasl.r_sasldata + +typedef int (BI_op_bind) LDAP_P(( struct slap_op *op, struct slap_rep *rs )); +typedef int (BI_op_unbind) LDAP_P(( struct slap_op *op, struct slap_rep *rs )); +typedef int (BI_op_search) LDAP_P(( struct slap_op *op, struct slap_rep *rs )); +typedef int (BI_op_compare) LDAP_P(( struct slap_op *op, struct slap_rep *rs )); +typedef int (BI_op_modify) LDAP_P(( struct slap_op *op, struct slap_rep *rs )); +typedef int (BI_op_modrdn) LDAP_P(( struct slap_op *op, struct slap_rep *rs )); +typedef int (BI_op_add) LDAP_P(( struct slap_op *op, struct slap_rep *rs )); +typedef int (BI_op_delete) LDAP_P(( struct slap_op *op, struct slap_rep *rs )); +typedef int (BI_op_abandon) LDAP_P(( struct slap_op *op, struct slap_rep *rs )); +typedef int (BI_op_cancel) LDAP_P(( struct slap_op *op, struct slap_rep *rs )); +typedef int (BI_op_extended) LDAP_P(( struct slap_op *op, struct slap_rep *rs )); +typedef int (BI_entry_release_rw) 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_chk_referrals) LDAP_P(( struct slap_op *op, struct slap_rep *rs )); +typedef int (BI_operational) LDAP_P(( struct slap_op *op, struct slap_rep *rs, int opattrs, Attribute **ap )); +typedef int (BI_has_subordinates) LDAP_P(( struct slap_op *op, Entry *e, int *hasSubs )); typedef int (BI_connection_init) LDAP_P((BackendDB *bd, struct slap_conn *c)); @@ -1538,12 +1729,10 @@ struct slap_backend_info { BI_op_extended *bi_extended; /* Auxilary Functions */ + BI_entry_get_rw *bi_entry_get_rw; BI_entry_release_rw *bi_entry_release_rw; BI_chk_referrals *bi_chk_referrals; - BI_acl_group *bi_acl_group; - BI_acl_attribute *bi_acl_attribute; - BI_operational *bi_operational; BI_has_subordinates *bi_has_subordinates; @@ -1587,26 +1776,10 @@ struct slap_backend_info { #define o_tls_ssf o_authz.sai_tls_ssf #define o_sasl_ssf o_authz.sai_sasl_ssf -typedef void (slap_response)( struct slap_conn *, struct slap_op *, - ber_tag_t, ber_int_t, ber_int_t, const char *, const char *, - BerVarray, const char *, struct berval *, - struct berval *, LDAPControl ** ); - -typedef void (slap_sresult)( struct slap_conn *, struct slap_op *, - ber_int_t, const char *, const char *, BerVarray, - LDAPControl **, int nentries); - -typedef int (slap_sendentry)( BackendDB *, struct slap_conn *, - struct slap_op *, Entry *, AttributeName *, int, LDAPControl **); - -typedef int (slap_sendreference)( BackendDB *, struct slap_conn *, - struct slap_op *, Entry *, BerVarray, LDAPControl **, BerVarray * ); +typedef int (slap_response)( struct slap_op *, struct slap_rep * ); typedef struct slap_callback { slap_response *sc_response; - slap_sresult *sc_sresult; - slap_sendentry *sc_sendentry; - slap_sendreference *sc_sendreference; void *sc_private; } slap_callback; @@ -1628,26 +1801,9 @@ typedef struct slap_paged_state { #define LDAP_PSEARCH_BY_MODIFY 0x04 #define LDAP_PSEARCH_BY_SCOPEOUT 0x05 -struct ldap_psearch_spec { - struct slap_op *op; - struct berval *base; - struct berval *nbase; - int scope; - int deref; - int slimit; - int tlimit; - Filter *filter; - struct berval *filterstr; - AttributeName *attrs; - int attrsonly; - int protocol; - int entry_count; - LDAP_LIST_ENTRY(ldap_psearch_spec) link; -}; - struct psid_entry { - struct ldap_psearch_spec* ps; - LDAP_LIST_ENTRY(psid_entry) link; + struct slap_op *ps_op; + LDAP_LIST_ENTRY(psid_entry) ps_link; }; #endif @@ -1659,13 +1815,67 @@ 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 */ 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 */ - char * o_extendedop; /* extended operation OID */ + struct berval o_req_dn; /* DN of target of request */ + struct berval o_req_ndn; + + union o_req_u { + req_add_s oq_add; + req_bind_s oq_bind; + req_compare_s oq_compare; + req_modify_s oq_modify; + req_modrdn_s oq_modrdn; + req_search_s oq_search; + req_abandon_s oq_abandon; + req_abandon_s oq_cancel; + req_extended_s oq_extended; + } o_request; + +/* short hands for union members */ +#define oq_add o_request.oq_add +#define oq_bind o_request.oq_bind +#define oq_compare o_request.oq_compare +#define oq_modify o_request.oq_modify +#define oq_modrdn o_request.oq_modrdn +#define oq_search o_request.oq_search +#define oq_abandon o_request.oq_abandon +#define oq_cancel o_request.oq_cancel +#define oq_extended o_request.oq_extended + +/* short hands for inner request members */ +#define orb_method oq_bind.rb_method +#define orb_cred oq_bind.rb_cred +#define orb_edn oq_bind.rb_edn +#define orb_ssf oq_bind.rb_ssf + +#define ors_scope oq_search.rs_scope +#define ors_deref oq_search.rs_deref +#define ors_slimit oq_search.rs_slimit +#define ors_tlimit oq_search.rs_tlimit +#define ors_attrsonly oq_search.rs_attrsonly +#define ors_attrs oq_search.rs_attrs +#define ors_filter oq_search.rs_filter +#define ors_filterstr oq_search.rs_filterstr + +#define orr_newrdn oq_modrdn.rs_newrdn +#define orr_nnewrdn oq_modrdn.rs_nnewrdn +#define orr_newSup oq_modrdn.rs_newSup +#define orr_nnewSup oq_modrdn.rs_nnewSup +#define orr_deleteoldrdn oq_modrdn.rs_deleteoldrdn + +#define orc_ava oq_compare.rs_ava +#define ora_e oq_add.rs_e +#define orn_msgid oq_abandon.rs_msgid +#define orm_modlist oq_modify.rs_modlist + +#define ore_reqoid oq_extended.rs_reqoid +#define ore_reqdata oq_extended.rs_reqdata ldap_pvt_thread_t o_tid; /* thread handling this op */ @@ -1677,6 +1887,7 @@ typedef struct slap_op { #define SLAP_CANCEL_DONE 0x03 char o_do_not_cache; /* don't cache from this op */ + char o_is_auth_check; /* authorization in progress */ #define SLAP_NO_CONTROL 0 #define SLAP_NONCRITICAL_CONTROL 1 @@ -1739,14 +1950,12 @@ typedef struct slap_op { #endif #if defined(LDAP_CLIENT_UPDATE) || defined(LDAP_SYNC) - LDAP_LIST_HEAD(lss, ldap_psearch_spec) psearch_spec; - LDAP_LIST_HEAD(pe, psid_entry) premodify_list; - LDAP_LIST_ENTRY(slap_op) link; + int o_ps_protocol; + int o_ps_entries; + LDAP_LIST_ENTRY(slap_op) o_ps_link; + LDAP_LIST_HEAD(pe, psid_entry) o_pm_list; #endif -#ifdef LDAP_CONNECTIONLESS - Sockaddr o_peeraddr; /* UDP peer address */ -#endif AuthorizationInformation o_authz; BerElement *o_ber; /* ber of the request */ @@ -1757,104 +1966,47 @@ typedef struct slap_op { 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 */ ValuesReturnFilter *vrFilter; /* Structure represents ValuesReturnFilter */ +#ifdef LDAP_CACHING + char o_caching_on; +#endif /*LDAP_CACHING */ + #ifdef LDAP_SLAPI void *o_pb; /* NS-SLAPI plugin */ #endif } Operation; -typedef void (*SEND_LDAP_RESULT)( - struct slap_conn *conn, - struct slap_op *op, - ber_int_t err, - const char *matched, - const char *text, - BerVarray ref, - LDAPControl **ctrls - ); - -#define send_ldap_result( conn, op, err, matched, text, ref, ctrls ) \ -(*conn->c_send_ldap_result)( conn, op, err, matched, text, ref, ctrls ) - - -typedef int (*SEND_SEARCH_ENTRY)( - struct slap_backend_db *be, - struct slap_conn *conn, - struct slap_op *op, - struct slap_entry *e, - AttributeName *attrs, - int attrsonly, - LDAPControl **ctrls - ); - -#define send_search_entry( be, conn, op, e, attrs, attrsonly, ctrls) \ -(*conn->c_send_search_entry)( be, conn, op, e, attrs, attrsonly, ctrls) - - -typedef void (*SEND_SEARCH_RESULT)( - struct slap_conn *conn, - struct slap_op *op, - ber_int_t err, - const char *matched, - const char *text, - BerVarray refs, - LDAPControl **ctrls, - int nentries - ); - -#define send_search_result( conn, op, err, matched, text, refs, ctrls, nentries ) \ -(*conn->c_send_search_result)( conn, op, err, matched, text, refs, ctrls, nentries ) - - -typedef int (*SEND_SEARCH_REFERENCE)( - struct slap_backend_db *be, - struct slap_conn *conn, - struct slap_op *op, - struct slap_entry *e, - BerVarray refs, - LDAPControl **ctrls, - BerVarray *v2refs - ); - -#define send_search_reference( be, conn, op, e, refs, ctrls, v2refs ) \ -(*conn->c_send_search_reference)( be, conn, op, e, refs, ctrls, v2refs ) - - -typedef void (*SEND_LDAP_EXTENDED)( - struct slap_conn *conn, - struct slap_op *op, - ber_int_t err, - const char *matched, - const char *text, - BerVarray refs, - const char *rspoid, - struct berval *rspdata, - LDAPControl **ctrls - ); - -#define send_ldap_extended( conn, op, err, matched, text, refs, rspoid, rspdata, ctrls) \ -(*conn->c_send_ldap_extended)( conn, op, err, matched, text, refs, rspoid, rspdata, ctrls ) - -typedef void (*SEND_LDAP_INTERMEDIATE_RESP)( - struct slap_conn *conn, - struct slap_op *op, - ber_int_t err, - const char *matched, - const char *text, - BerVarray refs, - const char *rspoid, - struct berval *rspdata, - LDAPControl **ctrls - ); - -#define send_ldap_intermediate_resp( conn, op, err, matched, text, refs, \ - rspoid, rspdata, ctrls) \ - (*conn->c_send_ldap_intermediate_resp)( conn, op, err, matched, text, \ - refs, rspoid, rspdata, ctrls ) +#define send_ldap_error( op, rs, err, text ) \ +do { (rs)->sr_err = err; (rs)->sr_text = text; \ +(op->o_conn->c_send_ldap_result)( op, rs ); } while (0) +#define send_ldap_discon( op, rs, err, text ) \ +do { (rs)->sr_err = err; (rs)->sr_text = text; \ +send_ldap_disconnect( op, rs ); } while (0) +typedef void (SEND_LDAP_RESULT)(struct slap_op *op, struct slap_rep *rs); +typedef int (SEND_SEARCH_ENTRY)(struct slap_op *op, struct slap_rep *rs); +typedef int (SEND_SEARCH_REFERENCE)(struct slap_op *op, struct slap_rep *rs); +typedef void (SEND_LDAP_EXTENDED)(struct slap_op *op, struct slap_rep *rs); +typedef void (SEND_LDAP_INTERMEDIATE_RESP)(struct slap_op *op, struct slap_rep *rs); +#define 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 ) +#define 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 ) +#define send_ldap_intermediate_resp( op, rs ) \ +(op->o_conn->c_send_ldap_intermediate_resp)( op, rs ) /* * Caches the result of a backend_group check for ACL evaluation @@ -1922,7 +2074,9 @@ typedef struct slap_conn { int c_needs_tls_accept; /* true if SSL_accept should be called */ #endif int c_sasl_layers; /* true if we need to install SASL i/o handlers */ - void *c_sasl_context; /* SASL session context */ + int c_sasl_done; /* SASL completed once */ + void *c_sasl_authctx; /* SASL authentication context */ + void *c_sasl_sockctx; /* SASL security layer context */ void *c_sasl_extra; /* SASL session extra stuff */ struct slap_op *c_sasl_bindop; /* set to current op if it's a bind */ @@ -1944,13 +2098,12 @@ typedef struct slap_conn { * supply data back to connected clients that are connected * through the "front-end". */ - SEND_LDAP_RESULT c_send_ldap_result; - SEND_SEARCH_ENTRY c_send_search_entry; - SEND_SEARCH_RESULT c_send_search_result; - SEND_SEARCH_REFERENCE c_send_search_reference; - SEND_LDAP_EXTENDED c_send_ldap_extended; + SEND_LDAP_RESULT *c_send_ldap_result; + SEND_SEARCH_ENTRY *c_send_search_entry; + SEND_SEARCH_REFERENCE *c_send_search_reference; + SEND_LDAP_EXTENDED *c_send_ldap_extended; #ifdef LDAP_RES_INTERMEDIATE_RESP - SEND_LDAP_INTERMEDIATE_RESP c_send_ldap_intermediate_resp; + SEND_LDAP_INTERMEDIATE_RESP *c_send_ldap_intermediate_resp; #endif } Connection; @@ -1972,14 +2125,6 @@ typedef struct slap_conn { fprintf( stderr, (fmt), (connid), (opid), (arg1), (arg2), (arg3) );\ } while (0) #define StatslogTest( level ) (ldap_debug & (level)) -#elif defined(LDAP_SYSLOG) -#define Statslog( level, fmt, connid, opid, arg1, arg2, arg3 ) \ - do { \ - if ( ldap_syslog & (level) ) \ - syslog( ldap_syslog_level, (fmt), (connid), (opid), (arg1), \ - (arg2), (arg3) ); \ - } while (0) -#define StatslogTest( level ) (ldap_syslog & (level)) #else #define Statslog( level, fmt, connid, opid, arg1, arg2, arg3 ) #define StatslogTest( level ) (0) @@ -1998,6 +2143,7 @@ struct slap_listener { #ifdef LDAP_CONNECTIONLESS int sl_is_udp; /* UDP listener is also data port */ #endif + int sl_is_mute; /* Listening is temporarily disabled */ ber_socket_t sl_sd; Sockaddr sl_sa; #define sl_addr sl_sa.sa_in_addr @@ -2042,6 +2188,30 @@ enum { #define SLAP_SEARCH_MAX_CTRLS 10 #endif +#define SLAP_CTRL_FRONTEND 0x80000000U +#define SLAP_CTRL_FRONTEND_SEARCH 0x01000000U /* for NOOP */ + +#define SLAP_CTRL_OPFLAGS 0x0000FFFFU +#define SLAP_CTRL_ABANDON 0x00000001U +#define SLAP_CTRL_ADD 0x00002002U +#define SLAP_CTRL_BIND 0x00000004U +#define SLAP_CTRL_COMPARE 0x00001008U +#define SLAP_CTRL_DELETE 0x00002010U +#define SLAP_CTRL_MODIFY 0x00002020U +#define SLAP_CTRL_RENAME 0x00002040U +#define SLAP_CTRL_SEARCH 0x00001080U +#define SLAP_CTRL_UNBIND 0x00000100U + +#define SLAP_CTRL_INTROGATE (SLAP_CTRL_COMPARE|SLAP_CTRL_SEARCH) +#define SLAP_CTRL_UPDATE \ + (SLAP_CTRL_ADD|SLAP_CTRL_DELETE|SLAP_CTRL_MODIFY|SLAP_CTRL_RENAME) +#define SLAP_CTRL_ACCESS (SLAP_CTRL_INTROGATE|SLAP_CTRL_UPDATE) + +typedef int (SLAP_CTRL_PARSE_FN) LDAP_P(( + Operation *op, + SlapReply *rs, + LDAPControl *ctrl )); + LDAP_END_DECL #include "proto-slap.h"