servers/slapd/slap.h - diff

Return to slap.h CVS log

Up to [OpenLDAP] / servers / slapd

Diff for /servers/slapd/slap.h between versions 1.452 and 1.452.2.14

version 1.452, 2003/05/30 03:24:39	version 1.452.2.14, 2004/03/22 17:33:28
Line 1	Line 1
/* slap.h - stand alone ldap server include file */	/* slap.h - stand alone ldap server include file */
/* $OpenLDAP: pkg/ldap/servers/slapd/slap.h,v 1.451 2003/05/30 00:17:30 kurt Exp $ */	/* $OpenLDAP: pkg/ldap/servers/slapd/slap.h,v 1.527 2004/03/20 11:56:31 hyc Exp $ */
/*	/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
* Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.	*
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file	* Copyright 1998-2004 The OpenLDAP Foundation.
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted only as authorized by the OpenLDAP
	* Public License.
	*
	* A copy of this license is available in the file LICENSE in the
	* top-level directory of the distribution or, alternatively, at
	* <http://www.OpenLDAP.org/license.html>.
	*/
	/* Portions Copyright (c) 1995 Regents of the University of Michigan.
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms are permitted
	* provided that this notice is preserved and that due credit is given
	* to the University of Michigan at Ann Arbor. The name of the University
	* may not be used to endorse or promote products derived from this
	* software without specific prior written permission. This software
	* is provided ``as is'' without express or implied warranty.
*/	*/

#ifndef _SLAP_H_	#ifndef _SLAP_H_
Line 32	Line 51
#include <ldap.h>	#include <ldap.h>
#include <ldap_schema.h>	#include <ldap_schema.h>

	#include "lber_pvt.h"
#include "ldap_pvt_thread.h"	#include "ldap_pvt_thread.h"
#include "ldap_queue.h"	#include "ldap_queue.h"

#ifdef LDAP_DEVEL
#define SLAP_EXTENDED_SCHEMA 1
#define LDAP_CACHING
#endif

LDAP_BEGIN_DECL	LDAP_BEGIN_DECL
/*	/*
* SLAPD Memory allocation macros	* SLAPD Memory allocation macros
Line 77 LDAP_BEGIN_DECL	Line 92 LDAP_BEGIN_DECL

#define SLAP_MAX_WORKER_THREADS (16)	#define SLAP_MAX_WORKER_THREADS (16)

#ifdef LDAP_SYNCREPL
#define SLAP_MAX_SYNCREPL_THREADS (8)	#define SLAP_MAX_SYNCREPL_THREADS (8)
#endif

#define SLAP_SB_MAX_INCOMING_DEFAULT ((1<<18) - 1)	#define SLAP_SB_MAX_INCOMING_DEFAULT ((1<<18) - 1)
#define SLAP_SB_MAX_INCOMING_AUTH ((1<<24) - 1)	#define SLAP_SB_MAX_INCOMING_AUTH ((1<<24) - 1)
Line 90 LDAP_BEGIN_DECL	Line 103 LDAP_BEGIN_DECL
#define SLAP_TEXT_BUFLEN (256)	#define SLAP_TEXT_BUFLEN (256)

/* psuedo error code indicating abandoned operation */	/* psuedo error code indicating abandoned operation */
#define SLAPD_ABANDON (-1)	#define SLAPD_ABANDON (-1024)

/* psuedo error code indicating disconnect */	/* psuedo error code indicating disconnect */
#define SLAPD_DISCONNECT (-2)	#define SLAPD_DISCONNECT (-1025)

	/* unknown config file directive */
	#define SLAP_CONF_UNKNOWN (-1026)

/* We assume "C" locale, that is US-ASCII */	/* We assume "C" locale, that is US-ASCII */
#define ASCII_SPACE(c) ( (c) == ' ' )	#define ASCII_SPACE(c) ( (c) == ' ' )
Line 102 LDAP_BEGIN_DECL	Line 117 LDAP_BEGIN_DECL
#define ASCII_UPPER(c) ( (c) >= 'A' && (c) <= 'Z' )	#define ASCII_UPPER(c) ( (c) >= 'A' && (c) <= 'Z' )
#define ASCII_ALPHA(c) ( ASCII_LOWER(c) \|\| ASCII_UPPER(c) )	#define ASCII_ALPHA(c) ( ASCII_LOWER(c) \|\| ASCII_UPPER(c) )
#define ASCII_DIGIT(c) ( (c) >= '0' && (c) <= '9' )	#define ASCII_DIGIT(c) ( (c) >= '0' && (c) <= '9' )
	#define ASCII_HEXLOWER(c) ( (c) >= 'a' && (c) <= 'f' )
	#define ASCII_HEXUPPER(c) ( (c) >= 'A' && (c) <= 'F' )
	#define ASCII_HEX(c) ( ASCII_DIGIT(c) \|\| \
	ASCII_HEXLOWER(c) \|\| ASCII_HEXUPPER(c) )
#define ASCII_ALNUM(c) ( ASCII_ALPHA(c) \|\| ASCII_DIGIT(c) )	#define ASCII_ALNUM(c) ( ASCII_ALPHA(c) \|\| ASCII_DIGIT(c) )
#define ASCII_PRINTABLE(c) ( (c) >= ' ' && (c) <= '~' )	#define ASCII_PRINTABLE(c) ( (c) >= ' ' && (c) <= '~' )

Line 142 LDAP_BEGIN_DECL	Line 161 LDAP_BEGIN_DECL
/* must match in schema_init.c */	/* must match in schema_init.c */
#define SLAPD_DN_SYNTAX "1.3.6.1.4.1.1466.115.121.1.12"	#define SLAPD_DN_SYNTAX "1.3.6.1.4.1.1466.115.121.1.12"
#define SLAPD_NAMEUID_SYNTAX "1.3.6.1.4.1.1466.115.121.1.34"	#define SLAPD_NAMEUID_SYNTAX "1.3.6.1.4.1.1466.115.121.1.34"
	#define SLAPD_INTEGER_SYNTAX "1.3.6.1.4.1.1466.115.121.1.27"
