git.sur5r.net Git - openldap/blob - servers/slapd/overlays/dds.c

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 2005-2007 The OpenLDAP Foundation.
   5  * Portions Copyright 2005-2006 SysNet s.n.c.
   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 the 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, sponsored by SysNet s.n.c.
  19  */
  20
  21 #include "portable.h"
  22
  23 #ifdef SLAPD_OVER_DDS
  24
  25 #include <stdio.h>
  26
  27 #include <ac/string.h>
  28 #include <ac/time.h>
  29
  30 #include "slap.h"
  31 #include "lutil.h"
  32 #include "ldap_rq.h"
  33
  34 #include "config.h"
  35
  36 #define DDS_RF2589_MAX_TTL              (31557600)      /* 1 year + 6 hours */
  37 #define DDS_RF2589_DEFAULT_TTL          (86400)         /* 1 day */
  38 #define DDS_DEFAULT_INTERVAL            (3600)          /* 1 hour */
  39
  40 typedef struct dds_info_t {
  41         unsigned                di_flags;
  42 #define DDS_FOFF                (0x1U)          /* is this really needed? */
  43 #define DDS_SET(di, f)          ( (di)->di_flags & (f) )
  44
  45 #define DDS_OFF(di)             DDS_SET( (di), DDS_FOFF )
  46
  47         time_t                  di_max_ttl;
  48         time_t                  di_min_ttl;
  49         time_t                  di_default_ttl;
  50 #define DDS_DEFAULT_TTL(di)     \
  51         ( (di)->di_default_ttl ? (di)->di_default_ttl : (di)->di_max_ttl )
  52
  53         time_t                  di_tolerance;
  54
  55         /* expire check interval and task */
  56         time_t                  di_interval;
  57 #define DDS_INTERVAL(di)        \
  58         ( (di)->di_interval ? (di)->di_interval : DDS_DEFAULT_INTERVAL )
  59         struct re_s             *di_expire_task;
  60
  61         /* allows to limit the maximum number of dynamic objects */
  62         ldap_pvt_thread_mutex_t di_mutex;
  63         int                     di_num_dynamicObjects;
  64         int                     di_max_dynamicObjects;
  65
  66         /* used to advertize the dynamicSubtrees in the root DSE,
  67          * and to select the database in the expiration task */
  68         BerVarray               di_suffix;
  69         BerVarray               di_nsuffix;
  70 } dds_info_t;
  71
  72 static struct berval slap_EXOP_REFRESH = BER_BVC( LDAP_EXOP_REFRESH );
  73 static AttributeDescription     *ad_entryExpireTimestamp;
  74
  75 /* list of expired DNs */
  76 typedef struct dds_expire_t {
  77         struct berval           de_ndn;
  78         struct dds_expire_t     *de_next;
  79 } dds_expire_t;
  80
  81 typedef struct dds_cb_t {
  82         dds_expire_t    *dc_ndnlist;
  83 } dds_cb_t;
  84
  85 static int
  86 dds_expire_cb( Operation *op, SlapReply *rs )
  87 {
  88         dds_cb_t        *dc = (dds_cb_t *)op->o_callback->sc_private;
  89         dds_expire_t    *de;
  90         int             rc;
  91
  92         switch ( rs->sr_type ) {
  93         case REP_SEARCH:
  94                 /* alloc list and buffer for berval all in one */
  95                 de = op->o_tmpalloc( sizeof( dds_expire_t ) + rs->sr_entry->e_nname.bv_len + 1,
  96                         op->o_tmpmemctx );
  97
  98                 de->de_next = dc->dc_ndnlist;
  99                 dc->dc_ndnlist = de;
 100
 101                 de->de_ndn.bv_len = rs->sr_entry->e_nname.bv_len;
 102                 de->de_ndn.bv_val = (char *)&de[ 1 ];
 103                 AC_MEMCPY( de->de_ndn.bv_val, rs->sr_entry->e_nname.bv_val,
 104                         rs->sr_entry->e_nname.bv_len + 1 );
 105                 rc = 0;
 106                 break;
 107
 108         case REP_SEARCHREF:
 109         case REP_RESULT:
 110                 rc = rs->sr_err;
 111                 break;
 112
 113         default:
 114                 assert( 0 );
 115         }
 116
 117         return rc;
 118 }
 119
 120 static int
 121 dds_expire( void *ctx, dds_info_t *di )
 122 {
 123         Connection      conn = { 0 };
 124         OperationBuffer opbuf;
 125         Operation       *op;
 126         slap_callback   sc = { 0 };
 127         dds_cb_t        dc = { 0 };
 128         dds_expire_t    *de = NULL, **dep;
 129         SlapReply       rs = { REP_RESULT };
 130
 131         time_t          expire;
 132         char            tsbuf[ LDAP_LUTIL_GENTIME_BUFSIZE ];
 133         struct berval   ts;
 134
 135         int             ndeletes, ntotdeletes;
 136
 137         int             rc;
 138         char            *extra = "";
 139
 140         connection_fake_init( &conn, &opbuf, ctx );
 141         op = &opbuf.ob_op;
 142
 143         op->o_tag = LDAP_REQ_SEARCH;
 144         memset( &op->oq_search, 0, sizeof( op->oq_search ) );
 145
 146         op->o_bd = select_backend( &di->di_nsuffix[ 0 ], 0 );
 147
 148         op->o_req_dn = op->o_bd->be_suffix[ 0 ];
 149         op->o_req_ndn = op->o_bd->be_nsuffix[ 0 ];
 150
 151         op->o_dn = op->o_bd->be_rootdn;
 152         op->o_ndn = op->o_bd->be_rootndn;
 153
 154         op->ors_scope = LDAP_SCOPE_SUBTREE;
 155         op->ors_tlimit = DDS_INTERVAL( di )/2 + 1;
 156         op->ors_slimit = SLAP_NO_LIMIT;
 157         op->ors_attrs = slap_anlist_no_attrs;
 158
 159         expire = slap_get_time() + di->di_tolerance;
 160         ts.bv_val = tsbuf;
 161         ts.bv_len = sizeof( tsbuf );
 162         slap_timestamp( &expire, &ts );
 163
 164         op->ors_filterstr.bv_len = STRLENOF( "(&(objectClass=" ")(" "<=" "))" )
 165                 + slap_schema.si_oc_dynamicObject->soc_cname.bv_len
 166                 + ad_entryExpireTimestamp->ad_cname.bv_len
 167                 + ts.bv_len;
 168         op->ors_filterstr.bv_val = op->o_tmpalloc( op->ors_filterstr.bv_len + 1, op->o_tmpmemctx );
 169         snprintf( op->ors_filterstr.bv_val, op->ors_filterstr.bv_len + 1,
 170                 "(&(objectClass=%s)(%s<=%s))",
 171                 slap_schema.si_oc_dynamicObject->soc_cname.bv_val,
 172                 ad_entryExpireTimestamp->ad_cname.bv_val, ts.bv_val );
 173
 174         op->ors_filter = str2filter_x( op, op->ors_filterstr.bv_val );
 175         if ( op->ors_filter == NULL ) {
 176                 rs.sr_err = LDAP_OTHER;
 177                 goto done_search;
 178         }
 179
 180         op->o_callback = &sc;
 181         sc.sc_response = dds_expire_cb;
 182         sc.sc_private = &dc;
 183
 184         (void)op->o_bd->bd_info->bi_op_search( op, &rs );
 185
 186 done_search:;
 187         op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx );
 188         filter_free_x( op, op->ors_filter );
 189
 190         rc = rs.sr_err;
 191         switch ( rs.sr_err ) {
 192         case LDAP_SUCCESS:
 193                 break;
 194
 195         case LDAP_NO_SUCH_OBJECT:
 196                 /* (ITS#5267) database not created yet? */
 197                 rs.sr_err = LDAP_SUCCESS;
 198                 extra = " (ignored)";
 199                 /* fallthru */
 200
 201         default:
 202                 Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
 203                         "DDS expired objects lookup failed err=%d%s\n",
 204                         rc, extra );
 205                 goto done;
 206         }
 207
 208         op->o_tag = LDAP_REQ_DELETE;
 209         op->o_callback = &sc;
 210         sc.sc_response = slap_null_cb;
 211         sc.sc_private = NULL;
 212
 213         for ( ntotdeletes = 0, ndeletes = 1; dc.dc_ndnlist != NULL  && ndeletes > 0; ) {
 214                 ndeletes = 0;
 215
 216                 for ( dep = &dc.dc_ndnlist; *dep != NULL; ) {
 217                         de = *dep;
 218
 219                         op->o_req_dn = de->de_ndn;
 220                         op->o_req_ndn = de->de_ndn;
 221                         (void)op->o_bd->bd_info->bi_op_delete( op, &rs );
 222                         switch ( rs.sr_err ) {
 223                         case LDAP_SUCCESS:
 224                                 Log1( LDAP_DEBUG_STATS, LDAP_LEVEL_INFO,
 225                                         "DDS dn=\"%s\" expired.\n",
 226                                         de->de_ndn.bv_val );
 227                                 ndeletes++;
 228                                 break;
 229
 230                         case LDAP_NOT_ALLOWED_ON_NONLEAF:
 231                                 Log1( LDAP_DEBUG_ANY, LDAP_LEVEL_NOTICE,
 232                                         "DDS dn=\"%s\" is non-leaf; "
 233                                         "deferring.\n",
 234                                         de->de_ndn.bv_val );
 235                                 dep = &de->de_next;
 236                                 de = NULL;
 237                                 break;
 238
 239                         default:
 240                                 Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_NOTICE,
 241                                         "DDS dn=\"%s\" err=%d; "
 242                                         "deferring.\n",
 243                                         de->de_ndn.bv_val, rs.sr_err );
 244                                 break;
 245                         }
 246
 247                         if ( de != NULL ) {
 248                                 *dep = de->de_next;
 249                                 dep = &de->de_next;
 250                                 op->o_tmpfree( de, op->o_tmpmemctx );
 251                         }
 252                 }
 253
 254                 ntotdeletes += ndeletes;
 255         }
 256
 257         rs.sr_err = LDAP_SUCCESS;
 258
 259         Log1( LDAP_DEBUG_STATS, LDAP_LEVEL_INFO,
 260                 "DDS expired=%d\n", ntotdeletes );
 261
 262 done:;
 263         return rs.sr_err;
 264 }
 265
 266 static void *
 267 dds_expire_fn( void *ctx, void *arg )
 268 {
 269         struct re_s     *rtask = arg;
 270         dds_info_t      *di = rtask->arg;
 271
 272         assert( di->di_expire_task == rtask );
 273
 274         (void)dds_expire( ctx, di );
 275
 276         ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex );
 277         if ( ldap_pvt_runqueue_isrunning( &slapd_rq, rtask )) {
 278                 ldap_pvt_runqueue_stoptask( &slapd_rq, rtask );
 279         }
 280         ldap_pvt_runqueue_resched( &slapd_rq, rtask, 0 );
 281         ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );
 282
 283         return NULL;
 284 }
 285
 286 /* frees the callback */
 287 static int
 288 dds_freeit_cb( Operation *op, SlapReply *rs )
 289 {
 290         op->o_tmpfree( op->o_callback, op->o_tmpmemctx );
 291         op->o_callback = NULL;
 292
 293         return SLAP_CB_CONTINUE;
 294 }
 295
 296 /* updates counter - installed on add/delete only if required */
 297 static int
 298 dds_counter_cb( Operation *op, SlapReply *rs )
 299 {
 300         assert( rs->sr_type == REP_RESULT );
 301
 302         if ( rs->sr_err == LDAP_SUCCESS ) {
 303                 dds_info_t      *di = op->o_callback->sc_private;
 304
 305                 ldap_pvt_thread_mutex_lock( &di->di_mutex );
 306                 switch ( op->o_tag ) {
 307                 case LDAP_REQ_DELETE:
 308                         assert( di->di_num_dynamicObjects > 0 );
 309                         di->di_num_dynamicObjects--;
 310                         break;
 311
 312                 case LDAP_REQ_ADD:
 313                         assert( di->di_num_dynamicObjects < di->di_max_dynamicObjects );
 314                         di->di_num_dynamicObjects++;
 315                         break;
 316
 317                 default:
 318                         assert( 0 );
 319                 }
 320                 ldap_pvt_thread_mutex_unlock( &di->di_mutex );
 321         }
 322
 323         return dds_freeit_cb( op, rs );
 324 }
 325
 326 static int
 327 dds_op_add( Operation *op, SlapReply *rs )
 328 {
 329         slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;
 330         dds_info_t      *di = on->on_bi.bi_private;
 331         int             is_dynamicObject;
 332
 333         if ( DDS_OFF( di ) ) {
 334                 return SLAP_CB_CONTINUE;
 335         }
 336
 337         is_dynamicObject = is_entry_dynamicObject( op->ora_e );
 338
 339         /* FIXME: do not allow this right now, pending clarification */
 340         if ( is_dynamicObject ) {
 341                 rs->sr_err = LDAP_SUCCESS;
 342
 343                 if ( is_entry_referral( op->ora_e ) ) {
 344                         rs->sr_err = LDAP_OBJECT_CLASS_VIOLATION;
 345                         rs->sr_text = "a referral cannot be a dynamicObject";
 346
 347                 } else if ( is_entry_alias( op->ora_e ) ) {
 348                         rs->sr_err = LDAP_OBJECT_CLASS_VIOLATION;
 349                         rs->sr_text = "an alias cannot be a dynamicObject";
 350                 }
 351
 352                 if ( rs->sr_err != LDAP_SUCCESS ) {
 353                         op->o_bd->bd_info = (BackendInfo *)on->on_info;
 354                         send_ldap_result( op, rs );
 355                         return rs->sr_err;
 356                 }
 357         }
 358
 359         /* we don't allow dynamicObjects to have static subordinates */
 360         if ( !dn_match( &op->o_req_ndn, &op->o_bd->be_nsuffix[ 0 ] ) ) {
 361                 struct berval   p_ndn;
 362                 Entry           *e = NULL;
 363                 int             rc;
 364                 BackendInfo     *bi = op->o_bd->bd_info;
 365
 366                 dnParent( &op->o_req_ndn, &p_ndn );
 367                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
 368                 rc = be_entry_get_rw( op, &p_ndn,
 369                         slap_schema.si_oc_dynamicObject, NULL, 0, &e );
 370                 if ( rc == LDAP_SUCCESS && e != NULL ) {
 371                         if ( !is_dynamicObject ) {
 372                                 /* return referral only if "disclose"
 373                                  * is granted on the object */
 374                                 if ( ! access_allowed( op, e,
 375                                                 slap_schema.si_ad_entry,
 376                                                 NULL, ACL_DISCLOSE, NULL ) )
 377                                 {
 378                                         rc = rs->sr_err = LDAP_NO_SUCH_OBJECT;
 379                                         send_ldap_result( op, rs );
 380
 381                                 } else {
 382                                         rc = rs->sr_err = LDAP_CONSTRAINT_VIOLATION;
 383                                         send_ldap_error( op, rs, rc, "no static subordinate entries allowed for dynamicObject" );
 384                                 }
 385                         }
 386
 387                         be_entry_release_r( op, e );
 388                         if ( rc != LDAP_SUCCESS ) {
 389                                 return rc;
 390                         }
 391                 }
 392                 op->o_bd->bd_info = bi;
 393         }
 394
 395         /* handle dynamic object operational attr(s) */
 396         if ( is_dynamicObject ) {
 397                 time_t          ttl, expire;
 398                 char            ttlbuf[] = "31557600";
 399                 char            tsbuf[ LDAP_LUTIL_GENTIME_BUFSIZE ];
 400                 struct berval   bv;
 401
 402                 if ( !be_isroot_dn( op->o_bd, &op->o_req_ndn ) ) {
 403                         ldap_pvt_thread_mutex_lock( &di->di_mutex );
 404                         rs->sr_err = ( di->di_max_dynamicObjects &&
 405                                 di->di_num_dynamicObjects >= di->di_max_dynamicObjects );
 406                         ldap_pvt_thread_mutex_unlock( &di->di_mutex );
 407                         if ( rs->sr_err ) {
 408                                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
 409                                 send_ldap_error( op, rs, LDAP_UNWILLING_TO_PERFORM,
 410                                         "too many dynamicObjects in context" );
 411                                 return rs->sr_err;
 412                         }
 413                 }
 414
 415                 ttl = DDS_DEFAULT_TTL( di );
 416
 417                 assert( ttl <= DDS_RF2589_MAX_TTL );
 418
 419                 bv.bv_val = ttlbuf;
 420                 bv.bv_len = snprintf( ttlbuf, sizeof( ttlbuf ), "%ld", ttl );
 421
 422                 /* FIXME: apparently, values in op->ora_e are malloc'ed
 423                  * on the thread's slab; works fine by chance,
 424                  * only because the attribute doesn't exist yet. */
 425                 assert( attr_find( op->ora_e->e_attrs, slap_schema.si_ad_entryTtl ) == NULL );
 426                 attr_merge_one( op->ora_e, slap_schema.si_ad_entryTtl, &bv, &bv );
 427
 428                 expire = slap_get_time() + ttl;
 429                 bv.bv_val = tsbuf;
 430                 bv.bv_len = sizeof( tsbuf );
 431                 slap_timestamp( &expire, &bv );
 432                 assert( attr_find( op->ora_e->e_attrs, ad_entryExpireTimestamp ) == NULL );
 433                 attr_merge_one( op->ora_e, ad_entryExpireTimestamp, &bv, &bv );
 434
 435                 /* if required, install counter callback */
 436                 if ( di->di_max_dynamicObjects > 0) {
 437                         slap_callback   *sc;
 438
 439                         sc = op->o_tmpalloc( sizeof( slap_callback ), op->o_tmpmemctx );
 440                         sc->sc_cleanup = dds_freeit_cb;
 441                         sc->sc_response = dds_counter_cb;
 442                         sc->sc_private = di;
 443                         sc->sc_next = op->o_callback;
 444
 445                         op->o_callback = sc;
 446                 }
 447         }
 448
 449         return SLAP_CB_CONTINUE;
 450 }
 451
 452 static int
 453 dds_op_delete( Operation *op, SlapReply *rs )
 454 {
 455         slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;
 456         dds_info_t      *di = on->on_bi.bi_private;
 457
 458         /* if required, install counter callback */
 459         if ( !DDS_OFF( di ) && di->di_max_dynamicObjects > 0 ) {
 460                 Entry           *e = NULL;
 461                 BackendInfo     *bi = op->o_bd->bd_info;
 462
 463                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
 464                 rs->sr_err = be_entry_get_rw( op, &op->o_req_ndn,
 465                         slap_schema.si_oc_dynamicObject, NULL, 0, &e );
 466
 467                 /* FIXME: couldn't the entry be added before deletion? */
 468                 if ( rs->sr_err == LDAP_SUCCESS && e != NULL ) {
 469                         slap_callback   *sc;
 470
 471                         be_entry_release_r( op, e );
 472                         e = NULL;
 473
 474                         sc = op->o_tmpalloc( sizeof( slap_callback ), op->o_tmpmemctx );
 475                         sc->sc_cleanup = dds_freeit_cb;
 476                         sc->sc_response = dds_counter_cb;
 477                         sc->sc_private = di;
 478                         sc->sc_next = op->o_callback;
 479
 480                         op->o_callback = sc;
 481                 }
 482                 op->o_bd->bd_info = bi;
 483         }
 484
 485         return SLAP_CB_CONTINUE;
 486 }
 487
 488 static int
 489 dds_op_modify( Operation *op, SlapReply *rs )
 490 {
 491         slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;
 492         dds_info_t      *di = (dds_info_t *)on->on_bi.bi_private;
 493         Modifications   *mod;
 494         Entry           *e = NULL;
 495         BackendInfo     *bi = op->o_bd->bd_info;
 496         int             was_dynamicObject = 0,
 497                         is_dynamicObject = 0;
 498         struct berval   bv_entryTtl = BER_BVNULL;
 499         time_t          entryTtl = 0;
 500         char            textbuf[ SLAP_TEXT_BUFLEN ];
 501
 502         if ( DDS_OFF( di ) ) {
 503                 return SLAP_CB_CONTINUE;
 504         }
 505
 506         /* bv_entryTtl stores the string representation of the entryTtl
 507          * across modifies for consistency checks of the final value;
 508          * the bv_val points to a static buffer; the bv_len is zero when
 509          * the attribute is deleted.
 510          * entryTtl stores the integer representation of the entryTtl;
 511          * its value is -1 when the attribute is deleted; it is 0 only
 512          * if no modifications of the entryTtl occurred, as an entryTtl
 513          * of 0 is invalid. */
 514         bv_entryTtl.bv_val = textbuf;
 515
 516         op->o_bd->bd_info = (BackendInfo *)on->on_info;
 517         rs->sr_err = be_entry_get_rw( op, &op->o_req_ndn,
 518                 slap_schema.si_oc_dynamicObject, slap_schema.si_ad_entryTtl, 0, &e );
 519         if ( rs->sr_err == LDAP_SUCCESS && e != NULL ) {
 520                 Attribute       *a = attr_find( e->e_attrs, slap_schema.si_ad_entryTtl );
 521
 522                 /* the value of the entryTtl is saved for later checks */
 523                 if ( a != NULL ) {
 524                         unsigned long   ttl;
 525                         int             rc;
 526
 527                         bv_entryTtl.bv_len = a->a_nvals[ 0 ].bv_len;
 528                         AC_MEMCPY( bv_entryTtl.bv_val, a->a_nvals[ 0 ].bv_val, bv_entryTtl.bv_len );
 529                         bv_entryTtl.bv_val[ bv_entryTtl.bv_len ] = '\0';
 530                         rc = lutil_atoul( &ttl, bv_entryTtl.bv_val );
 531                         assert( rc == 0 );
 532                         entryTtl = (time_t)ttl;
 533                 }
 534
 535                 be_entry_release_r( op, e );
 536                 e = NULL;
 537                 was_dynamicObject = is_dynamicObject = 1;
 538         }
 539         op->o_bd->bd_info = bi;
 540
 541         rs->sr_err = LDAP_SUCCESS;
 542         for ( mod = op->orm_modlist; mod; mod = mod->sml_next ) {
 543                 if ( mod->sml_desc == slap_schema.si_ad_objectClass ) {
 544                         int             i;
 545                         ObjectClass     *oc;
 546
 547                         switch ( mod->sml_op ) {
 548                         case LDAP_MOD_DELETE:
 549                                 if ( mod->sml_values == NULL ) {
 550                                         is_dynamicObject = 0;
 551                                         break;
 552                                 }
 553
 554                                 for ( i = 0; !BER_BVISNULL( &mod->sml_values[ i ] ); i++ ) {
 555                                         oc = oc_bvfind( &mod->sml_values[ i ] );
 556                                         if ( oc == slap_schema.si_oc_dynamicObject ) {
 557                                                 is_dynamicObject = 0;
 558                                                 break;
 559                                         }
 560                                 }
 561
 562                                 break;
 563
 564                         case LDAP_MOD_REPLACE:
 565                                 if ( mod->sml_values == NULL ) {
 566                                         is_dynamicObject = 0;
 567                                         break;
 568                                 }
 569                                 /* fallthru */
 570
 571                         case LDAP_MOD_ADD:
 572                                 for ( i = 0; !BER_BVISNULL( &mod->sml_values[ i ] ); i++ ) {
 573                                         oc = oc_bvfind( &mod->sml_values[ i ] );
 574                                         if ( oc == slap_schema.si_oc_dynamicObject ) {
 575                                                 is_dynamicObject = 1;
 576                                                 break;
 577                                         }
 578                                 }
 579                                 break;
 580                         }
 581
 582                 } else if ( mod->sml_desc == slap_schema.si_ad_entryTtl ) {
 583                         unsigned long   ttl;
 584                         int             rc;
 585
 586                         switch ( mod->sml_op ) {
 587                         case LDAP_MOD_DELETE:
 588                                 if ( mod->sml_values != NULL ) {
 589                                         if ( BER_BVISEMPTY( &bv_entryTtl )
 590                                                 || !bvmatch( &bv_entryTtl, &mod->sml_values[ 0 ] ) )
 591                                         {
 592                                                 rs->sr_err = backend_attribute( op, NULL, &op->o_req_ndn,
 593                                                         slap_schema.si_ad_entry, NULL, ACL_DISCLOSE );
 594                                                 if ( rs->sr_err == LDAP_INSUFFICIENT_ACCESS ) {
 595                                                         rs->sr_err = LDAP_NO_SUCH_OBJECT;
 596
 597                                                 } else {
 598                                                         rs->sr_err = LDAP_NO_SUCH_ATTRIBUTE;
 599                                                 }
 600                                                 goto done;
 601                                         }
 602                                 }
 603                                 bv_entryTtl.bv_len = 0;
 604                                 entryTtl = -1;
 605                                 break;
 606
 607                         case LDAP_MOD_REPLACE:
 608                                 bv_entryTtl.bv_len = 0;
 609                                 entryTtl = -1;
 610                                 /* fallthru */
 611
 612                         case SLAP_MOD_SOFTADD: /* FIXME? */
 613                         case LDAP_MOD_ADD:
 614                                 assert( mod->sml_values != NULL );
 615                                 assert( BER_BVISNULL( &mod->sml_values[ 1 ] ) );
 616
 617                                 if ( !BER_BVISEMPTY( &bv_entryTtl ) ) {
 618                                         rs->sr_err = backend_attribute( op, NULL, &op->o_req_ndn,
 619                                                 slap_schema.si_ad_entry, NULL, ACL_DISCLOSE );
 620                                         if ( rs->sr_err == LDAP_INSUFFICIENT_ACCESS ) {
 621                                                 rs->sr_err = LDAP_NO_SUCH_OBJECT;
 622
 623                                         } else {
 624                                                 rs->sr_text = "attribute 'entryTtl' cannot have multiple values";
 625                                                 rs->sr_err = LDAP_CONSTRAINT_VIOLATION;
 626                                         }
 627                                         goto done;
 628                                 }
 629
 630                                 rc = lutil_atoul( &ttl, mod->sml_values[ 0 ].bv_val );
 631                                 assert( rc == 0 );
 632                                 if ( ttl > DDS_RF2589_MAX_TTL ) {
 633                                         rs->sr_err = LDAP_PROTOCOL_ERROR;
 634                                         rs->sr_text = "invalid time-to-live for dynamicObject";
 635                                         goto done;
 636                                 }
 637
 638                                 if ( ttl <= 0 || ttl > di->di_max_ttl ) {
 639                                         /* FIXME: I don't understand if this has to be an error,
 640                                          * or an indication that the requested Ttl has been
 641                                          * shortened to di->di_max_ttl >= 1 day */
 642                                         rs->sr_err = LDAP_SIZELIMIT_EXCEEDED;
 643                                         rs->sr_text = "time-to-live for dynamicObject exceeds administrative limit";
 644                                         goto done;
 645                                 }
 646
 647                                 entryTtl = (time_t)ttl;
 648                                 bv_entryTtl.bv_len = mod->sml_values[ 0 ].bv_len;
 649                                 AC_MEMCPY( bv_entryTtl.bv_val, mod->sml_values[ 0 ].bv_val, bv_entryTtl.bv_len );
 650                                 bv_entryTtl.bv_val[ bv_entryTtl.bv_len ] = '\0';
 651                                 break;
 652
 653                         case LDAP_MOD_INCREMENT:
 654                                 if ( BER_BVISEMPTY( &bv_entryTtl ) ) {
 655                                         rs->sr_err = backend_attribute( op, NULL, &op->o_req_ndn,
 656                                                 slap_schema.si_ad_entry, NULL, ACL_DISCLOSE );
 657                                         if ( rs->sr_err == LDAP_INSUFFICIENT_ACCESS ) {
 658                                                 rs->sr_err = LDAP_NO_SUCH_OBJECT;
 659
 660                                         } else {
 661                                                 rs->sr_err = LDAP_NO_SUCH_ATTRIBUTE;
 662                                                 rs->sr_text = "modify/increment: entryTtl: no such attribute";
 663                                         }
 664                                         goto done;
 665                                 }
 666
 667                                 entryTtl++;
 668                                 if ( entryTtl > DDS_RF2589_MAX_TTL ) {
 669                                         rs->sr_err = LDAP_PROTOCOL_ERROR;
 670                                         rs->sr_text = "invalid time-to-live for dynamicObject";
 671
 672                                 } else if ( entryTtl <= 0 || entryTtl > di->di_max_ttl ) {
 673                                         /* FIXME: I don't understand if this has to be an error,
 674                                          * or an indication that the requested Ttl has been
 675                                          * shortened to di->di_max_ttl >= 1 day */
 676                                         rs->sr_err = LDAP_SIZELIMIT_EXCEEDED;
 677                                         rs->sr_text = "time-to-live for dynamicObject exceeds administrative limit";
 678                                 }
 679
 680                                 if ( rs->sr_err != LDAP_SUCCESS ) {
 681                                         rc = backend_attribute( op, NULL, &op->o_req_ndn,
 682                                                 slap_schema.si_ad_entry, NULL, ACL_DISCLOSE );
 683                                         if ( rc == LDAP_INSUFFICIENT_ACCESS ) {
 684                                                 rs->sr_text = NULL;
 685                                                 rs->sr_err = LDAP_NO_SUCH_OBJECT;
 686
 687                                         }
 688                                         goto done;
 689                                 }
 690
 691                                 bv_entryTtl.bv_len = snprintf( textbuf, sizeof( textbuf ), "%ld", entryTtl );
 692                                 break;
 693
 694                         default:
 695                                 assert( 0 );
 696                                 break;
 697                         }
 698
 699                 } else if ( mod->sml_desc == ad_entryExpireTimestamp ) {
 700                         /* should have been trapped earlier */
 701                         assert( mod->sml_flags & SLAP_MOD_INTERNAL );
 702                 }
 703         }
 704
 705 done:;
 706         if ( rs->sr_err == LDAP_SUCCESS ) {
 707                 int     rc;
 708
 709                 /* FIXME: this could be allowed when the Relax control is used...
 710                  * in that case:
 711                  *
 712                  * TODO
 713                  *
 714                  *      static => dynamic:
 715                  *              entryTtl must be provided; add
 716                  *              entryExpireTimestamp accordingly
 717                  *
 718                  *      dynamic => static:
 719                  *              entryTtl must be removed; remove
 720                  *              entryTimestamp accordingly
 721                  *
 722                  * ... but we need to make sure that there are no subordinate
 723                  * issues...
 724                  */
 725                 rc = is_dynamicObject - was_dynamicObject;
 726                 if ( rc ) {
 727 #if 0 /* fix subordinate issues first */
 728                         if ( get_relax( op ) ) {
 729                                 switch ( rc ) {
 730                                 case -1:
 731                                         /* need to delete entryTtl to have a consistent entry */
 732                                         if ( entryTtl != -1 ) {
 733                                                 rs->sr_text = "objectClass modification from dynamicObject to static entry requires entryTtl deletion";
 734                                                 rs->sr_err = LDAP_OBJECT_CLASS_VIOLATION;
 735                                         }
 736                                         break;
 737
 738                                 case 1:
 739                                         /* need to add entryTtl to have a consistent entry */
 740                                         if ( entryTtl <= 0 ) {
 741                                                 rs->sr_text = "objectClass modification from static entry to dynamicObject requires entryTtl addition";
 742                                                 rs->sr_err = LDAP_OBJECT_CLASS_VIOLATION;
 743                                         }
 744                                         break;
 745                                 }
 746
 747                         } else
 748 #endif
 749                         {
 750                                 switch ( rc ) {
 751                                 case -1:
 752                                         rs->sr_text = "objectClass modification cannot turn dynamicObject into static entry";
 753                                         break;
 754
 755                                 case 1:
 756                                         rs->sr_text = "objectClass modification cannot turn static entry into dynamicObject";
 757                                         break;
 758                                 }
 759                                 rs->sr_err = LDAP_OBJECT_CLASS_VIOLATION;
 760                         }
 761
 762                         if ( rc != LDAP_SUCCESS ) {
 763                                 rc = backend_attribute( op, NULL, &op->o_req_ndn,
 764                                         slap_schema.si_ad_entry, NULL, ACL_DISCLOSE );
 765                                 if ( rc == LDAP_INSUFFICIENT_ACCESS ) {
 766                                         rs->sr_text = NULL;
 767                                         rs->sr_err = LDAP_NO_SUCH_OBJECT;
 768                                 }
 769                         }
 770                 }
 771         }
 772
 773         if ( rs->sr_err == LDAP_SUCCESS && entryTtl != 0 ) {
 774                 Modifications   *tmpmod = NULL, **modp;
 775
 776                 for ( modp = &op->orm_modlist; *modp; modp = &(*modp)->sml_next )
 777                         ;
 778
 779                 tmpmod = ch_calloc( 1, sizeof( Modifications ) );
 780                 tmpmod->sml_flags = SLAP_MOD_INTERNAL;
 781                 tmpmod->sml_type = ad_entryExpireTimestamp->ad_cname;
 782                 tmpmod->sml_desc = ad_entryExpireTimestamp;
 783
 784                 *modp = tmpmod;
 785
 786                 if ( entryTtl == -1 ) {
 787                         /* delete entryExpireTimestamp */
 788                         tmpmod->sml_op = LDAP_MOD_DELETE;
 789
 790                 } else {
 791                         time_t          expire;
 792                         char            tsbuf[ LDAP_LUTIL_GENTIME_BUFSIZE ];
 793                         struct berval   bv;
 794
 795                         /* keep entryExpireTimestamp consistent
 796                          * with entryTtl */
 797                         expire = slap_get_time() + entryTtl;
 798                         bv.bv_val = tsbuf;
 799                         bv.bv_len = sizeof( tsbuf );
 800                         slap_timestamp( &expire, &bv );
 801
 802                         tmpmod->sml_op = LDAP_MOD_REPLACE;
 803                         value_add_one( &tmpmod->sml_values, &bv );
 804                         value_add_one( &tmpmod->sml_nvalues, &bv );
 805                         tmpmod->sml_numvals = 1;
 806                 }
 807         }
 808
 809         if ( rs->sr_err ) {
 810                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
 811                 send_ldap_result( op, rs );
 812                 return rs->sr_err;
 813         }
 814
 815         return SLAP_CB_CONTINUE;
 816 }
 817
 818 static int
 819 dds_op_rename( Operation *op, SlapReply *rs )
 820 {
 821         slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;
 822         dds_info_t      *di = on->on_bi.bi_private;
 823
 824         if ( DDS_OFF( di ) ) {
 825                 return SLAP_CB_CONTINUE;
 826         }
 827
 828         /* we don't allow dynamicObjects to have static subordinates */
 829         if ( op->orr_nnewSup != NULL ) {
 830                 Entry           *e = NULL;
 831                 BackendInfo     *bi = op->o_bd->bd_info;
 832                 int             is_dynamicObject = 0,
 833                                 rc;
 834
 835                 rs->sr_err = LDAP_SUCCESS;
 836
 837                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
 838                 rc = be_entry_get_rw( op, &op->o_req_ndn,
 839                         slap_schema.si_oc_dynamicObject, NULL, 0, &e );
 840                 if ( rc == LDAP_SUCCESS && e != NULL ) {
 841                         be_entry_release_r( op, e );
 842                         e = NULL;
 843                         is_dynamicObject = 1;
 844                 }
 845
 846                 rc = be_entry_get_rw( op, op->orr_nnewSup,
 847                         slap_schema.si_oc_dynamicObject, NULL, 0, &e );
 848                 if ( rc == LDAP_SUCCESS && e != NULL ) {
 849                         if ( !is_dynamicObject ) {
 850                                 /* return referral only if "disclose"
 851                                  * is granted on the object */
 852                                 if ( ! access_allowed( op, e,
 853                                                 slap_schema.si_ad_entry,
 854                                                 NULL, ACL_DISCLOSE, NULL ) )
 855                                 {
 856                                         rs->sr_err = LDAP_NO_SUCH_OBJECT;
 857                                         send_ldap_result( op, rs );
 858
 859                                 } else {
 860                                         send_ldap_error( op, rs, LDAP_CONSTRAINT_VIOLATION,
 861                                                 "static entry cannot have dynamicObject as newSuperior" );
 862                                 }
 863                         }
 864                         be_entry_release_r( op, e );
 865                 }
 866                 op->o_bd->bd_info = bi;
 867                 if ( rs->sr_err != LDAP_SUCCESS ) {
 868                         return rs->sr_err;
 869                 }
 870         }
 871
 872         return SLAP_CB_CONTINUE;
 873 }
 874
 875 static int
 876 slap_parse_refresh(
 877         struct berval   *in,
 878         struct berval   *ndn,
 879         time_t          *ttl,
 880         const char      **text,
 881         void            *ctx )
 882 {
 883         int                     rc = LDAP_SUCCESS;
 884         ber_tag_t               tag;
 885         ber_len_t               len = -1;
 886         BerElementBuffer        berbuf;
 887         BerElement              *ber = (BerElement *)&berbuf;
 888         struct berval           reqdata = BER_BVNULL;
 889         int                     tmp;
 890
 891         *text = NULL;
 892
 893         if ( ndn ) {
 894                 BER_BVZERO( ndn );
 895         }
 896
 897         if ( in == NULL || in->bv_len == 0 ) {
 898                 *text = "empty request data field in refresh exop";
 899                 return LDAP_PROTOCOL_ERROR;
 900         }
 901
 902         ber_dupbv_x( &reqdata, in, ctx );
 903
 904         /* ber_init2 uses reqdata directly, doesn't allocate new buffers */
 905         ber_init2( ber, &reqdata, 0 );
 906
 907         tag = ber_scanf( ber, "{" /*}*/ );
 908
 909         if ( tag == LBER_ERROR ) {
 910                 Log0( LDAP_DEBUG_TRACE, LDAP_LEVEL_ERR,
 911                         "slap_parse_refresh: decoding error.\n" );
 912                 goto decoding_error;
 913         }
 914
 915         tag = ber_peek_tag( ber, &len );
 916         if ( tag != LDAP_TAG_EXOP_REFRESH_REQ_DN ) {
 917                 Log0( LDAP_DEBUG_TRACE, LDAP_LEVEL_ERR,
 918                         "slap_parse_refresh: decoding error.\n" );
 919                 goto decoding_error;
 920         }
 921
 922         if ( ndn ) {
 923                 struct berval   dn;
 924
 925                 tag = ber_scanf( ber, "m", &dn );
 926                 if ( tag == LBER_ERROR ) {
 927                         Log0( LDAP_DEBUG_TRACE, LDAP_LEVEL_ERR,
 928                                 "slap_parse_refresh: DN parse failed.\n" );
 929                         goto decoding_error;
 930                 }
 931
 932                 rc = dnNormalize( 0, NULL, NULL, &dn, ndn, ctx );
 933                 if ( rc != LDAP_SUCCESS ) {
 934                         *text = "invalid DN in refresh exop request data";
 935                         goto done;
 936                 }
 937
 938         } else {
 939                 tag = ber_scanf( ber, "x" /* "m" */ );
 940                 if ( tag == LBER_DEFAULT ) {
 941                         goto decoding_error;
 942                 }
 943         }
 944
 945         tag = ber_peek_tag( ber, &len );
 946
 947         if ( tag != LDAP_TAG_EXOP_REFRESH_REQ_TTL ) {
 948                 Log0( LDAP_DEBUG_TRACE, LDAP_LEVEL_ERR,
 949                         "slap_parse_refresh: decoding error.\n" );
 950                 goto decoding_error;
 951         }
 952
 953         tag = ber_scanf( ber, "i", &tmp );
 954         if ( tag == LBER_ERROR ) {
 955                 Log0( LDAP_DEBUG_TRACE, LDAP_LEVEL_ERR,
 956                         "slap_parse_refresh: TTL parse failed.\n" );
 957                 goto decoding_error;
 958         }
 959
 960         if ( ttl ) {
 961                 *ttl = tmp;
 962         }
 963
 964         tag = ber_peek_tag( ber, &len );
 965
 966         if ( tag != LBER_DEFAULT || len != 0 ) {
 967 decoding_error:;
 968                 Log1( LDAP_DEBUG_TRACE, LDAP_LEVEL_ERR,
 969                         "slap_parse_refresh: decoding error, len=%ld\n",
 970                         (long)len );
 971                 rc = LDAP_PROTOCOL_ERROR;
 972                 *text = "data decoding error";
 973
 974 done:;
 975                 if ( ndn && !BER_BVISNULL( ndn ) ) {
 976                         slap_sl_free( ndn->bv_val, ctx );
 977                         BER_BVZERO( ndn );
 978                 }
 979         }
 980
 981         if ( !BER_BVISNULL( &reqdata ) ) {
 982                 ber_memfree_x( reqdata.bv_val, ctx );
 983         }
 984
 985         return rc;
 986 }
 987
 988 static int
 989 dds_op_extended( Operation *op, SlapReply *rs )
 990 {
 991         slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;
 992         dds_info_t      *di = on->on_bi.bi_private;
 993
 994         if ( DDS_OFF( di ) ) {
 995                 return SLAP_CB_CONTINUE;
 996         }
 997
 998         if ( bvmatch( &op->ore_reqoid, &slap_EXOP_REFRESH ) ) {
 999                 Entry           *e = NULL;
1000                 time_t          ttl;
1001                 BackendDB       db = *op->o_bd;
1002                 SlapReply       rs2 = { REP_RESULT };
1003                 Operation       op2 = *op;
1004                 slap_callback   sc = { 0 };
1005                 Modifications   ttlmod = { { 0 } };
1006                 struct berval   ttlvalues[ 2 ];
1007                 char            ttlbuf[] = "31557600";
1008
1009                 rs->sr_err = slap_parse_refresh( op->ore_reqdata, NULL, &ttl,
1010                         &rs->sr_text, NULL );
1011                 assert( rs->sr_err == LDAP_SUCCESS );
1012
1013                 if ( ttl <= 0 || ttl > DDS_RF2589_MAX_TTL ) {
1014                         rs->sr_err = LDAP_PROTOCOL_ERROR;
1015                         rs->sr_text = "invalid time-to-live for dynamicObject";
1016                         return rs->sr_err;
1017                 }
1018
1019                 if ( ttl > di->di_max_ttl ) {
1020                         /* FIXME: I don't understand if this has to be an error,
1021                          * or an indication that the requested Ttl has been
1022                          * shortened to di->di_max_ttl >= 1 day */
1023                         rs->sr_err = LDAP_SIZELIMIT_EXCEEDED;
1024                         rs->sr_text = "time-to-live for dynamicObject exceeds limit";
1025                         return rs->sr_err;
1026                 }
1027
1028                 if ( di->di_min_ttl && ttl < di->di_min_ttl ) {
1029                         ttl = di->di_min_ttl;
1030                 }
1031
1032                 /* This does not apply to multi-master case */
1033                 if ( !( !SLAP_SINGLE_SHADOW( op->o_bd ) || be_isupdate( op ) ) ) {
1034                         /* we SHOULD return a referral in this case */
1035                         BerVarray defref = op->o_bd->be_update_refs
1036                                 ? op->o_bd->be_update_refs : default_referral;
1037
1038                         if ( defref != NULL ) {
1039                                 rs->sr_ref = referral_rewrite( op->o_bd->be_update_refs,
1040                                         NULL, NULL, LDAP_SCOPE_DEFAULT );
1041                                 if ( rs->sr_ref ) {
1042                                         rs->sr_flags |= REP_REF_MUSTBEFREED;
1043                                 } else {
1044                                         rs->sr_ref = defref;
1045                                 }
1046                                 rs->sr_err = LDAP_REFERRAL;
1047
1048                         } else {
1049                                 rs->sr_text = "shadow context; no update referral";
1050                                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
1051                         }
1052
1053                         return rs->sr_err;
1054                 }
1055
1056                 assert( !BER_BVISNULL( &op->o_req_ndn ) );
1057
1058
1059
1060                 /* check if exists but not dynamicObject */
1061                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
1062                 rs->sr_err = be_entry_get_rw( op, &op->o_req_ndn,
1063                         slap_schema.si_oc_dynamicObject, NULL, 0, &e );
1064                 if ( rs->sr_err != LDAP_SUCCESS ) {
1065                         rs->sr_err = be_entry_get_rw( op, &op->o_req_ndn,
1066                                 NULL, NULL, 0, &e );
1067                         if ( rs->sr_err == LDAP_SUCCESS && e != NULL ) {
1068                                 /* return referral only if "disclose"
1069                                  * is granted on the object */
1070                                 if ( ! access_allowed( op, e,
1071                                                 slap_schema.si_ad_entry,
1072                                                 NULL, ACL_DISCLOSE, NULL ) )
1073                                 {
1074                                         rs->sr_err = LDAP_NO_SUCH_OBJECT;
1075
1076                                 } else {
1077                                         rs->sr_err = LDAP_OBJECT_CLASS_VIOLATION;
1078                                         rs->sr_text = "refresh operation only applies to dynamic objects";
1079                                 }
1080                                 be_entry_release_r( op, e );
1081
1082                         } else {
1083                                 rs->sr_err = LDAP_NO_SUCH_OBJECT;
1084                         }
1085                         return rs->sr_err;
1086
1087                 } else if ( e != NULL ) {
1088                         be_entry_release_r( op, e );
1089                 }
1090
1091                 /* we require manage privileges on the entryTtl,
1092                  * and fake a Relax control */
1093                 op2.o_tag = LDAP_REQ_MODIFY;
1094                 op2.o_bd = &db;
1095                 db.bd_info = (BackendInfo *)on->on_info;
1096                 op2.o_callback = &sc;
1097                 sc.sc_response = slap_null_cb;
1098                 op2.o_relax = SLAP_CONTROL_CRITICAL;
1099                 op2.orm_modlist = &ttlmod;
1100
1101                 ttlmod.sml_op = LDAP_MOD_REPLACE;
1102                 ttlmod.sml_flags = SLAP_MOD_MANAGING;
1103                 ttlmod.sml_desc = slap_schema.si_ad_entryTtl;
1104                 ttlmod.sml_values = ttlvalues;
1105                 ttlmod.sml_numvals = 1;
1106                 ttlvalues[ 0 ].bv_val = ttlbuf;
1107                 ttlvalues[ 0 ].bv_len = snprintf( ttlbuf, sizeof( ttlbuf ), "%ld", ttl );
1108                 BER_BVZERO( &ttlvalues[ 1 ] );
1109
1110                 /* the entryExpireTimestamp is added by modify */
1111                 rs->sr_err = op2.o_bd->be_modify( &op2, &rs2 );
1112
1113                 if ( ttlmod.sml_next != NULL ) {
1114                         slap_mods_free( ttlmod.sml_next, 1 );
1115                 }
1116
1117                 if ( rs->sr_err == LDAP_SUCCESS ) {
1118                         int                     rc;
1119                         BerElementBuffer        berbuf;
1120                         BerElement              *ber = (BerElement *)&berbuf;
1121
1122                         if ( rs->sr_err == LDAP_SUCCESS ) {
1123                                 ber_init_w_nullc( ber, LBER_USE_DER );
1124
1125                                 rc = ber_printf( ber, "{tiN}", LDAP_TAG_EXOP_REFRESH_RES_TTL, (int)ttl );
1126
1127                                 if ( rc < 0 ) {
1128                                         rs->sr_err = LDAP_OTHER;
1129                                         rs->sr_text = "internal error";
1130
1131                                 } else {
1132                                         (void)ber_flatten( ber, &rs->sr_rspdata );
1133                                         rs->sr_rspoid = ch_strdup( slap_EXOP_REFRESH.bv_val );
1134
1135                                         Log3( LDAP_DEBUG_TRACE, LDAP_LEVEL_INFO,
1136                                                 "%s REFRESH dn=\"%s\" TTL=%ld\n",
1137                                                 op->o_log_prefix, op->o_req_ndn.bv_val, ttl );
1138                                 }
1139
1140                                 ber_free_buf( ber );
1141                         }
1142                 }
1143
1144                 return rs->sr_err;
1145         }
1146
1147         return SLAP_CB_CONTINUE;
1148 }
1149
1150 enum {
1151         DDS_STATE = 1,
1152         DDS_MAXTTL,
1153         DDS_MINTTL,
1154         DDS_DEFAULTTTL,
1155         DDS_INTERVAL,
1156         DDS_TOLERANCE,
1157         DDS_MAXDYNAMICOBJS,
1158
1159         DDS_LAST
1160 };
1161
1162 static ConfigDriver dds_cfgen;
1163 #if 0
1164 static ConfigLDAPadd dds_ldadd;
1165 static ConfigCfAdd dds_cfadd;
1166 #endif
1167
1168 static ConfigTable dds_cfg[] = {
1169         { "dds-state", "on|off",
1170                 2, 2, 0, ARG_MAGIC|ARG_ON_OFF|DDS_STATE, dds_cfgen,
1171                 "( OLcfgOvAt:9.1 NAME 'olcDDSstate' "
1172                         "DESC 'RFC2589 Dynamic directory services state' "
1173                         "SYNTAX OMsBoolean "
1174                         "SINGLE-VALUE )", NULL, NULL },
1175         { "dds-max-ttl", "ttl",
1176                 2, 2, 0, ARG_MAGIC|DDS_MAXTTL, dds_cfgen,
1177                 "( OLcfgOvAt:9.2 NAME 'olcDDSmaxTtl' "
1178                         "DESC 'RFC2589 Dynamic directory services max TTL' "
1179                         "SYNTAX OMsDirectoryString "
1180                         "SINGLE-VALUE )", NULL, NULL },
1181         { "dds-min-ttl", "ttl",
1182                 2, 2, 0, ARG_MAGIC|DDS_MINTTL, dds_cfgen,
1183                 "( OLcfgOvAt:9.3 NAME 'olcDDSminTtl' "
1184                         "DESC 'RFC2589 Dynamic directory services min TTL' "
1185                         "SYNTAX OMsDirectoryString "
1186                         "SINGLE-VALUE )", NULL, NULL },
1187         { "dds-default-ttl", "ttl",
1188                 2, 2, 0, ARG_MAGIC|DDS_DEFAULTTTL, dds_cfgen,
1189                 "( OLcfgOvAt:9.4 NAME 'olcDDSdefaultTtl' "
1190                         "DESC 'RFC2589 Dynamic directory services default TTL' "
1191                         "SYNTAX OMsDirectoryString "
1192                         "SINGLE-VALUE )", NULL, NULL },
1193         { "dds-interval", "interval",
1194                 2, 2, 0, ARG_MAGIC|DDS_INTERVAL, dds_cfgen,
1195                 "( OLcfgOvAt:9.5 NAME 'olcDDSinterval' "
1196                         "DESC 'RFC2589 Dynamic directory services expiration "
1197                                 "task run interval' "
1198                         "SYNTAX OMsDirectoryString "
1199                         "SINGLE-VALUE )", NULL, NULL },
1200         { "dds-tolerance", "ttl",
1201                 2, 2, 0, ARG_MAGIC|DDS_TOLERANCE, dds_cfgen,
1202                 "( OLcfgOvAt:9.6 NAME 'olcDDStolerance' "
1203                         "DESC 'RFC2589 Dynamic directory services additional "
1204                                 "TTL in expiration scheduling' "
1205                         "SYNTAX OMsDirectoryString "
1206                         "SINGLE-VALUE )", NULL, NULL },
1207         { "dds-max-dynamicObjects", "num",
1208                 2, 2, 0, ARG_MAGIC|ARG_INT|DDS_MAXDYNAMICOBJS, dds_cfgen,
1209                 "( OLcfgOvAt:9.7 NAME 'olcDDSmaxDynamicObjects' "
1210                         "DESC 'RFC2589 Dynamic directory services max number of dynamic objects' "
1211                         "SYNTAX OMsInteger "
1212                         "SINGLE-VALUE )", NULL, NULL },
1213         { NULL, NULL, 0, 0, 0, ARG_IGNORED }
1214 };
1215
1216 static ConfigOCs dds_ocs[] = {
1217         { "( OLcfgOvOc:9.1 "
1218                 "NAME 'olcDDSConfig' "
1219                 "DESC 'RFC2589 Dynamic directory services configuration' "
1220                 "SUP olcOverlayConfig "
1221                 "MAY ( "
1222                         "olcDDSstate "
1223                         "$ olcDDSmaxTtl "
1224                         "$ olcDDSminTtl "
1225                         "$ olcDDSdefaultTtl "
1226                         "$ olcDDSinterval "
1227                         "$ olcDDStolerance "
1228                         "$ olcDDSmaxDynamicObjects "
1229                 " ) "
1230                 ")", Cft_Overlay, dds_cfg, NULL, NULL /* dds_cfadd */ },
1231         { NULL, 0, NULL }
1232 };
1233
1234 #if 0
1235 static int
1236 dds_ldadd( CfEntryInfo *p, Entry *e, ConfigArgs *ca )
1237 {
1238         return LDAP_SUCCESS;
1239 }
1240
1241 static int
1242 dds_cfadd( Operation *op, SlapReply *rs, Entry *p, ConfigArgs *ca )
1243 {
1244         return 0;
1245 }
1246 #endif
1247
1248 static int
1249 dds_cfgen( ConfigArgs *c )
1250 {
1251         slap_overinst   *on = (slap_overinst *)c->bi;
1252         dds_info_t      *di = on->on_bi.bi_private;
1253         int             rc = 0;
1254         unsigned long   t;
1255
1256
1257         if ( c->op == SLAP_CONFIG_EMIT ) {
1258                 char            buf[ SLAP_TEXT_BUFLEN ];
1259                 struct berval   bv;
1260
1261                 switch( c->type ) {
1262                 case DDS_STATE:
1263                         c->value_int = !DDS_OFF( di );
1264                         break;
1265
1266                 case DDS_MAXTTL:
1267                         lutil_unparse_time( buf, sizeof( buf ), di->di_max_ttl );
1268                         ber_str2bv( buf, 0, 0, &bv );
1269                         value_add_one( &c->rvalue_vals, &bv );
1270                         break;
1271
1272                 case DDS_MINTTL:
1273                         if ( di->di_min_ttl ) {
1274                                 lutil_unparse_time( buf, sizeof( buf ), di->di_min_ttl );
1275                                 ber_str2bv( buf, 0, 0, &bv );
1276                                 value_add_one( &c->rvalue_vals, &bv );
1277
1278                         } else {
1279                                 rc = 1;
1280                         }
1281                         break;
1282
1283                 case DDS_DEFAULTTTL:
1284                         if ( di->di_default_ttl ) {
1285                                 lutil_unparse_time( buf, sizeof( buf ), di->di_default_ttl );
1286                                 ber_str2bv( buf, 0, 0, &bv );
1287                                 value_add_one( &c->rvalue_vals, &bv );
1288
1289                         } else {
1290                                 rc = 1;
1291                         }
1292                         break;
1293
1294                 case DDS_INTERVAL:
1295                         if ( di->di_interval ) {
1296                                 lutil_unparse_time( buf, sizeof( buf ), di->di_interval );
1297                                 ber_str2bv( buf, 0, 0, &bv );
1298                                 value_add_one( &c->rvalue_vals, &bv );
1299
1300                         } else {
1301                                 rc = 1;
1302                         }
1303                         break;
1304
1305                 case DDS_TOLERANCE:
1306                         if ( di->di_tolerance ) {
1307                                 lutil_unparse_time( buf, sizeof( buf ), di->di_tolerance );
1308                                 ber_str2bv( buf, 0, 0, &bv );
1309                                 value_add_one( &c->rvalue_vals, &bv );
1310
1311                         } else {
1312                                 rc = 1;
1313                         }
1314                         break;
1315
1316                 case DDS_MAXDYNAMICOBJS:
1317                         if ( di->di_max_dynamicObjects > 0 ) {
1318                                 c->value_int = di->di_max_dynamicObjects;
1319
1320                         } else {
1321                                 rc = 1;
1322                         }
1323                         break;
1324
1325                 default:
1326                         rc = 1;
1327                         break;
1328                 }
1329
1330                 return rc;
1331
1332         } else if ( c->op == LDAP_MOD_DELETE ) {
1333                 switch( c->type ) {
1334                 case DDS_STATE:
1335                         di->di_flags &= ~DDS_FOFF;
1336                         break;
1337
1338                 case DDS_MAXTTL:
1339                         di->di_min_ttl = DDS_RF2589_DEFAULT_TTL;
1340                         break;
1341
1342                 case DDS_MINTTL:
1343                         di->di_min_ttl = 0;
1344                         break;
1345
1346                 case DDS_DEFAULTTTL:
1347                         di->di_default_ttl = 0;
1348                         break;
1349
1350                 case DDS_INTERVAL:
1351                         di->di_interval = 0;
1352                         break;
1353
1354                 case DDS_TOLERANCE:
1355                         di->di_tolerance = 0;
1356                         break;
1357
1358                 case DDS_MAXDYNAMICOBJS:
1359                         di->di_max_dynamicObjects = 0;
1360                         break;
1361
1362                 default:
1363                         rc = 1;
1364                         break;
1365                 }
1366
1367                 return rc;
1368         }
1369
1370         switch ( c->type ) {
1371         case DDS_STATE:
1372                 if ( c->value_int ) {
1373                         di->di_flags &= ~DDS_FOFF;
1374
1375                 } else {
1376                         di->di_flags |= DDS_FOFF;
1377                 }
1378                 break;
1379
1380         case DDS_MAXTTL:
1381                 if ( lutil_parse_time( c->argv[ 1 ], &t ) != 0 ) {
1382                         snprintf( c->cr_msg, sizeof( c->cr_msg),
1383                                 "DDS unable to parse dds-max-ttl \"%s\"",
1384                                 c->argv[ 1 ] );
1385                         Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1386                                 "%s: %s.\n", c->log, c->cr_msg );
1387                         return 1;
1388                 }
1389
1390                 if ( t < DDS_RF2589_DEFAULT_TTL || t > DDS_RF2589_MAX_TTL ) {
1391                         snprintf( c->cr_msg, sizeof( c->cr_msg ),
1392                                 "DDS invalid dds-max-ttl=%ld; must be between %d and %d",
1393                                 t, DDS_RF2589_DEFAULT_TTL, DDS_RF2589_MAX_TTL );
1394                         Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1395                                 "%s: %s.\n", c->log, c->cr_msg );
1396                         return 1;
1397                 }
1398
1399                 di->di_max_ttl = (time_t)t;
1400                 break;
1401
1402         case DDS_MINTTL:
1403                 if ( lutil_parse_time( c->argv[ 1 ], &t ) != 0 ) {
1404                         snprintf( c->cr_msg, sizeof( c->cr_msg),
1405                                 "DDS unable to parse dds-min-ttl \"%s\"",
1406                                 c->argv[ 1 ] );
1407                         Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1408                                 "%s: %s.\n", c->log, c->cr_msg );
1409                         return 1;
1410                 }
1411
1412                 if ( t < 0 || t > DDS_RF2589_MAX_TTL ) {
1413                         snprintf( c->cr_msg, sizeof( c->cr_msg ),
1414                                 "DDS invalid dds-min-ttl=%ld",
1415                                 t );
1416                         Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1417                                 "%s: %s.\n", c->log, c->cr_msg );
1418                         return 1;
1419                 }
1420
1421                 if ( t == 0 ) {
1422                         di->di_min_ttl = DDS_RF2589_DEFAULT_TTL;
1423
1424                 } else {
1425                         di->di_min_ttl = (time_t)t;
1426                 }
1427                 break;
1428
1429         case DDS_DEFAULTTTL:
1430                 if ( lutil_parse_time( c->argv[ 1 ], &t ) != 0 ) {
1431                         snprintf( c->cr_msg, sizeof( c->cr_msg),
1432                                 "DDS unable to parse dds-default-ttl \"%s\"",
1433                                 c->argv[ 1 ] );
1434                         Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1435                                 "%s: %s.\n", c->log, c->cr_msg );
1436                         return 1;
1437                 }
1438
1439                 if ( t < 0 || t > DDS_RF2589_MAX_TTL ) {
1440                         snprintf( c->cr_msg, sizeof( c->cr_msg ),
1441                                 "DDS invalid dds-default-ttl=%ld",
1442                                 t );
1443                         Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1444                                 "%s: %s.\n", c->log, c->cr_msg );
1445                         return 1;
1446                 }
1447
1448                 if ( t == 0 ) {
1449                         di->di_default_ttl = DDS_RF2589_DEFAULT_TTL;
1450
1451                 } else {
1452                         di->di_default_ttl = (time_t)t;
1453                 }
1454                 break;
1455
1456         case DDS_INTERVAL:
1457                 if ( lutil_parse_time( c->argv[ 1 ], &t ) != 0 ) {
1458                         snprintf( c->cr_msg, sizeof( c->cr_msg),
1459                                 "DDS unable to parse dds-interval \"%s\"",
1460                                 c->argv[ 1 ] );
1461                         Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1462                                 "%s: %s.\n", c->log, c->cr_msg );
1463                         return 1;
1464                 }
1465
1466                 if ( t <= 0 ) {
1467                         snprintf( c->cr_msg, sizeof( c->cr_msg ),
1468                                 "DDS invalid dds-interval=%ld",
1469                                 t );
1470                         Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1471                                 "%s: %s.\n", c->log, c->cr_msg );
1472                         return 1;
1473                 }
1474
1475                 if ( t < 60 ) {
1476                         Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_NOTICE,
1477                                 "%s: dds-interval=%lu may be too small.\n",
1478                                 c->log, t );
1479                 }
1480
1481                 di->di_interval = (time_t)t;
1482                 if ( di->di_expire_task ) {
1483                         ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex );
1484                         if ( ldap_pvt_runqueue_isrunning( &slapd_rq, di->di_expire_task ) ) {
1485                                 ldap_pvt_runqueue_stoptask( &slapd_rq, di->di_expire_task );
1486                         }
1487                         di->di_expire_task->interval.tv_sec = DDS_INTERVAL( di );
1488                         ldap_pvt_runqueue_resched( &slapd_rq, di->di_expire_task, 0 );
1489                         ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );
1490                 }
1491                 break;
1492
1493         case DDS_TOLERANCE:
1494                 if ( lutil_parse_time( c->argv[ 1 ], &t ) != 0 ) {
1495                         snprintf( c->cr_msg, sizeof( c->cr_msg),
1496                                 "DDS unable to parse dds-tolerance \"%s\"",
1497                                 c->argv[ 1 ] );
1498                         Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1499                                 "%s: %s.\n", c->log, c->cr_msg );
1500                         return 1;
1501                 }
1502
1503                 if ( t < 0 || t > DDS_RF2589_MAX_TTL ) {
1504                         snprintf( c->cr_msg, sizeof( c->cr_msg ),
1505                                 "DDS invalid dds-tolerance=%ld",
1506                                 t );
1507                         Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1508                                 "%s: %s.\n", c->log, c->cr_msg );
1509                         return 1;
1510                 }
1511
1512                 di->di_tolerance = (time_t)t;
1513                 break;
1514
1515         case DDS_MAXDYNAMICOBJS:
1516                 if ( c->value_int < 0 ) {
1517                         snprintf( c->cr_msg, sizeof( c->cr_msg ),
1518                                 "DDS invalid dds-max-dynamicObjects=%d", c->value_int );
1519                         Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1520                                 "%s: %s.\n", c->log, c->cr_msg );
1521                         return 1;
1522                 }
1523                 di->di_max_dynamicObjects = c->value_int;
1524                 break;
1525
1526         default:
1527                 rc = 1;
1528                 break;
1529         }
1530
1531         return rc;
1532 }
1533
1534 static int
1535 dds_db_init(
1536         BackendDB       *be,
1537         ConfigReply     *cr)
1538 {
1539         slap_overinst   *on = (slap_overinst *)be->bd_info;
1540         dds_info_t      *di;
1541         BackendInfo     *bi = on->on_info->oi_orig;
1542
1543         if ( SLAP_ISGLOBALOVERLAY( be ) ) {
1544                 Log0( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1545                         "DDS cannot be used as global overlay.\n" );
1546                 return 1;
1547         }
1548
1549         /* check support for required functions */
1550         /* FIXME: some could be provided by other overlays in between */
1551         if ( bi->bi_op_add == NULL                      /* object creation */
1552                 || bi->bi_op_delete == NULL             /* object deletion */
1553                 || bi->bi_op_modify == NULL             /* object refresh */
1554                 || bi->bi_op_search == NULL             /* object expiration */
1555                 || bi->bi_entry_get_rw == NULL )        /* object type/existence checking */
1556         {
1557                 Log1( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1558                         "DDS backend \"%s\" does not provide "
1559                         "required functionality.\n",
1560                         bi->bi_type );
1561                 return 1;
1562         }
1563
1564         di = (dds_info_t *)ch_calloc( 1, sizeof( dds_info_t ) );
1565         on->on_bi.bi_private = di;
1566
1567         di->di_max_ttl = DDS_RF2589_DEFAULT_TTL;
1568         di->di_max_ttl = DDS_RF2589_DEFAULT_TTL;
1569
1570         ldap_pvt_thread_mutex_init( &di->di_mutex );
1571
1572         SLAP_DBFLAGS( be ) |= SLAP_DBFLAG_DYNAMIC;
1573
1574         return 0;
1575 }
1576
1577 /* adds dynamicSubtrees to root DSE */
1578 static int
1579 dds_entry_info( void *arg, Entry *e )
1580 {
1581         dds_info_t      *di = (dds_info_t *)arg;
1582
1583         attr_merge( e, slap_schema.si_ad_dynamicSubtrees,
1584                 di->di_suffix, di->di_nsuffix );
1585
1586         return 0;
1587 }
1588
1589 /* callback that counts the returned entries, since the search
1590  * does not get to the point in slap_send_search_entries where
1591  * the actual count occurs */
1592 static int
1593 dds_count_cb( Operation *op, SlapReply *rs )
1594 {
1595         int     *nump = (int *)op->o_callback->sc_private;
1596
1597         switch ( rs->sr_type ) {
1598         case REP_SEARCH:
1599                 (*nump)++;
1600                 break;
1601
1602         case REP_SEARCHREF:
1603         case REP_RESULT:
1604                 break;
1605
1606         default:
1607                 assert( 0 );
1608         }
1609
1610         return 0;
1611 }
1612
1613 /* count dynamic objects existing in the database at startup */
1614 static int
1615 dds_count( void *ctx, BackendDB *be )
1616 {
1617         slap_overinst   *on = (slap_overinst *)be->bd_info;
1618         dds_info_t      *di = (dds_info_t *)on->on_bi.bi_private;
1619
1620         Connection      conn = { 0 };
1621         OperationBuffer opbuf;
1622         Operation       *op;
1623         slap_callback   sc = { 0 };
1624         SlapReply       rs = { REP_RESULT };
1625
1626         int             rc;
1627         char            *extra = "";
1628
1629         connection_fake_init( &conn, &opbuf, ctx );
1630         op = &opbuf.ob_op;
1631
1632         op->o_tag = LDAP_REQ_SEARCH;
1633         memset( &op->oq_search, 0, sizeof( op->oq_search ) );
1634
1635         op->o_bd = be;
1636
1637         op->o_req_dn = op->o_bd->be_suffix[ 0 ];
1638         op->o_req_ndn = op->o_bd->be_nsuffix[ 0 ];
1639
1640         op->o_dn = op->o_bd->be_rootdn;
1641         op->o_ndn = op->o_bd->be_rootndn;
1642
1643         op->ors_scope = LDAP_SCOPE_SUBTREE;
1644         op->ors_tlimit = SLAP_NO_LIMIT;
1645         op->ors_slimit = SLAP_NO_LIMIT;
1646         op->ors_attrs = slap_anlist_no_attrs;
1647
1648         op->ors_filterstr.bv_len = STRLENOF( "(objectClass=" ")" )
1649                 + slap_schema.si_oc_dynamicObject->soc_cname.bv_len;
1650         op->ors_filterstr.bv_val = op->o_tmpalloc( op->ors_filterstr.bv_len + 1, op->o_tmpmemctx );
1651         snprintf( op->ors_filterstr.bv_val, op->ors_filterstr.bv_len + 1,
1652                 "(objectClass=%s)",
1653                 slap_schema.si_oc_dynamicObject->soc_cname.bv_val );
1654
1655         op->ors_filter = str2filter_x( op, op->ors_filterstr.bv_val );
1656         if ( op->ors_filter == NULL ) {
1657                 rs.sr_err = LDAP_OTHER;
1658                 goto done_search;
1659         }
1660
1661         op->o_callback = &sc;
1662         sc.sc_response = dds_count_cb;
1663         sc.sc_private = &di->di_num_dynamicObjects;
1664         di->di_num_dynamicObjects = 0;
1665
1666         op->o_bd->bd_info = (BackendInfo *)on->on_info;
1667         (void)op->o_bd->bd_info->bi_op_search( op, &rs );
1668         op->o_bd->bd_info = (BackendInfo *)on;
1669
1670 done_search:;
1671         op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx );
1672         filter_free_x( op, op->ors_filter );
1673
1674         rc = rs.sr_err;
1675         switch ( rs.sr_err ) {
1676         case LDAP_SUCCESS:
1677                 Log1( LDAP_DEBUG_STATS, LDAP_LEVEL_INFO,
1678                         "DDS non-expired=%d\n",
1679                         di->di_num_dynamicObjects );
1680                 break;
1681
1682         case LDAP_NO_SUCH_OBJECT:
1683                 /* (ITS#5267) database not created yet? */
1684                 rs.sr_err = LDAP_SUCCESS;
1685                 extra = " (ignored)";
1686                 /* fallthru */
1687
1688         default:
1689                 Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1690                         "DDS non-expired objects lookup failed err=%d%s\n",
1691                         rc, extra );
1692                 break;
1693         }
1694
1695         return rs.sr_err;
1696 }
1697
1698 static int
1699 dds_db_open(
1700         BackendDB       *be,
1701         ConfigReply     *cr )
1702 {
1703         slap_overinst   *on = (slap_overinst *)be->bd_info;
1704         dds_info_t      *di = on->on_bi.bi_private;
1705         int             rc = 0;
1706         void            *thrctx = ldap_pvt_thread_pool_context();
1707
1708         if ( DDS_OFF( di ) ) {
1709                 goto done;
1710         }
1711
1712         if ( SLAP_SINGLE_SHADOW( be ) ) {
1713                 Log1( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1714                         "DDS incompatible with shadow database \"%s\".\n",
1715                         be->be_suffix[ 0 ].bv_val );
1716                 return 1;
1717         }
1718
1719         if ( di->di_max_ttl == 0 ) {
1720                 di->di_max_ttl = DDS_RF2589_DEFAULT_TTL;
1721         }
1722
1723         if ( di->di_min_ttl == 0 ) {
1724                 di->di_max_ttl = DDS_RF2589_DEFAULT_TTL;
1725         }
1726
1727         di->di_suffix = be->be_suffix;
1728         di->di_nsuffix = be->be_nsuffix;
1729
1730         /* ... so that count, if required, is accurate */
1731         if ( di->di_max_dynamicObjects > 0 ) {
1732                 /* force deletion of expired entries... */
1733                 be->bd_info = (BackendInfo *)on->on_info;
1734                 rc = dds_expire( thrctx, di );
1735                 be->bd_info = (BackendInfo *)on;
1736                 if ( rc != LDAP_SUCCESS ) {
1737                         rc = 1;
1738                         goto done;
1739                 }
1740
1741                 rc = dds_count( thrctx, be );
1742                 if ( rc != LDAP_SUCCESS ) {
1743                         rc = 1;
1744                         goto done;
1745                 }
1746         }
1747
1748         /* start expire task */
1749         ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex );
1750         di->di_expire_task = ldap_pvt_runqueue_insert( &slapd_rq,
1751                 DDS_INTERVAL( di ),
1752                 dds_expire_fn, di, "dds_expire_fn",
1753                 be->be_suffix[ 0 ].bv_val );
1754         ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );
1755
1756         /* register dinamicSubtrees root DSE info support */
1757         rc = entry_info_register( dds_entry_info, (void *)di );
1758
1759 done:;
1760
1761         return rc;
1762 }
1763
1764 static int
1765 dds_db_close(
1766         BackendDB       *be,
1767         ConfigReply     *cr )
1768 {
1769         slap_overinst   *on = (slap_overinst *)be->bd_info;
1770         dds_info_t      *di = on->on_bi.bi_private;
1771
1772         /* stop expire task */
1773         if ( di && di->di_expire_task ) {
1774                 ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex );
1775                 if ( ldap_pvt_runqueue_isrunning( &slapd_rq, di->di_expire_task ) ) {
1776                         ldap_pvt_runqueue_stoptask( &slapd_rq, di->di_expire_task );
1777                 }
1778                 ldap_pvt_runqueue_remove( &slapd_rq, di->di_expire_task );
1779                 ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );
1780         }
1781
1782         (void)entry_info_unregister( dds_entry_info, (void *)di );
1783
1784         return 0;
1785 }
1786
1787 static int
1788 dds_db_destroy(
1789         BackendDB       *be,
1790         ConfigReply     *cr )
1791 {
1792         slap_overinst   *on = (slap_overinst *)be->bd_info;
1793         dds_info_t      *di = on->on_bi.bi_private;
1794
1795         if ( di != NULL ) {
1796                 ldap_pvt_thread_mutex_destroy( &di->di_mutex );
1797
1798                 free( di );
1799         }
1800
1801         return 0;
1802 }
1803
1804 static int
1805 slap_exop_refresh(
1806                 Operation       *op,
1807                 SlapReply       *rs )
1808 {
1809         BackendDB               *bd = op->o_bd;
1810
1811         rs->sr_err = slap_parse_refresh( op->ore_reqdata, &op->o_req_ndn, NULL,
1812                 &rs->sr_text, op->o_tmpmemctx );
1813         if ( rs->sr_err != LDAP_SUCCESS ) {
1814                 return rs->sr_err;
1815         }
1816
1817         Log2( LDAP_DEBUG_STATS, LDAP_LEVEL_INFO,
1818                 "%s REFRESH dn=\"%s\"\n",
1819                 op->o_log_prefix, op->o_req_ndn.bv_val );
1820         op->o_req_dn = op->o_req_ndn;
1821
1822         op->o_bd = select_backend( &op->o_req_ndn, 0 );
1823         if ( !SLAP_DYNAMIC( op->o_bd ) ) {
1824                 send_ldap_error( op, rs, LDAP_UNAVAILABLE_CRITICAL_EXTENSION,
1825                         "backend does not support dynamic directory services" );
1826                 goto done;
1827         }
1828
1829         rs->sr_err = backend_check_restrictions( op, rs,
1830                 (struct berval *)&slap_EXOP_REFRESH );
1831         if ( rs->sr_err != LDAP_SUCCESS ) {
1832                 goto done;
1833         }
1834
1835         if ( op->o_bd->be_extended == NULL ) {
1836                 send_ldap_error( op, rs, LDAP_UNAVAILABLE_CRITICAL_EXTENSION,
1837                         "backend does not support extended operations" );
1838                 goto done;
1839         }
1840
1841         op->o_bd->be_extended( op, rs );
1842
1843 done:;
1844         if ( !BER_BVISNULL( &op->o_req_ndn ) ) {
1845                 op->o_tmpfree( op->o_req_ndn.bv_val, op->o_tmpmemctx );
1846                 BER_BVZERO( &op->o_req_ndn );
1847                 BER_BVZERO( &op->o_req_dn );
1848         }
1849         op->o_bd = bd;
1850
1851         return rs->sr_err;
1852 }
1853
1854 static slap_overinst dds;
1855
1856 static int do_not_load_exop;
1857 static int do_not_replace_exop;
1858 static int do_not_load_schema;
1859
1860 #if SLAPD_OVER_DDS == SLAPD_MOD_DYNAMIC
1861 static
1862 #endif /* SLAPD_OVER_DDS == SLAPD_MOD_DYNAMIC */
1863 int
1864 dds_initialize()
1865 {
1866         int             rc = 0;
1867         int             i, code;
1868
1869         /* Make sure we don't exceed the bits reserved for userland */
1870         config_check_userland( DDS_LAST );
1871
1872         if ( !do_not_load_schema ) {
1873                 static struct {
1874                         char                    *desc;
1875                         slap_mask_t             flags;
1876                         AttributeDescription    **ad;
1877                 }               s_at[] = {
1878                         { "( 1.3.6.1.4.1.4203.666.1.57 "
1879                                 "NAME ( 'entryExpireTimestamp' ) "
1880                                 "DESC 'RFC2589 OpenLDAP extension: expire time of a dynamic object, "
1881                                         "computed as now + entryTtl' "
1882                                 "EQUALITY generalizedTimeMatch "
1883                                 "ORDERING generalizedTimeOrderingMatch "
1884                                 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 "
1885                                 "SINGLE-VALUE "
1886                                 "NO-USER-MODIFICATION "
1887                                 "USAGE dSAOperation )",
1888                                 SLAP_AT_HIDE,
1889                                 &ad_entryExpireTimestamp },
1890                         { NULL }
1891                 };
1892
1893                 for ( i = 0; s_at[ i ].desc != NULL; i++ ) {
1894                         code = register_at( s_at[ i ].desc, s_at[ i ].ad, 0 );
1895                         if ( code ) {
1896                                 Debug( LDAP_DEBUG_ANY,
1897                                         "dds_initialize: register_at failed\n", 0, 0, 0 );
1898                                 return code;
1899                         }
1900                         (*s_at[ i ].ad)->ad_type->sat_flags |= SLAP_AT_HIDE;
1901                 }
1902         }
1903
1904         if ( !do_not_load_exop ) {
1905                 rc = load_extop2( (struct berval *)&slap_EXOP_REFRESH,
1906                         SLAP_EXOP_WRITES|SLAP_EXOP_HIDE, slap_exop_refresh,
1907                         !do_not_replace_exop );
1908                 if ( rc != LDAP_SUCCESS ) {
1909                         Log1( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1910                                 "DDS unable to register refresh exop: %d.\n",
1911                                 rc );
1912                         return rc;
1913                 }
1914         }
1915
1916         dds.on_bi.bi_type = "dds";
1917
1918         dds.on_bi.bi_db_init = dds_db_init;
1919         dds.on_bi.bi_db_open = dds_db_open;
1920         dds.on_bi.bi_db_close = dds_db_close;
1921         dds.on_bi.bi_db_destroy = dds_db_destroy;
1922
1923         dds.on_bi.bi_op_add = dds_op_add;
1924         dds.on_bi.bi_op_delete = dds_op_delete;
1925         dds.on_bi.bi_op_modify = dds_op_modify;
1926         dds.on_bi.bi_op_modrdn = dds_op_rename;
1927         dds.on_bi.bi_extended = dds_op_extended;
1928
1929         dds.on_bi.bi_cf_ocs = dds_ocs;
1930
1931         rc = config_register_schema( dds_cfg, dds_ocs );
1932         if ( rc ) {
1933                 return rc;
1934         }
1935
1936         return overlay_register( &dds );
1937 }
1938
1939 #if SLAPD_OVER_DDS == SLAPD_MOD_DYNAMIC
1940 int
1941 init_module( int argc, char *argv[] )
1942 {
1943         int     i;
1944
1945         for ( i = 0; i < argc; i++ ) {
1946                 char    *arg = argv[ i ];
1947                 int     no = 0;
1948
1949                 if ( strncasecmp( arg, "no-", STRLENOF( "no-" ) ) == 0 ) {
1950                         arg += STRLENOF( "no-" );
1951                         no = 1;
1952                 }
1953
1954                 if ( strcasecmp( arg, "exop" ) == 0 ) {
1955                         do_not_load_exop = no;
1956
1957                 } else if ( strcasecmp( arg, "replace" ) == 0 ) {
1958                         do_not_replace_exop = no;
1959
1960                 } else if ( strcasecmp( arg, "schema" ) == 0 ) {
1961                         do_not_load_schema = no;
1962
1963                 } else {
1964                         Log2( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
1965                                 "DDS unknown module arg[#%d]=\"%s\".\n",
1966                                 i, argv[ i ] );
1967                         return 1;
1968                 }
1969         }
1970
1971         return dds_initialize();
1972 }
1973 #endif /* SLAPD_OVER_DDS == SLAPD_MOD_DYNAMIC */
1974
1975 #endif  /* defined(SLAPD_OVER_DDS) */