]> git.sur5r.net Git - openldap/blob - servers/slapd/proto-slap.h
a3b75fd30570cba0e3965ba4a2ac3dc4b4ffcebe
[openldap] / servers / slapd / proto-slap.h
1 /* $OpenLDAP$ */
2 /*
3  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
5  */
6 #ifndef PROTO_SLAP_H
7 #define PROTO_SLAP_H
8
9 #include <ldap_cdefs.h>
10 #include "ldap_pvt.h"
11
12 LDAP_BEGIN_DECL
13
14 /*
15  * acl.c
16  */
17 LDAP_SLAPD_F (int) access_allowed LDAP_P((
18         Backend *be, Connection *conn, Operation *op,
19         Entry *e, AttributeDescription *desc, struct berval *val,
20         slap_access_t access,
21         AccessControlState *state ));
22 LDAP_SLAPD_F (int) acl_check_modlist LDAP_P((
23         Backend *be, Connection *conn, Operation *op,
24         Entry *e, Modifications *ml ));
25
26 LDAP_SLAPD_F (void) acl_append( AccessControl **l, AccessControl *a );
27
28 /*
29  * aclparse.c
30  */
31 LDAP_SLAPD_F (void) parse_acl LDAP_P(( Backend *be,
32         const char *fname, int lineno,
33         int argc, char **argv ));
34
35 LDAP_SLAPD_F (char *) access2str LDAP_P(( slap_access_t access ));
36 LDAP_SLAPD_F (slap_access_t) str2access LDAP_P(( const char *str ));
37
38 #define ACCESSMASK_MAXLEN       sizeof("unknown (+wrscan)")
39 LDAP_SLAPD_F (char *) accessmask2str LDAP_P(( slap_mask_t mask, char* ));
40 LDAP_SLAPD_F (slap_mask_t) str2accessmask LDAP_P(( const char *str ));
41 LDAP_SLAPD_F (void) acl_destroy LDAP_P(( AccessControl*, AccessControl* ));
42 LDAP_SLAPD_F (void) acl_free LDAP_P(( AccessControl *a ));
43
44 /*
45  * ad.c
46  */
47 LDAP_SLAPD_F (int) slap_str2ad LDAP_P((
48         const char *,
49         AttributeDescription **ad,
50         const char **text ));
51
52 LDAP_SLAPD_F (int) slap_bv2ad LDAP_P((
53         struct berval *bv,
54         AttributeDescription **ad,
55         const char **text ));
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) \
60         ? -1 : (((l)->ad_cname.bv_len > (r)->ad_cname.bv_len) \
61                 ? 1 : strcasecmp((l)->ad_cname.bv_val, (r)->ad_cname.bv_val )))
62
63 LDAP_SLAPD_F (int) is_ad_subtype LDAP_P((
64         AttributeDescription *sub,
65         AttributeDescription *super ));
66
67 LDAP_SLAPD_F (int) ad_inlist LDAP_P((
68         AttributeDescription *desc,
69         AttributeName *attrs ));
70
71 LDAP_SLAPD_F (int) slap_str2undef_ad LDAP_P((
72         const char *,
73         AttributeDescription **ad,
74         const char **text ));
75
76 LDAP_SLAPD_F (int) slap_bv2undef_ad LDAP_P((
77         struct berval *bv,
78         AttributeDescription **ad,
79         const char **text ));
80
81 LDAP_SLAPD_F (AttributeDescription *) ad_find_tags LDAP_P((
82         AttributeType *type,
83         struct berval *tags ));
84
85 LDAP_SLAPD_F (AttributeName *) str2anlist LDAP_P(( AttributeName *an,
86         char *str, const char *brkstr ));
87 LDAP_SLAPD_F (int) an_find LDAP_P(( AttributeName *a, struct berval *s ));
88 LDAP_SLAPD_F (int) ad_define_option LDAP_P(( const char *name,
89         const char *fname, int lineno ));
90
91 LDAP_SLAPD_F (MatchingRule *) ad_mr(
92         AttributeDescription *ad,
93         unsigned usage );
94
95 /*
96  * add.c
97  */
98 LDAP_SLAPD_F (int) slap_mods2entry LDAP_P(( Modifications *mods, Entry **e,
99         int repl_user, const char **text, char *textbuf, size_t textlen ));
100
101 /*
102  * at.c
103  */
104 LDAP_SLAPD_F (void) at_config LDAP_P((
105         const char *fname, int lineno,
106         int argc, char **argv ));
107 LDAP_SLAPD_F (AttributeType *) at_find LDAP_P((
108         const char *name ));
109 LDAP_SLAPD_F (AttributeType *) at_bvfind LDAP_P((
110         struct berval *name ));
111 LDAP_SLAPD_F (int) at_find_in_list LDAP_P((
112         AttributeType *sat, AttributeType **list ));
113 LDAP_SLAPD_F (int) at_append_to_list LDAP_P((
114         AttributeType *sat, AttributeType ***listp ));
115 LDAP_SLAPD_F (int) at_delete_from_list LDAP_P((
116         int pos, AttributeType ***listp ));
117 LDAP_SLAPD_F (int) at_schema_info LDAP_P(( Entry *e ));
118 LDAP_SLAPD_F (int) at_add LDAP_P((
119         LDAPAttributeType *at, const char **err ));
120 LDAP_SLAPD_F (void) at_destroy LDAP_P(( void ));
121
122 LDAP_SLAPD_F (int) is_at_subtype LDAP_P((
123         AttributeType *sub,
124         AttributeType *super ));
125
126 LDAP_SLAPD_F (int) is_at_syntax LDAP_P((
127         AttributeType *at,
128         const char *oid ));
129
130 LDAP_SLAPD_F (int) at_start LDAP_P(( AttributeType **at ));
131 LDAP_SLAPD_F (int) at_next LDAP_P(( AttributeType **at ));
132
133 /*
134  * attr.c
135  */
136 LDAP_SLAPD_F (void) attr_free LDAP_P(( Attribute *a ));
137 LDAP_SLAPD_F (Attribute *) attr_dup LDAP_P(( Attribute *a ));
138
139 #ifdef SLAP_NVALUES
140 #define attr_mergeit( e, d, v ) attr_merge( e, d, v, NULL /* FIXME */ )
141 #define attr_mergeit_one( e, d, v ) attr_merge_one( e, d, v, NULL /* FIXME */ )
142
143 LDAP_SLAPD_F (int) attr_merge LDAP_P(( Entry *e,
144         AttributeDescription *desc,
145         BerVarray vals,
146         BerVarray nvals ));
147 LDAP_SLAPD_F (int) attr_merge_one LDAP_P(( Entry *e,
148         AttributeDescription *desc,
149         struct berval *val,
150         struct berval *nval ));
151 #else
152 #define attr_mergeit( e, d, v ) attr_merge( e, d, v )
153 #define attr_mergeit_one( e, d, v ) attr_merge_one( e, d, v )
154 LDAP_SLAPD_F (int) attr_merge LDAP_P(( Entry *e,
155         AttributeDescription *desc,
156         BerVarray vals ));
157 LDAP_SLAPD_F (int) attr_merge_one LDAP_P(( Entry *e,
158         AttributeDescription *desc,
159         struct berval *val ));
160 #endif
161 LDAP_SLAPD_F (Attribute *) attrs_find LDAP_P((
162         Attribute *a, AttributeDescription *desc ));
163 LDAP_SLAPD_F (Attribute *) attr_find LDAP_P((
164         Attribute *a, AttributeDescription *desc ));
165 LDAP_SLAPD_F (int) attr_delete LDAP_P((
166         Attribute **attrs, AttributeDescription *desc ));
167
168 LDAP_SLAPD_F (void) attrs_free LDAP_P(( Attribute *a ));
169 LDAP_SLAPD_F (Attribute *) attrs_dup LDAP_P(( Attribute *a ));
170
171
172 /*
173  * ava.c
174  */
175 LDAP_SLAPD_F (int) get_ava LDAP_P((
176         BerElement *ber,
177         AttributeAssertion **ava,
178         unsigned usage,
179         const char **text ));
180 LDAP_SLAPD_F (void) ava_free LDAP_P((
181         AttributeAssertion *ava,
182         int freeit ));
183
184 /*
185  * backend.c
186  */
187 LDAP_SLAPD_F (int) backend_init LDAP_P((void));
188 LDAP_SLAPD_F (int) backend_add LDAP_P((BackendInfo *aBackendInfo));
189 LDAP_SLAPD_F (int) backend_num LDAP_P((Backend *be));
190 LDAP_SLAPD_F (int) backend_startup LDAP_P((Backend *be));
191 LDAP_SLAPD_F (int) backend_sync LDAP_P((Backend *be));
192 LDAP_SLAPD_F (int) backend_shutdown LDAP_P((Backend *be));
193 LDAP_SLAPD_F (int) backend_destroy LDAP_P((void));
194
195 LDAP_SLAPD_F (BackendInfo *) backend_info LDAP_P(( const char *type ));
196 LDAP_SLAPD_F (BackendDB *) backend_db_init LDAP_P(( const char *type ));
197
198 LDAP_SLAPD_F (BackendDB *) select_backend LDAP_P((
199         struct berval * dn,
200         int manageDSAit,
201         int noSubordinates ));
202
203 LDAP_SLAPD_F (int) be_issuffix LDAP_P(( Backend *be,
204         struct berval *suffix ));
205 LDAP_SLAPD_F (int) be_isroot LDAP_P(( Backend *be,
206         struct berval *ndn ));
207 LDAP_SLAPD_F (int) be_isroot_pw LDAP_P(( Backend *be,
208         Connection *conn, struct berval *ndn, struct berval *cred ));
209 LDAP_SLAPD_F (int) be_isupdate LDAP_P(( Backend *be, struct berval *ndn ));
210 LDAP_SLAPD_F (struct berval *) be_root_dn LDAP_P(( Backend *be ));
211 LDAP_SLAPD_F (int) be_entry_release_rw LDAP_P((
212         BackendDB *be, Connection *c, Operation *o, Entry *e, int rw ));
213 #define be_entry_release_r( be, c, o, e ) be_entry_release_rw( be, c, o, e, 0 )
214 #define be_entry_release_w( be, c, o, e ) be_entry_release_rw( be, c, o, e, 1 )
215
216 LDAP_SLAPD_F (int) backend_unbind LDAP_P((Connection *conn, Operation *op));
217
218 LDAP_SLAPD_F( int )     backend_check_restrictions LDAP_P((
219         BackendDB *be,
220         Connection *conn,
221         Operation *op,
222         struct berval *opdata,
223         const char **text ));
224
225 LDAP_SLAPD_F( int )     backend_check_referrals LDAP_P((
226         BackendDB *be,
227         Connection *conn,
228         Operation *op,
229         struct berval *dn,
230         struct berval *ndn ));
231
232 LDAP_SLAPD_F (int) backend_connection_init LDAP_P((Connection *conn));
233 LDAP_SLAPD_F (int) backend_connection_destroy LDAP_P((Connection *conn));
234
235 LDAP_SLAPD_F (int) backend_group LDAP_P((BackendDB *be,
236         Connection *conn,
237         Operation *op,
238         Entry *target,
239         struct berval *gr_ndn,
240         struct berval *op_ndn,
241         ObjectClass *group_oc,
242         AttributeDescription *group_at
243 ));
244
245 LDAP_SLAPD_F (int) backend_attribute LDAP_P((BackendDB *be,
246         Connection *conn,
247         Operation *op,
248         Entry *target,
249         struct berval *entry_ndn,
250         AttributeDescription *entry_at,
251         BerVarray *vals
252 ));
253
254 LDAP_SLAPD_F (Attribute *) backend_operational(
255         BackendDB *,
256         Connection *conn,
257         Operation *op,
258         Entry *e,
259         AttributeName *attrs,
260         int opattrs );
261
262 /*
263  * backglue.c
264  */
265
266 LDAP_SLAPD_F (int) glue_back_initialize( BackendInfo *bi );
267 LDAP_SLAPD_F (int) glue_sub_init( void );
268
269 /*
270  * ch_malloc.c
271  */
272 #ifdef CSRIMALLOC
273 #define ch_malloc malloc
274 #define ch_realloc realloc
275 #define ch_calloc calloc
276 #define ch_strdup strdup
277 #define ch_free free
278
279 #else
280 LDAP_SLAPD_F (void *) ch_malloc LDAP_P(( ber_len_t size ));
281 LDAP_SLAPD_F (void *) ch_realloc LDAP_P(( void *block, ber_len_t size ));
282 LDAP_SLAPD_F (void *) ch_calloc LDAP_P(( ber_len_t nelem, ber_len_t size ));
283 LDAP_SLAPD_F (char *) ch_strdup LDAP_P(( const char *string ));
284 LDAP_SLAPD_F (void) ch_free LDAP_P(( void * ));
285
286 #ifndef CH_FREE
287 #undef free
288 #define free ch_free
289 #endif
290 #endif
291
292 /*
293  * controls.c
294  */
295 LDAP_SLAPD_F (int) get_ctrls LDAP_P((
296         Connection *co,
297         Operation *op,
298         int senderrors ));
299 LDAP_SLAPD_F (int) register_supported_control LDAP_P((
300         const char *controloid,
301         slap_mask_t controlmask,
302         char **controlexops,
303         SLAP_CTRL_PARSE_FN *controlparsefn ));
304 LDAP_SLAPD_F (int) slap_controls_init LDAP_P ((void));
305 LDAP_SLAPD_F (void) controls_destroy LDAP_P ((void));
306 LDAP_SLAPD_F (int) controls_root_dse_info LDAP_P ((Entry *e));
307 LDAP_SLAPD_F (int) get_supported_controls LDAP_P (( char ***ctrloidsp, slap_mask_t **ctrlmasks ));
308
309 /*
310  * config.c
311  */
312 LDAP_SLAPD_F (int) read_config LDAP_P(( const char *fname, int depth ));
313 LDAP_SLAPD_F (void) config_destroy LDAP_P ((void));
314
315 /*
316  * connection.c
317  */
318 LDAP_SLAPD_F (int) connections_init LDAP_P((void));
319 LDAP_SLAPD_F (int) connections_shutdown LDAP_P((void));
320 LDAP_SLAPD_F (int) connections_destroy LDAP_P((void));
321 LDAP_SLAPD_F (int) connections_timeout_idle LDAP_P((time_t));
322
323 LDAP_SLAPD_F (long) connection_init LDAP_P((
324         ber_socket_t s,
325         Listener* url,
326         const char* dnsname,
327         const char* peername,
328         int use_tls,
329         slap_ssf_t ssf,
330         const char *id ));
331
332 LDAP_SLAPD_F (void) connection_closing LDAP_P(( Connection *c ));
333 LDAP_SLAPD_F (int) connection_state_closing LDAP_P(( Connection *c ));
334 LDAP_SLAPD_F (const char *) connection_state2str LDAP_P(( int state ))
335         LDAP_GCCATTR((const));
336
337 LDAP_SLAPD_F (int) connection_write LDAP_P((ber_socket_t s));
338 LDAP_SLAPD_F (int) connection_read LDAP_P((ber_socket_t s));
339
340 LDAP_SLAPD_F (unsigned long) connections_nextid(void);
341
342 LDAP_SLAPD_F (Connection *) connection_first LDAP_P(( ber_socket_t * ));
343 LDAP_SLAPD_F (Connection *) connection_next LDAP_P((
344         Connection *, ber_socket_t *));
345 LDAP_SLAPD_F (void) connection_done LDAP_P((Connection *));
346
347 LDAP_SLAPD_F (void) connection2anonymous LDAP_P((Connection *));
348
349 /*
350  * cr.c
351  */
352 LDAP_SLAPD_F (int) cr_schema_info( Entry *e );
353
354 LDAP_SLAPD_F (int) cr_add LDAP_P((
355         LDAPContentRule *oc,
356         int user,
357         const char **err));
358 LDAP_SLAPD_F (void) cr_destroy LDAP_P(( void ));
359
360 LDAP_SLAPD_F (ContentRule *) cr_find LDAP_P((
361         const char *crname));
362 LDAP_SLAPD_F (ContentRule *) cr_bvfind LDAP_P((
363         struct berval *crname));
364
365 /*
366  * daemon.c
367  */
368 LDAP_SLAPD_F (void) slapd_add_internal(ber_socket_t s);
369 LDAP_SLAPD_F (int) slapd_daemon_init( const char *urls );
370 LDAP_SLAPD_F (int) slapd_daemon_destroy(void);
371 LDAP_SLAPD_F (int) slapd_daemon(void);
372 LDAP_SLAPD_F (Listener **)      slapd_get_listeners LDAP_P((void));
373 LDAP_SLAPD_F (void) slapd_remove LDAP_P((ber_socket_t s, int wake));
374
375 LDAP_SLAPD_F (RETSIGTYPE) slap_sig_shutdown LDAP_P((int sig));
376 LDAP_SLAPD_F (RETSIGTYPE) slap_sig_wake LDAP_P((int sig));
377
378 LDAP_SLAPD_F (void) slapd_set_write LDAP_P((ber_socket_t s, int wake));
379 LDAP_SLAPD_F (void) slapd_clr_write LDAP_P((ber_socket_t s, int wake));
380 LDAP_SLAPD_F (void) slapd_set_read LDAP_P((ber_socket_t s, int wake));
381 LDAP_SLAPD_F (void) slapd_clr_read LDAP_P((ber_socket_t s, int wake));
382
383 /*
384  * dn.c
385  */
386
387 #define dn_match(dn1, dn2)      ( ber_bvcmp((dn1), (dn2)) == 0 )
388 #define bvmatch(bv1, bv2)       ( ((bv1)->bv_len == (bv2)->bv_len) && (memcmp((bv1)->bv_val, (bv2)->bv_val, (bv1)->bv_len) == 0) )
389
390 LDAP_SLAPD_F (int) dnValidate LDAP_P((
391         Syntax *syntax, 
392         struct berval *val ));
393
394 #ifdef SLAP_NVALUES
395 LDAP_SLAPD_F (int) dnNormalize LDAP_P((
396         slap_mask_t use,
397         Syntax *syntax, 
398         MatchingRule *mr,
399         struct berval *val, 
400         struct berval *normalized ));
401 #define dnNormalize2(s,v,n)             dnNormalize(0,(s),NULL,(v),(n))
402 #else
403 LDAP_SLAPD_F (int) dnNormalize LDAP_P((
404         Syntax *syntax, 
405         struct berval *val, 
406         struct berval *normalized ));
407 #define dnNormalize2(s,v,n)             dnNormalize((s),(v),(n))
408 #endif
409
410 LDAP_SLAPD_F (int) dnPretty LDAP_P(( 
411         Syntax *syntax, 
412         struct berval *val, 
413         struct berval **pretty ));
414
415 LDAP_SLAPD_F (int) dnPretty2 LDAP_P(( 
416         Syntax *syntax, 
417         struct berval *val, 
418         struct berval *pretty ));
419
420 LDAP_SLAPD_F (int) dnPrettyNormal LDAP_P(( 
421         Syntax *syntax, 
422         struct berval *val, 
423         struct berval *pretty,
424         struct berval *normal ));
425
426 LDAP_SLAPD_F (int) dnMatch LDAP_P(( 
427         int *matchp, 
428         slap_mask_t flags, 
429         Syntax *syntax, 
430         MatchingRule *mr,
431         struct berval *value, 
432         void *assertedValue ));
433
434 LDAP_SLAPD_F (int) dnIsSuffix LDAP_P((
435         const struct berval *dn, const struct berval *suffix ));
436
437 LDAP_SLAPD_F (int) dnExtractRdn LDAP_P((
438         struct berval *dn, struct berval *rdn ));
439
440 LDAP_SLAPD_F (int) rdnValidate LDAP_P(( struct berval * rdn ));
441
442 LDAP_SLAPD_F (int) dn_rdnlen LDAP_P(( Backend *be, struct berval *dn ));
443
444 LDAP_SLAPD_F (void) build_new_dn LDAP_P((
445         struct berval * new_dn,
446         struct berval * parent_dn,
447         struct berval * newrdn ));
448
449 LDAP_SLAPD_F (void) dnParent LDAP_P(( struct berval *dn, struct berval *pdn ));
450
451 LDAP_SLAPD_F (int) dnX509normalize LDAP_P(( void *x509_name, struct berval *out ));
452
453 LDAP_SLAPD_F (int) dnX509peerNormalize LDAP_P(( void *ssl, struct berval *dn ));
454
455 LDAP_SLAPD_F (int) dnPrettyNormalDN LDAP_P(( Syntax *syntax, struct berval *val, LDAPDN **dn, int flags ));
456 #define dnPrettyDN(syntax, val, dn) \
457         dnPrettyNormalDN((syntax),(val),(dn), SLAP_LDAPDN_PRETTY)
458 #define dnNormalDN(syntax, val, dn) \
459         dnPrettyNormalDN((syntax),(val),(dn), 0)
460
461
462 /*
463  * entry.c
464  */
465 LDAP_SLAPD_V (const Entry) slap_entry_root;
466
467 LDAP_SLAPD_F (int) entry_destroy LDAP_P((void));
468
469 LDAP_SLAPD_F (Entry *) str2entry LDAP_P(( char  *s ));
470 LDAP_SLAPD_F (char *) entry2str LDAP_P(( Entry *e, int *len ));
471
472 LDAP_SLAPD_F (int) entry_decode LDAP_P(( struct berval *bv, Entry **e ));
473 LDAP_SLAPD_F (int) entry_encode LDAP_P(( Entry *e, struct berval *bv ));
474
475 LDAP_SLAPD_F (void) entry_free LDAP_P(( Entry *e ));
476 LDAP_SLAPD_F (int) entry_cmp LDAP_P(( Entry *a, Entry *b ));
477 LDAP_SLAPD_F (int) entry_dn_cmp LDAP_P(( const void *v_a, const void *v_b ));
478 LDAP_SLAPD_F (int) entry_id_cmp LDAP_P(( const void *v_a, const void *v_b ));
479
480 /*
481  * extended.c
482  */
483 #ifdef LDAP_EXOP_X_CANCEL
484 const struct berval slap_EXOP_CANCEL;
485 #endif
486 const struct berval slap_EXOP_WHOAMI;
487 const struct berval slap_EXOP_MODIFY_PASSWD;
488 const struct berval slap_EXOP_START_TLS;
489
490 typedef int (SLAP_EXTOP_MAIN_FN) LDAP_P((
491         Connection *conn, Operation *op,
492         struct berval * reqoid,
493         struct berval * reqdata,
494         char ** rspoid,
495         struct berval ** rspdata,
496         LDAPControl *** rspctrls,
497         const char ** text,
498         BerVarray *refs ));
499
500 typedef int (SLAP_EXTOP_GETOID_FN) LDAP_P((
501         int index, struct berval *oid, int blen ));
502
503 LDAP_SLAPD_F (int) load_extop LDAP_P((
504         struct berval *ext_oid,
505         SLAP_EXTOP_MAIN_FN *ext_main ));
506
507 LDAP_SLAPD_F (int) extops_init LDAP_P(( void ));
508
509 LDAP_SLAPD_F (int) extops_kill LDAP_P(( void ));
510
511 LDAP_SLAPD_F (struct berval *) get_supported_extop LDAP_P((int index));
512
513 /*
514  *  * cancel.c
515  *   */
516 LDAP_SLAPD_F ( SLAP_EXTOP_MAIN_FN ) cancel_extop;
517
518 /*
519  * filter.c
520  */
521 LDAP_SLAPD_F (int) get_filter LDAP_P((
522         Connection *conn,
523         BerElement *ber,
524         Filter **filt,
525         const char **text ));
526
527 LDAP_SLAPD_F (void) filter_free LDAP_P(( Filter *f ));
528 LDAP_SLAPD_F (void) filter2bv LDAP_P(( Filter *f, struct berval *bv ));
529
530 LDAP_SLAPD_F (int) get_vrFilter LDAP_P(( Connection *conn, BerElement *ber,
531         ValuesReturnFilter **f,
532         const char **text ));
533
534 LDAP_SLAPD_F (void) vrFilter_free LDAP_P(( ValuesReturnFilter *f ));
535 LDAP_SLAPD_F (void) vrFilter2bv LDAP_P(( ValuesReturnFilter *f, struct berval *fstr ));
536
537 LDAP_SLAPD_F (int) filter_has_subordinates LDAP_P(( Filter *filter ));
538 LDAP_SLAPD_F (int) filter_escape_value LDAP_P(( struct berval *in, 
539         struct berval *out ));
540
541 /*
542  * filterentry.c
543  */
544
545 LDAP_SLAPD_F (int) test_filter LDAP_P((
546         Backend *be, Connection *conn, Operation *op,
547         Entry *e, Filter *f ));
548
549 /*
550  * globals.c
551  */
552
553 LDAP_SLAPD_V( const struct berval ) slap_empty_bv;
554 LDAP_SLAPD_V( const struct berval ) slap_unknown_bv;
555
556 /*
557  * index.c
558  */
559 LDAP_SLAPD_F (int) slap_str2index LDAP_P(( const char *str, slap_mask_t *idx ));
560
561 /*
562  * init.c
563  */
564 LDAP_SLAPD_F (int)      slap_init LDAP_P((int mode, const char* name));
565 LDAP_SLAPD_F (int)      slap_startup LDAP_P(( Backend *be ));
566 LDAP_SLAPD_F (int)      slap_shutdown LDAP_P(( Backend *be ));
567 LDAP_SLAPD_F (int)      slap_destroy LDAP_P((void));
568
569 LDAP_SLAPD_V (char **)  slap_known_controls;
570
571 /*
572  * kerberos.c
573  */
574 #ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND
575 LDAP_SLAPD_V (char *)   ldap_srvtab;
576 LDAP_SLAPD_V (int)      krbv4_ldap_auth();
577 #endif
578
579 /*
580  * limits.c
581  */
582 LDAP_SLAPD_F (int) get_limits LDAP_P((
583         Backend *be, struct berval *ndn,
584         struct slap_limits_set **limit ));
585 LDAP_SLAPD_F (int) parse_limits LDAP_P((
586         Backend *be, const char *fname, int lineno,
587         int argc, char **argv ));
588 LDAP_SLAPD_F (int) parse_limit LDAP_P(( const char *arg, 
589         struct slap_limits_set *limit ));
590
591 /*
592  * lock.c
593  */
594 LDAP_SLAPD_F (FILE *) lock_fopen LDAP_P(( const char *fname,
595         const char *type, FILE **lfp ));
596 LDAP_SLAPD_F (int) lock_fclose LDAP_P(( FILE *fp, FILE *lfp ));
597
598 /*
599  * matchedValues.c
600  */
601 LDAP_SLAPD_F (int) filter_matched_values( 
602         Backend         *be,
603         Connection      *conn,
604         Operation       *op,
605         Attribute       *a,
606         char            ***e_flags );
607
608 /*
609  * modrdn.c
610  */
611 LDAP_SLAPD_F (int) slap_modrdn2mods(
612         Backend         *be,
613         Connection      *conn,
614         Operation       *op,
615         Entry           *e,
616         LDAPRDN         *oldrdn,
617         LDAPRDN         *newrdn,
618         int             deleteoldrdn,
619         Modifications   **pmod );
620
621 /*
622  * modify.c
623  */
624 LDAP_SLAPD_F( int ) slap_mods_check(
625         Modifications *ml,
626         int update,
627         const char **text,
628         char *textbuf, size_t textlen );
629
630 LDAP_SLAPD_F( int ) slap_mods_opattrs(
631         Backend *be,
632         Operation *op,
633         Modifications *mods,
634         Modifications **modlist,
635         const char **text,
636         char *textbuf, size_t textlen );
637
638 /*
639  * mods.c
640  */
641 LDAP_SLAPD_F( int ) modify_check_duplicates(
642         AttributeDescription *ad, MatchingRule *mr, 
643         BerVarray vals, BerVarray mods, int permissive, 
644         const char **text, char *textbuf, size_t textlen );
645 LDAP_SLAPD_F( int ) modify_add_values( Entry *e,
646         Modification *mod,
647         int permissive,
648         const char **text, char *textbuf, size_t textlen );
649 LDAP_SLAPD_F( int ) modify_delete_values( Entry *e,
650         Modification *mod,
651         int permissive,
652         const char **text, char *textbuf, size_t textlen );
653 LDAP_SLAPD_F( int ) modify_replace_values( Entry *e,
654         Modification *mod,
655         int permissive,
656         const char **text, char *textbuf, size_t textlen );
657
658 LDAP_SLAPD_F( void ) slap_mod_free( Modification *mod, int freeit );
659 LDAP_SLAPD_F( void ) slap_mods_free( Modifications *mods );
660 LDAP_SLAPD_F( void ) slap_modlist_free( LDAPModList *ml );
661
662 /*
663  * module.c
664  */
665 #ifdef SLAPD_MODULES
666
667 LDAP_SLAPD_F (int) module_init LDAP_P(( void ));
668 LDAP_SLAPD_F (int) module_kill LDAP_P(( void ));
669
670 LDAP_SLAPD_F (int) load_null_module(
671         const void *module, const char *file_name);
672 LDAP_SLAPD_F (int) load_extop_module(
673         const void *module, const char *file_name);
674
675 LDAP_SLAPD_F (int) module_load LDAP_P((
676         const char* file_name,
677         int argc, char *argv[] ));
678 LDAP_SLAPD_F (int) module_path LDAP_P(( const char* path ));
679
680 LDAP_SLAPD_F (void) *module_resolve LDAP_P((
681         const void *module, const char *name));
682
683 #endif /* SLAPD_MODULES */
684
685 /* mr.c */
686 LDAP_SLAPD_F (MatchingRule *) mr_bvfind LDAP_P((struct berval *mrname));
687 LDAP_SLAPD_F (MatchingRule *) mr_find LDAP_P((const char *mrname));
688 LDAP_SLAPD_F (int) mr_add LDAP_P(( LDAPMatchingRule *mr,
689         slap_mrule_defs_rec *def,
690         MatchingRule * associated,
691         const char **err ));
692 LDAP_SLAPD_F (void) mr_destroy LDAP_P(( void ));
693
694 LDAP_SLAPD_F (int) register_matching_rule LDAP_P((
695         slap_mrule_defs_rec *def ));
696
697 LDAP_SLAPD_F (void) mru_destroy LDAP_P(( void ));
698 LDAP_SLAPD_F (int) matching_rule_use_init LDAP_P(( void ));
699
700 LDAP_SLAPD_F (int) mr_schema_info( Entry *e );
701 LDAP_SLAPD_F (int) mru_schema_info( Entry *e );
702
703 LDAP_SLAPD_F (int) mr_usable_with_at( MatchingRule *mr,
704         AttributeType *at );
705
706 /*
707  * mra.c
708  */
709 LDAP_SLAPD_F (int) get_mra LDAP_P((
710         BerElement *ber,
711         MatchingRuleAssertion **mra,
712         const char **text ));
713 LDAP_SLAPD_F (void) mra_free LDAP_P((
714         MatchingRuleAssertion *mra,
715         int freeit ));
716
717 /* oc.c */
718 LDAP_SLAPD_F (int) oc_add LDAP_P((
719         LDAPObjectClass *oc,
720         int user,
721         const char **err));
722 LDAP_SLAPD_F (void) oc_destroy LDAP_P(( void ));
723
724 LDAP_SLAPD_F (ObjectClass *) oc_find LDAP_P((
725         const char *ocname));
726 LDAP_SLAPD_F (ObjectClass *) oc_bvfind LDAP_P((
727         struct berval *ocname));
728 LDAP_SLAPD_F (int) is_object_subclass LDAP_P((
729         ObjectClass *sup,
730         ObjectClass *sub ));
731
732 LDAP_SLAPD_F (int) is_entry_objectclass LDAP_P((
733         Entry *, ObjectClass *oc, int set_flags ));
734 #define is_entry_alias(e)               \
735         (((e)->e_ocflags & SLAP_OC__END) \
736          ? (((e)->e_ocflags & SLAP_OC_ALIAS) != 0) \
737          : is_entry_objectclass((e), slap_schema.si_oc_alias, 1))
738 #define is_entry_referral(e)    \
739         (((e)->e_ocflags & SLAP_OC__END) \
740          ? (((e)->e_ocflags & SLAP_OC_REFERRAL) != 0) \
741          : is_entry_objectclass((e), slap_schema.si_oc_referral, 1))
742 #define is_entry_subentry(e)    \
743         (((e)->e_ocflags & SLAP_OC__END) \
744          ? (((e)->e_ocflags & SLAP_OC_SUBENTRY) != 0) \
745          : is_entry_objectclass((e), slap_schema.si_oc_subentry, 1))
746 #define is_entry_collectiveAttributeSubentry(e) \
747         (((e)->e_ocflags & SLAP_OC__END) \
748          ? (((e)->e_ocflags & SLAP_OC_COLLECTIVEATTRIBUTESUBENTRY) != 0) \
749          : is_entry_objectclass((e), slap_schema.si_oc_collectiveAttributeSubentry, 1))
750 #define is_entry_dynamicObject(e)       \
751         (((e)->e_ocflags & SLAP_OC__END) \
752          ? (((e)->e_ocflags & SLAP_OC_DYNAMICOBJECT) != 0) \
753          : is_entry_objectclass((e), slap_schema.si_oc_dynamicObject, 1))
754
755 LDAP_SLAPD_F (int) oc_schema_info( Entry *e );
756
757 /*
758  * oidm.c
759  */
760 LDAP_SLAPD_F(char *) oidm_find(char *oid);
761 LDAP_SLAPD_F (void) oidm_destroy LDAP_P(( void ));
762 LDAP_SLAPD_F (int) parse_oidm LDAP_P((
763         const char *fname, int lineno, int argc, char **argv ));
764
765 /*
766  * operation.c
767  */
768 LDAP_SLAPD_F (void) slap_op_free LDAP_P(( Operation *op ));
769 LDAP_SLAPD_F (Operation *) slap_op_alloc LDAP_P((
770         BerElement *ber, ber_int_t msgid,
771         ber_tag_t tag, ber_int_t id ));
772
773 LDAP_SLAPD_F (int) slap_op_add LDAP_P(( Operation **olist, Operation *op ));
774 LDAP_SLAPD_F (int) slap_op_remove LDAP_P(( Operation **olist, Operation *op ));
775 LDAP_SLAPD_F (Operation *) slap_op_pop LDAP_P(( Operation **olist ));
776
777 /*
778  * operational.c
779  */
780 LDAP_SLAPD_F (Attribute *) slap_operational_subschemaSubentry( Backend *be );
781 LDAP_SLAPD_F (Attribute *) slap_operational_hasSubordinate( int has );
782
783 /*
784  * passwd.c
785  */
786 LDAP_SLAPD_F (SLAP_EXTOP_MAIN_FN) passwd_extop;
787
788 LDAP_SLAPD_F (int) slap_passwd_check(
789         Connection                      *conn,
790         Attribute                       *attr,
791         struct berval           *cred );
792
793 LDAP_SLAPD_F (void) slap_passwd_generate( struct berval * );
794
795 LDAP_SLAPD_F (void) slap_passwd_hash(
796         struct berval           *cred,
797         struct berval           *hash );
798
799 LDAP_SLAPD_F (struct berval *) slap_passwd_return(
800         struct berval           *cred );
801
802 LDAP_SLAPD_F (int) slap_passwd_parse(
803         struct berval *reqdata,
804         struct berval *id,
805         struct berval *oldpass,
806         struct berval *newpass,
807         const char **text );
808
809 /*
810  * phonetic.c
811  */
812 LDAP_SLAPD_F (char *) phonetic LDAP_P(( char *s ));
813
814 /*
815  * referral.c
816  */
817 LDAP_SLAPD_F (int) validate_global_referral LDAP_P((
818         const char *url ));
819
820 LDAP_SLAPD_F (BerVarray) get_entry_referrals LDAP_P((
821         Backend *be, Connection *conn, Operation *op, Entry *e ));
822
823 LDAP_SLAPD_F (BerVarray) referral_rewrite LDAP_P((
824         BerVarray refs,
825         struct berval *base,
826         struct berval *target,
827         int scope ));
828
829 /*
830  * repl.c
831  */
832 LDAP_SLAPD_F (int) add_replica_info LDAP_P(( Backend *be,
833         const char *host ));
834 LDAP_SLAPD_F (int) add_replica_suffix LDAP_P(( Backend *be,
835         int nr, const char *suffix ));
836 LDAP_SLAPD_F (int) add_replica_attrs LDAP_P(( Backend *be,
837         int nr, char *attrs, int exclude ));
838 LDAP_SLAPD_F (void) replog LDAP_P(( Backend *be, Operation *op,
839         struct berval *dn, struct berval *ndn, void *change ));
840
841 /*
842  * result.c
843  */
844 LDAP_SLAPD_F (void) slap_send_ldap_result LDAP_P((
845         Connection *conn, Operation *op,
846         ber_int_t err, const char *matched, const char *text,
847         BerVarray refs,
848         LDAPControl **ctrls ));
849
850 LDAP_SLAPD_F (void) send_ldap_sasl LDAP_P((
851         Connection *conn, Operation *op,
852         ber_int_t err, const char *matched,
853         const char *text,
854         BerVarray refs,
855         LDAPControl **ctrls,
856         struct berval *cred ));
857
858 LDAP_SLAPD_F (void) send_ldap_disconnect LDAP_P((
859         Connection *conn, Operation *op,
860         ber_int_t err, const char *text ));
861
862 LDAP_SLAPD_F (void) slap_send_ldap_extended LDAP_P((
863         Connection *conn, Operation *op,
864         ber_int_t err, const char *matched,
865         const char *text, BerVarray refs,
866         const char *rspoid, struct berval *rspdata,
867         LDAPControl **ctrls ));
868
869 LDAP_SLAPD_F (void) slap_send_ldap_intermediate_resp LDAP_P((
870         Connection *conn, Operation *op,
871         ber_int_t err, const char *matched,
872         const char *text, BerVarray refs,
873         const char *rspoid, struct berval *rspdata,
874         LDAPControl **ctrls ));
875
876 LDAP_SLAPD_F (void) send_ldap_partial LDAP_P((
877         Connection *conn, Operation *op,
878         const char *rspoid, struct berval *rspdata,
879         LDAPControl **ctrls ));
880
881 LDAP_SLAPD_F (void) slap_send_search_result LDAP_P((
882         Connection *conn, Operation *op,
883         ber_int_t err, const char *matched, const char *text,
884         BerVarray refs,
885         LDAPControl **ctrls,
886         int nentries ));
887
888 LDAP_SLAPD_F (int) slap_send_search_reference LDAP_P((
889         Backend *be, Connection *conn, Operation *op,
890         Entry *e, BerVarray refs,
891         LDAPControl **ctrls,
892         BerVarray *v2refs ));
893
894 LDAP_SLAPD_F (int) slap_send_search_entry LDAP_P((
895         Backend *be, Connection *conn, Operation *op,
896         Entry *e, AttributeName *attrs, int attrsonly,
897         LDAPControl **ctrls ));
898
899 LDAP_SLAPD_F (int) str2result LDAP_P(( char *s,
900         int *code, char **matched, char **info ));
901
902 /*
903  * root_dse.c
904  */
905 LDAP_SLAPD_F (int) root_dse_info LDAP_P((
906         Connection *conn,
907         Entry **e,
908         const char **text ));
909
910 LDAP_SLAPD_F (int) read_root_dse_file LDAP_P((
911         const char *file));
912
913 /*
914  * sasl.c
915  */
916 LDAP_SLAPD_F (int) slap_sasl_init(void);
917 LDAP_SLAPD_F (char *) slap_sasl_secprops( const char * );
918 LDAP_SLAPD_F (int) slap_sasl_destroy(void);
919
920 LDAP_SLAPD_F (int) slap_sasl_open( Connection *c );
921 LDAP_SLAPD_F (char **) slap_sasl_mechs( Connection *c );
922
923 LDAP_SLAPD_F (int) slap_sasl_external( Connection *c,
924         slap_ssf_t ssf, /* relative strength of external security */
925         const char *authid );   /* asserted authenication id */
926
927 LDAP_SLAPD_F (int) slap_sasl_reset( Connection *c );
928 LDAP_SLAPD_F (int) slap_sasl_close( Connection *c );
929
930 LDAP_SLAPD_F (int) slap_sasl_bind LDAP_P((
931         Connection *conn, Operation *op, 
932         struct berval *dn, struct berval *ndn,
933         struct berval *cred,
934         struct berval *edn, slap_ssf_t *ssf ));
935
936 LDAP_SLAPD_F (int) slap_sasl_setpass(
937         Connection      *conn,
938         Operation       *op,
939         struct berval   *reqoid,
940         struct berval   *reqdata,
941         char            **rspoid,
942         struct berval   **rspdata,
943         LDAPControl     *** rspctrls,
944         const char      **text );
945
946 LDAP_SLAPD_F (int) slap_sasl_config(
947         int cargc,
948         char **cargv,
949         char *line,
950         const char *fname,
951         int lineno );
952
953 LDAP_SLAPD_F (int) slap_sasl_getdn( Connection *conn,
954         char *id, int len,
955         char *user_realm, struct berval *dn, int flags );
956
957 /*
958  * saslauthz.c
959  */
960 LDAP_SLAPD_F (void) slap_sasl2dn LDAP_P((
961         Connection *conn,
962         struct berval *saslname,
963         struct berval *dn ));
964 LDAP_SLAPD_F (int) slap_sasl_authorized LDAP_P((
965         Connection *conn,
966         struct berval *authcid,
967         struct berval *authzid ));
968 LDAP_SLAPD_F (int) slap_sasl_regexp_config LDAP_P((
969         const char *match, const char *replace ));
970 LDAP_SLAPD_F (int) slap_sasl_setpolicy LDAP_P(( const char * ));
971 LDAP_SLAPD_F (slap_response) slap_cb_null_response;
972 LDAP_SLAPD_F (slap_sresult) slap_cb_null_sresult;
973 LDAP_SLAPD_F (slap_sendreference) slap_cb_null_sreference;
974
975
976 /*
977  * schema.c
978  */
979 LDAP_SLAPD_F (int) schema_info LDAP_P(( Entry **entry, const char **text ));
980
981 /*
982  * schema_check.c
983  */
984 LDAP_SLAPD_F( int ) oc_check_allowed(
985         AttributeType *type,
986         BerVarray oclist,
987         ObjectClass *sc );
988
989 LDAP_SLAPD_F( int ) structural_class(
990         BerVarray ocs,
991         struct berval *scbv,
992         ObjectClass **sc,
993         const char **text,
994         char *textbuf, size_t textlen );
995
996 LDAP_SLAPD_F( int ) entry_schema_check(
997         Backend *be, Entry *e, Attribute *attrs,
998         const char** text,
999         char *textbuf, size_t textlen );
1000
1001 LDAP_SLAPD_F( int ) mods_structural_class(
1002         Modifications *mods,
1003         struct berval *oc,
1004         const char** text,
1005         char *textbuf, size_t textlen );
1006
1007 /*
1008  * schema_init.c
1009  */
1010 LDAP_SLAPD_V( int ) schema_init_done;
1011 LDAP_SLAPD_F (int) slap_schema_init LDAP_P((void));
1012 LDAP_SLAPD_F (void) schema_destroy LDAP_P(( void ));
1013
1014 LDAP_SLAPD_F( int ) octetStringIndexer(
1015         slap_mask_t use,
1016         slap_mask_t flags,
1017         Syntax *syntax,
1018         MatchingRule *mr,
1019         struct berval *prefix,
1020         BerVarray values,
1021         BerVarray *keysp );
1022
1023 LDAP_SLAPD_F( int ) octetStringFilter(
1024         slap_mask_t use,
1025         slap_mask_t flags,
1026         Syntax *syntax,
1027         MatchingRule *mr,
1028         struct berval *prefix,
1029         void * assertValue,
1030         BerVarray *keysp );
1031
1032 /*
1033  * schema_prep.c
1034  */
1035 LDAP_SLAPD_V( struct slap_internal_schema ) slap_schema;
1036 LDAP_SLAPD_F (int) slap_schema_load LDAP_P((void));
1037 LDAP_SLAPD_F (int) slap_schema_check LDAP_P((void));
1038
1039 /*
1040  * schemaparse.c
1041  */
1042 LDAP_SLAPD_F( int ) slap_valid_descr( const char * );
1043
1044 LDAP_SLAPD_F (int) parse_cr LDAP_P((
1045         const char *fname, int lineno, char *line, char **argv ));
1046 LDAP_SLAPD_F (int) parse_oc LDAP_P((
1047         const char *fname, int lineno, char *line, char **argv ));
1048 LDAP_SLAPD_F (int) parse_at LDAP_P((
1049         const char *fname, int lineno, char *line, char **argv ));
1050 LDAP_SLAPD_F (char *) scherr2str LDAP_P((int code)) LDAP_GCCATTR((const));
1051 LDAP_SLAPD_F (int) dscompare LDAP_P(( const char *s1, const char *s2del,
1052         char delim ));
1053
1054 /*
1055  * starttls.c
1056  */
1057 LDAP_SLAPD_F (SLAP_EXTOP_MAIN_FN) starttls_extop;
1058
1059 /*
1060  * str2filter.c
1061  */
1062 LDAP_SLAPD_F (Filter *) str2filter LDAP_P(( const char *str ));
1063
1064 /* syntax.c */
1065 LDAP_SLAPD_F (Syntax *) syn_find LDAP_P((
1066         const char *synname ));
1067 LDAP_SLAPD_F (Syntax *) syn_find_desc LDAP_P((
1068         const char *syndesc, int *slen ));
1069 LDAP_SLAPD_F (int) syn_add LDAP_P((
1070         LDAPSyntax *syn,
1071         slap_syntax_defs_rec *def,
1072         const char **err ));
1073 LDAP_SLAPD_F (void) syn_destroy LDAP_P(( void ));
1074
1075 LDAP_SLAPD_F (int) register_syntax LDAP_P((
1076         slap_syntax_defs_rec *def ));
1077
1078 LDAP_SLAPD_F (int) syn_schema_info( Entry *e );
1079
1080 /*
1081  * user.c
1082  */
1083 #if defined(HAVE_PWD_H) && defined(HAVE_GRP_H)
1084 LDAP_SLAPD_F (void) slap_init_user LDAP_P(( char *username, char *groupname ));
1085 #endif
1086
1087 /*
1088  * value.c
1089  */
1090 #ifdef SLAP_NVALUES
1091 LDAP_SLAPD_F (int) asserted_value_validate_normalize LDAP_P((
1092         AttributeDescription *ad,
1093         MatchingRule *mr,
1094         unsigned usage,
1095         struct berval *in,
1096         struct berval *out,
1097         const char ** text ));
1098 #else
1099 LDAP_SLAPD_F (int) value_validate LDAP_P((
1100         MatchingRule *mr,
1101         struct berval *in,
1102         const char ** text ));
1103 LDAP_SLAPD_F (int) value_normalize LDAP_P((
1104         AttributeDescription *ad,
1105         unsigned usage,
1106         struct berval *in,
1107         struct berval *out,
1108         const char ** text ));
1109 LDAP_SLAPD_F (int) value_validate_normalize LDAP_P((
1110         AttributeDescription *ad,
1111         unsigned usage,
1112         struct berval *in,
1113         struct berval *out,
1114         const char ** text ));
1115 #define value_find(ad,values,value) (value_find_ex((ad),0,(values),(value)))
1116 #endif
1117
1118 LDAP_SLAPD_F (int) value_match LDAP_P((
1119         int *match,
1120         AttributeDescription *ad,
1121         MatchingRule *mr,
1122         unsigned flags,
1123         struct berval *v1,
1124         void *v2,
1125         const char ** text ));
1126 LDAP_SLAPD_F (int) value_find_ex LDAP_P((
1127         AttributeDescription *ad,
1128         unsigned flags,
1129         BerVarray values,
1130         struct berval *value ));
1131
1132 LDAP_SLAPD_F (int) value_add LDAP_P((
1133         BerVarray *vals,
1134         BerVarray addvals ));
1135 LDAP_SLAPD_F (int) value_add_one LDAP_P((
1136         BerVarray *vals,
1137         struct berval *addval ));
1138
1139 /*
1140  * Other...
1141  */
1142 LDAP_SLAPD_V(unsigned) num_subordinates;
1143
1144 LDAP_SLAPD_V (ber_len_t) sockbuf_max_incoming;
1145 LDAP_SLAPD_V (ber_len_t) sockbuf_max_incoming_auth;
1146
1147 LDAP_SLAPD_V (slap_mask_t)      global_restrictops;
1148 LDAP_SLAPD_V (slap_mask_t)      global_allows;
1149 LDAP_SLAPD_V (slap_mask_t)      global_disallows;
1150 LDAP_SLAPD_V (slap_mask_t)      global_requires;
1151 LDAP_SLAPD_V (slap_ssf_set_t)   global_ssf_set;
1152
1153 LDAP_SLAPD_V (BerVarray)                default_referral;
1154 LDAP_SLAPD_V (char *)           replogfile;
1155 LDAP_SLAPD_V (const char)       Versionstr[];
1156 LDAP_SLAPD_V (struct slap_limits_set)           deflimit;
1157
1158 LDAP_SLAPD_V (slap_access_t)    global_default_access;
1159 LDAP_SLAPD_V (int)              global_gentlehup;
1160 LDAP_SLAPD_V (int)              global_idletimeout;
1161 LDAP_SLAPD_V (int)              global_schemacheck;
1162 LDAP_SLAPD_V (char *)   global_host;
1163 LDAP_SLAPD_V (char *)   global_realm;
1164 LDAP_SLAPD_V (char *)   default_passwd_hash;
1165 LDAP_SLAPD_V (int)              lber_debug;
1166 LDAP_SLAPD_V (int)              ldap_syslog;
1167 LDAP_SLAPD_V (struct berval)    default_search_base;
1168 LDAP_SLAPD_V (struct berval)    default_search_nbase;
1169
1170 LDAP_SLAPD_V (struct berval)    global_schemadn;
1171 LDAP_SLAPD_V (struct berval)    global_schemandn;
1172
1173 LDAP_SLAPD_V (ldap_pvt_thread_mutex_t)  num_sent_mutex;
1174 LDAP_SLAPD_V (unsigned long)            num_bytes_sent;
1175 LDAP_SLAPD_V (unsigned long)            num_pdu_sent;
1176 LDAP_SLAPD_V (unsigned long)            num_entries_sent;
1177 LDAP_SLAPD_V (unsigned long)            num_refs_sent;
1178
1179 LDAP_SLAPD_V (ldap_pvt_thread_mutex_t)  num_ops_mutex;
1180 LDAP_SLAPD_V (unsigned long)            num_ops_completed;
1181 LDAP_SLAPD_V (unsigned long)            num_ops_initiated;
1182 #ifdef SLAPD_MONITOR
1183 LDAP_SLAPD_V (unsigned long)            num_ops_completed_[SLAP_OP_LAST];
1184 LDAP_SLAPD_V (unsigned long)            num_ops_initiated_[SLAP_OP_LAST];
1185 #endif /* SLAPD_MONITOR */
1186
1187 LDAP_SLAPD_V (char *)           slapd_pid_file;
1188 LDAP_SLAPD_V (char *)           slapd_args_file;
1189 LDAP_SLAPD_V (time_t)           starttime;
1190
1191 /* use time(3) -- no mutex */
1192 #define slap_get_time() time( NULL )
1193
1194 LDAP_SLAPD_V (ldap_pvt_thread_pool_t)   connection_pool;
1195 LDAP_SLAPD_V (int)                      connection_pool_max;
1196
1197 LDAP_SLAPD_V (ldap_pvt_thread_mutex_t)  entry2str_mutex;
1198 LDAP_SLAPD_V (ldap_pvt_thread_mutex_t)  replog_mutex;
1199
1200 #if defined( SLAPD_CRYPT ) || defined( SLAPD_SPASSWD )
1201 LDAP_SLAPD_V (ldap_pvt_thread_mutex_t)  passwd_mutex;
1202 #endif
1203 LDAP_SLAPD_V (ldap_pvt_thread_mutex_t)  gmtime_mutex;
1204
1205 LDAP_SLAPD_V (AccessControl *) global_acl;
1206
1207 LDAP_SLAPD_V (ber_socket_t)     dtblsize;
1208
1209 LDAP_SLAPD_V (int)              use_reverse_lookup;
1210
1211 LDAP_SLAPD_V (struct berval)    AllUser;
1212 LDAP_SLAPD_V (struct berval)    AllOper;
1213 LDAP_SLAPD_V (struct berval)    NoAttrs;
1214
1215 /*
1216  * operations
1217  */
1218 LDAP_SLAPD_F (int) do_abandon LDAP_P((Connection *conn, Operation *op));
1219 LDAP_SLAPD_F (int) do_add LDAP_P((Connection *conn, Operation *op));
1220 LDAP_SLAPD_F (int) do_bind LDAP_P((Connection *conn, Operation *op));
1221 LDAP_SLAPD_F (int) do_compare LDAP_P((Connection *conn, Operation *op));
1222 LDAP_SLAPD_F (int) do_delete LDAP_P((Connection *conn, Operation *op));
1223 LDAP_SLAPD_F (int) do_modify LDAP_P((Connection *conn, Operation *op));
1224 LDAP_SLAPD_F (int) do_modrdn LDAP_P((Connection *conn, Operation *op));
1225 LDAP_SLAPD_F (int) do_search LDAP_P((Connection *conn, Operation *op));
1226 LDAP_SLAPD_F (int) do_unbind LDAP_P((Connection *conn, Operation *op));
1227 LDAP_SLAPD_F (int) do_extended LDAP_P((Connection *conn, Operation *op));
1228
1229 LDAP_END_DECL
1230
1231 #endif /* PROTO_SLAP_H */
1232