proto-slap.h 32.1 KB
Newer Older
1
/* $OpenLDAP$ */
2
/*
Kurt Zeilenga's avatar
Kurt Zeilenga committed
3
 * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
4
5
 * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
 */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
6
7
#ifndef PROTO_SLAP_H
#define PROTO_SLAP_H
Kurt Zeilenga's avatar
Kurt Zeilenga committed
8

Kurt Zeilenga's avatar
Kurt Zeilenga committed
9
#include <ldap_cdefs.h>
10
#include "ldap_pvt.h"
Kurt Zeilenga's avatar
Kurt Zeilenga committed
11

12
13
LDAP_BEGIN_DECL

Kurt Zeilenga's avatar
Kurt Zeilenga committed
14
15
16
17
/*
 * acl.c
 */
LDAP_SLAPD_F (int) access_allowed LDAP_P((
18
	Operation *op,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
19
	Entry *e, AttributeDescription *desc, struct berval *val,
20
21
	slap_access_t access,
	AccessControlState *state ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
22
LDAP_SLAPD_F (int) acl_check_modlist LDAP_P((
23
	Operation *op, Entry *e, Modifications *ml ));
24

Kurt Zeilenga's avatar
Kurt Zeilenga committed
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
LDAP_SLAPD_F (void) acl_append( AccessControl **l, AccessControl *a );

/*
 * aclparse.c
 */
LDAP_SLAPD_F (void) parse_acl LDAP_P(( Backend *be,
	const char *fname, int lineno,
	int argc, char **argv ));

LDAP_SLAPD_F (char *) access2str LDAP_P(( slap_access_t access ));
LDAP_SLAPD_F (slap_access_t) str2access LDAP_P(( const char *str ));

#define ACCESSMASK_MAXLEN	sizeof("unknown (+wrscan)")
LDAP_SLAPD_F (char *) accessmask2str LDAP_P(( slap_mask_t mask, char* ));
LDAP_SLAPD_F (slap_mask_t) str2accessmask LDAP_P(( const char *str ));
LDAP_SLAPD_F (void) acl_destroy LDAP_P(( AccessControl*, AccessControl* ));
LDAP_SLAPD_F (void) acl_free LDAP_P(( AccessControl *a ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
42

Kurt Zeilenga's avatar
Kurt Zeilenga committed
43
44
45
/*
 * ad.c
 */
46
LDAP_SLAPD_F (int) slap_str2ad LDAP_P((
47
48
	const char *,
	AttributeDescription **ad,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
49
	const char **text ));
50

51
LDAP_SLAPD_F (int) slap_bv2ad LDAP_P((
52
53
	struct berval *bv,
	AttributeDescription **ad,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
54
	const char **text ));
55

Kurt Zeilenga's avatar
Kurt Zeilenga committed
56
57
LDAP_SLAPD_F (void) ad_destroy LDAP_P(( AttributeDescription * ));

58
59
#define ad_cmp(l,r)	(((l)->ad_cname.bv_len < (r)->ad_cname.bv_len) \
	? -1 : (((l)->ad_cname.bv_len > (r)->ad_cname.bv_len) \
Pierangelo Masarati's avatar
Pierangelo Masarati committed
60
		? 1 : strcasecmp((l)->ad_cname.bv_val, (r)->ad_cname.bv_val )))
61

62
LDAP_SLAPD_F (int) is_ad_subtype LDAP_P((
63
64
65
	AttributeDescription *sub,
	AttributeDescription *super ));

66
LDAP_SLAPD_F (int) ad_inlist LDAP_P((
67
	AttributeDescription *desc,
68
	AttributeName *attrs ));
69

70
71
72
73
74
75
76
77
78
79
LDAP_SLAPD_F (int) slap_str2undef_ad LDAP_P((
	const char *,
	AttributeDescription **ad,
	const char **text ));

LDAP_SLAPD_F (int) slap_bv2undef_ad LDAP_P((
	struct berval *bv,
	AttributeDescription **ad,
	const char **text ));

80
LDAP_SLAPD_F (AttributeDescription *) ad_find_tags LDAP_P((
81
	AttributeType *type,
82
	struct berval *tags ));
83

84
LDAP_SLAPD_F (AttributeName *) str2anlist LDAP_P(( AttributeName *an,
85
	char *str, const char *brkstr ));
86
LDAP_SLAPD_F (int) an_find LDAP_P(( AttributeName *a, struct berval *s ));
87
88
LDAP_SLAPD_F (int) ad_define_option LDAP_P(( const char *name,
	const char *fname, int lineno ));
89

Kurt Zeilenga's avatar
Kurt Zeilenga committed
90
91
92
93
LDAP_SLAPD_F (MatchingRule *) ad_mr(
	AttributeDescription *ad,
	unsigned usage );

94
95
96
97
98
/*
 * add.c
 */
LDAP_SLAPD_F (int) slap_mods2entry LDAP_P(( Modifications *mods, Entry **e,
	int repl_user, const char **text, char *textbuf, size_t textlen ));
99

100
101
102
/*
 * at.c
 */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
103
104
105
106
107
LDAP_SLAPD_F (void) at_config LDAP_P((
	const char *fname, int lineno,
	int argc, char **argv ));
LDAP_SLAPD_F (AttributeType *) at_find LDAP_P((
	const char *name ));
108
109
LDAP_SLAPD_F (AttributeType *) at_bvfind LDAP_P((
	struct berval *name ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
110
111
112
113
114
115
LDAP_SLAPD_F (int) at_find_in_list LDAP_P((
	AttributeType *sat, AttributeType **list ));
LDAP_SLAPD_F (int) at_append_to_list LDAP_P((
	AttributeType *sat, AttributeType ***listp ));
LDAP_SLAPD_F (int) at_delete_from_list LDAP_P((
	int pos, AttributeType ***listp ));
116
LDAP_SLAPD_F (int) at_schema_info LDAP_P(( Entry *e ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
117
118
LDAP_SLAPD_F (int) at_add LDAP_P((
	LDAPAttributeType *at, const char **err ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
119
LDAP_SLAPD_F (void) at_destroy LDAP_P(( void ));
120

121
LDAP_SLAPD_F (int) is_at_subtype LDAP_P((
122
123
124
	AttributeType *sub,
	AttributeType *super ));

125
LDAP_SLAPD_F (int) is_at_syntax LDAP_P((
126
127
128
	AttributeType *at,
	const char *oid ));

129
130
131
LDAP_SLAPD_F (int) at_start LDAP_P(( AttributeType **at ));
LDAP_SLAPD_F (int) at_next LDAP_P(( AttributeType **at ));

Kurt Zeilenga's avatar
Kurt Zeilenga committed
132
133
134
/*
 * attr.c
 */
135
136
LDAP_SLAPD_F (void) attr_free LDAP_P(( Attribute *a ));
LDAP_SLAPD_F (Attribute *) attr_dup LDAP_P(( Attribute *a ));
137

138
139
140
#define attr_mergeit( e, d, v ) attr_merge( e, d, v, NULL /* FIXME */ )
#define attr_mergeit_one( e, d, v ) attr_merge_one( e, d, v, NULL /* FIXME */ )

Kurt Zeilenga's avatar
Kurt Zeilenga committed
141
142
143
144
145
146
147
148
LDAP_SLAPD_F (int) attr_merge LDAP_P(( Entry *e,
	AttributeDescription *desc,
	BerVarray vals,
	BerVarray nvals ));
LDAP_SLAPD_F (int) attr_merge_one LDAP_P(( Entry *e,
	AttributeDescription *desc,
	struct berval *val,
	struct berval *nval ));
149
150
LDAP_SLAPD_F (int) attr_merge_normalize LDAP_P(( Entry *e,
	AttributeDescription *desc,
Howard Chu's avatar
Howard Chu committed
151
	BerVarray vals, void *memctx ));
152
153
LDAP_SLAPD_F (int) attr_merge_normalize_one LDAP_P(( Entry *e,
	AttributeDescription *desc,
Howard Chu's avatar
Howard Chu committed
154
	struct berval *val, void *memctx ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
155
156
157
158
159
160
LDAP_SLAPD_F (Attribute *) attrs_find LDAP_P((
	Attribute *a, AttributeDescription *desc ));
LDAP_SLAPD_F (Attribute *) attr_find LDAP_P((
	Attribute *a, AttributeDescription *desc ));
LDAP_SLAPD_F (int) attr_delete LDAP_P((
	Attribute **attrs, AttributeDescription *desc ));
161

162
163
LDAP_SLAPD_F (void) attrs_free LDAP_P(( Attribute *a ));
LDAP_SLAPD_F (Attribute *) attrs_dup LDAP_P(( Attribute *a ));
164

165

Kurt Zeilenga's avatar
Kurt Zeilenga committed
166
167
168
/*
 * ava.c
 */
169
LDAP_SLAPD_F (int) get_ava LDAP_P((
170
	Operation *op,
171
	BerElement *ber,
172
	AttributeAssertion **ava,
173
	unsigned usage,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
174
	const char **text ));
175
LDAP_SLAPD_F (void) ava_free LDAP_P((
176
	Operation *op,
177
178
	AttributeAssertion *ava,
	int freeit ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
179
180
181
182

/*
 * backend.c
 */
183
184
185
186
LDAP_SLAPD_F (int) backend_init LDAP_P((void));
LDAP_SLAPD_F (int) backend_add LDAP_P((BackendInfo *aBackendInfo));
LDAP_SLAPD_F (int) backend_num LDAP_P((Backend *be));
LDAP_SLAPD_F (int) backend_startup LDAP_P((Backend *be));
187
LDAP_SLAPD_F (int) backend_sync LDAP_P((Backend *be));
188
189
LDAP_SLAPD_F (int) backend_shutdown LDAP_P((Backend *be));
LDAP_SLAPD_F (int) backend_destroy LDAP_P((void));
190

191
192
LDAP_SLAPD_F (BackendInfo *) backend_info LDAP_P(( const char *type ));
LDAP_SLAPD_F (BackendDB *) backend_db_init LDAP_P(( const char *type ));
193

194
LDAP_SLAPD_F (BackendDB *) select_backend LDAP_P((
195
	struct berval * dn,
196
197
	int manageDSAit,
	int noSubordinates ));
198

Kurt Zeilenga's avatar
Kurt Zeilenga committed
199
LDAP_SLAPD_F (int) be_issuffix LDAP_P(( Backend *be,
200
	struct berval *suffix ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
201
202
LDAP_SLAPD_F (int) be_isroot LDAP_P(( Backend *be,
	struct berval *ndn ));
203
LDAP_SLAPD_F (int) be_isroot_pw LDAP_P(( Operation *op ));
204
LDAP_SLAPD_F (int) be_isupdate LDAP_P(( Backend *be, struct berval *ndn ));
205
LDAP_SLAPD_F (struct berval *) be_root_dn LDAP_P(( Backend *be ));
206
LDAP_SLAPD_F (int) be_entry_get_rw LDAP_P(( struct slap_op *o,
207
208
		struct berval *ndn, ObjectClass *oc,
		AttributeDescription *at, int rw, Entry **e ));
209
LDAP_SLAPD_F (int) be_entry_release_rw LDAP_P((
210
211
212
	Operation *o, Entry *e, int rw ));
#define be_entry_release_r( o, e ) be_entry_release_rw( o, e, 0 )
#define be_entry_release_w( o, e ) be_entry_release_rw( o, e, 1 )
213

214
215
216
LDAP_SLAPD_F (int) backend_unbind LDAP_P((Operation *op, SlapReply *rs));
LDAP_SLAPD_F (int) backend_connection_init LDAP_P((Connection *conn));
LDAP_SLAPD_F (int) backend_connection_destroy LDAP_P((Connection *conn));
217

218
LDAP_SLAPD_F( int )	backend_check_restrictions LDAP_P((
219
	Operation *op,
220
221
	SlapReply *rs,
	struct berval *opdata ));
222

223
LDAP_SLAPD_F( int )	backend_check_referrals LDAP_P((
224
	Operation *op,
225
	SlapReply *rs ));
226

227
LDAP_SLAPD_F (int) backend_group LDAP_P((
228
	Operation *op,
229
	Entry *target,
230
	struct berval *gr_ndn,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
231
	struct berval *op_ndn,
232
233
	ObjectClass *group_oc,
	AttributeDescription *group_at
234
));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
235

236
LDAP_SLAPD_F (int) backend_attribute LDAP_P((
237
238
	Operation *op,
	Entry *target,
239
	struct berval *entry_ndn,
240
	AttributeDescription *entry_at,
241
	BerVarray *vals
242
243
));

244
245
LDAP_SLAPD_F (Attribute *) backend_operational(
	Operation *op,
246
	SlapReply *rs,
247
	int opattrs );
248

249
250
251
252
253
/*
 * backglue.c
 */

LDAP_SLAPD_F (int) glue_back_initialize( BackendInfo *bi );
254
LDAP_SLAPD_F (int) glue_sub_init( void );
255

Kurt Zeilenga's avatar
Kurt Zeilenga committed
256
257
258
/*
 * ch_malloc.c
 */
Howard Chu's avatar
Howard Chu committed
259
LDAP_SLAPD_V (BerMemoryFunctions) ch_mfuncs;
260
261
262
263
264
LDAP_SLAPD_F (void *) ch_malloc LDAP_P(( ber_len_t size ));
LDAP_SLAPD_F (void *) ch_realloc LDAP_P(( void *block, ber_len_t size ));
LDAP_SLAPD_F (void *) ch_calloc LDAP_P(( ber_len_t nelem, ber_len_t size ));
LDAP_SLAPD_F (char *) ch_strdup LDAP_P(( const char *string ));
LDAP_SLAPD_F (void) ch_free LDAP_P(( void * ));
265
266
267

#ifndef CH_FREE
#undef free
268
#define free ch_free
269
#endif
Kurt Zeilenga's avatar
Kurt Zeilenga committed
270

271
272
273
/*
 * controls.c
 */
274
LDAP_SLAPD_F (int) get_ctrls LDAP_P((
275
	Operation *op,
276
	SlapReply *rs,
277
	int senderrors ));
278
279
280
281
282
283
284
285
286
LDAP_SLAPD_F (int) register_supported_control LDAP_P((
	const char *controloid,
	slap_mask_t controlmask,
	char **controlexops,
	SLAP_CTRL_PARSE_FN *controlparsefn ));
LDAP_SLAPD_F (int) slap_controls_init LDAP_P ((void));
LDAP_SLAPD_F (void) controls_destroy LDAP_P ((void));
LDAP_SLAPD_F (int) controls_root_dse_info LDAP_P ((Entry *e));
LDAP_SLAPD_F (int) get_supported_controls LDAP_P (( char ***ctrloidsp, slap_mask_t **ctrlmasks ));
287

Kurt Zeilenga's avatar
Kurt Zeilenga committed
288
289
290
/*
 * config.c
 */
291
LDAP_SLAPD_F (int) read_config LDAP_P(( const char *fname, int depth ));
Howard Chu's avatar
Howard Chu committed
292
LDAP_SLAPD_F (void) config_destroy LDAP_P ((void));
293

Kurt Zeilenga's avatar
Kurt Zeilenga committed
294
295
296
/*
 * connection.c
 */
297
298
299
300
LDAP_SLAPD_F (int) connections_init LDAP_P((void));
LDAP_SLAPD_F (int) connections_shutdown LDAP_P((void));
LDAP_SLAPD_F (int) connections_destroy LDAP_P((void));
LDAP_SLAPD_F (int) connections_timeout_idle LDAP_P((time_t));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
301

302
LDAP_SLAPD_F (long) connection_init LDAP_P((
303
	ber_socket_t s,
Pierangelo Masarati's avatar
Pierangelo Masarati committed
304
	Listener* url,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
305
306
	const char* dnsname,
	const char* peername,
307
	int use_tls,
308
	slap_ssf_t ssf,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
309
	const char *id ));
310

311
312
LDAP_SLAPD_F (void) connection_closing LDAP_P(( Connection *c ));
LDAP_SLAPD_F (int) connection_state_closing LDAP_P(( Connection *c ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
313
314
LDAP_SLAPD_F (const char *) connection_state2str LDAP_P(( int state ))
	LDAP_GCCATTR((const));
315

316
317
LDAP_SLAPD_F (int) connection_write LDAP_P((ber_socket_t s));
LDAP_SLAPD_F (int) connection_read LDAP_P((ber_socket_t s));
318

319
LDAP_SLAPD_F (unsigned long) connections_nextid(void);
320

Kurt Zeilenga's avatar
Kurt Zeilenga committed
321
322
323
LDAP_SLAPD_F (Connection *) connection_first LDAP_P(( ber_socket_t * ));
LDAP_SLAPD_F (Connection *) connection_next LDAP_P((
	Connection *, ber_socket_t *));
324
LDAP_SLAPD_F (void) connection_done LDAP_P((Connection *));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
325

326
327
LDAP_SLAPD_F (void) connection2anonymous LDAP_P((Connection *));

328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
/*
 * cr.c
 */
LDAP_SLAPD_F (int) cr_schema_info( Entry *e );

LDAP_SLAPD_F (int) cr_add LDAP_P((
	LDAPContentRule *oc,
	int user,
	const char **err));
LDAP_SLAPD_F (void) cr_destroy LDAP_P(( void ));

LDAP_SLAPD_F (ContentRule *) cr_find LDAP_P((
	const char *crname));
LDAP_SLAPD_F (ContentRule *) cr_bvfind LDAP_P((
	struct berval *crname));

Kurt Zeilenga's avatar
Kurt Zeilenga committed
344
/*
Kurt Zeilenga's avatar
Kurt Zeilenga committed
345
 * daemon.c
Kurt Zeilenga's avatar
Kurt Zeilenga committed
346
 */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
347
348
349
350
351
352
LDAP_SLAPD_F (void) slapd_add_internal(ber_socket_t s);
LDAP_SLAPD_F (int) slapd_daemon_init( const char *urls );
LDAP_SLAPD_F (int) slapd_daemon_destroy(void);
LDAP_SLAPD_F (int) slapd_daemon(void);
LDAP_SLAPD_F (Listener **)	slapd_get_listeners LDAP_P((void));
LDAP_SLAPD_F (void) slapd_remove LDAP_P((ber_socket_t s, int wake));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
353

Kurt Zeilenga's avatar
Kurt Zeilenga committed
354
355
356
357
358
359
360
361
362
363
364
LDAP_SLAPD_F (RETSIGTYPE) slap_sig_shutdown LDAP_P((int sig));
LDAP_SLAPD_F (RETSIGTYPE) slap_sig_wake LDAP_P((int sig));

LDAP_SLAPD_F (void) slapd_set_write LDAP_P((ber_socket_t s, int wake));
LDAP_SLAPD_F (void) slapd_clr_write LDAP_P((ber_socket_t s, int wake));
LDAP_SLAPD_F (void) slapd_set_read LDAP_P((ber_socket_t s, int wake));
LDAP_SLAPD_F (void) slapd_clr_read LDAP_P((ber_socket_t s, int wake));

/*
 * dn.c
 */
365

366
#define dn_match(dn1, dn2) 	( ber_bvcmp((dn1), (dn2)) == 0 )
367
#define bvmatch(bv1, bv2)	( ((bv1)->bv_len == (bv2)->bv_len) && (memcmp((bv1)->bv_val, (bv2)->bv_val, (bv1)->bv_len) == 0) )
368

369
370
371
372
LDAP_SLAPD_F (int) dnValidate LDAP_P((
	Syntax *syntax, 
	struct berval *val ));

Howard Chu's avatar
Howard Chu committed
373
374
LDAP_SLAPD_F (slap_mr_normalize_func) dnNormalize;
#define dnNormalize2(s,v,n,x)		dnNormalize(0,(s),NULL,(v),(n),(x))
375

376
377
378
379
380
LDAP_SLAPD_F (int) dnPretty LDAP_P(( 
	Syntax *syntax, 
	struct berval *val, 
	struct berval **pretty ));

Howard Chu's avatar
Howard Chu committed
381
LDAP_SLAPD_F (slap_syntax_transform_func) dnPretty2;
382

383
384
385
386
LDAP_SLAPD_F (int) dnPrettyNormal LDAP_P(( 
	Syntax *syntax, 
	struct berval *val, 
	struct berval *pretty,
Howard Chu's avatar
Howard Chu committed
387
388
	struct berval *normal,
	void *ctx ));
389

390
391
392
393
394
395
396
397
LDAP_SLAPD_F (int) dnMatch LDAP_P(( 
	int *matchp, 
	slap_mask_t flags, 
	Syntax *syntax, 
	MatchingRule *mr,
	struct berval *value, 
	void *assertedValue ));

398
399
400
LDAP_SLAPD_F (int) dnIsSuffix LDAP_P((
	const struct berval *dn, const struct berval *suffix ));

401
LDAP_SLAPD_F (int) dnExtractRdn LDAP_P((
Howard Chu's avatar
Howard Chu committed
402
	struct berval *dn, struct berval *rdn, void *ctx ));
403

Kurt Zeilenga's avatar
Kurt Zeilenga committed
404
405
LDAP_SLAPD_F (int) rdnValidate LDAP_P(( struct berval * rdn ));

406
407
408
409
410
411
412
LDAP_SLAPD_F (int) dn_rdnlen LDAP_P(( Backend *be, struct berval *dn ));

LDAP_SLAPD_F (void) build_new_dn LDAP_P((
	struct berval * new_dn,
	struct berval * parent_dn,
	struct berval * newrdn ));

413
LDAP_SLAPD_F (void) dnParent LDAP_P(( struct berval *dn, struct berval *pdn ));
Pierangelo Masarati's avatar
Pierangelo Masarati committed
414

415
416
LDAP_SLAPD_F (int) dnX509normalize LDAP_P(( void *x509_name, struct berval *out ));

417
LDAP_SLAPD_F (int) dnX509peerNormalize LDAP_P(( void *ssl, struct berval *dn ));
418

Howard Chu's avatar
Howard Chu committed
419
420
421
422
423
LDAP_SLAPD_F (int) dnPrettyNormalDN LDAP_P(( Syntax *syntax, struct berval *val, LDAPDN *dn, int flags, void *ctx ));
#define dnPrettyDN(syntax, val, dn, ctx) \
	dnPrettyNormalDN((syntax),(val),(dn), SLAP_LDAPDN_PRETTY, ctx)
#define dnNormalDN(syntax, val, dn, ctx) \
	dnPrettyNormalDN((syntax),(val),(dn), 0, ctx)
424
425


Kurt Zeilenga's avatar
Kurt Zeilenga committed
426
427
428
/*
 * entry.c
 */
Howard Chu's avatar
Howard Chu committed
429
LDAP_SLAPD_V (const Entry) slap_entry_root;
430

431
LDAP_SLAPD_F (int) entry_destroy LDAP_P((void));
432

433
434
LDAP_SLAPD_F (Entry *) str2entry LDAP_P(( char	*s ));
LDAP_SLAPD_F (char *) entry2str LDAP_P(( Entry *e, int *len ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
435

Howard Chu's avatar
Howard Chu committed
436
437
LDAP_SLAPD_F (void) entry_flatsize LDAP_P((
	Entry *e, ber_len_t *siz, ber_len_t *len, int norm ));
438
LDAP_SLAPD_F (int) entry_decode LDAP_P(( struct berval *bv, Entry **e ));
439
LDAP_SLAPD_F (int) entry_encode LDAP_P(( Entry *e, struct berval *bv ));
440
441

LDAP_SLAPD_F (void) entry_free LDAP_P(( Entry *e ));
442
LDAP_SLAPD_F (int) entry_cmp LDAP_P(( Entry *a, Entry *b ));
443
444
LDAP_SLAPD_F (int) entry_dn_cmp LDAP_P(( const void *v_a, const void *v_b ));
LDAP_SLAPD_F (int) entry_id_cmp LDAP_P(( const void *v_a, const void *v_b ));
445

446
447
448
/*
 * extended.c
 */
449
450
451
452
453
454
455
#ifdef LDAP_EXOP_X_CANCEL
const struct berval slap_EXOP_CANCEL;
#endif
const struct berval slap_EXOP_WHOAMI;
const struct berval slap_EXOP_MODIFY_PASSWD;
const struct berval slap_EXOP_START_TLS;

456
typedef int (SLAP_EXTOP_MAIN_FN) LDAP_P(( Operation *op, SlapReply *rs ));
457

458
typedef int (SLAP_EXTOP_GETOID_FN) LDAP_P((
459
	int index, struct berval *oid, int blen ));
460

461
LDAP_SLAPD_F (int) load_extop LDAP_P((
462
	struct berval *ext_oid,
463
	SLAP_EXTOP_MAIN_FN *ext_main ));
464

465
LDAP_SLAPD_F (int) extops_init LDAP_P(( void ));
466

467
LDAP_SLAPD_F (int) extops_kill LDAP_P(( void ));
468

Howard Chu's avatar
Howard Chu committed
469
LDAP_SLAPD_F (struct berval *) get_supported_extop LDAP_P((int index));
470

Jong Hyuk Choi's avatar
Jong Hyuk Choi committed
471
472
473
474
475
/*
 *  * cancel.c
 *   */
LDAP_SLAPD_F ( SLAP_EXTOP_MAIN_FN ) cancel_extop;

Kurt Zeilenga's avatar
Kurt Zeilenga committed
476
477
478
/*
 * filter.c
 */
479
LDAP_SLAPD_F (int) get_filter LDAP_P((
480
	Operation *op,
481
482
	BerElement *ber,
	Filter **filt,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
483
	const char **text ));
484

485
LDAP_SLAPD_F (void) filter_free LDAP_P(( Filter *f ));
486
LDAP_SLAPD_F (void) filter_free_x LDAP_P(( Operation *op, Filter *f ));
487
LDAP_SLAPD_F (void) filter2bv LDAP_P(( Filter *f, struct berval *bv ));
Howard Chu's avatar
Howard Chu committed
488
LDAP_SLAPD_F (void) filter2bv_x LDAP_P(( Operation *op, Filter *f, struct berval *bv ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
489

490
LDAP_SLAPD_F (int) get_vrFilter LDAP_P(( Operation *op, BerElement *ber,
491
	ValuesReturnFilter **f,
492
	const char **text ));
493

494
495
LDAP_SLAPD_F (void) vrFilter_free LDAP_P(( Operation *op, ValuesReturnFilter *f ));
LDAP_SLAPD_F (void) vrFilter2bv LDAP_P(( Operation *op, ValuesReturnFilter *f, struct berval *fstr ));
496
497

LDAP_SLAPD_F (int) filter_has_subordinates LDAP_P(( Filter *filter ));
498
499
LDAP_SLAPD_F (int) filter_escape_value LDAP_P(( struct berval *in, 
	struct berval *out ));
500

Kurt Zeilenga's avatar
Kurt Zeilenga committed
501
502
503
/*
 * filterentry.c
 */
504

505
LDAP_SLAPD_F (int) test_filter LDAP_P(( Operation *op, Entry *e, Filter *f ));
506

507
508
509
510
511
512
/*
 * globals.c
 */

LDAP_SLAPD_V( const struct berval ) slap_empty_bv;
LDAP_SLAPD_V( const struct berval ) slap_unknown_bv;
513
514
LDAP_SLAPD_V( const struct berval ) slap_true_bv;
LDAP_SLAPD_V( const struct berval ) slap_false_bv;
515

Kurt Zeilenga's avatar
Kurt Zeilenga committed
516
517
518
519
520
521
522
523
524
525
526
527
528
/*
 * index.c
 */
LDAP_SLAPD_F (int) slap_str2index LDAP_P(( const char *str, slap_mask_t *idx ));

/*
 * init.c
 */
LDAP_SLAPD_F (int)	slap_init LDAP_P((int mode, const char* name));
LDAP_SLAPD_F (int)	slap_startup LDAP_P(( Backend *be ));
LDAP_SLAPD_F (int)	slap_shutdown LDAP_P(( Backend *be ));
LDAP_SLAPD_F (int)	slap_destroy LDAP_P((void));

529
LDAP_SLAPD_V (char **)	slap_known_controls;
530

Kurt Zeilenga's avatar
Kurt Zeilenga committed
531
532
533
534
535
536
537
538
/*
 * kerberos.c
 */
#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND
LDAP_SLAPD_V (char *)	ldap_srvtab;
LDAP_SLAPD_V (int)	krbv4_ldap_auth();
#endif

539
540
541
542
/*
 * limits.c
 */
LDAP_SLAPD_F (int) get_limits LDAP_P((
543
544
	Backend *be, struct berval *ndn,
	struct slap_limits_set **limit ));
545
LDAP_SLAPD_F (int) parse_limits LDAP_P((
546
547
	Backend *be, const char *fname, int lineno,
	int argc, char **argv ));
548
549
LDAP_SLAPD_F (int) parse_limit LDAP_P(( const char *arg, 
	struct slap_limits_set *limit ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
550
551
552
553

/*
 * lock.c
 */
554
555
LDAP_SLAPD_F (FILE *) lock_fopen LDAP_P(( const char *fname,
	const char *type, FILE **lfp ));
556
LDAP_SLAPD_F (int) lock_fclose LDAP_P(( FILE *fp, FILE *lfp ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
557

558
559
560
561
562
/*
 * matchedValues.c
 */
LDAP_SLAPD_F (int) filter_matched_values( 
	Operation	*op,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
563
	Attribute	*a,
564
565
	char		***e_flags );

566
567
568
569
570
/*
 * modrdn.c
 */
LDAP_SLAPD_F (int) slap_modrdn2mods(
	Operation	*op,
571
	SlapReply	*rs,
572
	Entry		*e,
Howard Chu's avatar
Howard Chu committed
573
574
	LDAPRDN		oldrdn,
	LDAPRDN		newrdn,
575
576
	Modifications	**pmod );

577
578
579
/*
 * modify.c
 */
580
581
582
583
LDAP_SLAPD_F( int ) slap_mods_check(
	Modifications *ml,
	int update,
	const char **text,
Howard Chu's avatar
Howard Chu committed
584
	char *textbuf, size_t textlen, void *ctx );
585

586
LDAP_SLAPD_F( int ) slap_mods_opattrs(
587
	Operation *op,
588
	Modifications *mods,
589
	Modifications **modlist,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
590
591
	const char **text,
	char *textbuf, size_t textlen );
592

Kurt Zeilenga's avatar
Kurt Zeilenga committed
593
594
595
/*
 * mods.c
 */
Pierangelo Masarati's avatar
/*    
Pierangelo Masarati committed
596
597
LDAP_SLAPD_F( int ) modify_check_duplicates(
	AttributeDescription *ad, MatchingRule *mr, 
598
	BerVarray vals, BerVarray mods, int permissive, 
Pierangelo Masarati's avatar
/*    
Pierangelo Masarati committed
599
	const char **text, char *textbuf, size_t textlen );
600
601
LDAP_SLAPD_F( int ) modify_add_values( Entry *e,
	Modification *mod,
602
	int permissive,
603
604
605
	const char **text, char *textbuf, size_t textlen );
LDAP_SLAPD_F( int ) modify_delete_values( Entry *e,
	Modification *mod,
606
	int permissive,
607
608
609
	const char **text, char *textbuf, size_t textlen );
LDAP_SLAPD_F( int ) modify_replace_values( Entry *e,
	Modification *mod,
610
	int permissive,
611
612
	const char **text, char *textbuf, size_t textlen );

Kurt Zeilenga's avatar
Kurt Zeilenga committed
613
614
615
616
LDAP_SLAPD_F( void ) slap_mod_free( Modification *mod, int freeit );
LDAP_SLAPD_F( void ) slap_mods_free( Modifications *mods );
LDAP_SLAPD_F( void ) slap_modlist_free( LDAPModList *ml );

617
618
619
620
/*
 * module.c
 */
#ifdef SLAPD_MODULES
621

622
623
LDAP_SLAPD_F (int) module_init LDAP_P(( void ));
LDAP_SLAPD_F (int) module_kill LDAP_P(( void ));
624

625
LDAP_SLAPD_F (int) load_null_module(
626
	const void *module, const char *file_name);
627
LDAP_SLAPD_F (int) load_extop_module(
628
629
	const void *module, const char *file_name);

630
LDAP_SLAPD_F (int) module_load LDAP_P((
631
632
	const char* file_name,
	int argc, char *argv[] ));
633
LDAP_SLAPD_F (int) module_path LDAP_P(( const char* path ));
634

635
LDAP_SLAPD_F (void) *module_resolve LDAP_P((
636
637
	const void *module, const char *name));

638
639
#endif /* SLAPD_MODULES */

Kurt Zeilenga's avatar
Kurt Zeilenga committed
640
641
642
643
/* mr.c */
LDAP_SLAPD_F (MatchingRule *) mr_bvfind LDAP_P((struct berval *mrname));
LDAP_SLAPD_F (MatchingRule *) mr_find LDAP_P((const char *mrname));
LDAP_SLAPD_F (int) mr_add LDAP_P(( LDAPMatchingRule *mr,
644
	slap_mrule_defs_rec *def,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
645
646
647
648
649
	MatchingRule * associated,
	const char **err ));
LDAP_SLAPD_F (void) mr_destroy LDAP_P(( void ));

LDAP_SLAPD_F (int) register_matching_rule LDAP_P((
650
	slap_mrule_defs_rec *def ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
651

652
653
654
LDAP_SLAPD_F (void) mru_destroy LDAP_P(( void ));
LDAP_SLAPD_F (int) matching_rule_use_init LDAP_P(( void ));

Kurt Zeilenga's avatar
Kurt Zeilenga committed
655
LDAP_SLAPD_F (int) mr_schema_info( Entry *e );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
656
LDAP_SLAPD_F (int) mru_schema_info( Entry *e );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
657

658
659
660
LDAP_SLAPD_F (int) mr_usable_with_at( MatchingRule *mr,
	AttributeType *at );

661
662
663
664
/*
 * mra.c
 */
LDAP_SLAPD_F (int) get_mra LDAP_P((
665
	Operation *op,
666
667
668
669
	BerElement *ber,
	MatchingRuleAssertion **mra,
	const char **text ));
LDAP_SLAPD_F (void) mra_free LDAP_P((
670
	Operation *op,
671
672
673
	MatchingRuleAssertion *mra,
	int freeit ));

Kurt Zeilenga's avatar
Kurt Zeilenga committed
674
675
676
/* oc.c */
LDAP_SLAPD_F (int) oc_add LDAP_P((
	LDAPObjectClass *oc,
677
	int user,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
678
679
680
681
682
683
684
685
	const char **err));
LDAP_SLAPD_F (void) oc_destroy LDAP_P(( void ));

LDAP_SLAPD_F (ObjectClass *) oc_find LDAP_P((
	const char *ocname));
LDAP_SLAPD_F (ObjectClass *) oc_bvfind LDAP_P((
	struct berval *ocname));
LDAP_SLAPD_F (int) is_object_subclass LDAP_P((
686
687
	ObjectClass *sup,
	ObjectClass *sub ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
688
689

LDAP_SLAPD_F (int) is_entry_objectclass LDAP_P((
690
	Entry *, ObjectClass *oc, int set_flags ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
691
#define is_entry_alias(e)		\
692
693
694
	(((e)->e_ocflags & SLAP_OC__END) \
	 ? (((e)->e_ocflags & SLAP_OC_ALIAS) != 0) \
	 : is_entry_objectclass((e), slap_schema.si_oc_alias, 1))
Kurt Zeilenga's avatar
Kurt Zeilenga committed
695
#define is_entry_referral(e)	\
696
697
698
	(((e)->e_ocflags & SLAP_OC__END) \
	 ? (((e)->e_ocflags & SLAP_OC_REFERRAL) != 0) \
	 : is_entry_objectclass((e), slap_schema.si_oc_referral, 1))
Kurt Zeilenga's avatar
Kurt Zeilenga committed
699
#define is_entry_subentry(e)	\
700
701
702
	(((e)->e_ocflags & SLAP_OC__END) \
	 ? (((e)->e_ocflags & SLAP_OC_SUBENTRY) != 0) \
	 : is_entry_objectclass((e), slap_schema.si_oc_subentry, 1))
703
#define is_entry_collectiveAttributeSubentry(e)	\
704
705
706
	(((e)->e_ocflags & SLAP_OC__END) \
	 ? (((e)->e_ocflags & SLAP_OC_COLLECTIVEATTRIBUTESUBENTRY) != 0) \
	 : is_entry_objectclass((e), slap_schema.si_oc_collectiveAttributeSubentry, 1))
Kurt Zeilenga's avatar
Kurt Zeilenga committed
707
#define is_entry_dynamicObject(e)	\
708
709
710
	(((e)->e_ocflags & SLAP_OC__END) \
	 ? (((e)->e_ocflags & SLAP_OC_DYNAMICOBJECT) != 0) \
	 : is_entry_objectclass((e), slap_schema.si_oc_dynamicObject, 1))
Kurt Zeilenga's avatar
Kurt Zeilenga committed
711
712
713

LDAP_SLAPD_F (int) oc_schema_info( Entry *e );

714
715
716
717
718
719
720
721
/*
 * oidm.c
 */
LDAP_SLAPD_F(char *) oidm_find(char *oid);
LDAP_SLAPD_F (void) oidm_destroy LDAP_P(( void ));
LDAP_SLAPD_F (int) parse_oidm LDAP_P((
	const char *fname, int lineno, int argc, char **argv ));

Kurt Zeilenga's avatar
Kurt Zeilenga committed
722
723
724
/*
 * operation.c
 */
Pierangelo Masarati's avatar
Pierangelo Masarati committed
725
726
LDAP_SLAPD_F (void) slap_op_init LDAP_P(( void ));
LDAP_SLAPD_F (void) slap_op_destroy LDAP_P(( void ));
727
728
LDAP_SLAPD_F (void) slap_op_free LDAP_P(( Operation *op ));
LDAP_SLAPD_F (Operation *) slap_op_alloc LDAP_P((
729
730
	BerElement *ber, ber_int_t msgid,
	ber_tag_t tag, ber_int_t id ));
731

732
733
734
LDAP_SLAPD_F (int) slap_op_add LDAP_P(( Operation **olist, Operation *op ));
LDAP_SLAPD_F (int) slap_op_remove LDAP_P(( Operation **olist, Operation *op ));
LDAP_SLAPD_F (Operation *) slap_op_pop LDAP_P(( Operation **olist ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
735
736

/*
Kurt Zeilenga's avatar
Kurt Zeilenga committed
737
 * operational.c
Kurt Zeilenga's avatar
Kurt Zeilenga committed
738
 */
739
LDAP_SLAPD_F (Attribute *) slap_operational_subschemaSubentry( Backend *be );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
740
LDAP_SLAPD_F (Attribute *) slap_operational_hasSubordinate( int has );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
741

Kurt Zeilenga's avatar
Kurt Zeilenga committed
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
/*
 * passwd.c
 */
LDAP_SLAPD_F (SLAP_EXTOP_MAIN_FN) passwd_extop;

LDAP_SLAPD_F (int) slap_passwd_check(
	Connection			*conn,
	Attribute			*attr,
	struct berval		*cred );

LDAP_SLAPD_F (void) slap_passwd_generate( struct berval * );

LDAP_SLAPD_F (void) slap_passwd_hash(
	struct berval		*cred,
	struct berval		*hash );

LDAP_SLAPD_F (struct berval *) slap_passwd_return(
	struct berval		*cred );

LDAP_SLAPD_F (int) slap_passwd_parse(
	struct berval *reqdata,
	struct berval *id,
	struct berval *oldpass,
	struct berval *newpass,
	const char **text );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
767
768

/*
Kurt Zeilenga's avatar
Kurt Zeilenga committed
769
 * phonetic.c
Kurt Zeilenga's avatar
Kurt Zeilenga committed
770
 */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
771
LDAP_SLAPD_F (char *) phonetic LDAP_P(( char *s ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
772
773

/*
774
 * referral.c
Kurt Zeilenga's avatar
Kurt Zeilenga committed
775
 */
776
777
LDAP_SLAPD_F (int) validate_global_referral LDAP_P((
	const char *url ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
778

779
LDAP_SLAPD_F (BerVarray) get_entry_referrals LDAP_P((
780
	Operation *op, Entry *e ));
781

782
783
LDAP_SLAPD_F (BerVarray) referral_rewrite LDAP_P((
	BerVarray refs,
784
785
	struct berval *base,
	struct berval *target,
786
787
	int scope ));

788
789
790
791
792
793
LDAP_SLAPD_F (int) get_alias_dn LDAP_P((
	Entry *e,
	struct berval *ndn,
	int *err,
	const char **text ));

794
/*
Kurt Zeilenga's avatar
Kurt Zeilenga committed
795
 * repl.c
796
 */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
797
798
799
800
LDAP_SLAPD_F (int) add_replica_info LDAP_P(( Backend *be,
	const char *host ));
LDAP_SLAPD_F (int) add_replica_suffix LDAP_P(( Backend *be,
	int nr, const char *suffix ));
801
LDAP_SLAPD_F (int) add_replica_attrs LDAP_P(( Backend *be,
802
	int nr, char *attrs, int exclude ));
803
LDAP_SLAPD_F (void) replog LDAP_P(( Operation *op ));
804

Kurt Zeilenga's avatar
Kurt Zeilenga committed
805
806
807
/*
 * result.c
 */
808
809
810
811
812
813
814
815
LDAP_SLAPD_F (void) slap_send_ldap_result LDAP_P(( Operation *op, SlapReply *rs ));
LDAP_SLAPD_F (void) send_ldap_sasl LDAP_P(( Operation *op, SlapReply *rs ));
LDAP_SLAPD_F (void) send_ldap_disconnect LDAP_P(( Operation *op, SlapReply *rs ));
LDAP_SLAPD_F (void) slap_send_ldap_extended LDAP_P(( Operation *op, SlapReply *rs ));
LDAP_SLAPD_F (void) slap_send_ldap_intermediate_resp LDAP_P(( Operation *op, SlapReply *rs ));
LDAP_SLAPD_F (void) slap_send_search_result LDAP_P(( Operation *op, SlapReply *rs ));
LDAP_SLAPD_F (int) slap_send_search_reference LDAP_P(( Operation *op, SlapReply *rs ));
LDAP_SLAPD_F (int) slap_send_search_entry LDAP_P(( Operation *op, SlapReply *rs ));
816

817
LDAP_SLAPD_F (int) str2result LDAP_P(( char *s,
818
	int *code, char **matched, char **info ));
819

820
/*
Kurt Zeilenga's avatar
Kurt Zeilenga committed
821
 * root_dse.c
822
 */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
823
824
825
826
827
828
829
LDAP_SLAPD_F (int) root_dse_info LDAP_P((
	Connection *conn,
	Entry **e,
	const char **text ));

LDAP_SLAPD_F (int) read_root_dse_file LDAP_P((
	const char *file));
830

Kurt Zeilenga's avatar
Kurt Zeilenga committed
831
832
833
/*
 * sasl.c
 */
834
835
836
837
838
839
840
841
LDAP_SLAPD_F (int) slap_sasl_init(void);
LDAP_SLAPD_F (char *) slap_sasl_secprops( const char * );
LDAP_SLAPD_F (int) slap_sasl_destroy(void);

LDAP_SLAPD_F (int) slap_sasl_open( Connection *c );
LDAP_SLAPD_F (char **) slap_sasl_mechs( Connection *c );

LDAP_SLAPD_F (int) slap_sasl_external( Connection *c,
842
	slap_ssf_t ssf,	/* relative strength of external security */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
843
	const char *authid );	/* asserted authenication id */
844
845
846
847

LDAP_SLAPD_F (int) slap_sasl_reset( Connection *c );
LDAP_SLAPD_F (int) slap_sasl_close( Connection *c );

848
LDAP_SLAPD_F (int) slap_sasl_bind LDAP_P(( Operation *op, SlapReply *rs ));
849

850
851
LDAP_SLAPD_F (int) slap_sasl_setpass(
	Operation       *op,
852
	SlapReply	*rs );
853

854
855
856
857
858
859
860
LDAP_SLAPD_F (int) slap_sasl_config(
	int cargc,
	char **cargv,
	char *line,
	const char *fname,
	int lineno );

861
LDAP_SLAPD_F (int) slap_sasl_getdn( Connection *conn, Operation *op,
862
863
	char *id, int len,
	char *user_realm, struct berval *dn, int flags );
864

Kurt Zeilenga's avatar
Kurt Zeilenga committed
865
866
867
/*
 * saslauthz.c
 */
868
LDAP_SLAPD_F (void) slap_sasl2dn LDAP_P((
869
	Operation *op,
870
871
	struct berval *saslname,
	struct berval *dn ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
872
LDAP_SLAPD_F (int) slap_sasl_authorized LDAP_P((
Kurt Zeilenga's avatar
Kurt Zeilenga committed
873
	Connection *conn,
874
875
	struct berval *authcid,
	struct berval *authzid ));
Kurt Zeilenga's avatar
Kurt Zeilenga committed
876
877
LDAP_SLAPD_F (int) slap_sasl_regexp_config LDAP_P((
	const char *match, const char *replace ));
878
879
LDAP_SLAPD_F (int) slap_sasl_setpolicy LDAP_P(( const char * ));

Kurt Zeilenga's avatar
Kurt Zeilenga committed
880

Kurt Zeilenga's avatar
Kurt Zeilenga committed
881
882
883
/*
 * schema.c
 */
884
LDAP_SLAPD_F (int) schema_info LDAP_P(( Entry **entry, const char **text ));
Howard Chu's avatar
Howard Chu committed
885

886
887
888
/*
 * schema_check.c
 */
Kurt Zeilenga's avatar
Kurt Zeilenga committed
889
LDAP_SLAPD_F( int ) oc_check_allowed(
890
	AttributeType *type,
891
	BerVarray oclist,
892
	ObjectClass *sc );
Kurt Zeilenga's avatar
Kurt Zeilenga committed
893
894

LDAP_SLAPD_F( int ) structural_class(
895
	BerVarray ocs,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
896
	struct berval *scbv,
Howard Chu's avatar
Howard Chu committed
897
	ObjectClass **sc,
Kurt Zeilenga's avatar
Kurt Zeilenga committed
898
899
900
901
	const char **text,
	char *textbuf, size_t textlen );

LDAP_SLAPD_F( int ) entry_schema_check(
902
	Backend *be, Entry *e, Attribute *attrs,