X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fslap.h;h=1ca24c39276c2ed3e21d23440b5cfcbb24cd02b2;hb=0f2eab27ce104de20bc0eb4f6b05196111f07c06;hp=a672e1ea86301fd7e7b062bcec3d4173fb1c074f;hpb=8a5b200c447a758d91805827593db72c54bea6e2;p=openldap diff --git a/servers/slapd/slap.h b/servers/slapd/slap.h index a672e1ea86..1ca24c3927 100644 --- a/servers/slapd/slap.h +++ b/servers/slapd/slap.h @@ -1,7 +1,7 @@ /* slap.h - stand alone ldap server include file */ /* $OpenLDAP$ */ /* - * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved. + * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved. * COPYING RESTRICTIONS APPLY, see COPYRIGHT file */ @@ -35,6 +35,11 @@ #include "ldap_pvt_thread.h" #include "ldap_queue.h" +#ifdef LDAP_DEVEL +#define SLAP_EXTENDED_SCHEMA 1 +#define LDAP_CACHING +#endif + LDAP_BEGIN_DECL /* * SLAPD Memory allocation macros @@ -62,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 */ @@ -141,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" @@ -164,8 +168,13 @@ typedef struct slap_ssf_set { slap_ssf_t sss_update_transport; slap_ssf_t sss_update_tls; slap_ssf_t sss_update_sasl; + 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 + /* * Index types */ @@ -198,7 +207,7 @@ typedef struct slap_ssf_set { #define SLAP_INDEX_FLAGS 0xF000UL #define SLAP_INDEX_NOSUBTYPES 0x1000UL /* don't use index w/ subtypes */ -#define SLAP_INDEX_NOLANG 0x2000UL /* don't use index w/ lang */ +#define SLAP_INDEX_NOTAGS 0x2000UL /* don't use index w/ tags */ /* * there is a single index for each attribute. these prefixes ensure @@ -211,9 +220,15 @@ typedef struct slap_ssf_set { #define SLAP_INDEX_SUBSTR_FINAL_PREFIX '$' #define SLAP_INDEX_CONT_PREFIX '.' /* prefix for continuation keys */ -#define SLAP_SYNTAX_MATCHINGRULES_OID "1.3.6.1.4.1.1466.115.121.1.30" -#define SLAP_SYNTAX_ATTRIBUTETYPES_OID "1.3.6.1.4.1.1466.115.121.1.3" -#define SLAP_SYNTAX_OBJECTCLASSES_OID "1.3.6.1.4.1.1466.115.121.1.37" +#define SLAP_SYNTAX_MATCHINGRULES_OID "1.3.6.1.4.1.1466.115.121.1.30" +#define SLAP_SYNTAX_ATTRIBUTETYPES_OID "1.3.6.1.4.1.1466.115.121.1.3" +#define SLAP_SYNTAX_OBJECTCLASSES_OID "1.3.6.1.4.1.1466.115.121.1.37" +#define SLAP_SYNTAX_MATCHINGRULEUSES_OID "1.3.6.1.4.1.1466.115.121.1.31" +#define SLAP_SYNTAX_CONTENTRULE_OID "1.3.6.1.4.1.1466.115.121.1.16" + +#ifdef LDAP_CLIENT_UPDATE +#define LCUP_COOKIE_OID "1.3.6.1.4.1.4203.666.10.1" +#endif /* LDAP_CLIENT_UPDATE */ /* * represents schema information for a database @@ -238,12 +253,17 @@ typedef struct slap_ssf_set { #define SLAP_SCHERR_NOT_SUPPORTED 18 #define SLAP_SCHERR_BAD_DESCR 19 #define SLAP_SCHERR_OIDM 20 -#define SLAP_SCHERR_LAST SLAP_SCHERR_OIDM +#define SLAP_SCHERR_CR_DUP 21 +#define SLAP_SCHERR_CR_BAD_STRUCT 22 +#define SLAP_SCHERR_CR_BAD_AUX 23 +#define SLAP_SCHERR_CR_BAD_AT 24 +#define SLAP_SCHERR_LAST SLAP_SCHERR_CR_BAD_AT typedef union slap_sockaddr { struct sockaddr sa_addr; struct sockaddr_in sa_in_addr; #ifdef LDAP_PF_INET6 + struct sockaddr_storage sa_storage; struct sockaddr_in6 sa_in6_addr; #endif #ifdef LDAP_PF_LOCAL @@ -258,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 */ @@ -272,7 +292,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; @@ -299,7 +320,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 @@ -308,7 +328,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) @@ -321,7 +341,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; @@ -332,7 +351,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(( @@ -340,7 +360,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(( @@ -359,7 +380,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(( @@ -369,7 +391,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; @@ -380,7 +403,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 @@ -393,45 +416,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 | 0x0100U ) -#define SLAP_MR_EQUALITY_APPROX ( SLAP_MR_EQUALITY | 0x0010U ) -#define SLAP_MR_DN_FOLD 0x0008U +#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_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; @@ -441,14 +483,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 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 @@ -464,7 +506,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 @@ -485,6 +527,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; @@ -518,7 +561,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 @@ -572,7 +615,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 @@ -585,7 +628,6 @@ typedef struct slap_object_class { #define SLAP_OC_OPERATIONAL 0x4000 #define SLAP_OC_HIDE 0x8000 -#ifdef LDAP_EXTENDED_SCHEMA /* * DIT content rule */ @@ -596,29 +638,28 @@ typedef struct slap_content_rule { AttributeType **scr_required; /* optional */ AttributeType **scr_allowed; /* optional */ AttributeType **scr_precluded; /* optional */ -#define scr_oid scr_crule.cr_oid -#define scr_names scr_crule.cr_names -#define scr_desc scr_crule.cr_desc -#define scr_obsolete soc_oclass.cr_obsolete -#define scr_cr_oids_aux soc_oclass.cr_oc_oids_aux -#define scr_cr_oids_must soc_oclass.cr_at_oids_must -#define scr_cr_oids_may soc_oclass.cr_at_oids_may -#define scr_cr_oids_not soc_oclass.cr_at_oids_not +#define scr_oid scr_crule.cr_oid +#define scr_names scr_crule.cr_names +#define scr_desc scr_crule.cr_desc +#define scr_obsolete scr_crule.cr_obsolete +#define scr_oc_oids_aux scr_crule.cr_oc_oids_aux +#define scr_at_oids_must scr_crule.cr_at_oids_must +#define scr_at_oids_may scr_crule.cr_at_oids_may +#define scr_at_oids_not scr_crule.cr_at_oids_not + + LDAP_SLIST_ENTRY( slap_content_rule ) scr_next; } ContentRule; -#endif -/* - * represents a recognized attribute description ( type + options ) - */ +/* Represents a recognized attribute description ( type + options ). */ typedef struct slap_attr_desc { struct slap_attr_desc *ad_next; AttributeType *ad_type; /* attribute type, must be specified */ struct berval ad_cname; /* canonical name, must be specified */ - struct berval ad_lang; /* empty if no language tags */ + struct berval ad_tags; /* empty if no tagging options */ unsigned ad_flags; #define SLAP_DESC_NONE 0x00U #define SLAP_DESC_BINARY 0x01U -#define SLAP_DESC_LANG_RANGE 0x80U +#define SLAP_DESC_TAG_RANGE 0x80U } AttributeDescription; typedef struct slap_attr_name { @@ -627,9 +668,9 @@ typedef struct slap_attr_name { ObjectClass *an_oc; } AttributeName; -#define slap_ad_is_lang(ad) ( (ad)->ad_lang.bv_len != 0 ) -#define slap_ad_is_lang_range(ad) \ - ( ((ad)->ad_flags & SLAP_DESC_LANG_RANGE) ? 1 : 0 ) +#define slap_ad_is_tagged(ad) ( (ad)->ad_tags.bv_len != 0 ) +#define slap_ad_is_tag_range(ad) \ + ( ((ad)->ad_flags & SLAP_DESC_TAG_RANGE) ? 1 : 0 ) #define slap_ad_is_binary(ad) \ ( ((ad)->ad_flags & SLAP_DESC_BINARY) ? 1 : 0 ) @@ -664,6 +705,13 @@ 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; @@ -725,12 +773,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 { @@ -815,29 +868,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; /* @@ -845,8 +919,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 @@ -894,7 +969,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 { @@ -902,7 +979,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; @@ -912,7 +991,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; /* @@ -1082,6 +1161,7 @@ typedef struct slap_acl_state { /* Access state */ AccessControl *as_vd_acl; + AccessControl *as_vi_acl; slap_mask_t as_vd_acl_mask; regmatch_t as_vd_acl_matches[MAXREMATCHES]; int as_vd_acl_count; @@ -1090,17 +1170,10 @@ typedef struct slap_acl_state { int as_vd_access_count; int as_result; + AttributeDescription *as_vd_ad; } AccessControlState; -#define ACL_STATE_INIT { ACL_STATE_NOT_RECORDED, NULL, 0UL, { { 0, 0 } }, 0, NULL, 0, 0 } - -/* - * 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 @@ -1139,6 +1212,8 @@ struct slap_limits_set { int lms_s_soft; int lms_s_hard; int lms_s_unchecked; + int lms_s_pr; + int lms_s_pr_hide; }; struct slap_limits { @@ -1184,15 +1259,25 @@ 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 #define be_attribute bd_info->bi_acl_attribute #define be_operational bd_info->bi_operational +/* + * define to honor hasSubordinates operational attribute in search filters + * (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 #define be_connection_init bd_info->bi_connection_init @@ -1220,6 +1305,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) @@ -1237,7 +1326,7 @@ struct slap_backend_db { #define SLAP_RESTRICT_OP_SEARCH 0x0080U #define SLAP_RESTRICT_OP_READS \ - ( SLAP_RESTRICT_OP_COMPARE \ + ( SLAP_RESTRICT_OP_COMPARE \ | SLAP_RESTRICT_OP_SEARCH ) #define SLAP_RESTRICT_OP_WRITES \ ( SLAP_RESTRICT_OP_ADD \ @@ -1247,7 +1336,9 @@ struct slap_backend_db { #define SLAP_ALLOW_BIND_V2 0x0001U /* LDAPv2 bind */ #define SLAP_ALLOW_BIND_ANON_CRED 0x0002U /* cred should be empty */ -#define SLAP_ALLOW_BIND_ANON_DN 0x0003U /* dn should be empty */ +#define SLAP_ALLOW_BIND_ANON_DN 0x0004U /* dn should be empty */ + +#define SLAP_ALLOW_UPDATE_ANON 0x0008U /* allow anonymous updates */ #define SLAP_DISALLOW_BIND_ANON 0x0001U /* no anonymous */ #define SLAP_DISALLOW_BIND_SIMPLE 0x0002U /* simple authentication */ @@ -1258,6 +1349,8 @@ struct slap_backend_db { #define SLAP_DISALLOW_TLS_2_ANON 0x0010U /* StartTLS -> Anonymous */ #define SLAP_DISALLOW_TLS_AUTHC 0x0020U /* TLS while authenticated */ +#define SLAP_DISALLOW_AUX_WO_CR 0x4000U + slap_mask_t be_requires; /* pre-operation requirements */ #define SLAP_REQUIRE_BIND 0x0001U /* bind before op */ #define SLAP_REQUIRE_LDAP_V3 0x0002U /* LDAPv3 before op */ @@ -1271,15 +1364,12 @@ 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 */ -#ifdef SLAPD_SCHEMA_DN struct berval be_schemadn; /* per-backend subschema subentry DN */ struct berval be_schemandn; /* normalized subschema DN */ -#endif struct berval be_rootdn; /* the magic "root" name (DN) for this db */ struct berval be_rootndn; /* the magic "root" normalized name (DN) for this db */ struct berval be_rootpw; /* the magic "root" password for this db */ - unsigned int be_max_deref_depth; /* limit for depth of an alias deref */ + unsigned int be_max_deref_depth; /* limit for depth of an alias deref */ #define be_sizelimit be_def_limit.lms_s_soft #define be_timelimit be_def_limit.lms_t_soft struct slap_limits_set be_def_limit; /* default limits */ @@ -1292,6 +1382,8 @@ struct slap_backend_db { BerVarray be_update_refs; /* where to refer modifying clients to */ char *be_realm; void *be_private; /* anything the backend database needs */ + + void *be_pb; /* Netscape plugin */ }; struct slap_conn; @@ -1314,81 +1406,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 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)); @@ -1471,18 +1601,18 @@ 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; BI_connection_init *bi_connection_init; BI_connection_destroy *bi_connection_destroy; @@ -1524,22 +1654,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; @@ -1553,6 +1671,21 @@ typedef struct slap_paged_state { ID ps_id; } PagedResultsState; + +#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 slap_op *ps_op; + LDAP_LIST_ENTRY(psid_entry) ps_link; +}; +#endif + + /* * represents an operation pending from an ldap client */ @@ -1560,50 +1693,198 @@ 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 */ + 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_CONNECTIONLESS - Sockaddr o_peeraddr; /* UDP peer address */ +#ifdef LDAP_CLIENT_UPDATE + char o_clientupdate; + char o_clientupdate_type; +#define SLAP_LCUP_NONE (0x0) +#define SLAP_LCUP_SYNC (0x1) +#define SLAP_LCUP_PERSIST (0x2) +#define SLAP_LCUP_SYNC_AND_PERSIST (0x3) + ber_int_t o_clientupdate_interval; + struct berval o_clientupdate_state; #endif + +#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 */ 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; -#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 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 @@ -1618,6 +1899,8 @@ typedef struct slap_gacl { char ga_ndn[1]; } GroupAssertion; +typedef struct slap_listener Listener; + /* * represents a connection from an ldap client */ @@ -1633,10 +1916,11 @@ typedef struct slap_conn { time_t c_activitytime; /* when the connection was last used */ unsigned long c_connid; /* id of this connection for stats*/ - struct berval c_listener_url; /* listener URL */ struct berval c_peer_domain; /* DNS name of client */ struct berval c_peer_name; /* peer name (trans=addr:port) */ - struct berval c_sock_name; /* sock name (trans=addr:port) */ + Listener *c_listener; +#define c_listener_url c_listener->sl_url /* listener URL */ +#define c_sock_name c_listener->sl_name /* sock name (trans=addr:port) */ /* only can be changed by binding thread */ int c_sasl_bind_in_progress; /* multi-op bind in progress */ @@ -1682,6 +1966,22 @@ typedef struct slap_conn { long c_n_get; /* num of get calls */ long c_n_read; /* num of read calls */ long c_n_write; /* num of write calls */ + + 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_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; #if defined(LDAP_SYSLOG) && defined(LDAP_DEBUG) @@ -1691,18 +1991,28 @@ typedef struct slap_conn { fprintf( stderr, (fmt), (connid), (opid), (arg1), (arg2), (arg3) );\ if ( ldap_syslog & (level) ) \ syslog( ldap_syslog_level, (fmt), (connid), (opid), (arg1), \ - (arg2), (arg3) ); \ + (arg2), (arg3) ); \ } while (0) +#define StatslogTest( level ) ((ldap_debug | ldap_syslog) & (level)) +#elif defined(LDAP_DEBUG) +#define Statslog( level, fmt, connid, opid, arg1, arg2, arg3 ) \ + do { \ + if ( ldap_debug & (level) ) \ + fprintf( stderr, (fmt), (connid), (opid), (arg1), (arg2), (arg3) );\ + } while (0) +#define StatslogTest( level ) (ldap_debug & (level)) #else #define Statslog( level, fmt, connid, opid, arg1, arg2, arg3 ) +#define StatslogTest( level ) (0) #endif /* * listener; need to access it from monitor backend */ -typedef struct slap_listener { - char* sl_url; - char* sl_name; +struct slap_listener { + struct berval sl_url; + struct berval sl_name; + mode_t sl_perms; #ifdef HAVE_TLS int sl_is_tls; #endif @@ -1712,7 +2022,7 @@ typedef struct slap_listener { ber_socket_t sl_sd; Sockaddr sl_sa; #define sl_addr sl_sa.sa_in_addr -} Listener; +}; #ifdef SLAPD_MONITOR /* @@ -1739,6 +2049,44 @@ enum { #define SLAP_LDAPDN_PRETTY 0x1 #define SLAP_LDAPDN_MAXLEN 8192 +/* + * Macros for LCUP + */ +#ifdef LDAP_CLIENT_UPDATE +#define SLAP_LCUP_STATE_UPDATE_TRUE 1 +#define SLAP_LCUP_STATE_UPDATE_FALSE 0 +#define SLAP_LCUP_ENTRY_DELETED_TRUE 1 +#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"