git.sur5r.net Git - openldap/blob - servers/slapd/back-monitor/proto-back-monitor.h

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 2001-2005 The OpenLDAP Foundation.
   5  * Portions Copyright 2001-2003 Pierangelo Masarati.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16 /* ACKNOWLEDGEMENTS:
  17  * This work was initially developed by Pierangelo Masarati for inclusion
  18  * in OpenLDAP Software.
  19  */
  20
  21 #ifndef _PROTO_BACK_MONITOR
  22 #define _PROTO_BACK_MONITOR
  23
  24 #include <ldap_cdefs.h>
  25
  26 LDAP_BEGIN_DECL
  27
  28 /*
  29  * backends
  30  */
  31 int
  32 monitor_subsys_backend_init LDAP_P((
  33         BackendDB               *be,
  34         monitor_subsys_t        *ms ));
  35
  36 /*
  37  * cache
  38  */
  39 extern int
  40 monitor_cache_cmp LDAP_P((
  41         const void              *c1,
  42         const void              *c2 ));
  43 extern int
  44 monitor_cache_dup LDAP_P((
  45         void                    *c1,
  46         void                    *c2 ));
  47 extern int
  48 monitor_cache_add LDAP_P((
  49         monitor_info_t          *mi,
  50         Entry                   *e ));
  51 extern int
  52 monitor_cache_get LDAP_P((
  53         monitor_info_t          *mi,
  54         struct berval           *ndn,
  55         Entry                   **ep ));
  56 extern int
  57 monitor_cache_dn2entry LDAP_P((
  58         Operation               *op,
  59         SlapReply               *rs,
  60         struct berval           *ndn,
  61         Entry                   **ep,
  62         Entry                   **matched ));
  63 extern int
  64 monitor_cache_lock LDAP_P((
  65         Entry                   *e ));
  66 extern int
  67 monitor_cache_release LDAP_P((
  68         monitor_info_t          *mi,
  69         Entry                   *e ));
  70
  71 /*
  72  * connections
  73  */
  74 extern int
  75 monitor_subsys_conn_init LDAP_P((
  76         BackendDB               *be,
  77         monitor_subsys_t        *ms ));
  78 extern int
  79 monitor_subsys_conn_update LDAP_P((
  80         Operation               *op,
  81         SlapReply               *rs,
  82         Entry                   *e ));
  83 extern int
  84 monitor_subsys_conn_create LDAP_P((
  85         Operation               *op,
  86         SlapReply               *rs,
  87         struct berval           *ndn,
  88         Entry                   *e_parent,
  89         Entry                   **ep ));
  90
  91 /*
  92  * databases
  93  */
  94 extern int
  95 monitor_subsys_database_init LDAP_P((
  96         BackendDB               *be,
  97         monitor_subsys_t        *ms ));
  98 extern int
  99 monitor_subsys_database_modify LDAP_P((
 100         Operation               *op,
 101         SlapReply               *rs,
 102         Entry                   *e ));
 103
 104 /*
 105  * entry
 106  */
 107 extern int
 108 monitor_entry_update LDAP_P((
 109         Operation               *op,
 110         SlapReply               *rs,
 111         Entry                   *e ));
 112 extern int
 113 monitor_entry_create LDAP_P((
 114         Operation               *op,
 115         SlapReply               *rs,
 116         struct berval           *ndn,
 117         Entry                   *e_parent,
 118         Entry                   **ep ));
 119 extern int
 120 monitor_entry_modify LDAP_P((
 121         Operation               *op,
 122         SlapReply               *rs,
 123         Entry                   *e ));
 124 extern int
 125 monitor_entry_test_flags LDAP_P((
 126         monitor_entry_t         *mp,
 127         int                     cond ));
 128 extern monitor_entry_t *
 129 monitor_entrypriv_create LDAP_P((
 130         void ));
 131
 132 /*
 133  * init
 134  */
 135 extern int
 136 monitor_back_register_subsys LDAP_P((
 137         monitor_subsys_t        *ms ));
 138 extern monitor_subsys_t *
 139 monitor_back_get_subsys LDAP_P((
 140         const char              *name ));
 141 extern monitor_subsys_t *
 142 monitor_back_get_subsys_by_dn LDAP_P((
 143         struct berval           *ndn,
 144         int                     sub ));
 145 extern int
 146 monitor_back_register_entry LDAP_P((
 147         Entry                   *e,
 148         monitor_callback_t      *cb ));
 149 extern int
 150 monitor_back_register_entry_parent LDAP_P((
 151         Entry                   *e,
 152         monitor_callback_t      *cb,
 153         struct berval           *base,
 154         int                     scope,
 155         struct berval           *filter ));
 156 extern int
 157 monitor_filter2ndn LDAP_P((
 158         struct berval           *base,
 159         int                     scope,
 160         struct berval           *filter,
 161         struct berval           *ndn ));
 162 extern int
 163 monitor_back_register_entry_attrs LDAP_P((
 164         struct berval           *ndn,
 165         Attribute               *a,
 166         monitor_callback_t      *cb,
 167         struct berval           *base,
 168         int                     scope,
 169         struct berval           *filter ));
 170 extern int
 171 monitor_back_register_entry_callback LDAP_P((
 172         struct berval           *ndn,
 173         monitor_callback_t      *cb,
 174         struct berval           *base,
 175         int                     scope,
 176         struct berval           *filter ));
 177
 178 /*
 179  * listener
 180  */
 181 extern int
 182 monitor_subsys_listener_init LDAP_P((
 183         BackendDB               *be,
 184         monitor_subsys_t        *ms ));
 185
 186 /*
 187  * log
 188  */
 189 extern int
 190 monitor_subsys_log_init LDAP_P((
 191         BackendDB               *be,
 192         monitor_subsys_t        *ms ));
 193 extern int
 194 monitor_subsys_log_modify LDAP_P((
 195         Operation               *op,
 196         SlapReply               *rs,
 197         Entry                   *e ));
 198
 199 /*
 200  * operations
 201  */
 202 extern int
 203 monitor_subsys_ops_init LDAP_P((
 204         BackendDB               *be,
 205         monitor_subsys_t        *ms ));
 206 extern int
 207 monitor_subsys_ops_update LDAP_P((
 208         Operation               *op,
 209         SlapReply               *rs,
 210         Entry                   *e ));
 211
 212 /*
 213  * overlay
 214  */
 215 extern int
 216 monitor_subsys_overlay_init LDAP_P((
 217         BackendDB               *be,
 218         monitor_subsys_t        *ms ));
 219
 220 /*
 221  * sent
 222  */
 223 extern int
 224 monitor_subsys_sent_init LDAP_P((
 225         BackendDB               *be,
 226         monitor_subsys_t        *ms ));
 227 extern int
 228 monitor_subsys_sent_update LDAP_P((
 229         Operation               *op,
 230         SlapReply               *rs,
 231         Entry                   *e ));
 232
 233 /*
 234  * threads
 235  */
 236 extern int
 237 monitor_subsys_thread_init LDAP_P((
 238         BackendDB               *be,
 239         monitor_subsys_t        *ms ));
 240 extern int
 241 monitor_subsys_thread_update LDAP_P((
 242         Operation               *op,
 243         SlapReply               *rs,
 244         Entry                   *e ));
 245
 246 /*
 247  * time
 248  */
 249 extern int monitor_subsys_time_init LDAP_P((
 250         BackendDB               *be,
 251         monitor_subsys_t        *ms ));
 252 extern int
 253 monitor_subsys_time_update LDAP_P((
 254         Operation               *op,
 255         SlapReply               *rs,
 256         Entry                   *e ));
 257
 258 /*
 259  * waiters
 260  */
 261 extern int
 262 monitor_subsys_rww_init LDAP_P((
 263         BackendDB               *be,
 264         monitor_subsys_t        *ms ));
 265 extern int
 266 monitor_subsys_rww_update LDAP_P((
 267         Operation               *op,
 268         SlapReply               *rs,
 269         Entry                   *e ));
 270
 271 /* NOTE: this macro assumes that bv has been allocated
 272  * by ber_* malloc functions or is { 0L, NULL } */
 273 #if defined(HAVE_BIGNUM)
 274 #define UI2BV(bv,ui) \
 275         do { \
 276                 char            *val; \
 277                 ber_len_t       len; \
 278                 val = BN_bn2dec(ui); \
 279                 if (val) { \
 280                         len = strlen(val); \
 281                         if ( len > (bv)->bv_len ) { \
 282                                 (bv)->bv_val = ber_memrealloc( (bv)->bv_val, len + 1 ); \
 283                         } \
 284                         AC_MEMCPY((bv)->bv_val, val, len + 1); \
 285                         (bv)->bv_len = len; \
 286                         OPENSSL_free(val); \
 287                 } else { \
 288                         ber_memfree( (bv)->bv_val ); \
 289                         BER_BVZERO( (bv) ); \
 290                 } \
 291         } while ( 0 )
 292 #elif defined(HAVE_GMP)
 293 /* NOTE: according to the documentation, the result
 294  * of mpz_sizeinbase() can exceed the length of the
 295  * string representation of the number by 1
 296  */
 297 #define UI2BV(bv,ui) \
 298         do { \
 299                 ber_len_t       len = mpz_sizeinbase( (ui), 10 ); \
 300                 if ( len > (bv)->bv_len ) { \
 301                         (bv)->bv_val = ber_memrealloc( (bv)->bv_val, len + 1 ); \
 302                 } \
 303                 (void)mpz_get_str( (bv)->bv_val, 10, (ui) ); \
 304                 if ( (bv)->bv_val[ len - 1 ] == '\0' ) { \
 305                         len--; \
 306                 } \
 307                 (bv)->bv_len = len; \
 308         } while ( 0 )
 309 #else /* ! HAVE_BIGNUM && ! HAVE_GMP */
 310 #define UI2BV(bv,ui) \
 311         do { \
 312                 char            buf[] = "+9223372036854775807L"; \
 313                 ber_len_t       len; \
 314                 snprintf( buf, sizeof( buf ), "%lu", (ui) ); \
 315                 len = strlen( buf ); \
 316                 if ( len > (bv)->bv_len ) { \
 317                         (bv)->bv_val = ber_memrealloc( (bv)->bv_val, len + 1 ); \
 318                 } \
 319                 AC_MEMCPY( (bv)->bv_val, buf, len + 1 ); \
 320         } while ( 0 )
 321 #endif /* ! HAVE_GMP */
 322
 323 /*
 324  * former external.h
 325  */
 326
 327 extern BI_init                  monitor_back_initialize;
 328
 329 extern BI_db_init               monitor_back_db_init;
 330 extern BI_db_open               monitor_back_db_open;
 331 extern BI_config                monitor_back_config;
 332 extern BI_db_destroy            monitor_back_db_destroy;
 333 extern BI_db_config             monitor_back_db_config;
 334
 335 extern BI_op_search             monitor_back_search;
 336 extern BI_op_compare            monitor_back_compare;
 337 extern BI_op_modify             monitor_back_modify;
 338 extern BI_op_bind               monitor_back_bind;
 339 extern BI_operational           monitor_back_operational;
 340
 341 LDAP_END_DECL
 342
 343 #endif /* _PROTO_BACK_MONITOR */
 344