1 /* $NetBSD: proto-slap.h,v 1.1.1.5 2014/05/28 09:58:47 tron Exp $ */ 2 3 /* $OpenLDAP$ */ 4 /* This work is part of OpenLDAP Software <http://www.openldap.org/>. 5 * 6 * Copyright 1998-2014 The OpenLDAP Foundation. 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted only as authorized by the OpenLDAP 11 * Public License. 12 * 13 * A copy of this license is available in the file LICENSE in the 14 * top-level directory of the distribution or, alternatively, at 15 * <http://www.OpenLDAP.org/license.html>. 16 */ 17 /* Portions Copyright (c) 1995 Regents of the University of Michigan. 18 * All rights reserved. 19 * 20 * Redistribution and use in source and binary forms are permitted 21 * provided that this notice is preserved and that due credit is given 22 * to the University of Michigan at Ann Arbor. The name of the University 23 * may not be used to endorse or promote products derived from this 24 * software without specific prior written permission. This software 25 * is provided ``as is'' without express or implied warranty. 26 */ 27 28 #ifndef PROTO_SLAP_H 29 #define PROTO_SLAP_H 30 31 #include <ldap_cdefs.h> 32 #include "ldap_pvt.h" 33 34 LDAP_BEGIN_DECL 35 36 struct config_args_s; /* config.h */ 37 struct config_reply_s; /* config.h */ 38 39 /* 40 * aci.c 41 */ 42 #ifdef SLAP_DYNACL 43 #ifdef SLAPD_ACI_ENABLED 44 LDAP_SLAPD_F (int) dynacl_aci_init LDAP_P(( void )); 45 #endif /* SLAPD_ACI_ENABLED */ 46 #endif /* SLAP_DYNACL */ 47 48 /* 49 * acl.c 50 */ 51 LDAP_SLAPD_F (int) access_allowed_mask LDAP_P(( 52 Operation *op, 53 Entry *e, AttributeDescription *desc, struct berval *val, 54 slap_access_t access, 55 AccessControlState *state, 56 slap_mask_t *mask )); 57 #define access_allowed(op,e,desc,val,access,state) access_allowed_mask(op,e,desc,val,access,state,NULL) 58 LDAP_SLAPD_F (int) slap_access_allowed LDAP_P(( 59 Operation *op, 60 Entry *e, 61 AttributeDescription *desc, 62 struct berval *val, 63 slap_access_t access, 64 AccessControlState *state, 65 slap_mask_t *maskp )); 66 LDAP_SLAPD_F (int) slap_access_always_allowed LDAP_P(( 67 Operation *op, 68 Entry *e, 69 AttributeDescription *desc, 70 struct berval *val, 71 slap_access_t access, 72 AccessControlState *state, 73 slap_mask_t *maskp )); 74 75 LDAP_SLAPD_F (int) acl_check_modlist LDAP_P(( 76 Operation *op, Entry *e, Modifications *ml )); 77 78 LDAP_SLAPD_F (void) acl_append( AccessControl **l, AccessControl *a, int pos ); 79 80 #ifdef SLAP_DYNACL 81 LDAP_SLAPD_F (int) slap_dynacl_register LDAP_P(( slap_dynacl_t *da )); 82 LDAP_SLAPD_F (slap_dynacl_t *) slap_dynacl_get LDAP_P(( const char *name )); 83 #endif /* SLAP_DYNACL */ 84 LDAP_SLAPD_F (int) acl_init LDAP_P(( void )); 85 86 LDAP_SLAPD_F (int) acl_get_part LDAP_P(( 87 struct berval *list, 88 int ix, 89 char sep, 90 struct berval *bv )); 91 LDAP_SLAPD_F (int) acl_match_set LDAP_P(( 92 struct berval *subj, 93 Operation *op, 94 Entry *e, 95 struct berval *default_set_attribute )); 96 LDAP_SLAPD_F (int) acl_string_expand LDAP_P(( 97 struct berval *newbuf, struct berval *pattern, 98 struct berval *dnmatch, struct berval *valmatch, AclRegexMatches *matches )); 99 100 /* 101 * aclparse.c 102 */ 103 LDAP_SLAPD_V (LDAP_CONST char *) style_strings[]; 104 105 LDAP_SLAPD_F (int) parse_acl LDAP_P(( Backend *be, 106 const char *fname, int lineno, 107 int argc, char **argv, int pos )); 108 109 LDAP_SLAPD_F (char *) access2str LDAP_P(( slap_access_t access )); 110 LDAP_SLAPD_F (slap_access_t) str2access LDAP_P(( const char *str )); 111 112 #define ACCESSMASK_MAXLEN sizeof("unknown (+wrscan)") 113 LDAP_SLAPD_F (char *) accessmask2str LDAP_P(( slap_mask_t mask, char*, int debug )); 114 LDAP_SLAPD_F (slap_mask_t) str2accessmask LDAP_P(( const char *str )); 115 LDAP_SLAPD_F (void) acl_unparse LDAP_P(( AccessControl*, struct berval* )); 116 LDAP_SLAPD_F (void) acl_destroy LDAP_P(( AccessControl* )); 117 LDAP_SLAPD_F (void) acl_free LDAP_P(( AccessControl *a )); 118 119 120 /* 121 * ad.c 122 */ 123 LDAP_SLAPD_F (int) slap_str2ad LDAP_P(( 124 const char *, 125 AttributeDescription **ad, 126 const char **text )); 127 128 LDAP_SLAPD_F (int) slap_bv2ad LDAP_P(( 129 struct berval *bv, 130 AttributeDescription **ad, 131 const char **text )); 132 133 LDAP_SLAPD_F (void) ad_destroy LDAP_P(( AttributeDescription * )); 134 LDAP_SLAPD_F (int) ad_keystring LDAP_P(( struct berval *bv )); 135 136 #define ad_cmp(l,r) (((l)->ad_cname.bv_len < (r)->ad_cname.bv_len) \ 137 ? -1 : (((l)->ad_cname.bv_len > (r)->ad_cname.bv_len) \ 138 ? 1 : strcasecmp((l)->ad_cname.bv_val, (r)->ad_cname.bv_val ))) 139 140 LDAP_SLAPD_F (int) is_ad_subtype LDAP_P(( 141 AttributeDescription *sub, 142 AttributeDescription *super )); 143 144 LDAP_SLAPD_F (int) ad_inlist LDAP_P(( 145 AttributeDescription *desc, 146 AttributeName *attrs )); 147 148 LDAP_SLAPD_F (int) slap_str2undef_ad LDAP_P(( 149 const char *, 150 AttributeDescription **ad, 151 const char **text, 152 unsigned proxied )); 153 154 LDAP_SLAPD_F (int) slap_bv2undef_ad LDAP_P(( 155 struct berval *bv, 156 AttributeDescription **ad, 157 const char **text, 158 unsigned proxied )); 159 160 LDAP_SLAPD_F (AttributeDescription *) slap_bv2tmp_ad LDAP_P(( 161 struct berval *bv, 162 void *memctx )); 163 164 LDAP_SLAPD_F (int) slap_ad_undef_promote LDAP_P(( 165 char *name, 166 AttributeType *nat )); 167 168 LDAP_SLAPD_F (AttributeDescription *) ad_find_tags LDAP_P(( 169 AttributeType *type, 170 struct berval *tags )); 171 172 LDAP_SLAPD_F (AttributeName *) str2anlist LDAP_P(( AttributeName *an, 173 char *str, const char *brkstr )); 174 LDAP_SLAPD_F (void) anlist_free LDAP_P(( AttributeName *an, 175 int freename, void *ctx )); 176 177 LDAP_SLAPD_F (char **) anlist2charray_x LDAP_P(( 178 AttributeName *an, int dup, void *ctx )); 179 LDAP_SLAPD_F (char **) anlist2charray LDAP_P(( AttributeName *an, int dup )); 180 LDAP_SLAPD_F (char **) anlist2attrs LDAP_P(( AttributeName *anlist )); 181 LDAP_SLAPD_F (AttributeName *) file2anlist LDAP_P(( 182 AttributeName *, const char *, const char * )); 183 LDAP_SLAPD_F (int) an_find LDAP_P(( AttributeName *a, struct berval *s )); 184 LDAP_SLAPD_F (int) ad_define_option LDAP_P(( const char *name, 185 const char *fname, int lineno )); 186 LDAP_SLAPD_F (void) ad_unparse_options LDAP_P(( BerVarray *res )); 187 188 LDAP_SLAPD_F (MatchingRule *) ad_mr( 189 AttributeDescription *ad, 190 unsigned usage ); 191 192 LDAP_SLAPD_V( AttributeName * ) slap_anlist_no_attrs; 193 LDAP_SLAPD_V( AttributeName * ) slap_anlist_all_user_attributes; 194 LDAP_SLAPD_V( AttributeName * ) slap_anlist_all_operational_attributes; 195 LDAP_SLAPD_V( AttributeName * ) slap_anlist_all_attributes; 196 197 LDAP_SLAPD_V( struct berval * ) slap_bv_no_attrs; 198 LDAP_SLAPD_V( struct berval * ) slap_bv_all_user_attrs; 199 LDAP_SLAPD_V( struct berval * ) slap_bv_all_operational_attrs; 200 201 /* deprecated; only defined for backward compatibility */ 202 #define NoAttrs (*slap_bv_no_attrs) 203 #define AllUser (*slap_bv_all_user_attrs) 204 #define AllOper (*slap_bv_all_operational_attrs) 205 206 /* 207 * add.c 208 */ 209 LDAP_SLAPD_F (int) slap_mods2entry LDAP_P(( Modifications *mods, Entry **e, 210 int initial, int dup, const char **text, char *textbuf, size_t textlen )); 211 212 LDAP_SLAPD_F (int) slap_entry2mods LDAP_P(( Entry *e, 213 Modifications **mods, const char **text, 214 char *textbuf, size_t textlen )); 215 LDAP_SLAPD_F( int ) slap_add_opattrs( 216 Operation *op, 217 const char **text, 218 char *textbuf, size_t textlen, 219 int manage_ctxcsn ); 220 221 222 /* 223 * at.c 224 */ 225 LDAP_SLAPD_V(int) at_oc_cache; 226 LDAP_SLAPD_F (void) at_config LDAP_P(( 227 const char *fname, int lineno, 228 int argc, char **argv )); 229 LDAP_SLAPD_F (AttributeType *) at_find LDAP_P(( 230 const char *name )); 231 LDAP_SLAPD_F (AttributeType *) at_bvfind LDAP_P(( 232 struct berval *name )); 233 LDAP_SLAPD_F (int) at_find_in_list LDAP_P(( 234 AttributeType *sat, AttributeType **list )); 235 LDAP_SLAPD_F (int) at_append_to_list LDAP_P(( 236 AttributeType *sat, AttributeType ***listp )); 237 LDAP_SLAPD_F (int) at_delete_from_list LDAP_P(( 238 int pos, AttributeType ***listp )); 239 LDAP_SLAPD_F (int) at_schema_info LDAP_P(( Entry *e )); 240 LDAP_SLAPD_F (int) at_add LDAP_P(( 241 LDAPAttributeType *at, int user, 242 AttributeType **sat, AttributeType *prev, const char **err )); 243 LDAP_SLAPD_F (void) at_destroy LDAP_P(( void )); 244 245 LDAP_SLAPD_F (int) is_at_subtype LDAP_P(( 246 AttributeType *sub, 247 AttributeType *super )); 248 249 LDAP_SLAPD_F (const char *) at_syntax LDAP_P(( 250 AttributeType *at )); 251 LDAP_SLAPD_F (int) is_at_syntax LDAP_P(( 252 AttributeType *at, 253 const char *oid )); 254 255 LDAP_SLAPD_F (int) at_start LDAP_P(( AttributeType **at )); 256 LDAP_SLAPD_F (int) at_next LDAP_P(( AttributeType **at )); 257 LDAP_SLAPD_F (void) at_delete LDAP_P(( AttributeType *at )); 258 259 LDAP_SLAPD_F (void) at_unparse LDAP_P(( 260 BerVarray *bva, AttributeType *start, AttributeType *end, int system )); 261 262 LDAP_SLAPD_F (int) register_at LDAP_P(( 263 const char *at, 264 AttributeDescription **ad, 265 int dupok )); 266 267 /* 268 * attr.c 269 */ 270 LDAP_SLAPD_F (void) attr_free LDAP_P(( Attribute *a )); 271 LDAP_SLAPD_F (Attribute *) attr_dup LDAP_P(( Attribute *a )); 272 273 #ifdef LDAP_COMP_MATCH 274 LDAP_SLAPD_F (void) comp_tree_free LDAP_P(( Attribute *a )); 275 #endif 276 277 #define attr_mergeit( e, d, v ) attr_merge( e, d, v, NULL /* FIXME */ ) 278 #define attr_mergeit_one( e, d, v ) attr_merge_one( e, d, v, NULL /* FIXME */ ) 279 280 LDAP_SLAPD_F (Attribute *) attr_alloc LDAP_P(( AttributeDescription *ad )); 281 LDAP_SLAPD_F (Attribute *) attrs_alloc LDAP_P(( int num )); 282 LDAP_SLAPD_F (int) attr_prealloc LDAP_P(( int num )); 283 LDAP_SLAPD_F (int) attr_valfind LDAP_P(( Attribute *a, 284 unsigned flags, 285 struct berval *val, 286 unsigned *slot, 287 void *ctx )); 288 LDAP_SLAPD_F (int) attr_valadd LDAP_P(( Attribute *a, 289 BerVarray vals, 290 BerVarray nvals, 291 int num )); 292 LDAP_SLAPD_F (int) attr_merge LDAP_P(( Entry *e, 293 AttributeDescription *desc, 294 BerVarray vals, 295 BerVarray nvals )); 296 LDAP_SLAPD_F (int) attr_merge_one LDAP_P(( Entry *e, 297 AttributeDescription *desc, 298 struct berval *val, 299 struct berval *nval )); 300 LDAP_SLAPD_F (int) attr_normalize LDAP_P(( AttributeDescription *desc, 301 BerVarray vals, BerVarray *nvalsp, void *memctx )); 302 LDAP_SLAPD_F (int) attr_normalize_one LDAP_P(( AttributeDescription *desc, 303 struct berval *val, struct berval *nval, void *memctx )); 304 LDAP_SLAPD_F (int) attr_merge_normalize LDAP_P(( Entry *e, 305 AttributeDescription *desc, 306 BerVarray vals, void *memctx )); 307 LDAP_SLAPD_F (int) attr_merge_normalize_one LDAP_P(( Entry *e, 308 AttributeDescription *desc, 309 struct berval *val, void *memctx )); 310 LDAP_SLAPD_F (Attribute *) attrs_find LDAP_P(( 311 Attribute *a, AttributeDescription *desc )); 312 LDAP_SLAPD_F (Attribute *) attr_find LDAP_P(( 313 Attribute *a, AttributeDescription *desc )); 314 LDAP_SLAPD_F (int) attr_delete LDAP_P(( 315 Attribute **attrs, AttributeDescription *desc )); 316 317 LDAP_SLAPD_F (void) attrs_free LDAP_P(( Attribute *a )); 318 LDAP_SLAPD_F (Attribute *) attrs_dup LDAP_P(( Attribute *a )); 319 LDAP_SLAPD_F (int) attr_init LDAP_P(( void )); 320 LDAP_SLAPD_F (int) attr_destroy LDAP_P(( void )); 321 322 323 /* 324 * ava.c 325 */ 326 LDAP_SLAPD_F (int) get_ava LDAP_P(( 327 Operation *op, 328 BerElement *ber, 329 Filter *f, 330 unsigned usage, 331 const char **text )); 332 LDAP_SLAPD_F (void) ava_free LDAP_P(( 333 Operation *op, 334 AttributeAssertion *ava, 335 int freeit )); 336 337 /* 338 * backend.c 339 */ 340 341 #define be_match( be1, be2 ) ( (be1) == (be2) || \ 342 ( (be1) && (be2) && (be1)->be_nsuffix == (be2)->be_nsuffix ) ) 343 344 LDAP_SLAPD_F (int) backend_init LDAP_P((void)); 345 LDAP_SLAPD_F (int) backend_add LDAP_P((BackendInfo *aBackendInfo)); 346 LDAP_SLAPD_F (int) backend_num LDAP_P((Backend *be)); 347 LDAP_SLAPD_F (int) backend_startup LDAP_P((Backend *be)); 348 LDAP_SLAPD_F (int) backend_startup_one LDAP_P((Backend *be, struct config_reply_s *cr)); 349 LDAP_SLAPD_F (int) backend_sync LDAP_P((Backend *be)); 350 LDAP_SLAPD_F (int) backend_shutdown LDAP_P((Backend *be)); 351 LDAP_SLAPD_F (int) backend_destroy LDAP_P((void)); 352 LDAP_SLAPD_F (void) backend_stopdown_one LDAP_P((BackendDB *bd )); 353 LDAP_SLAPD_F (void) backend_destroy_one LDAP_P((BackendDB *bd, int dynamic)); 354 355 LDAP_SLAPD_F (BackendInfo *) backend_info LDAP_P(( const char *type )); 356 LDAP_SLAPD_F (BackendDB *) backend_db_init LDAP_P(( const char *type, 357 BackendDB *be, int idx, struct config_reply_s *cr )); 358 LDAP_SLAPD_F (void) backend_db_insert LDAP_P((BackendDB *bd, int idx)); 359 LDAP_SLAPD_F (void) backend_db_move LDAP_P((BackendDB *bd, int idx)); 360 361 LDAP_SLAPD_F (BackendDB *) select_backend LDAP_P(( 362 struct berval * dn, 363 int noSubordinates )); 364 365 LDAP_SLAPD_F (int) be_issuffix LDAP_P(( Backend *be, 366 struct berval *suffix )); 367 LDAP_SLAPD_F (int) be_issubordinate LDAP_P(( Backend *be, 368 struct berval *subordinate )); 369 LDAP_SLAPD_F (int) be_isroot LDAP_P(( Operation *op )); 370 LDAP_SLAPD_F (int) be_isroot_dn LDAP_P(( Backend *be, struct berval *ndn )); 371 LDAP_SLAPD_F (int) be_isroot_pw LDAP_P(( Operation *op )); 372 LDAP_SLAPD_F (int) be_rootdn_bind LDAP_P(( Operation *op, SlapReply *rs )); 373 LDAP_SLAPD_F (int) be_slurp_update LDAP_P(( Operation *op )); 374 #define be_isupdate( op ) be_slurp_update( (op) ) 375 LDAP_SLAPD_F (int) be_shadow_update LDAP_P(( Operation *op )); 376 LDAP_SLAPD_F (int) be_isupdate_dn LDAP_P(( Backend *be, struct berval *ndn )); 377 LDAP_SLAPD_F (struct berval *) be_root_dn LDAP_P(( Backend *be )); 378 LDAP_SLAPD_F (int) be_entry_get_rw LDAP_P(( Operation *o, 379 struct berval *ndn, ObjectClass *oc, 380 AttributeDescription *at, int rw, Entry **e )); 381 LDAP_SLAPD_F (int) be_entry_release_rw LDAP_P(( 382 Operation *o, Entry *e, int rw )); 383 #define be_entry_release_r( o, e ) be_entry_release_rw( o, e, 0 ) 384 #define be_entry_release_w( o, e ) be_entry_release_rw( o, e, 1 ) 385 386 LDAP_SLAPD_F (int) backend_unbind LDAP_P((Operation *op, SlapReply *rs)); 387 LDAP_SLAPD_F (int) backend_connection_init LDAP_P((Connection *conn)); 388 LDAP_SLAPD_F (int) backend_connection_destroy LDAP_P((Connection *conn)); 389 390 LDAP_SLAPD_F( int ) backend_check_controls LDAP_P(( 391 Operation *op, 392 SlapReply *rs )); 393 LDAP_SLAPD_F( int ) backend_check_restrictions LDAP_P(( 394 Operation *op, 395 SlapReply *rs, 396 struct berval *opdata )); 397 398 LDAP_SLAPD_F( int ) backend_check_referrals LDAP_P(( 399 Operation *op, 400 SlapReply *rs )); 401 402 LDAP_SLAPD_F (int) backend_group LDAP_P(( 403 Operation *op, 404 Entry *target, 405 struct berval *gr_ndn, 406 struct berval *op_ndn, 407 ObjectClass *group_oc, 408 AttributeDescription *group_at 409 )); 410 411 LDAP_SLAPD_F (int) backend_attribute LDAP_P(( 412 Operation *op, 413 Entry *target, 414 struct berval *entry_ndn, 415 AttributeDescription *entry_at, 416 BerVarray *vals, 417 slap_access_t access 418 )); 419 420 LDAP_SLAPD_F (int) backend_access LDAP_P(( 421 Operation *op, 422 Entry *target, 423 struct berval *edn, 424 AttributeDescription *entry_at, 425 struct berval *nval, 426 slap_access_t access, 427 slap_mask_t *mask )); 428 429 LDAP_SLAPD_F (int) backend_operational LDAP_P(( 430 Operation *op, 431 SlapReply *rs 432 )); 433 434 LDAP_SLAPD_F (ID) backend_tool_entry_first LDAP_P(( BackendDB *be )); 435 436 LDAP_SLAPD_V(BackendInfo) slap_binfo[]; 437 438 /* 439 * backglue.c 440 */ 441 442 LDAP_SLAPD_F (int) glue_sub_init( void ); 443 LDAP_SLAPD_F (int) glue_sub_attach( int online ); 444 LDAP_SLAPD_F (int) glue_sub_add( BackendDB *be, int advert, int online ); 445 LDAP_SLAPD_F (int) glue_sub_del( BackendDB *be ); 446 447 /* 448 * backover.c 449 */ 450 LDAP_SLAPD_F (int) overlay_register LDAP_P(( slap_overinst *on )); 451 LDAP_SLAPD_F (int) overlay_config LDAP_P(( BackendDB *be, const char *ov, 452 int idx, BackendInfo **res, ConfigReply *cr )); 453 LDAP_SLAPD_F (void) overlay_destroy_one LDAP_P(( 454 BackendDB *be, 455 slap_overinst *on )); 456 LDAP_SLAPD_F (slap_overinst *) overlay_next LDAP_P(( slap_overinst *on )); 457 LDAP_SLAPD_F (slap_overinst *) overlay_find LDAP_P(( const char *name )); 458 LDAP_SLAPD_F (int) overlay_is_over LDAP_P(( BackendDB *be )); 459 LDAP_SLAPD_F (int) overlay_is_inst LDAP_P(( BackendDB *be, const char *name )); 460 LDAP_SLAPD_F (int) overlay_register_control LDAP_P(( 461 BackendDB *be, 462 const char *oid )); 463 LDAP_SLAPD_F (int) overlay_op_walk LDAP_P(( 464 Operation *op, 465 SlapReply *rs, 466 slap_operation_t which, 467 slap_overinfo *oi, 468 slap_overinst *on )); 469 LDAP_SLAPD_F (int) overlay_entry_get_ov LDAP_P(( 470 Operation *op, 471 struct berval *dn, 472 ObjectClass *oc, 473 AttributeDescription *ad, 474 int rw, 475 Entry **e, 476 slap_overinst *ov )); 477 LDAP_SLAPD_F (int) overlay_entry_release_ov LDAP_P(( 478 Operation *op, 479 Entry *e, 480 int rw, 481 slap_overinst *ov )); 482 LDAP_SLAPD_F (void) overlay_insert LDAP_P(( 483 BackendDB *be, slap_overinst *on, slap_overinst ***prev, int idx )); 484 LDAP_SLAPD_F (void) overlay_move LDAP_P(( 485 BackendDB *be, slap_overinst *on, int idx )); 486 #ifdef SLAP_CONFIG_DELETE 487 LDAP_SLAPD_F (void) overlay_remove LDAP_P(( 488 BackendDB *be, slap_overinst *on, Operation *op )); 489 LDAP_SLAPD_F (void) overlay_unregister_control LDAP_P(( 490 BackendDB *be, 491 const char *oid )); 492 #endif /* SLAP_CONFIG_DELETE */ 493 LDAP_SLAPD_F (int) overlay_callback_after_backover LDAP_P(( 494 Operation *op, slap_callback *sc, int append )); 495 496 /* 497 * bconfig.c 498 */ 499 LDAP_SLAPD_F (int) slap_loglevel_register LDAP_P (( slap_mask_t m, struct berval *s )); 500 LDAP_SLAPD_F (int) slap_loglevel_get LDAP_P(( struct berval *s, int *l )); 501 LDAP_SLAPD_F (int) str2loglevel LDAP_P(( const char *s, int *l )); 502 LDAP_SLAPD_F (int) loglevel2bvarray LDAP_P(( int l, BerVarray *bva )); 503 LDAP_SLAPD_F (const char *) loglevel2str LDAP_P(( int l )); 504 LDAP_SLAPD_F (int) loglevel2bv LDAP_P(( int l, struct berval *bv )); 505 LDAP_SLAPD_F (int) loglevel_print LDAP_P(( FILE *out )); 506 LDAP_SLAPD_F (int) slap_cf_aux_table_parse LDAP_P(( const char *word, void *bc, slap_cf_aux_table *tab0, LDAP_CONST char *tabmsg )); 507 LDAP_SLAPD_F (int) slap_cf_aux_table_unparse LDAP_P(( void *bc, struct berval *bv, slap_cf_aux_table *tab0 )); 508 509 /* 510 * ch_malloc.c 511 */ 512 LDAP_SLAPD_V (BerMemoryFunctions) ch_mfuncs; 513 LDAP_SLAPD_F (void *) ch_malloc LDAP_P(( ber_len_t size )); 514 LDAP_SLAPD_F (void *) ch_realloc LDAP_P(( void *block, ber_len_t size )); 515 LDAP_SLAPD_F (void *) ch_calloc LDAP_P(( ber_len_t nelem, ber_len_t size )); 516 LDAP_SLAPD_F (char *) ch_strdup LDAP_P(( const char *string )); 517 LDAP_SLAPD_F (void) ch_free LDAP_P(( void * )); 518 519 #ifndef CH_FREE 520 #undef free 521 #define free ch_free 522 #endif 523 524 /* 525 * compare.c 526 */ 527 528 LDAP_SLAPD_F (int) slap_compare_entry LDAP_P(( 529 Operation *op, 530 Entry *e, 531 AttributeAssertion *ava )); 532 533 /* 534 * component.c 535 */ 536 #ifdef LDAP_COMP_MATCH 537 struct comp_attribute_aliasing; 538 539 LDAP_SLAPD_F (int) test_comp_filter_entry LDAP_P(( 540 Operation* op, 541 Entry* e, 542 MatchingRuleAssertion* mr)); 543 544 LDAP_SLAPD_F (int) dup_comp_filter LDAP_P(( 545 Operation* op, 546 struct berval *bv, 547 ComponentFilter *in_f, 548 ComponentFilter **out_f )); 549 550 LDAP_SLAPD_F (int) get_aliased_filter_aa LDAP_P(( 551 Operation* op, 552 AttributeAssertion* a_assert, 553 struct comp_attribute_aliasing* aa, 554 const char** text )); 555 556 LDAP_SLAPD_F (int) get_aliased_filter LDAP_P(( 557 Operation* op, 558 MatchingRuleAssertion* ma, 559 struct comp_attribute_aliasing* aa, 560 const char** text )); 561 562 LDAP_SLAPD_F (int) get_comp_filter LDAP_P(( 563 Operation* op, 564 BerValue* bv, 565 ComponentFilter** filt, 566 const char **text )); 567 568 LDAP_SLAPD_F (int) insert_component_reference LDAP_P(( 569 ComponentReference *cr, 570 ComponentReference** cr_list )); 571 572 LDAP_SLAPD_F (int) is_component_reference LDAP_P(( 573 char *attr )); 574 575 LDAP_SLAPD_F (int) extract_component_reference LDAP_P(( 576 char* attr, 577 ComponentReference** cr )); 578 579 LDAP_SLAPD_F (int) componentFilterMatch LDAP_P(( 580 int *matchp, 581 slap_mask_t flags, 582 Syntax *syntax, 583 MatchingRule *mr, 584 struct berval *value, 585 void *assertedValue )); 586 587 LDAP_SLAPD_F (int) directoryComponentsMatch LDAP_P(( 588 int *matchp, 589 slap_mask_t flags, 590 Syntax *syntax, 591 MatchingRule *mr, 592 struct berval *value, 593 void *assertedValue )); 594 595 LDAP_SLAPD_F (int) allComponentsMatch LDAP_P(( 596 int *matchp, 597 slap_mask_t flags, 598 Syntax *syntax, 599 MatchingRule *mr, 600 struct berval *value, 601 void *assertedValue )); 602 603 LDAP_SLAPD_F (ComponentReference*) dup_comp_ref LDAP_P(( 604 Operation *op, 605 ComponentReference *cr )); 606 607 LDAP_SLAPD_F (int) componentFilterValidate LDAP_P(( 608 Syntax *syntax, 609 struct berval* bv )); 610 611 LDAP_SLAPD_F (int) allComponentsValidate LDAP_P(( 612 Syntax *syntax, 613 struct berval* bv )); 614 615 LDAP_SLAPD_F (void) component_free LDAP_P(( 616 ComponentFilter *f )); 617 618 LDAP_SLAPD_F (void) free_ComponentData LDAP_P(( 619 Attribute *a )); 620 621 LDAP_SLAPD_V (test_membership_func*) is_aliased_attribute; 622 623 LDAP_SLAPD_V (free_component_func*) component_destructor; 624 625 LDAP_SLAPD_V (get_component_info_func*) get_component_description; 626 627 LDAP_SLAPD_V (component_encoder_func*) component_encoder; 628 629 LDAP_SLAPD_V (convert_attr_to_comp_func*) attr_converter; 630 631 LDAP_SLAPD_V (alloc_nibble_func*) nibble_mem_allocator; 632 633 LDAP_SLAPD_V (free_nibble_func*) nibble_mem_free; 634 #endif 635 636 /* 637 * controls.c 638 */ 639 LDAP_SLAPD_V( struct slap_control_ids ) slap_cids; 640 LDAP_SLAPD_F (void) slap_free_ctrls LDAP_P(( 641 Operation *op, 642 LDAPControl **ctrls )); 643 LDAP_SLAPD_F (int) slap_add_ctrls LDAP_P(( 644 Operation *op, 645 SlapReply *rs, 646 LDAPControl **ctrls )); 647 LDAP_SLAPD_F (int) slap_parse_ctrl LDAP_P(( 648 Operation *op, 649 SlapReply *rs, 650 LDAPControl *control, 651 const char **text )); 652 LDAP_SLAPD_F (int) get_ctrls LDAP_P(( 653 Operation *op, 654 SlapReply *rs, 655 int senderrors )); 656 LDAP_SLAPD_F (int) register_supported_control2 LDAP_P(( 657 const char *controloid, 658 slap_mask_t controlmask, 659 char **controlexops, 660 SLAP_CTRL_PARSE_FN *controlparsefn, 661 unsigned flags, 662 int *controlcid )); 663 #define register_supported_control(oid, mask, exops, fn, cid) \ 664 register_supported_control2((oid), (mask), (exops), (fn), 0, (cid)) 665 #ifdef SLAP_CONFIG_DELETE 666 LDAP_SLAPD_F (int) unregister_supported_control LDAP_P(( 667 const char* controloid )); 668 #endif /* SLAP_CONFIG_DELETE */ 669 LDAP_SLAPD_F (int) slap_controls_init LDAP_P ((void)); 670 LDAP_SLAPD_F (void) controls_destroy LDAP_P ((void)); 671 LDAP_SLAPD_F (int) controls_root_dse_info LDAP_P ((Entry *e)); 672 LDAP_SLAPD_F (int) get_supported_controls LDAP_P (( 673 char ***ctrloidsp, slap_mask_t **ctrlmasks )); 674 LDAP_SLAPD_F (int) slap_find_control_id LDAP_P (( 675 const char *oid, int *cid )); 676 LDAP_SLAPD_F (int) slap_global_control LDAP_P (( 677 Operation *op, const char *oid, int *cid )); 678 LDAP_SLAPD_F (int) slap_remove_control LDAP_P(( 679 Operation *op, 680 SlapReply *rs, 681 int ctrl, 682 BI_chk_controls fnc )); 683 684 #ifdef SLAP_CONTROL_X_SESSION_TRACKING 685 LDAP_SLAPD_F (int) 686 slap_ctrl_session_tracking_add LDAP_P(( 687 Operation *op, 688 SlapReply *rs, 689 struct berval *ip, 690 struct berval *name, 691 struct berval *id, 692 LDAPControl *ctrl )); 693 LDAP_SLAPD_F (int) 694 slap_ctrl_session_tracking_request_add LDAP_P(( 695 Operation *op, SlapReply *rs, LDAPControl *ctrl )); 696 #endif /* SLAP_CONTROL_X_SESSION_TRACKING */ 697 #ifdef SLAP_CONTROL_X_WHATFAILED 698 LDAP_SLAPD_F (int) 699 slap_ctrl_whatFailed_add LDAP_P(( 700 Operation *op, 701 SlapReply *rs, 702 char **oids )); 703 #endif /* SLAP_CONTROL_X_WHATFAILED */ 704 705 /* 706 * config.c 707 */ 708 LDAP_SLAPD_F (int) read_config LDAP_P(( const char *fname, const char *dir )); 709 LDAP_SLAPD_F (void) config_destroy LDAP_P ((void)); 710 LDAP_SLAPD_F (char **) slap_str2clist LDAP_P(( 711 char ***, char *, const char * )); 712 LDAP_SLAPD_F (int) bverb_to_mask LDAP_P(( 713 struct berval *bword, slap_verbmasks *v )); 714 LDAP_SLAPD_F (int) verb_to_mask LDAP_P(( 715 const char *word, slap_verbmasks *v )); 716 LDAP_SLAPD_F (int) verbs_to_mask LDAP_P(( 717 int argc, char *argv[], slap_verbmasks *v, slap_mask_t *m )); 718 LDAP_SLAPD_F (int) mask_to_verbs LDAP_P(( 719 slap_verbmasks *v, slap_mask_t m, BerVarray *bva )); 720 LDAP_SLAPD_F (int) mask_to_verbstring LDAP_P(( 721 slap_verbmasks *v, slap_mask_t m, char delim, struct berval *bv )); 722 LDAP_SLAPD_F (int) verbstring_to_mask LDAP_P(( 723 slap_verbmasks *v, char *str, char delim, slap_mask_t *m )); 724 LDAP_SLAPD_F (int) enum_to_verb LDAP_P(( 725 slap_verbmasks *v, slap_mask_t m, struct berval *bv )); 726 LDAP_SLAPD_F (int) slap_verbmasks_init LDAP_P(( slap_verbmasks **vp, slap_verbmasks *v )); 727 LDAP_SLAPD_F (int) slap_verbmasks_destroy LDAP_P(( slap_verbmasks *v )); 728 LDAP_SLAPD_F (int) slap_verbmasks_append LDAP_P(( slap_verbmasks **vp, 729 slap_mask_t m, struct berval *v, slap_mask_t *ignore )); 730 LDAP_SLAPD_F (int) slap_tls_get_config LDAP_P(( 731 LDAP *ld, int opt, char **val )); 732 LDAP_SLAPD_F (void) bindconf_tls_defaults LDAP_P(( slap_bindconf *bc )); 733 LDAP_SLAPD_F (int) bindconf_tls_parse LDAP_P(( 734 const char *word, slap_bindconf *bc )); 735 LDAP_SLAPD_F (int) bindconf_tls_unparse LDAP_P(( 736 slap_bindconf *bc, struct berval *bv )); 737 LDAP_SLAPD_F (int) bindconf_parse LDAP_P(( 738 const char *word, slap_bindconf *bc )); 739 LDAP_SLAPD_F (int) bindconf_unparse LDAP_P(( 740 slap_bindconf *bc, struct berval *bv )); 741 LDAP_SLAPD_F (int) bindconf_tls_set LDAP_P(( 742 slap_bindconf *bc, LDAP *ld )); 743 LDAP_SLAPD_F (void) bindconf_free LDAP_P(( slap_bindconf *bc )); 744 LDAP_SLAPD_F (int) slap_client_connect LDAP_P(( LDAP **ldp, slap_bindconf *sb )); 745 LDAP_SLAPD_F (int) config_generic_wrapper LDAP_P(( Backend *be, 746 const char *fname, int lineno, int argc, char **argv )); 747 LDAP_SLAPD_F (char *) anlist_unparse LDAP_P(( AttributeName *, char *, ber_len_t buflen )); 748 LDAP_SLAPD_F (int) slap_keepalive_parse( struct berval *val, void *bc, 749 slap_cf_aux_table *tab0, const char *tabmsg, int unparse ); 750 751 #ifdef LDAP_SLAPI 752 LDAP_SLAPD_V (int) slapi_plugins_used; 753 #endif 754 755 /* 756 * connection.c 757 */ 758 LDAP_SLAPD_F (int) connections_init LDAP_P((void)); 759 LDAP_SLAPD_F (int) connections_shutdown LDAP_P((void)); 760 LDAP_SLAPD_F (int) connections_destroy LDAP_P((void)); 761 LDAP_SLAPD_F (int) connections_timeout_idle LDAP_P((time_t)); 762 LDAP_SLAPD_F (void) connections_drop LDAP_P((void)); 763 764 LDAP_SLAPD_F (Connection *) connection_client_setup LDAP_P(( 765 ber_socket_t s, 766 ldap_pvt_thread_start_t *func, 767 void *arg )); 768 LDAP_SLAPD_F (void) connection_client_enable LDAP_P(( Connection *c )); 769 LDAP_SLAPD_F (void) connection_client_stop LDAP_P(( Connection *c )); 770 771 #ifdef LDAP_PF_LOCAL_SENDMSG 772 #define LDAP_PF_LOCAL_SENDMSG_ARG(arg) , arg 773 #else 774 #define LDAP_PF_LOCAL_SENDMSG_ARG(arg) 775 #endif 776 777 LDAP_SLAPD_F (Connection *) connection_init LDAP_P(( 778 ber_socket_t s, 779 Listener* url, 780 const char* dnsname, 781 const char* peername, 782 int use_tls, 783 slap_ssf_t ssf, 784 struct berval *id 785 LDAP_PF_LOCAL_SENDMSG_ARG(struct berval *peerbv))); 786 787 LDAP_SLAPD_F (void) connection_closing LDAP_P(( 788 Connection *c, const char *why )); 789 LDAP_SLAPD_F (int) connection_valid LDAP_P(( Connection *c )); 790 LDAP_SLAPD_F (const char *) connection_state2str LDAP_P(( int state )) 791 LDAP_GCCATTR((const)); 792 793 LDAP_SLAPD_F (int) connection_read_activate LDAP_P((ber_socket_t s)); 794 LDAP_SLAPD_F (int) connection_write LDAP_P((ber_socket_t s)); 795 796 LDAP_SLAPD_F (unsigned long) connections_nextid(void); 797 798 LDAP_SLAPD_F (Connection *) connection_first LDAP_P(( ber_socket_t * )); 799 LDAP_SLAPD_F (Connection *) connection_next LDAP_P(( 800 Connection *, ber_socket_t *)); 801 LDAP_SLAPD_F (void) connection_done LDAP_P((Connection *)); 802 803 LDAP_SLAPD_F (void) connection2anonymous LDAP_P((Connection *)); 804 LDAP_SLAPD_F (void) connection_fake_init LDAP_P(( 805 Connection *conn, 806 OperationBuffer *opbuf, 807 void *threadctx )); 808 LDAP_SLAPD_F (void) connection_fake_init2 LDAP_P(( 809 Connection *conn, 810 OperationBuffer *opbuf, 811 void *threadctx, 812 int newmem )); 813 LDAP_SLAPD_F (void) operation_fake_init LDAP_P(( 814 Connection *conn, 815 Operation *op, 816 void *threadctx, 817 int newmem )); 818 LDAP_SLAPD_F (void) connection_assign_nextid LDAP_P((Connection *)); 819 820 /* 821 * cr.c 822 */ 823 LDAP_SLAPD_F (int) cr_schema_info( Entry *e ); 824 LDAP_SLAPD_F (void) cr_unparse LDAP_P(( 825 BerVarray *bva, ContentRule *start, ContentRule *end, int system )); 826 827 LDAP_SLAPD_F (int) cr_add LDAP_P(( 828 LDAPContentRule *oc, 829 int user, 830 ContentRule **scr, 831 const char **err)); 832 833 LDAP_SLAPD_F (void) cr_destroy LDAP_P(( void )); 834 835 LDAP_SLAPD_F (ContentRule *) cr_find LDAP_P(( 836 const char *crname)); 837 LDAP_SLAPD_F (ContentRule *) cr_bvfind LDAP_P(( 838 struct berval *crname)); 839 840 /* 841 * ctxcsn.c 842 */ 843 844 LDAP_SLAPD_V( int ) slap_serverID; 845 LDAP_SLAPD_V( const struct berval ) slap_ldapsync_bv; 846 LDAP_SLAPD_V( const struct berval ) slap_ldapsync_cn_bv; 847 LDAP_SLAPD_F (void) slap_get_commit_csn LDAP_P(( 848 Operation *, struct berval *maxcsn, int *foundit )); 849 LDAP_SLAPD_F (void) slap_rewind_commit_csn LDAP_P(( Operation * )); 850 LDAP_SLAPD_F (void) slap_graduate_commit_csn LDAP_P(( Operation * )); 851 LDAP_SLAPD_F (Entry *) slap_create_context_csn_entry LDAP_P(( Backend *, struct berval *)); 852 LDAP_SLAPD_F (int) slap_get_csn LDAP_P(( Operation *, struct berval *, int )); 853 LDAP_SLAPD_F (void) slap_queue_csn LDAP_P(( Operation *, struct berval * )); 854 855 /* 856 * daemon.c 857 */ 858 LDAP_SLAPD_F (void) slapd_add_internal(ber_socket_t s, int isactive); 859 LDAP_SLAPD_F (int) slapd_daemon_init( const char *urls ); 860 LDAP_SLAPD_F (int) slapd_daemon_destroy(void); 861 LDAP_SLAPD_F (int) slapd_daemon(void); 862 LDAP_SLAPD_F (Listener **) slapd_get_listeners LDAP_P((void)); 863 LDAP_SLAPD_F (void) slapd_remove LDAP_P((ber_socket_t s, Sockbuf *sb, 864 int wasactive, int wake, int locked )); 865 866 LDAP_SLAPD_F (RETSIGTYPE) slap_sig_shutdown LDAP_P((int sig)); 867 LDAP_SLAPD_F (RETSIGTYPE) slap_sig_wake LDAP_P((int sig)); 868 LDAP_SLAPD_F (void) slap_wake_listener LDAP_P((void)); 869 870 LDAP_SLAPD_F (void) slap_suspend_listeners LDAP_P((void)); 871 LDAP_SLAPD_F (void) slap_resume_listeners LDAP_P((void)); 872 873 LDAP_SLAPD_F (void) slapd_set_write LDAP_P((ber_socket_t s, int wake)); 874 LDAP_SLAPD_F (void) slapd_clr_write LDAP_P((ber_socket_t s, int wake)); 875 LDAP_SLAPD_F (void) slapd_set_read LDAP_P((ber_socket_t s, int wake)); 876 LDAP_SLAPD_F (int) slapd_clr_read LDAP_P((ber_socket_t s, int wake)); 877 LDAP_SLAPD_F (void) slapd_clr_writetime LDAP_P((time_t old)); 878 LDAP_SLAPD_F (time_t) slapd_get_writetime LDAP_P((void)); 879 880 LDAP_SLAPD_V (volatile sig_atomic_t) slapd_abrupt_shutdown; 881 LDAP_SLAPD_V (volatile sig_atomic_t) slapd_shutdown; 882 LDAP_SLAPD_V (int) slapd_register_slp; 883 LDAP_SLAPD_V (const char *) slapd_slp_attrs; 884 LDAP_SLAPD_V (slap_ssf_t) local_ssf; 885 LDAP_SLAPD_V (struct runqueue_s) slapd_rq; 886 LDAP_SLAPD_V (int) slapd_daemon_threads; 887 LDAP_SLAPD_V (int) slapd_daemon_mask; 888 #ifdef LDAP_TCP_BUFFER 889 LDAP_SLAPD_V (int) slapd_tcp_rmem; 890 LDAP_SLAPD_V (int) slapd_tcp_wmem; 891 #endif /* LDAP_TCP_BUFFER */ 892 893 #ifdef HAVE_WINSOCK 894 LDAP_SLAPD_F (ber_socket_t) slapd_socknew(ber_socket_t s); 895 LDAP_SLAPD_F (ber_socket_t) slapd_sock2fd(ber_socket_t s); 896 LDAP_SLAPD_V (SOCKET *) slapd_ws_sockets; 897 #define SLAP_FD2SOCK(s) slapd_ws_sockets[s] 898 #define SLAP_SOCK2FD(s) slapd_sock2fd(s) 899 #define SLAP_SOCKNEW(s) slapd_socknew(s) 900 #else 901 #define SLAP_FD2SOCK(s) s 902 #define SLAP_SOCK2FD(s) s 903 #define SLAP_SOCKNEW(s) s 904 #endif 905 906 /* 907 * dn.c 908 */ 909 910 #define dn_match(dn1, dn2) ( ber_bvcmp((dn1), (dn2)) == 0 ) 911 #define bvmatch(bv1, bv2) ( ((bv1)->bv_len == (bv2)->bv_len) && (memcmp((bv1)->bv_val, (bv2)->bv_val, (bv1)->bv_len) == 0) ) 912 913 LDAP_SLAPD_F (int) dnValidate LDAP_P(( 914 Syntax *syntax, 915 struct berval *val )); 916 LDAP_SLAPD_F (int) rdnValidate LDAP_P(( 917 Syntax *syntax, 918 struct berval *val )); 919 920 LDAP_SLAPD_F (slap_mr_normalize_func) dnNormalize; 921 922 LDAP_SLAPD_F (slap_mr_normalize_func) rdnNormalize; 923 924 LDAP_SLAPD_F (slap_syntax_transform_func) dnPretty; 925 926 LDAP_SLAPD_F (slap_syntax_transform_func) rdnPretty; 927 928 LDAP_SLAPD_F (int) dnPrettyNormal LDAP_P(( 929 Syntax *syntax, 930 struct berval *val, 931 struct berval *pretty, 932 struct berval *normal, 933 void *ctx )); 934 935 LDAP_SLAPD_F (int) dnMatch LDAP_P(( 936 int *matchp, 937 slap_mask_t flags, 938 Syntax *syntax, 939 MatchingRule *mr, 940 struct berval *value, 941 void *assertedValue )); 942 943 LDAP_SLAPD_F (int) dnRelativeMatch LDAP_P(( 944 int *matchp, 945 slap_mask_t flags, 946 Syntax *syntax, 947 MatchingRule *mr, 948 struct berval *value, 949 void *assertedValue )); 950 951 LDAP_SLAPD_F (int) rdnMatch LDAP_P(( 952 int *matchp, 953 slap_mask_t flags, 954 Syntax *syntax, 955 MatchingRule *mr, 956 struct berval *value, 957 void *assertedValue )); 958 959 960 LDAP_SLAPD_F (int) dnIsSuffix LDAP_P(( 961 const struct berval *dn, const struct berval *suffix )); 962 963 LDAP_SLAPD_F (int) dnIsWithinScope LDAP_P(( 964 struct berval *ndn, struct berval *nbase, int scope )); 965 966 LDAP_SLAPD_F (int) dnIsSuffixScope LDAP_P(( 967 struct berval *ndn, struct berval *nbase, int scope )); 968 969 LDAP_SLAPD_F (int) dnIsOneLevelRDN LDAP_P(( struct berval *rdn )); 970 971 LDAP_SLAPD_F (int) dnExtractRdn LDAP_P(( 972 struct berval *dn, struct berval *rdn, void *ctx )); 973 974 LDAP_SLAPD_F (int) rdn_validate LDAP_P(( struct berval * rdn )); 975 976 LDAP_SLAPD_F (ber_len_t) dn_rdnlen LDAP_P(( Backend *be, struct berval *dn )); 977 978 LDAP_SLAPD_F (void) build_new_dn LDAP_P(( 979 struct berval * new_dn, 980 struct berval * parent_dn, 981 struct berval * newrdn, 982 void *memctx )); 983 984 LDAP_SLAPD_F (void) dnParent LDAP_P(( struct berval *dn, struct berval *pdn )); 985 LDAP_SLAPD_F (void) dnRdn LDAP_P(( struct berval *dn, struct berval *rdn )); 986 987 LDAP_SLAPD_F (int) dnX509normalize LDAP_P(( void *x509_name, struct berval *out )); 988 989 LDAP_SLAPD_F (int) dnX509peerNormalize LDAP_P(( void *ssl, struct berval *dn )); 990 991 LDAP_SLAPD_F (int) dnPrettyNormalDN LDAP_P(( Syntax *syntax, struct berval *val, LDAPDN *dn, int flags, void *ctx )); 992 #define dnPrettyDN(syntax, val, dn, ctx) \ 993 dnPrettyNormalDN((syntax),(val),(dn), SLAP_LDAPDN_PRETTY, ctx) 994 #define dnNormalDN(syntax, val, dn, ctx) \ 995 dnPrettyNormalDN((syntax),(val),(dn), 0, ctx) 996 997 typedef int (SLAP_CERT_MAP_FN) LDAP_P(( void *ssl, struct berval *dn )); 998 LDAP_SLAPD_F (int) register_certificate_map_function LDAP_P(( SLAP_CERT_MAP_FN *fn )); 999 1000 /* 1001 * entry.c 1002 */ 1003 LDAP_SLAPD_V (const Entry) slap_entry_root; 1004 1005 LDAP_SLAPD_F (int) entry_init LDAP_P((void)); 1006 LDAP_SLAPD_F (int) entry_destroy LDAP_P((void)); 1007 1008 LDAP_SLAPD_F (Entry *) str2entry LDAP_P(( char *s )); 1009 LDAP_SLAPD_F (Entry *) str2entry2 LDAP_P(( char *s, int checkvals )); 1010 LDAP_SLAPD_F (char *) entry2str LDAP_P(( Entry *e, int *len )); 1011 LDAP_SLAPD_F (char *) entry2str_wrap LDAP_P(( Entry *e, int *len, ber_len_t wrap )); 1012 1013 LDAP_SLAPD_F (ber_len_t) entry_flatsize LDAP_P(( Entry *e, int norm )); 1014 LDAP_SLAPD_F (void) entry_partsize LDAP_P(( Entry *e, ber_len_t *len, 1015 int *nattrs, int *nvals, int norm )); 1016 1017 LDAP_SLAPD_F (int) entry_header LDAP_P(( EntryHeader *eh )); 1018 LDAP_SLAPD_F (int) entry_decode_dn LDAP_P(( 1019 EntryHeader *eh, struct berval *dn, struct berval *ndn )); 1020 #ifdef SLAP_ZONE_ALLOC 1021 LDAP_SLAPD_F (int) entry_decode LDAP_P(( 1022 EntryHeader *eh, Entry **e, void *ctx )); 1023 #else 1024 LDAP_SLAPD_F (int) entry_decode LDAP_P(( 1025 EntryHeader *eh, Entry **e )); 1026 #endif 1027 LDAP_SLAPD_F (int) entry_encode LDAP_P(( Entry *e, struct berval *bv )); 1028 1029 LDAP_SLAPD_F (void) entry_clean LDAP_P(( Entry *e )); 1030 LDAP_SLAPD_F (void) entry_free LDAP_P(( Entry *e )); 1031 LDAP_SLAPD_F (int) entry_cmp LDAP_P(( Entry *a, Entry *b )); 1032 LDAP_SLAPD_F (int) entry_dn_cmp LDAP_P(( const void *v_a, const void *v_b )); 1033 LDAP_SLAPD_F (int) entry_id_cmp LDAP_P(( const void *v_a, const void *v_b )); 1034 LDAP_SLAPD_F (Entry *) entry_dup LDAP_P(( Entry *e )); 1035 LDAP_SLAPD_F (Entry *) entry_dup2 LDAP_P(( Entry *dest, Entry *src )); 1036 LDAP_SLAPD_F (Entry *) entry_dup_bv LDAP_P(( Entry *e )); 1037 LDAP_SLAPD_F (Entry *) entry_alloc LDAP_P((void)); 1038 LDAP_SLAPD_F (int) entry_prealloc LDAP_P((int num)); 1039 1040 /* 1041 * extended.c 1042 */ 1043 LDAP_SLAPD_F (int) exop_root_dse_info LDAP_P ((Entry *e)); 1044 1045 #define exop_is_write( op ) ((op->ore_flags & SLAP_EXOP_WRITES) != 0) 1046 1047 LDAP_SLAPD_V( const struct berval ) slap_EXOP_CANCEL; 1048 LDAP_SLAPD_V( const struct berval ) slap_EXOP_WHOAMI; 1049 LDAP_SLAPD_V( const struct berval ) slap_EXOP_MODIFY_PASSWD; 1050 LDAP_SLAPD_V( const struct berval ) slap_EXOP_START_TLS; 1051 #ifdef LDAP_X_TXN 1052 LDAP_SLAPD_V( const struct berval ) slap_EXOP_TXN_START; 1053 LDAP_SLAPD_V( const struct berval ) slap_EXOP_TXN_END; 1054 #endif 1055 1056 typedef int (SLAP_EXTOP_MAIN_FN) LDAP_P(( Operation *op, SlapReply *rs )); 1057 1058 typedef int (SLAP_EXTOP_GETOID_FN) LDAP_P(( 1059 int index, struct berval *oid, int blen )); 1060 1061 LDAP_SLAPD_F (int) load_extop2 LDAP_P(( 1062 const struct berval *ext_oid, 1063 slap_mask_t flags, 1064 SLAP_EXTOP_MAIN_FN *ext_main, 1065 unsigned tmpflags )); 1066 #define load_extop(ext_oid, flags, ext_main) \ 1067 load_extop2((ext_oid), (flags), (ext_main), 0) 1068 1069 LDAP_SLAPD_F (int) extops_init LDAP_P(( void )); 1070 1071 LDAP_SLAPD_F (int) extops_kill LDAP_P(( void )); 1072 1073 LDAP_SLAPD_F (struct berval *) get_supported_extop LDAP_P((int index)); 1074 1075 /* 1076 * txn.c 1077 */ 1078 #ifdef LDAP_X_TXN 1079 LDAP_SLAPD_F ( SLAP_CTRL_PARSE_FN ) txn_spec_ctrl; 1080 LDAP_SLAPD_F ( SLAP_EXTOP_MAIN_FN ) txn_start_extop; 1081 LDAP_SLAPD_F ( SLAP_EXTOP_MAIN_FN ) txn_end_extop; 1082 #endif 1083 1084 /* 1085 * cancel.c 1086 */ 1087 LDAP_SLAPD_F ( SLAP_EXTOP_MAIN_FN ) cancel_extop; 1088 1089 /* 1090 * filter.c 1091 */ 1092 LDAP_SLAPD_F (int) get_filter LDAP_P(( 1093 Operation *op, 1094 BerElement *ber, 1095 Filter **filt, 1096 const char **text )); 1097 1098 LDAP_SLAPD_F (void) filter_free LDAP_P(( Filter *f )); 1099 LDAP_SLAPD_F (void) filter_free_x LDAP_P(( Operation *op, Filter *f, int freeme )); 1100 LDAP_SLAPD_F (void) filter2bv LDAP_P(( Filter *f, struct berval *bv )); 1101 LDAP_SLAPD_F (void) filter2bv_x LDAP_P(( Operation *op, Filter *f, struct berval *bv )); 1102 LDAP_SLAPD_F (void) filter2bv_undef LDAP_P(( Filter *f, int noundef, struct berval *bv )); 1103 LDAP_SLAPD_F (void) filter2bv_undef_x LDAP_P(( Operation *op, Filter *f, int noundef, struct berval *bv )); 1104 LDAP_SLAPD_F (Filter *) filter_dup LDAP_P(( Filter *f, void *memctx )); 1105 1106 LDAP_SLAPD_F (int) get_vrFilter LDAP_P(( Operation *op, BerElement *ber, 1107 ValuesReturnFilter **f, 1108 const char **text )); 1109 1110 LDAP_SLAPD_F (void) vrFilter_free LDAP_P(( Operation *op, ValuesReturnFilter *f )); 1111 LDAP_SLAPD_F (void) vrFilter2bv LDAP_P(( Operation *op, ValuesReturnFilter *f, struct berval *fstr )); 1112 1113 LDAP_SLAPD_F (int) filter_has_subordinates LDAP_P(( Filter *filter )); 1114 #define filter_escape_value( in, out ) ldap_bv2escaped_filter_value_x( (in), (out), 0, NULL ) 1115 #define filter_escape_value_x( in, out, ctx ) ldap_bv2escaped_filter_value_x( (in), (out), 0, ctx ) 1116 1117 LDAP_SLAPD_V (const Filter *) slap_filter_objectClass_pres; 1118 LDAP_SLAPD_V (const struct berval *) slap_filterstr_objectClass_pres; 1119 1120 LDAP_SLAPD_F (int) filter_init LDAP_P(( void )); 1121 LDAP_SLAPD_F (void) filter_destroy LDAP_P(( void )); 1122 /* 1123 * filterentry.c 1124 */ 1125 1126 LDAP_SLAPD_F (int) test_filter LDAP_P(( Operation *op, Entry *e, Filter *f )); 1127 1128 /* 1129 * frontend.c 1130 */ 1131 LDAP_SLAPD_F (int) frontend_init LDAP_P(( void )); 1132 1133 /* 1134 * globals.c 1135 */ 1136 1137 LDAP_SLAPD_V( const struct berval ) slap_empty_bv; 1138 LDAP_SLAPD_V( const struct berval ) slap_unknown_bv; 1139 LDAP_SLAPD_V( const struct berval ) slap_true_bv; 1140 LDAP_SLAPD_V( const struct berval ) slap_false_bv; 1141 LDAP_SLAPD_V( struct slap_sync_cookie_s ) slap_sync_cookie; 1142 LDAP_SLAPD_V( void * ) slap_tls_ctx; 1143 LDAP_SLAPD_V( LDAP * ) slap_tls_ld; 1144 1145 /* 1146 * index.c 1147 */ 1148 LDAP_SLAPD_F (int) slap_str2index LDAP_P(( const char *str, slap_mask_t *idx )); 1149 LDAP_SLAPD_F (void) slap_index2bvlen LDAP_P(( slap_mask_t idx, struct berval *bv )); 1150 LDAP_SLAPD_F (void) slap_index2bv LDAP_P(( slap_mask_t idx, struct berval *bv )); 1151 1152 /* 1153 * init.c 1154 */ 1155 LDAP_SLAPD_F (int) slap_init LDAP_P((int mode, const char* name)); 1156 LDAP_SLAPD_F (int) slap_startup LDAP_P(( Backend *be )); 1157 LDAP_SLAPD_F (int) slap_shutdown LDAP_P(( Backend *be )); 1158 LDAP_SLAPD_F (int) slap_destroy LDAP_P((void)); 1159 LDAP_SLAPD_F (void) slap_counters_init LDAP_P((slap_counters_t *sc)); 1160 LDAP_SLAPD_F (void) slap_counters_destroy LDAP_P((slap_counters_t *sc)); 1161 1162 LDAP_SLAPD_V (char *) slap_known_controls[]; 1163 1164 /* 1165 * ldapsync.c 1166 */ 1167 LDAP_SLAPD_F (void) slap_compose_sync_cookie LDAP_P(( 1168 Operation *, struct berval *, BerVarray, int, int )); 1169 LDAP_SLAPD_F (void) slap_sync_cookie_free LDAP_P(( 1170 struct sync_cookie *, int free_cookie )); 1171 LDAP_SLAPD_F (int) slap_parse_csn_sid LDAP_P(( 1172 struct berval * )); 1173 LDAP_SLAPD_F (int *) slap_parse_csn_sids LDAP_P(( 1174 BerVarray, int, void *memctx )); 1175 LDAP_SLAPD_F (int) slap_sort_csn_sids LDAP_P(( 1176 BerVarray, int *, int, void *memctx )); 1177 LDAP_SLAPD_F (void) slap_insert_csn_sids LDAP_P(( 1178 struct sync_cookie *ck, int, int, struct berval * )); 1179 LDAP_SLAPD_F (int) slap_parse_sync_cookie LDAP_P(( 1180 struct sync_cookie *, void *memctx )); 1181 LDAP_SLAPD_F (void) slap_reparse_sync_cookie LDAP_P(( 1182 struct sync_cookie *, void *memctx )); 1183 LDAP_SLAPD_F (int) slap_init_sync_cookie_ctxcsn LDAP_P(( 1184 struct sync_cookie * )); 1185 LDAP_SLAPD_F (struct sync_cookie *) slap_dup_sync_cookie LDAP_P(( 1186 struct sync_cookie *, struct sync_cookie * )); 1187 LDAP_SLAPD_F (int) slap_build_syncUUID_set LDAP_P(( 1188 Operation *, BerVarray *, Entry * )); 1189 1190 /* 1191 * limits.c 1192 */ 1193 LDAP_SLAPD_F (int) limits_parse LDAP_P(( 1194 Backend *be, const char *fname, int lineno, 1195 int argc, char **argv )); 1196 LDAP_SLAPD_F (int) limits_parse_one LDAP_P(( const char *arg, 1197 struct slap_limits_set *limit )); 1198 LDAP_SLAPD_F (int) limits_check LDAP_P(( 1199 Operation *op, SlapReply *rs )); 1200 LDAP_SLAPD_F (int) limits_unparse_one LDAP_P(( 1201 struct slap_limits_set *limit, int which, struct berval *bv, ber_len_t buflen )); 1202 LDAP_SLAPD_F (int) limits_unparse LDAP_P(( 1203 struct slap_limits *limit, struct berval *bv, ber_len_t buflen )); 1204 LDAP_SLAPD_F (void) limits_free_one LDAP_P(( 1205 struct slap_limits *lm )); 1206 LDAP_SLAPD_F (void) limits_destroy LDAP_P(( struct slap_limits **lm )); 1207 1208 /* 1209 * lock.c 1210 */ 1211 LDAP_SLAPD_F (FILE *) lock_fopen LDAP_P(( const char *fname, 1212 const char *type, FILE **lfp )); 1213 LDAP_SLAPD_F (int) lock_fclose LDAP_P(( FILE *fp, FILE *lfp )); 1214 1215 /* 1216 * main.c 1217 */ 1218 LDAP_SLAPD_F (int) 1219 parse_debug_level LDAP_P(( const char *arg, int *levelp, char ***unknowns )); 1220 LDAP_SLAPD_F (int) 1221 parse_syslog_level LDAP_P(( const char *arg, int *levelp )); 1222 LDAP_SLAPD_F (int) 1223 parse_syslog_user LDAP_P(( const char *arg, int *syslogUser )); 1224 LDAP_SLAPD_F (int) 1225 parse_debug_unknowns LDAP_P(( char **unknowns, int *levelp )); 1226 1227 /* 1228 * matchedValues.c 1229 */ 1230 LDAP_SLAPD_F (int) filter_matched_values( 1231 Operation *op, 1232 Attribute *a, 1233 char ***e_flags ); 1234 1235 /* 1236 * modrdn.c 1237 */ 1238 LDAP_SLAPD_F (int) slap_modrdn2mods LDAP_P(( 1239 Operation *op, 1240 SlapReply *rs )); 1241 1242 /* 1243 * modify.c 1244 */ 1245 LDAP_SLAPD_F( int ) slap_mods_obsolete_check( 1246 Operation *op, 1247 Modifications *ml, 1248 const char **text, 1249 char *textbuf, size_t textlen ); 1250 1251 LDAP_SLAPD_F( int ) slap_mods_no_user_mod_check( 1252 Operation *op, 1253 Modifications *ml, 1254 const char **text, 1255 char *textbuf, size_t textlen ); 1256 1257 LDAP_SLAPD_F ( int ) slap_mods_no_repl_user_mod_check( 1258 Operation *op, 1259 Modifications *ml, 1260 const char **text, 1261 char *textbuf, 1262 size_t textlen ); 1263 1264 LDAP_SLAPD_F( int ) slap_mods_check( 1265 Operation *op, 1266 Modifications *ml, 1267 const char **text, 1268 char *textbuf, size_t textlen, void *ctx ); 1269 1270 LDAP_SLAPD_F( int ) slap_sort_vals( 1271 Modifications *ml, 1272 const char **text, 1273 int *dup, 1274 void *ctx ); 1275 1276 LDAP_SLAPD_F( void ) slap_timestamp( 1277 time_t *tm, 1278 struct berval *bv ); 1279 1280 LDAP_SLAPD_F( void ) slap_mods_opattrs( 1281 Operation *op, 1282 Modifications **modsp, 1283 int manage_ctxcsn ); 1284 1285 LDAP_SLAPD_F( int ) slap_parse_modlist( 1286 Operation *op, 1287 SlapReply *rs, 1288 BerElement *ber, 1289 req_modify_s *ms ); 1290 1291 /* 1292 * mods.c 1293 */ 1294 LDAP_SLAPD_F( int ) modify_add_values( Entry *e, 1295 Modification *mod, 1296 int permissive, 1297 const char **text, char *textbuf, size_t textlen ); 1298 LDAP_SLAPD_F( int ) modify_delete_values( Entry *e, 1299 Modification *mod, 1300 int permissive, 1301 const char **text, char *textbuf, size_t textlen ); 1302 LDAP_SLAPD_F( int ) modify_delete_vindex( Entry *e, 1303 Modification *mod, 1304 int permissive, 1305 const char **text, char *textbuf, size_t textlen, int *idx ); 1306 LDAP_SLAPD_F( int ) modify_replace_values( Entry *e, 1307 Modification *mod, 1308 int permissive, 1309 const char **text, char *textbuf, size_t textlen ); 1310 LDAP_SLAPD_F( int ) modify_increment_values( Entry *e, 1311 Modification *mod, 1312 int permissive, 1313 const char **text, char *textbuf, size_t textlen ); 1314 1315 LDAP_SLAPD_F( void ) slap_mod_free( Modification *mod, int freeit ); 1316 LDAP_SLAPD_F( void ) slap_mods_free( Modifications *mods, int freevals ); 1317 LDAP_SLAPD_F( void ) slap_modlist_free( LDAPModList *ml ); 1318 1319 /* 1320 * module.c 1321 */ 1322 #ifdef SLAPD_MODULES 1323 1324 LDAP_SLAPD_F (int) module_init LDAP_P(( void )); 1325 LDAP_SLAPD_F (int) module_kill LDAP_P(( void )); 1326 1327 LDAP_SLAPD_F (int) load_null_module( 1328 const void *module, const char *file_name); 1329 LDAP_SLAPD_F (int) load_extop_module( 1330 const void *module, const char *file_name); 1331 1332 LDAP_SLAPD_F (int) module_load LDAP_P(( 1333 const char* file_name, 1334 int argc, char *argv[] )); 1335 LDAP_SLAPD_F (int) module_path LDAP_P(( const char* path )); 1336 LDAP_SLAPD_F (int) module_unload LDAP_P(( const char* file_name )); 1337 1338 LDAP_SLAPD_F (void *) module_handle LDAP_P(( const char* file_name )); 1339 1340 LDAP_SLAPD_F (void *) module_resolve LDAP_P(( 1341 const void *module, const char *name)); 1342 1343 #endif /* SLAPD_MODULES */ 1344 1345 /* mr.c */ 1346 LDAP_SLAPD_F (MatchingRule *) mr_bvfind LDAP_P((struct berval *mrname)); 1347 LDAP_SLAPD_F (MatchingRule *) mr_find LDAP_P((const char *mrname)); 1348 LDAP_SLAPD_F (int) mr_add LDAP_P(( LDAPMatchingRule *mr, 1349 slap_mrule_defs_rec *def, 1350 MatchingRule * associated, 1351 const char **err )); 1352 LDAP_SLAPD_F (void) mr_destroy LDAP_P(( void )); 1353 1354 LDAP_SLAPD_F (int) register_matching_rule LDAP_P(( 1355 slap_mrule_defs_rec *def )); 1356 1357 LDAP_SLAPD_F (void) mru_destroy LDAP_P(( void )); 1358 LDAP_SLAPD_F (int) matching_rule_use_init LDAP_P(( void )); 1359 1360 LDAP_SLAPD_F (int) mr_schema_info LDAP_P(( Entry *e )); 1361 LDAP_SLAPD_F (int) mru_schema_info LDAP_P(( Entry *e )); 1362 1363 LDAP_SLAPD_F (int) mr_usable_with_at LDAP_P(( MatchingRule *mr, 1364 AttributeType *at )); 1365 LDAP_SLAPD_F (int) mr_make_syntax_compat_with_mr LDAP_P(( 1366 Syntax *syn, 1367 MatchingRule *mr )); 1368 LDAP_SLAPD_F (int) mr_make_syntax_compat_with_mrs LDAP_P(( 1369 const char *syntax, 1370 char *const *mrs )); 1371 1372 /* 1373 * mra.c 1374 */ 1375 LDAP_SLAPD_F (int) get_mra LDAP_P(( 1376 Operation *op, 1377 BerElement *ber, 1378 Filter *f, 1379 const char **text )); 1380 LDAP_SLAPD_F (void) mra_free LDAP_P(( 1381 Operation *op, 1382 MatchingRuleAssertion *mra, 1383 int freeit )); 1384 1385 /* oc.c */ 1386 LDAP_SLAPD_F (int) oc_add LDAP_P(( 1387 LDAPObjectClass *oc, 1388 int user, 1389 ObjectClass **soc, 1390 ObjectClass *prev, 1391 const char **err)); 1392 LDAP_SLAPD_F (void) oc_destroy LDAP_P(( void )); 1393 1394 LDAP_SLAPD_F (ObjectClass *) oc_find LDAP_P(( 1395 const char *ocname)); 1396 LDAP_SLAPD_F (ObjectClass *) oc_bvfind LDAP_P(( 1397 struct berval *ocname)); 1398 LDAP_SLAPD_F (ObjectClass *) oc_bvfind_undef LDAP_P(( 1399 struct berval *ocname)); 1400 LDAP_SLAPD_F (int) is_object_subclass LDAP_P(( 1401 ObjectClass *sup, 1402 ObjectClass *sub )); 1403 1404 LDAP_SLAPD_F (int) is_entry_objectclass LDAP_P(( 1405 Entry *, ObjectClass *oc, unsigned flags )); 1406 #define is_entry_objectclass_or_sub(e,oc) \ 1407 (is_entry_objectclass((e),(oc),SLAP_OCF_CHECK_SUP)) 1408 #define is_entry_alias(e) \ 1409 (((e)->e_ocflags & SLAP_OC__END) \ 1410 ? (((e)->e_ocflags & SLAP_OC_ALIAS) != 0) \ 1411 : is_entry_objectclass((e), slap_schema.si_oc_alias, SLAP_OCF_SET_FLAGS)) 1412 #define is_entry_referral(e) \ 1413 (((e)->e_ocflags & SLAP_OC__END) \ 1414 ? (((e)->e_ocflags & SLAP_OC_REFERRAL) != 0) \ 1415 : is_entry_objectclass((e), slap_schema.si_oc_referral, SLAP_OCF_SET_FLAGS)) 1416 #define is_entry_subentry(e) \ 1417 (((e)->e_ocflags & SLAP_OC__END) \ 1418 ? (((e)->e_ocflags & SLAP_OC_SUBENTRY) != 0) \ 1419 : is_entry_objectclass((e), slap_schema.si_oc_subentry, SLAP_OCF_SET_FLAGS)) 1420 #define is_entry_collectiveAttributeSubentry(e) \ 1421 (((e)->e_ocflags & SLAP_OC__END) \ 1422 ? (((e)->e_ocflags & SLAP_OC_COLLECTIVEATTRIBUTESUBENTRY) != 0) \ 1423 : is_entry_objectclass((e), slap_schema.si_oc_collectiveAttributeSubentry, SLAP_OCF_SET_FLAGS)) 1424 #define is_entry_dynamicObject(e) \ 1425 (((e)->e_ocflags & SLAP_OC__END) \ 1426 ? (((e)->e_ocflags & SLAP_OC_DYNAMICOBJECT) != 0) \ 1427 : is_entry_objectclass((e), slap_schema.si_oc_dynamicObject, SLAP_OCF_SET_FLAGS)) 1428 #define is_entry_glue(e) \ 1429 (((e)->e_ocflags & SLAP_OC__END) \ 1430 ? (((e)->e_ocflags & SLAP_OC_GLUE) != 0) \ 1431 : is_entry_objectclass((e), slap_schema.si_oc_glue, SLAP_OCF_SET_FLAGS)) 1432 #define is_entry_syncProviderSubentry(e) \ 1433 (((e)->e_ocflags & SLAP_OC__END) \ 1434 ? (((e)->e_ocflags & SLAP_OC_SYNCPROVIDERSUBENTRY) != 0) \ 1435 : is_entry_objectclass((e), slap_schema.si_oc_syncProviderSubentry, SLAP_OCF_SET_FLAGS)) 1436 #define is_entry_syncConsumerSubentry(e) \ 1437 (((e)->e_ocflags & SLAP_OC__END) \ 1438 ? (((e)->e_ocflags & SLAP_OC_SYNCCONSUMERSUBENTRY) != 0) \ 1439 : is_entry_objectclass((e), slap_schema.si_oc_syncConsumerSubentry, SLAP_OCF_SET_FLAGS)) 1440 1441 LDAP_SLAPD_F (int) oc_schema_info( Entry *e ); 1442 1443 LDAP_SLAPD_F (int) oc_start LDAP_P(( ObjectClass **oc )); 1444 LDAP_SLAPD_F (int) oc_next LDAP_P(( ObjectClass **oc )); 1445 LDAP_SLAPD_F (void) oc_delete LDAP_P(( ObjectClass *oc )); 1446 1447 LDAP_SLAPD_F (void) oc_unparse LDAP_P(( 1448 BerVarray *bva, ObjectClass *start, ObjectClass *end, int system )); 1449 1450 LDAP_SLAPD_F (int) register_oc LDAP_P(( 1451 const char *desc, 1452 ObjectClass **oc, 1453 int dupok )); 1454 1455 /* 1456 * oidm.c 1457 */ 1458 LDAP_SLAPD_F(char *) oidm_find(char *oid); 1459 LDAP_SLAPD_F (void) oidm_destroy LDAP_P(( void )); 1460 LDAP_SLAPD_F (void) oidm_unparse LDAP_P(( 1461 BerVarray *bva, OidMacro *start, OidMacro *end, int system )); 1462 LDAP_SLAPD_F (int) parse_oidm LDAP_P(( 1463 struct config_args_s *ca, int user, OidMacro **om )); 1464 1465 /* 1466 * operation.c 1467 */ 1468 LDAP_SLAPD_F (void) slap_op_init LDAP_P(( void )); 1469 LDAP_SLAPD_F (void) slap_op_destroy LDAP_P(( void )); 1470 LDAP_SLAPD_F (void) slap_op_groups_free LDAP_P(( Operation *op )); 1471 LDAP_SLAPD_F (void) slap_op_free LDAP_P(( Operation *op, void *ctx )); 1472 LDAP_SLAPD_F (void) slap_op_time LDAP_P(( time_t *t, int *n )); 1473 LDAP_SLAPD_F (Operation *) slap_op_alloc LDAP_P(( 1474 BerElement *ber, ber_int_t msgid, 1475 ber_tag_t tag, ber_int_t id, void *ctx )); 1476 1477 LDAP_SLAPD_F (slap_op_t) slap_req2op LDAP_P(( ber_tag_t tag )); 1478 1479 /* 1480 * operational.c 1481 */ 1482 LDAP_SLAPD_F (Attribute *) slap_operational_subschemaSubentry( Backend *be ); 1483 LDAP_SLAPD_F (Attribute *) slap_operational_entryDN( Entry *e ); 1484 LDAP_SLAPD_F (Attribute *) slap_operational_hasSubordinate( int has ); 1485 1486 /* 1487 * overlays.c 1488 */ 1489 LDAP_SLAPD_F (int) overlay_init( void ); 1490 1491 /* 1492 * passwd.c 1493 */ 1494 LDAP_SLAPD_F (SLAP_EXTOP_MAIN_FN) passwd_extop; 1495 1496 LDAP_SLAPD_F (int) slap_passwd_check( 1497 Operation *op, 1498 Entry *e, 1499 Attribute *a, 1500 struct berval *cred, 1501 const char **text ); 1502 1503 LDAP_SLAPD_F (void) slap_passwd_generate( struct berval * ); 1504 1505 LDAP_SLAPD_F (void) slap_passwd_hash( 1506 struct berval *cred, 1507 struct berval *hash, 1508 const char **text ); 1509 1510 LDAP_SLAPD_F (void) slap_passwd_hash_type( 1511 struct berval *cred, 1512 struct berval *hash, 1513 char *htype, 1514 const char **text ); 1515 1516 LDAP_SLAPD_F (struct berval *) slap_passwd_return( 1517 struct berval *cred ); 1518 1519 LDAP_SLAPD_F (int) slap_passwd_parse( 1520 struct berval *reqdata, 1521 struct berval *id, 1522 struct berval *oldpass, 1523 struct berval *newpass, 1524 const char **text ); 1525 1526 LDAP_SLAPD_F (void) slap_passwd_init (void); 1527 1528 /* 1529 * phonetic.c 1530 */ 1531 LDAP_SLAPD_F (char *) phonetic LDAP_P(( char *s )); 1532 1533 /* 1534 * referral.c 1535 */ 1536 LDAP_SLAPD_F (int) validate_global_referral LDAP_P(( 1537 const char *url )); 1538 1539 LDAP_SLAPD_F (BerVarray) get_entry_referrals LDAP_P(( 1540 Operation *op, Entry *e )); 1541 1542 LDAP_SLAPD_F (BerVarray) referral_rewrite LDAP_P(( 1543 BerVarray refs, 1544 struct berval *base, 1545 struct berval *target, 1546 int scope )); 1547 1548 LDAP_SLAPD_F (int) get_alias_dn LDAP_P(( 1549 Entry *e, 1550 struct berval *ndn, 1551 int *err, 1552 const char **text )); 1553 1554 /* 1555 * result.c 1556 */ 1557 #if USE_RS_ASSERT /*defined(USE_RS_ASSERT)?(USE_RS_ASSERT):defined(LDAP_TEST)*/ 1558 #ifdef __GNUC__ 1559 # define RS_FUNC_ __FUNCTION__ 1560 #elif defined(__STDC_VERSION__) && (__STDC_VERSION__) >= 199901L 1561 # define RS_FUNC_ __func__ 1562 #else 1563 # define rs_assert_(file, line, func, cond) rs_assert__(file, line, cond) 1564 #endif 1565 LDAP_SLAPD_V(int) rs_suppress_assert; 1566 LDAP_SLAPD_F(void) rs_assert_(const char*, unsigned, const char*, const char*); 1567 # define RS_ASSERT(cond) ((rs_suppress_assert > 0 || (cond)) \ 1568 ? (void) 0 : rs_assert_(__FILE__, __LINE__, RS_FUNC_, #cond)) 1569 #else 1570 # define RS_ASSERT(cond) ((void) 0) 1571 # define rs_assert_ok(rs) ((void) (rs)) 1572 # define rs_assert_ready(rs) ((void) (rs)) 1573 # define rs_assert_done(rs) ((void) (rs)) 1574 #endif 1575 LDAP_SLAPD_F (void) (rs_assert_ok) LDAP_P(( const SlapReply *rs )); 1576 LDAP_SLAPD_F (void) (rs_assert_ready) LDAP_P(( const SlapReply *rs )); 1577 LDAP_SLAPD_F (void) (rs_assert_done) LDAP_P(( const SlapReply *rs )); 1578 1579 #define rs_reinit(rs, type) do { \ 1580 SlapReply *const rsRI = (rs); \ 1581 rs_assert_done( rsRI ); \ 1582 rsRI->sr_type = (type); \ 1583 /* Got type before memset in case of rs_reinit(rs, rs->sr_type) */ \ 1584 assert( !offsetof( SlapReply, sr_type ) ); \ 1585 memset( (slap_reply_t *) rsRI + 1, 0, \ 1586 sizeof(*rsRI) - sizeof(slap_reply_t) ); \ 1587 } while ( 0 ) 1588 LDAP_SLAPD_F (void) (rs_reinit) LDAP_P(( SlapReply *rs, slap_reply_t type )); 1589 LDAP_SLAPD_F (void) rs_flush_entry LDAP_P(( Operation *op, 1590 SlapReply *rs, slap_overinst *on )); 1591 LDAP_SLAPD_F (void) rs_replace_entry LDAP_P(( Operation *op, 1592 SlapReply *rs, slap_overinst *on, Entry *e )); 1593 LDAP_SLAPD_F (int) rs_entry2modifiable LDAP_P(( Operation *op, 1594 SlapReply *rs, slap_overinst *on )); 1595 #define rs_ensure_entry_modifiable rs_entry2modifiable /* older name */ 1596 LDAP_SLAPD_F (void) slap_send_ldap_result LDAP_P(( Operation *op, SlapReply *rs )); 1597 LDAP_SLAPD_F (void) send_ldap_sasl LDAP_P(( Operation *op, SlapReply *rs )); 1598 LDAP_SLAPD_F (void) send_ldap_disconnect LDAP_P(( Operation *op, SlapReply *rs )); 1599 LDAP_SLAPD_F (void) slap_send_ldap_extended LDAP_P(( Operation *op, SlapReply *rs )); 1600 LDAP_SLAPD_F (void) slap_send_ldap_intermediate LDAP_P(( Operation *op, SlapReply *rs )); 1601 LDAP_SLAPD_F (void) slap_send_search_result LDAP_P(( Operation *op, SlapReply *rs )); 1602 LDAP_SLAPD_F (int) slap_send_search_reference LDAP_P(( Operation *op, SlapReply *rs )); 1603 LDAP_SLAPD_F (int) slap_send_search_entry LDAP_P(( Operation *op, SlapReply *rs )); 1604 LDAP_SLAPD_F (int) slap_null_cb LDAP_P(( Operation *op, SlapReply *rs )); 1605 LDAP_SLAPD_F (int) slap_freeself_cb LDAP_P(( Operation *op, SlapReply *rs )); 1606 1607 LDAP_SLAPD_V( const struct berval ) slap_pre_read_bv; 1608 LDAP_SLAPD_V( const struct berval ) slap_post_read_bv; 1609 LDAP_SLAPD_F (int) slap_read_controls LDAP_P(( Operation *op, SlapReply *rs, 1610 Entry *e, const struct berval *oid, LDAPControl **ctrl )); 1611 1612 LDAP_SLAPD_F (int) str2result LDAP_P(( char *s, 1613 int *code, char **matched, char **info )); 1614 LDAP_SLAPD_F (int) slap_map_api2result LDAP_P(( SlapReply *rs )); 1615 LDAP_SLAPD_F (slap_mask_t) slap_attr_flags LDAP_P(( AttributeName *an )); 1616 LDAP_SLAPD_F (ber_tag_t) slap_req2res LDAP_P(( ber_tag_t tag )); 1617 1618 LDAP_SLAPD_V( const struct berval ) slap_dummy_bv; 1619 1620 /* 1621 * root_dse.c 1622 */ 1623 LDAP_SLAPD_F (int) root_dse_init LDAP_P(( void )); 1624 LDAP_SLAPD_F (int) root_dse_destroy LDAP_P(( void )); 1625 1626 LDAP_SLAPD_F (int) root_dse_info LDAP_P(( 1627 Connection *conn, 1628 Entry **e, 1629 const char **text )); 1630 1631 LDAP_SLAPD_F (int) root_dse_read_file LDAP_P(( 1632 const char *file)); 1633 1634 LDAP_SLAPD_F (int) slap_discover_feature LDAP_P(( 1635 slap_bindconf *sb, 1636 const char *attr, 1637 const char *val )); 1638 1639 LDAP_SLAPD_F (int) supported_feature_load LDAP_P(( struct berval *f )); 1640 LDAP_SLAPD_F (int) supported_feature_destroy LDAP_P(( void )); 1641 1642 LDAP_SLAPD_F (int) entry_info_register LDAP_P(( SLAP_ENTRY_INFO_FN func, void *arg )); 1643 LDAP_SLAPD_F (int) entry_info_unregister LDAP_P(( SLAP_ENTRY_INFO_FN func, void *arg )); 1644 LDAP_SLAPD_F (void) entry_info_destroy LDAP_P(( void )); 1645 1646 /* 1647 * sasl.c 1648 */ 1649 LDAP_SLAPD_F (int) slap_sasl_init(void); 1650 LDAP_SLAPD_F (char *) slap_sasl_secprops( const char * ); 1651 LDAP_SLAPD_F (void) slap_sasl_secprops_unparse( struct berval * ); 1652 LDAP_SLAPD_F (int) slap_sasl_destroy(void); 1653 1654 LDAP_SLAPD_F (int) slap_sasl_open( Connection *c, int reopen ); 1655 LDAP_SLAPD_F (char **) slap_sasl_mechs( Connection *c ); 1656 1657 LDAP_SLAPD_F (int) slap_sasl_external( Connection *c, 1658 slap_ssf_t ssf, /* relative strength of external security */ 1659 struct berval *authid ); /* asserted authenication id */ 1660 1661 LDAP_SLAPD_F (int) slap_sasl_reset( Connection *c ); 1662 LDAP_SLAPD_F (int) slap_sasl_close( Connection *c ); 1663 1664 LDAP_SLAPD_F (int) slap_sasl_bind LDAP_P(( Operation *op, SlapReply *rs )); 1665 1666 LDAP_SLAPD_F (int) slap_sasl_setpass( 1667 Operation *op, 1668 SlapReply *rs ); 1669 1670 LDAP_SLAPD_F (int) slap_sasl_getdn( Connection *conn, Operation *op, 1671 struct berval *id, char *user_realm, struct berval *dn, int flags ); 1672 1673 /* 1674 * saslauthz.c 1675 */ 1676 LDAP_SLAPD_F (int) slap_parse_user LDAP_P(( 1677 struct berval *id, struct berval *user, 1678 struct berval *realm, struct berval *mech )); 1679 LDAP_SLAPD_F (int) slap_sasl_matches LDAP_P(( 1680 Operation *op, BerVarray rules, 1681 struct berval *assertDN, struct berval *authc )); 1682 LDAP_SLAPD_F (void) slap_sasl2dn LDAP_P(( 1683 Operation *op, 1684 struct berval *saslname, 1685 struct berval *dn, 1686 int flags )); 1687 LDAP_SLAPD_F (int) slap_sasl_authorized LDAP_P(( 1688 Operation *op, 1689 struct berval *authcid, 1690 struct berval *authzid )); 1691 LDAP_SLAPD_F (int) slap_sasl_regexp_config LDAP_P(( 1692 const char *match, const char *replace )); 1693 LDAP_SLAPD_F (void) slap_sasl_regexp_unparse LDAP_P(( BerVarray *bva )); 1694 LDAP_SLAPD_F (int) slap_sasl_setpolicy LDAP_P(( const char * )); 1695 LDAP_SLAPD_F (const char *) slap_sasl_getpolicy LDAP_P(( void )); 1696 #ifdef SLAP_AUTH_REWRITE 1697 LDAP_SLAPD_F (int) slap_sasl_rewrite_config LDAP_P(( 1698 const char *fname, 1699 int lineno, 1700 int argc, 1701 char **argv )); 1702 LDAP_SLAPD_F (void) slap_sasl_regexp_destroy LDAP_P(( void )); 1703 #endif /* SLAP_AUTH_REWRITE */ 1704 LDAP_SLAPD_F (int) authzValidate LDAP_P(( 1705 Syntax *syn, struct berval *in )); 1706 #if 0 1707 LDAP_SLAPD_F (int) authzMatch LDAP_P(( 1708 int *matchp, 1709 slap_mask_t flags, 1710 Syntax *syntax, 1711 MatchingRule *mr, 1712 struct berval *value, 1713 void *assertedValue )); 1714 #endif 1715 LDAP_SLAPD_F (int) authzPretty LDAP_P(( 1716 Syntax *syntax, 1717 struct berval *val, 1718 struct berval *out, 1719 void *ctx )); 1720 LDAP_SLAPD_F (int) authzNormalize LDAP_P(( 1721 slap_mask_t usage, 1722 Syntax *syntax, 1723 MatchingRule *mr, 1724 struct berval *val, 1725 struct berval *normalized, 1726 void *ctx )); 1727 1728 /* 1729 * schema.c 1730 */ 1731 LDAP_SLAPD_F (int) schema_info LDAP_P(( Entry **entry, const char **text )); 1732 1733 /* 1734 * schema_check.c 1735 */ 1736 LDAP_SLAPD_F( int ) oc_check_allowed( 1737 AttributeType *type, 1738 ObjectClass **socs, 1739 ObjectClass *sc ); 1740 1741 LDAP_SLAPD_F( int ) structural_class( 1742 BerVarray ocs, 1743 ObjectClass **sc, 1744 ObjectClass ***socs, 1745 const char **text, 1746 char *textbuf, size_t textlen, void *ctx ); 1747 1748 LDAP_SLAPD_F( int ) entry_schema_check( 1749 Operation *op, 1750 Entry *e, 1751 Attribute *attrs, 1752 int manage, 1753 int add, 1754 Attribute **socp, 1755 const char** text, 1756 char *textbuf, size_t textlen ); 1757 1758 LDAP_SLAPD_F( int ) mods_structural_class( 1759 Modifications *mods, 1760 struct berval *oc, 1761 const char** text, 1762 char *textbuf, size_t textlen, void *ctx ); 1763 1764 /* 1765 * schema_init.c 1766 */ 1767 LDAP_SLAPD_V( int ) schema_init_done; 1768 LDAP_SLAPD_F (int) slap_schema_init LDAP_P((void)); 1769 LDAP_SLAPD_F (void) schema_destroy LDAP_P(( void )); 1770 1771 LDAP_SLAPD_F( slap_mr_indexer_func ) octetStringIndexer; 1772 LDAP_SLAPD_F( slap_mr_filter_func ) octetStringFilter; 1773 1774 LDAP_SLAPD_F( int ) numericoidValidate LDAP_P(( 1775 Syntax *syntax, 1776 struct berval *in )); 1777 LDAP_SLAPD_F( int ) numericStringValidate LDAP_P(( 1778 Syntax *syntax, 1779 struct berval *in )); 1780 LDAP_SLAPD_F( int ) octetStringMatch LDAP_P(( 1781 int *matchp, 1782 slap_mask_t flags, 1783 Syntax *syntax, 1784 MatchingRule *mr, 1785 struct berval *value, 1786 void *assertedValue )); 1787 LDAP_SLAPD_F( int ) octetStringOrderingMatch LDAP_P(( 1788 int *matchp, 1789 slap_mask_t flags, 1790 Syntax *syntax, 1791 MatchingRule *mr, 1792 struct berval *value, 1793 void *assertedValue )); 1794 1795 /* 1796 * schema_prep.c 1797 */ 1798 LDAP_SLAPD_V( struct slap_internal_schema ) slap_schema; 1799 LDAP_SLAPD_F (int) slap_schema_load LDAP_P((void)); 1800 LDAP_SLAPD_F (int) slap_schema_check LDAP_P((void)); 1801 1802 /* 1803 * schemaparse.c 1804 */ 1805 LDAP_SLAPD_F( int ) slap_valid_descr( const char * ); 1806 1807 LDAP_SLAPD_F (int) parse_cr LDAP_P(( 1808 struct config_args_s *ca, ContentRule **scr )); 1809 LDAP_SLAPD_F (int) parse_oc LDAP_P(( 1810 struct config_args_s *ca, ObjectClass **soc, ObjectClass *prev )); 1811 LDAP_SLAPD_F (int) parse_at LDAP_P(( 1812 struct config_args_s *ca, AttributeType **sat, AttributeType *prev )); 1813 LDAP_SLAPD_F (char *) scherr2str LDAP_P((int code)) LDAP_GCCATTR((const)); 1814 LDAP_SLAPD_F (int) dscompare LDAP_P(( const char *s1, const char *s2del, 1815 char delim )); 1816 LDAP_SLAPD_F (int) parse_syn LDAP_P(( 1817 struct config_args_s *ca, Syntax **sat, Syntax *prev )); 1818 1819 /* 1820 * sessionlog.c 1821 */ 1822 LDAP_SLAPD_F (int) slap_send_session_log LDAP_P(( 1823 Operation *, Operation *, SlapReply *)); 1824 LDAP_SLAPD_F (int) slap_add_session_log LDAP_P(( 1825 Operation *, Operation *, Entry * )); 1826 1827 /* 1828 * sl_malloc.c 1829 */ 1830 LDAP_SLAPD_F (void *) slap_sl_malloc LDAP_P(( 1831 ber_len_t size, void *ctx )); 1832 LDAP_SLAPD_F (void *) slap_sl_realloc LDAP_P(( 1833 void *block, ber_len_t size, void *ctx )); 1834 LDAP_SLAPD_F (void *) slap_sl_calloc LDAP_P(( 1835 ber_len_t nelem, ber_len_t size, void *ctx )); 1836 LDAP_SLAPD_F (void) slap_sl_free LDAP_P(( 1837 void *, void *ctx )); 1838 1839 LDAP_SLAPD_V (BerMemoryFunctions) slap_sl_mfuncs; 1840 1841 LDAP_SLAPD_F (void) slap_sl_mem_init LDAP_P(( void )); 1842 LDAP_SLAPD_F (void *) slap_sl_mem_create LDAP_P(( 1843 ber_len_t size, int stack, void *ctx, int flag )); 1844 LDAP_SLAPD_F (void) slap_sl_mem_detach LDAP_P(( void *ctx, void *memctx )); 1845 LDAP_SLAPD_F (void) slap_sl_mem_destroy LDAP_P(( void *key, void *data )); 1846 LDAP_SLAPD_F (void *) slap_sl_context LDAP_P(( void *ptr )); 1847 1848 /* 1849 * starttls.c 1850 */ 1851 LDAP_SLAPD_F (SLAP_EXTOP_MAIN_FN) starttls_extop; 1852 1853 /* 1854 * str2filter.c 1855 */ 1856 LDAP_SLAPD_F (Filter *) str2filter LDAP_P(( const char *str )); 1857 LDAP_SLAPD_F (Filter *) str2filter_x LDAP_P(( Operation *op, const char *str )); 1858 1859 /* 1860 * syncrepl.c 1861 */ 1862 1863 LDAP_SLAPD_F (int) syncrepl_add_glue LDAP_P(( 1864 Operation*, Entry* )); 1865 LDAP_SLAPD_F (void) syncrepl_diff_entry LDAP_P(( 1866 Operation *op, Attribute *old, Attribute *anew, 1867 Modifications **mods, Modifications **ml, int is_ctx )); 1868 LDAP_SLAPD_F (void) syncinfo_free LDAP_P(( struct syncinfo_s *, int all )); 1869 1870 /* syntax.c */ 1871 LDAP_SLAPD_F (int) syn_is_sup LDAP_P(( 1872 Syntax *syn, 1873 Syntax *sup )); 1874 LDAP_SLAPD_F (Syntax *) syn_find LDAP_P(( 1875 const char *synname )); 1876 LDAP_SLAPD_F (Syntax *) syn_find_desc LDAP_P(( 1877 const char *syndesc, int *slen )); 1878 LDAP_SLAPD_F (int) syn_add LDAP_P(( 1879 LDAPSyntax *syn, 1880 int user, 1881 slap_syntax_defs_rec *def, 1882 Syntax **ssyn, 1883 Syntax *prev, 1884 const char **err )); 1885 LDAP_SLAPD_F (void) syn_destroy LDAP_P(( void )); 1886 1887 LDAP_SLAPD_F (int) register_syntax LDAP_P(( 1888 slap_syntax_defs_rec *def )); 1889 1890 LDAP_SLAPD_F (int) syn_schema_info( Entry *e ); 1891 1892 LDAP_SLAPD_F (int) syn_start LDAP_P(( Syntax **at )); 1893 LDAP_SLAPD_F (int) syn_next LDAP_P(( Syntax **at )); 1894 LDAP_SLAPD_F (void) syn_delete LDAP_P(( Syntax *at )); 1895 1896 LDAP_SLAPD_F (void) syn_unparse LDAP_P(( 1897 BerVarray *bva, Syntax *start, Syntax *end, int system )); 1898 1899 /* 1900 * user.c 1901 */ 1902 #if defined(HAVE_PWD_H) && defined(HAVE_GRP_H) 1903 LDAP_SLAPD_F (void) slap_init_user LDAP_P(( char *username, char *groupname )); 1904 #endif 1905 1906 /* 1907 * value.c 1908 */ 1909 LDAP_SLAPD_F (int) asserted_value_validate_normalize LDAP_P(( 1910 AttributeDescription *ad, 1911 MatchingRule *mr, 1912 unsigned usage, 1913 struct berval *in, 1914 struct berval *out, 1915 const char ** text, 1916 void *ctx )); 1917 1918 LDAP_SLAPD_F (int) value_match LDAP_P(( 1919 int *match, 1920 AttributeDescription *ad, 1921 MatchingRule *mr, 1922 unsigned flags, 1923 struct berval *v1, 1924 void *v2, 1925 const char ** text )); 1926 LDAP_SLAPD_F (int) value_find_ex LDAP_P(( 1927 AttributeDescription *ad, 1928 unsigned flags, 1929 BerVarray values, 1930 struct berval *value, 1931 void *ctx )); 1932 1933 LDAP_SLAPD_F (int) ordered_value_add LDAP_P(( 1934 Entry *e, 1935 AttributeDescription *ad, 1936 Attribute *a, 1937 BerVarray vals, 1938 BerVarray nvals )); 1939 1940 LDAP_SLAPD_F (int) ordered_value_validate LDAP_P(( 1941 AttributeDescription *ad, 1942 struct berval *in, 1943 int mop )); 1944 1945 LDAP_SLAPD_F (int) ordered_value_pretty LDAP_P(( 1946 AttributeDescription *ad, 1947 struct berval *val, 1948 struct berval *out, 1949 void *ctx )); 1950 1951 LDAP_SLAPD_F (int) ordered_value_normalize LDAP_P(( 1952 slap_mask_t usage, 1953 AttributeDescription *ad, 1954 MatchingRule *mr, 1955 struct berval *val, 1956 struct berval *normalized, 1957 void *ctx )); 1958 1959 LDAP_SLAPD_F (int) ordered_value_match LDAP_P(( 1960 int *match, 1961 AttributeDescription *ad, 1962 MatchingRule *mr, 1963 unsigned flags, 1964 struct berval *v1, 1965 struct berval *v2, 1966 const char ** text )); 1967 1968 LDAP_SLAPD_F (void) ordered_value_renumber LDAP_P(( 1969 Attribute *a )); 1970 1971 LDAP_SLAPD_F (int) ordered_value_sort LDAP_P(( 1972 Attribute *a, 1973 int do_renumber )); 1974 1975 LDAP_SLAPD_F (int) value_add LDAP_P(( 1976 BerVarray *vals, 1977 BerVarray addvals )); 1978 LDAP_SLAPD_F (int) value_add_one LDAP_P(( 1979 BerVarray *vals, 1980 struct berval *addval )); 1981 1982 /* assumes (x) > (y) returns 1 if true, 0 otherwise */ 1983 #define SLAP_PTRCMP(x, y) ((x) < (y) ? -1 : (x) > (y)) 1984 1985 #ifdef SLAP_ZONE_ALLOC 1986 /* 1987 * zn_malloc.c 1988 */ 1989 LDAP_SLAPD_F (void *) slap_zn_malloc LDAP_P((ber_len_t, void *)); 1990 LDAP_SLAPD_F (void *) slap_zn_realloc LDAP_P((void *, ber_len_t, void *)); 1991 LDAP_SLAPD_F (void *) slap_zn_calloc LDAP_P((ber_len_t, ber_len_t, void *)); 1992 LDAP_SLAPD_F (void) slap_zn_free LDAP_P((void *, void *)); 1993 1994 LDAP_SLAPD_F (void *) slap_zn_mem_create LDAP_P(( 1995 ber_len_t, ber_len_t, ber_len_t, ber_len_t)); 1996 LDAP_SLAPD_F (void) slap_zn_mem_destroy LDAP_P((void *)); 1997 LDAP_SLAPD_F (int) slap_zn_validate LDAP_P((void *, void *, int)); 1998 LDAP_SLAPD_F (int) slap_zn_invalidate LDAP_P((void *, void *)); 1999 LDAP_SLAPD_F (int) slap_zh_rlock LDAP_P((void*)); 2000 LDAP_SLAPD_F (int) slap_zh_runlock LDAP_P((void*)); 2001 LDAP_SLAPD_F (int) slap_zh_wlock LDAP_P((void*)); 2002 LDAP_SLAPD_F (int) slap_zh_wunlock LDAP_P((void*)); 2003 LDAP_SLAPD_F (int) slap_zn_rlock LDAP_P((void*, void*)); 2004 LDAP_SLAPD_F (int) slap_zn_runlock LDAP_P((void*, void*)); 2005 LDAP_SLAPD_F (int) slap_zn_wlock LDAP_P((void*, void*)); 2006 LDAP_SLAPD_F (int) slap_zn_wunlock LDAP_P((void*, void*)); 2007 #endif 2008 2009 /* 2010 * Other... 2011 */ 2012 LDAP_SLAPD_V (unsigned int) index_substr_if_minlen; 2013 LDAP_SLAPD_V (unsigned int) index_substr_if_maxlen; 2014 LDAP_SLAPD_V (unsigned int) index_substr_any_len; 2015 LDAP_SLAPD_V (unsigned int) index_substr_any_step; 2016 LDAP_SLAPD_V (unsigned int) index_intlen; 2017 /* all signed integers from strings of this size need more than intlen bytes */ 2018 /* i.e. log(10)*(index_intlen_strlen-2) > log(2)*(8*(index_intlen)-1) */ 2019 LDAP_SLAPD_V (unsigned int) index_intlen_strlen; 2020 #define SLAP_INDEX_INTLEN_STRLEN(intlen) ((8*(intlen)-1) * 146/485 + 3) 2021 2022 LDAP_SLAPD_V (ber_len_t) sockbuf_max_incoming; 2023 LDAP_SLAPD_V (ber_len_t) sockbuf_max_incoming_auth; 2024 LDAP_SLAPD_V (int) slap_conn_max_pending; 2025 LDAP_SLAPD_V (int) slap_conn_max_pending_auth; 2026 2027 LDAP_SLAPD_V (slap_mask_t) global_allows; 2028 LDAP_SLAPD_V (slap_mask_t) global_disallows; 2029 2030 LDAP_SLAPD_V (BerVarray) default_referral; 2031 LDAP_SLAPD_V (const char) Versionstr[]; 2032 2033 LDAP_SLAPD_V (int) global_gentlehup; 2034 LDAP_SLAPD_V (int) global_idletimeout; 2035 LDAP_SLAPD_V (int) global_writetimeout; 2036 LDAP_SLAPD_V (char *) global_host; 2037 LDAP_SLAPD_V (struct berval) global_host_bv; 2038 LDAP_SLAPD_V (char *) global_realm; 2039 LDAP_SLAPD_V (char *) sasl_host; 2040 LDAP_SLAPD_V (char *) slap_sasl_auxprops; 2041 LDAP_SLAPD_V (char **) default_passwd_hash; 2042 LDAP_SLAPD_V (int) lber_debug; 2043 LDAP_SLAPD_V (int) ldap_syslog; 2044 LDAP_SLAPD_V (struct berval) default_search_base; 2045 LDAP_SLAPD_V (struct berval) default_search_nbase; 2046 2047 LDAP_SLAPD_V (slap_counters_t) slap_counters; 2048 2049 LDAP_SLAPD_V (char *) slapd_pid_file; 2050 LDAP_SLAPD_V (char *) slapd_args_file; 2051 LDAP_SLAPD_V (time_t) starttime; 2052 2053 /* use time(3) -- no mutex */ 2054 #define slap_get_time() time( NULL ) 2055 2056 LDAP_SLAPD_V (ldap_pvt_thread_pool_t) connection_pool; 2057 LDAP_SLAPD_V (int) connection_pool_max; 2058 LDAP_SLAPD_V (int) slap_tool_thread_max; 2059 2060 LDAP_SLAPD_V (ldap_pvt_thread_mutex_t) entry2str_mutex; 2061 2062 #ifndef LDAP_DEVEL 2063 /* to be removed with 2.5 */ 2064 #define gmtime_mutex ldap_int_gmtime_mutex 2065 #endif /* ! LDAP_DEVEL */ 2066 2067 LDAP_SLAPD_V (ldap_pvt_thread_mutex_t) ad_index_mutex; 2068 LDAP_SLAPD_V (ldap_pvt_thread_mutex_t) ad_undef_mutex; 2069 LDAP_SLAPD_V (ldap_pvt_thread_mutex_t) oc_undef_mutex; 2070 2071 LDAP_SLAPD_V (ber_socket_t) dtblsize; 2072 2073 LDAP_SLAPD_V (int) use_reverse_lookup; 2074 2075 /* 2076 * operations 2077 */ 2078 LDAP_SLAPD_F (int) do_abandon LDAP_P((Operation *op, SlapReply *rs)); 2079 LDAP_SLAPD_F (int) do_add LDAP_P((Operation *op, SlapReply *rs)); 2080 LDAP_SLAPD_F (int) do_bind LDAP_P((Operation *op, SlapReply *rs)); 2081 LDAP_SLAPD_F (int) do_compare LDAP_P((Operation *op, SlapReply *rs)); 2082 LDAP_SLAPD_F (int) do_delete LDAP_P((Operation *op, SlapReply *rs)); 2083 LDAP_SLAPD_F (int) do_modify LDAP_P((Operation *op, SlapReply *rs)); 2084 LDAP_SLAPD_F (int) do_modrdn LDAP_P((Operation *op, SlapReply *rs)); 2085 LDAP_SLAPD_F (int) do_search LDAP_P((Operation *op, SlapReply *rs)); 2086 LDAP_SLAPD_F (int) do_unbind LDAP_P((Operation *op, SlapReply *rs)); 2087 LDAP_SLAPD_F (int) do_extended LDAP_P((Operation *op, SlapReply *rs)); 2088 2089 /* 2090 * frontend operations 2091 */ 2092 LDAP_SLAPD_F (int) fe_op_abandon LDAP_P((Operation *op, SlapReply *rs)); 2093 LDAP_SLAPD_F (int) fe_op_add LDAP_P((Operation *op, SlapReply *rs)); 2094 LDAP_SLAPD_F (int) fe_op_bind LDAP_P((Operation *op, SlapReply *rs)); 2095 LDAP_SLAPD_F (int) fe_op_bind_success LDAP_P(( Operation *op, SlapReply *rs )); 2096 LDAP_SLAPD_F (int) fe_op_compare LDAP_P((Operation *op, SlapReply *rs)); 2097 LDAP_SLAPD_F (int) fe_op_delete LDAP_P((Operation *op, SlapReply *rs)); 2098 LDAP_SLAPD_F (int) fe_op_modify LDAP_P((Operation *op, SlapReply *rs)); 2099 LDAP_SLAPD_F (int) fe_op_modrdn LDAP_P((Operation *op, SlapReply *rs)); 2100 LDAP_SLAPD_F (int) fe_op_search LDAP_P((Operation *op, SlapReply *rs)); 2101 LDAP_SLAPD_F (int) fe_aux_operational LDAP_P((Operation *op, SlapReply *rs)); 2102 #if 0 2103 LDAP_SLAPD_F (int) fe_op_unbind LDAP_P((Operation *op, SlapReply *rs)); 2104 #endif 2105 LDAP_SLAPD_F (int) fe_extended LDAP_P((Operation *op, SlapReply *rs)); 2106 LDAP_SLAPD_F (int) fe_acl_group LDAP_P(( 2107 Operation *op, 2108 Entry *target, 2109 struct berval *gr_ndn, 2110 struct berval *op_ndn, 2111 ObjectClass *group_oc, 2112 AttributeDescription *group_at )); 2113 LDAP_SLAPD_F (int) fe_acl_attribute LDAP_P(( 2114 Operation *op, 2115 Entry *target, 2116 struct berval *edn, 2117 AttributeDescription *entry_at, 2118 BerVarray *vals, 2119 slap_access_t access )); 2120 LDAP_SLAPD_F (int) fe_access_allowed LDAP_P(( 2121 Operation *op, 2122 Entry *e, 2123 AttributeDescription *desc, 2124 struct berval *val, 2125 slap_access_t access, 2126 AccessControlState *state, 2127 slap_mask_t *maskp )); 2128 2129 /* NOTE: this macro assumes that bv has been allocated 2130 * by ber_* malloc functions or is { 0L, NULL } */ 2131 #ifdef USE_MP_BIGNUM 2132 # define UI2BVX(bv,ui,ctx) \ 2133 do { \ 2134 char *val; \ 2135 ber_len_t len; \ 2136 val = BN_bn2dec(ui); \ 2137 if (val) { \ 2138 len = strlen(val); \ 2139 if ( len > (bv)->bv_len ) { \ 2140 (bv)->bv_val = ber_memrealloc_x( (bv)->bv_val, len + 1, (ctx) ); \ 2141 } \ 2142 AC_MEMCPY((bv)->bv_val, val, len + 1); \ 2143 (bv)->bv_len = len; \ 2144 OPENSSL_free(val); \ 2145 } else { \ 2146 ber_memfree_x( (bv)->bv_val, (ctx) ); \ 2147 BER_BVZERO( (bv) ); \ 2148 } \ 2149 } while ( 0 ) 2150 2151 #elif defined( USE_MP_GMP ) 2152 /* NOTE: according to the documentation, the result 2153 * of mpz_sizeinbase() can exceed the length of the 2154 * string representation of the number by 1 2155 */ 2156 # define UI2BVX(bv,ui,ctx) \ 2157 do { \ 2158 ber_len_t len = mpz_sizeinbase( (ui), 10 ); \ 2159 if ( len > (bv)->bv_len ) { \ 2160 (bv)->bv_val = ber_memrealloc_x( (bv)->bv_val, len + 1, (ctx) ); \ 2161 } \ 2162 (void)mpz_get_str( (bv)->bv_val, 10, (ui) ); \ 2163 if ( (bv)->bv_val[ len - 1 ] == '\0' ) { \ 2164 len--; \ 2165 } \ 2166 (bv)->bv_len = len; \ 2167 } while ( 0 ) 2168 2169 #else 2170 # ifdef USE_MP_LONG_LONG 2171 # define UI2BV_FORMAT "%llu" 2172 # elif defined USE_MP_LONG 2173 # define UI2BV_FORMAT "%lu" 2174 # elif defined HAVE_LONG_LONG 2175 # define UI2BV_FORMAT "%llu" 2176 # else 2177 # define UI2BV_FORMAT "%lu" 2178 # endif 2179 2180 # define UI2BVX(bv,ui,ctx) \ 2181 do { \ 2182 char buf[LDAP_PVT_INTTYPE_CHARS(long)]; \ 2183 ber_len_t len; \ 2184 len = snprintf( buf, sizeof( buf ), UI2BV_FORMAT, (ui) ); \ 2185 if ( len > (bv)->bv_len ) { \ 2186 (bv)->bv_val = ber_memrealloc_x( (bv)->bv_val, len + 1, (ctx) ); \ 2187 } \ 2188 (bv)->bv_len = len; \ 2189 AC_MEMCPY( (bv)->bv_val, buf, len + 1 ); \ 2190 } while ( 0 ) 2191 #endif 2192 2193 #define UI2BV(bv,ui) UI2BVX(bv,ui,NULL) 2194 2195 LDAP_END_DECL 2196 2197 #endif /* PROTO_SLAP_H */ 2198