#define SLAPD_GROUP_ATTR "member"	#define SLAPD_GROUP_ATTR "member"
#define SLAPD_GROUP_CLASS "groupOfNames"	#define SLAPD_GROUP_CLASS "groupOfNames"
#define SLAPD_ROLE_ATTR "roleOccupant"	#define SLAPD_ROLE_ATTR "roleOccupant"
Line 230 typedef struct slap_ssf_set {	Line 250 typedef struct slap_ssf_set {
#define SLAP_SYNTAX_MATCHINGRULEUSES_OID "1.3.6.1.4.1.1466.115.121.1.31"	#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"	#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	* represents schema information for a database
*/	*/
Line 303 typedef struct slap_syntax {	Line 319 typedef struct slap_syntax {
LDAPSyntax ssyn_syn;	LDAPSyntax ssyn_syn;
#define ssyn_oid ssyn_syn.syn_oid	#define ssyn_oid ssyn_syn.syn_oid
#define ssyn_desc ssyn_syn.syn_desc	#define ssyn_desc ssyn_syn.syn_desc
#define ssyn_extensions ssyn_syn.syn_extensions	#define ssyn_extensions ssyn_syn.syn_extensions
/*	/*
* Note: the former	* Note: the former
ber_len_t ssyn_oidlen;	ber_len_t ssyn_oidlen;
Line 321 typedef struct slap_syntax {	Line 337 typedef struct slap_syntax {
#define SLAP_SYNTAX_BLOB 0x0001U /* syntax treated as blob (audio) */	#define SLAP_SYNTAX_BLOB 0x0001U /* syntax treated as blob (audio) */
#define SLAP_SYNTAX_BINARY 0x0002U /* binary transfer required (certificate) */	#define SLAP_SYNTAX_BINARY 0x0002U /* binary transfer required (certificate) */
#define SLAP_SYNTAX_BER 0x0004U /* stored in BER encoding (certificate) */	#define SLAP_SYNTAX_BER 0x0004U /* stored in BER encoding (certificate) */
	#ifdef LDAP_DEVEL
	#define SLAP_SYNTAX_HIDE 0x0000U /* publish everything */
	#else
#define SLAP_SYNTAX_HIDE 0x8000U /* hide (do not publish) */	#define SLAP_SYNTAX_HIDE 0x8000U /* hide (do not publish) */
	#endif

slap_syntax_validate_func *ssyn_validate;	slap_syntax_validate_func *ssyn_validate;
slap_syntax_transform_func *ssyn_pretty;	slap_syntax_transform_func *ssyn_pretty;
Line 418 typedef struct slap_matching_rule {	Line 438 typedef struct slap_matching_rule {

slap_mask_t smr_usage;	slap_mask_t smr_usage;

	#ifdef LDAP_DEVEL
	#define SLAP_MR_HIDE 0x0000U
	#else
#define SLAP_MR_HIDE 0x8000U	#define SLAP_MR_HIDE 0x8000U
	#endif

#define SLAP_MR_TYPE_MASK 0x0F00U	#define SLAP_MR_TYPE_MASK 0x0F00U
#define SLAP_MR_SUBTYPE_MASK 0x00F0U	#define SLAP_MR_SUBTYPE_MASK 0x00F0U
Line 450 typedef struct slap_matching_rule {	Line 474 typedef struct slap_matching_rule {
*/	*/
#define SLAP_MR_VALUE_OF_ASSERTION_SYNTAX 0x0001U	#define SLAP_MR_VALUE_OF_ASSERTION_SYNTAX 0x0001U
#define SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX 0x0002U	#define SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX 0x0002U
	#define SLAP_MR_VALUE_OF_SYNTAX 0x0003U

#define SLAP_MR_IS_VALUE_OF_ATTRIBUTE_SYNTAX( usage ) \	#define SLAP_MR_IS_VALUE_OF_ATTRIBUTE_SYNTAX( usage ) \
((usage) & SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX )	((usage) & SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX )
#define SLAP_MR_IS_VALUE_OF_ASSERTION_SYNTAX( usage ) \	#define SLAP_MR_IS_VALUE_OF_ASSERTION_SYNTAX( usage ) \
((usage) & SLAP_MR_VALUE_OF_ASSERTION_SYNTAX )	((usage) & SLAP_MR_VALUE_OF_ASSERTION_SYNTAX )
	#ifdef LDAP_DEBUG
	#define SLAP_MR_IS_VALUE_OF_SYNTAX( usage ) \
	((usage) & SLAP_MR_VALUE_OF_SYNTAX)
	#else
	#define SLAP_MR_IS_VALUE_OF_SYNTAX( usage ) (1)
	#endif

/* either or both the asserted value or attribute value	/* either or both the asserted value or attribute value
* may be provided in normalized form	* may be provided in normalized form
Line 571 typedef struct slap_attribute_type {	Line 602 typedef struct slap_attribute_type {
#define SLAP_AT_NONE 0x0000U	#define SLAP_AT_NONE 0x0000U
#define SLAP_AT_ABSTRACT 0x0100U /* cannot be instantiated */	#define SLAP_AT_ABSTRACT 0x0100U /* cannot be instantiated */
#define SLAP_AT_FINAL 0x0200U /* cannot be subtyped */	#define SLAP_AT_FINAL 0x0200U /* cannot be subtyped */
	#ifdef LDAP_DEVEL
	#define SLAP_AT_HIDE 0x0000U /* publish everything */
	#else
#define SLAP_AT_HIDE 0x8000U /* hide attribute */	#define SLAP_AT_HIDE 0x8000U /* hide attribute */
	#endif
slap_mask_t sat_flags;	slap_mask_t sat_flags;

LDAP_SLIST_ENTRY(slap_attribute_type) sat_next;	LDAP_SLIST_ENTRY(slap_attribute_type) sat_next;
Line 636 typedef struct slap_object_class {	Line 671 typedef struct slap_object_class {
#define SLAP_OC_SUBENTRY 0x0004	#define SLAP_OC_SUBENTRY 0x0004
#define SLAP_OC_DYNAMICOBJECT 0x0008	#define SLAP_OC_DYNAMICOBJECT 0x0008
#define SLAP_OC_COLLECTIVEATTRIBUTESUBENTRY 0x0010	#define SLAP_OC_COLLECTIVEATTRIBUTESUBENTRY 0x0010
#define SLAP_OC__MASK 0x001F	#define SLAP_OC_GLUE 0x0020
#define SLAP_OC__END 0x0020	#define SLAP_OC_SYNCPROVIDERSUBENTRY 0x0040
	#define SLAP_OC_SYNCCONSUMERSUBENTRY 0x0080
	#define SLAP_OC__MASK 0x00FF
	#define SLAP_OC__END 0x0100
#define SLAP_OC_OPERATIONAL 0x4000	#define SLAP_OC_OPERATIONAL 0x4000
	#ifdef LDAP_DEVEL
	#define SLAP_OC_HIDE 0x0000
	#else
#define SLAP_OC_HIDE 0x8000	#define SLAP_OC_HIDE 0x8000
	#endif

/*	/*
* DIT content rule	* DIT content rule
Line 678 typedef struct slap_attr_desc {	Line 720 typedef struct slap_attr_desc {
typedef struct slap_attr_name {	typedef struct slap_attr_name {
struct berval an_name;	struct berval an_name;
AttributeDescription *an_desc;	AttributeDescription *an_desc;
	int an_oc_exclude;
ObjectClass *an_oc;	ObjectClass *an_oc;
} AttributeName;	} AttributeName;

Line 702 struct slap_internal_schema {	Line 745 struct slap_internal_schema {
ObjectClass *si_oc_collectiveAttributeSubentry;	ObjectClass *si_oc_collectiveAttributeSubentry;
ObjectClass *si_oc_dynamicObject;	ObjectClass *si_oc_dynamicObject;

#ifdef LDAP_SYNCREPL	ObjectClass *si_oc_glue;
ObjectClass *si_oc_glue;	ObjectClass *si_oc_syncConsumerSubentry;
ObjectClass *si_oc_syncConsumerSubentry;	ObjectClass *si_oc_syncProviderSubentry;
ObjectClass *si_oc_syncProviderSubentry;
#endif

/* objectClass attribute descriptions */	/* objectClass attribute descriptions */
AttributeDescription *si_ad_objectClass;	AttributeDescription *si_ad_objectClass;
Line 726 struct slap_internal_schema {	Line 767 struct slap_internal_schema {
AttributeDescription *si_ad_namingCSN;	AttributeDescription *si_ad_namingCSN;
AttributeDescription *si_ad_superiorUUID;	AttributeDescription *si_ad_superiorUUID;

#ifdef LDAP_CACHING	AttributeDescription *si_ad_dseType;
/* LDAP cache specific operational attribute */	AttributeDescription *si_ad_syncreplCookie;
AttributeDescription *si_ad_queryid;	AttributeDescription *si_ad_syncTimestamp;
#endif /* LDAP_CACHING */	AttributeDescription *si_ad_contextCSN;

#ifdef LDAP_SYNCREPL
AttributeDescription *si_ad_dseType;
AttributeDescription *si_ad_syncreplCookie;
#endif

/* root DSE attribute descriptions */	/* root DSE attribute descriptions */
AttributeDescription *si_ad_altServer;	AttributeDescription *si_ad_altServer;
Line 784 struct slap_internal_schema {	Line 820 struct slap_internal_schema {
AttributeDescription *si_ad_name;	AttributeDescription *si_ad_name;
AttributeDescription *si_ad_cn;	AttributeDescription *si_ad_cn;
AttributeDescription *si_ad_userPassword;	AttributeDescription *si_ad_userPassword;
	AttributeDescription *si_ad_labeledURI;
#ifdef SLAPD_AUTHPASSWD	#ifdef SLAPD_AUTHPASSWD
AttributeDescription *si_ad_authPassword;	AttributeDescription *si_ad_authPassword;
#endif	#endif
Line 835 typedef struct slap_mr_assertion {	Line 872 typedef struct slap_mr_assertion {
*/	*/
typedef struct slap_filter {	typedef struct slap_filter {
ber_tag_t f_choice; /* values taken from ldap.h, plus: */	ber_tag_t f_choice; /* values taken from ldap.h, plus: */
#define SLAPD_FILTER_COMPUTED ((ber_tag_t) -1)	#define SLAPD_FILTER_COMPUTED ((ber_tag_t) -1)
#define SLAPD_FILTER_DN_ONE ((ber_tag_t) -2)	#define SLAPD_FILTER_DN_ONE ((ber_tag_t) -2)
#define SLAPD_FILTER_DN_SUBTREE ((ber_tag_t) -3)	#define SLAPD_FILTER_DN_SUBTREE ((ber_tag_t) -3)
	#ifdef LDAP_SCOPE_SUBORDINATE
	#define SLAPD_FILTER_DN_CHILDREN ((ber_tag_t) -4)
	#endif

union f_un_u {	union f_un_u {
/* precomputed result */	/* precomputed result */
Line 1040 typedef enum slap_control_e {	Line 1080 typedef enum slap_control_e {

typedef enum slap_style_e {	typedef enum slap_style_e {
ACL_STYLE_REGEX = 0,	ACL_STYLE_REGEX = 0,
	ACL_STYLE_EXPAND,
ACL_STYLE_BASE,	ACL_STYLE_BASE,
ACL_STYLE_ONE,	ACL_STYLE_ONE,
ACL_STYLE_SUBTREE,	ACL_STYLE_SUBTREE,
ACL_STYLE_CHILDREN,	ACL_STYLE_CHILDREN,
ACL_STYLE_ATTROF,	ACL_STYLE_ATTROF,
	ACL_STYLE_IP,
	ACL_STYLE_PATH
} slap_style_t;	} slap_style_t;

typedef struct slap_authz_info {	typedef struct slap_authz_info {
ber_tag_t sai_method; /* LDAP_AUTH_* from <ldap.h> */	ber_tag_t sai_method; /* LDAP_AUTH_* from <ldap.h> */
struct berval sai_mech; /* SASL Mechanism */	struct berval sai_mech; /* SASL Mechanism */
struct berval sai_dn; /* DN for reporting purposes */	struct berval sai_dn; /* DN for reporting purposes */
struct berval sai_ndn; /* Normalized DN */	struct berval sai_ndn; /* Normalized DN */
Line 1133 typedef struct slap_access {	Line 1176 typedef struct slap_access {

slap_style_t a_peername_style;	slap_style_t a_peername_style;
struct berval a_peername_pat;	struct berval a_peername_pat;
	unsigned long a_peername_addr,
	a_peername_mask;
	int a_peername_port;

slap_style_t a_sockname_style;	slap_style_t a_sockname_style;
struct berval a_sockname_pat;	struct berval a_sockname_pat;

Line 1166 typedef struct slap_acl {	Line 1213 typedef struct slap_acl {
regex_t acl_dn_re;	regex_t acl_dn_re;
struct berval acl_dn_pat;	struct berval acl_dn_pat;
AttributeName *acl_attrs;	AttributeName *acl_attrs;
	slap_style_t acl_attrval_style;
	regex_t acl_attrval_re;
	struct berval acl_attrval;

/* "by" part: list of who has what access to the entries */	/* "by" part: list of who has what access to the entries */
Access *acl_access;	Access *acl_access;
Line 1240 struct slap_limits_set {	Line 1290 struct slap_limits_set {
};	};

struct slap_limits {	struct slap_limits {
int lm_type; /* type of pattern */	unsigned lm_flags; /* type of pattern */
#define SLAP_LIMITS_UNDEFINED 0x0000	#define SLAP_LIMITS_UNDEFINED 0x0000U
#define SLAP_LIMITS_EXACT 0x0001	#define SLAP_LIMITS_EXACT 0x0001U
#define SLAP_LIMITS_BASE SLAP_LIMITS_EXACT	#define SLAP_LIMITS_BASE SLAP_LIMITS_EXACT
#define SLAP_LIMITS_ONE 0x0002	#define SLAP_LIMITS_ONE 0x0002U
#define SLAP_LIMITS_SUBTREE 0x0003	#define SLAP_LIMITS_SUBTREE 0x0003U
#define SLAP_LIMITS_CHILDREN 0x0004	#define SLAP_LIMITS_CHILDREN 0x0004U
#define SLAP_LIMITS_REGEX 0x0005	#define SLAP_LIMITS_REGEX 0x0005U
#define SLAP_LIMITS_ANONYMOUS 0x0006	#define SLAP_LIMITS_ANONYMOUS 0x0006U
#define SLAP_LIMITS_USERS 0x0007	#define SLAP_LIMITS_USERS 0x0007U
#define SLAP_LIMITS_ANY 0x0008	#define SLAP_LIMITS_ANY 0x0008U
regex_t lm_dn_regex; /* regex data for REGEX */	#define SLAP_LIMITS_MASK 0x000FU

	#define SLAP_LIMITS_TYPE_DN 0x0000U
	#define SLAP_LIMITS_TYPE_GROUP 0x0010U
	#define SLAP_LIMITS_TYPE_MASK 0x00F0U

	regex_t lm_regex; /* regex data for REGEX */

/*	/*
* normalized DN for EXACT, BASE, ONE, SUBTREE, CHILDREN;	* normalized DN for EXACT, BASE, ONE, SUBTREE, CHILDREN;
* pattern for REGEX; NULL for ANONYMOUS, USERS	* pattern for REGEX; NULL for ANONYMOUS, USERS
*/	*/
struct berval lm_dn_pat;	struct berval lm_pat;

	/* if lm_flags & SLAP_LIMITS_TYPE_MASK == SLAP_LIMITS_GROUP,
	* lm_group_oc is objectClass and lm_group_at is attributeType
	* of member in oc for match; then lm_flags & SLAP_LIMITS_MASK
	* can only be SLAP_LIMITS_EXACT */
	ObjectClass *lm_group_oc;
	AttributeDescription *lm_group_ad;

struct slap_limits_set lm_limits;	struct slap_limits_set lm_limits;
};	};
Line 1267 typedef BackendDB Backend;	Line 1330 typedef BackendDB Backend;
#define nbackends nBackendDB	#define nbackends nBackendDB
#define backends backendDB	#define backends backendDB

#ifdef LDAP_SYNCREPL	/*
	* syncinfo structure for syncrepl
	*/

	#define SLAP_SYNC_SID_SIZE 3
	#define SLAP_SYNC_RID_SIZE 3
	#define SLAP_SYNCUUID_SET_SIZE 256

struct nonpresent_entry {	struct nonpresent_entry {
struct berval *dn;	struct berval *npe_name;
struct berval *ndn;	struct berval *npe_nname;
LDAP_LIST_ENTRY(nonpresent_entry) np_link;	LDAP_LIST_ENTRY(nonpresent_entry) npe_link;
};	};

/*	struct sync_cookie {
* syncinfo structure for syncrepl	struct berval *ctxcsn;
*/	long sid;
typedef struct syncinfo_s {	struct berval *octet_str;
struct slap_conn *conn;	long rid;
struct slap_backend_db *be;	LDAP_STAILQ_ENTRY(sync_cookie) sc_next;
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"	LDAP_STAILQ_HEAD( slap_sync_cookie_s, sync_cookie );
#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 */	typedef struct syncinfo_s {
	struct slap_backend_db *si_be;
	long si_rid;
	char *si_provideruri;
	BerVarray si_provideruri_bv;
	#define SYNCINFO_TLS_OFF 0
	#define SYNCINFO_TLS_ON 1
	#define SYNCINFO_TLS_CRITICAL 2
	int si_tls;
	struct berval si_updatedn;
	int si_bindmethod;
	char *si_binddn;
	char *si_passwd;
	char *si_saslmech;
	char *si_secprops;
	char *si_realm;
	char *si_authcId;
	char *si_authzId;
	int si_schemachecking;
	Filter *si_filter;
	struct berval si_filterstr;
	struct berval si_base;
	int si_scope;
	int si_attrsonly;
	char **si_attrs;
	int si_type;
	time_t si_interval;
	struct sync_cookie si_syncCookie;
	int si_manageDSAit;
	int si_slimit;
	int si_tlimit;
	struct berval si_syncUUID_ndn;
	Avlnode *si_presentlist;
	LDAP *si_ld;
	LDAP_LIST_HEAD(np, nonpresent_entry) si_nonpresentlist;
	LDAP_STAILQ_ENTRY( syncinfo_s ) si_next;
	} syncinfo_t;

struct slap_backend_db {	struct slap_backend_db {
BackendInfo bd_info; / pointer to shared backend info */	BackendInfo bd_info; / pointer to shared backend info */
Line 1408 struct slap_backend_db {	Line 1440 struct slap_backend_db {
#define be_entry_get bd_info->bi_tool_entry_get	#define be_entry_get bd_info->bi_tool_entry_get
#define be_entry_put bd_info->bi_tool_entry_put	#define be_entry_put bd_info->bi_tool_entry_put
#define be_sync bd_info->bi_tool_sync	#define be_sync bd_info->bi_tool_sync
	#define be_dn2id_get bd_info->bi_tool_dn2id_get
	#define be_id2entry_get bd_info->bi_tool_id2entry_get
	#define be_entry_modify bd_info->bi_tool_entry_modify
#endif	#endif

#define SLAP_BFLAG_NOLASTMOD 0x0001U	#define SLAP_BFLAG_NOLASTMOD 0x0001U
	#define SLAP_BFLAG_NO_SCHEMA_CHECK 0x0002U
#define SLAP_BFLAG_GLUE_INSTANCE 0x0010U /* a glue backend */	#define SLAP_BFLAG_GLUE_INSTANCE 0x0010U /* a glue backend */
#define SLAP_BFLAG_GLUE_SUBORDINATE 0x0020U /* child of a glue hierarchy */	#define SLAP_BFLAG_GLUE_SUBORDINATE 0x0020U /* child of a glue hierarchy */
#define SLAP_BFLAG_GLUE_LINKED 0x0040U /* child is connected to parent */	#define SLAP_BFLAG_GLUE_LINKED 0x0040U /* child is connected to parent */
#define SLAP_BFLAG_ALIASES 0x0100U	#define SLAP_BFLAG_MONITOR 0x0080U /* a monitor backend */
#define SLAP_BFLAG_REFERRALS 0x0200U	#define SLAP_BFLAG_INCREMENT 0x0100U
#define SLAP_BFLAG_SUBENTRIES 0x0400U	#define SLAP_BFLAG_ALIASES 0x1000U
#define SLAP_BFLAG_MONITOR 0x1000U	#define SLAP_BFLAG_REFERRALS 0x2000U
#define SLAP_BFLAG_DYNAMIC 0x2000U	#define SLAP_BFLAG_SUBENTRIES 0x4000U
	#define SLAP_BFLAG_DYNAMIC 0x8000U
slap_mask_t be_flags;	slap_mask_t be_flags;
#define SLAP_LASTMOD(be) (!((be)->be_flags & SLAP_BFLAG_NOLASTMOD))	#define SLAP_LASTMOD(be) (!((be)->be_flags & SLAP_BFLAG_NOLASTMOD))
	#define SLAP_NO_SCHEMA_CHECK(be) (((be)->be_flags & SLAP_BFLAG_NO_SCHEMA_CHECK))
#define SLAP_GLUE_INSTANCE(be) ((be)->be_flags & SLAP_BFLAG_GLUE_INSTANCE)	#define SLAP_GLUE_INSTANCE(be) ((be)->be_flags & SLAP_BFLAG_GLUE_INSTANCE)
#define SLAP_GLUE_SUBORDINATE(be) \	#define SLAP_GLUE_SUBORDINATE(be) \
((be)->be_flags & SLAP_BFLAG_GLUE_SUBORDINATE)	((be)->be_flags & SLAP_BFLAG_GLUE_SUBORDINATE)
#define SLAP_GLUE_LINKED(be) ((be)->be_flags & SLAP_BFLAG_GLUE_LINKED)	#define SLAP_GLUE_LINKED(be) ((be)->be_flags & SLAP_BFLAG_GLUE_LINKED)

	#define SLAP_MONITOR(be) ((be)->be_flags & SLAP_BFLAG_MONITOR)
	#define SLAP_INCREMENT(be) ((be)->be_flags & SLAP_BFLAG_INCREMENT)

#define SLAP_ALIASES(be) ((be)->be_flags & SLAP_BFLAG_ALIASES)	#define SLAP_ALIASES(be) ((be)->be_flags & SLAP_BFLAG_ALIASES)
#define SLAP_REFERRALS(be) ((be)->be_flags & SLAP_BFLAG_REFERRALS)	#define SLAP_REFERRALS(be) ((be)->be_flags & SLAP_BFLAG_REFERRALS)
#define SLAP_SUBENTRIES(be) ((be)->be_flags & SLAP_BFLAG_SUBENTRIES)	#define SLAP_SUBENTRIES(be) ((be)->be_flags & SLAP_BFLAG_SUBENTRIES)
#define SLAP_MONITOR(be) ((be)->be_flags & SLAP_BFLAG_MONITOR)
#define SLAP_DYNAMIC(be) ((be)->be_flags & SLAP_BFLAG_DYNAMIC)	#define SLAP_DYNAMIC(be) ((be)->be_flags & SLAP_BFLAG_DYNAMIC)


slap_mask_t be_restrictops; /* restriction operations */	slap_mask_t be_restrictops; /* restriction operations */
#define SLAP_RESTRICT_OP_ADD 0x0001U	#define SLAP_RESTRICT_OP_ADD 0x0001U
#define SLAP_RESTRICT_OP_BIND 0x0002U	#define SLAP_RESTRICT_OP_BIND 0x0002U
Line 1458 struct slap_backend_db {	Line 1500 struct slap_backend_db {

#define SLAP_DISALLOW_BIND_ANON 0x0001U /* no anonymous */	#define SLAP_DISALLOW_BIND_ANON 0x0001U /* no anonymous */
#define SLAP_DISALLOW_BIND_SIMPLE 0x0002U /* simple authentication */	#define SLAP_DISALLOW_BIND_SIMPLE 0x0002U /* simple authentication */
#define SLAP_DISALLOW_BIND_SIMPLE_UNPROTECTED \	#define SLAP_DISALLOW_BIND_KRBV4 0x0004U /* Kerberos V4 authentication */
0x0004U /* unprotected simple auth */
#define SLAP_DISALLOW_BIND_KRBV4 0x0008U /* Kerberos V4 authentication */

#define SLAP_DISALLOW_TLS_2_ANON 0x0010U /* StartTLS -> Anonymous */	#define SLAP_DISALLOW_TLS_2_ANON 0x0010U /* StartTLS -> Anonymous */
#define SLAP_DISALLOW_TLS_AUTHC 0x0020U /* TLS while authenticated */	#define SLAP_DISALLOW_TLS_AUTHC 0x0020U /* TLS while authenticated */
Line 1500 struct slap_backend_db {	Line 1540 struct slap_backend_db {
void be_private; / anything the backend database needs */	void be_private; / anything the backend database needs */

void be_pb; / Netscape plugin */	void be_pb; / Netscape plugin */
#ifdef LDAP_SYNCREPL	LDAP_TAILQ_HEAD( be_pcl, slap_csn_entry ) be_pending_csn_list;
syncinfo_t syncinfo; / For syncrepl */	ldap_pvt_thread_mutex_t be_pcl_mutex;
#endif	struct berval be_context_csn;
	ldap_pvt_thread_mutex_t be_context_csn_mutex;
	LDAP_STAILQ_HEAD( be_si, syncinfo_s ) be_syncinfo; /* For syncrepl */
};	};

struct slap_conn;	struct slap_conn;
Line 1537 typedef struct req_search_s {	Line 1579 typedef struct req_search_s {
int rs_deref;	int rs_deref;
int rs_slimit;	int rs_slimit;
int rs_tlimit;	int rs_tlimit;
	/* NULL means be_isroot evaluated to TRUE */
	struct slap_limits_set *rs_limit;
int rs_attrsonly;	int rs_attrsonly;
AttributeName *rs_attrs;	AttributeName *rs_attrs;
Filter *rs_filter;	Filter *rs_filter;
Line 1572 typedef struct req_extended_s {	Line 1616 typedef struct req_extended_s {
struct berval *rs_reqdata;	struct berval *rs_reqdata;
} req_extended_s;	} req_extended_s;

	typedef struct req_pwdexop_s {
	struct berval rs_reqoid;
	struct berval rs_old;
	struct berval rs_new;
	Modifications *rs_mods;
	Modifications **rs_modtail;
	} req_pwdexop_s;

typedef enum slap_reply_e {	typedef enum slap_reply_e {
REP_RESULT,	REP_RESULT,
REP_SASL,	REP_SASL,
REP_EXTENDED,	REP_EXTENDED,
REP_SEARCH,	REP_SEARCH,
REP_SEARCHREF	REP_SEARCHREF,
	REP_INTERMEDIATE
} slap_reply_t;	} slap_reply_t;

typedef struct rep_sasl_s {	typedef struct rep_sasl_s {
Line 1610 typedef struct slap_rep {	Line 1663 typedef struct slap_rep {
rep_extended_s sru_extended;	rep_extended_s sru_extended;
rep_search_s sru_search;	rep_search_s sru_search;
} sr_un;	} sr_un;
	slap_mask_t sr_flags;
	#define REP_ENTRY_MODIFIABLE 0x00000001
	#define REP_ENTRY_MUSTBEFREED 0x00000002
	#define REP_MATCHED_MUSTBEFREED 0x00000010
} SlapReply;	} SlapReply;

/* short hands for response members */	/* short hands for response members */
Line 1653 typedef ID (BI_tool_entry_put) LDAP_P((	Line 1710 typedef ID (BI_tool_entry_put) LDAP_P((
struct berval *text ));	struct berval *text ));
typedef int (BI_tool_entry_reindex) LDAP_P(( BackendDB *be, ID id ));	typedef int (BI_tool_entry_reindex) LDAP_P(( BackendDB *be, ID id ));
typedef int (BI_tool_sync) LDAP_P(( BackendDB *be ));	typedef int (BI_tool_sync) LDAP_P(( BackendDB *be ));
	typedef ID (BI_tool_dn2id_get) LDAP_P(( BackendDB be, struct berval dn ));
	typedef int (BI_tool_id2entry_get) LDAP_P(( BackendDB be, ID id, Entry *e ));
	typedef ID (BI_tool_entry_modify) LDAP_P(( BackendDB be, Entry e,
	struct berval *text ));

struct slap_backend_info {	struct slap_backend_info {
char bi_type; / type of backend */	char bi_type; / type of backend */
Line 1737 struct slap_backend_info {	Line 1798 struct slap_backend_info {
BI_connection_destroy *bi_connection_destroy;	BI_connection_destroy *bi_connection_destroy;

/* hooks for slap tools */	/* hooks for slap tools */
BI_tool_entry_open *bi_tool_entry_open;	BI_tool_entry_open *bi_tool_entry_open;
BI_tool_entry_close *bi_tool_entry_close;	BI_tool_entry_close *bi_tool_entry_close;
BI_tool_entry_first *bi_tool_entry_first;	BI_tool_entry_first *bi_tool_entry_first;
BI_tool_entry_next *bi_tool_entry_next;	BI_tool_entry_next *bi_tool_entry_next;
BI_tool_entry_get *bi_tool_entry_get;	BI_tool_entry_get *bi_tool_entry_get;
BI_tool_entry_put *bi_tool_entry_put;	BI_tool_entry_put *bi_tool_entry_put;
BI_tool_entry_reindex *bi_tool_entry_reindex;	BI_tool_entry_reindex *bi_tool_entry_reindex;
BI_tool_sync *bi_tool_sync;	BI_tool_sync *bi_tool_sync;
	BI_tool_dn2id_get *bi_tool_dn2id_get;
	BI_tool_id2entry_get *bi_tool_id2entry_get;
	BI_tool_entry_modify *bi_tool_entry_modify;

#define SLAP_INDEX_ADD_OP 0x0001	#define SLAP_INDEX_ADD_OP 0x0001
#define SLAP_INDEX_DELETE_OP 0x0002	#define SLAP_INDEX_DELETE_OP 0x0002
Line 1776 struct slap_backend_info {	Line 1840 struct slap_backend_info {
typedef int (slap_response)( struct slap_op , struct slap_rep );	typedef int (slap_response)( struct slap_op , struct slap_rep );

typedef struct slap_callback {	typedef struct slap_callback {
	struct slap_callback *sc_next;
slap_response *sc_response;	slap_response *sc_response;
	slap_response *sc_cleanup;
void *sc_private;	void *sc_private;
} slap_callback;	} slap_callback;

	struct slap_overinfo;

	typedef struct slap_overinst {
	BackendInfo on_bi;
	slap_response *on_response;
	struct slap_overinfo *on_info;
	struct slap_overinst *on_next;
	} slap_overinst;

	typedef struct slap_overinfo {
	BackendInfo oi_bi;
	BackendInfo *oi_orig;
	struct slap_overinst *oi_list;
	} slap_overinfo;

	/* Should successive callbacks in a chain be processed? */
	#define SLAP_CB_CONTINUE 0x8000

/*	/*
* Paged Results state	* Paged Results state
*/	*/
Line 1791 typedef struct slap_paged_state {	Line 1875 typedef struct slap_paged_state {
} PagedResultsState;	} PagedResultsState;


#if defined(LDAP_CLIENT_UPDATE) \|\| defined(LDAP_SYNC)	#define LDAP_PSEARCH_BY_ADD 0x01
#define LDAP_PSEARCH_BY_ADD 0x01
#define LDAP_PSEARCH_BY_DELETE 0x02	#define LDAP_PSEARCH_BY_DELETE 0x02
#define LDAP_PSEARCH_BY_PREMODIFY 0x03	#define LDAP_PSEARCH_BY_PREMODIFY 0x03
#define LDAP_PSEARCH_BY_MODIFY 0x04	#define LDAP_PSEARCH_BY_MODIFY 0x04
Line 1802 struct psid_entry {	Line 1885 struct psid_entry {
struct slap_op *ps_op;	struct slap_op *ps_op;
LDAP_LIST_ENTRY(psid_entry) ps_link;	LDAP_LIST_ENTRY(psid_entry) ps_link;
};	};
#endif

	struct slog_entry {
	struct berval sl_uuid;
	struct berval sl_name;
	struct berval sl_csn;
	LDAP_STAILQ_ENTRY(slog_entry) sl_link;
	};

	/* session lists */
	struct slap_session_entry {
	int se_id;
	int se_size;
	struct berval se_spec;
	LDAP_LIST_ENTRY( slap_session_entry ) se_link;
	};

	struct slap_csn_entry {
	struct berval *csn;
	unsigned long opid;
	unsigned long connid;
	#define SLAP_CSN_PENDING 1
	#define SLAP_CSN_COMMIT 2
	long state;
	LDAP_TAILQ_ENTRY (slap_csn_entry) csn_link;
	};

	/*
	* Caches the result of a backend_group check for ACL evaluation
	*/
	typedef struct slap_gacl {
	struct slap_gacl *ga_next;
	Backend *ga_be;
	ObjectClass *ga_oc;
	AttributeDescription *ga_at;
	int ga_res;
	ber_len_t ga_len;
	char ga_ndn[1];
	} GroupAssertion;

/*	/*
* represents an operation pending from an ldap client	* represents an operation pending from an ldap client
Line 1832 typedef struct slap_op {	Line 1951 typedef struct slap_op {
req_abandon_s oq_abandon;	req_abandon_s oq_abandon;
req_abandon_s oq_cancel;	req_abandon_s oq_cancel;
req_extended_s oq_extended;	req_extended_s oq_extended;
	req_pwdexop_s oq_pwdexop;
} o_request;	} o_request;

/* short hands for union members */	/* short hands for union members */
Line 1844 typedef struct slap_op {	Line 1964 typedef struct slap_op {
#define oq_abandon o_request.oq_abandon	#define oq_abandon o_request.oq_abandon
#define oq_cancel o_request.oq_cancel	#define oq_cancel o_request.oq_cancel
#define oq_extended o_request.oq_extended	#define oq_extended o_request.oq_extended
	#define oq_pwdexop o_request.oq_pwdexop

/* short hands for inner request members */	/* short hands for inner request members */
#define orb_method oq_bind.rb_method	#define orb_method oq_bind.rb_method
Line 1855 typedef struct slap_op {	Line 1976 typedef struct slap_op {
#define ors_deref oq_search.rs_deref	#define ors_deref oq_search.rs_deref
#define ors_slimit oq_search.rs_slimit	#define ors_slimit oq_search.rs_slimit
#define ors_tlimit oq_search.rs_tlimit	#define ors_tlimit oq_search.rs_tlimit
	#define ors_limit oq_search.rs_limit
#define ors_attrsonly oq_search.rs_attrsonly	#define ors_attrsonly oq_search.rs_attrsonly
#define ors_attrs oq_search.rs_attrs	#define ors_attrs oq_search.rs_attrs
#define ors_filter oq_search.rs_filter	#define ors_filter oq_search.rs_filter
Line 1883 typedef struct slap_op {	Line 2005 typedef struct slap_op {
#define SLAP_CANCEL_ACK 0x02	#define SLAP_CANCEL_ACK 0x02
#define SLAP_CANCEL_DONE 0x03	#define SLAP_CANCEL_DONE 0x03

char o_do_not_cache; /* don't cache from this op */	GroupAssertion *o_groups;
	char o_do_not_cache; /* don't cache groups from this op */
char o_is_auth_check; /* authorization in progress */	char o_is_auth_check; /* authorization in progress */

#define SLAP_NO_CONTROL 0	#define SLAP_NO_CONTROL 0
Line 1900 typedef struct slap_op {	Line 2023 typedef struct slap_op {
char o_subentries_visibility;	char o_subentries_visibility;
#define get_subentries_visibility(op) ((int)(op)->o_subentries_visibility)	#define get_subentries_visibility(op) ((int)(op)->o_subentries_visibility)

	char o_assert;
	#define get_assert(op) ((int)(op)->o_assert)

char o_valuesreturnfilter;	char o_valuesreturnfilter;

#ifdef LDAP_CONTROL_X_PERMISSIVE_MODIFY	#ifdef LDAP_CONTROL_X_PERMISSIVE_MODIFY
Line 1916 typedef struct slap_op {	Line 2042 typedef struct slap_op {
#define get_domainScope(op) (0)	#define get_domainScope(op) (0)
#endif	#endif

#ifdef LDAP_CONTROL_PAGEDRESULTS	#ifdef LDAP_CONTROL_X_TREE_DELETE
	char o_tree_delete;
	#define get_treeDelete(op) ((int)(op)->o_tree_delete)
	#else
	#define get_treeDelete(op) (0)
	#endif

	char o_preread;
	char o_postread;
	AttributeName *o_preread_attrs;
	AttributeName *o_postread_attrs;

char o_pagedresults;	char o_pagedresults;
#define get_pagedresults(op) ((int)(op)->o_pagedresults)	#define get_pagedresults(op) ((int)(op)->o_pagedresults)
ber_int_t o_pagedresults_size;	ber_int_t o_pagedresults_size;
PagedResultsState o_pagedresults_state;	PagedResultsState o_pagedresults_state;
#else
#define get_pagedresults(op) (0)
#endif

#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;
char o_sync_mode;	char o_sync_mode;
#define SLAP_SYNC_NONE (0x0)	#define SLAP_SYNC_NONE LDAP_SYNC_NONE
#define SLAP_SYNC_REFRESH (0x1)	#define SLAP_SYNC_REFRESH LDAP_SYNC_REFRESH_ONLY
#define SLAP_SYNC_PERSIST (0x2)	#define SLAP_SYNC_PERSIST LDAP_SYNC_RESERVED
#define SLAP_SYNC_REFRESH_AND_PERSIST (0x3)	#define SLAP_SYNC_REFRESH_AND_PERSIST LDAP_SYNC_REFRESH_AND_PERSIST
struct berval o_sync_state;	struct sync_cookie o_sync_state;
#endif	int o_sync_rhint;
	struct berval o_sync_cid;
	int o_sync_slog_size;
	struct berval o_sync_csn;
	struct berval o_sync_slog_omitcsn;
	int o_sync_slog_len;
	LDAP_STAILQ_HEAD(sl, slog_entry) o_sync_slog_list;

#if defined(LDAP_CLIENT_UPDATE) \|\| defined(LDAP_SYNC)
int o_ps_protocol;
int o_ps_entries;	int o_ps_entries;
	int o_no_psearch;
LDAP_LIST_ENTRY(slap_op) o_ps_link;	LDAP_LIST_ENTRY(slap_op) o_ps_link;
LDAP_LIST_HEAD(pe, psid_entry) o_pm_list;	LDAP_LIST_HEAD(pe, psid_entry) o_pm_list;
#endif

AuthorizationInformation o_authz;	AuthorizationInformation o_authz;

BerElement o_ber; / ber of the request */	BerElement o_ber; / ber of the request */
#ifdef LDAP_CONNECTIONLESS	BerElement o_res_ber; / ber of the CLDAP reply or readback control */
BerElement o_res_ber; / ber of the reply */	slap_callback o_callback; / callback pointers */
#endif
slap_callback o_callback; / callback pointers */
LDAPControl *o_ctrls; / controls */	LDAPControl *o_ctrls; / controls */

void o_threadctx; / thread pool thread context */	void o_threadctx; / thread pool thread context */
Line 1972 typedef struct slap_op {	Line 2096 typedef struct slap_op {
void o_private; / anything the backend needs */	void o_private; / anything the backend needs */

LDAP_STAILQ_ENTRY(slap_op) o_next; /* next operation in list */	LDAP_STAILQ_ENTRY(slap_op) o_next; /* next operation in list */
ValuesReturnFilter vrFilter; / Structure represents ValuesReturnFilter */

#ifdef LDAP_CACHING	Filter o_assertion; / Assert control filter */
char o_caching_on;	#define get_assertion(op) ((op)->o_assertion)
#endif /LDAP_CACHING /
	ValuesReturnFilter o_vrFilter; / ValuesReturnFilter */

	int o_nocaching;
	int o_delete_glue_parent;

#ifdef LDAP_SLAPI	#ifdef LDAP_SLAPI
void o_pb; / NS-SLAPI plugin */	void o_pb; / NS-SLAPI plugin */
	void o_extensions; / NS-SLAPI plugin */
#endif	#endif
} Operation;	} Operation;

#define send_ldap_error( op, rs, err, text ) \	#define send_ldap_error( op, rs, err, text ) do { \
do { (rs)->sr_err = err; (rs)->sr_text = text; \	(rs)->sr_err = err; (rs)->sr_text = text; \
(op->o_conn->c_send_ldap_result)( op, rs ); } while (0)	(op->o_conn->c_send_ldap_result)( op, rs ); \
#define send_ldap_discon( op, rs, err, text ) \	} while (0)
do { (rs)->sr_err = err; (rs)->sr_text = text; \	#define send_ldap_discon( op, rs, err, text ) do { \
send_ldap_disconnect( op, rs ); } while (0)	(rs)->sr_err = err; (rs)->sr_text = text; \
typedef void (SEND_LDAP_RESULT)(struct slap_op op, struct slap_rep rs);	send_ldap_disconnect( op, rs ); \
typedef int (SEND_SEARCH_ENTRY)(struct slap_op op, struct slap_rep rs);	} while (0)
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_RESULT)(
typedef void (SEND_LDAP_INTERMEDIATE_RESP)(struct slap_op op, struct slap_rep rs);	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)(
	struct slap_op op, struct slap_rep rs);

#define send_ldap_result( op, rs ) \	#define send_ldap_result( op, rs ) \
(op->o_conn->c_send_ldap_result)( op, rs )	(op->o_conn->c_send_ldap_result)( op, rs )
#define send_search_entry( op, rs ) \	#define send_search_entry( op, rs ) \
(op->o_conn->c_send_search_entry)( op, rs )	(op->o_conn->c_send_search_entry)( op, rs )
#define send_search_reference( op, rs ) \	#define send_search_reference( op, rs ) \
(op->o_conn->c_send_search_reference)( op, rs )	(op->o_conn->c_send_search_reference)( op, rs )
#define send_ldap_extended( op, rs ) \	#define send_ldap_extended( op, rs ) \
(op->o_conn->c_send_ldap_extended)( op, rs )	(op->o_conn->c_send_ldap_extended)( op, rs )
#define send_ldap_intermediate_resp( op, rs ) \	#define send_ldap_intermediate( op, rs ) \
(op->o_conn->c_send_ldap_intermediate_resp)( op, rs )	(op->o_conn->c_send_ldap_intermediate)( op, rs )

/*
* Caches the result of a backend_group check for ACL evaluation
*/
typedef struct slap_gacl {
struct slap_gacl *ga_next;
Backend *ga_be;
ObjectClass *ga_oc;
AttributeDescription *ga_at;
int ga_res;
ber_len_t ga_len;
char ga_ndn[1];
} GroupAssertion;

typedef struct slap_listener Listener;	typedef struct slap_listener Listener;

Line 2026 typedef struct slap_listener Listener;	Line 2150 typedef struct slap_listener Listener;
typedef struct slap_conn {	typedef struct slap_conn {
int c_struct_state; /* structure management state */	int c_struct_state; /* structure management state */
int c_conn_state; /* connection state */	int c_conn_state; /* connection state */
	int c_conn_idx; /* slot in connections array */

ldap_pvt_thread_mutex_t c_mutex; /* protect the connection */	ldap_pvt_thread_mutex_t c_mutex; /* protect the connection */
Sockbuf c_sb; / ber connection stuff */	Sockbuf c_sb; / ber connection stuff */
Line 2050 typedef struct slap_conn {	Line 2175 typedef struct slap_conn {
Backend *c_authz_backend;	Backend *c_authz_backend;

AuthorizationInformation c_authz;	AuthorizationInformation c_authz;
GroupAssertion *c_groups;

ber_int_t c_protocol; /* version of the LDAP protocol used by client */	ber_int_t c_protocol; /* version of the LDAP protocol used by client */

Line 2063 typedef struct slap_conn {	Line 2187 typedef struct slap_conn {
BerElement c_currentber; / ber we're attempting to read */	BerElement c_currentber; / ber we're attempting to read */
int c_writewaiter; /* true if writer is waiting */	int c_writewaiter; /* true if writer is waiting */

	#define CONN_IS_TLS 1
	#define CONN_IS_UDP 2
	#define CONN_IS_CLIENT 3

#ifdef LDAP_CONNECTIONLESS	#ifdef LDAP_CONNECTIONLESS
int c_is_udp; /* true if this is (C)LDAP over UDP */	int c_is_udp; /* true if this is (C)LDAP over UDP */
#endif	#endif
Line 2089 typedef struct slap_conn {	Line 2217 typedef struct slap_conn {
long c_n_write; /* num of write calls */	long c_n_write; /* num of write calls */

void c_pb; / Netscape plugin */	void c_pb; / Netscape plugin */
	void c_extensions; / Netscape plugin */

	/*
	* Client connection handling
	*/
	ldap_pvt_thread_start_t *c_clientfunc;
	void *c_clientarg;

/*	/*
* These are the "callbacks" that are available for back-ends to	* These are the "callbacks" that are available for back-ends to
Line 2099 typedef struct slap_conn {	Line 2234 typedef struct slap_conn {
SEND_SEARCH_ENTRY *c_send_search_entry;	SEND_SEARCH_ENTRY *c_send_search_entry;
SEND_SEARCH_REFERENCE *c_send_search_reference;	SEND_SEARCH_REFERENCE *c_send_search_reference;
SEND_LDAP_EXTENDED *c_send_ldap_extended;	SEND_LDAP_EXTENDED *c_send_ldap_extended;
#ifdef LDAP_RES_INTERMEDIATE_RESP	#ifdef LDAP_RES_INTERMEDIATE
SEND_LDAP_INTERMEDIATE_RESP *c_send_ldap_intermediate_resp;	SEND_LDAP_INTERMEDIATE *c_send_ldap_intermediate;
#endif	#endif

} Connection;	} Connection;

#if defined(LDAP_SYSLOG) && defined(LDAP_DEBUG)	#if defined(LDAP_SYSLOG) && defined(LDAP_DEBUG)
Line 2171 enum {	Line 2306 enum {
#define SLAP_LDAPDN_PRETTY 0x1	#define SLAP_LDAPDN_PRETTY 0x1
#define SLAP_LDAPDN_MAXLEN 8192	#define SLAP_LDAPDN_MAXLEN 8192

/*	/* number of response controls supported */
* Macros for LCUP	#define SLAP_MAX_RESPONSE_CONTROLS 6
*/
#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)	#ifdef LDAP_DEVEL
#define SLAP_SEARCH_MAX_CTRLS 10	#define SLAP_CTRL_HIDE 0x00000000U
	#else
	#define SLAP_CTRL_HIDE 0x80000000U
#endif	#endif

#define SLAP_CTRL_FRONTEND 0x80000000U	#define SLAP_CTRL_FRONTEND 0x00800000U
#define SLAP_CTRL_FRONTEND_SEARCH 0x01000000U /* for NOOP */	#define SLAP_CTRL_FRONTEND_SEARCH 0x00010000U /* for NOOP */

#define SLAP_CTRL_OPFLAGS 0x0000FFFFU	#define SLAP_CTRL_OPFLAGS 0x0000FFFFU
#define SLAP_CTRL_ABANDON 0x00000001U	#define SLAP_CTRL_ABANDON 0x00000001U
Line 2209 typedef int (SLAP_CTRL_PARSE_FN) LDAP_P(	Line 2339 typedef int (SLAP_CTRL_PARSE_FN) LDAP_P(
SlapReply *rs,	SlapReply *rs,
LDAPControl *ctrl ));	LDAPControl *ctrl ));

	#define SLMALLOC_SLAB_SIZE (1024*1024)

LDAP_END_DECL	LDAP_END_DECL

#include "proto-slap.h"	#include "proto-slap.h"

Removed from v.1.452
changed lines
	Added in v.1.452.2.14