ldap/servers/plugins/chainingdb/cb_monitor.c \

  	ldap/servers/plugins/chainingdb/cb_schema.c \

  	ldap/servers/plugins/chainingdb/cb_search.c \

  	ldap/servers/plugins/chainingdb/cb_start.c \

  	ldap/servers/plugins/chainingdb/cb_temp.c \

  	ldap/servers/plugins/chainingdb/cb_test.c \

  attributeTypes: ( 2.16.840.1.113730.3.1.2368 NAME 'nsslapd-filterrewriter' DESC 'Filter rewriter function name' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 X-ORIGIN '389 Directory Server' )

  attributeTypes: ( 2.16.840.1.113730.3.1.2369 NAME 'nsslapd-returnedAttrRewriter' DESC 'Returned attribute rewriter function name' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 X-ORIGIN '389 Directory Server' )

  attributeTypes: ( 2.16.840.1.113730.3.1.2370 NAME 'nsslapd-enable-upgrade-hash' DESC 'Upgrade password hash on bind' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE X-ORIGIN '389 Directory Server' )

  #

  # objectclasses

  #

  int chainingdb_build_candidate_list(Slapi_PBlock *pb);

  int chainingdb_start(Slapi_PBlock *pb);

  int chainingdb_bind(Slapi_PBlock *pb);

  int cb_back_close(Slapi_PBlock *pb);

  int cb_back_cleanup(Slapi_PBlock *pb);

  void chaining_back_search_results_release(void **sr);

                             (void *)chaining_back_modrdn);

      rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_DB_ABANDON_FN,

                             (void *)chaining_back_abandon);

      rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_CLOSE_FN,

                             (void *)cb_back_close);

      rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_CLEANUP_FN,

      /****

          rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_DB_ENTRY_RELEASE_FN,

              (void *) chaining_back_entry_release );

          rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_DB_TEST_FN,

              (void *) cb_back_test );

  ****/

          mapping_tree_init();

          if (dblayer_setup(li)) {

              return -1;

          }

      /* copied here, need better solution */

      /* initialize dblayer  */

          if (dblayer_setup(li)) {

              goto out;

          }

  /* Name of attribute type used for binder-based look through simple paged limit */

  #define LDBM_PAGEDALLIDSLIMIT_AT "nsPagedIDListScanLimit"

  #define LDBM_ANCESTORID_STR                "ancestorid"

  #define LDBM_ENTRYDN_STR                   SLAPI_ATTR_ENTRYDN

  #define LDBM_ENTRYRDN_STR                  "entryrdn"

  }

  /*

   *

   * functions to convert idl from the old format to the new one

   * (604921) Support a database uprev process any time post-install

  int upgradedb_delete_indices_4cmd(ldbm_instance *inst, int flags);

  /*

   *    check the DB version and if it's old idl'ed index,

   *    then reindex using new idl.

   *

      PRUint32 dbversion_flags = DBVERSION_ALL;

      slapi_pblock_get(pb, SLAPI_SEQ_TYPE, &up_flags);

      slapi_pblock_get(pb, SLAPI_TASK_FLAGS, &task_flags);

      slapi_pblock_get(pb, SLAPI_BACKEND_TASK, &task);

      slapi_pblock_get(pb, SLAPI_DB2LDIF_SERVER_RUNNING, &server_running);

          ldbm_instance *inst = NULL;

          /* server is up -- mark all backends busy */

                        "server is up -- marking all LDBM backends busy\n");

          for (inst_obj = objset_first_obj(li->li_instance_set); inst_obj;

               inst_obj = objset_next_obj(li->li_instance_set, inst_obj)) {

              /* BUSY flag is cleared at the end of import_main (join thread);

                 it should not cleared in this thread [610347] */

              if (instance_set_busy(inst) != 0) {

                                "ldbm: '%s' is already in the middle of "

                                "another task and cannot be disturbed.\n",

                                inst->inst_name);

           * DN2RDN option (-r) is given, but subtree-rename is off.

           * Print an error and back off.

           */

                        "DN2RDN option (-r) is given, but %s is off in "

                        "dse.ldif.  Please change the value to on.\n",

                        CONFIG_ENTRYRDN_SWITCH);

                  need_upgrade = (rval & (DBVERSION_UPGRADE_3_4 | DBVERSION_UPGRADE_4_4));

              }

              if (!need_upgrade) {

                                "Index version is up-to-date\n");

                  return 0;

              }

          }

      } else {

          slapi_log_err(SLAPI_LOG_WARNING,

          return -1;

      }

                 since dblayer_close is called in upgradedb_core =>

                 bdb_back_ldif2db */

              if (0 != bdb_start(li, DBLAYER_IMPORT_MODE)) {

                                "Failed to init database\n");

                  goto fail1;

              }

          if (inst_dirp != inst_dir)

              slapi_ch_free_string(&inst_dirp);

          if (backup_rval < 0) {

                            "Failed to backup index files (instance %s).\n", inst_dirp);

              goto fail1;

          }

              rval = upgradedb_delete_indices_4cmd(inst, up_flags);

              if (rval) {

                  upgrade_rval += rval;

                                "Can't clean up indices in %s\n", inst->inst_dir_name);

                  continue; /* Need to make all backups; continue */

              }

              rval = dblayer_delete_indices(inst);

              if (rval) {

                  upgrade_rval += rval;

                                "Can't clean up indices in %s\n", inst->inst_dir_name);

                  continue; /* Need to make all backups; continue */

              }

          rval = upgradedb_core(pb, inst);

          if (rval) {

              upgrade_rval += rval;

                            "upgradedb: Failed to upgrade database %s\n",

                            inst->inst_name);

              if (run_from_cmdline) {

      /* close the database down again */

      if (run_from_cmdline) {

          if (0 != dblayer_close(li, DBLAYER_IMPORT_MODE)) {

                            "Failed to close database\n");

              goto fail1;

          }

       * We just want not to generate a guardian file...

       */

      if (0 != dblayer_close(li, DBLAYER_ARCHIVE_MODE))

                        "Failed to close database\n");

      /* restore from the backup, if possible */

              return -1;

          }

      } else {

                        " Online mode is not supported. "

                        "Shutdown the server and run the tool\n");

          goto bail;

      /* Find the instance that the ldif2db will be done on. */

      inst = ldbm_instance_find_by_name(li, instance_name);

      if (NULL == inst) {

                        "Unknown ldbm instance %s\n", instance_name);

          goto bail;

      }

                    "%s: Start upgrade dn format.\n", inst->inst_name);

      slapi_pblock_set(pb, SLAPI_BACKEND, inst->inst_be);

      prst = PR_GetFileInfo64(rawworkdbdir, &prfinfo);

      if (PR_FAILURE == prst || PR_FILE_DIRECTORY != prfinfo.type) {

                        "Working DB instance dir %s is not a directory\n",

                        rawworkdbdir);

          goto bail;

      }

      dirhandle = PR_OpenDir(rawworkdbdir);

      if (!dirhandle) {

                        "Failed to open working DB instance dir %s\n",

                        rawworkdbdir);

          goto bail;

      PR_CloseDir(dirhandle);

      if (!found) {

                        "Working DB instance dir %s does not include %s file\n",

                        rawworkdbdir, ID2ENTRY);

          goto bail;

                  rc = 3; /* 0: need upgrade (dn norm sp, only) */

              } else {

                  /* DN format already takes care of the multiple spaces */

                                "Instance %s in %s is up-to-date\n",

                                instance_name, workdbdir);

                  rc = 0; /* 0: up-to-date */

              rc = 1; /* 0: need upgrade (both) */

          }

      } else {

                        "Failed to get DBVERSION (Instance name: %s, dir %s)\n",

                        instance_name, workdbdir);

          rc = -1; /* error */

      sep = PL_strrchr(workdbdir, '/');

      if (!sep) {

                        "Working DB instance dir %s does not include %s file\n",

                        workdbdir, ID2ENTRY);

          goto bail;

      if (run_from_cmdline) {

          if (0 != bdb_start(li, DBLAYER_IMPORT_MODE)) {

                            "Failed to init database\n");

              goto bail;

          }

      /* bdb_instance_start will init the id2entry index. */

      be = inst->inst_be;

      if (0 != bdb_instance_start(be, DBLAYER_IMPORT_MODE)) {

                        "Failed to init instance %s\n", inst->inst_name);

          goto bail;

      }

      /* close the database */

      if (run_from_cmdline) {

          if (0 != dblayer_close(li, DBLAYER_IMPORT_MODE)) {

                            "Failed to close database\n");

              goto bail;

          }

      /* Check the values are sane. */

      if ((autosize_percentage > 100) || (import_percentage > 100) || (autosize_db_percentage_split > 100) ||

          ((autosize_percentage > 0) && (import_percentage > 0) && (autosize_percentage + import_percentage > 100))) {

          return SLAPI_FAIL_GENERAL;

      }

      /* Get our platform memory values. */

      slapi_pal_meminfo *mi = spal_meminfo_get();

      if (mi == NULL) {

          return SLAPI_FAIL_GENERAL;

      }

      /* In the case it is not, this will *reduce* the allocation */

      issane = util_is_cachesize_sane(mi, &zone_size);

      if (issane == UTIL_CACHESIZE_REDUCED) {

      }

      /* It's valid, lets divide it up and set according to user prefs */

      db_size = (autosize_db_percentage_split * zone_size) / 100;

          }

      }

      /* We've now calculated the autotuning values. Do we need to apply it?

       * we use the logic of "if size is 0, or autosize is > 0. This way three

      /* First, check the dbcache */

      if (li->li_dbcachesize == 0 || li->li_cache_autosize > 0) {

          if (db_size < (500 * MEGABYTE)) {

              db_size = db_size / 1.25;

          }

           * it's highly unlikely.

           */

          if (cache_size == 0 || cache_size == MINCACHESIZE || li->li_cache_autosize > 0) {

              cache_set_max_entries(&(inst->inst_cache), -1);

              cache_set_max_size(&(inst->inst_cache), li->li_cache_autosize_ec, CACHE_TYPE_ENTRY);

          }

          if (dncache_size == 0 || dncache_size == MINCACHESIZE || li->li_cache_autosize > 0) {

              cache_set_max_entries(&(inst->inst_dncache), -1);

              cache_set_max_size(&(inst->inst_dncache), li->li_dncache_autosize_ec, CACHE_TYPE_DN);

          }

          cache_size = (PRUint64)cache_get_max_size(&(inst->inst_cache));

          db_size = bdb_get_id2entry_size(inst);

          if (cache_size < db_size) {

                            "%s: entry cache size %" PRIu64 " B is "

                            "less than db size %" PRIu64 " B; "

                            "We recommend to increase the entry cache size "

          import_size = (import_percentage * mi->system_total_bytes) / 100;

          issane = util_is_cachesize_sane(mi, &import_size);

          if (issane == UTIL_CACHESIZE_REDUCED) {

          }

          /* We just accept the reduced allocation here. */

          sprintf(size_to_str, "%" PRIu64, import_size);

          ldbm_config_internal_set(li, CONFIG_IMPORT_CACHESIZE, size_to_str);

      }

      /* Finally, lets check that the total result is sane. */

      issane = util_is_cachesize_sane(mi, &total_cache_size);

      if (issane != UTIL_CACHESIZE_VALID) {

          /* Right, it's time to panic */

                        total_cache_size, (uint64_t)li->li_dbcachesize, mi->system_available_bytes);

          /* WB 2016 - This should be UNCOMMENTED in a future release */

          /* return SLAPI_FAIL_GENERAL; */

      }

      char **instance_names = NULL;

      char *dbdir = NULL;

      slapi_pblock_get(pb, SLAPI_BACKEND_INSTANCE_NAME, &instance_names);

      slapi_pblock_get(pb, SLAPI_SEQ_TYPE, &verbose);

      slapi_pblock_get(pb, SLAPI_PLUGIN_PRIVATE, &li);

      /* no write needed; choose EXPORT MODE */

      if (0 != bdb_start(li, DBLAYER_EXPORT_MODE)) {

          return rval;

      }

      /* server is up */

      if (instance_names) /* instance is specified */

      {

          char **inp = NULL;

              /* check if an import/restore is already ongoing... */

              if (instance_set_busy(inst) != 0) {

                  /* standalone, only.  never happens */

                                "Backend '%s' is already in the middle of "

                                "another task and cannot be disturbed.\n",

                                inst->inst_name);

      /* close the database down again */

      rval = bdb_post_close(li, DBLAYER_EXPORT_MODE);

      if (0 != rval) {

      }

      return rval_main;

  static Slapi_PluginDesc pdesc = {"ldbm-backend", VENDOR,

                                   DS_PACKAGE_VERSION, "high-performance LDAP backend database plugin"};

  int

  ldbm_back_init(Slapi_PBlock *pb)

  {

          goto fail;

      }

      /* set plugin private pointer and initialize locks, etc. */

      rc = slapi_pblock_set(pb, SLAPI_PLUGIN_PRIVATE, (void *)li);

                             (void *)dblayer_plugin_commit);

      rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_DB_ABORT_FN,

                             (void *)dblayer_plugin_abort);

      rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_DB_WIRE_IMPORT_FN,

                             (void *)ldbm_back_wire_import);

      rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_DB_GET_INFO_FN,

                             (void *)ldbm_back_get_info);

      rc |= slapi_pblock_set(pb, SLAPI_PLUGIN_DB_SET_INFO_FN,

      }

      dblayer_private *priv = (dblayer_private *)li->li_dblayer_private;

  }

  #define LOG "log."

      slapi_pblock_get(pb, SLAPI_PLUGIN_PRIVATE, &li);

      dblayer_private *priv = (dblayer_private *)li->li_dblayer_private;

  }

      case SLAPI_PLUGIN_DB_PREV_SEARCH_RESULTS_FN:

          *ret_fnptr = be->be_prev_search_results;

          break;

      case SLAPI_PLUGIN_DB_TEST_FN:

          *ret_fnptr = (void *)be->be_dbtest;

          break;

      case SLAPI_PLUGIN_DB_RMDB_FN:

          *ret_fnptr = (void *)be->be_rmdb;

          break;

      case SLAPI_PLUGIN_DB_SEQ_FN:

          *ret_fnptr = (void *)be->be_seq;

          break;

      case SLAPI_PLUGIN_DB_PREV_SEARCH_RESULTS_FN:

          be->be_prev_search_results = (VFP)ret_fnptr;

          break;

      case SLAPI_PLUGIN_DB_TEST_FN:

          be->be_dbtest = (IFP)ret_fnptr;

          break;

      case SLAPI_PLUGIN_DB_RMDB_FN:

          be->be_rmdb = (IFP)ret_fnptr;

          break;

      case SLAPI_PLUGIN_DB_SEQ_FN:

          be->be_seq = (IFP)ret_fnptr;

          break;

      case SLAPI_PLUGIN_DB_WIRE_IMPORT_FN:

          (*(IFP *)value) = pblock->pb_plugin->plg_wire_import;

          break;

      case SLAPI_PLUGIN_DB_GET_INFO_FN:

          (*(IFP *)value) = pblock->pb_plugin->plg_get_info;

          break;

          }

          (*(IFP *)value) = pblock->pb_plugin->plg_rmdb;

          break;

      case SLAPI_PLUGIN_DB_LDIF2DB_FN:

          if (pblock->pb_plugin->plg_type != SLAPI_PLUGIN_DATABASE) {

              return (-1);

          }

          (*(IFP *)value) = pblock->pb_plugin->plg_un.plg_un_db.plg_un_db_abort;

          break;

      case SLAPI_PLUGIN_DB_TEST_FN:

          if (pblock->pb_plugin->plg_type != SLAPI_PLUGIN_DATABASE) {

              return (-1);

      case SLAPI_PLUGIN_DB_WIRE_IMPORT_FN:

          pblock->pb_plugin->plg_wire_import = (IFP)value;

          break;

      case SLAPI_PLUGIN_DB_GET_INFO_FN:

          pblock->pb_plugin->plg_get_info = (IFP)value;

          break;

          }

          pblock->pb_plugin->plg_rmdb = (IFP)value;

          break;

      case SLAPI_PLUGIN_DB_LDIF2DB_FN:

          if (pblock->pb_plugin->plg_type != SLAPI_PLUGIN_DATABASE) {

              return (-1);

          }

          pblock->pb_plugin->plg_un.plg_un_db.plg_un_db_abort = (IFP)value;

          break;

      case SLAPI_PLUGIN_DB_TEST_FN:

          if (pblock->pb_plugin->plg_type != SLAPI_PLUGIN_DATABASE) {

              return (-1);

          /* borrow the task flag space */

          slapi_pblock_set(pb, SLAPI_SCHEMA_FLAGS, (void *)&schema_flags);

             checking during initialization; this will be overridden when

             its "real" definition is read from the schema conf files */

                  be = be_new_internal(*local_pschemadse, "DSE", DSE_SCHEMA, &schema_plugin);

                  be_addsuffix(be, &schema);

              } else { /* schema file reload */

                  be_replace_dse_internal(be, *local_pschemadse);

              }

          }

      }

  #define SLAPI_PLUGIN_DB_DB2ARCHIVE_FN             223

  #define SLAPI_PLUGIN_DB_NEXT_SEARCH_ENTRY_FN      224

  #define SLAPI_PLUGIN_DB_FREE_RESULT_SET_FN        225

  #define SLAPI_PLUGIN_DB_TEST_FN                   227

  #define SLAPI_PLUGIN_DB_DB2INDEX_FN               228

  #define SLAPI_PLUGIN_DB_NEXT_SEARCH_ENTRY_EXT_FN  229

  #define SLAPI_PLUGIN_DB_ENTRY_RELEASE_FN          230

  #define SLAPI_PLUGIN_DB_WIRE_IMPORT_FN            234

  #define SLAPI_PLUGIN_DB_UPGRADEDB_FN              235

  #define SLAPI_PLUGIN_DB_DBVERIFY_FN               236

  #define SLAPI_PLUGIN_DB_SEARCH_RESULTS_RELEASE_FN 238

  #define SLAPI_PLUGIN_DB_PREV_SEARCH_RESULTS_FN    239

  #define SLAPI_PLUGIN_DB_UPGRADEDNFORMAT_FN        240