X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fslap.h;h=939198ed28ae3950c5a4f83eb65f7998b3a5f91a;hb=fbc6a7e8ac780fd421e057c34caa9d4ecb166807;hp=a7c28fc0106668e69d8d946019797bd09c2f33de;hpb=6939c531700652491f4be4688c6a1f35a1ab8a18;p=openldap diff --git a/servers/slapd/slap.h b/servers/slapd/slap.h index a7c28fc010..939198ed28 100644 --- a/servers/slapd/slap.h +++ b/servers/slapd/slap.h @@ -35,7 +35,10 @@ #include "ldap_pvt_thread.h" #include "ldap_queue.h" +#ifdef LDAP_DEVEL #define SLAP_EXTENDED_SCHEMA 1 +#define LDAP_CACHING +#endif LDAP_BEGIN_DECL /* @@ -64,21 +67,22 @@ LDAP_BEGIN_DECL #define SLAPD_ANONYMOUS "cn=anonymous" /* LDAPMod.mod_op value ===> Must be kept in sync with ldap.h! - * * This is a value used internally by the backends. It is needed to allow * adding values that already exist without getting an error as required by * modrdn when the new rdn was already an attribute value itself. - * JCG 05/1999 (gomez@engr.sgi.com) */ #define SLAP_MOD_SOFTADD 0x1000 #define MAXREMATCHES (100) -#define SLAP_MAX_WORKER_THREADS (32) +#define SLAP_MAX_WORKER_THREADS (16) #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 */ @@ -143,8 +147,6 @@ LDAP_BEGIN_DECL #define SLAPD_ACI_SYNTAX "1.3.6.1.4.1.4203.666.2.1" #endif -#define SLAPD_OCTETSTRING_SYNTAX "1.3.6.1.4.1.1466.115.121.1.40" - /* change this to "OpenLDAPset" */ #define SLAPD_ACI_SET_ATTR "template" @@ -169,7 +171,6 @@ typedef struct slap_ssf_set { slap_ssf_t sss_simple_bind; } slap_ssf_set_t; - /* Flags for telling slap_sasl_getdn() what type of identity is being passed */ #define SLAP_GETDN_AUTHCID 2 #define SLAP_GETDN_AUTHZID 4 @@ -277,7 +278,7 @@ extern int slap_inet4or6; typedef struct slap_oid_macro { struct berval som_oid; char **som_names; - struct slap_oid_macro *som_next; + LDAP_SLIST_ENTRY(slap_oid_macro) som_next; } OidMacro; /* forward declarations */ @@ -318,7 +319,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 @@ -327,7 +327,7 @@ typedef struct slap_syntax { slap_syntax_transform_func *ssyn_str2ber; #endif - struct slap_syntax *ssyn_next; + LDAP_SLIST_ENTRY(slap_syntax) ssyn_next; } Syntax; #define slap_syntax_is_flag(s,flag) ((int)((s)->ssyn_flags & (flag)) ? 1 : 0) @@ -340,7 +340,7 @@ 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_normalizeXXX; /* to be deleted */ slap_syntax_transform_func *sd_pretty; #ifdef SLAPD_BINARY_CONVERSION slap_syntax_transform_func *sd_ber2str; @@ -399,7 +399,7 @@ typedef struct slap_matching_rule { struct berval smr_str; /* * Note: the former - ber_len_t smr_oidlen; + * ber_len_t smr_oidlen; * has been replaced by a struct berval that uses the value * provided by smr_mrule.mr_oid; a macro that expands to * the bv_len field of the berval is provided for backward @@ -412,46 +412,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 ) -#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) +/* 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_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; @@ -461,14 +479,14 @@ typedef struct slap_matching_rule { slap_mr_filter_func *smr_filter; /* - * null terminated list of syntaxes compatible with this syntax + * null terminated array of syntaxes compatible with this syntax * note: when MS_EXT is set, this MUST NOT contain the assertion * syntax of the rule. When MS_EXT is not set, it MAY. */ Syntax **smr_compat_syntaxes; struct slap_matching_rule *smr_associated; - struct slap_matching_rule *smr_next; + LDAP_SLIST_ENTRY(slap_matching_rule)smr_next; #define smr_oid smr_mrule.mr_oid #define smr_names smr_mrule.mr_names @@ -484,7 +502,7 @@ struct slap_matching_rule_use { /* RFC2252 string representation */ struct berval smru_str; - struct slap_matching_rule_use *smru_next; + LDAP_SLIST_ENTRY(slap_matching_rule_use) smru_next; #define smru_oid smru_mruleuse.mru_oid #define smru_names smru_mruleuse.mru_names @@ -505,6 +523,7 @@ 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 appropriate approximate rule */ char * mrd_associated; } slap_mrule_defs_rec; @@ -538,7 +557,7 @@ typedef struct slap_attribute_type { #define SLAP_AT_HIDE 0x8000U /* hide attribute */ slap_mask_t sat_flags; - struct slap_attribute_type *sat_next; + LDAP_SLIST_ENTRY(slap_attribute_type) sat_next; #define sat_oid sat_atype.at_oid #define sat_names sat_atype.at_names @@ -592,7 +611,7 @@ typedef struct slap_object_class { #define soc_at_oids_may soc_oclass.oc_at_oids_may #define soc_extensions soc_oclass.oc_extensions - struct slap_object_class *soc_next; + LDAP_SLIST_ENTRY(slap_object_class) soc_next; } ObjectClass; #define SLAP_OC_ALIAS 0x0001 @@ -624,7 +643,7 @@ typedef struct slap_content_rule { #define scr_at_oids_may scr_crule.cr_at_oids_may #define scr_at_oids_not scr_crule.cr_at_oids_not - struct slap_content_rule *scr_next; + LDAP_SLIST_ENTRY( slap_content_rule ) scr_next; } ContentRule; /* Represents a recognized attribute description ( type + options ). */ @@ -682,8 +701,14 @@ 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 */ + /* root DSE attribute descriptions */ AttributeDescription *si_ad_altServer; AttributeDescription *si_ad_namingContexts; @@ -744,12 +769,17 @@ struct slap_internal_schema { /* 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; /* 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 { @@ -834,29 +864,50 @@ typedef struct slap_filter { #define SLAPD_COMPARE_UNDEFINED ((ber_int_t) -1) typedef struct slap_valuesreturnfilter { - ber_tag_t f_choice; + ber_tag_t vrf_choice; union vrf_un_u { /* precomputed result */ - ber_int_t f_un_result; + ber_int_t vrf_un_result; /* DN */ - char *f_un_dn; + char *vrf_un_dn; /* present */ - AttributeDescription *f_un_desc; + AttributeDescription *vrf_un_desc; /* simple value assertion */ - AttributeAssertion *f_un_ava; + AttributeAssertion *vrf_un_ava; /* substring assertion */ - SubstringsAssertion *f_un_ssa; + SubstringsAssertion *vrf_un_ssa; /* matching rule assertion */ - MatchingRuleAssertion *f_un_mra; - } f_un; - - struct slap_valuesreturnfilter *f_next; + MatchingRuleAssertion *vrf_un_mra; + +#define vrf_result vrf_un.vrf_un_result +#define vrf_dn vrf_un.vrf_un_dn +#define vrf_desc vrf_un.vrf_un_desc +#define vrf_ava vrf_un.vrf_un_ava +#define vrf_av_desc vrf_un.vrf_un_ava->aa_desc +#define vrf_av_value vrf_un.vrf_un_ava->aa_value +#define vrf_ssa vrf_un.vrf_un_ssa +#define vrf_sub vrf_un.vrf_un_ssa +#define vrf_sub_desc vrf_un.vrf_un_ssa->sa_desc +#define vrf_sub_initial vrf_un.vrf_un_ssa->sa_initial +#define vrf_sub_any vrf_un.vrf_un_ssa->sa_any +#define vrf_sub_final vrf_un.vrf_un_ssa->sa_final +#define vrf_mra vrf_un.vrf_un_mra +#define vrf_mr_rule vrf_un.vrf_un_mra->ma_rule +#define vrf_mr_rule_text vrf_un.vrf_un_mra->ma_rule_text +#define vrf_mr_desc vrf_un.vrf_un_mra->ma_desc +#define vrf_mr_value vrf_un.vrf_un_mra->ma_value +#define vrf_mr_dnattrs vrf_un.vrf_un_mra->ma_dnattrs + + + } vrf_un; + + struct slap_valuesreturnfilter *vrf_next; } ValuesReturnFilter; /* @@ -864,8 +915,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 @@ -913,7 +965,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 { @@ -921,7 +975,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; @@ -931,7 +987,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; /* @@ -1112,16 +1168,8 @@ typedef struct slap_acl_state { int as_result; AttributeDescription *as_vd_ad; } AccessControlState; -#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; -}; +#define ACL_STATE_INIT { ACL_STATE_NOT_RECORDED, NULL, NULL, 0UL, \ + { { 0, 0 } }, 0, NULL, 0, 0, NULL } /* * Backend-info @@ -1207,9 +1255,12 @@ struct slap_backend_db { #define be_modify bd_info->bi_op_modify #define be_modrdn bd_info->bi_op_modrdn #define be_search bd_info->bi_op_search +#define be_abandon bd_info->bi_op_abandon +#define be_cancel bd_info->bi_op_cancel #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 @@ -1221,7 +1272,6 @@ struct slap_backend_db { * (in previous use there was a flaw with back-bdb and back-ldbm; now it * is fixed). */ - #define be_has_subordinates bd_info->bi_has_subordinates #define be_controls bd_info->bi_controls @@ -1251,6 +1301,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) @@ -1306,7 +1360,6 @@ struct slap_backend_db { /* these should be renamed from be_ to bd_ */ BerVarray be_suffix; /* the DN suffixes of data in this backend */ BerVarray be_nsuffix; /* the normalized DN suffixes in this backend */ - BerVarray be_suffixAlias; /* pairs of DN suffix aliases and deref values */ struct berval be_schemadn; /* per-backend subschema subentry DN */ struct berval be_schemandn; /* normalized subschema DN */ struct berval be_rootdn; /* the magic "root" name (DN) for this db */ @@ -1349,85 +1402,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_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)); @@ -1510,17 +1597,16 @@ struct slap_backend_info { BI_op_add *bi_op_add; BI_op_delete *bi_op_delete; BI_op_abandon *bi_op_abandon; + BI_op_cancel *bi_op_cancel; /* Extended Operations Helper */ 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; @@ -1564,22 +1650,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_response)( struct slap_op *, struct slap_rep * ); typedef struct slap_callback { slap_response *sc_response; - slap_sresult *sc_sresult; - slap_sendentry *sc_sendentry; void *sc_private; } slap_callback; @@ -1594,36 +1668,18 @@ typedef struct slap_paged_state { } PagedResultsState; -#ifdef LDAP_CLIENT_UPDATE -#define LCUP_PSEARCH_BY_ADD 0x01 -#define LCUP_PSEARCH_BY_DELETE 0x02 -#define LCUP_PSEARCH_BY_PREMODIFY 0x03 -#define LCUP_PSEARCH_BY_MODIFY 0x04 -#define LCUP_PSEARCH_BY_SCOPEOUT 0x05 - -struct lcup_search_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; - struct lcup_entry *elist; - ldap_pvt_thread_mutex_t elist_mutex; - int entry_count; - LDAP_LIST_ENTRY(lcup_search_spec) link; -}; +#if defined(LDAP_CLIENT_UPDATE) || defined(LDAP_SYNC) +#define LDAP_PSEARCH_BY_ADD 0x01 +#define LDAP_PSEARCH_BY_DELETE 0x02 +#define LDAP_PSEARCH_BY_PREMODIFY 0x03 +#define LDAP_PSEARCH_BY_MODIFY 0x04 +#define LDAP_PSEARCH_BY_SCOPEOUT 0x05 struct psid_entry { - struct lcup_search_spec* ps; - LDAP_LIST_ENTRY(psid_entry) link; + struct slap_op *ps_op; + LDAP_LIST_ENTRY(psid_entry) ps_link; }; -#endif /* LDAP_CLIENT_UPDATE */ +#endif /* @@ -1633,33 +1689,118 @@ 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 */ volatile sig_atomic_t o_abandon; /* abandon flag */ + volatile sig_atomic_t o_cancel; /* cancel flag */ +#define SLAP_CANCEL_NONE 0x00 +#define SLAP_CANCEL_REQ 0x01 +#define SLAP_CANCEL_ACK 0x02 +#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 #define SLAP_CRITICAL_CONTROL 2 char o_managedsait; +#define get_manageDSAit(op) ((int)(op)->o_managedsait) + char o_noop; char o_proxy_authz; + 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) + char o_valuesreturnfilter; +#ifdef LDAP_CONTROL_X_PERMISSIVE_MODIFY + char o_permissive_modify; +#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 get_domainScope(op) ((int)(op)->o_domain_scope) +#else +#define get_domainScope(op) (0) +#endif + +#ifdef LDAP_CONTROL_PAGEDRESULTS char o_pagedresults; +#define get_pagedresults(op) ((int)(op)->o_pagedresults) ber_int_t o_pagedresults_size; PagedResultsState o_pagedresults_state; +#else +#define get_pagedresults(op) (0) +#endif #ifdef LDAP_CLIENT_UPDATE char o_clientupdate; @@ -1667,20 +1808,34 @@ typedef struct slap_op { #define SLAP_LCUP_NONE (0x0) #define SLAP_LCUP_SYNC (0x1) #define SLAP_LCUP_PERSIST (0x2) -#define SLAP_LCUP_SYNC_AND_PERSIST (0x3) +#define SLAP_LCUP_SYNC_AND_PERSIST (0x3) ber_int_t o_clientupdate_interval; struct berval o_clientupdate_state; - LDAP_LIST_HEAD(lss, lcup_search_spec) psearch_spec; - LDAP_LIST_HEAD(pe, psid_entry) premodify_list; - LDAP_LIST_ENTRY(slap_op) link; -#endif /* LDAP_CLIENT_UPDATE */ +#endif -#ifdef LDAP_CONNECTIONLESS - Sockaddr o_peeraddr; /* UDP peer address */ +#ifdef LDAP_SYNC + char o_sync; + char o_sync_mode; +#define SLAP_SYNC_NONE (0x0) +#define SLAP_SYNC_REFRESH (0x1) +#define SLAP_SYNC_PERSIST (0x2) +#define SLAP_SYNC_REFRESH_AND_PERSIST (0x3) + struct berval o_sync_state; #endif + +#if defined(LDAP_CLIENT_UPDATE) || defined(LDAP_SYNC) + 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 + AuthorizationInformation o_authz; BerElement *o_ber; /* ber of the request */ +#ifdef LDAP_CONNECTIONLESS + BerElement *o_res_ber; /* ber of the reply */ +#endif slap_callback *o_callback; /* callback pointers */ LDAPControl **o_ctrls; /* controls */ @@ -1690,89 +1845,36 @@ typedef struct slap_op { LDAP_STAILQ_ENTRY(slap_op) o_next; /* next operation in list */ ValuesReturnFilter *vrFilter; /* Structure represents ValuesReturnFilter */ - void *o_pb; /* Netscape plugin */ +#ifdef LDAP_CACHING + char o_caching_on; +#endif /*LDAP_CACHING */ +#ifdef LDAP_SLAPI + void *o_pb; /* NS-SLAPI plugin */ +#endif } Operation; -#define get_manageDSAit(op) ((int)(op)->o_managedsait) -#define get_subentries(op) ((int)(op)->o_subentries) -#define get_subentries_visibility(op) ((int)(op)->o_subentries_visibility) -#define get_pagedresults(op) ((int)(op)->o_pagedresults) - - - -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 ) - +#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 @@ -1857,16 +1959,18 @@ typedef struct slap_conn { void *c_pb; /* Netscape plugin */ - /* + /* * These are the "callbacks" that are available for back-ends to * 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; +#endif } Connection; @@ -1887,14 +1991,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) @@ -1953,6 +2049,34 @@ enum { #define SLAP_LCUP_ENTRY_DELETED_FALSE 0 #endif /* LDAP_CLIENT_UPDATE */ +#if defined(LDAP_CLIENT_UPDATE) || defined(LDAP_SYNC) +#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"